@etsoo/shared 1.2.76 → 1.2.78

package/.github/workflows/main.yml

@@ -23,13 +23,13 @@ jobs:
     steps:
       # https://github.com/actions/checkout, This action checks-out your repository under $GITHUB_WORKSPACE
       # so your workflow can access it.
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       # Set up your GitHub Actions workflow with a specific version of node.js
       # Setup .npmrc file to publish to npm
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v6
         with:
-          node-version: "latest"
+          node-version: "24.11" # latest
           registry-url: "https://registry.npmjs.org"
 
       # Named after Continuous Integration, installs dependencies directly from package-lock.json

package/README.md

@@ -302,7 +302,6 @@ String and other related utilities
 |      charsToNumber | Base64 chars to number                                              |
 |     containChinese | Check the input string contains Chinese character or not            |
 |       correctTypes | Correct object's property value type                                |
-|             equals | Two values equal                                                    |
 |            exclude | Exclude specific items                                              |
 |       excludeAsync | Async exclude specific items                                        |
 |      formatInitial | Format inital character to lower case or upper case                 |

package/__tests__/DataTypes.ts

@@ -272,3 +272,193 @@ test("Tests for BasicTemplate", () => {
 
   expect(data.id).toBe(1);
 });
+
+test("Tests for isDeepEqual - Primitive values", () => {
+  // Same values
+  expect(DataTypes.isDeepEqual(1, 1)).toBeTruthy();
+  expect(DataTypes.isDeepEqual("hello", "hello")).toBeTruthy();
+  expect(DataTypes.isDeepEqual(true, true)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(false, false)).toBeTruthy();
+
+  // Different values
+  expect(DataTypes.isDeepEqual(1, 2)).toBeFalsy();
+  expect(DataTypes.isDeepEqual("hello", "world")).toBeFalsy();
+  expect(DataTypes.isDeepEqual(true, false)).toBeFalsy();
+
+  // Different types
+  expect(DataTypes.isDeepEqual(1, "1")).toBeFalsy();
+  expect(DataTypes.isDeepEqual(true, 1)).toBeFalsy();
+  expect(DataTypes.isDeepEqual(null, undefined)).toBeTruthy(); // Default strict=1
+});
+
+test("Tests for isDeepEqual - Null and undefined", () => {
+  // strict = undefined (default): null == undefined
+  expect(DataTypes.isDeepEqual(null, null)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(undefined, undefined)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(null, undefined)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(undefined, null)).toBeTruthy();
+
+  // strict = 2: null !== undefined
+  expect(DataTypes.isDeepEqual(null, null, true)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(undefined, undefined, true)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(null, undefined, true)).toBeFalsy();
+  expect(DataTypes.isDeepEqual(undefined, null, true)).toBeFalsy();
+
+  // With non-null values
+  expect(DataTypes.isDeepEqual(null, 0)).toBeFalsy();
+  expect(DataTypes.isDeepEqual(undefined, "")).toBeFalsy();
+});
+
+test("Tests for isDeepEqual - Loose equality (strict=0)", () => {
+  // Loose equal cases
+  expect(DataTypes.isDeepEqual(1, "1", false)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(0, false, false)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(1, true, false)).toBeTruthy();
+  expect(DataTypes.isDeepEqual("", false, false)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(null, undefined, false)).toBeTruthy();
+
+  // Still not equal
+  expect(DataTypes.isDeepEqual(1, 2, false)).toBeFalsy();
+  expect(DataTypes.isDeepEqual("hello", "world", false)).toBeFalsy();
+});
+
+test("Tests for isDeepEqual - BigInt values", () => {
+  expect(DataTypes.isDeepEqual(123n, 123n)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(123n, 456n)).toBeFalsy();
+  expect(DataTypes.isDeepEqual(123n, 123)).toBeFalsy();
+});
+
+test("Tests for isDeepEqual - Date objects", () => {
+  const date1 = new Date("2023-01-01");
+  const date2 = new Date("2023-01-01");
+  const date3 = new Date("2023-01-02");
+
+  expect(DataTypes.isDeepEqual(date1, date1)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(date1, date2)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(date1, date3)).toBeFalsy();
+});
+
+test("Tests for isDeepEqual - Arrays", () => {
+  const arr1 = [1, 2, 3];
+  expect(DataTypes.isDeepEqual(arr1, arr1)).toBeTruthy();
+
+  // Different references, same content
+  expect(DataTypes.isDeepEqual([1, 2, 3], [1, 2, 3])).toBeTruthy();
+  expect(DataTypes.isDeepEqual([], [])).toBeTruthy();
+
+  // Different content
+  expect(DataTypes.isDeepEqual([1, 2, 3], [1, 2, 4])).toBeFalsy();
+  expect(DataTypes.isDeepEqual([1, 2], [1, 2, 3])).toBeFalsy();
+
+  // Nested arrays
+  expect(
+    DataTypes.isDeepEqual(
+      [
+        [1, 2],
+        [3, 4]
+      ],
+      [
+        [1, 2],
+        [3, 4]
+      ]
+    )
+  ).toBeTruthy();
+  expect(
+    DataTypes.isDeepEqual(
+      [
+        [1, 2],
+        [3, 4]
+      ],
+      [
+        [1, 2],
+        [3, 5]
+      ]
+    )
+  ).toBeFalsy();
+});
+
+test("Tests for isDeepEqual - Objects", () => {
+  // Same reference
+  const obj1 = { a: 1, b: 2 };
+  expect(DataTypes.isDeepEqual(obj1, obj1)).toBeTruthy();
+
+  // Different references, same content
+  expect(DataTypes.isDeepEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBeTruthy();
+  expect(DataTypes.isDeepEqual({}, {})).toBeTruthy();
+
+  // Different content
+  expect(DataTypes.isDeepEqual({ a: 1, b: 2 }, { a: 1, b: 3 })).toBeFalsy();
+  expect(DataTypes.isDeepEqual({ a: 1 }, { a: 1, b: 2 })).toBeFalsy();
+
+  expect(
+    DataTypes.isDeepEqual({ a: 1, b: "2" }, { a: 1, b: 2 }, false)
+  ).toBeTruthy();
+  expect(DataTypes.isDeepEqual({ a: 1 }, { a: 1, b: null })).toBeTruthy();
+  expect(
+    DataTypes.isDeepEqual({ a: 1, c: true }, { a: 1, b: null })
+  ).toBeFalsy();
+  expect(DataTypes.isDeepEqual({ a: 1 }, { a: 1, b: null }, true)).toBeFalsy();
+
+  // Nested objects
+  expect(
+    DataTypes.isDeepEqual(
+      { a: { x: 1, y: 2 }, b: 3 },
+      { a: { x: 1, y: 2 }, b: 3 }
+    )
+  ).toBeTruthy();
+
+  expect(
+    DataTypes.isDeepEqual(
+      { a: { x: 1, y: 2 }, b: 3 },
+      { a: { x: 1, y: 3 }, b: 3 }
+    )
+  ).toBeFalsy();
+});
+
+test("Tests for isDeepEqual - Mixed complex types", () => {
+  // Arrays with objects
+  expect(
+    DataTypes.isDeepEqual(
+      [
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" }
+      ],
+      [
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" }
+      ]
+    )
+  ).toBeTruthy();
+
+  // Objects with arrays
+  expect(
+    DataTypes.isDeepEqual(
+      { users: [1, 2, 3], active: true },
+      { users: [1, 2, 3], active: true }
+    )
+  ).toBeTruthy();
+
+  // Objects with different property order
+  expect(DataTypes.isDeepEqual({ a: 1, b: 2 }, { b: 2, a: 1 })).toBeTruthy();
+});
+
+test("Tests for isDeepEqual - Edge cases", () => {
+  // Functions - should not be equal unless same reference
+  const func1 = () => {};
+  const func2 = () => {};
+  expect(DataTypes.isDeepEqual(func1, func1)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(func1, func2)).toBeFalsy();
+
+  // NaN values
+  // NaN === NaN is false, but they should be considered equal
+  expect(DataTypes.isDeepEqual(NaN, NaN)).toBeTruthy();
+
+  // Infinity
+  expect(DataTypes.isDeepEqual(Infinity, Infinity)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(-Infinity, -Infinity)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(Infinity, -Infinity)).toBeFalsy();
+
+  // Zero variants
+  expect(DataTypes.isDeepEqual(0, -0)).toBeTruthy();
+  expect(DataTypes.isDeepEqual(+0, -0)).toBeTruthy();
+});

package/__tests__/DomUtils.ts

@@ -1,44 +1,9 @@
 import { DomUtils } from "../src/DomUtils";
 import { DataTypes } from "../src/DataTypes";
 import { DateUtils } from "../src/DateUtils";
+import { MockDOMRect } from "../src/test/MockDOMRect";
 import { ErrorData } from "../src/types/ErrorData";
 
-// Implement for tests
-class Rect 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 {
-    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: number, height: number, x: number = 0, y: number = 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;
-  }
-}
-
 describe("Tests for clearFormData", () => {
   // Applies only to tests in this describe block
   // Arrange
@@ -110,8 +75,8 @@ test("Tests for mergeFormData", () => {
 });
 
 test("Tests for dimensionEqual", () => {
-  const rect1: DOMRect = new Rect(200, 300);
-  const rect2: DOMRect = new Rect(100, 200);
+  const rect1: DOMRect = new MockDOMRect(200, 300);
+  const rect2: DOMRect = new MockDOMRect(100, 200);
   expect(DomUtils.dimensionEqual(undefined, undefined)).toBeTruthy();
   expect(DomUtils.dimensionEqual(rect1, undefined)).toBeFalsy();
   expect(DomUtils.dimensionEqual(rect1, rect2)).toBeFalsy();

package/__tests__/Utils.ts

@@ -53,7 +53,7 @@ describe("Tests for addUrlParams", () => {
     );
   });
 
-  global.URL = undefined as any;
+  globalThis.URL = undefined as any;
 
   const result3 = url.addUrlParams(data);
 
@@ -275,9 +275,9 @@ test("Tests for objectEqual", () => {
   const obj1 = { a: 1, b: "abc", c: true, d: null, f: [1, 2] };
   const obj2 = { a: "1", b: "abc", c: true, f: [1, 2] };
   expect(Utils.objectEqual(obj1, obj2)).toBeFalsy();
-  expect(Utils.objectEqual(obj1, obj2, [], 0)).toBeTruthy();
+  expect(Utils.objectEqual(obj1, obj2, [], false)).toBeTruthy();
   expect(Utils.objectEqual(obj1, obj2, ["a"])).toBeTruthy();
-  expect(Utils.objectEqual(obj1, obj2, ["a"], 2)).toBeFalsy();
+  expect(Utils.objectEqual(obj1, obj2, ["a"], true)).toBeFalsy();
 });
 
 test("Tests for parseJsonArray", () => {

package/lib/cjs/ArrayUtils.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayUtils = void 0;
-const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
+const DataTypes_1 = require("./DataTypes");
 Array.prototype.different = function (target, round) {
     return ArrayUtils.differences(this, target, round);
 };
@@ -19,7 +16,7 @@ Array.prototype.toggleItem = function (item, add, idField) {
                 return i[idField] === item;
             }
         }
-        return (0, lodash_isequal_1.default)(i, item);
+        return DataTypes_1.DataTypes.isDeepEqual(i, item);
     });
     if (add) {
         if (index < 0) {
@@ -39,7 +36,7 @@ Array.prototype.toUnique = function () {
         return Array.from(new Set(this));
     const newArray = [];
     this.forEach((item) => {
-        if (newArray.some((newItem) => (0, lodash_isequal_1.default)(item, newItem)))
+        if (newArray.some((newItem) => DataTypes_1.DataTypes.isDeepEqual(item, newItem)))
             return;
         newArray.push(item);
     });

package/lib/cjs/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/cjs/DataTypes.js

@@ -455,6 +455,64 @@ 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/cjs/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/cjs/Utils.js

@@ -1,11 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Utils = void 0;
 const DataTypes_1 = require("./DataTypes");
-const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
 const DateUtils_1 = require("./DateUtils");
 String.prototype.addUrlParam = function (name, value, arrayFormat) {
     return this.addUrlParams({ [name]: value }, arrayFormat);
@@ -186,29 +182,6 @@ 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 (0, lodash_isequal_1.default)(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
@@ -287,7 +260,7 @@ var Utils;
                     return;
                 }
                 const newValue = DataTypes_1.DataTypes.convert(value, initValue);
-                if (Utils.equals(newValue, initValue)) {
+                if (DataTypes_1.DataTypes.isDeepEqual(newValue, initValue)) {
                     Reflect.deleteProperty(input, key);
                     return;
                 }
@@ -452,17 +425,17 @@ 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_1.DataTypes.isDeepEqual(v1, v2, isStrict))
                 return false;
         }
         return true;
@@ -487,10 +460,10 @@ 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
@@ -499,7 +472,7 @@ var Utils;
             // Values
             const vNew = Reflect.get(objNew, key);
             const vPrev = Reflect.get(objPrev, key);
-            if (!Utils.equals(vNew, vPrev, strict)) {
+            if (!DataTypes_1.DataTypes.isDeepEqual(vNew, vPrev, isStrict)) {
                 fields.push(key);
             }
         }

package/lib/cjs/index.d.ts

@@ -8,6 +8,8 @@ export * from "./types/EventClass";
 export * from "./types/FormData";
 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/cjs/index.js

@@ -24,6 +24,8 @@ __exportStar(require("./types/EventClass"), exports);
 __exportStar(require("./types/FormData"), exports);
 __exportStar(require("./storage/IStorage"), exports);
 __exportStar(require("./storage/WindowStorage"), exports);
+__exportStar(require("./test/MockDOMRect"), exports);
+__exportStar(require("./test/MockResizeObserver"), exports);
 __exportStar(require("./ActionResult"), exports);
 __exportStar(require("./ArrayUtils"), exports);
 __exportStar(require("./DataTypes"), exports);

package/lib/cjs/node/Storage.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/cjs/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/cjs/test/MockDOMRect.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDOMRect = void 0;
+/**
+ * A mock implementation of DOMRect for testing purposes
+ */
+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;
+    }
+}
+exports.MockDOMRect = MockDOMRect;

package/lib/cjs/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/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;