ts-data-forge 5.1.1 → 6.1.0

package/src/guard/has-key.test.mts

@@ -1,223 +1,126 @@
 import { expectType } from '../expect-type.mjs';
 import { hasKey, type HasKeyReturnType } from './has-key.mjs';
 
-{
-  expectType<
-    HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'a'>,
-    Readonly<{ a: 0 }>
-  >('=');
-
-  expectType<
-    HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'b'>,
-    Readonly<{ b: 1 }>
-  >('=');
-
-  expectType<
-    HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'd'>,
-    never
-  >('=');
-
-  expectType<
-    HasKeyReturnType<
-      | Readonly<{ a: 0 }>
-      | Readonly<{ a: 1; b: 1 }>
-      | Readonly<{ b: 2 }>
-      | Readonly<{ c: 3 }>,
-      'a'
-    >,
-    Readonly<{ a: 0 }> | Readonly<{ a: 1; b: 1 }>
-  >('=');
-
-  expectType<
-    HasKeyReturnType<
-      | Readonly<{ a: 0 }>
-      | Readonly<{ a: 1; b: 1 }>
-      | Readonly<{ b: 2 }>
-      | Readonly<{ c: 3 }>,
-      'b'
-    >,
-    Readonly<{ a: 1; b: 1 }> | Readonly<{ b: 2 }>
-  >('=');
-
-  expectType<
-    HasKeyReturnType<
-      | ReadonlyRecord<string, number>
-      | Readonly<{ a: 0 }>
-      | Readonly<{ a: 1; b: 1 }>
-      | Readonly<{ b: 2 }>,
-      'a'
-    >,
-    | Readonly<{ a: 0 }>
-    | Readonly<{ a: 1; b: 1 }>
-    | (ReadonlyRecord<'a', number> & ReadonlyRecord<string, number>)
-  >('=');
-
-  expectType<
-    HasKeyReturnType<ReadonlyRecord<string, unknown>, 'a'>,
-    ReadonlyRecord<'a', unknown> & ReadonlyRecord<string, unknown>
-  >('=');
-}
-
-{
-  type R = Readonly<{ a: 0 }> | Readonly<{ b: 1 }>;
-
-  const obj: R = { a: 0 } as R;
-
-  if (hasKey(obj, 'a')) {
-    expectType<typeof obj.a, 0>('=');
-
-    expectType<typeof obj, Readonly<{ a: 0 }>>('=');
-  }
-
-  if (hasKey(obj, 'c')) {
-    expectType<typeof obj, never>('=');
-  }
-}
-
-{
-  type R =
-    | Readonly<{ a: 0 }>
-    | Readonly<{ a: 1; b: 1 }>
-    | Readonly<{ b: 2 }>
-    | Readonly<{ c: 3 }>;
-
-  const obj: R = { a: 0 } as R;
-
-  if (hasKey(obj, 'a') && hasKey(obj, 'b')) {
-    expectType<typeof obj.a, 1>('=');
-
-    expectType<typeof obj.b, 1>('=');
-
-    expectType<typeof obj, Readonly<{ a: 1; b: 1 }>>('=');
-  }
-}
+test('hasKey type inferences', () => {
+  {
+    expectType<
+      HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'a'>,
+      Readonly<{ a: 0 }>
+    >('=');
 
-{
-  type R =
-    | ReadonlyRecord<string, number>
-    | Readonly<{ a: 0 }>
-    | Readonly<{ a: 1; b: 1 }>
-    | Readonly<{ b: 2 }>;
+    expectType<
+      HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'b'>,
+      Readonly<{ b: 1 }>
+    >('=');
 
-  const obj: R = { a: 0 } as R;
+    expectType<
+      HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'd'>,
+      never
+    >('=');
 
-  expectType<
-    R,
-    | ReadonlyRecord<string, number>
-    | Readonly<{ a: 0 }>
-    | Readonly<{ a: 1; b: 1 }>
-    | Readonly<{ b: 2 }>
-  >('=');
+    expectType<
+      HasKeyReturnType<
+        | Readonly<{ a: 0 }>
+        | Readonly<{ a: 1; b: 1 }>
+        | Readonly<{ b: 2 }>
+        | Readonly<{ c: 3 }>,
+        'a'
+      >,
+      Readonly<{ a: 0 }> | Readonly<{ a: 1; b: 1 }>
+    >('=');
 
-  if (hasKey(obj, 'a')) {
-    expectType<typeof obj.a, number>('=');
+    expectType<
+      HasKeyReturnType<
+        | Readonly<{ a: 0 }>
+        | Readonly<{ a: 1; b: 1 }>
+        | Readonly<{ b: 2 }>
+        | Readonly<{ c: 3 }>,
+        'b'
+      >,
+      Readonly<{ a: 1; b: 1 }> | Readonly<{ b: 2 }>
+    >('=');
 
     expectType<
-      typeof obj,
+      HasKeyReturnType<
+        | ReadonlyRecord<string, number>
+        | Readonly<{ a: 0 }>
+        | Readonly<{ a: 1; b: 1 }>
+        | Readonly<{ b: 2 }>,
+        'a'
+      >,
       | Readonly<{ a: 0 }>
       | Readonly<{ a: 1; b: 1 }>
       | (ReadonlyRecord<'a', number> & ReadonlyRecord<string, number>)
     >('=');
-  }
-
-  if (hasKey(obj, 'a') && hasKey(obj, 'b')) {
-    expectType<typeof obj.a, number>('=');
-
-    expectType<typeof obj.b, number>('=');
 
     expectType<
-      typeof obj,
-      | Readonly<{ a: 1; b: 1 }>
-      | (ReadonlyRecord<'a', number> &
-          ReadonlyRecord<'b', number> &
-          ReadonlyRecord<string, number>)
+      HasKeyReturnType<ReadonlyRecord<string, unknown>, 'a'>,
+      ReadonlyRecord<'a', unknown> & ReadonlyRecord<string, unknown>
     >('=');
   }
-}
 
-{
-  const o: ReadonlyRecord<string, unknown> = { a: 0, b: 1 };
+  {
+    type R = Readonly<{ a: 0 }> | Readonly<{ b: 1 }>;
 
-  if (hasKey(o, 'a')) {
-    expectType<typeof o.a, unknown>('=');
+    const obj: R = { a: 0 } as R;
 
-    expectType<
-      typeof o,
-      ReadonlyRecord<'a', unknown> & ReadonlyRecord<string, unknown>
-    >('=');
-  }
+    if (hasKey(obj, 'a')) {
+      expectType<typeof obj.a, 0>('=');
 
-  if (hasKey(o, 'c')) {
-    expectType<typeof o.c, unknown>('=');
+      expectType<typeof obj, Readonly<{ a: 0 }>>('=');
+    }
 
-    expectType<
-      typeof o,
-      ReadonlyRecord<'c', unknown> & ReadonlyRecord<string, unknown>
-    >('=');
+    if (hasKey(obj, 'c')) {
+      expectType<typeof obj, never>('=');
+    }
   }
 
-  if (hasKey(o, 'a') && hasKey(o, 'b')) {
-    expectType<typeof o.a, unknown>('=');
+  {
+    type R =
+      | Readonly<{ a: 0 }>
+      | Readonly<{ a: 1; b: 1 }>
+      | Readonly<{ b: 2 }>
+      | Readonly<{ c: 3 }>;
 
-    expectType<typeof o.b, unknown>('=');
+    const obj: R = { a: 0 } as R;
 
-    expectType<
-      typeof o,
-      ReadonlyRecord<'a', unknown> &
-        ReadonlyRecord<'b', unknown> &
-        ReadonlyRecord<string, unknown>
-    >('=');
+    if (hasKey(obj, 'a') && hasKey(obj, 'b')) {
+      expectType<typeof obj.a, 1>('=');
+
+      expectType<typeof obj.b, 1>('=');
+
+      expectType<typeof obj, Readonly<{ a: 1; b: 1 }>>('=');
+    }
   }
 
   {
-    /**
-     * @note Simply using `R & Record<K, R[K]>` as the return type of hasKey may seem good enough
-     * since it works as intended for cases like `obj: Record<string, unknown>`.
-     * However, for finite-sized types like `obj: { a: 0 } | { b: 1 }`,
-     * filtering with `hasKey(obj, 'a')` causes `obj.a` to widen to `unknown` instead of `0`,
-     * which doesn't work well.
-     */
-
-    const hasOwnNaive = <R extends UnknownRecord, K extends string>(
-      obj: R,
-      key: K,
-    ): obj is R & Record<K, R[K]> => hasKey(obj, key);
-
-    {
-      type O =
-        | Readonly<{ a: 0 }>
-        | Readonly<{ a: 1; b: 1 }>
-        | Readonly<{ b: 2 }>
-        | Record<string, number>;
+    type R =
+      | ReadonlyRecord<string, number>
+      | Readonly<{ a: 0 }>
+      | Readonly<{ a: 1; b: 1 }>
+      | Readonly<{ b: 2 }>;
 
-      const o2 = { b: 2 } as O;
+    const obj: R = { a: 0 } as R;
 
-      if (hasOwnNaive(o2, 'a')) {
-        expectType<typeof o2.a, unknown>('=');
-      }
+    expectType<
+      R,
+      | ReadonlyRecord<string, number>
+      | Readonly<{ a: 0 }>
+      | Readonly<{ a: 1; b: 1 }>
+      | Readonly<{ b: 2 }>
+    >('=');
 
-      // eslint-disable-next-line no-restricted-syntax
-      if ('a' in o2) {
-        expectType<typeof o2.a, number>('=');
-      }
-    }
+    if (hasKey(obj, 'a')) {
+      expectType<typeof obj.a, number>('=');
 
-    {
-      type O =
+      expectType<
+        typeof obj,
         | Readonly<{ a: 0 }>
         | Readonly<{ a: 1; b: 1 }>
-        | Readonly<{ b: 2 }>;
-
-      const o2 = { b: 2 } as O;
-
-      if (hasOwnNaive(o2, 'a')) {
-        expectType<typeof o2.a, unknown>('=');
-      }
-
-      // eslint-disable-next-line no-restricted-syntax
-      if ('a' in o2) {
-        expectType<typeof o2.a, 0 | 1>('=');
-      }
+        | (ReadonlyRecord<'a', number> & ReadonlyRecord<string, number>)
+      >('=');
     }
   }
-}
+
+  assert.strictEqual(true, true);
+});

package/src/guard/is-record.mts

@@ -38,8 +38,7 @@ import { isNonNullObject } from './is-non-null-object.mjs';
  * @see {@link isNonNullObject} - For checking any object type (includes arrays)
  * @see {@link hasKey} - For checking if a record has specific keys
  */
-export const isRecord = (u: unknown): u is UnknownRecord =>
-  isNonNullObject(u) && !Array.isArray(u);
+export const isRecord = (u: unknown): u is UnknownRecord => isNonNullObject(u);
 
 /**
  * Type guard that checks if a value is a mutable record (an object with mutable string keys).

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

@@ -2,110 +2,100 @@ import { expectType } from '../expect-type.mjs';
 import { isRecord } from './is-record.mjs';
 
 describe(isRecord, () => {
-  test('{ x: 1 } is a record', () => {
-    const obj = { x: 1 } as const;
+  describe('arrays are Records', () => {
+    test('number[] is assignable to Record<number, unknown>', () => {
+      const arr: Record<number, unknown> = [1, 2, 3];
 
-    const unk: unknown = obj;
+      const unk: unknown = arr;
 
-    const res = isRecord(unk);
+      assert.isTrue(isRecord(unk));
 
-    expectType<typeof obj, UnknownRecord>('<=');
+      expectType<typeof unk, UnknownRecord>('<=');
+    });
 
-    expectType<typeof res, boolean>('=');
+    test('string[] is assignable to Record<number, unknown>', () => {
+      const arr: Record<number, unknown> = ['1', '2', '3'];
 
-    if (res) {
-      expectType<typeof unk, UnknownRecord>('=');
-    }
+      const unk: unknown = arr;
 
-    assert.isTrue(res);
-  });
-
-  test('{} is a record', () => {
-    const obj = {} as const;
-
-    const unk: unknown = obj;
+      assert.isTrue(isRecord(unk));
 
-    const res = isRecord(unk);
+      expectType<typeof unk, UnknownRecord>('<=');
+    });
 
-    expectType<typeof obj, {}>('=');
+    test('[] is a record', () => {
+      const arr: unknown = [] as const;
 
-    expectType<typeof res, boolean>('=');
+      const unk: unknown = arr;
 
-    if (res) {
-      expectType<typeof unk, UnknownRecord>('=');
-    }
+      assert.isTrue(isRecord(unk));
 
-    assert.isTrue(res);
+      expectType<typeof unk, UnknownRecord>('<=');
+    });
   });
 
-  test('[] is not a record', () => {
-    const obj: DeepReadonly<never[]> = [] as const;
-
-    const unk: unknown = obj;
-
-    const res = isRecord(unk);
-
-    expectType<typeof obj, readonly never[]>('=');
+  describe('non-null objects are Records', () => {
+    test('{ x: 1 } is a record', () => {
+      const obj = { x: 1 } as const;
 
-    expectType<typeof res, boolean>('=');
+      const unk: unknown = obj;
 
-    assert.isFalse(res);
-  });
-
-  test('null is not a record', () => {
-    const obj = null;
+      assert.isTrue(isRecord(unk));
 
-    const unk: unknown = obj;
+      expectType<typeof unk, UnknownRecord>('<=');
+    });
 
-    const res = isRecord(unk);
+    test('{} is a record', () => {
+      const obj = {} as const;
 
-    expectType<typeof obj, null>('=');
+      const unk: unknown = obj;
 
-    expectType<typeof res, boolean>('=');
+      assert.isTrue(isRecord(unk));
 
-    assert.isFalse(res);
+      expectType<typeof unk, UnknownRecord>('<=');
+    });
   });
 
-  test('undefined is not a record', () => {
-    const obj = undefined;
-
-    const unk: unknown = obj;
+  describe('primitives are not Records', () => {
+    test('null is not a record', () => {
+      const obj = null;
 
-    const res = isRecord(unk);
+      const unk: unknown = obj;
 
-    expectType<typeof obj, undefined>('=');
+      assert.isFalse(isRecord(unk));
 
-    expectType<typeof res, boolean>('=');
+      expectType<typeof unk, UnknownRecord>('!<=');
+    });
 
-    assert.isFalse(res);
-  });
-
-  test('3 is not a record', () => {
-    const obj = 3;
+    test('undefined is not a record', () => {
+      const prm = undefined;
 
-    const unk: unknown = obj;
+      const unk: unknown = prm;
 
-    const res = isRecord(unk);
+      assert.isFalse(isRecord(unk));
 
-    expectType<typeof obj, 3>('=');
+      expectType<typeof unk, UnknownRecord>('!<=');
+    });
 
-    expectType<typeof res, boolean>('=');
+    test('3 is not a record', () => {
+      const prm = 3;
 
-    assert.isFalse(res);
-  });
+      const unk: unknown = prm;
 
-  test('"str" is not a record', () => {
-    const obj = 'str';
+      assert.isFalse(isRecord(unk));
 
-    const unk: unknown = obj;
+      expectType<typeof unk, UnknownRecord>('!<=');
+    });
 
-    const res = isRecord(unk);
+    test('"str" is not a record', () => {
+      const prm = 'str';
 
-    expectType<typeof obj, 'str'>('=');
+      const unk: unknown = prm;
 
-    expectType<typeof res, boolean>('=');
+      assert.isFalse(isRecord(unk));
 
-    assert.isFalse(res);
+      expectType<typeof unk, UnknownRecord>('!<=');
+    });
   });
 
   // test('Map is not a record', () => {

package/src/json/json.test.mts

@@ -118,11 +118,11 @@ describe('parse', () => {
   });
 
   test('should not throw errors', () => {
-    expect(() => Json.parse('{{{')).not.toThrow();
+    expect(() => Json.parse('{{{')).not.toThrowError();
 
-    expect(() => Json.parse('null null')).not.toThrow();
+    expect(() => Json.parse('null null')).not.toThrowError();
 
-    expect(() => Json.parse(String(undefined))).not.toThrow();
+    expect(() => Json.parse(String(undefined))).not.toThrowError();
   });
 
   test('should use reviver function to transform values', () => {
@@ -323,9 +323,9 @@ describe('stringify', () => {
 
     mut_circularArray.push(mut_circularArray);
 
-    expect(() => Json.stringify(mut_circularArray)).not.toThrow();
+    expect(() => Json.stringify(mut_circularArray)).not.toThrowError();
 
-    expect(() => Json.stringify({ fn: () => {} })).not.toThrow();
+    expect(() => Json.stringify({ fn: () => {} })).not.toThrowError();
   });
 
   test('should use replacer function to filter values', () => {

package/src/number/branded-types/finite-number.test.mts

@@ -6,27 +6,31 @@ import { asNonZeroFiniteNumber } from './non-zero-finite-number.mjs';
 describe('FiniteNumber test', () => {
   describe(asFiniteNumber, () => {
     test('accepts valid finite numbers', () => {
-      expect(() => asFiniteNumber(0)).not.toThrow();
+      expect(() => asFiniteNumber(0)).not.toThrowError();
 
-      expect(() => asFiniteNumber(1)).not.toThrow();
+      expect(() => asFiniteNumber(1)).not.toThrowError();
 
-      expect(() => asFiniteNumber(-1)).not.toThrow();
+      expect(() => asFiniteNumber(-1)).not.toThrowError();
 
-      expect(() => asFiniteNumber(3.14)).not.toThrow();
+      expect(() => asFiniteNumber(3.14)).not.toThrowError();
 
-      expect(() => asFiniteNumber(-2.5)).not.toThrow();
+      expect(() => asFiniteNumber(-2.5)).not.toThrowError();
 
-      expect(() => asFiniteNumber(Number.MAX_VALUE)).not.toThrow();
+      expect(() => asFiniteNumber(Number.MAX_VALUE)).not.toThrowError();
 
-      expect(() => asFiniteNumber(-Number.MAX_VALUE)).not.toThrow();
+      expect(() => asFiniteNumber(-Number.MAX_VALUE)).not.toThrowError();
     });
 
     test('rejects non-finite numbers', () => {
-      expect(() => asFiniteNumber(Number.NaN)).toThrow(TypeError);
+      expect(() => asFiniteNumber(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asFiniteNumber(Number.POSITIVE_INFINITY)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asFiniteNumber(Number.NEGATIVE_INFINITY)).toThrowError(
+        TypeError,
+      );
     });
 
     test('returns the same value for valid inputs', () => {
@@ -44,7 +48,7 @@ describe('FiniteNumber test', () => {
     ] as const)(
       `asFiniteNumber($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asFiniteNumber(value)).toThrow(
+        expect(() => asFiniteNumber(value)).toThrowError(
           new TypeError(`Expected a finite number, got: ${value}`),
         );
       },

package/src/number/branded-types/int.test.mts

@@ -6,31 +6,31 @@ import { asNonZeroInt } from './non-zero-int.mjs';
 describe('Int test', () => {
   describe(asInt, () => {
     test('accepts valid integers', () => {
-      expect(() => asInt(0)).not.toThrow();
+      expect(() => asInt(0)).not.toThrowError();
 
-      expect(() => asInt(1)).not.toThrow();
+      expect(() => asInt(1)).not.toThrowError();
 
-      expect(() => asInt(-1)).not.toThrow();
+      expect(() => asInt(-1)).not.toThrowError();
 
-      expect(() => asInt(42)).not.toThrow();
+      expect(() => asInt(42)).not.toThrowError();
 
-      expect(() => asInt(-42)).not.toThrow();
+      expect(() => asInt(-42)).not.toThrowError();
 
-      expect(() => asInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+      expect(() => asInt(Number.MAX_SAFE_INTEGER)).not.toThrowError();
 
-      expect(() => asInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
+      expect(() => asInt(Number.MIN_SAFE_INTEGER)).not.toThrowError();
     });
 
     test('rejects non-integers', () => {
-      expect(() => asInt(Number.NaN)).toThrow(TypeError);
+      expect(() => asInt(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asInt(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asInt(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asInt(1.2)).toThrow(TypeError);
+      expect(() => asInt(1.2)).toThrowError(TypeError);
 
-      expect(() => asInt(-3.4)).toThrow(TypeError);
+      expect(() => asInt(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -48,7 +48,7 @@ describe('Int test', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
     ] as const)(`asInt($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asInt(value)).toThrow(
+      expect(() => asInt(value)).toThrowError(
         new TypeError(`Expected an integer, got: ${value}`),
       );
     });