@domql/utils 3.1.2 → 3.2.7

package/dist/cjs/object.js

@@ -29,7 +29,6 @@ __export(object_exports, {
   detectInfiniteLoop: () => detectInfiniteLoop,
   excludeKeysFromObject: () => excludeKeysFromObject,
   exec: () => exec,
-  execPromise: () => execPromise,
   getInObjectByPath: () => getInObjectByPath,
   hasFunction: () => hasFunction,
   hasOwnProperty: () => hasOwnProperty,
@@ -56,26 +55,25 @@ var import_array = require("./array.js");
 var import_string = require("./string.js");
 var import_node = require("./node.js");
 var import_keys = require("./keys.js");
-const ENV = "development";
+const ENV = process.env.NODE_ENV;
+const _startsWithDunder = (e) => e.charCodeAt(0) === 95 && e.charCodeAt(1) === 95;
 const exec = (param, element, state, context) => {
   if ((0, import_types.isFunction)(param)) {
-    return param.call(
-      element,
-      element,
-      state || element.state,
-      context || element.context
-    );
-  }
-  return param;
-};
-const execPromise = async (param, element, state, context) => {
-  if ((0, import_types.isFunction)(param)) {
-    return await param.call(
+    if (!element) return;
+    const result = param.call(
       element,
       element,
       state || element.state,
       context || element.context
     );
+    if (result && typeof result.then === "function") {
+      let resolved;
+      result.then((value) => {
+        resolved = value;
+      });
+      return resolved;
+    }
+    return result;
   }
   return param;
 };
@@ -85,25 +83,23 @@ const map = (obj, extention, element) => {
   }
 };
 const merge = (element, obj, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set;
   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;
+    if (!Object.prototype.hasOwnProperty.call(obj, e)) continue;
+    if (_startsWithDunder(e)) continue;
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
+    if (element[e] === void 0) {
+      element[e] = obj[e];
     }
   }
   return element;
 };
 const deepMerge = (element, extend, excludeFrom = import_keys.METHODS_EXL) => {
+  const useSet = excludeFrom instanceof Set;
   for (const e in extend) {
-    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(extend, e);
-    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__")) {
-      continue;
-    }
+    if (!Object.prototype.hasOwnProperty.call(extend, e)) continue;
+    if (_startsWithDunder(e)) continue;
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
     const elementProp = element[e];
     const extendProp = extend[e];
     if ((0, import_types.isObjectLike)(elementProp) && (0, import_types.isObjectLike)(extendProp)) {
@@ -115,12 +111,12 @@ const deepMerge = (element, extend, excludeFrom = import_keys.METHODS_EXL) => {
   return element;
 };
 const clone = (obj, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set;
   const o = {};
   for (const prop in obj) {
-    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, prop);
-    if (!hasOwnProperty2 || excludeFrom.includes(prop) || prop.startsWith("__")) {
-      continue;
-    }
+    if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue;
+    if (_startsWithDunder(prop)) continue;
+    if (useSet ? excludeFrom.has(prop) : excludeFrom.includes(prop)) continue;
     o[prop] = obj[prop];
   }
   return o;
@@ -134,23 +130,24 @@ const deepClone = (obj, options = {}) => {
     visited = /* @__PURE__ */ new WeakMap(),
     handleExtends = false
   } = options;
+  const contentWindow = targetWindow || import_globals.window || globalThis;
   if (!(0, import_types.isObjectLike)(obj) || (0, import_node.isDOMNode)(obj)) {
     return obj;
   }
   if (visited.has(obj)) {
     return visited.get(obj);
   }
-  const clone2 = targetWindow ? (0, import_types.isArray)(obj) ? new targetWindow.Array() : new targetWindow.Object() : (0, import_types.isArray)(obj) ? [] : {};
+  const isArr = (0, import_types.isArray)(obj);
+  const clone2 = isArr ? [] : {};
   visited.set(obj, clone2);
+  const excludeSet = exclude instanceof Set ? exclude : exclude.length > 3 ? new Set(exclude) : null;
   for (const key in obj) {
     if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
-    if (exclude.includes(key) || key.startsWith("__") || key === "__proto__") {
-      continue;
-    }
+    if (_startsWithDunder(key) || key === "__proto__") continue;
+    if (excludeSet ? excludeSet.has(key) : exclude.includes(key)) continue;
     const value = obj[key];
-    if (cleanUndefined && (0, import_types.isUndefined)(value) || cleanNull && (0, import_types.isNull)(value)) {
-      continue;
-    }
+    if (cleanUndefined && value === void 0) continue;
+    if (cleanNull && value === null) continue;
     if ((0, import_node.isDOMNode)(value)) {
       clone2[key] = value;
       continue;
@@ -159,8 +156,8 @@ const deepClone = (obj, options = {}) => {
       clone2[key] = (0, import_array.unstackArrayOfObjects)(value, exclude);
       continue;
     }
-    if ((0, import_types.isFunction)(value) && targetWindow) {
-      clone2[key] = targetWindow.eval("(" + value.toString() + ")");
+    if ((0, import_types.isFunction)(value) && options.window) {
+      clone2[key] = contentWindow.eval("(" + value.toString() + ")");
       continue;
     }
     if ((0, import_types.isObjectLike)(value)) {
@@ -175,14 +172,13 @@ const deepClone = (obj, options = {}) => {
   return clone2;
 };
 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(
+    (obj.__element || obj.parent?.__element).warn(
       "Trying to clone element or state at",
       obj
     );
-    obj = (_b = obj.parse) == null ? void 0 : _b.call(obj);
+    obj = obj.parse?.();
   }
   for (const prop in obj) {
     const objProp = obj[prop];
@@ -192,50 +188,63 @@ const deepStringify = (obj, stringified = {}) => {
       stringified[prop] = {};
       deepStringify(objProp, stringified[prop]);
     } else if ((0, import_types.isArray)(objProp)) {
-      stringified[prop] = [];
-      objProp.forEach((v, i) => {
+      const arr = stringified[prop] = [];
+      for (let i = 0; i < objProp.length; i++) {
+        const v = objProp[i];
         if ((0, import_types.isObject)(v)) {
-          stringified[prop][i] = {};
-          deepStringify(v, stringified[prop][i]);
+          arr[i] = {};
+          deepStringify(v, arr[i]);
         } else if ((0, import_types.isFunction)(v)) {
-          stringified[prop][i] = v.toString();
+          arr[i] = v.toString();
         } else {
-          stringified[prop][i] = v;
+          arr[i] = v;
         }
-      });
+      }
     } else {
       stringified[prop] = objProp;
     }
   }
   return stringified;
 };
+const OBJ_TO_STR_SPECIAL_CHARS = /* @__PURE__ */ new Set([
+  "&",
+  "*",
+  "-",
+  ":",
+  "%",
+  "{",
+  "}",
+  ">",
+  "<",
+  "@",
+  ".",
+  "/",
+  "!",
+  " "
+]);
 const objectToString = (obj = {}, indent = 0) => {
   if (obj === null || typeof obj !== "object") {
     return String(obj);
   }
-  if (Object.keys(obj).length === 0) {
-    return "{}";
+  let hasKeys = false;
+  for (const _k in obj) {
+    hasKeys = true;
+    break;
   }
+  if (!hasKeys) return "{}";
   const spaces = "  ".repeat(indent);
   let str = "{\n";
-  for (const [key, value] of Object.entries(obj)) {
-    const keyNotAllowdChars = (0, import_string.stringIncludesAny)(key, [
-      "&",
-      "*",
-      "-",
-      ":",
-      "%",
-      "{",
-      "}",
-      ">",
-      "<",
-      "@",
-      ".",
-      "/",
-      "!",
-      " "
-    ]);
-    const stringedKey = keyNotAllowdChars ? `'${key}'` : key;
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    const value = obj[key];
+    let keyNeedsQuotes = false;
+    for (let i = 0; i < key.length; i++) {
+      if (OBJ_TO_STR_SPECIAL_CHARS.has(key[i])) {
+        keyNeedsQuotes = true;
+        break;
+      }
+    }
+    const stringedKey = keyNeedsQuotes ? `'${key}'` : key;
     str += `${spaces}  ${stringedKey}: `;
     if ((0, import_types.isArray)(value)) {
       str += "[\n";
@@ -264,36 +273,36 @@ const objectToString = (obj = {}, indent = 0) => {
   str += `${spaces}}`;
   return str;
 };
+const FN_PATTERNS = [
+  /^\(\s*\{[^}]*\}\s*\)\s*=>/,
+  /^(\([^)]*\)|[^=]*)\s*=>/,
+  /^function[\s(]/,
+  /^async\s+/,
+  /^\(\s*function/,
+  /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/
+];
+const RE_JSON_LIKE = /^["[{]/;
 const hasFunction = (str) => {
   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;
-  const patterns = [
-    /^\(\s*\{[^}]*\}\s*\)\s*=>/,
-    /^(\([^)]*\)|[^=]*)\s*=>/,
-    /^function[\s(]/,
-    /^async\s+/,
-    /^\(\s*function/,
-    /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/
-  ];
-  const isFunction2 = patterns.some((pattern) => pattern.test(trimmed));
-  const isObjectLiteral = trimmed.startsWith("{") && !trimmed.includes("=>");
-  const isArrayLiteral = trimmed.startsWith("[");
-  const isJSONLike = /^["[{]/.test(trimmed) && !trimmed.includes("=>");
-  return isFunction2 && !isObjectLiteral && !isArrayLiteral && !isJSONLike;
+  if (trimmed === "" || trimmed === "{}" || trimmed === "[]") return false;
+  const isFn = FN_PATTERNS.some((pattern) => pattern.test(trimmed));
+  if (!isFn) return false;
+  const firstChar = trimmed.charCodeAt(0);
+  const hasArrow = trimmed.includes("=>");
+  if (firstChar === 123 && !hasArrow) return false;
+  if (firstChar === 91) return false;
+  if (RE_JSON_LIKE.test(trimmed) && !hasArrow) return false;
+  return true;
 };
 const deepDestringify = (obj, destringified = {}) => {
   for (const prop in obj) {
-    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, prop);
-    if (!hasOwnProperty2) continue;
+    if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue;
     const objProp = obj[prop];
     if ((0, import_types.isString)(objProp)) {
       if (hasFunction(objProp)) {
         try {
-          const evalProp = import_globals.window.eval(`(${objProp})`);
-          destringified[prop] = evalProp;
+          destringified[prop] = import_globals.window.eval(`(${objProp})`);
         } catch (e) {
           if (e) destringified[prop] = objProp;
         }
@@ -301,25 +310,25 @@ const deepDestringify = (obj, destringified = {}) => {
         destringified[prop] = objProp;
       }
     } else if ((0, import_types.isArray)(objProp)) {
-      destringified[prop] = [];
-      objProp.forEach((arrProp) => {
+      const arr = destringified[prop] = [];
+      for (let i = 0; i < objProp.length; i++) {
+        const arrProp = objProp[i];
         if ((0, import_types.isString)(arrProp)) {
           if (hasFunction(arrProp)) {
             try {
-              const evalProp = import_globals.window.eval(`(${arrProp})`);
-              destringified[prop].push(evalProp);
+              arr.push(import_globals.window.eval(`(${arrProp})`));
             } catch (e) {
-              if (e) destringified[prop].push(arrProp);
+              if (e) arr.push(arrProp);
             }
           } else {
-            destringified[prop].push(arrProp);
+            arr.push(arrProp);
           }
         } else if ((0, import_types.isObject)(arrProp)) {
-          destringified[prop].push(deepDestringify(arrProp));
+          arr.push(deepDestringify(arrProp));
         } else {
-          destringified[prop].push(arrProp);
+          arr.push(arrProp);
         }
-      });
+      }
     } else if ((0, import_types.isObject)(objProp)) {
       destringified[prop] = deepDestringify(objProp, destringified[prop]);
     } else {
@@ -336,39 +345,44 @@ const stringToObject = (str, opts = { verbose: true }) => {
   }
 };
 const hasOwnProperty = (o, ...args) => Object.prototype.hasOwnProperty.call(o, ...args);
-const isEmpty = (o) => Object.keys(o).length === 0;
+const isEmpty = (o) => {
+  for (const _ in o) return false;
+  return true;
+};
 const isEmptyObject = (o) => (0, import_types.isObject)(o) && isEmpty(o);
 const makeObjectWithoutPrototype = () => /* @__PURE__ */ Object.create(null);
 const overwrite = (element, params, opts = {}) => {
   const excl = opts.exclude || [];
   const allowUnderscore = opts.preventUnderscore;
   for (const e in params) {
-    if (excl.includes(e) || !allowUnderscore && e.startsWith("__")) continue;
-    const paramsProp = params[e];
-    if (paramsProp !== void 0) {
-      element[e] = paramsProp;
+    if (excl.includes(e) || !allowUnderscore && _startsWithDunder(e)) continue;
+    if (params[e] !== void 0) {
+      element[e] = params[e];
     }
   }
   return element;
 };
 const overwriteShallow = (obj, params, excludeFrom = []) => {
+  const useSet = excludeFrom instanceof Set;
   for (const e in params) {
-    if (excludeFrom.includes(e) || e.startsWith("__")) continue;
+    if (_startsWithDunder(e)) continue;
+    if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) 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 (!(0, import_types.isObjectLike)(obj) || !(0, import_types.isObjectLike)(params) || (0, import_node.isDOMNode)(obj) || (0, import_node.isDOMNode)(params)) {
     return params;
   }
   if (visited.has(obj)) return visited.get(obj);
   visited.set(obj, obj);
+  const excl = opts.exclude;
+  const exclSet = excl ? excl instanceof Set ? excl : new Set(excl) : null;
+  const forcedExclude = !opts.preventForce;
   for (const e in params) {
-    if (!Object.hasOwnProperty.call(params, e)) continue;
-    if (excl.includes(e) || forcedExclude && e.startsWith("__")) continue;
+    if (!Object.prototype.hasOwnProperty.call(params, e)) continue;
+    if (exclSet && exclSet.has(e) || forcedExclude && _startsWithDunder(e)) continue;
     const objProp = obj[e];
     const paramsProp = params[e];
     if ((0, import_node.isDOMNode)(paramsProp)) {
@@ -395,29 +409,30 @@ const isEqualDeep = (param, element, visited = /* @__PURE__ */ new Set()) => {
   if (keysParam.length !== keysElement.length) {
     return false;
   }
-  for (const key of keysParam) {
-    if (!keysElement.includes(key)) {
+  for (let i = 0; i < keysParam.length; i++) {
+    const key = keysParam[i];
+    if (!Object.prototype.hasOwnProperty.call(element, key)) {
       return false;
     }
-    const paramProp = param[key];
-    const elementProp = element[key];
-    if (!isEqualDeep(paramProp, elementProp, visited)) {
+    if (!isEqualDeep(param[key], element[key], visited)) {
       return false;
     }
   }
   return true;
 };
-const deepContains = (obj1, obj2, ignoredKeys = ["node", "__ref"]) => {
+const DEEP_CONTAINS_IGNORED = /* @__PURE__ */ new Set(["node", "__ref"]);
+const deepContains = (obj1, obj2, ignoredKeys = DEEP_CONTAINS_IGNORED) => {
   if (obj1 === obj2) return true;
   if (!(0, import_types.isObjectLike)(obj1) || !(0, import_types.isObjectLike)(obj2)) return obj1 === obj2;
   if ((0, import_node.isDOMNode)(obj1) || (0, import_node.isDOMNode)(obj2)) return obj1 === obj2;
+  const ignored = ignoredKeys instanceof Set ? ignoredKeys : new Set(ignoredKeys);
   const visited = /* @__PURE__ */ new WeakSet();
   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 (ignored.has(key)) continue;
       if (!Object.prototype.hasOwnProperty.call(target, key)) return false;
       const sourceValue = source[key];
       const targetValue = target[key];
@@ -438,7 +453,7 @@ const removeFromObject = (obj, props) => {
   if ((0, import_types.is)(props)("string", "number")) {
     delete obj[props];
   } else if ((0, import_types.isArray)(props)) {
-    props.forEach((prop) => delete obj[prop]);
+    for (let i = 0; i < props.length; i++) delete obj[props[i]];
   } else {
     throw new Error(
       "Invalid input: props must be a string or an array of strings"
@@ -459,19 +474,17 @@ const createObjectWithoutPrototype = (obj) => {
   return newObj;
 };
 const createNestedObject = (arr, lastValue) => {
+  if (arr.length === 0) return 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;
+  let current = nestedObject;
+  for (let i = 0; i < arr.length; i++) {
+    if (i === arr.length - 1 && lastValue) {
+      current[arr[i]] = lastValue;
+    } else {
+      current[arr[i]] = {};
+      current = current[arr[i]];
     }
-    return obj[value];
-  }, nestedObject);
+  }
   return nestedObject;
 };
 const removeNestedKeyByPath = (obj, path) => {
@@ -480,13 +493,11 @@ const removeNestedKeyByPath = (obj, path) => {
   }
   let current = obj;
   for (let i = 0; i < path.length - 1; i++) {
-    if (current[path[i]] === void 0) {
-      return;
-    }
+    if (current[path[i]] === void 0) return;
     current = current[path[i]];
   }
   const lastKey = path[path.length - 1];
-  if (current && Object.hasOwnProperty.call(current, lastKey)) {
+  if (current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
     delete current[lastKey];
   }
 };
@@ -501,8 +512,7 @@ const setInObjectByPath = (obj, path, value) => {
     }
     current = current[path[i]];
   }
-  const lastKey = path[path.length - 1];
-  current[lastKey] = value;
+  current[path[path.length - 1]] = value;
   return obj;
 };
 const getInObjectByPath = (obj, path) => {
@@ -545,15 +555,13 @@ const detectInfiniteLoop = (arr) => {
   }
 };
 const isCyclic = (obj) => {
-  const seenObjects = [];
+  const seen = /* @__PURE__ */ new WeakSet();
   function detect(obj2) {
     if (obj2 && typeof obj2 === "object") {
-      if (seenObjects.indexOf(obj2) !== -1) {
-        return true;
-      }
-      seenObjects.push(obj2);
+      if (seen.has(obj2)) return true;
+      seen.add(obj2);
       for (const key in obj2) {
-        if (Object.hasOwnProperty.call(obj2, key) && detect(obj2[key])) {
+        if (Object.prototype.hasOwnProperty.call(obj2, key) && detect(obj2[key])) {
           console.log(obj2, "cycle at " + key);
           return true;
         }
@@ -564,7 +572,12 @@ const isCyclic = (obj) => {
   return detect(obj);
 };
 const excludeKeysFromObject = (obj, excludedKeys) => {
-  const result = { ...obj };
-  excludedKeys.forEach((key) => delete result[key]);
+  const excluded = excludedKeys instanceof Set ? excludedKeys : new Set(excludedKeys);
+  const result = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key) && !excluded.has(key)) {
+      result[key] = obj[key];
+    }
+  }
   return result;
 };