ts-data-forge 5.0.1 → 5.1.1

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

@@ -7,32 +7,43 @@ describe('Uint32 test', () => {
   describe(asUint32, () => {
     test('accepts valid uint32 values', () => {
       expect(() => asUint32(0)).not.toThrow();
+
       expect(() => asUint32(1)).not.toThrow();
+
       expect(() => asUint32(4_294_967_295)).not.toThrow(); // 2^32 - 1
+
       expect(() => asUint32(2_147_483_648)).not.toThrow(); // 2^31
     });
 
     test('rejects values outside uint32 range', () => {
       expect(() => asUint32(4_294_967_296)).toThrow(TypeError); // 2^32
+
       expect(() => asUint32(10_000_000_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asUint32(-1)).toThrow(TypeError);
+
       expect(() => asUint32(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asUint32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asUint32(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asUint32(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asUint32(1.2)).toThrow(TypeError);
+
       expect(() => asUint32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asUint32(5)).toBe(5);
+
       expect(asUint32(0)).toBe(0);
+
       expect(asUint32(4_294_967_295)).toBe(4_294_967_295);
     });
 
@@ -54,35 +65,46 @@ describe('Uint32 test', () => {
 
   describe(isUint32, () => {
     test('correctly identifies uint32 values', () => {
-      expect(isUint32(0)).toBe(true);
-      expect(isUint32(1)).toBe(true);
-      expect(isUint32(4_294_967_295)).toBe(true);
-      expect(isUint32(2_147_483_648)).toBe(true);
+      assert.isTrue(isUint32(0));
+
+      assert.isTrue(isUint32(1));
+
+      assert.isTrue(isUint32(4_294_967_295));
+
+      assert.isTrue(isUint32(2_147_483_648));
     });
 
     test('correctly identifies values outside uint32 range', () => {
-      expect(isUint32(4_294_967_296)).toBe(false);
-      expect(isUint32(10_000_000_000)).toBe(false);
+      assert.isFalse(isUint32(4_294_967_296));
+
+      assert.isFalse(isUint32(10_000_000_000));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isUint32(-1)).toBe(false);
-      expect(isUint32(-42)).toBe(false);
+      assert.isFalse(isUint32(-1));
+
+      assert.isFalse(isUint32(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isUint32(Number.NaN)).toBe(false);
-      expect(isUint32(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isUint32(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isUint32(1.2)).toBe(false);
-      expect(isUint32(-3.4)).toBe(false);
+      assert.isFalse(isUint32(Number.NaN));
+
+      assert.isFalse(isUint32(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isUint32(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isUint32(1.2));
+
+      assert.isFalse(isUint32(-3.4));
     });
   });
 
   describe('Uint32.is', () => {
     test('same as isUint32 function', () => {
       expect(Uint32.is(5)).toBe(isUint32(5));
+
       expect(Uint32.is(4_294_967_296)).toBe(isUint32(4_294_967_296));
+
       expect(Uint32.is(-1)).toBe(isUint32(-1));
     });
   });
@@ -90,19 +112,25 @@ describe('Uint32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(Uint32.MIN_VALUE).toBe(0);
+
       expect(Uint32.MAX_VALUE).toBe(4_294_967_295);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asUint32(1_000_000);
+
     const b = asUint32(500_000);
+
     const c = asUint32(0);
 
     test('min and max', () => {
       expect(Uint32.min(a, b)).toBe(500_000);
+
       expect(Uint32.max(a, b)).toBe(1_000_000);
+
       expect(Uint32.min(a, c)).toBe(0);
+
       expect(Uint32.max(a, c)).toBe(1_000_000);
     });
 
@@ -110,12 +138,15 @@ describe('Uint32 test', () => {
       const result = Uint32.add(asUint32(4_294_967_000), asUint32(1000));
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(Uint32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (never goes below 0)', () => {
       expect(Uint32.sub(a, b)).toBe(500_000);
+
       expect(Uint32.sub(b, a)).toBe(0); // clamped to 0
+
       expect(Uint32.sub(c, a)).toBe(0); // clamped to 0
     });
 
@@ -123,12 +154,15 @@ describe('Uint32 test', () => {
       const result = Uint32.mul(asUint32(100_000), asUint32(100_000));
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(Uint32.mul(asUint32(1000), asUint32(5))).toBe(5000);
     });
 
     test('div (floor division, never goes below 0)', () => {
       expect(Uint32.div(a, asNonZeroUint32(500_000))).toBe(2);
+
       expect(Uint32.div(asUint32(7), asNonZeroUint32(3))).toBe(2);
+
       expect(Uint32.div(asUint32(500_000), asNonZeroUint32(1_000_000))).toBe(0); // floor(500000/1000000) = 0
     });
 
@@ -136,6 +170,7 @@ describe('Uint32 test', () => {
       const result = Uint32.pow(asUint32(10_000), asUint32(3));
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(Uint32.pow(asUint32(2), asUint32(3))).toBe(8);
     });
   });
@@ -143,15 +178,20 @@ describe('Uint32 test', () => {
   describe('random', () => {
     test('generates uint32 values within specified range', () => {
       const min = 0;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = Uint32.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(Uint32.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(Uint32.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).toBeGreaterThanOrEqual(0);
       }
     });
@@ -161,6 +201,7 @@ describe('Uint32 test', () => {
         const result = Uint32.random(0, 30);
 
         expect(result).toBeGreaterThanOrEqual(0);
+
         expect(result).toBeLessThanOrEqual(4_294_967_295);
       }
     });

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

@@ -77,6 +77,7 @@ describe('Int8 test', () => {
   describe('Int8.min', () => {
     test('should return minimum value', () => {
       expect(Int8.min(-100, -50, 10)).toBe(-100);
+
       expect(Int8.min(1, 2, 3)).toBe(1);
     });
   });
@@ -84,6 +85,7 @@ describe('Int8 test', () => {
   describe('Int8.max', () => {
     test('should return maximum value', () => {
       expect(Int8.max(-100, -50, 10)).toBe(10);
+
       expect(Int8.max(1, 2, 3)).toBe(3);
     });
   });
@@ -174,12 +176,16 @@ describe('Int8 test', () => {
   describe('Int8.random', () => {
     test('should generate value within range', () => {
       const min = -10;
+
       const max = 10;
+
       const result = Int8.random(min, max);
 
       expect(result).toBeGreaterThanOrEqual(min);
+
       expect(result).toBeLessThanOrEqual(max);
-      expect(Number.isInteger(result)).toBe(true);
+
+      assert.isTrue(Number.isInteger(result));
     });
   });
 });

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

@@ -77,6 +77,7 @@ describe('Uint8 test', () => {
   describe('Uint8.min', () => {
     test('should return minimum value', () => {
       expect(Uint8.min(100, 50, 10)).toBe(10);
+
       expect(Uint8.min(1, 2, 3)).toBe(1);
     });
   });
@@ -84,6 +85,7 @@ describe('Uint8 test', () => {
   describe('Uint8.max', () => {
     test('should return maximum value', () => {
       expect(Uint8.max(100, 50, 10)).toBe(100);
+
       expect(Uint8.max(1, 2, 3)).toBe(3);
     });
   });
@@ -156,12 +158,16 @@ describe('Uint8 test', () => {
   describe('Uint8.random', () => {
     test('should generate value within range', () => {
       const min = 10;
+
       const max = 50;
+
       const result = Uint8.random(min, max);
 
       expect(result).toBeGreaterThanOrEqual(min);
+
       expect(result).toBeLessThanOrEqual(max);
-      expect(Number.isInteger(result)).toBe(true);
+
+      assert.isTrue(Number.isInteger(result));
     });
   });
 });

package/src/number/num.mts

@@ -26,7 +26,7 @@ export namespace Num {
    *
    * const result = Num.from(input);
    *
-   * assert(result === 123.45);
+   * assert.isTrue(result === 123.45);
    * ```
    *
    * @param n The value to convert.
@@ -50,10 +50,11 @@ export namespace Num {
    *   // Safe to divide now that we know value is non-zero
    *   // eslint-disable-next-line total-functions/no-partial-division
    *   const inverted = 1 / value;
-   *   assert(inverted === 0.2);
+   *
+   *   assert.isTrue(inverted === 0.2);
    * }
    *
-   * assert.notOk(Num.isNonZero(0));
+   * assert.isFalse(Num.isNonZero(0));
    * ```
    *
    * @template N - The numeric literal type or number type to check
@@ -81,10 +82,11 @@ export namespace Num {
    *
    * if (Num.isNonNegative(candidate)) {
    *   const index: number = candidate;
-   *   assert(index === 10);
+   *
+   *   assert.isTrue(index === 10);
    * }
    *
-   * assert.notOk(Num.isNonNegative(-1));
+   * assert.isFalse(Num.isNonNegative(-1));
    * ```
    *
    * @template N - The numeric literal type or number type to check
@@ -109,10 +111,10 @@ export namespace Num {
    * const amount = 42;
    *
    * if (Num.isPositive(amount)) {
-   *   assert.ok(amount > 0);
+   *   assert.isTrue(amount > 0);
    * }
    *
-   * assert.notOk(Num.isPositive(0));
+   * assert.isFalse(Num.isPositive(0));
    * ```
    *
    * @template N - The numeric literal type or number type to check
@@ -133,8 +135,9 @@ export namespace Num {
    * ```ts
    * const isGrade = Num.isInRange(0, 100);
    *
-   * assert.ok(isGrade(50));
-   * assert.notOk(isGrade(100));
+   * assert.isTrue(isGrade(50));
+   *
+   * assert.isFalse(isGrade(100));
    * ```
    *
    * @param lowerBound The lower bound (inclusive).
@@ -156,8 +159,9 @@ export namespace Num {
    * ```ts
    * const isPercentage = Num.isInRangeInclusive(0, 100);
    *
-   * assert.ok(isPercentage(100));
-   * assert.notOk(isPercentage(-1));
+   * assert.isTrue(isPercentage(100));
+   *
+   * assert.isFalse(isPercentage(-1));
    * ```
    *
    * @param lowerBound The lower bound (inclusive).
@@ -215,9 +219,11 @@ export namespace Num {
    * ```ts
    * const indexGuard = Num.isUintInRange(0, 5);
    *
-   * assert.ok(indexGuard(3));
-   * assert.notOk(indexGuard(5));
-   * assert.notOk(indexGuard(-1));
+   * assert.isTrue(indexGuard(3));
+   *
+   * assert.isFalse(indexGuard(5));
+   *
+   * assert.isFalse(indexGuard(-1));
    * ```
    *
    * @template L - The lower bound as a SmallUint literal type
@@ -249,8 +255,9 @@ export namespace Num {
    * ```ts
    * const inclusiveGuard = Num.isUintInRangeInclusive(0, 5);
    *
-   * assert.ok(inclusiveGuard(5));
-   * assert.notOk(inclusiveGuard(6));
+   * assert.isTrue(inclusiveGuard(5));
+   *
+   * assert.isFalse(inclusiveGuard(6));
    * ```
    *
    * @template L - The lower bound as a SmallUint literal type
@@ -277,13 +284,15 @@ export namespace Num {
    * @example
    *
    * ```ts
-   * assert(Num.clamp(150, 0, 100) === 100);
-   * assert(Num.clamp(-50, 0, 100) === 0);
+   * assert.isTrue(Num.clamp(150, 0, 100) === 100);
+   *
+   * assert.isTrue(Num.clamp(-50, 0, 100) === 0);
    *
    * const clampToPercentage = Num.clamp(0, 100);
    *
-   * assert(clampToPercentage(75) === 75);
-   * assert(clampToPercentage(150) === 100);
+   * assert.isTrue(clampToPercentage(75) === 75);
+   *
+   * assert.isTrue(clampToPercentage(150) === 100);
    * ```
    */
   export function clamp(
@@ -306,6 +315,7 @@ export namespace Num {
     switch (args.length) {
       case 3: {
         const [target, lowerBound, upperBound] = args;
+
         return !Number.isFinite(target)
           ? lowerBound
           : Math.max(lowerBound, Math.min(upperBound, target));
@@ -313,6 +323,7 @@ export namespace Num {
 
       case 2: {
         const [lowerBound, upperBound] = args;
+
         return (target: number): number =>
           clamp(target, lowerBound, upperBound);
       }
@@ -385,7 +396,7 @@ export namespace Num {
    * @returns The rounded integer as an Int branded type
    */
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  export const roundToInt = (num: number): Int => (0 | (num + 0.5)) as Int;
+  export const roundToInt = (num: number): Int => Math.trunc(num + 0.5) as Int;
 
   /**
    * Creates a reusable rounding function with a fixed precision.