@domql/utils 2.4.12 → 2.5.14

package/dist/cjs/function.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var function_exports = {};
 __export(function_exports, {
   debounce: () => debounce,
+  isStringFunction: () => isStringFunction,
   memoize: () => memoize
 });
 module.exports = __toCommonJS(function_exports);
@@ -44,3 +45,7 @@ const memoize = (fn) => {
     }
   };
 };
+const isStringFunction = (inputString) => {
+  const functionRegex = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/;
+  return functionRegex.test(inputString);
+};

package/dist/cjs/object.js

@@ -21,6 +21,7 @@ __export(object_exports, {
   clone: () => clone,
   deepClone: () => deepClone,
   deepCloneExclude: () => deepCloneExclude,
+  deepContains: () => deepContains,
   deepDestringify: () => deepDestringify,
   deepMerge: () => deepMerge,
   deepStringify: () => deepStringify,
@@ -380,23 +381,56 @@ const flattenRecursive = (param, prop, stack = []) => {
   delete objectized[prop];
   return stack;
 };
-const isEqualDeep = (param, element) => {
-  if (param === element)
+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;
-  if (!param || !element)
+  }
+  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 prop in param) {
-    const paramProp = param[prop];
-    const elementProp = element[prop];
-    if ((0, import_types.isObjectLike)(paramProp)) {
-      const isEqual = isEqualDeep(paramProp, elementProp);
-      if (!isEqual)
-        return false;
-    } else {
-      const isEqual = paramProp === elementProp;
-      if (!isEqual)
+  }
+  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) => {
+  if (typeof obj1 !== typeof obj2) {
+    return false;
+  }
+  if ((0, import_types.isObjectLike)(obj1)) {
+    if (Array.isArray(obj1) && Array.isArray(obj2)) {
+      if (obj1.length !== obj2.length) {
         return false;
+      }
+      for (let i = 0; i < obj1.length; i++) {
+        if (!deepContains(obj1[i], obj2[i])) {
+          return false;
+        }
+      }
+    } else if ((0, import_types.isObjectLike)(obj1) && obj2 !== null) {
+      for (const key in obj1) {
+        const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj2, key);
+        if (!hasOwnProperty || !deepContains(obj1[key], obj2[key])) {
+          return false;
+        }
+      }
     }
+  } else {
+    return obj2 === obj1;
   }
   return true;
 };

package/function.js

@@ -21,3 +21,11 @@ export const memoize = (fn) => {
     }
   }
 }
+
+export const isStringFunction = inputString => {
+  // Regular expression to match both regular and arrow function declarations
+  const functionRegex = /^((function\s*\([^)]*\)\s*\{[^}]*\})|(\([^)]*\)\s*=>))/
+
+  // Use the regex to test if the inputString matches the function pattern
+  return functionRegex.test(inputString)
+}

package/object.js

@@ -375,20 +375,107 @@ export const flattenRecursive = (param, prop, stack = []) => {
   return stack
 }
 
-export const isEqualDeep = (param, element) => {
-  if (param === element) return true
-  if (!param || !element) return false
-  for (const prop in param) {
-    const paramProp = param[prop]
-    const elementProp = element[prop]
-    if (isObjectLike(paramProp)) {
-      const isEqual = isEqualDeep(paramProp, elementProp)
-      if (!isEqual) return false
-    } else {
-      const isEqual = paramProp === elementProp
-      if (!isEqual) return false
+/**
+ * Recursively compares two values to determine if they are deeply equal.
+ *
+ * This function checks for deep equality between two values, including
+ * objects, arrays, and nested structures. It handles circular references to
+ * prevent infinite loops.
+ *
+ * @param {*} param - The first value to compare.
+ * @param {*} element - The second value to compare.
+ * @param {Set} [visited] - (Optional) A set to track visited objects during recursion
+ *   to handle circular references. You can omit this parameter when calling
+ *   the function; it is used internally for tracking visited objects.
+ *
+ * @returns {boolean} Returns `true` if the values are deeply equal, `false` otherwise.
+ *
+ * @example
+ * // Comparing primitive values
+ * isEqualDeep(42, 42); // true
+ * isEqualDeep('hello', 'hello'); // true
+ * isEqualDeep(true, true); // true
+ * isEqualDeep(42, '42'); // false
+ *
+ * // Comparing simple objects
+ * const obj1 = { a: 1, b: { c: 2 } };
+ * const obj2 = { a: 1, b: { c: 2 } };
+ * isEqualDeep(obj1, obj2); // true
+ *
+ * // Handling circular references
+ * const circularObj = { prop: null };
+ * circularObj.prop = circularObj;
+ * const anotherObj = { prop: null };
+ * anotherObj.prop = anotherObj;
+ * isEqualDeep(circularObj, anotherObj); // true
+ */
+export const isEqualDeep = (param, element, visited = new Set()) => {
+  // Check if both values are non-null objects
+  if (typeof param !== 'object' || typeof element !== 'object' || param === null || element === null) {
+    return param === element // Compare non-object values directly
+  }
+
+  // Check for circular references
+  if (visited.has(param) || visited.has(element)) {
+    return true // Assume equality to break the circular reference
+  }
+
+  visited.add(param)
+  visited.add(element)
+
+  const keysParam = Object.keys(param)
+  const keysElement = Object.keys(element)
+
+  // Check if both objects have the same number of properties
+  if (keysParam.length !== keysElement.length) {
+    return false
+  }
+
+  // Check if all properties in param also exist in element
+  for (const key of keysParam) {
+    if (!keysElement.includes(key)) {
+      return false
+    }
+
+    const paramProp = param[key]
+    const elementProp = element[key]
+
+    // Recursively check property values
+    if (!isEqualDeep(paramProp, elementProp, visited)) {
+      return false
     }
   }
+
+  return true
+}
+
+export const deepContains = (obj1, obj2) => {
+  if (typeof obj1 !== typeof obj2) {
+    return false
+  }
+
+  if (isObjectLike(obj1)) {
+    if (Array.isArray(obj1) && Array.isArray(obj2)) {
+      if (obj1.length !== obj2.length) {
+        return false
+      }
+      for (let i = 0; i < obj1.length; i++) {
+        if (!deepContains(obj1[i], obj2[i])) {
+          return false
+        }
+      }
+    } else if (isObjectLike(obj1) && obj2 !== null) {
+      for (const key in obj1) {
+        const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj2, key)
+        if (!hasOwnProperty || !deepContains(obj1[key], obj2[key])) {
+          return false
+        }
+      }
+    }
+  } else {
+    return obj2 === obj1
+  }
+
   return true
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/utils",
-  "version": "2.4.12",
+  "version": "2.5.14",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -23,7 +23,7 @@
     "build": "yarn build:cjs",
     "prepublish": "rimraf -I dist && yarn build && yarn copy:package:cjs"
   },
-  "gitHead": "fb655eb1dbbde28cb1b843f13aad21afcfcece40",
+  "gitHead": "ab852cb3a435b154f6b32a9a664f65ec56a9c49f",
   "devDependencies": {
     "@babel/core": "^7.12.0"
   }