@domql/utils 2.5.187 → 3.0.0

package/dist/esm/object.js

@@ -26,12 +26,12 @@ import {
   isString,
   is,
   isUndefined,
-  isDate,
   isNull
 } from "./types.js";
-import { mergeAndCloneIfArray, mergeArray } from "./array.js";
+import { unstackArrayOfObjects } from "./array.js";
 import { stringIncludesAny } from "./string.js";
 import { isDOMNode } from "./node.js";
+import { METHODS_EXL } from "./keys.js";
 const ENV = "development";
 const exec = (param, element, state, context) => {
   if (isFunction(param)) {
@@ -44,6 +44,17 @@ const exec = (param, element, state, context) => {
   }
   return param;
 };
+const execPromise = async (param, element, state, context) => {
+  if (isFunction(param)) {
+    return await 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);
@@ -52,8 +63,9 @@ const map = (obj, extention, 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("__"))
+    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__")) {
       continue;
+    }
     const elementProp = element[e];
     const objProp = obj[e];
     if (elementProp === void 0) {
@@ -62,11 +74,12 @@ const merge = (element, obj, excludeFrom = []) => {
   }
   return element;
 };
-const deepMerge = (element, extend, excludeFrom = []) => {
+const deepMerge = (element, extend, excludeFrom = METHODS_EXL) => {
   for (const e in extend) {
     const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(extend, e);
-    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__"))
+    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__")) {
       continue;
+    }
     const elementProp = element[e];
     const extendProp = extend[e];
     if (isObjectLike(elementProp) && isObjectLike(extendProp)) {
@@ -81,15 +94,13 @@ 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("__"))
+    if (!hasOwnProperty2 || excludeFrom.includes(prop) || prop.startsWith("__")) {
       continue;
+    }
     o[prop] = obj[prop];
   }
   return o;
 };
-const mergeArrayExclude = (arr, exclude = []) => {
-  return arr.reduce((acc, curr) => deepMerge(acc, deepClone(curr, { exclude })), {});
-};
 const deepClone = (obj, options = {}) => {
   const {
     exclude = [],
@@ -97,7 +108,7 @@ const deepClone = (obj, options = {}) => {
     cleanNull = false,
     window: targetWindow,
     visited = /* @__PURE__ */ new WeakMap(),
-    handleExtend = false
+    handleExtends = false
   } = options;
   if (!isObjectLike(obj) || isDOMNode(obj)) {
     return obj;
@@ -108,19 +119,20 @@ const deepClone = (obj, options = {}) => {
   const clone2 = targetWindow ? isArray(obj) ? new targetWindow.Array() : new targetWindow.Object() : isArray(obj) ? [] : {};
   visited.set(obj, clone2);
   for (const key in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, key))
-      continue;
-    if (exclude.includes(key) || key.startsWith("__") || key === "__proto__")
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    if (exclude.includes(key) || key.startsWith("__") || key === "__proto__") {
       continue;
+    }
     const value = obj[key];
-    if (cleanUndefined && isUndefined(value) || cleanNull && isNull(value))
+    if (cleanUndefined && isUndefined(value) || cleanNull && isNull(value)) {
       continue;
+    }
     if (isDOMNode(value)) {
       clone2[key] = value;
       continue;
     }
-    if (handleExtend && key === "extend" && isArray(value)) {
-      clone2[key] = mergeArray(value, exclude);
+    if (handleExtends && key === "extends" && isArray(value)) {
+      clone2[key] = unstackArrayOfObjects(value, exclude);
       continue;
     }
     if (isFunction(value) && targetWindow) {
@@ -140,7 +152,11 @@ const deepClone = (obj, options = {}) => {
 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.__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) {
@@ -168,39 +184,6 @@ const deepStringify = (obj, stringified = {}) => {
   }
   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) => {
   if (obj === null || typeof obj !== "object") {
     return String(obj);
@@ -211,7 +194,22 @@ 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 keyNotAllowdChars = stringIncludesAny(key, [
+      "&",
+      "*",
+      "-",
+      ":",
+      "%",
+      "{",
+      "}",
+      ">",
+      "<",
+      "@",
+      ".",
+      "/",
+      "!",
+      " "
+    ]);
     const stringedKey = keyNotAllowdChars ? `'${key}'` : key;
     str += `${spaces}  ${stringedKey}: `;
     if (isArray(value)) {
@@ -241,42 +239,12 @@ const objectToString = (obj = {}, indent = 0) => {
   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 hasFunction = (str) => {
-  if (!str)
-    return false;
+  if (!str) return false;
   const trimmed = str.trim().replace(/\n\s*/g, " ").trim();
-  if (trimmed === "")
-    return false;
-  if (trimmed === "{}")
-    return false;
-  if (trimmed === "[]")
-    return false;
+  if (trimmed === "") return false;
+  if (trimmed === "{}") return false;
+  if (trimmed === "[]") return false;
   const patterns = [
     /^\(\s*\{[^}]*\}\s*\)\s*=>/,
     /^(\([^)]*\)|[^=]*)\s*=>/,
@@ -294,8 +262,7 @@ const hasFunction = (str) => {
 const deepDestringify = (obj, destringified = {}) => {
   for (const prop in obj) {
     const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, prop);
-    if (!hasOwnProperty2)
-      continue;
+    if (!hasOwnProperty2) continue;
     const objProp = obj[prop];
     if (isString(objProp)) {
       if (hasFunction(objProp)) {
@@ -303,8 +270,7 @@ const deepDestringify = (obj, destringified = {}) => {
           const evalProp = window.eval(`(${objProp})`);
           destringified[prop] = evalProp;
         } catch (e) {
-          if (e)
-            destringified[prop] = objProp;
+          if (e) destringified[prop] = objProp;
         }
       } else {
         destringified[prop] = objProp;
@@ -318,8 +284,7 @@ const deepDestringify = (obj, destringified = {}) => {
               const evalProp = window.eval(`(${arrProp})`);
               destringified[prop].push(evalProp);
             } catch (e) {
-              if (e)
-                destringified[prop].push(arrProp);
+              if (e) destringified[prop].push(arrProp);
             }
           } else {
             destringified[prop].push(arrProp);
@@ -342,110 +307,28 @@ 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);
+    if (opts.verbose) console.warn(e);
   }
-  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];
+    if (excl.includes(e) || !allowUnderscore && e.startsWith("__")) continue;
     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;
+    if (excludeFrom.includes(e) || e.startsWith("__")) continue;
     obj[e] = params[e];
   }
   return obj;
@@ -456,14 +339,11 @@ const overwriteDeep = (obj, params, opts = {}, visited = /* @__PURE__ */ new Wea
   if (!isObjectLike(obj) || !isObjectLike(params) || isDOMNode(obj) || isDOMNode(params)) {
     return params;
   }
-  if (visited.has(obj))
-    return visited.get(obj);
+  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;
+    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)) {
@@ -476,20 +356,6 @@ const overwriteDeep = (obj, params, opts = {}, visited = /* @__PURE__ */ new Wea
   }
   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;
@@ -517,51 +383,41 @@ const isEqualDeep = (param, element, visited = /* @__PURE__ */ new Set()) => {
   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]];
+  if (obj1 === obj2) return true;
+  if (!isObjectLike(obj1) || !isObjectLike(obj2)) return obj1 === obj2;
+  if (isDOMNode(obj1) || isDOMNode(obj2)) return 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) {
+  function checkContains(target, source) {
+    if (visited.has(source)) return true;
+    visited.add(source);
+    for (const key in source) {
+      if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+      if (ignoredKeys.includes(key)) continue;
+      if (!Object.prototype.hasOwnProperty.call(target, key)) return false;
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (isDOMNode(sourceValue) || isDOMNode(targetValue)) {
+        if (sourceValue !== targetValue) return false;
+      } else if (isObjectLike(sourceValue) && isObjectLike(targetValue)) {
+        if (!checkContains(targetValue, sourceValue)) return false;
+      } else if (sourceValue !== targetValue) {
         return false;
       }
     }
+    return true;
   }
-  return true;
+  return checkContains(obj1, obj2);
 };
 const removeFromObject = (obj, props) => {
-  if (props === void 0 || props === null)
-    return obj;
+  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");
+    throw new Error(
+      "Invalid input: props must be a string or an array of strings"
+    );
   }
   return obj;
 };
@@ -653,7 +509,10 @@ const detectInfiniteLoop = (arr) => {
       }
       if (repeatCount >= maxRepeats * 2) {
         if (ENV === "test" || ENV === "development") {
-          console.warn("Warning: Potential infinite loop detected due to repeated sequence:", pattern);
+          console.warn(
+            "Warning: Potential infinite loop detected due to repeated sequence:",
+            pattern
+          );
         }
         return true;
       }
@@ -691,18 +550,12 @@ export {
   deepClone,
   deepContains,
   deepDestringify,
-  deepDiff,
   deepMerge,
   deepStringify,
-  deepStringifyWithMaxDepth,
-  detachFunctionsFromObject,
   detectInfiniteLoop,
-  diff,
-  diffArrays,
-  diffObjects,
   excludeKeysFromObject,
   exec,
-  flattenRecursive,
+  execPromise,
   getInObjectByPath,
   hasFunction,
   hasOwnProperty,
@@ -713,8 +566,6 @@ export {
   makeObjectWithoutPrototype,
   map,
   merge,
-  mergeArrayExclude,
-  mergeIfExisted,
   objectToString,
   overwrite,
   overwriteDeep,