refactor: use custom isEqual

Author: es3n1n

packages/svelte-stores/src/lib/queryParamsStore.ts

@@ -1,10 +1,9 @@
 import { derived, get, type Readable } from 'svelte/store';
 import type { Page } from '@sveltejs/kit';
-import { isEqual } from 'lodash-es';
 
 import * as Serialize from '@layerstack/utils/serialize';
 import rollup from '@layerstack/utils/rollup';
-import { entries, type ValueOf } from '@layerstack/utils';
+import { entries, isEqual, type ValueOf } from '@layerstack/utils';
 
 // Matches $app/navigation's goto without dependency - https://kit.svelte.dev/docs/modules#$app-navigation-goto
 type Goto = (url: string | URL, opts?: any) => any;

packages/utils/src/lib/index.ts

@@ -35,6 +35,7 @@ export * from './logger.js';
 export { round, clamp, randomInteger } from './number.js';
 export { get } from './get.js';
 export { set } from './set.js';
+export { isEqual } from './isEqual.js';
 export { isEmptyObject, isLiteralObject, omit, pick } from './object.js';
 export { mergeWith, merge, defaultsDeep } from './mergeWith.js';
 export * from './promise.js';

packages/utils/src/lib/isEqual.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+
+import { isEqual } from './isEqual.js';
+
+describe('isEqual', () => {
+  it('compares primitives', () => {
+    expect(isEqual(1, 1)).toBe(true);
+    expect(isEqual(1, 2)).toBe(false);
+    expect(isEqual('a', 'a')).toBe(true);
+    expect(isEqual(true, false)).toBe(false);
+    expect(isEqual(null, null)).toBe(true);
+    expect(isEqual(undefined, undefined)).toBe(true);
+    expect(isEqual(null, undefined)).toBe(false);
+  });
+
+  it('treats NaN as equal to NaN', () => {
+    expect(isEqual(Number.NaN, Number.NaN)).toBe(true);
+  });
+
+  it('compares arrays deeply', () => {
+    expect(isEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+    expect(isEqual([1, 2, 3], [1, 2, 4])).toBe(false);
+  });
+
+  it('compares objects deeply', () => {
+    expect(isEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } })).toBe(true);
+    expect(isEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 3 } })).toBe(false);
+  });
+
+  it('compares dates by timestamp', () => {
+    expect(
+      isEqual(new Date('2020-01-01T00:00:00.000Z'), new Date('2020-01-01T00:00:00.000Z'))
+    ).toBe(true);
+    expect(
+      isEqual(new Date('2020-01-01T00:00:00.000Z'), new Date('2020-01-02T00:00:00.000Z'))
+    ).toBe(false);
+  });
+
+  it('handles circular references', () => {
+    const a: any = { x: 1 };
+    a.self = a;
+    const b: any = { x: 1 };
+    b.self = b;
+    expect(isEqual(a, b)).toBe(true);
+  });
+});

packages/utils/src/lib/isEqual.ts

@@ -0,0 +1,40 @@
+export function isEqual(a: any, b: any, seen = new WeakMap()): boolean {
+  if (a === b || (a !== a && b !== b)) return true; // identical or both NaN
+  if (a == null || b == null) return a === b;
+  if (typeof a !== 'object' || typeof b !== 'object') return false;
+
+  // Circular reference handling
+  if (seen.has(a)) return seen.get(a) === b;
+  seen.set(a, b);
+
+  // Dates
+  if (a instanceof Date && b instanceof Date) return +a === +b;
+  if (a instanceof Date || b instanceof Date) return false;
+
+  // Maps
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [k, v] of a) if (!b.has(k) || !isEqual(v, b.get(k), seen)) return false;
+    return true;
+  }
+  if (a instanceof Map || b instanceof Map) return false;
+
+  // Sets
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const v of a) if (!b.has(v)) return false;
+    return true;
+  }
+  if (a instanceof Set || b instanceof Set) return false;
+
+  // Arrays
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => isEqual(v, b[i], seen));
+  }
+  if (Array.isArray(a) || Array.isArray(b)) return false;
+
+  // Plain objects
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  return keysA.length === keysB.length && keysA.every((k) => k in b && isEqual(a[k], b[k], seen));
+}