ts-data-forge 5.0.1 → 5.1.1

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

@@ -7,32 +7,47 @@ describe('Int32 test', () => {
   describe(asInt32, () => {
     test('accepts valid int32 values', () => {
       expect(() => asInt32(0)).not.toThrow();
+
       expect(() => asInt32(1)).not.toThrow();
+
       expect(() => asInt32(-1)).not.toThrow();
+
       expect(() => asInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
+
       expect(() => asInt32(-2_147_483_648)).not.toThrow(); // -2^31
     });
 
     test('rejects values outside int32 range', () => {
       expect(() => asInt32(2_147_483_648)).toThrow(TypeError); // 2^31
+
       expect(() => asInt32(-2_147_483_649)).toThrow(TypeError); // -2^31 - 1
+
       expect(() => asInt32(4_294_967_296)).toThrow(TypeError);
+
       expect(() => asInt32(-4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asInt32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asInt32(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asInt32(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asInt32(1.2)).toThrow(TypeError);
+
       expect(() => asInt32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asInt32(5)).toBe(5);
+
       expect(asInt32(-10)).toBe(-10);
+
       expect(asInt32(0)).toBe(0);
+
       expect(asInt32(2_147_483_647)).toBe(2_147_483_647);
+
       expect(asInt32(-2_147_483_648)).toBe(-2_147_483_648);
     });
 
@@ -51,33 +66,46 @@ describe('Int32 test', () => {
 
   describe(isInt32, () => {
     test('correctly identifies int32 values', () => {
-      expect(isInt32(0)).toBe(true);
-      expect(isInt32(1)).toBe(true);
-      expect(isInt32(-1)).toBe(true);
-      expect(isInt32(2_147_483_647)).toBe(true);
-      expect(isInt32(-2_147_483_648)).toBe(true);
+      assert.isTrue(isInt32(0));
+
+      assert.isTrue(isInt32(1));
+
+      assert.isTrue(isInt32(-1));
+
+      assert.isTrue(isInt32(2_147_483_647));
+
+      assert.isTrue(isInt32(-2_147_483_648));
     });
 
     test('correctly identifies values outside int32 range', () => {
-      expect(isInt32(2_147_483_648)).toBe(false);
-      expect(isInt32(-2_147_483_649)).toBe(false);
-      expect(isInt32(4_294_967_296)).toBe(false);
-      expect(isInt32(-4_294_967_296)).toBe(false);
+      assert.isFalse(isInt32(2_147_483_648));
+
+      assert.isFalse(isInt32(-2_147_483_649));
+
+      assert.isFalse(isInt32(4_294_967_296));
+
+      assert.isFalse(isInt32(-4_294_967_296));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isInt32(Number.NaN)).toBe(false);
-      expect(isInt32(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isInt32(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isInt32(1.2)).toBe(false);
-      expect(isInt32(-3.4)).toBe(false);
+      assert.isFalse(isInt32(Number.NaN));
+
+      assert.isFalse(isInt32(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isInt32(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isInt32(1.2));
+
+      assert.isFalse(isInt32(-3.4));
     });
   });
 
   describe('Int32.is', () => {
     test('same as isInt32 function', () => {
       expect(Int32.is(5)).toBe(isInt32(5));
+
       expect(Int32.is(2_147_483_648)).toBe(isInt32(2_147_483_648));
+
       expect(Int32.is(-2_147_483_649)).toBe(isInt32(-2_147_483_649));
     });
   });
@@ -85,25 +113,33 @@ describe('Int32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(Int32.MIN_VALUE).toBe(-2_147_483_648);
+
       expect(Int32.MAX_VALUE).toBe(2_147_483_647);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asInt32(1_000_000);
+
     const b = asInt32(500_000);
+
     const c = asInt32(-300_000);
 
     test('abs', () => {
       expect(Int32.abs(a)).toBe(1_000_000);
+
       expect(Int32.abs(c)).toBe(300_000);
+
       expect(Int32.abs(asInt32(0))).toBe(0);
     });
 
     test('min and max', () => {
       expect(Int32.min(a, b)).toBe(500_000);
+
       expect(Int32.max(a, b)).toBe(1_000_000);
+
       expect(Int32.min(a, c)).toBe(-300_000);
+
       expect(Int32.max(a, c)).toBe(1_000_000);
     });
 
@@ -111,6 +147,7 @@ describe('Int32 test', () => {
       const result = Int32.add(asInt32(2_147_483_000), asInt32(1000));
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(Int32.add(a, b)).toBe(1_500_000);
     });
 
@@ -118,6 +155,7 @@ describe('Int32 test', () => {
       const result = Int32.sub(asInt32(-2_147_483_000), asInt32(1000));
 
       expect(result).toBe(-2_147_483_648); // clamped to min
+
       expect(Int32.sub(a, b)).toBe(500_000);
     });
 
@@ -125,12 +163,15 @@ describe('Int32 test', () => {
       const result = Int32.mul(asInt32(100_000), asInt32(100_000));
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(Int32.mul(asInt32(1000), asInt32(5))).toBe(5000);
     });
 
     test('div (floor division with clamping)', () => {
       expect(Int32.div(a, asNonZeroInt32(500_000))).toBe(2);
+
       expect(Int32.div(asInt32(7), asNonZeroInt32(3))).toBe(2);
+
       expect(Int32.div(asInt32(-7), asNonZeroInt32(3))).toBe(-3);
     });
 
@@ -138,6 +179,7 @@ describe('Int32 test', () => {
       const result = Int32.pow(asInt32(10_000), asInt32(3));
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(Int32.pow(asInt32(2), asInt32(3))).toBe(8);
     });
   });
@@ -145,15 +187,19 @@ describe('Int32 test', () => {
   describe('random', () => {
     test('generates int32 values within specified range', () => {
       const min = -10;
+
       const max = 10;
 
       for (const _ of range(10)) {
         const result = Int32.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(Int32.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(Int32.is(result));
+
+        assert.isTrue(Number.isInteger(result));
       }
     });
 
@@ -162,6 +208,7 @@ describe('Int32 test', () => {
         const result = Int32.random(-20, 20);
 
         expect(result).toBeGreaterThanOrEqual(Int32.MIN_VALUE);
+
         expect(result).toBeLessThanOrEqual(Int32.MAX_VALUE);
       }
     });

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

@@ -10,15 +10,21 @@ describe('NonNegativeFiniteNumber test', () => {
   describe(asNonNegativeFiniteNumber, () => {
     test('accepts valid non-negative finite numbers', () => {
       expect(() => asNonNegativeFiniteNumber(0)).not.toThrow();
+
       expect(() => asNonNegativeFiniteNumber(1)).not.toThrow();
+
       expect(() => asNonNegativeFiniteNumber(3.14)).not.toThrow();
+
       expect(() => asNonNegativeFiniteNumber(0.5)).not.toThrow();
+
       expect(() => asNonNegativeFiniteNumber(Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects negative numbers', () => {
       expect(() => asNonNegativeFiniteNumber(-1)).toThrow(TypeError);
+
       expect(() => asNonNegativeFiniteNumber(-0.1)).toThrow(TypeError);
+
       expect(() => asNonNegativeFiniteNumber(-Number.MAX_VALUE)).toThrow(
         TypeError,
       );
@@ -26,9 +32,11 @@ describe('NonNegativeFiniteNumber test', () => {
 
     test('rejects non-finite numbers', () => {
       expect(() => asNonNegativeFiniteNumber(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonNegativeFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonNegativeFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
@@ -36,7 +44,9 @@ describe('NonNegativeFiniteNumber test', () => {
 
     test('returns the same value for valid inputs', () => {
       expect(asNonNegativeFiniteNumber(5.5)).toBe(5.5);
+
       expect(asNonNegativeFiniteNumber(0)).toBe(0);
+
       expect(asNonNegativeFiniteNumber(10)).toBe(10);
     });
 
@@ -57,32 +67,42 @@ describe('NonNegativeFiniteNumber test', () => {
 
   describe(isNonNegativeFiniteNumber, () => {
     test('correctly identifies non-negative finite numbers', () => {
-      expect(isNonNegativeFiniteNumber(0)).toBe(true);
-      expect(isNonNegativeFiniteNumber(1)).toBe(true);
-      expect(isNonNegativeFiniteNumber(3.14)).toBe(true);
-      expect(isNonNegativeFiniteNumber(0.5)).toBe(true);
-      expect(isNonNegativeFiniteNumber(Number.MAX_VALUE)).toBe(true);
+      assert.isTrue(isNonNegativeFiniteNumber(0));
+
+      assert.isTrue(isNonNegativeFiniteNumber(1));
+
+      assert.isTrue(isNonNegativeFiniteNumber(3.14));
+
+      assert.isTrue(isNonNegativeFiniteNumber(0.5));
+
+      assert.isTrue(isNonNegativeFiniteNumber(Number.MAX_VALUE));
     });
 
     test('correctly identifies negative numbers', () => {
-      expect(isNonNegativeFiniteNumber(-1)).toBe(false);
-      expect(isNonNegativeFiniteNumber(-0.1)).toBe(false);
-      expect(isNonNegativeFiniteNumber(-Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(isNonNegativeFiniteNumber(-1));
+
+      assert.isFalse(isNonNegativeFiniteNumber(-0.1));
+
+      assert.isFalse(isNonNegativeFiniteNumber(-Number.MAX_VALUE));
     });
 
     test('correctly identifies non-finite numbers', () => {
-      expect(isNonNegativeFiniteNumber(Number.NaN)).toBe(false);
-      expect(isNonNegativeFiniteNumber(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isNonNegativeFiniteNumber(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isNonNegativeFiniteNumber(Number.NaN));
+
+      assert.isFalse(isNonNegativeFiniteNumber(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isNonNegativeFiniteNumber(Number.NEGATIVE_INFINITY));
     });
   });
 
   describe('NonNegativeFiniteNumber.is', () => {
     test('same as isNonNegativeFiniteNumber function', () => {
       expect(NonNegativeFiniteNumber.is(5)).toBe(isNonNegativeFiniteNumber(5));
+
       expect(NonNegativeFiniteNumber.is(-1)).toBe(
         isNonNegativeFiniteNumber(-1),
       );
+
       expect(NonNegativeFiniteNumber.is(0)).toBe(isNonNegativeFiniteNumber(0));
     });
   });
@@ -95,37 +115,50 @@ describe('NonNegativeFiniteNumber test', () => {
 
   describe('mathematical operations', () => {
     const a = asNonNegativeFiniteNumber(5.5);
+
     const b = asNonNegativeFiniteNumber(2.5);
+
     const c = asNonNegativeFiniteNumber(0);
 
     test('min and max', () => {
       expect(NonNegativeFiniteNumber.min(a, b)).toBe(2.5);
+
       expect(NonNegativeFiniteNumber.max(a, b)).toBe(5.5);
+
       expect(NonNegativeFiniteNumber.min(a, c)).toBe(0);
+
       expect(NonNegativeFiniteNumber.max(a, c)).toBe(5.5);
     });
 
     test('floor, ceil, round', () => {
       expect(NonNegativeFiniteNumber.floor(a)).toBe(5);
+
       expect(NonNegativeFiniteNumber.ceil(a)).toBe(6);
+
       expect(NonNegativeFiniteNumber.round(a)).toBe(6);
+
       expect(NonNegativeFiniteNumber.floor(b)).toBe(2);
+
       expect(NonNegativeFiniteNumber.ceil(b)).toBe(3);
+
       expect(NonNegativeFiniteNumber.round(b)).toBe(3);
     });
 
     test('add (never goes below 0)', () => {
       expect(NonNegativeFiniteNumber.add(a, b)).toBe(8);
+
       expect(NonNegativeFiniteNumber.add(a, c)).toBe(5.5);
     });
 
     test('sub (never goes below 0)', () => {
       expect(NonNegativeFiniteNumber.sub(a, b)).toBe(3);
+
       expect(NonNegativeFiniteNumber.sub(b, a)).toBe(0); // clamped to 0
     });
 
     test('mul (never goes below 0)', () => {
       expect(NonNegativeFiniteNumber.mul(a, b)).toBe(13.75);
+
       expect(NonNegativeFiniteNumber.mul(a, c)).toBe(0);
     });
 
@@ -142,6 +175,7 @@ describe('NonNegativeFiniteNumber test', () => {
           asNonNegativeFiniteNumber(3),
         ),
       ).toBe(8);
+
       expect(
         NonNegativeFiniteNumber.pow(
           asNonNegativeFiniteNumber(3),
@@ -154,26 +188,32 @@ describe('NonNegativeFiniteNumber test', () => {
   describe('random', () => {
     test('generates non-negative numbers within specified range', () => {
       const min = asNonNegativeFiniteNumber(1.5);
+
       const max = asNonNegativeFiniteNumber(10.3);
 
       for (const _ of range(10)) {
         const result = NonNegativeFiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonNegativeFiniteNumber.is(result)).toBe(true);
+
+        assert.isTrue(NonNegativeFiniteNumber.is(result));
+
         expect(result).toBeGreaterThanOrEqual(0);
       }
     });
 
     test('generates numbers starting from 0', () => {
       const min = asNonNegativeFiniteNumber(0);
+
       const max = asNonNegativeFiniteNumber(5);
 
       for (const _ of range(10)) {
         const result = NonNegativeFiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(0);
+
         expect(result).toBeLessThanOrEqual(5);
       }
     });

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

@@ -11,37 +11,49 @@ describe('NonNegativeInt16 test', () => {
   describe(asNonNegativeInt16, () => {
     test('accepts valid non-negative int16 values', () => {
       expect(() => asNonNegativeInt16(0)).not.toThrow();
+
       expect(() => asNonNegativeInt16(1)).not.toThrow();
+
       expect(() => asNonNegativeInt16(1000)).not.toThrow();
+
       expect(() => asNonNegativeInt16(32_767)).not.toThrow(); // 2^15 - 1
     });
 
     test('rejects negative integers', () => {
       expect(() => asNonNegativeInt16(-1)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt16(-42)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt16(-32_768)).toThrow(TypeError);
     });
 
     test('rejects values outside int16 range', () => {
       expect(() => asNonNegativeInt16(32_768)).toThrow(TypeError); // 2^15
+
       expect(() => asNonNegativeInt16(65_536)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonNegativeInt16(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt16(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonNegativeInt16(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonNegativeInt16(1.2)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonNegativeInt16(0)).toBe(0);
+
       expect(asNonNegativeInt16(5)).toBe(5);
+
       expect(asNonNegativeInt16(32_767)).toBe(32_767);
     });
 
@@ -67,36 +79,48 @@ describe('NonNegativeInt16 test', () => {
 
   describe(isNonNegativeInt16, () => {
     test('correctly identifies non-negative int16 values', () => {
-      expect(isNonNegativeInt16(0)).toBe(true);
-      expect(isNonNegativeInt16(1)).toBe(true);
-      expect(isNonNegativeInt16(1000)).toBe(true);
-      expect(isNonNegativeInt16(32_767)).toBe(true);
+      assert.isTrue(isNonNegativeInt16(0));
+
+      assert.isTrue(isNonNegativeInt16(1));
+
+      assert.isTrue(isNonNegativeInt16(1000));
+
+      assert.isTrue(isNonNegativeInt16(32_767));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isNonNegativeInt16(-1)).toBe(false);
-      expect(isNonNegativeInt16(-42)).toBe(false);
-      expect(isNonNegativeInt16(-32_768)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(-1));
+
+      assert.isFalse(isNonNegativeInt16(-42));
+
+      assert.isFalse(isNonNegativeInt16(-32_768));
     });
 
     test('correctly identifies values outside int16 range', () => {
-      expect(isNonNegativeInt16(32_768)).toBe(false);
-      expect(isNonNegativeInt16(65_536)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(32_768));
+
+      assert.isFalse(isNonNegativeInt16(65_536));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonNegativeInt16(Number.NaN)).toBe(false);
-      expect(isNonNegativeInt16(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isNonNegativeInt16(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isNonNegativeInt16(1.2)).toBe(false);
-      expect(isNonNegativeInt16(-3.4)).toBe(false);
+      assert.isFalse(isNonNegativeInt16(Number.NaN));
+
+      assert.isFalse(isNonNegativeInt16(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isNonNegativeInt16(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isNonNegativeInt16(1.2));
+
+      assert.isFalse(isNonNegativeInt16(-3.4));
     });
   });
 
   describe('NonNegativeInt16.is', () => {
     test('same as isNonNegativeInt16 function', () => {
       expect(NonNegativeInt16.is(5)).toBe(isNonNegativeInt16(5));
+
       expect(NonNegativeInt16.is(0)).toBe(isNonNegativeInt16(0));
+
       expect(NonNegativeInt16.is(-1)).toBe(isNonNegativeInt16(-1));
     });
   });
@@ -104,19 +128,25 @@ describe('NonNegativeInt16 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonNegativeInt16.MIN_VALUE).toBe(0);
+
       expect(NonNegativeInt16.MAX_VALUE).toBe(32_767);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonNegativeInt16(100);
+
     const b = asNonNegativeInt16(50);
+
     const c = asNonNegativeInt16(0);
 
     test('min and max', () => {
       expect(NonNegativeInt16.min(a, b)).toBe(50);
+
       expect(NonNegativeInt16.max(a, b)).toBe(100);
+
       expect(NonNegativeInt16.min(a, c)).toBe(0);
+
       expect(NonNegativeInt16.max(a, c)).toBe(100);
     });
 
@@ -127,12 +157,15 @@ describe('NonNegativeInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(NonNegativeInt16.add(a, b)).toBe(150);
     });
 
     test('sub (never goes below 0)', () => {
       expect(NonNegativeInt16.sub(a, b)).toBe(50);
+
       expect(NonNegativeInt16.sub(b, a)).toBe(0); // clamped to 0
+
       expect(NonNegativeInt16.sub(c, a)).toBe(0); // clamped to 0
     });
 
@@ -143,6 +176,7 @@ describe('NonNegativeInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(
         NonNegativeInt16.mul(asNonNegativeInt16(10), asNonNegativeInt16(5)),
       ).toBe(50);
@@ -150,9 +184,11 @@ describe('NonNegativeInt16 test', () => {
 
     test('div (floor division, never goes below 0)', () => {
       expect(NonNegativeInt16.div(a, asPositiveInt16(50))).toBe(2);
+
       expect(
         NonNegativeInt16.div(asNonNegativeInt16(7), asPositiveInt16(3)),
       ).toBe(2);
+
       expect(
         NonNegativeInt16.div(asNonNegativeInt16(50), asPositiveInt16(100)),
       ).toBe(0); // floor(50/100) = 0
@@ -165,6 +201,7 @@ describe('NonNegativeInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(
         NonNegativeInt16.pow(asNonNegativeInt16(2), asNonNegativeInt16(3)),
       ).toBe(8);
@@ -174,15 +211,20 @@ describe('NonNegativeInt16 test', () => {
   describe('random', () => {
     test('generates non-negative int16 values within specified range', () => {
       const min = 0;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = NonNegativeInt16.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonNegativeInt16.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonNegativeInt16.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).toBeGreaterThanOrEqual(0);
       }
     });
@@ -192,6 +234,7 @@ describe('NonNegativeInt16 test', () => {
         const result = NonNegativeInt16.random(0, 30);
 
         expect(result).toBeGreaterThanOrEqual(0);
+
         expect(result).toBeLessThanOrEqual(32_767);
       }
     });