@develia/commons 0.4.9 → 0.4.13

package/src/utilities.ts

@@ -113,50 +113,58 @@ export function isFunction(value: any): value is Function {
 
 
 /**
- * Compares two objects or arrays to check if they have the same fields and values,
- * or the same elements if they are arrays (deep equality check).
+ * Structural deep equality check.
  *
- * @param {any} a - The first object or array.
- * @param {any} b - The second object or array.
- * @return {boolean} - Returns true if the objects/arrays are deeply equal, otherwise false.
+ * Compares primitives by value, and objects/arrays/Maps/Sets/Dates/RegExps
+ * by structure. Handles circular references.
+ *
+ * @param a - First value.
+ * @param b - Second value.
+ * @param seen - Internal map used to handle circular references. Do not pass manually.
+ * @returns `true` if `a` and `b` are structurally equal.
  */
-export function deepEqual(a: any, b: any): boolean {
-    if (a === b) {
+export function deepEqual(
+    a: unknown,
+    b: unknown,
+    seen: WeakMap<object, unknown> = new WeakMap()
+): boolean {
+    if (a === b) return true;
+    if (a === null || b === null) return false;
+    if (typeof a !== typeof b) return false;
+    if (typeof a !== "object") return false;
+
+    const objA = a as object;
+    if (seen.has(objA)) return seen.get(objA) === b;
+    seen.set(objA, b);
+
+    if (a instanceof Date) return b instanceof Date && a.getTime() === b.getTime();
+    if (a instanceof RegExp) return b instanceof RegExp && a.toString() === b.toString();
+    if (Array.isArray(a) !== Array.isArray(b)) return false;
+
+    if (a instanceof Map) {
+        if (!(b instanceof Map) || a.size !== b.size) return false;
+        for (const [k, v] of a) {
+            if (!b.has(k) || !deepEqual(v, b.get(k), seen)) return false;
+        }
         return true;
     }
 
-    if (a === null || b === null || typeof a !== typeof b) {
-        return false;
-    }
-
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length) {
-            return false;
-        }
-        for (let i = 0; i < a.length; i++) {
-            if (!deepEqual(a[i], b[i])) {
-                return false;
-            }
-        }
+    if (a instanceof Set) {
+        if (!(b instanceof Set) || a.size !== b.size) return false;
+        for (const v of a) if (!b.has(v)) return false;
         return true;
     }
 
-    if (typeof a === "object" && typeof b === "object") {
-        const keysA = Object.keys(a);
-        const keysB = Object.keys(b);
+    const keysA = Reflect.ownKeys(a as object);
+    const keysB = Reflect.ownKeys(b as object);
+    if (keysA.length !== keysB.length) return false;
 
-        if (keysA.length !== keysB.length) {
-            return false;
-        }
-        for (const key of keysA) {
-            if (!keysB.includes(key) || !deepEqual(a[key], b[key])) {
-                return false;
-            }
-        }
-        return true;
+    for (const key of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+        if (!deepEqual((a as any)[key], (b as any)[key], seen)) return false;
     }
 
-    return false;
+    return true;
 }
 
 
@@ -361,33 +369,57 @@ export function promisify<T>(thing: Resolvable<T>): Promise<T> {
 
 
 /**
- * Creates a deep clone of the given object.
- * @template T
- * @param {T} obj - The object to clone.
- * @return {T} - The deep clone of the given object.
+ * Create a deep, independent copy of a value.
+ *
+ * Supports primitives, plain objects, arrays, `Date`, `RegExp`, `Map`, `Set`,
+ * symbol-keyed properties and circular references. Functions are copied by
+ * reference. Class instances preserve their prototype.
+ *
+ * @template T - The value's type.
+ * @param value - The value to clone.
+ * @param seen - Internal map used to handle circular references. Do not pass manually.
+ * @returns A deep clone of `value`.
  */
-export function deepClone<T>(obj: T): T {
-    if (obj === null || typeof obj !== 'object') {
-        return obj;
+export function deepClone<T>(
+    value: T,
+    seen: WeakMap<object, unknown> = new WeakMap()
+): T {
+    if (value === null || typeof value !== "object") return value;
+
+    const obj = value as unknown as object;
+    if (seen.has(obj)) return seen.get(obj) as T;
+
+    if (value instanceof Date) return new Date(value) as T;
+    if (value instanceof RegExp) return new RegExp(value) as T;
+
+    if (value instanceof Map) {
+        const copy = new Map();
+        seen.set(value, copy);
+        value.forEach((v, k) => copy.set(deepClone(k, seen), deepClone(v, seen)));
+        return copy as T;
     }
 
-    if (Array.isArray(obj)) {
-        const copy: any[] = [];
-        for (const element of obj) {
-            copy.push(deepClone(element));
-        }
+    if (value instanceof Set) {
+        const copy = new Set();
+        seen.set(value, copy);
+        value.forEach((v) => copy.add(deepClone(v, seen)));
         return copy as T;
     }
 
-    const copy: { [key: string]: any } = {};
-    for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            copy[key] = deepClone((obj as { [key: string]: any })[key]);
-        }
+    const copy: any = Array.isArray(value)
+        ? []
+        : Object.create(Object.getPrototypeOf(value));
+
+    seen.set(obj, copy);
+
+    for (const key of Reflect.ownKeys(obj)) {
+        copy[key] = deepClone((value as any)[key], seen);
     }
+
     return copy as T;
 }
 
+
 /**
  * Returns the type of the given value.
  *