ts-data-forge 5.0.0 → 5.1.0

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);
     });
 
@@ -45,19 +57,29 @@ 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);
     });
 
     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);
     });
   });
@@ -65,53 +87,69 @@ describe('Int test', () => {
   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,14 +157,18 @@ 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);
       }
     });

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);
     });
 
@@ -52,24 +67,35 @@ 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);
     });
 
     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);
     });
 
     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);
     });
   });
@@ -77,7 +103,9 @@ describe('Int16 test', () => {
   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,14 +187,18 @@ 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);
       }
     });
@@ -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);
       }
     });

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);
     });
 
@@ -52,24 +67,35 @@ 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);
     });
 
     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);
     });
 
     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);
     });
   });
@@ -77,7 +103,9 @@ describe('Int32 test', () => {
   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,14 +187,18 @@ 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);
       }
     });
@@ -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);
       }
     });