@longlast/equals 0.5.3 → 0.5.5

package/dist/index.js

@@ -3,6 +3,8 @@
  */
 import { curry } from "@longlast/curry";
 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,39 +67,72 @@ 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.
-    if (a != null && typeof a[$equals] === "function") {
+    if (a == null) {
+        return a === b;
+    }
+    // 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.
+    if (typeof a[$equals] === "function") {
         return Boolean(a[$equals](b));
     }
     if (Object.is(a, b)) {
         return true;
     }
-    if (a instanceof Date && b instanceof Date) {
+    if (typeof a === "function" && typeof b === "function") {
+        const aUnapplied = a[$unapplied];
+        const bUnapplied = b[$unapplied];
+        return (aUnapplied != null &&
+            aUnapplied === bUnapplied &&
+            _equals(getBoundArguments(a), getBoundArguments(b)));
+    }
+    // If `a` is a primitive at this point, return false, since we already know
+    // it is not identical to `b`.
+    if (typeof a !== "object") {
+        return false;
+    }
+    const aConstructorString = functionString(constructorOf(a));
+    const bConstructorString = functionString(constructorOf(b));
+    if (aConstructorString !== bConstructorString) {
+        return false;
+    }
+    if (dateConstructorString === aConstructorString) {
+        unsafeNarrow(a);
+        unsafeNarrow(b);
         return Object.is(+a, +b);
     }
-    if (a instanceof RegExp && b instanceof RegExp) {
+    if (regexConstructorString === aConstructorString) {
         return String(a) === String(b);
     }
-    if (a instanceof Error && b instanceof Error) {
-        return (a.message === b.message &&
-            Object.getPrototypeOf(a) === Object.getPrototypeOf(b));
+    if ((a instanceof Error && b instanceof Error) ||
+        nativeErrorConstructorStrings.includes(aConstructorString)) {
+        unsafeNarrow(a);
+        unsafeNarrow(b);
+        return a.message === b.message;
     }
     if (Array.isArray(a) && Array.isArray(b)) {
         return a.length === b.length && a.every((_, i) => _equals(a[i], b[i]));
     }
-    if (a instanceof Set && b instanceof Set) {
+    if (setConstructorString === aConstructorString) {
+        unsafeNarrow(a);
+        unsafeNarrow(b);
         return a.size === b.size && [...a].every((v) => b.has(v));
     }
-    if (typeof a === "function" && typeof b === "function") {
-        const aUnapplied = a[$unapplied];
-        const bUnapplied = b[$unapplied];
-        return (aUnapplied != null &&
-            aUnapplied === bUnapplied &&
-            _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)) {
+    // TODO: typed arrays
+    // TODO: Map
+    if (objectConstructorString === aConstructorString ||
+        protoOf(a) === protoOf(b)) {
+        unsafeNarrow(a);
+        unsafeNarrow(b);
+        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])) {
@@ -109,6 +144,36 @@ function _equals(a, b) {
     return false;
 }
 function getBoundArguments(f) {
+    // TODO: (pre-1.0.0) remove `f[$boundArguments]` fallback.
     return f[$getBoundArguments]?.() ?? f[$boundArguments];
 }
+function functionString(f) {
+    if (typeof f !== "function") {
+        return "";
+    }
+    return Function.prototype.toString.call(f);
+}
+function constructorOf(value) {
+    if (value == null) {
+        return null;
+    }
+    return Object.getPrototypeOf(value)?.constructor;
+}
+function unsafeNarrow(value) {
+    value;
+}
 const protoOf = Object.getPrototypeOf;
+const objectConstructorString = functionString(Object);
+const dateConstructorString = functionString(Date);
+const regexConstructorString = functionString(RegExp);
+const setConstructorString = functionString(Set);
+const nativeErrorConstructorStrings = [
+    functionString(Error),
+    // TODO: add DOMException? Be sure to check the `name` property.
+    functionString(EvalError),
+    functionString(RangeError),
+    functionString(ReferenceError),
+    functionString(SyntaxError),
+    functionString(TypeError),
+    functionString(URIError),
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longlast/equals",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Deeply compares objects",
   "homepage": "https://longlast.js.org/",
   "license": "MIT",