ts-data-forge 7.1.0 → 8.0.0

package/src/guard/is-record.test.mts

@@ -1,123 +1,195 @@
 import { type UnknownRecord } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
+import { hasKey } from './has-key.mjs';
 import { isRecord } from './is-record.mjs';
 
 describe(isRecord, () => {
-  describe('arrays are Records', () => {
-    test('number[] is assignable to Record<number, unknown>', () => {
-      const arr: Record<number, unknown> = [1, 2, 3] as const;
+  describe('plain objects are records', () => {
+    test('{ x: 1 } is a record', () => {
+      const unk: unknown = { x: 1 } as const;
+
+      if (isRecord(unk)) {
+        expectType<typeof unk, UnknownRecord>('=');
+      } else {
+        assert.fail();
+      }
+    });
 
-      const unk: unknown = arr;
+    test('{} is a record', () => {
+      const unk: unknown = {} as const;
 
       assert.isTrue(isRecord(unk));
+    });
+
+    test('Object.create(null) is a record', () => {
+      const unk: unknown = Object.create(null);
 
-      expectType<typeof unk, UnknownRecord>('<=');
+      assert.isTrue(isRecord(unk));
     });
+  });
 
-    test('string[] is assignable to Record<number, unknown>', () => {
-      const arr: Record<number, unknown> = ['1', '2', '3'] as const;
+  describe('arrays are not records', () => {
+    test('type-level: arrays are not assignable to UnknownRecord', () => {
+      // Arrays have a number index signature but no string index signature,
+      // so they are assignable to `Record<number, unknown>` but not to
+      // `UnknownRecord` (= `ReadonlyRecord<string, unknown>`).
+      expectType<readonly number[], Record<number, unknown>>('<=');
 
-      const unk: unknown = arr;
+      expectType<readonly number[], UnknownRecord>('!<=');
 
-      assert.isTrue(isRecord(unk));
+      expectType<readonly string[], Record<number, unknown>>('<=');
+
+      expectType<readonly string[], UnknownRecord>('!<=');
 
-      expectType<typeof unk, UnknownRecord>('<=');
+      expectType<readonly [], UnknownRecord>('!<=');
     });
 
-    test('[] is a record', () => {
-      const arr: unknown = [] as const;
+    test('[1, 2, 3] is not a record', () => {
+      const unk: unknown = [1, 2, 3] as const;
 
-      const unk: unknown = arr;
+      assert.isFalse(isRecord(unk));
+    });
 
-      assert.isTrue(isRecord(unk));
+    test('["1", "2", "3"] is not a record', () => {
+      const unk: unknown = ['1', '2', '3'] as const;
 
-      expectType<typeof unk, UnknownRecord>('<=');
+      assert.isFalse(isRecord(unk));
+    });
+
+    test('[] is not a record', () => {
+      const unk: unknown = [] as const;
+
+      assert.isFalse(isRecord(unk));
     });
   });
 
-  describe('non-null objects are Records', () => {
-    test('{ x: 1 } is a record', () => {
-      const obj = { x: 1 } as const;
+  describe('other non-null objects are records', () => {
+    // These are not statically assignable to `UnknownRecord` either, but the
+    // guard intentionally admits them: every property read through
+    // `UnknownRecord` is typed `unknown`, so the narrowing is type-safe, and
+    // it keeps `isRecord(u) && hasKey(u, k)` usable for probing instances
+    // such as caught `Error` objects.
+    test('Date is a record', () => {
+      expectType<Date, UnknownRecord>('!<=');
+
+      const unk: unknown = new Date('2020-01-01');
+
+      assert.isTrue(isRecord(unk));
+    });
 
-      const unk: unknown = obj;
+    test('RegExp is a record', () => {
+      const unk: unknown = /test/u;
 
       assert.isTrue(isRecord(unk));
+    });
+
+    test('Map is a record (but its entries are not own properties)', () => {
+      expectType<ReadonlyMap<string, number>, UnknownRecord>('!<=');
+
+      const unk: unknown = new Map([['a', 1]]);
 
-      expectType<typeof unk, UnknownRecord>('<=');
+      if (isRecord(unk)) {
+        // Map entries are not own properties, so hasKey correctly rejects them.
+        assert.isFalse(hasKey(unk, 'a'));
+      } else {
+        assert.fail();
+      }
     });
 
-    test('{} is a record', () => {
-      const obj = {} as const;
+    test('Set is a record', () => {
+      expectType<ReadonlySet<number>, UnknownRecord>('!<=');
+
+      const unk: unknown = new Set([1, 2, 3]);
+
+      assert.isTrue(isRecord(unk));
+    });
+
+    test('Error is a record and its own properties can be probed', () => {
+      const unk: unknown = Object.assign(new Error('failure'), {
+        code: 'ENOENT',
+      });
+
+      if (isRecord(unk) && hasKey(unk, 'code')) {
+        expectType<(typeof unk)['code'], unknown>('=');
 
-      const unk: unknown = obj;
+        assert.strictEqual(unk.code, 'ENOENT');
+      } else {
+        assert.fail();
+      }
+    });
+
+    test('class instance is a record', () => {
+      class Foo {
+        readonly x = 1;
+      }
+
+      const unk: unknown = new Foo();
 
       assert.isTrue(isRecord(unk));
+    });
+  });
+
+  describe('functions are not records', () => {
+    test('arrow function is not a record', () => {
+      const unk: unknown = () => 0;
 
-      expectType<typeof unk, UnknownRecord>('<=');
+      assert.isFalse(isRecord(unk));
     });
   });
 
-  describe('primitives are not Records', () => {
+  describe('primitives are not records', () => {
     test('null is not a record', () => {
-      const obj = null;
-
-      const unk: unknown = obj;
+      const unk: unknown = null;
 
       assert.isFalse(isRecord(unk));
-
-      expectType<typeof unk, UnknownRecord>('!<=');
     });
 
     test('undefined is not a record', () => {
-      const prm = undefined;
-
-      const unk: unknown = prm;
+      const unk: unknown = undefined;
 
       assert.isFalse(isRecord(unk));
-
-      expectType<typeof unk, UnknownRecord>('!<=');
     });
 
     test('3 is not a record', () => {
-      const prm = 3;
-
-      const unk: unknown = prm;
+      const unk: unknown = 3;
 
       assert.isFalse(isRecord(unk));
-
-      expectType<typeof unk, UnknownRecord>('!<=');
     });
 
     test('"str" is not a record', () => {
-      const prm = 'str';
-
-      const unk: unknown = prm;
+      const unk: unknown = 'str';
 
       assert.isFalse(isRecord(unk));
+    });
 
-      expectType<typeof unk, UnknownRecord>('!<=');
+    test('true is not a record', () => {
+      const unk: unknown = true;
+
+      assert.isFalse(isRecord(unk));
     });
-  });
 
-  // test('Map is not a record', () => {
-  //   const obj = new MutableMap();
-  //   const unk: unknown = obj;
-  //   const res = isRecord(unk);
+    test('symbol is not a record', () => {
+      const unk: unknown = Symbol('sym');
 
-  //   assertNotType<typeof obj, UnknownRecord>("<=");
-  //   expectType<typeof res, boolean>("=");
+      assert.isFalse(isRecord(unk));
+    });
 
-  //   expect(res).toBe(false);
-  // });
+    test('bigint is not a record', () => {
+      const unk: unknown = 1n;
 
-  // test('Set is not a record', () => {
-  //   const obj = new MutableSet();
-  //   const unk: unknown = obj;
-  //   const res = isRecord(unk);
+      assert.isFalse(isRecord(unk));
+    });
+  });
+
+  test('combined with hasKey', () => {
+    const unk: unknown = { 'some-key': 42 } as const;
 
-  //   assertNotType<typeof obj, UnknownRecord>("<=");
-  //   expectType<typeof res, boolean>("=");
+    if (isRecord(unk) && hasKey(unk, 'some-key')) {
+      expectType<(typeof unk)['some-key'], unknown>('=');
 
-  //   expect(res).toBe(false);
-  // });
+      assert.strictEqual(unk['some-key'], 42);
+    } else {
+      assert.fail();
+    }
+  });
 });

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

@@ -16,6 +16,16 @@ export const fastDeepEqual = <T,>(a: T, b: T): boolean => {
     return false;
   }
 
+  // Arrays are handled before `isRecord`, which excludes them.
+  if (Array.isArray(a)) {
+    return (
+      Array.isArray(b) &&
+      a.constructor === b.constructor &&
+      a.length === b.length &&
+      a.every((ai, index) => fastDeepEqual(ai, b[index]))
+    );
+  }
+
   if (isRecord(a)) {
     if (!isRecord(b)) {
       return false;
@@ -25,14 +35,6 @@ export const fastDeepEqual = <T,>(a: T, b: T): boolean => {
       return false;
     }
 
-    if (Array.isArray(a)) {
-      return (
-        Array.isArray(b) &&
-        a.length === b.length &&
-        a.every((ai, index) => fastDeepEqual(ai, b[index]))
-      );
-    }
-
     if (isMap(a)) {
       return (
         isMap(b) &&