ts-data-forge 5.0.1 → 5.1.1

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

@@ -7,23 +7,33 @@ describe('FiniteNumber test', () => {
   describe(asFiniteNumber, () => {
     test('accepts valid finite numbers', () => {
       expect(() => asFiniteNumber(0)).not.toThrow();
+
       expect(() => asFiniteNumber(1)).not.toThrow();
+
       expect(() => asFiniteNumber(-1)).not.toThrow();
+
       expect(() => asFiniteNumber(3.14)).not.toThrow();
+
       expect(() => asFiniteNumber(-2.5)).not.toThrow();
+
       expect(() => asFiniteNumber(Number.MAX_VALUE)).not.toThrow();
+
       expect(() => asFiniteNumber(-Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects non-finite numbers', () => {
       expect(() => asFiniteNumber(Number.NaN)).toThrow(TypeError);
+
       expect(() => asFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asFiniteNumber(5.5)).toBe(5.5);
+
       expect(asFiniteNumber(-10)).toBe(-10);
+
       expect(asFiniteNumber(0)).toBe(0);
     });
 
@@ -43,71 +53,98 @@ describe('FiniteNumber test', () => {
 
   describe('FiniteNumber.is', () => {
     test('correctly identifies finite numbers', () => {
-      expect(FiniteNumber.is(0)).toBe(true);
-      expect(FiniteNumber.is(1)).toBe(true);
-      expect(FiniteNumber.is(-1)).toBe(true);
-      expect(FiniteNumber.is(3.14)).toBe(true);
-      expect(FiniteNumber.is(-2.5)).toBe(true);
-      expect(FiniteNumber.is(Number.MAX_VALUE)).toBe(true);
-      expect(FiniteNumber.is(-Number.MAX_VALUE)).toBe(true);
+      assert.isTrue(FiniteNumber.is(0));
+
+      assert.isTrue(FiniteNumber.is(1));
+
+      assert.isTrue(FiniteNumber.is(-1));
+
+      assert.isTrue(FiniteNumber.is(3.14));
+
+      assert.isTrue(FiniteNumber.is(-2.5));
+
+      assert.isTrue(FiniteNumber.is(-Number.MAX_VALUE));
+
+      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);
-      expect(FiniteNumber.is(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(FiniteNumber.is(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(FiniteNumber.is(Number.NaN));
+
+      assert.isFalse(FiniteNumber.is(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(FiniteNumber.is(Number.NEGATIVE_INFINITY));
     });
   });
 
   describe('mathematical operations', () => {
     const a = asFiniteNumber(5.5);
+
     const b = asFiniteNumber(2.5);
+
     const c = asFiniteNumber(-3.5);
 
     test('abs', () => {
       expect(FiniteNumber.abs(a)).toBe(5.5);
+
       expect(FiniteNumber.abs(c)).toBe(3.5);
+
       expect(FiniteNumber.abs(asFiniteNumber(0))).toBe(0);
     });
 
     test('min and max', () => {
       expect(FiniteNumber.min(a, b)).toBe(2.5);
+
       expect(FiniteNumber.max(a, b)).toBe(5.5);
+
       expect(FiniteNumber.min(a, c)).toBe(-3.5);
+
       expect(FiniteNumber.max(a, c)).toBe(5.5);
     });
 
     test('floor, ceil, round', () => {
       expect(FiniteNumber.floor(a)).toBe(5);
+
       expect(FiniteNumber.ceil(a)).toBe(6);
+
       expect(FiniteNumber.round(a)).toBe(6);
+
       expect(FiniteNumber.floor(c)).toBe(-4);
+
       expect(FiniteNumber.ceil(c)).toBe(-3);
+
       expect(FiniteNumber.round(c)).toBe(-3);
     });
 
     test('add', () => {
       expect(FiniteNumber.add(a, b)).toBe(8);
+
       expect(FiniteNumber.add(a, c)).toBe(2);
     });
 
     test('sub', () => {
       expect(FiniteNumber.sub(a, b)).toBe(3);
+
       expect(FiniteNumber.sub(a, c)).toBe(9);
     });
 
     test('mul', () => {
       expect(FiniteNumber.mul(a, b)).toBe(13.75);
+
       expect(FiniteNumber.mul(a, c)).toBe(-19.25);
     });
 
     test('div', () => {
       expect(FiniteNumber.div(a, asNonZeroFiniteNumber(2.5))).toBe(2.2);
+
       expect(FiniteNumber.div(a, asNonZeroFiniteNumber(2))).toBe(2.75);
     });
 
     test('pow', () => {
       expect(FiniteNumber.pow(asFiniteNumber(2), asFiniteNumber(3))).toBe(8);
+
       expect(FiniteNumber.pow(asFiniteNumber(3), asFiniteNumber(2))).toBe(9);
     });
   });
@@ -115,14 +152,17 @@ describe('FiniteNumber test', () => {
   describe('random', () => {
     test('generates numbers within specified range', () => {
       const min = asFiniteNumber(-5.5);
+
       const max = asFiniteNumber(10.3);
 
       for (const _ of range(10)) {
         const result = FiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(FiniteNumber.is(result)).toBe(true);
+
+        assert.isTrue(FiniteNumber.is(result));
       }
     });
   });

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

@@ -38,9 +38,11 @@ const {
  * @example
  *
  * ```ts
- * assert.ok(isInt(5));
- * assert.notOk(isInt(5.25));
- * assert.ok(Int.is(-10));
+ * assert.isTrue(isInt(5));
+ *
+ * assert.isFalse(isInt(5.25));
+ *
+ * assert.isTrue(Int.is(-10));
  * ```
  *
  * @param value - The value to check
@@ -60,8 +62,9 @@ export const isInt = is;
  * ```ts
  * const branded = asInt(42);
  *
- * assert(branded === 42);
- * assert.ok(Int.is(branded));
+ * assert.isTrue(branded === 42);
+ *
+ * assert.isTrue(Int.is(branded));
  * ```
  *
  * @param value - The value to cast
@@ -88,9 +91,11 @@ export const Int = {
    * @example
    *
    * ```ts
-   * assert.ok(isInt(5));
-   * assert.notOk(isInt(5.25));
-   * assert.ok(Int.is(-10));
+   * assert.isTrue(isInt(5));
+   *
+   * assert.isFalse(isInt(5.25));
+   *
+   * assert.isTrue(Int.is(-10));
    * ```
    *
    * @param value - The value to check
@@ -110,10 +115,12 @@ export const Int = {
    *
    * ```ts
    * const negative = asInt(-12);
+   *
    * const absolute = Int.abs(negative);
    *
-   * assert(absolute === 12);
-   * assert.ok(Int.is(absolute));
+   * assert.isTrue(absolute === 12);
+   *
+   * assert.isTrue(Int.is(absolute));
    * ```
    *
    * @param a - The integer value
@@ -129,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)
@@ -145,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)
@@ -163,11 +170,14 @@ export const Int = {
    *
    * ```ts
    * const min = asInt(1);
+   *
    * const max = asInt(6);
+   *
    * const randomValue = Int.random(min, max);
    *
-   * assert.ok(Int.is(randomValue));
-   * assert.ok(randomValue >= 1 && randomValue <= 6);
+   * assert.isTrue(Int.is(randomValue));
+   *
+   * assert.isTrue(randomValue >= 1 && randomValue <= 6);
    * ```
    *
    * @param min - The minimum value (inclusive)
@@ -183,10 +193,12 @@ export const Int = {
    *
    * ```ts
    * const base = asInt(2);
+   *
    * const exponent = asInt(5);
+   *
    * const power = Int.pow(base, exponent);
    *
-   * assert(power === 32);
+   * assert.isTrue(power === 32);
    * ```
    *
    * @param a - The base integer
@@ -203,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
@@ -220,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
@@ -237,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
@@ -256,10 +268,12 @@ export const Int = {
    *
    * ```ts
    * const dividend = asInt(17);
+   *
    * const divisor = asInt(5);
+   *
    * 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

@@ -7,25 +7,37 @@ describe('Int test', () => {
   describe(asInt, () => {
     test('accepts valid integers', () => {
       expect(() => asInt(0)).not.toThrow();
+
       expect(() => asInt(1)).not.toThrow();
+
       expect(() => asInt(-1)).not.toThrow();
+
       expect(() => asInt(42)).not.toThrow();
+
       expect(() => asInt(-42)).not.toThrow();
+
       expect(() => asInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+
       expect(() => asInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects non-integers', () => {
       expect(() => asInt(Number.NaN)).toThrow(TypeError);
+
       expect(() => asInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asInt(1.2)).toThrow(TypeError);
+
       expect(() => asInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asInt(5)).toBe(5);
+
       expect(asInt(-10)).toBe(-10);
+
       expect(asInt(0)).toBe(0);
     });
 
@@ -44,74 +56,100 @@ describe('Int test', () => {
 
   describe(isInt, () => {
     test('correctly identifies integers', () => {
-      expect(isInt(0)).toBe(true);
-      expect(isInt(1)).toBe(true);
-      expect(isInt(-1)).toBe(true);
-      expect(isInt(42)).toBe(true);
-      expect(isInt(-42)).toBe(true);
-      expect(isInt(Number.MAX_SAFE_INTEGER)).toBe(true);
-      expect(isInt(Number.MIN_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isInt(0));
+
+      assert.isTrue(isInt(1));
+
+      assert.isTrue(isInt(-1));
+
+      assert.isTrue(isInt(42));
+
+      assert.isTrue(isInt(-42));
+
+      assert.isTrue(isInt(Number.MAX_SAFE_INTEGER));
+
+      assert.isTrue(isInt(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isInt(Number.NaN)).toBe(false);
-      expect(isInt(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isInt(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isInt(1.2)).toBe(false);
-      expect(isInt(-3.4)).toBe(false);
+      assert.isFalse(isInt(Number.NaN));
+
+      assert.isFalse(isInt(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isInt(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isInt(1.2));
+
+      assert.isFalse(isInt(-3.4));
     });
   });
 
   describe('Int.is', () => {
     test('same as isInt function', () => {
       expect(Int.is(5)).toBe(isInt(5));
+
       expect(Int.is(1.5)).toBe(isInt(1.5));
+
       expect(Int.is(-10)).toBe(isInt(-10));
     });
   });
 
   describe('mathematical operations', () => {
     const a = asInt(5);
+
     const b = asInt(2);
+
     const c = asInt(-3);
 
     test('abs', () => {
       expect(Int.abs(a)).toBe(5);
+
       expect(Int.abs(c)).toBe(3);
+
       expect(Int.abs(asInt(0))).toBe(0);
     });
 
     test('min and max', () => {
       expect(Int.min(a, b)).toBe(2);
+
       expect(Int.max(a, b)).toBe(5);
+
       expect(Int.min(a, c)).toBe(-3);
+
       expect(Int.max(a, c)).toBe(5);
     });
 
     test('add', () => {
       expect(Int.add(a, b)).toBe(7);
+
       expect(Int.add(a, c)).toBe(2);
     });
 
     test('sub', () => {
       expect(Int.sub(a, b)).toBe(3);
+
       expect(Int.sub(a, c)).toBe(8);
     });
 
     test('mul', () => {
       expect(Int.mul(a, b)).toBe(10);
+
       expect(Int.mul(a, c)).toBe(-15);
     });
 
     test('div (floor division)', () => {
       expect(Int.div(a, asNonZeroInt(2))).toBe(2);
+
       expect(Int.div(asInt(7), asNonZeroInt(3))).toBe(2);
+
       expect(Int.div(asInt(-7), asNonZeroInt(3))).toBe(-3);
     });
 
     test('pow', () => {
       expect(Int.pow(asInt(2), asInt(3))).toBe(8);
+
       expect(Int.pow(asInt(3), asInt(2))).toBe(9);
+
       expect(Int.pow(asInt(-2), asInt(3))).toBe(-8);
     });
   });
@@ -119,15 +157,19 @@ describe('Int test', () => {
   describe('random', () => {
     test('generates integers within specified range', () => {
       const min = -5;
+
       const max = 10;
 
       for (const _ of range(10)) {
         const result = Int.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(Int.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(Int.is(result));
+
+        assert.isTrue(Number.isInteger(result));
       }
     });
   });

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

@@ -7,32 +7,47 @@ describe('Int16 test', () => {
   describe(asInt16, () => {
     test('accepts valid int16 values', () => {
       expect(() => asInt16(0)).not.toThrow();
+
       expect(() => asInt16(1)).not.toThrow();
+
       expect(() => asInt16(-1)).not.toThrow();
+
       expect(() => asInt16(32_767)).not.toThrow(); // 2^15 - 1
+
       expect(() => asInt16(-32_768)).not.toThrow(); // -2^15
     });
 
     test('rejects values outside int16 range', () => {
       expect(() => asInt16(32_768)).toThrow(TypeError); // 2^15
+
       expect(() => asInt16(-32_769)).toThrow(TypeError); // -2^15 - 1
+
       expect(() => asInt16(65_536)).toThrow(TypeError);
+
       expect(() => asInt16(-65_536)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asInt16(Number.NaN)).toThrow(TypeError);
+
       expect(() => asInt16(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asInt16(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asInt16(1.2)).toThrow(TypeError);
+
       expect(() => asInt16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asInt16(5)).toBe(5);
+
       expect(asInt16(-10)).toBe(-10);
+
       expect(asInt16(0)).toBe(0);
+
       expect(asInt16(32_767)).toBe(32_767);
+
       expect(asInt16(-32_768)).toBe(-32_768);
     });
 
@@ -51,33 +66,46 @@ describe('Int16 test', () => {
 
   describe(isInt16, () => {
     test('correctly identifies int16 values', () => {
-      expect(isInt16(0)).toBe(true);
-      expect(isInt16(1)).toBe(true);
-      expect(isInt16(-1)).toBe(true);
-      expect(isInt16(32_767)).toBe(true);
-      expect(isInt16(-32_768)).toBe(true);
+      assert.isTrue(isInt16(0));
+
+      assert.isTrue(isInt16(1));
+
+      assert.isTrue(isInt16(-1));
+
+      assert.isTrue(isInt16(32_767));
+
+      assert.isTrue(isInt16(-32_768));
     });
 
     test('correctly identifies values outside int16 range', () => {
-      expect(isInt16(32_768)).toBe(false);
-      expect(isInt16(-32_769)).toBe(false);
-      expect(isInt16(65_536)).toBe(false);
-      expect(isInt16(-65_536)).toBe(false);
+      assert.isFalse(isInt16(32_768));
+
+      assert.isFalse(isInt16(-32_769));
+
+      assert.isFalse(isInt16(65_536));
+
+      assert.isFalse(isInt16(-65_536));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isInt16(Number.NaN)).toBe(false);
-      expect(isInt16(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isInt16(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isInt16(1.2)).toBe(false);
-      expect(isInt16(-3.4)).toBe(false);
+      assert.isFalse(isInt16(Number.NaN));
+
+      assert.isFalse(isInt16(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isInt16(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isInt16(1.2));
+
+      assert.isFalse(isInt16(-3.4));
     });
   });
 
   describe('Int16.is', () => {
     test('same as isInt16 function', () => {
       expect(Int16.is(5)).toBe(isInt16(5));
+
       expect(Int16.is(32_768)).toBe(isInt16(32_768));
+
       expect(Int16.is(-32_769)).toBe(isInt16(-32_769));
     });
   });
@@ -85,25 +113,33 @@ describe('Int16 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(Int16.MIN_VALUE).toBe(-32_768);
+
       expect(Int16.MAX_VALUE).toBe(32_767);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asInt16(100);
+
     const b = asInt16(50);
+
     const c = asInt16(-30);
 
     test('abs', () => {
       expect(Int16.abs(a)).toBe(100);
+
       expect(Int16.abs(c)).toBe(30);
+
       expect(Int16.abs(asInt16(0))).toBe(0);
     });
 
     test('min and max', () => {
       expect(Int16.min(a, b)).toBe(50);
+
       expect(Int16.max(a, b)).toBe(100);
+
       expect(Int16.min(a, c)).toBe(-30);
+
       expect(Int16.max(a, c)).toBe(100);
     });
 
@@ -111,6 +147,7 @@ describe('Int16 test', () => {
       const result = Int16.add(asInt16(32_000), asInt16(1000));
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(Int16.add(a, b)).toBe(150);
     });
 
@@ -118,6 +155,7 @@ describe('Int16 test', () => {
       const result = Int16.sub(asInt16(-32_000), asInt16(1000));
 
       expect(result).toBe(-32_768); // clamped to min
+
       expect(Int16.sub(a, b)).toBe(50);
     });
 
@@ -125,12 +163,15 @@ describe('Int16 test', () => {
       const result = Int16.mul(asInt16(1000), asInt16(100));
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(Int16.mul(asInt16(10), asInt16(5))).toBe(50);
     });
 
     test('div (floor division with clamping)', () => {
       expect(Int16.div(a, asNonZeroInt16(50))).toBe(2);
+
       expect(Int16.div(asInt16(7), asNonZeroInt16(3))).toBe(2);
+
       expect(Int16.div(asInt16(-7), asNonZeroInt16(3))).toBe(-3);
     });
 
@@ -138,6 +179,7 @@ describe('Int16 test', () => {
       const result = Int16.pow(asInt16(200), asInt16(3));
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(Int16.pow(asInt16(2), asInt16(3))).toBe(8);
     });
   });
@@ -145,15 +187,19 @@ describe('Int16 test', () => {
   describe('random', () => {
     test('generates int16 values within specified range', () => {
       const min = -10;
+
       const max = 10;
 
       for (const _ of range(10)) {
         const result = Int16.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(Int16.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(Int16.is(result));
+
+        assert.isTrue(Number.isInteger(result));
       }
     });
 
@@ -162,6 +208,7 @@ describe('Int16 test', () => {
         const result = Int16.random(-20, 20);
 
         expect(result).toBeGreaterThanOrEqual(Int16.MIN_VALUE);
+
         expect(result).toBeLessThanOrEqual(Int16.MAX_VALUE);
       }
     });