ts-data-forge 5.0.0 → 5.1.0

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);
     });
 
@@ -58,21 +68,29 @@ 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);
     });
 
     test('correctly identifies negative numbers', () => {
       expect(isNonNegativeFiniteNumber(-1)).toBe(false);
+
       expect(isNonNegativeFiniteNumber(-0.1)).toBe(false);
+
       expect(isNonNegativeFiniteNumber(-Number.MAX_VALUE)).toBe(false);
     });
 
     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);
     });
   });
@@ -80,9 +98,11 @@ describe('NonNegativeFiniteNumber test', () => {
   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);
+
         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);
     });
 
@@ -68,27 +80,37 @@ 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);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isNonNegativeInt16(-1)).toBe(false);
+
       expect(isNonNegativeInt16(-42)).toBe(false);
+
       expect(isNonNegativeInt16(-32_768)).toBe(false);
     });
 
     test('correctly identifies values outside int16 range', () => {
       expect(isNonNegativeInt16(32_768)).toBe(false);
+
       expect(isNonNegativeInt16(65_536)).toBe(false);
     });
 
     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);
     });
   });
@@ -96,7 +118,9 @@ describe('NonNegativeInt16 test', () => {
   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);
+
         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);
       }
     });

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

@@ -11,37 +11,49 @@ describe('NonNegativeInt32 test', () => {
   describe(asNonNegativeInt32, () => {
     test('accepts valid non-negative int32 values', () => {
       expect(() => asNonNegativeInt32(0)).not.toThrow();
+
       expect(() => asNonNegativeInt32(1)).not.toThrow();
+
       expect(() => asNonNegativeInt32(1000)).not.toThrow();
+
       expect(() => asNonNegativeInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
     });
 
     test('rejects negative integers', () => {
       expect(() => asNonNegativeInt32(-1)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt32(-42)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt32(-2_147_483_648)).toThrow(TypeError);
     });
 
     test('rejects values outside int32 range', () => {
       expect(() => asNonNegativeInt32(2_147_483_648)).toThrow(TypeError); // 2^31
+
       expect(() => asNonNegativeInt32(4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonNegativeInt32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt32(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonNegativeInt32(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonNegativeInt32(1.2)).toThrow(TypeError);
+
       expect(() => asNonNegativeInt32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonNegativeInt32(0)).toBe(0);
+
       expect(asNonNegativeInt32(5)).toBe(5);
+
       expect(asNonNegativeInt32(2_147_483_647)).toBe(2_147_483_647);
     });
 
@@ -68,27 +80,37 @@ describe('NonNegativeInt32 test', () => {
   describe(isNonNegativeInt32, () => {
     test('correctly identifies non-negative int32 values', () => {
       expect(isNonNegativeInt32(0)).toBe(true);
+
       expect(isNonNegativeInt32(1)).toBe(true);
+
       expect(isNonNegativeInt32(1000)).toBe(true);
+
       expect(isNonNegativeInt32(2_147_483_647)).toBe(true);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isNonNegativeInt32(-1)).toBe(false);
+
       expect(isNonNegativeInt32(-42)).toBe(false);
+
       expect(isNonNegativeInt32(-2_147_483_648)).toBe(false);
     });
 
     test('correctly identifies values outside int32 range', () => {
       expect(isNonNegativeInt32(2_147_483_648)).toBe(false);
+
       expect(isNonNegativeInt32(4_294_967_296)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isNonNegativeInt32(Number.NaN)).toBe(false);
+
       expect(isNonNegativeInt32(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isNonNegativeInt32(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isNonNegativeInt32(1.2)).toBe(false);
+
       expect(isNonNegativeInt32(-3.4)).toBe(false);
     });
   });
@@ -96,7 +118,9 @@ describe('NonNegativeInt32 test', () => {
   describe('NonNegativeInt32.is', () => {
     test('same as isNonNegativeInt32 function', () => {
       expect(NonNegativeInt32.is(5)).toBe(isNonNegativeInt32(5));
+
       expect(NonNegativeInt32.is(0)).toBe(isNonNegativeInt32(0));
+
       expect(NonNegativeInt32.is(-1)).toBe(isNonNegativeInt32(-1));
     });
   });
@@ -104,19 +128,25 @@ describe('NonNegativeInt32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonNegativeInt32.MIN_VALUE).toBe(0);
+
       expect(NonNegativeInt32.MAX_VALUE).toBe(2_147_483_647);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonNegativeInt32(1_000_000);
+
     const b = asNonNegativeInt32(500_000);
+
     const c = asNonNegativeInt32(0);
 
     test('min and max', () => {
       expect(NonNegativeInt32.min(a, b)).toBe(500_000);
+
       expect(NonNegativeInt32.max(a, b)).toBe(1_000_000);
+
       expect(NonNegativeInt32.min(a, c)).toBe(0);
+
       expect(NonNegativeInt32.max(a, c)).toBe(1_000_000);
     });
 
@@ -127,12 +157,15 @@ describe('NonNegativeInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(NonNegativeInt32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (never goes below 0)', () => {
       expect(NonNegativeInt32.sub(a, b)).toBe(500_000);
+
       expect(NonNegativeInt32.sub(b, a)).toBe(0); // clamped to 0
+
       expect(NonNegativeInt32.sub(c, a)).toBe(0); // clamped to 0
     });
 
@@ -143,6 +176,7 @@ describe('NonNegativeInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(
         NonNegativeInt32.mul(asNonNegativeInt32(1000), asNonNegativeInt32(5)),
       ).toBe(5000);
@@ -150,9 +184,11 @@ describe('NonNegativeInt32 test', () => {
 
     test('div (floor division, never goes below 0)', () => {
       expect(NonNegativeInt32.div(a, asPositiveInt32(500_000))).toBe(2);
+
       expect(
         NonNegativeInt32.div(asNonNegativeInt32(7), asPositiveInt32(3)),
       ).toBe(2);
+
       expect(
         NonNegativeInt32.div(
           asNonNegativeInt32(500_000),
@@ -168,6 +204,7 @@ describe('NonNegativeInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(
         NonNegativeInt32.pow(asNonNegativeInt32(2), asNonNegativeInt32(3)),
       ).toBe(8);
@@ -177,15 +214,20 @@ describe('NonNegativeInt32 test', () => {
   describe('random', () => {
     test('generates non-negative int32 values within specified range', () => {
       const min = 0;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = NonNegativeInt32.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(NonNegativeInt32.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).toBeGreaterThanOrEqual(0);
       }
     });
@@ -195,6 +237,7 @@ describe('NonNegativeInt32 test', () => {
         const result = NonNegativeInt32.random(0, 30);
 
         expect(result).toBeGreaterThanOrEqual(0);
+
         expect(result).toBeLessThanOrEqual(2_147_483_647);
       }
     });