@etsoo/shared 1.2.76 → 1.2.79

package/lib/cjs/test/MockResizeObserver.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockResizeObserver = void 0;
+/**
+ * Mock implementation of ResizeObserver for testing purposes
+ */
+class MockResizeObserver {
+    constructor(callback) {
+        this.callbacks = [];
+        this.elements = [];
+        this.callbacks.push(callback);
+    }
+    observe(element) {
+        this.elements.push(element);
+    }
+    unobserve(element) {
+        this.elements = this.elements.filter((el) => el !== element);
+    }
+    disconnect() {
+        this.elements = [];
+    }
+    // Helper to trigger the callback manually in tests
+    trigger(entries) {
+        this.callbacks.forEach((cb) => cb(entries));
+    }
+}
+exports.MockResizeObserver = MockResizeObserver;

package/lib/mjs/ArrayUtils.js

@@ -1,4 +1,4 @@
-import isEqual from "lodash.isequal";
+import { DataTypes } from "./DataTypes";
 Array.prototype.different = function (target, round) {
     return ArrayUtils.differences(this, target, round);
 };
@@ -13,7 +13,7 @@ Array.prototype.toggleItem = function (item, add, idField) {
                 return i[idField] === item;
             }
         }
-        return isEqual(i, item);
+        return DataTypes.isDeepEqual(i, item);
     });
     if (add) {
         if (index < 0) {
@@ -33,7 +33,7 @@ Array.prototype.toUnique = function () {
         return Array.from(new Set(this));
     const newArray = [];
     this.forEach((item) => {
-        if (newArray.some((newItem) => isEqual(item, newItem)))
+        if (newArray.some((newItem) => DataTypes.isDeepEqual(item, newItem)))
             return;
         newArray.push(item);
     });

package/lib/mjs/DataTypes.d.ts

@@ -399,6 +399,14 @@ export declare namespace DataTypes {
      * @returns Is basic type
      */
     function isBasicName(name: string): name is BasicNames;
+    /**
+     * Check deep equality
+     * @param a Input a
+     * @param b Input b
+     * @param isStrict Strict or not, false: loose equal, undefined === but null equal undefined, NaN equal NaN, true: strict equal
+     * @returns Result
+     */
+    function isDeepEqual(a: unknown, b: unknown, isStrict?: boolean): boolean;
     /**
      * Is the target a simple object (Type guard)
      * @param input Test data

package/lib/mjs/DataTypes.js

@@ -452,6 +452,64 @@ export var DataTypes;
         return DataTypes.BasicArray.includes(name);
     }
     DataTypes.isBasicName = isBasicName;
+    /**
+     * Check deep equality
+     * @param a Input a
+     * @param b Input b
+     * @param isStrict Strict or not, false: loose equal, undefined === but null equal undefined, NaN equal NaN, true: strict equal
+     * @returns Result
+     */
+    function isDeepEqual(a, b, isStrict) {
+        // Same object or value
+        if (a === b)
+            return true;
+        // Null and undefined case
+        if (a == null || b == null) {
+            if (!isStrict && a == b)
+                return true;
+            return a === b;
+        }
+        else if (isStrict === false) {
+            // Loose equal case
+            if (a == b)
+                return true;
+        }
+        // Different type
+        if (typeof a !== typeof b)
+            return false;
+        // NaN case
+        if (Number.isNaN(a) && Number.isNaN(b) && !isStrict)
+            return true;
+        if (typeof a === "object") {
+            // Date
+            if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            // Array
+            if (Array.isArray(a) && Array.isArray(b)) {
+                if (a.length !== b.length)
+                    return false;
+                for (let i = 0; i < a.length; i++) {
+                    if (!isDeepEqual(a[i], b[i], isStrict))
+                        return false;
+                }
+                return true;
+            }
+            // Loop object keys
+            const aKeys = Object.keys(a);
+            const bKeys = Object.keys(b);
+            if (aKeys.length !== bKeys.length && isStrict)
+                return false;
+            const allKeys = new Set([...aKeys, ...bKeys]);
+            for (const key of allKeys) {
+                if (!isDeepEqual(Reflect.get(a, key), Reflect.get(b, key), isStrict))
+                    return false;
+            }
+            return true;
+        }
+        return isStrict ? a === b : a == b;
+    }
+    DataTypes.isDeepEqual = isDeepEqual;
     /**
      * Is the target a simple object (Type guard)
      * @param input Test data

package/lib/mjs/StorageUtils.js

@@ -1,4 +1,4 @@
-import { NodeStorage } from "./node/Storage";
+import { NodeStorage } from "./node/NodeStorage";
 import { Utils } from "./Utils";
 // Mock node
 globalThis.localStorage ?? (globalThis.localStorage = new NodeStorage());

package/lib/mjs/Utils.d.ts

@@ -112,13 +112,6 @@ export declare namespace Utils {
     export function correctTypes<T extends object, F extends {
         [P in keyof T]?: DataTypes.BasicNames;
     }>(input: T, fields: F): void;
-    /**
-     * Two values equal
-     * @param v1 Value 1
-     * @param v2 Value 2
-     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
-     */
-    export function equals(v1: unknown, v2: unknown, strict?: number): boolean;
     /**
      * Exclude specific items
      * @param items Items
@@ -231,10 +224,10 @@ export declare namespace Utils {
      * @param obj1 Object 1
      * @param obj2 Object 2
      * @param ignoreFields Ignored fields
-     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @param isStrict Strict or not, false: loose equal, undefined === but null equal undefined, NaN equal NaN, true: strict equal
      * @returns Result
      */
-    export function objectEqual(obj1: object, obj2: object, ignoreFields?: string[], strict?: number): boolean;
+    export function objectEqual(obj1: object, obj2: object, ignoreFields?: string[], isStrict?: boolean): boolean;
     /**
      * Get two object's unqiue properties
      * @param obj1 Object 1
@@ -248,10 +241,10 @@ export declare namespace Utils {
      * @param objNew New object
      * @param objPre Previous object
      * @param ignoreFields Ignored fields
-     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @param isStrict Strict or not, false: loose equal, undefined === but null equal undefined, NaN equal NaN, true: strict equal
      * @returns Updated fields
      */
-    export function objectUpdated(objNew: object, objPrev: object, ignoreFields?: string[], strict?: number): string[];
+    export function objectUpdated(objNew: object, objPrev: object, ignoreFields?: string[], isStrict?: boolean): string[];
     /**
      * Try to parse JSON input to array
      * @param input JSON input

package/lib/mjs/Utils.js

@@ -1,5 +1,4 @@
 import { DataTypes } from "./DataTypes";
-import isEqual from "lodash.isequal";
 import { DateUtils } from "./DateUtils";
 String.prototype.addUrlParam = function (name, value, arrayFormat) {
     return this.addUrlParams({ [name]: value }, arrayFormat);
@@ -180,29 +179,6 @@ export var Utils;
         }
     }
     Utils.correctTypes = correctTypes;
-    /**
-     * Two values equal
-     * @param v1 Value 1
-     * @param v2 Value 2
-     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
-     */
-    function equals(v1, v2, strict = 1) {
-        // Null and undefined case
-        if (v1 == null || v2 == null) {
-            if (strict <= 1 && v1 == v2)
-                return true;
-            return v1 === v2;
-        }
-        // For date, array and object
-        if (typeof v1 === "object")
-            return isEqual(v1, v2);
-        // 1 and '1' case
-        if (strict === 0)
-            return v1 == v2;
-        // Strict equal
-        return v1 === v2;
-    }
-    Utils.equals = equals;
     /**
      * Exclude specific items
      * @param items Items
@@ -281,7 +257,7 @@ export var Utils;
                     return;
                 }
                 const newValue = DataTypes.convert(value, initValue);
-                if (Utils.equals(newValue, initValue)) {
+                if (DataTypes.isDeepEqual(newValue, initValue)) {
                     Reflect.deleteProperty(input, key);
                     return;
                 }
@@ -446,17 +422,17 @@ export var Utils;
      * @param obj1 Object 1
      * @param obj2 Object 2
      * @param ignoreFields Ignored fields
-     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @param isStrict Strict or not, false: loose equal, undefined === but null equal undefined, NaN equal NaN, true: strict equal
      * @returns Result
      */
-    function objectEqual(obj1, obj2, ignoreFields = [], strict = 1) {
+    function objectEqual(obj1, obj2, ignoreFields = [], isStrict) {
         // Unique keys
         const keys = Utils.objectKeys(obj1, obj2, ignoreFields);
         for (const key of keys) {
             // Values
             const v1 = Reflect.get(obj1, key);
             const v2 = Reflect.get(obj2, key);
-            if (!Utils.equals(v1, v2, strict))
+            if (!DataTypes.isDeepEqual(v1, v2, isStrict))
                 return false;
         }
         return true;
@@ -481,10 +457,10 @@ export var Utils;
      * @param objNew New object
      * @param objPre Previous object
      * @param ignoreFields Ignored fields
-     * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+     * @param isStrict Strict or not, false: loose equal, undefined === but null equal undefined, NaN equal NaN, true: strict equal
      * @returns Updated fields
      */
-    function objectUpdated(objNew, objPrev, ignoreFields = [], strict = 1) {
+    function objectUpdated(objNew, objPrev, ignoreFields = [], isStrict) {
         // Fields
         const fields = [];
         // Unique keys
@@ -493,7 +469,7 @@ export var Utils;
             // Values
             const vNew = Reflect.get(objNew, key);
             const vPrev = Reflect.get(objPrev, key);
-            if (!Utils.equals(vNew, vPrev, strict)) {
+            if (!DataTypes.isDeepEqual(vNew, vPrev, isStrict)) {
                 fields.push(key);
             }
         }

package/lib/mjs/index.d.ts

@@ -6,8 +6,11 @@ export * from "./types/EHistory";
 export * from "./types/ErrorData";
 export * from "./types/EventClass";
 export * from "./types/FormData";
+export * from "./node/NodeStorage";
 export * from "./storage/IStorage";
 export * from "./storage/WindowStorage";
+export * from "./test/MockDOMRect";
+export * from "./test/MockResizeObserver";
 export * from "./ActionResult";
 export * from "./ArrayUtils";
 export * from "./DataTypes";

package/lib/mjs/index.js

@@ -6,8 +6,11 @@ export * from "./types/EHistory";
 export * from "./types/ErrorData";
 export * from "./types/EventClass";
 export * from "./types/FormData";
+export * from "./node/NodeStorage";
 export * from "./storage/IStorage";
 export * from "./storage/WindowStorage";
+export * from "./test/MockDOMRect";
+export * from "./test/MockResizeObserver";
 export * from "./ActionResult";
 export * from "./ArrayUtils";
 export * from "./DataTypes";

package/lib/mjs/node/{Storage.d.ts → NodeStorage.d.ts}

@@ -2,7 +2,7 @@
  * Node storage
  * Please take care of the persistence with source property
  */
-export declare class NodeStorage {
+export declare class NodeStorage implements Storage {
     /**
      * Storage source
      */

package/lib/mjs/test/MockDOMRect.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A mock implementation of DOMRect for testing purposes
+ */
+export declare class MockDOMRect implements DOMRect {
+    readonly bottom: number;
+    readonly height: number;
+    readonly left: number;
+    readonly right: number;
+    readonly top: number;
+    readonly width: number;
+    readonly x: number;
+    readonly y: number;
+    toJSON(): any;
+    constructor(width: number, height: number, x?: number, y?: number);
+}

package/lib/mjs/test/MockDOMRect.js

@@ -0,0 +1,27 @@
+/**
+ * A mock implementation of DOMRect for testing purposes
+ */
+export class MockDOMRect {
+    toJSON() {
+        return JSON.stringify({
+            bottom: this.bottom,
+            height: this.height,
+            left: this.left,
+            right: this.right,
+            top: this.top,
+            width: this.width,
+            x: this.x,
+            y: this.y
+        });
+    }
+    constructor(width, height, x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+        this.left = x;
+        this.top = y;
+        this.bottom = this.top + this.height;
+        this.right = this.left = this.width;
+    }
+}

package/lib/mjs/test/MockResizeObserver.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Mock implementation of ResizeObserver for testing purposes
+ */
+export declare class MockResizeObserver implements ResizeObserver {
+    callbacks: Function[];
+    elements: Element[];
+    constructor(callback: Function);
+    observe(element: Element): void;
+    unobserve(element: Element): void;
+    disconnect(): void;
+    trigger(entries: ResizeObserverEntry[]): void;
+}

package/lib/mjs/test/MockResizeObserver.js

@@ -0,0 +1,23 @@
+/**
+ * Mock implementation of ResizeObserver for testing purposes
+ */
+export class MockResizeObserver {
+    constructor(callback) {
+        this.callbacks = [];
+        this.elements = [];
+        this.callbacks.push(callback);
+    }
+    observe(element) {
+        this.elements.push(element);
+    }
+    unobserve(element) {
+        this.elements = this.elements.filter((el) => el !== element);
+    }
+    disconnect() {
+        this.elements = [];
+    }
+    // Helper to trigger the callback manually in tests
+    trigger(entries) {
+        this.callbacks.forEach((cb) => cb(entries));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etsoo/shared",
-  "version": "1.2.76",
+  "version": "1.2.79",
   "description": "TypeScript shared utilities and functions",
   "main": "lib/cjs/index.js",
   "module": "lib/mjs/index.js",
@@ -36,14 +36,10 @@
   },
   "homepage": "https://github.com/ETSOO/Shared#readme",
   "devDependencies": {
-    "@types/lodash.isequal": "^4.5.8",
-    "@types/node": "^24.3.3",
-    "@vitejs/plugin-react": "^5.0.2",
-    "jsdom": "^27.0.0",
-    "typescript": "^5.9.2",
-    "vitest": "^3.2.4"
-  },
-  "dependencies": {
-    "lodash.isequal": "^4.5.0"
+    "@types/node": "^24.10.0",
+    "@vitejs/plugin-react": "^5.1.0",
+    "jsdom": "^27.1.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.7"
   }
 }

package/src/ArrayUtils.ts

@@ -1,5 +1,4 @@
-import isEqual from "lodash.isequal";
-import { DataTypes, IdType } from "./DataTypes";
+import { DataTypes } from "./DataTypes";
 
 declare global {
   interface Array<T> {
@@ -127,7 +126,7 @@ Array.prototype.toggleItem = function <
         return i[idField as keyof T] === item;
       }
     }
-    return isEqual(i, item);
+    return DataTypes.isDeepEqual(i, item);
   });
 
   if (add) {
@@ -149,7 +148,8 @@ Array.prototype.toUnique = function <T>(this: Array<T>) {
 
   const newArray: T[] = [];
   this.forEach((item) => {
-    if (newArray.some((newItem) => isEqual(item, newItem))) return;
+    if (newArray.some((newItem) => DataTypes.isDeepEqual(item, newItem)))
+      return;
     newArray.push(item);
   });
   return newArray;

package/src/DataTypes.ts

@@ -741,6 +741,70 @@ export namespace DataTypes {
     return BasicArray.includes(<BasicNames>name);
   }
 
+  /**
+   * Check deep equality
+   * @param a Input a
+   * @param b Input b
+   * @param isStrict Strict or not, false: loose equal, undefined === but null equal undefined, NaN equal NaN, true: strict equal
+   * @returns Result
+   */
+  export function isDeepEqual(
+    a: unknown,
+    b: unknown,
+    isStrict?: boolean
+  ): boolean {
+    // Same object or value
+    if (a === b) return true;
+
+    // Null and undefined case
+    if (a == null || b == null) {
+      if (!isStrict && a == b) return true;
+      return a === b;
+    } else if (isStrict === false) {
+      // Loose equal case
+      if (a == b) return true;
+    }
+
+    // Different type
+    if (typeof a !== typeof b) return false;
+
+    // NaN case
+    if (Number.isNaN(a) && Number.isNaN(b) && !isStrict) return true;
+
+    if (typeof a === "object") {
+      // Date
+      if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+      }
+
+      // Array
+      if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) return false;
+
+        for (let i = 0; i < a.length; i++) {
+          if (!isDeepEqual(a[i], b[i], isStrict)) return false;
+        }
+
+        return true;
+      }
+
+      // Loop object keys
+      const aKeys = Object.keys(a);
+      const bKeys = Object.keys(b);
+      if (aKeys.length !== bKeys.length && isStrict) return false;
+
+      const allKeys = new Set<string>([...aKeys, ...bKeys]);
+      for (const key of allKeys) {
+        if (!isDeepEqual(Reflect.get(a, key), Reflect.get(b, key), isStrict))
+          return false;
+      }
+
+      return true;
+    }
+
+    return isStrict ? a === b : a == b;
+  }
+
   /**
    * Is the target a simple object (Type guard)
    * @param input Test data

package/src/StorageUtils.ts

@@ -1,4 +1,4 @@
-import { NodeStorage } from "./node/Storage";
+import { NodeStorage } from "./node/NodeStorage";
 import { Utils } from "./Utils";
 
 // Mock node

package/src/Utils.ts

@@ -1,5 +1,4 @@
 import { DataTypes, IdType } from "./DataTypes";
-import isEqual from "lodash.isequal";
 import { DateUtils } from "./DateUtils";
 import { ParsedPath } from "./types/ParsedPath";
 
@@ -326,29 +325,6 @@ export namespace Utils {
     }
   }
 
-  /**
-   * Two values equal
-   * @param v1 Value 1
-   * @param v2 Value 2
-   * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
-   */
-  export function equals(v1: unknown, v2: unknown, strict = 1) {
-    // Null and undefined case
-    if (v1 == null || v2 == null) {
-      if (strict <= 1 && v1 == v2) return true;
-      return v1 === v2;
-    }
-
-    // For date, array and object
-    if (typeof v1 === "object") return isEqual(v1, v2);
-
-    // 1 and '1' case
-    if (strict === 0) return v1 == v2;
-
-    // Strict equal
-    return v1 === v2;
-  }
-
   /**
    * Exclude specific items
    * @param items Items
@@ -454,7 +430,7 @@ export namespace Utils {
         }
 
         const newValue = DataTypes.convert(value, initValue);
-        if (Utils.equals(newValue, initValue)) {
+        if (DataTypes.isDeepEqual(newValue, initValue)) {
           Reflect.deleteProperty(input, key);
           return;
         }
@@ -636,14 +612,14 @@ export namespace Utils {
    * @param obj1 Object 1
    * @param obj2 Object 2
    * @param ignoreFields Ignored fields
-   * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+   * @param isStrict Strict or not, false: loose equal, undefined === but null equal undefined, NaN equal NaN, true: strict equal
    * @returns Result
    */
   export function objectEqual(
     obj1: object,
     obj2: object,
     ignoreFields: string[] = [],
-    strict = 1
+    isStrict?: boolean
   ) {
     // Unique keys
     const keys = Utils.objectKeys(obj1, obj2, ignoreFields);
@@ -653,7 +629,7 @@ export namespace Utils {
       const v1 = Reflect.get(obj1, key);
       const v2 = Reflect.get(obj2, key);
 
-      if (!Utils.equals(v1, v2, strict)) return false;
+      if (!DataTypes.isDeepEqual(v1, v2, isStrict)) return false;
     }
 
     return true;
@@ -685,14 +661,14 @@ export namespace Utils {
    * @param objNew New object
    * @param objPre Previous object
    * @param ignoreFields Ignored fields
-   * @param strict Strict level, 0 with ==, 1 === but null equal undefined, 2 ===
+   * @param isStrict Strict or not, false: loose equal, undefined === but null equal undefined, NaN equal NaN, true: strict equal
    * @returns Updated fields
    */
   export function objectUpdated(
     objNew: object,
     objPrev: object,
     ignoreFields: string[] = [],
-    strict = 1
+    isStrict?: boolean
   ) {
     // Fields
     const fields: string[] = [];
@@ -705,7 +681,7 @@ export namespace Utils {
       const vNew = Reflect.get(objNew, key);
       const vPrev = Reflect.get(objPrev, key);
 
-      if (!Utils.equals(vNew, vPrev, strict)) {
+      if (!DataTypes.isDeepEqual(vNew, vPrev, isStrict)) {
         fields.push(key);
       }
     }

package/src/index.ts

@@ -7,9 +7,14 @@ export * from "./types/ErrorData";
 export * from "./types/EventClass";
 export * from "./types/FormData";
 
+export * from "./node/NodeStorage";
+
 export * from "./storage/IStorage";
 export * from "./storage/WindowStorage";
 
+export * from "./test/MockDOMRect";
+export * from "./test/MockResizeObserver";
+
 export * from "./ActionResult";
 export * from "./ArrayUtils";
 export * from "./DataTypes";

package/src/node/{Storage.ts → NodeStorage.ts}

@@ -2,7 +2,7 @@
  * Node storage
  * Please take care of the persistence with source property
  */
-export class NodeStorage {
+export class NodeStorage implements Storage {
   /**
    * Storage source
    */