@domql/utils 2.4.7 → 2.5.13

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/key.js

@@ -18,11 +18,11 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var key_exports = {};
 __export(key_exports, {
-  createKey: () => createKey,
-  createSnapshotId: () => createSnapshotId
+  createSnapshotId: () => createSnapshotId,
+  generateKey: () => generateKey
 });
 module.exports = __toCommonJS(key_exports);
-const createKey = function() {
+const generateKey = function() {
   let index = 0;
   function newId() {
     index++;
@@ -30,4 +30,4 @@ const createKey = function() {
   }
   return newId;
 }();
-const createSnapshotId = createKey;
+const createSnapshotId = generateKey;

package/dist/cjs/object.js

@@ -380,22 +380,28 @@ 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)
-        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;

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/key.js

@@ -1,6 +1,6 @@
 'use strict'
 
-export const createKey = (function () {
+export const generateKey = (function () {
   let index = 0
 
   function newId () {
@@ -11,4 +11,4 @@ export const createKey = (function () {
   return newId
 })()
 
-export const createSnapshotId = createKey
+export const createSnapshotId = generateKey

package/object.js

@@ -375,20 +375,77 @@ 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
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/utils",
-  "version": "2.4.7",
+  "version": "2.5.13",
   "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": "fd9683a7d42893983463967fa512ac095a6a36e9",
+  "gitHead": "3bbff7f4e2ced6f104572489a2779a5cf0dbb450",
   "devDependencies": {
     "@babel/core": "^7.12.0"
   }