@longlast/equals 0.5.2 → 0.5.4

package/dist/index.js

@@ -2,7 +2,9 @@
  * @module equals
  */
 import { curry } from "@longlast/curry";
-import { $boundArguments, $equals, $unapplied } from "@longlast/symbols";
+import { $boundArguments, $equals, $getBoundArguments, $unapplied, } from "@longlast/symbols";
+// TODO: export an `Equatable` interface that classes with the [$equals] method
+// can implement.
 /**
  * @function
  * Deeply compares two values, returning true if they're equal and false
@@ -65,6 +67,11 @@ export const equals = curry(_equals);
 function _equals(a, b) {
     // This is an optimized implementation. There is a simpler, equivalent one
     // in pkg/equals/alt/reference.ts.
+    // TODO: (pre-1.0.0) decide if we should pass `equals` as the second
+    // argument to [$equals]. This would open the "protocol" up a bit more,
+    // since people could then define their own implementations of `equals`
+    // that work consistently through custom equality comparisons.
+    // TODO: Compare cross-realm objects.
     if (a != null && typeof a[$equals] === "function") {
         return Boolean(a[$equals](b));
     }
@@ -78,8 +85,7 @@ function _equals(a, b) {
         return String(a) === String(b);
     }
     if (a instanceof Error && b instanceof Error) {
-        return (a.message === b.message &&
-            Object.getPrototypeOf(a) === Object.getPrototypeOf(b));
+        return a.message === b.message && protoOf(a) === protoOf(b);
     }
     if (Array.isArray(a) && Array.isArray(b)) {
         return a.length === b.length && a.every((_, i) => _equals(a[i], b[i]));
@@ -88,18 +94,21 @@ function _equals(a, b) {
         return a.size === b.size && [...a].every((v) => b.has(v));
     }
     if (typeof a === "function" && typeof b === "function") {
-        const aArgs = a[$boundArguments];
-        const bArgs = b[$boundArguments];
         const aUnapplied = a[$unapplied];
         const bUnapplied = b[$unapplied];
         return (aUnapplied != null &&
             aUnapplied === bUnapplied &&
-            _equals(aArgs, bArgs));
+            _equals(getBoundArguments(a), getBoundArguments(b)));
     }
     if (a && b && typeof a === "object" && protoOf(a) === protoOf(b)) {
-        const bKeys = new Set(Object.keys(b));
-        for (const key of Object.keys(a)) {
-            if (!bKeys.has(key)) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length) {
+            return false;
+        }
+        const bKeySet = new Set(bKeys);
+        for (const key of aKeys) {
+            if (!bKeySet.has(key)) {
                 return false;
             }
             if (!_equals(a[key], b[key])) {
@@ -110,4 +119,8 @@ function _equals(a, b) {
     }
     return false;
 }
+function getBoundArguments(f) {
+    // TODO: (pre-1.0.0) remove `f[$boundArguments]` fallback.
+    return f[$getBoundArguments]?.() ?? f[$boundArguments];
+}
 const protoOf = Object.getPrototypeOf;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longlast/equals",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Deeply compares objects",
   "homepage": "https://longlast.js.org/",
   "license": "MIT",
@@ -17,7 +17,7 @@
     "#@longlast/equals": "./src/index.ts"
   },
   "dependencies": {
-    "@longlast/curry": "^0.4.0",
+    "@longlast/curry": "^0.5.0",
     "@longlast/symbols": "^1.0.0"
   }
 }