openblox/dist/utils/utils.js

Roblox API Wrapper For Both Classic And OpenCloud APIs.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var utils_exports = {};
__export(utils_exports, {
  cloneAndMutateObject: () => cloneAndMutateObject,
  createObjectMapByKeyWithMiddleware: () => createObjectMapByKeyWithMiddleware,
  dataIsSuccess: () => dataIsSuccess,
  formDataBuilder: () => formDataBuilder,
  isArrayOrObj: () => isArrayOrObj,
  isObject: () => isObject,
  mergeDeep: () => mergeDeep,
  objectToFieldMask: () => objectToFieldMask,
  removeNullUndefined: () => removeNullUndefined,
  toCamel: () => toCamel,
  toPascal: () => toPascal
});
module.exports = __toCommonJS(utils_exports);
var import_lodash = require("lodash");
const cloneAndMutateObject = (obj = {}, mutateFn) => {
  const clone = (0, import_lodash.cloneDeep)(obj);
  mutateFn(clone);
  return clone;
};
const dataIsSuccess = (data) => {
  if (typeof data === "object" && !Array.isArray(data) && data !== null) {
    return !Object.keys(data).length;
  }
  return false;
};
const createObjectMapByKeyWithMiddleware = (arrayOfObjects, keyName, middlewareFn) => {
  const objMap = {};
  arrayOfObjects.forEach((item) => objMap[item[keyName]] = middlewareFn ? middlewareFn(item) : item);
  return objMap;
};
const removeNullUndefined = (obj) => Object.entries(obj).reduce((a, [k, v]) => v == null ? a : (a[k] = v, a), {});
const isObject = (maybeObject) => maybeObject?.constructor === Object;
function mergeDeep(target, ...sources) {
  if (!sources.length) return target;
  const source = sources.shift();
  if (isObject(target) && isObject(source)) {
    for (const key in source) {
      if (isObject(source[key])) {
        if (!target[key]) Object.assign(target, { [key]: {} });
        mergeDeep(target[key], source[key]);
      } else {
        Object.assign(target, { [key]: source[key] });
      }
    }
  }
  return mergeDeep(target, ...sources);
}
const objectToFieldMask = (o) => {
  if (!o || typeof o !== "object") return [];
  const paths = [];
  const stack = [{ obj: o, path: [] }];
  while (stack.length > 0) {
    const { obj, path } = stack.pop();
    if (typeof obj === "object" && obj !== null) {
      let isEmpty = true;
      for (const key in obj) {
        isEmpty = false;
        stack.push({ obj: obj[key], path: [...path, key] });
      }
      if (isEmpty) {
        paths.push(path);
      }
    } else {
      paths.push(path);
    }
  }
  return paths.map((path) => path.join(".")).join(",");
};
const toCamel = (o) => {
  var newO, origKey, newKey, value;
  if (o instanceof Array) {
    return o.map(function(value2) {
      if (typeof value2 === "object") {
        value2 = toCamel(value2);
      }
      return value2;
    });
  } else {
    newO = {};
    for (origKey in o) {
      if (o.hasOwnProperty(origKey)) {
        newKey = (origKey.charAt(0).toLowerCase() + origKey.slice(1) || origKey).toString();
        value = o[origKey];
        if (value instanceof Array || value !== null && value.constructor === Object) {
          value = toCamel(value);
        }
        newO[newKey] = value;
      }
    }
  }
  return newO;
};
const toPascal = (obj) => {
  return Object.keys(obj).reduce(
    (result, key) => ({
      ...result,
      [key.charAt(0).toUpperCase() + key.slice(1)]: obj[key]
    }),
    {}
  );
};
const isArrayOrObj = (x) => isObject(x) || Array.isArray(x);
const formDataBuilder = () => {
  const formData = new FormData();
  const oldAppend = formData.append.bind(formData);
  const append = (name, value) => {
    if (!value) return formData;
    oldAppend(name, value);
    return formData;
  };
  formData.append = append;
  return formData;
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  cloneAndMutateObject,
  createObjectMapByKeyWithMiddleware,
  dataIsSuccess,
  formDataBuilder,
  isArrayOrObj,
  isObject,
  mergeDeep,
  objectToFieldMask,
  removeNullUndefined,
  toCamel,
  toPascal
});