ts-data-forge 6.7.0 → 6.9.0

package/src/array/impl/array-utils-transformation.mts

@@ -4,6 +4,7 @@ import { asPositiveUint32, asUint32, Uint32 } from '../../number/index.mjs';
 import { castMutable, tp } from '../../others/index.mjs';
 import { newArray, seq } from './array-utils-creation.mjs';
 import { size } from './array-utils-size.mjs';
+import { isNonEmpty } from './array-utils-validation.mjs';
 
 /**
  * Creates a new array by transforming each element with a mapping function.
@@ -809,3 +810,42 @@ export const zip = <
  * @see {@link partition}
  */
 export const chunk = partition;
+
+/**
+ * Computes the cartesian product of arrays.
+ * cartesianProduct([[1,2], [3,4]]) => [[1,3], [1,4], [2,3], [2,4]]
+ *
+ * @example
+ *
+ *
+ * ```ts
+ * const sizes = ['S', 'M'] as const;
+ *
+ * const colors = ['red', 'blue'] as const;
+ *
+ * const combinations = Arr.cartesianProduct([sizes, colors]);
+ *
+ * const expectedCombinations = [
+ *   ['S', 'red'],
+ *   ['S', 'blue'],
+ *   ['M', 'red'],
+ *   ['M', 'blue'],
+ * ] as const;
+ *
+ * assert.deepStrictEqual(combinations, expectedCombinations);
+ * ```
+ */
+export const cartesianProduct = <T,>(
+  arrays: readonly (readonly T[])[],
+): readonly (readonly T[])[] => {
+  if (!isNonEmpty(arrays)) return [[]];
+
+  const [first, ...rest] = arrays;
+
+  // If first array is empty, the result is empty
+  if (!isNonEmpty(first)) return [];
+
+  const restProduct = cartesianProduct(rest);
+
+  return first.flatMap((item) => restProduct.map((prod) => [item, ...prod]));
+};

package/src/array/impl/array-utils-transformation.test.mts

@@ -3,6 +3,7 @@ import { expectType } from '../../expect-type.mjs';
 import { Optional } from '../../functional/index.mjs';
 import { SafeUint } from '../../number/index.mjs';
 import {
+  cartesianProduct,
   concat,
   filter,
   filterNot,
@@ -1093,4 +1094,57 @@ describe('Arr transformations', () => {
       assert.deepStrictEqual(result, []);
     });
   });
+
+  describe(cartesianProduct, () => {
+    test('Empty array', () => {
+      assert.deepStrictEqual(cartesianProduct([]), [[]]);
+    });
+
+    test('Single array', () => {
+      assert.deepStrictEqual(cartesianProduct([[1, 2, 3]]), [[1], [2], [3]]);
+    });
+
+    test('Two arrays', () => {
+      assert.deepStrictEqual(
+        cartesianProduct([
+          [1, 2],
+          [3, 4],
+        ]),
+        [
+          [1, 3],
+          [1, 4],
+          [2, 3],
+          [2, 4],
+        ],
+      );
+    });
+
+    test('Three arrays', () => {
+      assert.deepStrictEqual(
+        cartesianProduct<string | number | boolean>([
+          ['a', 'b'],
+          [1, 2],
+          [true, false],
+        ]),
+        [
+          ['a', 1, true],
+          ['a', 1, false],
+          ['a', 2, true],
+          ['a', 2, false],
+          ['b', 1, true],
+          ['b', 1, false],
+          ['b', 2, true],
+          ['b', 2, false],
+        ],
+      );
+    });
+
+    test('Array with empty array', () => {
+      assert.deepStrictEqual(cartesianProduct([[1, 2], [], [3, 4]]), []);
+    });
+
+    test('Single element arrays', () => {
+      assert.deepStrictEqual(cartesianProduct([[1], [2], [3]]), [[1, 2, 3]]);
+    });
+  });
 });

package/src/array/impl/array-utils-validation.mts

@@ -106,9 +106,7 @@ export const isNonEmpty = <E,>(
 export const isArrayOfLength = <E, N extends SizeType.ArgArr>(
   array: readonly E[],
   len: N,
-): array is ArrayOfLength<N, E> =>
-  // eslint-disable-next-line ts-data-forge/prefer-arr-is-array-of-length
-  array.length === len;
+): array is ArrayOfLength<N, E> => array.length === len;
 
 /**
  * Checks if an array has at least a specific length.
@@ -132,9 +130,7 @@ export const isArrayOfLength = <E, N extends SizeType.ArgArr>(
 export const isArrayAtLeastLength = <E, N extends SizeType.ArgArr>(
   array: readonly E[],
   len: N,
-): array is ArrayAtLeastLen<N, E> =>
-  // eslint-disable-next-line ts-data-forge/prefer-arr-is-array-at-least-length
-  array.length >= len;
+): array is ArrayAtLeastLen<N, E> => array.length >= len;
 
 /**
  * Tests whether all elements in an array pass a test implemented by a predicate.

package/src/functional/optional.test.mts

@@ -218,7 +218,7 @@ describe('Optional test', () => {
     });
 
     test('should throw for None', () => {
-      expect(() => Optional.unwrapThrow(Optional.none)).toThrowError(
+      expect(() => Optional.unwrapThrow(Optional.none)).toThrow(
         '`unwrapThrow()` has failed because it is `None`',
       );
     });
@@ -300,9 +300,7 @@ describe('Optional test', () => {
     test('should throw with custom message for None', () => {
       const expectNumber = Optional.expectToBe<number>('Expected a number');
 
-      expect(() => expectNumber(Optional.none)).toThrowError(
-        'Expected a number',
-      );
+      expect(() => expectNumber(Optional.none)).toThrow('Expected a number');
     });
 
     test('should be curried', () => {
@@ -314,7 +312,7 @@ describe('Optional test', () => {
 
       expect(expectValidId(id1)).toBe('user-123');
 
-      expect(() => expectValidId(id2)).toThrowError('ID is required');
+      expect(() => expectValidId(id2)).toThrow('ID is required');
     });
 
     test('should support curried form', () => {
@@ -328,7 +326,7 @@ describe('Optional test', () => {
 
       const noneValue = Optional.none;
 
-      expect(() => getValue(noneValue)).toThrowError('Value must exist');
+      expect(() => getValue(noneValue)).toThrow('Value must exist');
     });
 
     test('should work with pipe when curried', () => {
@@ -340,7 +338,7 @@ describe('Optional test', () => {
 
       assert.deepStrictEqual(someResult, { name: 'Alice', age: 30 });
 
-      expect(() => pipe(Optional.none).map(expectUser).value).toThrowError(
+      expect(() => pipe(Optional.none).map(expectUser).value).toThrow(
         'User not found',
       );
     });

package/src/functional/result.test.mts

@@ -248,7 +248,7 @@ describe('Result test', () => {
     test('throws on Err result', () => {
       const result = Result.err('error message');
 
-      expect(() => Result.unwrapThrow(result)).toThrowError('error message');
+      expect(() => Result.unwrapThrow(result)).toThrow('error message');
     });
   });
 
@@ -589,7 +589,7 @@ describe('Result test', () => {
     test('should throw for Ok', () => {
       const result = Result.ok(42);
 
-      expect(() => Result.unwrapErrThrow(result)).toThrowError(
+      expect(() => Result.unwrapErrThrow(result)).toThrow(
         'Expected Err but got Ok: 42',
       );
     });
@@ -599,7 +599,7 @@ describe('Result test', () => {
 
       expect(() =>
         Result.unwrapErrThrow(result, (obj) => `Object(id=${obj.id})`),
-      ).toThrowError('Expected Err but got Ok: Object(id=1)');
+      ).toThrow('Expected Err but got Ok: Object(id=1)');
     });
   });
 
@@ -665,9 +665,9 @@ describe('Result test', () => {
     test('should throw custom error for Err result', () => {
       const result = Result.err('failed');
 
-      expect(() =>
-        Result.expectToBe(result, 'Operation must succeed'),
-      ).toThrowError('Operation must succeed');
+      expect(() => Result.expectToBe(result, 'Operation must succeed')).toThrow(
+        'Operation must succeed',
+      );
     });
 
     test('should support curried form', () => {
@@ -681,9 +681,7 @@ describe('Result test', () => {
 
       const errResult: Result<string, string> = Result.err('failed');
 
-      expect(() => mustBeOk(errResult)).toThrowError(
-        'Expected successful result',
-      );
+      expect(() => mustBeOk(errResult)).toThrow('Expected successful result');
     });
 
     test('should work with pipe when curried', () => {
@@ -695,7 +693,7 @@ describe('Result test', () => {
 
       expect(
         () => pipe(Result.err('validation error')).map(mustBeOk).value,
-      ).toThrowError('Validation failed');
+      ).toThrow('Validation failed');
     });
   });
 

package/src/functional/ternary-result.test.mts

@@ -171,15 +171,15 @@ describe('TernaryResult test', () => {
   test('throwing unwrap variants provide descriptive errors', () => {
     expect(() =>
       TernaryResult.unwrapThrow(TernaryResult.warn('notice', 'warned')),
-    ).toThrowError(/Warn/u);
+    ).toThrow(/Warn/u);
 
     expect(() =>
       TernaryResult.unwrapWarnThrow(TernaryResult.err('no warn')),
-    ).toThrowError(/Err/u);
+    ).toThrow(/Err/u);
 
     expect(() =>
       TernaryResult.unwrapErrThrow(TernaryResult.ok('no err')),
-    ).toThrowError(/Ok/u);
+    ).toThrow(/Ok/u);
   });
 
   test('expectToBe unwraps Ok values', () => {
@@ -187,7 +187,7 @@ describe('TernaryResult test', () => {
 
     expect(() =>
       TernaryResult.expectToBe(TernaryResult.err('x'), 'missing'),
-    ).toThrowError(/missing/u);
+    ).toThrow(/missing/u);
   });
 
   test('zip prefers Err over Warn or Ok.', () => {

package/src/json/json.test.mts

@@ -118,11 +118,11 @@ describe('parse', () => {
   });
 
   test('should not throw errors', () => {
-    expect(() => Json.parse('{{{')).not.toThrowError();
+    expect(() => Json.parse('{{{')).not.toThrow();
 
-    expect(() => Json.parse('null null')).not.toThrowError();
+    expect(() => Json.parse('null null')).not.toThrow();
 
-    expect(() => Json.parse(String(undefined))).not.toThrowError();
+    expect(() => Json.parse(String(undefined))).not.toThrow();
   });
 
   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.toThrowError();
+    expect(() => Json.stringify(mut_circularArray)).not.toThrow();
 
-    expect(() => Json.stringify({ fn: () => {} })).not.toThrowError();
+    expect(() => Json.stringify({ fn: () => {} })).not.toThrow();
   });
 
   test('should use replacer function to filter values', () => {

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

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

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

@@ -6,37 +6,37 @@ import { asNonZeroInt16 } from './non-zero-int16.mjs';
 describe('Int16 test', () => {
   describe(asInt16, () => {
     test('accepts valid int16 values', () => {
-      expect(() => asInt16(0)).not.toThrowError();
+      expect(() => asInt16(0)).not.toThrow();
 
-      expect(() => asInt16(1)).not.toThrowError();
+      expect(() => asInt16(1)).not.toThrow();
 
-      expect(() => asInt16(-1)).not.toThrowError();
+      expect(() => asInt16(-1)).not.toThrow();
 
-      expect(() => asInt16(32_767)).not.toThrowError(); // 2^15 - 1
+      expect(() => asInt16(32_767)).not.toThrow(); // 2^15 - 1
 
-      expect(() => asInt16(-32_768)).not.toThrowError(); // -2^15
+      expect(() => asInt16(-32_768)).not.toThrow(); // -2^15
     });
 
     test('rejects values outside int16 range', () => {
-      expect(() => asInt16(32_768)).toThrowError(TypeError); // 2^15
+      expect(() => asInt16(32_768)).toThrow(TypeError); // 2^15
 
-      expect(() => asInt16(-32_769)).toThrowError(TypeError); // -2^15 - 1
+      expect(() => asInt16(-32_769)).toThrow(TypeError); // -2^15 - 1
 
-      expect(() => asInt16(65_536)).toThrowError(TypeError);
+      expect(() => asInt16(65_536)).toThrow(TypeError);
 
-      expect(() => asInt16(-65_536)).toThrowError(TypeError);
+      expect(() => asInt16(-65_536)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asInt16(Number.NaN)).toThrowError(TypeError);
+      expect(() => asInt16(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asInt16(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asInt16(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asInt16(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asInt16(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asInt16(1.2)).toThrowError(TypeError);
+      expect(() => asInt16(1.2)).toThrow(TypeError);
 
-      expect(() => asInt16(-3.4)).toThrowError(TypeError);
+      expect(() => asInt16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -58,7 +58,7 @@ describe('Int16 test', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
     ] as const)(`asInt16($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asInt16(value)).toThrowError(
+      expect(() => asInt16(value)).toThrow(
         new TypeError(`Expected an integer in [-2^15, 2^15), got: ${value}`),
       );
     });

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

@@ -6,37 +6,37 @@ import { asNonZeroInt32 } from './non-zero-int32.mjs';
 describe('Int32 test', () => {
   describe(asInt32, () => {
     test('accepts valid int32 values', () => {
-      expect(() => asInt32(0)).not.toThrowError();
+      expect(() => asInt32(0)).not.toThrow();
 
-      expect(() => asInt32(1)).not.toThrowError();
+      expect(() => asInt32(1)).not.toThrow();
 
-      expect(() => asInt32(-1)).not.toThrowError();
+      expect(() => asInt32(-1)).not.toThrow();
 
-      expect(() => asInt32(2_147_483_647)).not.toThrowError(); // 2^31 - 1
+      expect(() => asInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
 
-      expect(() => asInt32(-2_147_483_648)).not.toThrowError(); // -2^31
+      expect(() => asInt32(-2_147_483_648)).not.toThrow(); // -2^31
     });
 
     test('rejects values outside int32 range', () => {
-      expect(() => asInt32(2_147_483_648)).toThrowError(TypeError); // 2^31
+      expect(() => asInt32(2_147_483_648)).toThrow(TypeError); // 2^31
 
-      expect(() => asInt32(-2_147_483_649)).toThrowError(TypeError); // -2^31 - 1
+      expect(() => asInt32(-2_147_483_649)).toThrow(TypeError); // -2^31 - 1
 
-      expect(() => asInt32(4_294_967_296)).toThrowError(TypeError);
+      expect(() => asInt32(4_294_967_296)).toThrow(TypeError);
 
-      expect(() => asInt32(-4_294_967_296)).toThrowError(TypeError);
+      expect(() => asInt32(-4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asInt32(Number.NaN)).toThrowError(TypeError);
+      expect(() => asInt32(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asInt32(Number.POSITIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asInt32(Number.POSITIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asInt32(Number.NEGATIVE_INFINITY)).toThrowError(TypeError);
+      expect(() => asInt32(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
 
-      expect(() => asInt32(1.2)).toThrowError(TypeError);
+      expect(() => asInt32(1.2)).toThrow(TypeError);
 
-      expect(() => asInt32(-3.4)).toThrowError(TypeError);
+      expect(() => asInt32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -58,7 +58,7 @@ describe('Int32 test', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
     ] as const)(`asInt32($name) should throw a TypeError`, ({ value }) => {
-      expect(() => asInt32(value)).toThrowError(
+      expect(() => asInt32(value)).toThrow(
         new TypeError(`Expected an integer in [-2^31, 2^31), got: ${value}`),
       );
     });

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

@@ -9,41 +9,37 @@ import {
 describe('NonNegativeFiniteNumber test', () => {
   describe(asNonNegativeFiniteNumber, () => {
     test('accepts valid non-negative finite numbers', () => {
-      expect(() => asNonNegativeFiniteNumber(0)).not.toThrowError();
+      expect(() => asNonNegativeFiniteNumber(0)).not.toThrow();
 
-      expect(() => asNonNegativeFiniteNumber(1)).not.toThrowError();
+      expect(() => asNonNegativeFiniteNumber(1)).not.toThrow();
 
-      expect(() => asNonNegativeFiniteNumber(3.14)).not.toThrowError();
+      expect(() => asNonNegativeFiniteNumber(3.14)).not.toThrow();
 
-      expect(() => asNonNegativeFiniteNumber(0.5)).not.toThrowError();
+      expect(() => asNonNegativeFiniteNumber(0.5)).not.toThrow();
 
-      expect(() =>
-        asNonNegativeFiniteNumber(Number.MAX_VALUE),
-      ).not.toThrowError();
+      expect(() => asNonNegativeFiniteNumber(Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects negative numbers', () => {
-      expect(() => asNonNegativeFiniteNumber(-1)).toThrowError(TypeError);
+      expect(() => asNonNegativeFiniteNumber(-1)).toThrow(TypeError);
 
-      expect(() => asNonNegativeFiniteNumber(-0.1)).toThrowError(TypeError);
+      expect(() => asNonNegativeFiniteNumber(-0.1)).toThrow(TypeError);
 
-      expect(() => asNonNegativeFiniteNumber(-Number.MAX_VALUE)).toThrowError(
+      expect(() => asNonNegativeFiniteNumber(-Number.MAX_VALUE)).toThrow(
         TypeError,
       );
     });
 
     test('rejects non-finite numbers', () => {
-      expect(() => asNonNegativeFiniteNumber(Number.NaN)).toThrowError(
+      expect(() => asNonNegativeFiniteNumber(Number.NaN)).toThrow(TypeError);
+
+      expect(() => asNonNegativeFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() =>
-        asNonNegativeFiniteNumber(Number.POSITIVE_INFINITY),
-      ).toThrowError(TypeError);
-
-      expect(() =>
-        asNonNegativeFiniteNumber(Number.NEGATIVE_INFINITY),
-      ).toThrowError(TypeError);
+      expect(() => asNonNegativeFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(
+        TypeError,
+      );
     });
 
     test('returns the same value for valid inputs', () => {
@@ -62,7 +58,7 @@ describe('NonNegativeFiniteNumber test', () => {
     ] as const)(
       `asNonNegativeFiniteNumber($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asNonNegativeFiniteNumber(value)).toThrowError(
+        expect(() => asNonNegativeFiniteNumber(value)).toThrow(
           new TypeError(`Expected a non-negative finite number, got: ${value}`),
         );
       },

package/src/number/branded-types/non-negative-int16.test.mts

@@ -10,43 +10,43 @@ import { asPositiveInt16 } from './positive-int16.mjs';
 describe('NonNegativeInt16 test', () => {
   describe(asNonNegativeInt16, () => {
     test('accepts valid non-negative int16 values', () => {
-      expect(() => asNonNegativeInt16(0)).not.toThrowError();
+      expect(() => asNonNegativeInt16(0)).not.toThrow();
 
-      expect(() => asNonNegativeInt16(1)).not.toThrowError();
+      expect(() => asNonNegativeInt16(1)).not.toThrow();
 
-      expect(() => asNonNegativeInt16(1000)).not.toThrowError();
+      expect(() => asNonNegativeInt16(1000)).not.toThrow();
 
-      expect(() => asNonNegativeInt16(32_767)).not.toThrowError(); // 2^15 - 1
+      expect(() => asNonNegativeInt16(32_767)).not.toThrow(); // 2^15 - 1
     });
 
     test('rejects negative integers', () => {
-      expect(() => asNonNegativeInt16(-1)).toThrowError(TypeError);
+      expect(() => asNonNegativeInt16(-1)).toThrow(TypeError);
 
-      expect(() => asNonNegativeInt16(-42)).toThrowError(TypeError);
+      expect(() => asNonNegativeInt16(-42)).toThrow(TypeError);
 
-      expect(() => asNonNegativeInt16(-32_768)).toThrowError(TypeError);
+      expect(() => asNonNegativeInt16(-32_768)).toThrow(TypeError);
     });
 
     test('rejects values outside int16 range', () => {
-      expect(() => asNonNegativeInt16(32_768)).toThrowError(TypeError); // 2^15
+      expect(() => asNonNegativeInt16(32_768)).toThrow(TypeError); // 2^15
 
-      expect(() => asNonNegativeInt16(65_536)).toThrowError(TypeError);
+      expect(() => asNonNegativeInt16(65_536)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
-      expect(() => asNonNegativeInt16(Number.NaN)).toThrowError(TypeError);
+      expect(() => asNonNegativeInt16(Number.NaN)).toThrow(TypeError);
 
-      expect(() => asNonNegativeInt16(Number.POSITIVE_INFINITY)).toThrowError(
+      expect(() => asNonNegativeInt16(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() => asNonNegativeInt16(Number.NEGATIVE_INFINITY)).toThrowError(
+      expect(() => asNonNegativeInt16(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
 
-      expect(() => asNonNegativeInt16(1.2)).toThrowError(TypeError);
+      expect(() => asNonNegativeInt16(1.2)).toThrow(TypeError);
 
-      expect(() => asNonNegativeInt16(-3.4)).toThrowError(TypeError);
+      expect(() => asNonNegativeInt16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
@@ -68,7 +68,7 @@ describe('NonNegativeInt16 test', () => {
     ] as const)(
       `asNonNegativeInt16($name) should throw a TypeError`,
       ({ value }) => {
-        expect(() => asNonNegativeInt16(value)).toThrowError(
+        expect(() => asNonNegativeInt16(value)).toThrow(
           new TypeError(
             `Expected a non-negative integer in [0, 2^15), got: ${value}`,
           ),