zek 19.0.13 → 19.0.16

package/fesm2022/zek.mjs

@@ -92,6 +92,28 @@ class ArrayHelper {
         }
         return result;
     }
+    /**
+     * Returns a new array with duplicates removed based on a specific key or selector.
+     * @param array The source array.
+     * @param keySelector A function that returns the value to compare by.
+     */
+    static distinctBy(array, keySelector) {
+        // Guard clause for null/undefined or empty arrays
+        if (!array || array.length === 0) {
+            return [];
+        }
+        const seen = new Set();
+        const result = [];
+        // Using a for...of loop is often cleaner than standard for loop in modern JS
+        for (const item of array) {
+            const key = keySelector(item);
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(item);
+            }
+        }
+        return result;
+    }
     static filterByKey(filterValue, key, array) {
         if (typeof filterValue === 'undefined' || filterValue == null || (typeof key === 'string' && key.length === 0))
             return array;
@@ -1033,25 +1055,69 @@ class ObjectHelper {
         return target;
     }
     static deepCopy(value) {
+        // 1. Guard clause: if value is null or not an object, return it.
+        // (This handles primitives and breaks recursion)
         if (!this.isObject(value))
             return value;
-        let output = {};
+        // 2. Handle Arrays
         if (Array.isArray(value)) {
-            output = value.map(x => this.deepCopy(x));
-        }
-        else {
-            Object.keys(value).forEach((key) => {
-                const v = value[key];
-                if (this.isObject(v)) {
-                    output[key] = this.deepCopy(v);
-                }
-                else {
-                    Object.assign(output, { [key]: v });
-                }
-            });
+            return value.map(x => this.deepCopy(x));
+        }
+        // 3. Handle Objects
+        const output = {};
+        for (const key of Object.keys(value)) {
+            const v = value[key];
+            if (this.isObject(v)) {
+                output[key] = this.deepCopy(v);
+            }
+            else {
+                Object.assign(output, { [key]: v });
+            }
         }
         return output;
     }
+    static deepEquals(a, b) {
+        // 1. Strict equality for primitives
+        if (a === b)
+            return true;
+        // 2. If one is null/undefined or types differ → not equal
+        if (a == null || b == null || typeof a !== typeof b)
+            return false;
+        // 3. Date comparison
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() === b.getTime();
+        }
+        // 4. Arrays
+        if (Array.isArray(a)) {
+            if (!Array.isArray(b))
+                return false;
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++) {
+                if (!this.deepEquals(a[i], b[i]))
+                    return false;
+            }
+            return true;
+        }
+        // 5. Objects
+        if (this.isObject(a)) {
+            if (!this.isObject(b))
+                return false;
+            const keysA = Object.keys(a);
+            const keysB = Object.keys(b);
+            if (keysA.length !== keysB.length)
+                return false;
+            for (const key of keysA) {
+                if (!keysB.includes(key))
+                    return false;
+                if (!this.deepEquals(a[key], b[key]))
+                    return false;
+            }
+            return true;
+        }
+        // 6. Fallback
+        return false;
+    }
 }
 
 class FilterHelper {
@@ -2815,6 +2881,12 @@ class IdName {
 }
 class IdNameChecked extends IdName {
     checked;
+    constructor(init) {
+        super();
+        if (init) {
+            Object.assign(this, init);
+        }
+    }
 }
 
 class KeyPair {