ts-data-forge 5.1.0 → 6.0.0

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

@@ -53,27 +53,29 @@ describe('FiniteNumber test', () => {
 
   describe('FiniteNumber.is', () => {
     test('correctly identifies finite numbers', () => {
-      expect(FiniteNumber.is(0)).toBe(true);
+      assert.isTrue(FiniteNumber.is(0));
 
-      expect(FiniteNumber.is(1)).toBe(true);
+      assert.isTrue(FiniteNumber.is(1));
 
-      expect(FiniteNumber.is(-1)).toBe(true);
+      assert.isTrue(FiniteNumber.is(-1));
 
-      expect(FiniteNumber.is(3.14)).toBe(true);
+      assert.isTrue(FiniteNumber.is(3.14));
 
-      expect(FiniteNumber.is(-2.5)).toBe(true);
+      assert.isTrue(FiniteNumber.is(-2.5));
 
-      expect(FiniteNumber.is(Number.MAX_VALUE)).toBe(true);
+      assert.isTrue(FiniteNumber.is(-Number.MAX_VALUE));
 
-      expect(FiniteNumber.is(-Number.MAX_VALUE)).toBe(true);
+      assert.isTrue(FiniteNumber.is(Number.MAX_VALUE));
+
+      expectType<FiniteNumber, typeof Number.MAX_VALUE>('=');
     });
 
     test('correctly identifies non-finite numbers', () => {
-      expect(FiniteNumber.is(Number.NaN)).toBe(false);
+      assert.isFalse(FiniteNumber.is(Number.NaN));
 
-      expect(FiniteNumber.is(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(FiniteNumber.is(Number.POSITIVE_INFINITY));
 
-      expect(FiniteNumber.is(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(FiniteNumber.is(Number.NEGATIVE_INFINITY));
     });
   });
 
@@ -160,7 +162,7 @@ describe('FiniteNumber test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(FiniteNumber.is(result)).toBe(true);
+        assert.isTrue(FiniteNumber.is(result));
       }
     });
   });

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

@@ -38,11 +38,11 @@ const {
  * @example
  *
  * ```ts
- * assert.ok(isInt(5));
+ * assert.isTrue(isInt(5));
  *
- * assert.notOk(isInt(5.25));
+ * assert.isFalse(isInt(5.25));
  *
- * assert.ok(Int.is(-10));
+ * assert.isTrue(Int.is(-10));
  * ```
  *
  * @param value - The value to check
@@ -62,9 +62,9 @@ export const isInt = is;
  * ```ts
  * const branded = asInt(42);
  *
- * assert(branded === 42);
+ * assert.isTrue(branded === 42);
  *
- * assert.ok(Int.is(branded));
+ * assert.isTrue(Int.is(branded));
  * ```
  *
  * @param value - The value to cast
@@ -91,11 +91,11 @@ export const Int = {
    * @example
    *
    * ```ts
-   * assert.ok(isInt(5));
+   * assert.isTrue(isInt(5));
    *
-   * assert.notOk(isInt(5.25));
+   * assert.isFalse(isInt(5.25));
    *
-   * assert.ok(Int.is(-10));
+   * assert.isTrue(Int.is(-10));
    * ```
    *
    * @param value - The value to check
@@ -118,9 +118,9 @@ export const Int = {
    *
    * const absolute = Int.abs(negative);
    *
-   * assert(absolute === 12);
+   * assert.isTrue(absolute === 12);
    *
-   * assert.ok(Int.is(absolute));
+   * assert.isTrue(Int.is(absolute));
    * ```
    *
    * @param a - The integer value
@@ -136,7 +136,7 @@ export const Int = {
    * ```ts
    * const smallest = Int.min(asInt(7), asInt(-3), asInt(2));
    *
-   * assert(smallest === -3);
+   * assert.isTrue(smallest === -3);
    * ```
    *
    * @param values - The integers to compare (at least one required)
@@ -152,7 +152,7 @@ export const Int = {
    * ```ts
    * const largest = Int.max(asInt(7), asInt(-3), asInt(2));
    *
-   * assert(largest === 7);
+   * assert.isTrue(largest === 7);
    * ```
    *
    * @param values - The integers to compare (at least one required)
@@ -175,9 +175,9 @@ export const Int = {
    *
    * const randomValue = Int.random(min, max);
    *
-   * assert.ok(Int.is(randomValue));
+   * assert.isTrue(Int.is(randomValue));
    *
-   * assert.ok(randomValue >= 1 && randomValue <= 6);
+   * assert.isTrue(randomValue >= 1 && randomValue <= 6);
    * ```
    *
    * @param min - The minimum value (inclusive)
@@ -198,7 +198,7 @@ export const Int = {
    *
    * const power = Int.pow(base, exponent);
    *
-   * assert(power === 32);
+   * assert.isTrue(power === 32);
    * ```
    *
    * @param a - The base integer
@@ -215,7 +215,7 @@ export const Int = {
    * ```ts
    * const sum = Int.add(asInt(12), asInt(8));
    *
-   * assert(sum === 20);
+   * assert.isTrue(sum === 20);
    * ```
    *
    * @param a - First integer
@@ -232,7 +232,7 @@ export const Int = {
    * ```ts
    * const difference = Int.sub(asInt(12), asInt(8));
    *
-   * assert(difference === 4);
+   * assert.isTrue(difference === 4);
    * ```
    *
    * @param a - First integer
@@ -249,7 +249,7 @@ export const Int = {
    * ```ts
    * const product = Int.mul(asInt(-4), asInt(6));
    *
-   * assert(product === -24);
+   * assert.isTrue(product === -24);
    * ```
    *
    * @param a - First integer
@@ -273,7 +273,7 @@ export const Int = {
    *
    * const quotient = Int.div(dividend, divisor);
    *
-   * assert(quotient === 3);
+   * assert.isTrue(quotient === 3);
    * ```
    *
    * @param a - The dividend

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

@@ -56,31 +56,31 @@ describe('Int test', () => {
 
   describe(isInt, () => {
     test('correctly identifies integers', () => {
-      expect(isInt(0)).toBe(true);
+      assert.isTrue(isInt(0));
 
-      expect(isInt(1)).toBe(true);
+      assert.isTrue(isInt(1));
 
-      expect(isInt(-1)).toBe(true);
+      assert.isTrue(isInt(-1));
 
-      expect(isInt(42)).toBe(true);
+      assert.isTrue(isInt(42));
 
-      expect(isInt(-42)).toBe(true);
+      assert.isTrue(isInt(-42));
 
-      expect(isInt(Number.MAX_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isInt(Number.MAX_SAFE_INTEGER));
 
-      expect(isInt(Number.MIN_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isInt(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isInt(Number.NaN)).toBe(false);
+      assert.isFalse(isInt(Number.NaN));
 
-      expect(isInt(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isInt(Number.POSITIVE_INFINITY));
 
-      expect(isInt(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isInt(Number.NEGATIVE_INFINITY));
 
-      expect(isInt(1.2)).toBe(false);
+      assert.isFalse(isInt(1.2));
 
-      expect(isInt(-3.4)).toBe(false);
+      assert.isFalse(isInt(-3.4));
     });
   });
 
@@ -167,9 +167,9 @@ describe('Int test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(Int.is(result)).toBe(true);
+        assert.isTrue(Int.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
       }
     });
   });

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

@@ -66,37 +66,37 @@ describe('Int16 test', () => {
 
   describe(isInt16, () => {
     test('correctly identifies int16 values', () => {
-      expect(isInt16(0)).toBe(true);
+      assert.isTrue(isInt16(0));
 
-      expect(isInt16(1)).toBe(true);
+      assert.isTrue(isInt16(1));
 
-      expect(isInt16(-1)).toBe(true);
+      assert.isTrue(isInt16(-1));
 
-      expect(isInt16(32_767)).toBe(true);
+      assert.isTrue(isInt16(32_767));
 
-      expect(isInt16(-32_768)).toBe(true);
+      assert.isTrue(isInt16(-32_768));
     });
 
     test('correctly identifies values outside int16 range', () => {
-      expect(isInt16(32_768)).toBe(false);
+      assert.isFalse(isInt16(32_768));
 
-      expect(isInt16(-32_769)).toBe(false);
+      assert.isFalse(isInt16(-32_769));
 
-      expect(isInt16(65_536)).toBe(false);
+      assert.isFalse(isInt16(65_536));
 
-      expect(isInt16(-65_536)).toBe(false);
+      assert.isFalse(isInt16(-65_536));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isInt16(Number.NaN)).toBe(false);
+      assert.isFalse(isInt16(Number.NaN));
 
-      expect(isInt16(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isInt16(Number.POSITIVE_INFINITY));
 
-      expect(isInt16(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isInt16(Number.NEGATIVE_INFINITY));
 
-      expect(isInt16(1.2)).toBe(false);
+      assert.isFalse(isInt16(1.2));
 
-      expect(isInt16(-3.4)).toBe(false);
+      assert.isFalse(isInt16(-3.4));
     });
   });
 
@@ -197,9 +197,9 @@ describe('Int16 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(Int16.is(result)).toBe(true);
+        assert.isTrue(Int16.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
       }
     });
 

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

@@ -66,37 +66,37 @@ describe('Int32 test', () => {
 
   describe(isInt32, () => {
     test('correctly identifies int32 values', () => {
-      expect(isInt32(0)).toBe(true);
+      assert.isTrue(isInt32(0));
 
-      expect(isInt32(1)).toBe(true);
+      assert.isTrue(isInt32(1));
 
-      expect(isInt32(-1)).toBe(true);
+      assert.isTrue(isInt32(-1));
 
-      expect(isInt32(2_147_483_647)).toBe(true);
+      assert.isTrue(isInt32(2_147_483_647));
 
-      expect(isInt32(-2_147_483_648)).toBe(true);
+      assert.isTrue(isInt32(-2_147_483_648));
     });
 
     test('correctly identifies values outside int32 range', () => {
-      expect(isInt32(2_147_483_648)).toBe(false);
+      assert.isFalse(isInt32(2_147_483_648));
 
-      expect(isInt32(-2_147_483_649)).toBe(false);
+      assert.isFalse(isInt32(-2_147_483_649));
 
-      expect(isInt32(4_294_967_296)).toBe(false);
+      assert.isFalse(isInt32(4_294_967_296));
 
-      expect(isInt32(-4_294_967_296)).toBe(false);
+      assert.isFalse(isInt32(-4_294_967_296));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isInt32(Number.NaN)).toBe(false);
+      assert.isFalse(isInt32(Number.NaN));
 
-      expect(isInt32(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isInt32(Number.POSITIVE_INFINITY));
 
-      expect(isInt32(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isInt32(Number.NEGATIVE_INFINITY));
 
-      expect(isInt32(1.2)).toBe(false);
+      assert.isFalse(isInt32(1.2));
 
-      expect(isInt32(-3.4)).toBe(false);
+      assert.isFalse(isInt32(-3.4));
     });
   });
 
@@ -197,9 +197,9 @@ describe('Int32 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(Int32.is(result)).toBe(true);
+        assert.isTrue(Int32.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
       }
     });
 

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

@@ -67,31 +67,31 @@ describe('NonNegativeFiniteNumber test', () => {
 
   describe(isNonNegativeFiniteNumber, () => {
     test('correctly identifies non-negative finite numbers', () => {
-      expect(isNonNegativeFiniteNumber(0)).toBe(true);
+      assert.isTrue(isNonNegativeFiniteNumber(0));
 
-      expect(isNonNegativeFiniteNumber(1)).toBe(true);
+      assert.isTrue(isNonNegativeFiniteNumber(1));
 
-      expect(isNonNegativeFiniteNumber(3.14)).toBe(true);
+      assert.isTrue(isNonNegativeFiniteNumber(3.14));
 
-      expect(isNonNegativeFiniteNumber(0.5)).toBe(true);
+      assert.isTrue(isNonNegativeFiniteNumber(0.5));
 
-      expect(isNonNegativeFiniteNumber(Number.MAX_VALUE)).toBe(true);
+      assert.isTrue(isNonNegativeFiniteNumber(Number.MAX_VALUE));
     });
 
     test('correctly identifies negative numbers', () => {
-      expect(isNonNegativeFiniteNumber(-1)).toBe(false);
+      assert.isFalse(isNonNegativeFiniteNumber(-1));
 
-      expect(isNonNegativeFiniteNumber(-0.1)).toBe(false);
+      assert.isFalse(isNonNegativeFiniteNumber(-0.1));
 
-      expect(isNonNegativeFiniteNumber(-Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(isNonNegativeFiniteNumber(-Number.MAX_VALUE));
     });
 
     test('correctly identifies non-finite numbers', () => {
-      expect(isNonNegativeFiniteNumber(Number.NaN)).toBe(false);
+      assert.isFalse(isNonNegativeFiniteNumber(Number.NaN));
 
-      expect(isNonNegativeFiniteNumber(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonNegativeFiniteNumber(Number.POSITIVE_INFINITY));
 
-      expect(isNonNegativeFiniteNumber(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonNegativeFiniteNumber(Number.NEGATIVE_INFINITY));
     });
   });
 
@@ -198,7 +198,7 @@ describe('NonNegativeFiniteNumber test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonNegativeFiniteNumber.is(result)).toBe(true);
+        assert.isTrue(NonNegativeFiniteNumber.is(result));
 
         expect(result).toBeGreaterThanOrEqual(0);
       }

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

@@ -79,39 +79,39 @@ describe('NonNegativeInt16 test', () => {
 
   describe(isNonNegativeInt16, () => {
     test('correctly identifies non-negative int16 values', () => {
-      expect(isNonNegativeInt16(0)).toBe(true);
+      assert.isTrue(isNonNegativeInt16(0));
 
-      expect(isNonNegativeInt16(1)).toBe(true);
+      assert.isTrue(isNonNegativeInt16(1));
 
-      expect(isNonNegativeInt16(1000)).toBe(true);
+      assert.isTrue(isNonNegativeInt16(1000));
 
-      expect(isNonNegativeInt16(32_767)).toBe(true);
+      assert.isTrue(isNonNegativeInt16(32_767));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isNonNegativeInt16(-1)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(-1));
 
-      expect(isNonNegativeInt16(-42)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(-42));
 
-      expect(isNonNegativeInt16(-32_768)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(-32_768));
     });
 
     test('correctly identifies values outside int16 range', () => {
-      expect(isNonNegativeInt16(32_768)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(32_768));
 
-      expect(isNonNegativeInt16(65_536)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(65_536));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonNegativeInt16(Number.NaN)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(Number.NaN));
 
-      expect(isNonNegativeInt16(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(Number.POSITIVE_INFINITY));
 
-      expect(isNonNegativeInt16(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(Number.NEGATIVE_INFINITY));
 
-      expect(isNonNegativeInt16(1.2)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(1.2));
 
-      expect(isNonNegativeInt16(-3.4)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(-3.4));
     });
   });
 
@@ -221,9 +221,9 @@ describe('NonNegativeInt16 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonNegativeInt16.is(result)).toBe(true);
+        assert.isTrue(NonNegativeInt16.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThanOrEqual(0);
       }

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

@@ -79,39 +79,39 @@ describe('NonNegativeInt32 test', () => {
 
   describe(isNonNegativeInt32, () => {
     test('correctly identifies non-negative int32 values', () => {
-      expect(isNonNegativeInt32(0)).toBe(true);
+      assert.isTrue(isNonNegativeInt32(0));
 
-      expect(isNonNegativeInt32(1)).toBe(true);
+      assert.isTrue(isNonNegativeInt32(1));
 
-      expect(isNonNegativeInt32(1000)).toBe(true);
+      assert.isTrue(isNonNegativeInt32(1000));
 
-      expect(isNonNegativeInt32(2_147_483_647)).toBe(true);
+      assert.isTrue(isNonNegativeInt32(2_147_483_647));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isNonNegativeInt32(-1)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(-1));
 
-      expect(isNonNegativeInt32(-42)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(-42));
 
-      expect(isNonNegativeInt32(-2_147_483_648)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(-2_147_483_648));
     });
 
     test('correctly identifies values outside int32 range', () => {
-      expect(isNonNegativeInt32(2_147_483_648)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(2_147_483_648));
 
-      expect(isNonNegativeInt32(4_294_967_296)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(4_294_967_296));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonNegativeInt32(Number.NaN)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(Number.NaN));
 
-      expect(isNonNegativeInt32(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(Number.POSITIVE_INFINITY));
 
-      expect(isNonNegativeInt32(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(Number.NEGATIVE_INFINITY));
 
-      expect(isNonNegativeInt32(1.2)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(1.2));
 
-      expect(isNonNegativeInt32(-3.4)).toBe(false);
+      assert.isFalse(isNonNegativeInt32(-3.4));
     });
   });
 
@@ -224,9 +224,9 @@ describe('NonNegativeInt32 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonNegativeInt32.is(result)).toBe(true);
+        assert.isTrue(NonNegativeInt32.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThanOrEqual(0);
       }

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

@@ -69,31 +69,31 @@ describe('NonZeroFiniteNumber test', () => {
 
   describe(isNonZeroFiniteNumber, () => {
     test('correctly identifies non-zero finite numbers', () => {
-      expect(isNonZeroFiniteNumber(1)).toBe(true);
+      assert.isTrue(isNonZeroFiniteNumber(1));
 
-      expect(isNonZeroFiniteNumber(-1)).toBe(true);
+      assert.isTrue(isNonZeroFiniteNumber(-1));
 
-      expect(isNonZeroFiniteNumber(3.14)).toBe(true);
+      assert.isTrue(isNonZeroFiniteNumber(3.14));
 
-      expect(isNonZeroFiniteNumber(-2.5)).toBe(true);
+      assert.isTrue(isNonZeroFiniteNumber(-2.5));
 
-      expect(isNonZeroFiniteNumber(0.001)).toBe(true);
+      assert.isTrue(isNonZeroFiniteNumber(0.001));
 
-      expect(isNonZeroFiniteNumber(-0.001)).toBe(true);
+      assert.isTrue(isNonZeroFiniteNumber(-0.001));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroFiniteNumber(0)).toBe(false);
+      assert.isFalse(isNonZeroFiniteNumber(0));
 
-      expect(isNonZeroFiniteNumber(-0)).toBe(false);
+      assert.isFalse(isNonZeroFiniteNumber(-0));
     });
 
     test('correctly identifies non-finite numbers', () => {
-      expect(isNonZeroFiniteNumber(Number.NaN)).toBe(false);
+      assert.isFalse(isNonZeroFiniteNumber(Number.NaN));
 
-      expect(isNonZeroFiniteNumber(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroFiniteNumber(Number.POSITIVE_INFINITY));
 
-      expect(isNonZeroFiniteNumber(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonZeroFiniteNumber(Number.NEGATIVE_INFINITY));
     });
   });
 
@@ -200,7 +200,7 @@ describe('NonZeroFiniteNumber test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroFiniteNumber.is(result)).toBe(true);
+        assert.isTrue(NonZeroFiniteNumber.is(result));
 
         expect(result).not.toBe(0);
       }
@@ -218,7 +218,7 @@ describe('NonZeroFiniteNumber test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroFiniteNumber.is(result)).toBe(true);
+        assert.isTrue(NonZeroFiniteNumber.is(result));
 
         expect(result).not.toBe(0);
       }
@@ -236,7 +236,7 @@ describe('NonZeroFiniteNumber test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(NonZeroFiniteNumber.is(result)).toBe(true);
+        assert.isTrue(NonZeroFiniteNumber.is(result));
 
         expect(result).not.toBe(0);
       }