@bb-labs/deep-equal-test 0.0.1

package/README.md

@@ -0,0 +1,62 @@
+## Introduction
+
+A tiny utility for **deep structural equality** that is:sa
+
+- ✅ Aware of rich JavaScript types via **[SuperJSON](https://github.com/blitz-js/superjson)**
+- ✅ Uses **[fast-deep-equal](https://github.com/epoberezkin/fast-deep-equal)** under the hood
+- ✅ Treats **arrays as equal even when items are in a different order**
+- ✅ Stable & deterministic (objects and arrays are normalized before comparison)
+
+---
+
+## Installation
+
+```bash
+npm install @bigbang-sdk/local-db
+# or
+yarn add @bigbang-sdk/local-db
+# or
+bun add @bigbang-sdk/local-db
+```
+
+---
+
+## Why?
+
+Plain deep equality libraries usually assume:
+
+- Arrays must be in the **same order**
+- Only handle plain JSON-ish structures welcasl
+
+This helper does two important things:
+
+1. Runs values through **SuperJSON** so things like `Date`, `BigInt`, `Map`, `Set`, etc. end up in a consistent, JSON-safe shape.
+2. **Recursively normalizes** that shape:
+   - Arrays are **sorted** by their JSON representation → order no longer matters.
+   - Object keys are **sorted** so key order never affects equality.
+
+Then it compares the normalized values with `fast-deep-equal`.
+
+---
+
+## API
+
+### `isDeepEqual(a: unknown, b: unknown): boolean`
+
+Deep equality check with:
+
+- SuperJSON-aware serialization
+- Order-insensitive arrays
+- Stable object key orderingg
+
+```ts
+import { isDeepEqual } from "@bigbang-sdk/local-db";
+
+isDeepEqual([1, 2, 3], [3, 2, 1]); // true
+
+isDeepEqual([{ x: 1, y: 2 }, { a: 5 }], [{ a: 5 }, { y: 2, x: 1 }]); // true
+
+isDeepEqual(new Date("2020-01-01"), new Date("2020-01-01")); // true
+
+isDeepEqual(new Set([3, 2, 1]), new Set([1, 2, 3])); // true (via SuperJSON serialization)
+```

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare const isDeepEqual: (a: unknown, b: unknown) => boolean;

package/dist/index.js

@@ -0,0 +1,17 @@
+import deepEqual from "fast-deep-equal";
+import SuperJSON from "superjson";
+import { deepSort } from "@bb-labs/deep-sort-test";
+/**
+ * Normalize structures so deep-equal works:
+ * - Encode using SuperJSON (handles Dates, BigInts, Maps/Sets via metadata)
+ * - Deep-sort objects and arrays so order does not matter
+ */
+const normalize = (value) => {
+    // First serialize using SuperJSON for consistency / rich types
+    const { json } = SuperJSON.serialize(value);
+    // Then deep-sort the JSON-safe structure
+    return deepSort(json);
+};
+export const isDeepEqual = (a, b) => {
+    return deepEqual(normalize(a), normalize(b));
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@bb-labs/deep-equal-test",
+  "version": "0.0.1",
+  "npm": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/beepbop-labs/libraries.git"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bldr",
+    "dev": "bldr -w",
+    "clean": "rm -rf node_modules bun.lock dist"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "tsc-alias": "^1.8.16"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@bb-labs/bldr": "^0.0.16",
+    "@bb-labs/deep-sort-test": "0.0.0",
+    "@bb-labs/tsconfigs": "^0.0.4",
+    "fast-deep-equal": "^3.1.3",
+    "superjson": "^2.2.6"
+  }
+}