ts-data-forge 5.1.1 → 6.1.0

package/src/number/branded-types/positive-uint32.test.mts

@@ -9,45 +9,45 @@ import {
 describe('PositiveUint32 test', () => {
   describe(asPositiveUint32, () => {
     test('accepts valid positive uint32 values', () => {
-      expect(() => asPositiveUint32(1)).not.toThrow();
+      expect(() => asPositiveUint32(1)).not.toThrowError();
 
-      expect(() => asPositiveUint32(1000)).not.toThrow();
+      expect(() => asPositiveUint32(1000)).not.toThrowError();
 
-      expect(() => asPositiveUint32(4_294_967_295)).not.toThrow(); // 2^32 - 1
+      expect(() => asPositiveUint32(4_294_967_295)).not.toThrowError(); // 2^32 - 1
 
-      expect(() => asPositiveUint32(2_147_483_648)).not.toThrow(); // 2^31
+      expect(() => asPositiveUint32(2_147_483_648)).not.toThrowError(); // 2^31
     });
 
     test('rejects zero', () => {
-      expect(() => asPositiveUint32(0)).toThrow(TypeError);
+      expect(() => asPositiveUint32(0)).toThrowError(TypeError);
     });
 
     test('rejects values outside uint32 range', () => {
-      expect(() => asPositiveUint32(4_294_967_296)).toThrow(TypeError); // 2^32
+      expect(() => asPositiveUint32(4_294_967_296)).toThrowError(TypeError); // 2^32
 
-      expect(() => asPositiveUint32(10_000_000_000)).toThrow(TypeError);
+      expect(() => asPositiveUint32(10_000_000_000)).toThrowError(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asPositiveUint32(-1)).toThrow(TypeError);
+      expect(() => asPositiveUint32(-1)).toThrowError(TypeError);
 
-      expect(() => asPositiveUint32(-42)).toThrow(TypeError);
+      expect(() => asPositiveUint32(-42)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asPositiveUint32(Number.NaN)).toThrow(TypeError);
+      expect(() => asPositiveUint32(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asPositiveUint32(Number.POSITIVE_INFINITY)).toThrow(
+      expect(() => asPositiveUint32(Number.POSITIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveUint32(Number.NEGATIVE_INFINITY)).toThrow(
+      expect(() => asPositiveUint32(Number.NEGATIVE_INFINITY)).toThrowError(
         TypeError,
       );
 
-      expect(() => asPositiveUint32(1.2)).toThrow(TypeError);
+      expect(() => asPositiveUint32(1.2)).toThrowError(TypeError);
 
-      expect(() => asPositiveUint32(-3.4)).toThrow(TypeError);
+      expect(() => asPositiveUint32(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -70,7 +70,7 @@ describe('PositiveUint32 test', () => {
     ] as const)(
       `asPositiveUint32($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asPositiveUint32(value)).toThrow(
+        expect(() => asPositiveUint32(value)).toThrowError(
           new TypeError(
             `Expected a positive integer in [1, 2^32), got: ${value}`,
           ),

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

@@ -5,41 +5,45 @@ import { asSafeInt, SafeInt } from './safe-int.mjs';
 describe('SafeInt test', () => {
   describe(asSafeInt, () => {
     test('accepts valid safe integers', () => {
-      expect(() => asSafeInt(0)).not.toThrow();
+      expect(() => asSafeInt(0)).not.toThrowError();
 
-      expect(() => asSafeInt(1)).not.toThrow();
+      expect(() => asSafeInt(1)).not.toThrowError();
 
-      expect(() => asSafeInt(-1)).not.toThrow();
+      expect(() => asSafeInt(-1)).not.toThrowError();
 
-      expect(() => asSafeInt(42)).not.toThrow();
+      expect(() => asSafeInt(42)).not.toThrowError();
 
-      expect(() => asSafeInt(-42)).not.toThrow();
+      expect(() => asSafeInt(-42)).not.toThrowError();
 
-      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER)).not.toThrowError();
 
-      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
+      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER)).not.toThrowError();
     });
 
     test('rejects values outside safe integer range', () => {
-      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.MAX_SAFE_INTEGER + 1)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER - 1)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.MIN_SAFE_INTEGER - 1)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asSafeInt(Number.MAX_VALUE)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.MAX_VALUE)).toThrowError(TypeError);
 
-      expect(() => asSafeInt(-Number.MAX_VALUE)).toThrow(TypeError);
+      expect(() => asSafeInt(-Number.MAX_VALUE)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asSafeInt(Number.NaN)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asSafeInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asSafeInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asSafeInt(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asSafeInt(1.2)).toThrow(TypeError);
+      expect(() => asSafeInt(1.2)).toThrowError(TypeError);
 
-      expect(() => asSafeInt(-3.4)).toThrow(TypeError);
+      expect(() => asSafeInt(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -61,7 +65,7 @@ describe('SafeInt test', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
     ] as const)(`asSafeInt($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asSafeInt(value)).toThrow(
+      expect(() => asSafeInt(value)).toThrowError(
         new TypeError(`Expected a safe integer, got: ${value}`),
       );
     });

package/src/number/branded-types/safe-uint.test.mts

@@ -5,41 +5,47 @@ import { asSafeUint, isSafeUint, SafeUint } from './safe-uint.mjs';
 describe('SafeUint test', () => {
   describe(asSafeUint, () => {
     test('accepts valid safe unsigned integers', () => {
-      expect(() => asSafeUint(0)).not.toThrow();
+      expect(() => asSafeUint(0)).not.toThrowError();
 
-      expect(() => asSafeUint(1)).not.toThrow();
+      expect(() => asSafeUint(1)).not.toThrowError();
 
-      expect(() => asSafeUint(42)).not.toThrow();
+      expect(() => asSafeUint(42)).not.toThrowError();
 
-      expect(() => asSafeUint(100)).not.toThrow();
+      expect(() => asSafeUint(100)).not.toThrowError();
 
-      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER)).not.toThrow();
+      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER)).not.toThrowError();
     });
 
     test('rejects negative numbers', () => {
-      expect(() => asSafeUint(-1)).toThrow(TypeError);
+      expect(() => asSafeUint(-1)).toThrowError(TypeError);
 
-      expect(() => asSafeUint(-42)).toThrow(TypeError);
+      expect(() => asSafeUint(-42)).toThrowError(TypeError);
 
-      expect(() => asSafeUint(Number.MIN_SAFE_INTEGER)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.MIN_SAFE_INTEGER)).toThrowError(TypeError);
     });
 
     test('rejects values outside safe integer range', () => {
-      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER + 1)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.MAX_SAFE_INTEGER + 1)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asSafeUint(Number.MAX_VALUE)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.MAX_VALUE)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asSafeUint(Number.NaN)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asSafeUint(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.POSITIVE_INFINITY)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asSafeUint(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asSafeUint(Number.NEGATIVE_INFINITY)).toThrowError(
+        TypeError,
+      );
 
-      expect(() => asSafeUint(1.2)).toThrow(TypeError);
+      expect(() => asSafeUint(1.2)).toThrowError(TypeError);
 
-      expect(() => asSafeUint(-3.4)).toThrow(TypeError);
+      expect(() => asSafeUint(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -60,7 +66,7 @@ describe('SafeUint test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '-1', value: -1 },
     ] as const)(`asSafeUint($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asSafeUint(value)).toThrow(
+      expect(() => asSafeUint(value)).toThrowError(
         new TypeError(`Expected a non-negative safe integer, got: ${value}`),
       );
     });

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

@@ -5,35 +5,35 @@ import { asUint, isUint, Uint } from './uint.mjs';
 describe('Uint test', () => {
   describe(asUint, () => {
     test('accepts valid unsigned integers', () => {
-      expect(() => asUint(0)).not.toThrow();
+      expect(() => asUint(0)).not.toThrowError();
 
-      expect(() => asUint(1)).not.toThrow();
+      expect(() => asUint(1)).not.toThrowError();
 
-      expect(() => asUint(42)).not.toThrow();
+      expect(() => asUint(42)).not.toThrowError();
 
-      expect(() => asUint(100)).not.toThrow();
+      expect(() => asUint(100)).not.toThrowError();
 
-      expect(() => asUint(Number.MAX_SAFE_INTEGER)).not.toThrow();
+      expect(() => asUint(Number.MAX_SAFE_INTEGER)).not.toThrowError();
     });
 
     test('rejects negative integers', () => {
-      expect(() => asUint(-1)).toThrow(TypeError);
+      expect(() => asUint(-1)).toThrowError(TypeError);
 
-      expect(() => asUint(-42)).toThrow(TypeError);
+      expect(() => asUint(-42)).toThrowError(TypeError);
 
-      expect(() => asUint(Number.MIN_SAFE_INTEGER)).toThrow(TypeError);
+      expect(() => asUint(Number.MIN_SAFE_INTEGER)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asUint(Number.NaN)).toThrow(TypeError);
+      expect(() => asUint(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asUint(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asUint(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asUint(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asUint(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asUint(1.2)).toThrow(TypeError);
+      expect(() => asUint(1.2)).toThrowError(TypeError);
 
-      expect(() => asUint(-3.4)).toThrow(TypeError);
+      expect(() => asUint(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -52,7 +52,7 @@ describe('Uint test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '-1', value: -1 },
     ] as const)(`asUint($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asUint(value)).toThrow(
+      expect(() => asUint(value)).toThrowError(
         new TypeError(`Expected a non-negative integer, got: ${value}`),
       );
     });

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

@@ -6,37 +6,37 @@ import { asUint16, isUint16, Uint16 } from './uint16.mjs';
 describe('Uint16 test', () => {
   describe(asUint16, () => {
     test('accepts valid uint16 values', () => {
-      expect(() => asUint16(0)).not.toThrow();
+      expect(() => asUint16(0)).not.toThrowError();
 
-      expect(() => asUint16(1)).not.toThrow();
+      expect(() => asUint16(1)).not.toThrowError();
 
-      expect(() => asUint16(65_535)).not.toThrow(); // 2^16 - 1
+      expect(() => asUint16(65_535)).not.toThrowError(); // 2^16 - 1
 
-      expect(() => asUint16(32_768)).not.toThrow(); // 2^15
+      expect(() => asUint16(32_768)).not.toThrowError(); // 2^15
     });
 
     test('rejects values outside uint16 range', () => {
-      expect(() => asUint16(65_536)).toThrow(TypeError); // 2^16
+      expect(() => asUint16(65_536)).toThrowError(TypeError); // 2^16
 
-      expect(() => asUint16(100_000)).toThrow(TypeError);
+      expect(() => asUint16(100_000)).toThrowError(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asUint16(-1)).toThrow(TypeError);
+      expect(() => asUint16(-1)).toThrowError(TypeError);
 
-      expect(() => asUint16(-42)).toThrow(TypeError);
+      expect(() => asUint16(-42)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asUint16(Number.NaN)).toThrow(TypeError);
+      expect(() => asUint16(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asUint16(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asUint16(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asUint16(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asUint16(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asUint16(1.2)).toThrow(TypeError);
+      expect(() => asUint16(1.2)).toThrowError(TypeError);
 
-      expect(() => asUint16(-3.4)).toThrow(TypeError);
+      expect(() => asUint16(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -55,7 +55,7 @@ describe('Uint16 test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '-1', value: -1 },
     ] as const)(`asUint16($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asUint16(value)).toThrow(
+      expect(() => asUint16(value)).toThrowError(
         new TypeError(
           `Expected a non-negative integer less than 2^16, got: ${value}`,
         ),

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

@@ -6,37 +6,37 @@ import { asUint32, isUint32, Uint32 } from './uint32.mjs';
 describe('Uint32 test', () => {
   describe(asUint32, () => {
     test('accepts valid uint32 values', () => {
-      expect(() => asUint32(0)).not.toThrow();
+      expect(() => asUint32(0)).not.toThrowError();
 
-      expect(() => asUint32(1)).not.toThrow();
+      expect(() => asUint32(1)).not.toThrowError();
 
-      expect(() => asUint32(4_294_967_295)).not.toThrow(); // 2^32 - 1
+      expect(() => asUint32(4_294_967_295)).not.toThrowError(); // 2^32 - 1
 
-      expect(() => asUint32(2_147_483_648)).not.toThrow(); // 2^31
+      expect(() => asUint32(2_147_483_648)).not.toThrowError(); // 2^31
     });
 
     test('rejects values outside uint32 range', () => {
-      expect(() => asUint32(4_294_967_296)).toThrow(TypeError); // 2^32
+      expect(() => asUint32(4_294_967_296)).toThrowError(TypeError); // 2^32
 
-      expect(() => asUint32(10_000_000_000)).toThrow(TypeError);
+      expect(() => asUint32(10_000_000_000)).toThrowError(TypeError);
     });
 
     test('rejects negative integers', () => {
-      expect(() => asUint32(-1)).toThrow(TypeError);
+      expect(() => asUint32(-1)).toThrowError(TypeError);
 
-      expect(() => asUint32(-42)).toThrow(TypeError);
+      expect(() => asUint32(-42)).toThrowError(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asUint32(Number.NaN)).toThrow(TypeError);
+      expect(() => asUint32(Number.NaN)).toThrowError(TypeError);
 
-      expect(() => asUint32(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asUint32(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asUint32(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+      expect(() => asUint32(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
 
-      expect(() => asUint32(1.2)).toThrow(TypeError);
+      expect(() => asUint32(1.2)).toThrowError(TypeError);
 
-      expect(() => asUint32(-3.4)).toThrow(TypeError);
+      expect(() => asUint32(-3.4)).toThrowError(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -55,7 +55,7 @@ describe('Uint32 test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '-1', value: -1 },
     ] as const)(`asUint32($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asUint32(value)).toThrow(
+      expect(() => asUint32(value)).toThrowError(
         new TypeError(
           `Expected a non-negative integer less than 2^32, got: ${value}`,
         ),

package/src/number/enum/int8.test.mts

@@ -35,7 +35,7 @@ describe('Int8 test', () => {
       { value: Number.POSITIVE_INFINITY, name: 'Infinity' },
       { value: Number.NEGATIVE_INFINITY, name: '-Infinity' },
     ])('asInt8($name) should throw TypeError', ({ value }) => {
-      expect(() => asInt8(value)).toThrow(TypeError);
+      expect(() => asInt8(value)).toThrowError(TypeError);
     });
   });
 

package/src/number/enum/uint8.test.mts

@@ -35,7 +35,7 @@ describe('Uint8 test', () => {
       { value: Number.POSITIVE_INFINITY, name: 'Infinity' },
       { value: Number.NEGATIVE_INFINITY, name: '-Infinity' },
     ])('asUint8($name) should throw TypeError', ({ value }) => {
-      expect(() => asUint8(value)).toThrow(TypeError);
+      expect(() => asUint8(value)).toThrowError(TypeError);
     });
   });
 

package/src/others/memoize-function.test.mts

@@ -51,6 +51,7 @@ describe(memoizeFunction, () => {
     expect(mockFn).toHaveBeenCalledOnce();
 
     // Should use cache even for undefined
+
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
     expect(memoized(5)).toBeUndefined();