@longlast/equals 0.1.0

package/dist/api/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/test.js

@@ -0,0 +1,8 @@
+import { test, expect, is } from "@benchristel/taste";
+import { equals } from "../index.js";
+test("equals", {
+    "compares booleans"() {
+        expect(equals(true, false), is, false);
+        expect(equals(false, false), is, true);
+    },
+});

package/dist/api/typetest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/typetest.js

@@ -0,0 +1,5 @@
+import { test, expect } from "tstyche";
+import { equals } from "../index.js";
+test("equals", () => {
+    expect(equals(true, true)).type.toBeAssignableTo();
+});

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @module equals
+ */
+/**
+ * Deeply compares two values, returning true if they're equal and false
+ * otherwise. The following criteria are used to determine equality:
+ *
+ *   - All values are always equal to themselves.
+ *   - Arrays are equal iff they have the same length and their corresponding
+ *     elements are equal (according to `equals`).
+ *   - Dates are equal iff they serialize to the same ISO string.
+ *   - Sets are equal iff they contain the same elements. Note that set
+ *     elements are _not_ deeply compared.
+ *   - Errors are equal iff they have the same class and message.
+ *   - Other objects are equal iff they have the same prototype (e.g. the same
+ *     class) and the same set of enumerable string-keyed properties, and the
+ *     values of their corresponding properties are equal (according to
+ *     `equals`).
+ *   - Primitives `a` and `b` are equal iff `a === b`.
+ *
+ * `equals()` can throw a RangeError if one of its arguments contains a
+ * reference cycle. Avoid passing mutable objects to `equals()` unless you know
+ * that they do not contain cycles.
+ */
+export declare function equals(a: unknown, b: unknown): boolean;

package/dist/index.js

@@ -0,0 +1,55 @@
+/**
+ * @module equals
+ */
+/**
+ * Deeply compares two values, returning true if they're equal and false
+ * otherwise. The following criteria are used to determine equality:
+ *
+ *   - All values are always equal to themselves.
+ *   - Arrays are equal iff they have the same length and their corresponding
+ *     elements are equal (according to `equals`).
+ *   - Dates are equal iff they serialize to the same ISO string.
+ *   - Sets are equal iff they contain the same elements. Note that set
+ *     elements are _not_ deeply compared.
+ *   - Errors are equal iff they have the same class and message.
+ *   - Other objects are equal iff they have the same prototype (e.g. the same
+ *     class) and the same set of enumerable string-keyed properties, and the
+ *     values of their corresponding properties are equal (according to
+ *     `equals`).
+ *   - Primitives `a` and `b` are equal iff `a === b`.
+ *
+ * `equals()` can throw a RangeError if one of its arguments contains a
+ * reference cycle. Avoid passing mutable objects to `equals()` unless you know
+ * that they do not contain cycles.
+ */
+export function equals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((_, i) => equals(a[i], b[i]));
+    }
+    if (a instanceof Date && b instanceof Date) {
+        return a.toISOString() === b.toISOString();
+    }
+    if (a instanceof Set && b instanceof Set) {
+        return a.size === b.size && [...a.values()].every((v) => b.has(v));
+    }
+    if (a instanceof Error && b instanceof Error) {
+        return (a.message === b.message &&
+            Object.getPrototypeOf(a)?.constructor ===
+                Object.getPrototypeOf(b)?.constructor);
+    }
+    if (isObject(a) && isObject(b)) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        return (aKeys.length === bKeys.length &&
+            aKeys.every((k) => equals(a[k], b[k])) &&
+            Object.getPrototypeOf(a)?.constructor ===
+                Object.getPrototypeOf(b)?.constructor);
+    }
+    return a === b;
+}
+function isObject(x) {
+    return !!x && typeof x === "object";
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@longlast/equals",
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "imports": {
+    "#@longlast/equals": "./src/index.ts"
+  }
+}