@splendidlabz/utils 1.6.0 → 1.8.1

package/dist/cjs/lib/objects/index.cjs

@@ -0,0 +1,378 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/objects/index.js
+var objects_exports = {};
+__export(objects_exports, {
+  camelCaseKeys: () => camelCaseKeys,
+  concatMix: () => concatMix,
+  createMix: () => createMix,
+  extendObject: () => extendObject,
+  flattenObject: () => flattenObject,
+  getNestedProperty: () => getNestedProperty,
+  getNestedProperty2: () => getNestedProperty2,
+  getNestedValue: () => getNestedValue,
+  isEmpty: () => isEmpty,
+  isEqual: () => isEqual,
+  mix: () => mix,
+  normalizeObject: () => normalizeObject,
+  notEmpty: () => notEmpty,
+  notEqual: () => notEqual,
+  objectForEach: () => objectForEach,
+  objectMap: () => objectMap,
+  omitEmpty: () => omitEmpty,
+  parseJSON: () => parseJSON,
+  sizeOf: () => sizeOf,
+  splitObject: () => splitObject
+});
+module.exports = __toCommonJS(objects_exports);
+
+// src/lib/objects/loop.js
+function objectForEach(object, callback) {
+  Object.entries(object).forEach(([key, value]) => {
+    callback({ key, value });
+  });
+}
+function objectMap(object, callback) {
+  return Object.entries(object).map(([key, value]) => {
+    return callback({ key, value });
+  });
+}
+
+// src/lib/strings/convert-case/convert-case.js
+function toKebab(string) {
+  if (!string) return "";
+  return string.split("").map((letter, index) => {
+    const previousLetter = string[index - 1] || "";
+    const currentLetter = letter;
+    if (isDigit(currentLetter) && !isDigit(previousLetter)) {
+      return `-${currentLetter}`;
+    }
+    if (!isCaps(currentLetter)) return currentLetter;
+    if (previousLetter === "") {
+      return `${currentLetter.toLowerCase()}`;
+    }
+    if (isCaps(previousLetter)) {
+      return `${currentLetter.toLowerCase()}`;
+    }
+    return `-${currentLetter.toLowerCase()}`;
+  }).join("").trim().replace(/[-_\s]+/g, "-");
+}
+function toCamel(string) {
+  return toKebab(string).split("-").map((word, index) => {
+    if (index === 0) return word;
+    return word.slice(0, 1).toUpperCase() + word.slice(1).toLowerCase();
+  }).join("");
+}
+function isCaps(char) {
+  return /\p{Lu}/u.test(char);
+}
+function isDigit(char) {
+  return /[0-9]/.test(char);
+}
+
+// src/lib/objects/camelcase-keys.js
+function camelCaseKeys(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  const result = {};
+  objectForEach(obj, ({ key, value }) => {
+    const camelCaseKey = toCamel(key);
+    result[camelCaseKey] = camelCaseKeys(value);
+  });
+  return result;
+}
+
+// src/lib/objects/empty.js
+function isEmpty(obj) {
+  if (typeof obj === "undefined") return true;
+  if (obj === null) return true;
+  if (Array.isArray(obj)) return obj.length === 0;
+  return Object.keys(obj).length === 0;
+}
+function notEmpty(obj) {
+  return !isEmpty(obj);
+}
+
+// src/lib/objects/equal.js
+var import_deep_eql = __toESM(require("deep-eql"), 1);
+function isEqual(a, b) {
+  return (0, import_deep_eql.default)(a, b);
+}
+function notEqual(a, b) {
+  return !isEqual(a, b);
+}
+
+// src/lib/functions/functional.js
+function curry(fn) {
+  return function curried(...args) {
+    if (args.length >= fn.length) {
+      return fn.apply(this, args);
+    } else {
+      return function(...moreArgs) {
+        return curried.apply(this, args.concat(moreArgs));
+      };
+    }
+  };
+}
+function pipe(...fns) {
+  return function(value) {
+    return fns.reduce((acc, fn) => fn(acc), value);
+  };
+}
+
+// src/lib/objects/mix/mix.js
+var DEFAULT_OPTIONS = { array: "replace" };
+var mix = createMix();
+var concatMix = createMix({ array: "concat" });
+function createMix(userOptions = {}) {
+  const options = { ...DEFAULT_OPTIONS, ...userOptions };
+  function _mix(...sources) {
+    const result = {};
+    for (const source of sources) {
+      if (source == null) continue;
+      merge(result, source, options);
+    }
+    return result;
+  }
+  return _mix;
+}
+function merge(output, input, options) {
+  const props = Object.keys(input);
+  for (const prop of props) {
+    if (prop === "__proto__") continue;
+    const descriptor = Object.getOwnPropertyDescriptor(input, prop);
+    const value = descriptor.value;
+    if (value) descriptor.value = cloneDescriptorValue(value);
+    if (!output[prop]) {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (typeof output[prop] !== "object") {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (descriptor.value == null || typeof descriptor.value !== "object") {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (objectType(descriptor.value) === "[object Array]") {
+      output[prop] = options.array === "replace" ? descriptor.value.slice() : output[prop].concat(descriptor.value);
+      continue;
+    }
+    merge(output[prop], descriptor.value, options);
+  }
+}
+function cloneDescriptorValue(value) {
+  if (objectType(value) === "[object Array]") {
+    const array = [];
+    for (let v of value) {
+      v = cloneDescriptorValue(v);
+      array.push(v);
+    }
+    return array;
+  }
+  if (objectType(value) === "[object Object]") {
+    const obj = {};
+    const props = Object.keys(value);
+    for (const prop of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, prop);
+      if (descriptor.value)
+        descriptor.value = cloneDescriptorValue(descriptor.value);
+      Object.defineProperty(obj, prop, descriptor);
+    }
+    return obj;
+  }
+  if (objectType(value) === "[object Date]") {
+    return new Date(value.getTime());
+  }
+  if (objectType(value) === "[object Map]") {
+    const map = /* @__PURE__ */ new Map();
+    for (const entry of value) {
+      map.set(entry[0], cloneDescriptorValue(entry[1]));
+    }
+    return map;
+  }
+  if (objectType(value) === "[object Set]") {
+    const set = /* @__PURE__ */ new Set();
+    for (const entry of value.entries()) {
+      set.add(cloneDescriptorValue(entry[0]));
+    }
+    return set;
+  }
+  return value;
+}
+function objectType(value) {
+  return Object.prototype.toString.call(value);
+}
+
+// src/lib/objects/extend.js
+function extendObject(object) {
+  const orig = object;
+  const extended = mix({}, object);
+  extended.forEach = curry(objectForEach)(orig);
+  extended.map = curry(objectMap)(orig);
+  return { orig, extended };
+}
+
+// src/lib/checks.js
+function isObject(x) {
+  return typeof x === "object" && !Array.isArray(x) && x !== null;
+}
+
+// src/lib/objects/flatten.js
+function flattenObject(obj, { separator, prefix = "" }) {
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    const newKey = prefix ? `${prefix}${separator}${key}` : key;
+    const isAnObject = isObject(value);
+    const hasNestedObject = isAnObject && Object.values(value).some(isObject);
+    if (hasNestedObject) {
+      Object.assign(acc, flattenObject(value, { separator, prefix: newKey }));
+    } else {
+      acc[newKey] = value;
+    }
+    return acc;
+  }, {});
+}
+
+// src/lib/objects/json.js
+function parseJSON(value, defaultValue = {}) {
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return defaultValue;
+  }
+}
+
+// src/lib/objects/nested-property.js
+function getNestedProperty(object, pathArr) {
+  return pathArr.reduce(
+    (nestedObject, key) => nestedObject && nestedObject[key] !== "undefined" ? nestedObject[key] : void 0,
+    object
+  );
+}
+function getNestedProperty2(object, path) {
+  const pathArray = path.split(".");
+  return getNestedProperty(object, pathArray);
+}
+function getNestedValue(object, path) {
+  return path.split(".").reduce((acc, part) => acc?.[part], object);
+}
+
+// src/lib/objects/omit-empty.js
+function omitEmpty(obj, shallow = false) {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (obj instanceof Date) return obj;
+  const result = Array.isArray(obj) ? [] : {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === null || value === void 0 || value === "" || typeof value === "object" && !(value instanceof Date) && Object.keys(value).length === 0) {
+      continue;
+    }
+    result[key] = shallow ? value : omitEmpty(value);
+  }
+  return result;
+}
+
+// src/lib/objects/normalize-object.js
+function normalizeObject(object) {
+  return pipe(omitEmpty, camelCaseKeys)(object);
+}
+
+// src/lib/objects/size.js
+function sizeOf(obj) {
+  let bytes = 0;
+  function size(obj2) {
+    if (obj2 !== null && obj2 !== void 0) {
+      switch (typeof obj2) {
+        case "number":
+          bytes += 8;
+          break;
+        case "string":
+          bytes += obj2.length * 2;
+          break;
+        case "boolean":
+          bytes += 4;
+          break;
+        case "object":
+          const objClass = Object.prototype.toString.call(obj2).slice(8, -1);
+          if (objClass === "Object" || objClass === "Array") {
+            for (const key in obj2) {
+              if (!obj2.hasOwnProperty(key)) continue;
+              size(obj2[key]);
+            }
+          } else bytes += obj2.toString().length * 2;
+          break;
+      }
+    }
+    return bytes;
+  }
+  function formatByteSize(bytes2) {
+    if (bytes2 < 1024) return bytes2 + " bytes";
+    else if (bytes2 < 1048576) return (bytes2 / 1024).toFixed(3) + " KiB";
+    else if (bytes2 < 1073741824) return (bytes2 / 1048576).toFixed(3) + " MiB";
+    else return (bytes2 / 1073741824).toFixed(3) + " GiB";
+  }
+  return formatByteSize(size(obj));
+}
+
+// src/lib/objects/split.js
+function splitObject(obj, keys) {
+  const picked = {};
+  const omitted = { ...obj };
+  keys.forEach((key) => {
+    if (key in obj) {
+      picked[key] = obj[key];
+      delete omitted[key];
+    }
+  });
+  return { picked, omitted, p: picked, o: omitted };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  camelCaseKeys,
+  concatMix,
+  createMix,
+  extendObject,
+  flattenObject,
+  getNestedProperty,
+  getNestedProperty2,
+  getNestedValue,
+  isEmpty,
+  isEqual,
+  mix,
+  normalizeObject,
+  notEmpty,
+  notEqual,
+  objectForEach,
+  objectMap,
+  omitEmpty,
+  parseJSON,
+  sizeOf,
+  splitObject
+});

package/dist/cjs/lib/objects/json.cjs

@@ -0,0 +1,35 @@
+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);
+
+// src/lib/objects/json.js
+var json_exports = {};
+__export(json_exports, {
+  parseJSON: () => parseJSON
+});
+module.exports = __toCommonJS(json_exports);
+function parseJSON(value, defaultValue = {}) {
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return defaultValue;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseJSON
+});

package/dist/cjs/lib/objects/loop.cjs

@@ -0,0 +1,40 @@
+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);
+
+// src/lib/objects/loop.js
+var loop_exports = {};
+__export(loop_exports, {
+  objectForEach: () => objectForEach,
+  objectMap: () => objectMap
+});
+module.exports = __toCommonJS(loop_exports);
+function objectForEach(object, callback) {
+  Object.entries(object).forEach(([key, value]) => {
+    callback({ key, value });
+  });
+}
+function objectMap(object, callback) {
+  return Object.entries(object).map(([key, value]) => {
+    return callback({ key, value });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  objectForEach,
+  objectMap
+});

package/dist/cjs/lib/objects/mix/mix.cjs

@@ -0,0 +1,115 @@
+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);
+
+// src/lib/objects/mix/mix.js
+var mix_exports = {};
+__export(mix_exports, {
+  concatMix: () => concatMix,
+  createMix: () => createMix,
+  mix: () => mix
+});
+module.exports = __toCommonJS(mix_exports);
+var DEFAULT_OPTIONS = { array: "replace" };
+var mix = createMix();
+var concatMix = createMix({ array: "concat" });
+function createMix(userOptions = {}) {
+  const options = { ...DEFAULT_OPTIONS, ...userOptions };
+  function _mix(...sources) {
+    const result = {};
+    for (const source of sources) {
+      if (source == null) continue;
+      merge(result, source, options);
+    }
+    return result;
+  }
+  return _mix;
+}
+function merge(output, input, options) {
+  const props = Object.keys(input);
+  for (const prop of props) {
+    if (prop === "__proto__") continue;
+    const descriptor = Object.getOwnPropertyDescriptor(input, prop);
+    const value = descriptor.value;
+    if (value) descriptor.value = cloneDescriptorValue(value);
+    if (!output[prop]) {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (typeof output[prop] !== "object") {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (descriptor.value == null || typeof descriptor.value !== "object") {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (objectType(descriptor.value) === "[object Array]") {
+      output[prop] = options.array === "replace" ? descriptor.value.slice() : output[prop].concat(descriptor.value);
+      continue;
+    }
+    merge(output[prop], descriptor.value, options);
+  }
+}
+function cloneDescriptorValue(value) {
+  if (objectType(value) === "[object Array]") {
+    const array = [];
+    for (let v of value) {
+      v = cloneDescriptorValue(v);
+      array.push(v);
+    }
+    return array;
+  }
+  if (objectType(value) === "[object Object]") {
+    const obj = {};
+    const props = Object.keys(value);
+    for (const prop of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, prop);
+      if (descriptor.value)
+        descriptor.value = cloneDescriptorValue(descriptor.value);
+      Object.defineProperty(obj, prop, descriptor);
+    }
+    return obj;
+  }
+  if (objectType(value) === "[object Date]") {
+    return new Date(value.getTime());
+  }
+  if (objectType(value) === "[object Map]") {
+    const map = /* @__PURE__ */ new Map();
+    for (const entry of value) {
+      map.set(entry[0], cloneDescriptorValue(entry[1]));
+    }
+    return map;
+  }
+  if (objectType(value) === "[object Set]") {
+    const set = /* @__PURE__ */ new Set();
+    for (const entry of value.entries()) {
+      set.add(cloneDescriptorValue(entry[0]));
+    }
+    return set;
+  }
+  return value;
+}
+function objectType(value) {
+  return Object.prototype.toString.call(value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  concatMix,
+  createMix,
+  mix
+});

package/dist/cjs/lib/objects/nested-property.cjs

@@ -0,0 +1,45 @@
+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);
+
+// src/lib/objects/nested-property.js
+var nested_property_exports = {};
+__export(nested_property_exports, {
+  getNestedProperty: () => getNestedProperty,
+  getNestedProperty2: () => getNestedProperty2,
+  getNestedValue: () => getNestedValue
+});
+module.exports = __toCommonJS(nested_property_exports);
+function getNestedProperty(object, pathArr) {
+  return pathArr.reduce(
+    (nestedObject, key) => nestedObject && nestedObject[key] !== "undefined" ? nestedObject[key] : void 0,
+    object
+  );
+}
+function getNestedProperty2(object, path) {
+  const pathArray = path.split(".");
+  return getNestedProperty(object, pathArray);
+}
+function getNestedValue(object, path) {
+  return path.split(".").reduce((acc, part) => acc?.[part], object);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNestedProperty,
+  getNestedProperty2,
+  getNestedValue
+});