fast-equals 5.1.2 → 5.2.0

package/package.json

@@ -22,6 +22,7 @@
     "decircularize": "^1.0.0",
     "deep-eql": "^4.1.4",
     "deep-equal": "^2.0.5",
+    "dequal": "^2.0.3",
     "eslint": "^8.57.1",
     "eslint-friendly-formatter": "^4.0.1",
     "eslint-webpack-plugin": "^4.0.0",
@@ -98,7 +99,7 @@
     "start": "npm run dev",
     "release": "release-it",
     "release:beta": "release-it --config=.release-it.beta.json",
-    "release:scripts": "npm run typecheck && npm run lint && npm run test:coverage && npm run dist",
+    "release:scripts": "npm run typecheck && npm run lint && npm run test:coverage && npm run build",
     "test": "NODE_PATH=. jest",
     "test:coverage": "rm -rf coverage && npm test -- --coverage",
     "test:watch": "npm test -- --watch",
@@ -107,5 +108,5 @@
   "sideEffects": false,
   "type": "module",
   "types": "./index.d.ts",
-  "version": "5.1.2"
+  "version": "5.2.0"
 }

package/src/equals.ts

@@ -6,7 +6,9 @@ import type {
   TypedArray,
 } from './internalTypes';
 
-const OWNER = '_owner';
+const PREACT_VNODE = '__v';
+const PREACT_OWNER = '__o';
+const REACT_OWNER = '_owner';
 
 const { getOwnPropertyDescriptor, keys } = Object;
 
@@ -66,16 +68,22 @@ export function areMapsEqual(
   b: Map<any, any>,
   state: State<any>,
 ): boolean {
-  if (a.size !== b.size) {
+  const size = a.size;
+
+  if (size !== b.size) {
     return false;
   }
 
-  const matchedIndices: Record<number, true> = {};
+  if (!size) {
+    return true;
+  }
+
+  const matchedIndices: Array<true | undefined> = new Array(size);
   const aIterable = a.entries();
 
-  let index = 0;
   let aResult: IteratorResult<[any, any]>;
   let bResult: IteratorResult<[any, any]>;
+  let index = 0;
 
   while ((aResult = aIterable.next())) {
     if (aResult.done) {
@@ -92,17 +100,20 @@ export function areMapsEqual(
         break;
       }
 
-      const [aKey, aValue] = aResult.value;
-      const [bKey, bValue] = bResult.value;
+      if (matchedIndices[matchIndex]) {
+        matchIndex++;
+        continue;
+      }
+
+      const aEntry = aResult.value;
+      const bEntry = bResult.value;
 
       if (
-        !hasMatch &&
-        !matchedIndices[matchIndex] &&
-        (hasMatch =
-          state.equals(aKey, bKey, index, matchIndex, a, b, state) &&
-          state.equals(aValue, bValue, aKey, bKey, a, b, state))
+        state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) &&
+        state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)
       ) {
-        matchedIndices[matchIndex] = true;
+        hasMatch = matchedIndices[matchIndex] = true;
+        break;
       }
 
       matchIndex++;
@@ -139,27 +150,12 @@ export function areObjectsEqual(
     return false;
   }
 
-  let property: string;
-
   // Decrementing `while` showed faster results than either incrementing or
   // decrementing `for` loop and than an incrementing `while` loop. Declarative
   // methods like `some` / `every` were not used to avoid incurring the garbage
   // cost of anonymous callbacks.
   while (index-- > 0) {
-    property = properties[index]!;
-
-    if (
-      property === OWNER &&
-      (a.$$typeof || b.$$typeof) &&
-      a.$$typeof !== b.$$typeof
-    ) {
-      return false;
-    }
-
-    if (
-      !hasOwn(b, property) ||
-      !state.equals(a[property], b[property], property, property, a, b, state)
-    ) {
+    if (!isPropertyEqual(a, b, state, properties[index]!)) {
       return false;
     }
   }
@@ -194,21 +190,7 @@ export function areObjectsEqualStrict(
   while (index-- > 0) {
     property = properties[index]!;
 
-    if (
-      property === OWNER &&
-      (a.$$typeof || b.$$typeof) &&
-      a.$$typeof !== b.$$typeof
-    ) {
-      return false;
-    }
-
-    if (!hasOwn(b, property)) {
-      return false;
-    }
-
-    if (
-      !state.equals(a[property], b[property], property, property, a, b, state)
-    ) {
+    if (!isPropertyEqual(a, b, state, property)) {
       return false;
     }
 
@@ -255,11 +237,17 @@ export function areSetsEqual(
   b: Set<any>,
   state: State<any>,
 ): boolean {
-  if (a.size !== b.size) {
+  const size = a.size;
+
+  if (size !== b.size) {
     return false;
   }
 
-  const matchedIndices: Record<number, true> = {};
+  if (!size) {
+    return true;
+  }
+
+  const matchedIndices: Array<true | undefined> = new Array(size);
   const aIterable = a.values();
 
   let aResult: IteratorResult<any>;
@@ -281,9 +269,8 @@ export function areSetsEqual(
       }
 
       if (
-        !hasMatch &&
         !matchedIndices[matchIndex] &&
-        (hasMatch = state.equals(
+        state.equals(
           aResult.value,
           bResult.value,
           aResult.value,
@@ -291,9 +278,10 @@ export function areSetsEqual(
           a,
           b,
           state,
-        ))
+        )
       ) {
-        matchedIndices[matchIndex] = true;
+        hasMatch = matchedIndices[matchIndex] = true;
+        break;
       }
 
       matchIndex++;
@@ -340,3 +328,24 @@ export function areUrlsEqual(a: URL, b: URL): boolean {
     a.password === b.password
   );
 }
+
+function isPropertyEqual(
+  a: Dictionary,
+  b: Dictionary,
+  state: State<any>,
+  property: string | symbol,
+) {
+  if (
+    (property === REACT_OWNER ||
+      property === PREACT_OWNER ||
+      property === PREACT_VNODE) &&
+    (a.$$typeof || b.$$typeof)
+  ) {
+    return true;
+  }
+
+  return (
+    hasOwn(b, property) &&
+    state.equals(a[property], b[property], property, property, a, b, state)
+  );
+}