@domql/utils 2.5.156 → 2.5.159

package/dist/esm/object.js

@@ -0,0 +1,687 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { window } from "./globals.js";
+import {
+  isFunction,
+  isObjectLike,
+  isObject,
+  isArray,
+  isString,
+  is,
+  isUndefined,
+  isDate,
+  isNull
+} from "./types.js";
+import { mergeAndCloneIfArray, mergeArray } from "./array.js";
+import { stringIncludesAny } from "./string.js";
+import { isDOMNode } from "./node.js";
+const ENV = "development";
+const exec = (param, element, state, context) => {
+  if (isFunction(param)) {
+    return param.call(
+      element,
+      element,
+      state || element.state,
+      context || element.context
+    );
+  }
+  return param;
+};
+const map = (obj, extention, element) => {
+  for (const e in extention) {
+    obj[e] = exec(extention[e], element);
+  }
+};
+const merge = (element, obj, excludeFrom = []) => {
+  for (const e in obj) {
+    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, e);
+    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__"))
+      continue;
+    const elementProp = element[e];
+    const objProp = obj[e];
+    if (elementProp === void 0) {
+      element[e] = objProp;
+    }
+  }
+  return element;
+};
+const deepMerge = (element, extend, excludeFrom = []) => {
+  for (const e in extend) {
+    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(extend, e);
+    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__"))
+      continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (isObjectLike(elementProp) && isObjectLike(extendProp)) {
+      deepMerge(elementProp, extendProp, excludeFrom);
+    } else if (elementProp === void 0) {
+      element[e] = extendProp;
+    }
+  }
+  return element;
+};
+const clone = (obj, excludeFrom = []) => {
+  const o = {};
+  for (const prop in obj) {
+    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, prop);
+    if (!hasOwnProperty2 || excludeFrom.includes(prop) || prop.startsWith("__"))
+      continue;
+    o[prop] = obj[prop];
+  }
+  return o;
+};
+const deepCloneExclude = (obj, excludeFrom = []) => {
+  if (isArray(obj)) {
+    return obj.map((x) => deepCloneExclude(x, excludeFrom));
+  }
+  const o = {};
+  for (const k in obj) {
+    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, k);
+    if (!hasOwnProperty2 || excludeFrom.includes(k) || k.startsWith("__"))
+      continue;
+    let v = obj[k];
+    if (k === "extend" && isArray(v)) {
+      v = mergeArrayExclude(v, excludeFrom);
+    }
+    if (isArray(v)) {
+      o[k] = v.map((x) => deepCloneExclude(x, excludeFrom));
+    } else if (isObject(v)) {
+      o[k] = deepCloneExclude(v, excludeFrom);
+    } else
+      o[k] = v;
+  }
+  return o;
+};
+const mergeArrayExclude = (arr, excl = []) => {
+  return arr.reduce((acc, curr) => deepMerge(acc, deepCloneExclude(curr, excl)), {});
+};
+const deepClone = (obj, exclude = [], cleanUndefined = false, visited = /* @__PURE__ */ new WeakMap()) => {
+  if (!isObjectLike(obj) || isDOMNode(obj))
+    return obj;
+  if (visited.has(obj))
+    return visited.get(obj);
+  const clone2 = isArray(obj) ? [] : {};
+  visited.set(obj, clone2);
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key) && !exclude.includes(key)) {
+      const value = obj[key];
+      if (isDOMNode(value)) {
+        clone2[key] = value;
+      } else if (key === "extend" && isArray(value)) {
+        clone2[key] = mergeArray(value, exclude);
+      } else if (isObjectLike(value)) {
+        clone2[key] = deepClone(value, exclude, cleanUndefined, visited);
+      } else {
+        clone2[key] = value;
+      }
+    }
+  }
+  return clone2;
+};
+const deepCloneWithExtend = (obj, excludeFrom = ["node"], options = {}, visited = /* @__PURE__ */ new WeakSet()) => {
+  if (isObjectLike(obj)) {
+    if (visited.has(obj)) {
+      return obj;
+    }
+    visited.add(obj);
+  }
+  const o = options.window ? isArray(obj) ? new options.window.Array([]) : new options.window.Object({}) : isArray(obj) ? [] : {};
+  for (const prop in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, prop))
+      continue;
+    const objProp = obj[prop];
+    if (excludeFrom.includes(prop) || prop.startsWith("__") || options.cleanUndefined && isUndefined(objProp) || options.cleanNull && isNull(objProp)) {
+      continue;
+    }
+    if (isObjectLike(objProp)) {
+      o[prop] = deepCloneWithExtend(objProp, excludeFrom, options, visited);
+    } else if (isFunction(objProp) && options.window) {
+      o[prop] = (options.window || window).eval("(" + objProp.toString() + ")");
+    } else {
+      o[prop] = objProp;
+    }
+  }
+  return o;
+};
+const deepStringify = (obj, stringified = {}) => {
+  var _a, _b;
+  if (obj.node || obj.__ref || obj.parent || obj.__element || obj.parse) {
+    (obj.__element || ((_a = obj.parent) == null ? void 0 : _a.__element)).warn("Trying to clone element or state at", obj);
+    obj = (_b = obj.parse) == null ? void 0 : _b.call(obj);
+  }
+  for (const prop in obj) {
+    const objProp = obj[prop];
+    if (isFunction(objProp)) {
+      stringified[prop] = objProp.toString();
+    } else if (isObject(objProp)) {
+      stringified[prop] = {};
+      deepStringify(objProp, stringified[prop]);
+    } else if (isArray(objProp)) {
+      stringified[prop] = [];
+      objProp.forEach((v, i) => {
+        if (isObject(v)) {
+          stringified[prop][i] = {};
+          deepStringify(v, stringified[prop][i]);
+        } else if (isFunction(v)) {
+          stringified[prop][i] = v.toString();
+        } else {
+          stringified[prop][i] = v;
+        }
+      });
+    } else {
+      stringified[prop] = objProp;
+    }
+  }
+  return stringified;
+};
+const MAX_DEPTH = 100;
+const deepStringifyWithMaxDepth = (obj, stringified = {}, depth = 0, path = "") => {
+  if (depth > MAX_DEPTH) {
+    console.warn(`Maximum depth exceeded at path: ${path}. Possible circular reference.`);
+    return "[MAX_DEPTH_EXCEEDED]";
+  }
+  for (const prop in obj) {
+    const currentPath = path ? `${path}.${prop}` : prop;
+    const objProp = obj[prop];
+    if (isFunction(objProp)) {
+      stringified[prop] = objProp.toString();
+    } else if (isObject(objProp)) {
+      stringified[prop] = {};
+      deepStringifyWithMaxDepth(objProp, stringified[prop], depth + 1, currentPath);
+    } else if (isArray(objProp)) {
+      stringified[prop] = [];
+      objProp.forEach((v, i) => {
+        const itemPath = `${currentPath}[${i}]`;
+        if (isObject(v)) {
+          stringified[prop][i] = {};
+          deepStringifyWithMaxDepth(v, stringified[prop][i], depth + 1, itemPath);
+        } else if (isFunction(v)) {
+          stringified[prop][i] = v.toString();
+        } else {
+          stringified[prop][i] = v;
+        }
+      });
+    } else {
+      stringified[prop] = objProp;
+    }
+  }
+  return stringified;
+};
+const objectToString = (obj = {}, indent = 0) => {
+  const spaces = "  ".repeat(indent);
+  let str = "{\n";
+  for (const [key, value] of Object.entries(obj)) {
+    const keyNotAllowdChars = stringIncludesAny(key, ["&", "*", "-", ":", "%", "{", "}", ">", "<", "@", ".", "/", "!", " "]);
+    const stringedKey = keyNotAllowdChars ? `'${key}'` : key;
+    str += `${spaces}  ${stringedKey}: `;
+    if (isArray(value)) {
+      str += "[\n";
+      for (const element of value) {
+        if (isObjectLike(element) && element !== null) {
+          str += `${spaces}    ${objectToString(element, indent + 2)},
+`;
+        } else if (isString(element)) {
+          str += `${spaces}    '${element}',
+`;
+        } else {
+          str += `${spaces}    ${element},
+`;
+        }
+      }
+      str += `${spaces}  ]`;
+    } else if (isObjectLike(value)) {
+      str += objectToString(value, indent + 1);
+    } else if (isString(value)) {
+      str += stringIncludesAny(value, ["\n", "'"]) ? `\`${value}\`` : `'${value}'`;
+    } else {
+      str += value;
+    }
+    str += ",\n";
+  }
+  str += `${spaces}}`;
+  return str;
+};
+const detachFunctionsFromObject = (obj, detached = {}) => {
+  for (const prop in obj) {
+    const objProp = obj[prop];
+    if (isFunction(objProp))
+      continue;
+    else if (isObject(objProp)) {
+      detached[prop] = {};
+      deepStringify(objProp, detached[prop]);
+    } else if (isArray(objProp)) {
+      detached[prop] = [];
+      objProp.forEach((v, i) => {
+        if (isFunction(v))
+          return;
+        if (isObject(v)) {
+          detached[prop][i] = {};
+          detachFunctionsFromObject(v, detached[prop][i]);
+        } else {
+          detached[prop][i] = v;
+        }
+      });
+    } else {
+      detached[prop] = objProp;
+    }
+  }
+  return detached;
+};
+const deepDestringify = (obj, destringified = {}) => {
+  for (const prop in obj) {
+    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, prop);
+    if (!hasOwnProperty2)
+      continue;
+    const objProp = obj[prop];
+    if (isString(objProp)) {
+      if ((objProp.includes("(){") || objProp.includes("() {") || objProp.includes("=>") || objProp.startsWith("()") || objProp.startsWith("async") || objProp.startsWith("function") || objProp.startsWith("(")) && !objProp.startsWith("{") && !objProp.startsWith("[")) {
+        try {
+          const evalProp = window.eval(`(${objProp})`);
+          destringified[prop] = evalProp;
+        } catch (e) {
+          if (e)
+            destringified[prop] = objProp;
+        }
+      } else {
+        destringified[prop] = objProp;
+      }
+    } else if (isArray(objProp)) {
+      destringified[prop] = [];
+      objProp.forEach((arrProp) => {
+        if (isString(arrProp)) {
+          if (arrProp.includes("=>") || arrProp.includes("function") || arrProp.startsWith("(")) {
+            try {
+              const evalProp = window.eval(`(${arrProp})`);
+              destringified[prop].push(evalProp);
+            } catch (e) {
+              if (e)
+                destringified[prop].push(arrProp);
+            }
+          } else {
+            destringified[prop].push(arrProp);
+          }
+        } else if (isObject(arrProp)) {
+          destringified[prop].push(deepDestringify(arrProp));
+        } else {
+          destringified[prop].push(arrProp);
+        }
+      });
+    } else if (isObject(objProp)) {
+      destringified[prop] = deepDestringify(objProp, destringified[prop]);
+    } else {
+      destringified[prop] = objProp;
+    }
+  }
+  return destringified;
+};
+const stringToObject = (str, opts = { verbose: true }) => {
+  try {
+    return str ? window.eval("(" + str + ")") : {};
+  } catch (e) {
+    if (opts.verbose)
+      console.warn(e);
+  }
+};
+const diffObjects = (original, objToDiff, cache) => {
+  for (const e in objToDiff) {
+    if (e === "ref")
+      continue;
+    const originalProp = original[e];
+    const objToDiffProp = objToDiff[e];
+    if (isObject(originalProp) && isObject(objToDiffProp)) {
+      cache[e] = {};
+      diff(originalProp, objToDiffProp, cache[e]);
+    } else if (objToDiffProp !== void 0) {
+      cache[e] = objToDiffProp;
+    }
+  }
+  return cache;
+};
+const diffArrays = (original, objToDiff, cache) => {
+  if (original.length !== objToDiff.length) {
+    cache = objToDiff;
+  } else {
+    const diffArr = [];
+    for (let i = 0; i < original.length; i++) {
+      const diffObj = diff(original[i], objToDiff[i]);
+      if (Object.keys(diffObj).length > 0) {
+        diffArr.push(diffObj);
+      }
+    }
+    if (diffArr.length > 0) {
+      cache = diffArr;
+    }
+  }
+  return cache;
+};
+const diff = (original, objToDiff, cache = {}) => {
+  if (isArray(original) && isArray(objToDiff)) {
+    cache = [];
+    diffArrays(original, objToDiff, cache);
+  } else {
+    diffObjects(original, objToDiff, cache);
+  }
+  return cache;
+};
+const hasOwnProperty = (o, ...args) => Object.prototype.hasOwnProperty.call(o, ...args);
+const isEmpty = (o) => Object.keys(o).length === 0;
+const isEmptyObject = (o) => isObject(o) && isEmpty(o);
+const makeObjectWithoutPrototype = () => /* @__PURE__ */ Object.create(null);
+const deepDiff = (lhs, rhs) => {
+  if (lhs === rhs)
+    return {};
+  if (!isObjectLike(lhs) || !isObjectLike(rhs))
+    return rhs;
+  const deletedValues = Object.keys(lhs).reduce((acc, key) => {
+    if (!hasOwnProperty(rhs, key)) {
+      acc[key] = void 0;
+    }
+    return acc;
+  }, makeObjectWithoutPrototype());
+  if (isDate(lhs) || isDate(rhs)) {
+    if (lhs.valueOf() === rhs.valueOf())
+      return {};
+    return rhs;
+  }
+  return Object.keys(rhs).reduce((acc, key) => {
+    if (!hasOwnProperty(lhs, key)) {
+      acc[key] = rhs[key];
+      return acc;
+    }
+    const difference = diff(lhs[key], rhs[key]);
+    if (isEmptyObject(difference) && !isDate(difference) && (isEmptyObject(lhs[key]) || !isEmptyObject(rhs[key]))) {
+      return acc;
+    }
+    acc[key] = difference;
+    return acc;
+  }, deletedValues);
+};
+const overwrite = (element, params, opts = {}) => {
+  const { __ref: ref } = element;
+  const excl = opts.exclude || [];
+  const allowUnderscore = opts.preventUnderscore;
+  const preventCaching = opts.preventCaching;
+  for (const e in params) {
+    if (excl.includes(e) || !allowUnderscore && e.startsWith("__"))
+      continue;
+    const elementProp = element[e];
+    const paramsProp = params[e];
+    if (paramsProp !== void 0) {
+      element[e] = paramsProp;
+      if (ref && !preventCaching) {
+        ref.__cache[e] = elementProp;
+      }
+      if (isObject(opts.diff)) {
+        diff[e] = elementProp;
+      }
+    }
+  }
+  return element;
+};
+const overwriteShallow = (obj, params, excludeFrom = []) => {
+  for (const e in params) {
+    if (excludeFrom.includes(e) || e.startsWith("__"))
+      continue;
+    obj[e] = params[e];
+  }
+  return obj;
+};
+const overwriteDeep = (obj, params, opts = {}, visited = /* @__PURE__ */ new WeakMap()) => {
+  const excl = opts.exclude || [];
+  const forcedExclude = opts.preventForce ? [] : ["node", "window"];
+  if (!isObjectLike(obj) || !isObjectLike(params) || isDOMNode(obj) || isDOMNode(params)) {
+    return params;
+  }
+  if (visited.has(obj))
+    return visited.get(obj);
+  visited.set(obj, obj);
+  for (const e in params) {
+    if (!Object.hasOwnProperty.call(params, e))
+      continue;
+    if (excl.includes(e) || forcedExclude && e.startsWith("__"))
+      continue;
+    const objProp = obj[e];
+    const paramsProp = params[e];
+    if (isDOMNode(paramsProp)) {
+      obj[e] = paramsProp;
+    } else if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
+      obj[e] = overwriteDeep(objProp, paramsProp, opts, visited);
+    } else if (paramsProp !== void 0) {
+      obj[e] = paramsProp;
+    }
+  }
+  return obj;
+};
+const mergeIfExisted = (a, b) => {
+  if (isObjectLike(a) && isObjectLike(b))
+    return deepMerge(a, b);
+  return a || b;
+};
+const flattenRecursive = (param, prop, stack = []) => {
+  const objectized = mergeAndCloneIfArray(param);
+  stack.push(objectized);
+  const extendOfExtend = objectized[prop];
+  if (extendOfExtend)
+    flattenRecursive(extendOfExtend, prop, stack);
+  delete objectized[prop];
+  return stack;
+};
+const isEqualDeep = (param, element, visited = /* @__PURE__ */ new Set()) => {
+  if (typeof param !== "object" || typeof element !== "object" || param === null || element === null) {
+    return param === element;
+  }
+  if (visited.has(param) || visited.has(element)) {
+    return true;
+  }
+  visited.add(param);
+  visited.add(element);
+  const keysParam = Object.keys(param);
+  const keysElement = Object.keys(element);
+  if (keysParam.length !== keysElement.length) {
+    return false;
+  }
+  for (const key of keysParam) {
+    if (!keysElement.includes(key)) {
+      return false;
+    }
+    const paramProp = param[key];
+    const elementProp = element[key];
+    if (!isEqualDeep(paramProp, elementProp, visited)) {
+      return false;
+    }
+  }
+  return true;
+};
+const deepContains = (obj1, obj2, ignoredKeys = ["node", "__ref"]) => {
+  if (obj1 === obj2)
+    return true;
+  if (!isObjectLike(obj1) || !isObjectLike(obj2))
+    return false;
+  if (isDOMNode(obj1) || isDOMNode(obj2))
+    return obj1 === obj2;
+  const stack = [[obj1, obj2]];
+  const visited = /* @__PURE__ */ new WeakSet();
+  while (stack.length > 0) {
+    const [current1, current2] = stack.pop();
+    if (visited.has(current1))
+      continue;
+    visited.add(current1);
+    const keys1 = Object.keys(current1).filter((key) => !ignoredKeys.includes(key));
+    const keys2 = Object.keys(current2).filter((key) => !ignoredKeys.includes(key));
+    if (keys1.length !== keys2.length)
+      return false;
+    for (const key of keys1) {
+      if (!Object.prototype.hasOwnProperty.call(current2, key))
+        return false;
+      const value1 = current1[key];
+      const value2 = current2[key];
+      if (isDOMNode(value1) || isDOMNode(value2)) {
+        if (value1 !== value2)
+          return false;
+      } else if (isObjectLike(value1) && isObjectLike(value2)) {
+        if (value1 !== value2) {
+          stack.push([value1, value2]);
+        }
+      } else if (value1 !== value2) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+const removeFromObject = (obj, props) => {
+  if (props === void 0 || props === null)
+    return obj;
+  if (is(props)("string", "number")) {
+    delete obj[props];
+  } else if (isArray(props)) {
+    props.forEach((prop) => delete obj[prop]);
+  } else {
+    throw new Error("Invalid input: props must be a string or an array of strings");
+  }
+  return obj;
+};
+const createObjectWithoutPrototype = (obj) => {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  const newObj = /* @__PURE__ */ Object.create(null);
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      newObj[key] = createObjectWithoutPrototype(obj[key]);
+    }
+  }
+  return newObj;
+};
+const createNestedObject = (arr, lastValue) => {
+  const nestedObject = {};
+  if (arr.length === 0) {
+    return lastValue;
+  }
+  arr.reduce((obj, value, index) => {
+    if (!obj[value]) {
+      obj[value] = {};
+    }
+    if (index === arr.length - 1 && lastValue) {
+      obj[value] = lastValue;
+    }
+    return obj[value];
+  }, nestedObject);
+  return nestedObject;
+};
+const removeNestedKeyByPath = (obj, path) => {
+  if (!Array.isArray(path)) {
+    throw new Error("Path must be an array.");
+  }
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    if (current[path[i]] === void 0) {
+      return;
+    }
+    current = current[path[i]];
+  }
+  const lastKey = path[path.length - 1];
+  if (current && Object.hasOwnProperty.call(current, lastKey)) {
+    delete current[lastKey];
+  }
+};
+const detectInfiniteLoop = (arr) => {
+  const maxRepeats = 10;
+  let pattern = [];
+  let repeatCount = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (pattern.length < 2) {
+      pattern.push(arr[i]);
+    } else {
+      if (arr[i] === pattern[i % 2]) {
+        repeatCount++;
+      } else {
+        pattern = [arr[i - 1], arr[i]];
+        repeatCount = 1;
+      }
+      if (repeatCount >= maxRepeats * 2) {
+        if (ENV === "test" || ENV === "development") {
+          console.warn("Warning: Potential infinite loop detected due to repeated sequence:", pattern);
+        }
+        return true;
+      }
+    }
+  }
+};
+const isCyclic = (obj) => {
+  const seenObjects = [];
+  function detect(obj2) {
+    if (obj2 && typeof obj2 === "object") {
+      if (seenObjects.indexOf(obj2) !== -1) {
+        return true;
+      }
+      seenObjects.push(obj2);
+      for (const key in obj2) {
+        if (Object.hasOwnProperty.call(obj2, key) && detect(obj2[key])) {
+          console.log(obj2, "cycle at " + key);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  return detect(obj);
+};
+const excludeKeysFromObject = (obj, excludedKeys) => {
+  const result = __spreadValues({}, obj);
+  excludedKeys.forEach((key) => delete result[key]);
+  return result;
+};
+export {
+  clone,
+  createNestedObject,
+  createObjectWithoutPrototype,
+  deepClone,
+  deepCloneExclude,
+  deepCloneWithExtend,
+  deepContains,
+  deepDestringify,
+  deepDiff,
+  deepMerge,
+  deepStringify,
+  deepStringifyWithMaxDepth,
+  detachFunctionsFromObject,
+  detectInfiniteLoop,
+  diff,
+  diffArrays,
+  diffObjects,
+  excludeKeysFromObject,
+  exec,
+  flattenRecursive,
+  hasOwnProperty,
+  isCyclic,
+  isEmpty,
+  isEmptyObject,
+  isEqualDeep,
+  makeObjectWithoutPrototype,
+  map,
+  merge,
+  mergeArrayExclude,
+  mergeIfExisted,
+  objectToString,
+  overwrite,
+  overwriteDeep,
+  overwriteShallow,
+  removeFromObject,
+  removeNestedKeyByPath,
+  stringToObject
+};