ts-data-forge 7.1.1 → 9.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/number/refined-number-utils.mts

@@ -185,15 +185,7 @@ export namespace TsDataForgeInternals {
       }>;
 
     type BaseKeys =
-      | 'add'
-      | 'div'
-      | 'is'
-      | 'max'
-      | 'min'
-      | 'mul'
-      | 'pow'
-      | 'random'
-      | 'sub';
+      'add' | 'div' | 'is' | 'max' | 'min' | 'mul' | 'pow' | 'random' | 'sub';
 
     type FloatMethods = 'ceil' | 'floor' | 'round';
 

package/src/object/object.mts

@@ -224,11 +224,9 @@ export namespace Obj {
     const Keys extends readonly (keyof R)[],
   >(
     ...args:
-      | readonly [record: R, keys: Keys]
-      | readonly [keys: readonly PropertyKey[]]
+      readonly [record: R, keys: Keys] | readonly [keys: readonly PropertyKey[]]
   ):
-    | Omit<R, ArrayElement<Keys>>
-    | ((record: R) => Omit<R, ArrayElement<Keys>>) {
+    Omit<R, ArrayElement<Keys>> | ((record: R) => Omit<R, ArrayElement<Keys>>) {
     switch (args.length) {
       case 2: {
         const [record, keys] = args;
@@ -644,32 +642,36 @@ declare namespace TsDataForgeInternals {
     readonly [K in keyof B as {} extends Pick<B, K> ? never : K]: B[K];
   } & {
     // 2. Optional properties from B that are NOT in A
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    readonly [K in keyof B as {} extends Pick<B, K>
-      ? K extends keyof A
-        ? never
-        : K
-      : never]?: B[K];
+    readonly [
+      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+      K in keyof B as {} extends Pick<B, K>
+        ? K extends keyof A
+          ? never
+          : K
+        : never
+    ]?: B[K];
   } & {
     // 3. Optional properties from B that ARE in A (create union)
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    readonly [K in keyof B as {} extends Pick<B, K>
-      ? K extends keyof A
-        ? K
+    readonly [
+      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+      K in keyof B as {} extends Pick<B, K>
+        ? K extends keyof A
+          ? K
+          : never
         : never
-      : never]?: K extends keyof A ? A[K] | B[K] : never;
+    ]?: K extends keyof A ? A[K] | B[K] : never;
   } & {
     // 4. Required properties only in A (not overridden by B)
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    readonly [K in Exclude<keyof A, keyof B> as {} extends Pick<A, K>
-      ? never
-      : K]: A[K];
+    readonly [
+      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+      K in Exclude<keyof A, keyof B> as {} extends Pick<A, K> ? never : K
+    ]: A[K];
   } & {
     // 5. Optional properties only in A (not overridden by B)
-    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    readonly [K in Exclude<keyof A, keyof B> as {} extends Pick<A, K>
-      ? K
-      : never]?: A[K];
+    readonly [
+      // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+      K in Exclude<keyof A, keyof B> as {} extends Pick<A, K> ? K : never
+    ]?: A[K];
   } extends infer O
     ? Readonly<
         {

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) &&