@guanghechen/equal 2.0.1 → 2.0.3

package/CHANGELOG.md

@@ -1,8 +1,41 @@
 # Change Log
 
+## 2.0.3
+
+### Patch Changes
+
+- Fix deep equality for Map, Set, typed arrays, DataView/ArrayBuffer, and null-prototype objects.
+
+## 2.0.2
+
+### Patch Changes
+
+- chore: vitest config auto-load aliases and coverage thresholds; style/doc formatting updates
+
 All notable changes to this project will be documented in this file. See
 [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 2.0.1 (2025-02-07)
+
+### Improvements
+
+- Clean up build configs and standardize package exports
+
+### Documentation
+
+- Update README.md
+
+### Miscellaneous
+
+- Add LICENSE file
+- Migrate from lerna to changesets
+
+## 2.0.0 (2025-01-15)
+
+### Improvements
+
+- Switch to recommended ESLint stack
+
 ## 1.0.0-alpha.7 (2024-09-18)
 
 - :wrench: chore: upgrade devDependencies and fix configs

package/README.md

@@ -114,6 +114,18 @@ isEqual(/abc/g, /abc/i)    // false
 // Date
 isEqual(new Date('2024-01-01'), new Date('2024-01-01'))  // true
 
+// Map (keys matched by identity, values compared deeply)
+isEqual(new Map([['a', 1]]), new Map([['a', 1]]))  // true
+isEqual(new Map([['a', 1]]), new Map([['a', 2]]))  // false
+
+// Set (elements matched by identity)
+isEqual(new Set([1, 2, 3]), new Set([3, 2, 1]))  // true
+isEqual(new Set([1, 2]), new Set([1, 2, 3]))     // false
+
+// Typed arrays (element-wise)
+isEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]))  // true
+isEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 4]))  // false
+
 // Custom valueOf/toString
 class Point {
   constructor(public x: number, public y: number) {}

package/lib/cjs/index.cjs

@@ -23,12 +23,69 @@ function isEqual(x, y) {
             }
             return true;
         }
+        if (x instanceof Map) {
+            if (x.size !== y.size)
+                return false;
+            for (const [key, value] of x) {
+                if (!y.has(key) || !isEqual(value, y.get(key)))
+                    return false;
+            }
+            return true;
+        }
+        if (x instanceof Set) {
+            if (x.size !== y.size)
+                return false;
+            for (const value of x) {
+                if (!y.has(value))
+                    return false;
+            }
+            return true;
+        }
+        if (ArrayBuffer.isView(x)) {
+            if (x instanceof DataView) {
+                if (x.byteLength !== y.byteLength)
+                    return false;
+                for (let i = 0; i < x.byteLength; ++i) {
+                    if (x.getUint8(i) !== y.getUint8(i))
+                        return false;
+                }
+                return true;
+            }
+            const lhs = x;
+            const rhs = y;
+            if (lhs.length !== rhs.length)
+                return false;
+            for (let i = 0; i < lhs.length; ++i) {
+                if (!Object.is(lhs[i], rhs[i]))
+                    return false;
+            }
+            return true;
+        }
+        if (x instanceof ArrayBuffer) {
+            if (x.byteLength !== y.byteLength)
+                return false;
+            if (x.byteLength === 0)
+                return true;
+            const lhs = new Uint8Array(x);
+            const rhs = new Uint8Array(y);
+            for (let i = 0; i < lhs.length; ++i) {
+                if (lhs[i] !== rhs[i])
+                    return false;
+            }
+            return true;
+        }
         if (x.constructor === RegExp)
             return x.source === y.source && x.flags === y.flags;
-        if (x.valueOf !== Object.prototype.valueOf)
+        if (typeof x.valueOf === 'function' && x.valueOf !== Object.prototype.valueOf) {
+            if (typeof y.valueOf !== 'function')
+                return false;
             return x.valueOf() === y.valueOf();
-        if (x.toString !== Object.prototype.toString)
+        }
+        if (typeof x.toString === 'function' && x.toString !== Object.prototype.toString) {
+            if (typeof y.toString !== 'function')
+                return false;
             return x.toString() === y.toString();
+        }
         const keys = Object.keys(x);
         if (keys.length !== Object.keys(y).length)
             return false;

package/lib/esm/index.mjs

@@ -19,12 +19,69 @@ function isEqual(x, y) {
             }
             return true;
         }
+        if (x instanceof Map) {
+            if (x.size !== y.size)
+                return false;
+            for (const [key, value] of x) {
+                if (!y.has(key) || !isEqual(value, y.get(key)))
+                    return false;
+            }
+            return true;
+        }
+        if (x instanceof Set) {
+            if (x.size !== y.size)
+                return false;
+            for (const value of x) {
+                if (!y.has(value))
+                    return false;
+            }
+            return true;
+        }
+        if (ArrayBuffer.isView(x)) {
+            if (x instanceof DataView) {
+                if (x.byteLength !== y.byteLength)
+                    return false;
+                for (let i = 0; i < x.byteLength; ++i) {
+                    if (x.getUint8(i) !== y.getUint8(i))
+                        return false;
+                }
+                return true;
+            }
+            const lhs = x;
+            const rhs = y;
+            if (lhs.length !== rhs.length)
+                return false;
+            for (let i = 0; i < lhs.length; ++i) {
+                if (!Object.is(lhs[i], rhs[i]))
+                    return false;
+            }
+            return true;
+        }
+        if (x instanceof ArrayBuffer) {
+            if (x.byteLength !== y.byteLength)
+                return false;
+            if (x.byteLength === 0)
+                return true;
+            const lhs = new Uint8Array(x);
+            const rhs = new Uint8Array(y);
+            for (let i = 0; i < lhs.length; ++i) {
+                if (lhs[i] !== rhs[i])
+                    return false;
+            }
+            return true;
+        }
         if (x.constructor === RegExp)
             return x.source === y.source && x.flags === y.flags;
-        if (x.valueOf !== Object.prototype.valueOf)
+        if (typeof x.valueOf === 'function' && x.valueOf !== Object.prototype.valueOf) {
+            if (typeof y.valueOf !== 'function')
+                return false;
             return x.valueOf() === y.valueOf();
-        if (x.toString !== Object.prototype.toString)
+        }
+        if (typeof x.toString === 'function' && x.toString !== Object.prototype.toString) {
+            if (typeof y.toString !== 'function')
+                return false;
             return x.toString() === y.toString();
+        }
         const keys = Object.keys(x);
         if (keys.length !== Object.keys(y).length)
             return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanghechen/equal",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "The fastest deep equal with ES6 Map, Set and Typed arrays support.",
   "author": {
     "name": "guanghechen",