fast-is-equal 1.0.2 → 1.0.4

package/README.md

@@ -1,6 +1,8 @@
 # fast-is-equal
 
-Blazing-fast equality checks, minus the baggage. A lean, standalone alternative to Lodash’s `isEqual`—because speed matters.
+Blazing-fast equality checks, minus the baggage. A lean, standalone alternative to Lodash’s `isEqual` - because speed matters.
+
+[![npm version](https://img.shields.io/npm/v/fast-is-equal)](https://badge.fury.io/js/fast-is-equal)
 
 ## Installation
 
@@ -174,4 +176,4 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-```
+```

package/dist/__tests__/fastIsEqual.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("../index");
-describe('isEqual', () => {
+describe('fastIsEqual', () => {
     // **Primitives**
     it('should return true for identical primitives', () => {
         expect((0, index_1.fastIsEqual)(1, 1)).toBe(true);
@@ -37,6 +37,21 @@ describe('isEqual', () => {
         const obj2 = { a: 1, b: { c: 2 } };
         expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
     });
+    it('should return true for deeply unequal objects', () => {
+        const obj1 = { a: 1, b: { c: 2 } };
+        const obj2 = { a: 1, b: { c: 3 } };
+        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(false);
+    });
+    it('should return true for deeply equal objects with array', () => {
+        const obj1 = { a: 1, b: { c: [1, 2, 3] } };
+        const obj2 = { a: 1, b: { c: [1, 2, 3] } };
+        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
+    });
+    it('should return true for deeply unequal objects with array', () => {
+        const obj1 = { a: 1, b: { c: [1, 2, 3] } };
+        const obj2 = { a: 1, b: { c: [1, 2, 3, 4] } };
+        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(false);
+    });
     it('should return false for objects with different keys', () => {
         const obj1 = { a: 1 };
         const obj2 = { b: 1 };
@@ -67,6 +82,11 @@ describe('isEqual', () => {
         const arr2 = [1, 3];
         expect((0, index_1.fastIsEqual)(arr1, arr2)).toBe(false);
     });
+    it('should return true for arrays with different order', () => {
+        const arr1 = [1, 2, 3, 4];
+        const arr2 = [1, 2, 4, 3];
+        expect((0, index_1.fastIsEqual)(arr1, arr2)).toBe(false);
+    });
     // **Dates**
     it('should return true for identical dates', () => {
         const date = new Date();
@@ -177,4 +197,137 @@ describe('isEqual', () => {
         expect((0, index_1.fastIsEqual)({}, [])).toBe(false);
         expect((0, index_1.fastIsEqual)(new Map(), new Set())).toBe(false);
     });
+    // **Symbol Tests**
+    it('should return true for identical symbols', () => {
+        const sym = Symbol('test');
+        expect((0, index_1.fastIsEqual)(sym, sym)).toBe(true);
+    });
+    it('should return false for different symbols with same description', () => {
+        expect((0, index_1.fastIsEqual)(Symbol('test'), Symbol('test'))).toBe(false);
+    });
+    // **BigInt Tests**
+    it('should return true for identical BigInts', () => {
+        expect((0, index_1.fastIsEqual)(BigInt(123), BigInt(123))).toBe(true);
+    });
+    it('should return false for different BigInts', () => {
+        expect((0, index_1.fastIsEqual)(BigInt(123), BigInt(456))).toBe(false);
+    });
+    // **Nested Complex Structures**
+    it('should handle deeply nested objects with arrays, maps and sets', () => {
+        const obj1 = {
+            a: [1, 2, { b: new Map([['key', new Set([1, 2, { c: 3 }])]]) }],
+            d: new Set([new Map([['e', { f: 7 }]])])
+        };
+        const obj2 = {
+            a: [1, 2, { b: new Map([['key', new Set([1, 2, { c: 3 }])]]) }],
+            d: new Set([new Map([['e', { f: 7 }]])])
+        };
+        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
+    });
+    it('should detect differences in deeply nested structures', () => {
+        const obj1 = {
+            a: [1, 2, { b: new Map([['key', new Set([1, 2, { c: 3 }])]]) }]
+        };
+        const obj2 = {
+            a: [1, 2, { b: new Map([['key', new Set([1, 2, { c: 4 }])]]) }]
+        };
+        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(false);
+    });
+    // **Typed Arrays**
+    it('should compare typed arrays correctly', () => {
+        expect((0, index_1.fastIsEqual)(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]))).toBe(true);
+        expect((0, index_1.fastIsEqual)(new Int32Array([1, 2, 3]), new Int32Array([1, 2, 3]))).toBe(true);
+        expect((0, index_1.fastIsEqual)(new Float64Array([1.1, 2.2]), new Float64Array([1.1, 2.2]))).toBe(true);
+        expect((0, index_1.fastIsEqual)(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 4]))).toBe(false);
+        expect((0, index_1.fastIsEqual)(new Uint8Array([1, 2]), new Int8Array([1, 2]))).toBe(false);
+    });
+    // **Partial Object Comparison with Extra Keys**
+    it('should detect when objects have extra keys', () => {
+        const obj1 = { a: 1, b: 2 };
+        const obj2 = { a: 1, b: 2, c: 3 };
+        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(false);
+    });
+    // **Object with Different Property Orders**
+    it('should return true for objects with same properties in different order', () => {
+        const obj1 = { a: 1, b: 2, c: 3 };
+        const obj2 = { c: 3, a: 1, b: 2 };
+        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
+    });
+    // **Map/Set with Object Keys/Values**
+    it('should handle Maps with object keys correctly', () => {
+        const key1 = { id: 1 };
+        const key2 = { id: 1 };
+        const map1 = new Map([[key1, 'value']]);
+        const map2 = new Map([[key2, 'value']]);
+        // Objects as keys are compared by reference
+        expect((0, index_1.fastIsEqual)(map1, map2)).toBe(false);
+        // Same reference should work
+        const map3 = new Map([[key1, 'value']]);
+        expect((0, index_1.fastIsEqual)(map1, map3)).toBe(true);
+    });
+    // **WeakMap and WeakSet** (if supported by fastIsEqual)
+    it('should return true for identical WeakMap/WeakSet references', () => {
+        const weakMap = new WeakMap();
+        const weakSet = new WeakSet();
+        expect((0, index_1.fastIsEqual)(weakMap, weakMap)).toBe(true);
+        expect((0, index_1.fastIsEqual)(weakSet, weakSet)).toBe(true);
+    });
+    it('should return false for different WeakMap/WeakSet instances', () => {
+        expect((0, index_1.fastIsEqual)(new WeakMap(), new WeakMap())).toBe(false);
+        expect((0, index_1.fastIsEqual)(new WeakSet(), new WeakSet())).toBe(false);
+    });
+    // **Cross-circular References**
+    it('should handle cross-circular references', () => {
+        const obj1 = { name: 'object1' };
+        const obj2 = { name: 'object2' };
+        obj1.ref = obj2;
+        obj2.ref = obj1;
+        const obj3 = { name: 'object1' };
+        const obj4 = { name: 'object2' };
+        obj3.ref = obj4;
+        obj4.ref = obj3;
+        expect((0, index_1.fastIsEqual)(obj1, obj3)).toBe(true);
+    });
+    it('should detect differences in cross-circular references', () => {
+        const obj1 = { name: 'object1' };
+        const obj2 = { name: 'object2' };
+        obj1.ref = obj2;
+        obj2.ref = obj1;
+        const obj3 = { name: 'object1' };
+        const obj4 = { name: 'differentName' };
+        obj3.ref = obj4;
+        obj4.ref = obj3;
+        expect((0, index_1.fastIsEqual)(obj1, obj3)).toBe(false);
+    });
+    // **Edge Cases**
+    it('should handle -0 and +0 comparison', () => {
+        expect((0, index_1.fastIsEqual)(0, -0)).toBe(true); // Depending on implementation
+    });
+    it('should handle Object.create(null)', () => {
+        const obj1 = Object.create(null);
+        obj1.a = 1;
+        const obj2 = Object.create(null);
+        obj2.a = 1;
+        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
+    });
+    // **Performance Stress Test**
+    it('should handle large objects without stack overflow', () => {
+        // Create a very deep object
+        let obj1 = {};
+        let obj2 = {};
+        let temp1 = obj1;
+        let temp2 = obj2;
+        for (let i = 0; i < 1000; i++) {
+            temp1.next = {};
+            temp2.next = {};
+            temp1 = temp1.next;
+            temp2 = temp2.next;
+            temp1.value = i;
+            temp2.value = i;
+        }
+        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(true);
+        // Change a value deep in the structure
+        temp2.value = 'different';
+        expect((0, index_1.fastIsEqual)(obj1, obj2)).toBe(false);
+    });
 });

package/dist/index.js

@@ -52,6 +52,13 @@ function deepEqual(valA, valB, visited) {
         return valA === valB;
     if (typeof valA !== typeof valB)
         return false;
+    // Handle WeakMap and WeakSet (reference equality)
+    if (valA instanceof WeakMap && valB instanceof WeakMap) {
+        return valA === valB;
+    }
+    if (valA instanceof WeakSet && valB instanceof WeakSet) {
+        return valA === valB;
+    }
     // Handle Dates
     if (valA instanceof Date && valB instanceof Date) {
         return valA.getTime() === valB.getTime();
@@ -96,12 +103,23 @@ function deepEqual(valA, valB, visited) {
         }
         return true;
     }
-    // Handle Sets
+    // Handle Sets with deep equality
     if (valA instanceof Set && valB instanceof Set) {
         if (valA.size !== valB.size)
             return false;
-        for (const value of valA) {
-            if (!valB.has(value))
+        const arrA = Array.from(valA);
+        const arrB = Array.from(valB);
+        const matched = new Set();
+        for (const elemA of arrA) {
+            let found = false;
+            for (const elemB of arrB) {
+                if (!matched.has(elemB) && deepEqual(elemA, elemB, visited)) {
+                    matched.add(elemB);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
                 return false;
         }
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-is-equal",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Blazing-fast equality checks, minus the baggage. A lean, standalone alternative to Lodash's isEqual—because speed matters.",
   "keywords": [
     "lodash",
@@ -40,5 +40,19 @@
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "typescript": "^5.8.2"
-  }
+  },
+  "funding": [
+    {
+      "type": "individual",
+      "url": "https://www.paypal.com/paypalme/jairajjangle001/usd"
+    },
+    {
+      "type": "individual",
+      "url": "https://liberapay.com/FutureJJ/donate"
+    },
+    {
+      "type": "individual",
+      "url": "https://ko-fi.com/futurejj"
+    }
+  ]
 }