ts-data-forge 14.10.0 → 14.10.1

package/src/others/fast-deep-equal.test.mts

@@ -203,6 +203,18 @@ describe(fastDeepEqual, () => {
         y: { toString: () => 'Hello world!' } as any,
         expected: '=',
       },
+      {
+        name: 'objects whose own `valueOf` and `toString` are not functions are compared by key',
+        x: { valueOf: 1, toString: 'a' } as any,
+        y: { valueOf: 1, toString: 'a' } as any,
+        expected: '=',
+      },
+      {
+        name: 'objects whose own `valueOf` that is not a function differs are not equal',
+        x: { valueOf: 1 } as any,
+        y: { valueOf: 2 } as any,
+        expected: '!=',
+      },
       {
         name: 'objects with `toString` functions returning different values are not equal',
         x: { toString: () => 'Hello world!' } as any,
@@ -212,6 +224,54 @@ describe(fastDeepEqual, () => {
     ] as const satisfies readonly TestCase[])('$name', testFn);
   });
 
+  describe('null-prototype objects', () => {
+    const withNullPrototype = (
+      entries: ReadonlyRecord<string, unknown>,
+    ): unknown => Object.setPrototypeOf({ ...entries }, null);
+
+    const groupByParity = (xs: readonly number[]): unknown =>
+      Object.groupBy(xs, (x) => (x % 2 === 0 ? 'even' : 'odd'));
+
+    test.each([
+      {
+        name: 'empty null-prototype objects are equal',
+        x: Object.create(null),
+        y: Object.create(null),
+        expected: '=',
+      },
+      {
+        name: 'null-prototype objects with the same entries are equal',
+        x: withNullPrototype({ a: 1, b: [2] }),
+        y: withNullPrototype({ a: 1, b: [2] }),
+        expected: '=',
+      },
+      {
+        name: 'null-prototype objects with different entries are not equal',
+        x: withNullPrototype({ a: 1 }),
+        y: withNullPrototype({ a: 2 }),
+        expected: '!=',
+      },
+      {
+        name: 'a null-prototype object and a plain object are not equal',
+        x: Object.create(null),
+        y: {},
+        expected: '!=',
+      },
+      {
+        name: 'Object.groupBy results with the same groups are equal',
+        x: groupByParity([1, 2, 3]),
+        y: groupByParity([1, 2, 3]),
+        expected: '=',
+      },
+      {
+        name: 'Object.groupBy results with different groups are not equal',
+        x: groupByParity([1, 2, 3]),
+        y: groupByParity([1, 2, 4]),
+        expected: '!=',
+      },
+    ] as const satisfies readonly TestCase[])('$name', testFn);
+  });
+
   describe('arrays', () => {
     test.each([
       { name: 'two empty arrays are equal', x: [], y: [], expected: '=' },
@@ -382,13 +442,13 @@ describe(fastDeepEqual, () => {
     test.each([
       {
         name: 'empty maps are equal',
-        x: new Map(),
-        y: new Map(),
+        x: new Map<unknown, unknown>(),
+        y: new Map<unknown, unknown>(),
         expected: '=',
       },
       {
         name: 'empty maps of different class are not equal',
-        x: new Map(),
+        x: new Map<unknown, unknown>(),
         y: new MyMap(),
         expected: '!=',
       },
@@ -436,32 +496,44 @@ describe(fastDeepEqual, () => {
       },
       {
         name: 'equal maps (same sub-keys)',
-        x: new Map([['a', [createMap({ b: 'c' })]]]),
-        y: new Map([['a', [createMap({ b: 'c' })]]]),
+        x: new Map<string, readonly ReadonlyMap<unknown, string>[]>([
+          ['a', [createMap({ b: 'c' })]],
+        ]),
+        y: new Map<string, readonly ReadonlyMap<unknown, string>[]>([
+          ['a', [createMap({ b: 'c' })]],
+        ]),
         expected: '=',
       },
       {
         name: 'not equal maps (different sub-key value)',
-        x: new Map([['a', [createMap({ b: 'c' })]]]),
-        y: new Map([['a', [createMap({ b: 'd' })]]]),
+        x: new Map<string, readonly ReadonlyMap<unknown, string>[]>([
+          ['a', [createMap({ b: 'c' })]],
+        ]),
+        y: new Map<string, readonly ReadonlyMap<unknown, string>[]>([
+          ['a', [createMap({ b: 'd' })]],
+        ]),
         expected: '!=',
       },
       {
         name: 'not equal maps (different sub-key)',
-        x: new Map([['a', [createMap({ b: 'c' })]]]),
-        y: new Map([['a', [createMap({ c: 'c' })]]]),
+        x: new Map<string, readonly ReadonlyMap<unknown, string>[]>([
+          ['a', [createMap({ b: 'c' })]],
+        ]),
+        y: new Map<string, readonly ReadonlyMap<unknown, string>[]>([
+          ['a', [createMap({ c: 'c' })]],
+        ]),
         expected: '!=',
       },
       {
         name: 'empty map and empty object are equal',
         x: {},
-        y: new Map(),
+        y: new Map<unknown, unknown>(),
         expected: '!=',
       },
       {
         name: 'empty map and empty array are not equal',
         x: [],
-        y: new Map(),
+        y: new Map<unknown, unknown>(),
         expected: '!=',
       },
       {
@@ -514,13 +586,13 @@ describe(fastDeepEqual, () => {
     test.each([
       {
         name: 'empty sets are equal',
-        x: new Set(),
-        y: new Set(),
+        x: new Set<unknown>(),
+        y: new Set<unknown>(),
         expected: '=',
       },
       {
         name: 'empty sets of different class are not equal',
-        x: new Set(),
+        x: new Set<unknown>(),
         y: new MySet(),
         expected: '!=',
       },
@@ -575,13 +647,13 @@ describe(fastDeepEqual, () => {
       {
         name: 'empty set and empty object are not equal',
         x: {},
-        y: new Set(),
+        y: new Set<unknown>(),
         expected: '!=',
       },
       {
         name: 'empty set and empty array are not equal',
         x: [],
-        y: new Set(),
+        y: new Set<unknown>(),
         expected: '!=',
       },
       {
@@ -598,7 +670,7 @@ describe(fastDeepEqual, () => {
       },
       {
         name: 'set and pseudo set are not equal',
-        x: new Set(),
+        x: new Set<unknown>(),
         y: {
           constructor: Set,
           size: 0,
@@ -702,15 +774,58 @@ describe(fastDeepEqual, () => {
           'content',
         );
 
-        // These elements have the same structure but different _owner references
-        // fastDeepEqual should skip _owner comparison and not cause infinite loop
-        // The result depends on whether other properties are equal
-        const result = fastDeepEqualUntyped(element1, element2);
-
-        // The important thing is that it doesn't throw or hang
-        assert.isBoolean(result);
+        assert.isTrue(fastDeepEqualUntyped(element1, element2));
       });
 
+      test.each([
+        {
+          name: 'element-shaped objects with different _owner are equal',
+          x: {
+            $$typeof: Symbol.for('react.element'),
+            type: 'div',
+            key: null,
+            props: { className: 'x' },
+            _owner: { name: 'A' },
+          },
+          y: {
+            $$typeof: Symbol.for('react.element'),
+            type: 'div',
+            key: null,
+            props: { className: 'x' },
+            _owner: { name: 'B' },
+          },
+          expected: '=',
+        },
+        {
+          name: 'element-shaped objects with different props are not equal',
+          x: {
+            $$typeof: Symbol.for('react.element'),
+            type: 'div',
+            props: { className: 'x' },
+            _owner: null,
+          },
+          y: {
+            $$typeof: Symbol.for('react.element'),
+            type: 'div',
+            props: { className: 'y' },
+            _owner: null,
+          },
+          expected: '!=',
+        },
+        {
+          name: '_owner is compared on an object without $$typeof',
+          x: { _owner: { name: 'A' } },
+          y: { _owner: { name: 'B' } },
+          expected: '!=',
+        },
+        {
+          name: '_owner is compared when $$typeof is falsy',
+          x: { $$typeof: null, _owner: { name: 'A' } },
+          y: { $$typeof: null, _owner: { name: 'B' } },
+          expected: '!=',
+        },
+      ] as const satisfies readonly TestCase[])('$name', testFn);
+
       test('React elements with different props are not equal', () => {
         const element1 = React.createElement('div', { className: 'test1' });
 
@@ -747,9 +862,7 @@ describe(fastDeepEqual, () => {
           child.render();
         }
 
-        // Should still be 1 or 2 depending on React element comparison
-        // The important thing is it doesn't throw or hang
-        assert.isTrue(mut_renderCount >= 1);
+        assert.strictEqual(mut_renderCount, 1);
 
         // Update with different props - should re-render
         const differentProps = {
@@ -763,8 +876,7 @@ describe(fastDeepEqual, () => {
           child.render();
         }
 
-        // Should have rendered at least once more
-        assert.isTrue(mut_renderCount >= 2);
+        assert.strictEqual(mut_renderCount, 2);
       });
     });
   });

package/src/others/replace-equal-deep.mts

@@ -7,18 +7,18 @@ import { fastDeepEqual } from './fast-deep-equal.mjs';
  * replaced by that part of `current` (structural sharing). When the whole of
  * `next` is deeply equal to `current`, `current` itself is returned, so an
  * `Object.is` comparison of the result with `current` tells whether anything
- * changed, and a reader that compares by reference sees a new object only
- * where the value really changed.
+ * changed, and a reader that compares by reference sees a new object only where
+ * the value really changed.
  *
  * Only plain objects and arrays are walked into. Anything else — a `Map`, a
  * `Set`, a `Date`, a class instance — is compared whole with
  * {@link fastDeepEqual} and kept or replaced whole.
  *
  * Array items are matched by index. Give `key` to match them by key instead:
- * an item for which it returns something other than `undefined` is matched
- * with the item of `current` it returns the same key for, and an item it
- * returns `undefined` for is still matched by index. The one `key` is used
- * for the arrays at every depth.
+ * an item for which it returns something other than `undefined` is matched with
+ * the item of `current` it returns the same key for, and an item it returns
+ * `undefined` for is still matched by index. The one `key` is used for the
+ * arrays at every depth.
  *
  * Neither argument is changed. The result shares objects with both, so it
  * relies on neither being changed afterwards.
@@ -91,23 +91,29 @@ export const replaceEqualDeep = <T,>(
   next: T,
   options?: ReplaceEqualDeepOptions,
 ): T =>
-  // The walk sees `unknown`; what it returns is `current`, `next`, or a copy
-  // of `next`'s shape whose parts are parts of either, so it is a `T`.
+  // The walk sees `unknown`; what it returns is `current`, `next`, or a copy of
+  // `next`'s shape whose parts are parts of either, so it is a `T`.
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   replace(current, next, options?.key) as T;
 
 /** Options of {@link replaceEqualDeep}. */
 export type ReplaceEqualDeepOptions = Readonly<{
   /**
-   * The key an array item is matched by. Items it returns `undefined` for
-   * are matched by index. Keys are compared with `SameValueZero`, as `Map`
-   * compares them.
+   * The key an array item is matched by. Items it returns `undefined` for are
+   * matched by index. Keys are compared with `SameValueZero`, as `Map` compares
+   * them.
    */
   key?: (item: unknown) => unknown;
 }>;
 
 type Key = (item: unknown) => unknown;
 
+const isPlainArray = (value: unknown): value is readonly unknown[] =>
+  Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype;
+
+const isPlainObject = (value: unknown): value is UnknownRecord =>
+  isRecord(value) && Object.getPrototypeOf(value) === Object.prototype;
+
 const replace = (
   current: unknown,
   next: unknown,
@@ -123,9 +129,26 @@ const replace = (
           ? current
           : next;
 
-// Each walk returns `current` when every part of the result is the same part
-// of `current`, `next` when every part is the same part of `next` (nothing
-// was reused, so no copy is needed), and the copy otherwise.
+const indexByKey = (
+  items: readonly unknown[],
+  key: Key,
+): ReadonlyMap<unknown, unknown> => {
+  const mut_byKey = new Map<unknown, unknown>();
+
+  for (const item of items) {
+    const itemKey = key(item);
+
+    if (itemKey !== undefined && !mut_byKey.has(itemKey)) {
+      mut_byKey.set(itemKey, item);
+    }
+  }
+
+  return mut_byKey;
+};
+
+// Each walk returns `current` when every part of the result is the same part of
+// `current`, `next` when every part is the same part of `next` (nothing was
+// reused, so no copy is needed), and the copy otherwise.
 
 const replaceArray = (
   current: readonly unknown[],
@@ -200,26 +223,3 @@ const replaceObject = (
 
 // What an item of `next` is matched with when nothing of `current` is.
 const absent: unique symbol = Symbol('absent');
-
-const indexByKey = (
-  items: readonly unknown[],
-  key: Key,
-): ReadonlyMap<unknown, unknown> => {
-  const mut_byKey = new Map<unknown, unknown>();
-
-  for (const item of items) {
-    const itemKey = key(item);
-
-    if (itemKey !== undefined && !mut_byKey.has(itemKey)) {
-      mut_byKey.set(itemKey, item);
-    }
-  }
-
-  return mut_byKey;
-};
-
-const isPlainArray = (value: unknown): value is readonly unknown[] =>
-  Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype;
-
-const isPlainObject = (value: unknown): value is UnknownRecord =>
-  isRecord(value) && Object.getPrototypeOf(value) === Object.prototype;

package/src/others/replace-equal-deep.test.mts

@@ -228,11 +228,17 @@ describe(replaceEqualDeep, () => {
   });
 
   test('compares a Map, a Set, a Date or a class instance whole', () => {
-    const map = new Map([['a', { x: 1 }]]);
+    const map = new Map<string, Readonly<{ x: number }>>([['a', { x: 1 }]]);
 
-    assert.strictEqual(replaceEqualDeep(map, new Map([['a', { x: 1 }]])), map);
+    assert.strictEqual(
+      replaceEqualDeep(
+        map,
+        new Map<string, Readonly<{ x: number }>>([['a', { x: 1 }]]),
+      ),
+      map,
+    );
 
-    const changedMap = new Map([
+    const changedMap = new Map<string, Readonly<{ x: number }>>([
       ['a', { x: 1 }],
       ['b', { x: 2 }],
     ]);
@@ -244,9 +250,9 @@ describe(replaceEqualDeep, () => {
     // Nothing inside is reused.
     assert.notStrictEqual(sharedMap.get('a'), map.get('a'));
 
-    const set = new Set([1, 2]);
+    const set = new Set<number>([1, 2]);
 
-    assert.strictEqual(replaceEqualDeep(set, new Set([1, 2])), set);
+    assert.strictEqual(replaceEqualDeep(set, new Set<number>([1, 2])), set);
 
     const date = new Date(0);
 
@@ -282,12 +288,12 @@ describe(replaceEqualDeep, () => {
   });
 
   test('reuses a Map compared whole inside a plain object', () => {
-    const map = new Map([['a', 1]]);
+    const map = new Map<string, number>([['a', 1]]);
 
     const current = { map, count: 1 } as const;
 
     const shared = replaceEqualDeep(current, {
-      map: new Map([['a', 1]]),
+      map: new Map<string, number>([['a', 1]]),
       count: 2,
     });
 

package/src/string/str.mts

@@ -522,8 +522,8 @@ export namespace Str {
    * `NonEmptyString` is an alias of `MinLengthString<1>`, so this is the
    * length-1 specialization of {@link asMinLengthString}. Use this instead of
    * writing `s as unknown as NonEmptyString`: the length is verified at
-   * runtime, and the original string type (e.g. literal types) is preserved
-   * via intersection.
+   * runtime, and the original string type (e.g. literal types) is preserved via
+   * intersection.
    *
    * @example
    *