ts-data-forge 5.0.0 → 5.1.0

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

@@ -10,25 +10,35 @@ describe('NonZeroFiniteNumber test', () => {
   describe(asNonZeroFiniteNumber, () => {
     test('accepts valid non-zero finite numbers', () => {
       expect(() => asNonZeroFiniteNumber(1)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(-1)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(3.14)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(-2.5)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(0.001)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(-0.001)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(Number.MAX_VALUE)).not.toThrow();
+
       expect(() => asNonZeroFiniteNumber(-Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects zero', () => {
       expect(() => asNonZeroFiniteNumber(0)).toThrow(TypeError);
+
       expect(() => asNonZeroFiniteNumber(-0)).toThrow(TypeError);
     });
 
     test('rejects non-finite numbers', () => {
       expect(() => asNonZeroFiniteNumber(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
@@ -36,7 +46,9 @@ describe('NonZeroFiniteNumber test', () => {
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroFiniteNumber(5.5)).toBe(5.5);
+
       expect(asNonZeroFiniteNumber(-10)).toBe(-10);
+
       expect(asNonZeroFiniteNumber(1)).toBe(1);
     });
 
@@ -58,21 +70,29 @@ describe('NonZeroFiniteNumber test', () => {
   describe(isNonZeroFiniteNumber, () => {
     test('correctly identifies non-zero finite numbers', () => {
       expect(isNonZeroFiniteNumber(1)).toBe(true);
+
       expect(isNonZeroFiniteNumber(-1)).toBe(true);
+
       expect(isNonZeroFiniteNumber(3.14)).toBe(true);
+
       expect(isNonZeroFiniteNumber(-2.5)).toBe(true);
+
       expect(isNonZeroFiniteNumber(0.001)).toBe(true);
+
       expect(isNonZeroFiniteNumber(-0.001)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
       expect(isNonZeroFiniteNumber(0)).toBe(false);
+
       expect(isNonZeroFiniteNumber(-0)).toBe(false);
     });
 
     test('correctly identifies non-finite numbers', () => {
       expect(isNonZeroFiniteNumber(Number.NaN)).toBe(false);
+
       expect(isNonZeroFiniteNumber(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroFiniteNumber(Number.NEGATIVE_INFINITY)).toBe(false);
     });
   });
@@ -80,55 +100,73 @@ describe('NonZeroFiniteNumber test', () => {
   describe('NonZeroFiniteNumber.is', () => {
     test('same as isNonZeroFiniteNumber function', () => {
       expect(NonZeroFiniteNumber.is(5)).toBe(isNonZeroFiniteNumber(5));
+
       expect(NonZeroFiniteNumber.is(0)).toBe(isNonZeroFiniteNumber(0));
+
       expect(NonZeroFiniteNumber.is(-1)).toBe(isNonZeroFiniteNumber(-1));
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroFiniteNumber(5.5);
+
     const b = asNonZeroFiniteNumber(2.5);
+
     const c = asNonZeroFiniteNumber(-3.5);
 
     test('abs', () => {
       expect(NonZeroFiniteNumber.abs(a)).toBe(5.5);
+
       expect(NonZeroFiniteNumber.abs(c)).toBe(3.5);
+
       expect(NonZeroFiniteNumber.abs(asNonZeroFiniteNumber(-1))).toBe(1);
     });
 
     test('min and max', () => {
       expect(NonZeroFiniteNumber.min(a, b)).toBe(2.5);
+
       expect(NonZeroFiniteNumber.max(a, b)).toBe(5.5);
+
       expect(NonZeroFiniteNumber.min(a, c)).toBe(-3.5);
+
       expect(NonZeroFiniteNumber.max(a, c)).toBe(5.5);
     });
 
     test('floor, ceil, round', () => {
       expect(NonZeroFiniteNumber.floor(a)).toBe(5);
+
       expect(NonZeroFiniteNumber.ceil(a)).toBe(6);
+
       expect(NonZeroFiniteNumber.round(a)).toBe(6);
+
       expect(NonZeroFiniteNumber.floor(c)).toBe(-4);
+
       expect(NonZeroFiniteNumber.ceil(c)).toBe(-3);
+
       expect(NonZeroFiniteNumber.round(c)).toBe(-3);
     });
 
     test('add', () => {
       expect(NonZeroFiniteNumber.add(a, b)).toBe(8);
+
       expect(NonZeroFiniteNumber.add(a, c)).toBe(2);
     });
 
     test('sub', () => {
       expect(NonZeroFiniteNumber.sub(a, b)).toBe(3);
+
       expect(NonZeroFiniteNumber.sub(a, c)).toBe(9);
     });
 
     test('mul', () => {
       expect(NonZeroFiniteNumber.mul(a, b)).toBe(13.75);
+
       expect(NonZeroFiniteNumber.mul(a, c)).toBe(-19.25);
     });
 
     test('div', () => {
       expect(NonZeroFiniteNumber.div(a, b)).toBe(2.2);
+
       expect(NonZeroFiniteNumber.div(a, asNonZeroFiniteNumber(2))).toBe(2.75);
     });
 
@@ -139,6 +177,7 @@ describe('NonZeroFiniteNumber test', () => {
           asNonZeroFiniteNumber(3),
         ),
       ).toBe(8);
+
       expect(
         NonZeroFiniteNumber.pow(
           asNonZeroFiniteNumber(3),
@@ -151,42 +190,54 @@ describe('NonZeroFiniteNumber test', () => {
   describe('random', () => {
     test('generates non-zero numbers within specified range (positive range)', () => {
       const min = asNonZeroFiniteNumber(1.5);
+
       const max = asNonZeroFiniteNumber(10.3);
 
       for (const _ of range(10)) {
         const result = NonZeroFiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(NonZeroFiniteNumber.is(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero numbers within specified range (negative range)', () => {
       const min = asNonZeroFiniteNumber(-10.3);
+
       const max = asNonZeroFiniteNumber(-1.5);
 
       for (const _ of range(10)) {
         const result = NonZeroFiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(NonZeroFiniteNumber.is(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero numbers within range that spans zero', () => {
       const min = asNonZeroFiniteNumber(-5.5);
+
       const max = asNonZeroFiniteNumber(5.5);
 
       for (const _ of range(10)) {
         const result = NonZeroFiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(NonZeroFiniteNumber.is(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });

package/src/number/branded-types/non-zero-int.test.mts

@@ -6,29 +6,41 @@ describe('NonZeroInt test', () => {
   describe(asNonZeroInt, () => {
     test('accepts valid non-zero integers', () => {
       expect(() => asNonZeroInt(1)).not.toThrow();
+
       expect(() => asNonZeroInt(-1)).not.toThrow();
+
       expect(() => asNonZeroInt(42)).not.toThrow();
+
       expect(() => asNonZeroInt(-42)).not.toThrow();
+
       expect(() => asNonZeroInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
+
       expect(() => asNonZeroInt(Number.MIN_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects zero', () => {
       expect(() => asNonZeroInt(0)).toThrow(TypeError);
+
       expect(() => asNonZeroInt(-0)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroInt(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroInt(5)).toBe(5);
+
       expect(asNonZeroInt(-10)).toBe(-10);
+
       expect(asNonZeroInt(1)).toBe(1);
     });
 
@@ -49,23 +61,33 @@ describe('NonZeroInt test', () => {
   describe(isNonZeroInt, () => {
     test('correctly identifies non-zero integers', () => {
       expect(isNonZeroInt(1)).toBe(true);
+
       expect(isNonZeroInt(-1)).toBe(true);
+
       expect(isNonZeroInt(42)).toBe(true);
+
       expect(isNonZeroInt(-42)).toBe(true);
+
       expect(isNonZeroInt(Number.MAX_SAFE_INTEGER)).toBe(true);
+
       expect(isNonZeroInt(Number.MIN_SAFE_INTEGER)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
       expect(isNonZeroInt(0)).toBe(false);
+
       expect(isNonZeroInt(-0)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isNonZeroInt(Number.NaN)).toBe(false);
+
       expect(isNonZeroInt(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroInt(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroInt(1.2)).toBe(false);
+
       expect(isNonZeroInt(-3.4)).toBe(false);
     });
   });
@@ -73,53 +95,69 @@ describe('NonZeroInt test', () => {
   describe('NonZeroInt.is', () => {
     test('same as isNonZeroInt function', () => {
       expect(NonZeroInt.is(5)).toBe(isNonZeroInt(5));
+
       expect(NonZeroInt.is(0)).toBe(isNonZeroInt(0));
+
       expect(NonZeroInt.is(-10)).toBe(isNonZeroInt(-10));
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroInt(5);
+
     const b = asNonZeroInt(2);
+
     const c = asNonZeroInt(-3);
 
     test('abs', () => {
       expect(NonZeroInt.abs(a)).toBe(5);
+
       expect(NonZeroInt.abs(c)).toBe(3);
+
       expect(NonZeroInt.abs(asNonZeroInt(-1))).toBe(1);
     });
 
     test('min and max', () => {
       expect(NonZeroInt.min(a, b)).toBe(2);
+
       expect(NonZeroInt.max(a, b)).toBe(5);
+
       expect(NonZeroInt.min(a, c)).toBe(-3);
+
       expect(NonZeroInt.max(a, c)).toBe(5);
     });
 
     test('add', () => {
       expect(NonZeroInt.add(a, b)).toBe(7);
+
       expect(NonZeroInt.add(a, c)).toBe(2);
     });
 
     test('sub', () => {
       expect(NonZeroInt.sub(a, b)).toBe(3);
+
       expect(NonZeroInt.sub(a, c)).toBe(8);
     });
 
     test('mul', () => {
       expect(NonZeroInt.mul(a, b)).toBe(10);
+
       expect(NonZeroInt.mul(a, c)).toBe(-15);
     });
 
     test('div (floor division)', () => {
       expect(NonZeroInt.div(a, b)).toBe(2);
+
       expect(NonZeroInt.div(asNonZeroInt(7), asNonZeroInt(3))).toBe(2);
+
       expect(NonZeroInt.div(asNonZeroInt(-7), asNonZeroInt(3))).toBe(-3);
     });
 
     test('pow', () => {
       expect(NonZeroInt.pow(asNonZeroInt(2), asNonZeroInt(3))).toBe(8);
+
       expect(NonZeroInt.pow(asNonZeroInt(3), asNonZeroInt(2))).toBe(9);
+
       expect(NonZeroInt.pow(asNonZeroInt(-2), asNonZeroInt(3))).toBe(-8);
     });
   });
@@ -127,45 +165,60 @@ describe('NonZeroInt test', () => {
   describe('random', () => {
     test('generates non-zero integers within specified range (positive range)', () => {
       const min = 1;
+
       const max = 10;
 
       for (const _ of range(10)) {
         const result = NonZeroInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(NonZeroInt.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero integers within specified range (negative range)', () => {
       const min = -10;
+
       const max = -1;
 
       for (const _ of range(10)) {
         const result = NonZeroInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(NonZeroInt.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });
 
     test('generates non-zero integers within range that spans zero', () => {
       const min = -5;
+
       const max = 5;
 
       for (const _ of range(10)) {
         const result = NonZeroInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(NonZeroInt.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });

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

@@ -10,8 +10,11 @@ describe('NonZeroInt16 test', () => {
   describe(asNonZeroInt16, () => {
     test('accepts valid non-zero int16 values', () => {
       expect(() => asNonZeroInt16(1)).not.toThrow();
+
       expect(() => asNonZeroInt16(-1)).not.toThrow();
+
       expect(() => asNonZeroInt16(32_767)).not.toThrow(); // 2^15 - 1
+
       expect(() => asNonZeroInt16(-32_768)).not.toThrow(); // -2^15
     });
 
@@ -21,23 +24,33 @@ describe('NonZeroInt16 test', () => {
 
     test('rejects values outside int16 range', () => {
       expect(() => asNonZeroInt16(32_768)).toThrow(TypeError); // 2^15
+
       expect(() => asNonZeroInt16(-32_769)).toThrow(TypeError); // -2^15 - 1
+
       expect(() => asNonZeroInt16(65_536)).toThrow(TypeError);
+
       expect(() => asNonZeroInt16(-65_536)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroInt16(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroInt16(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt16(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt16(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroInt16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroInt16(5)).toBe(5);
+
       expect(asNonZeroInt16(-10)).toBe(-10);
+
       expect(asNonZeroInt16(32_767)).toBe(32_767);
+
       expect(asNonZeroInt16(-32_768)).toBe(-32_768);
     });
 
@@ -65,8 +78,11 @@ describe('NonZeroInt16 test', () => {
   describe(isNonZeroInt16, () => {
     test('correctly identifies non-zero int16 values', () => {
       expect(isNonZeroInt16(1)).toBe(true);
+
       expect(isNonZeroInt16(-1)).toBe(true);
+
       expect(isNonZeroInt16(32_767)).toBe(true);
+
       expect(isNonZeroInt16(-32_768)).toBe(true);
     });
 
@@ -76,16 +92,23 @@ describe('NonZeroInt16 test', () => {
 
     test('correctly identifies values outside int16 range', () => {
       expect(isNonZeroInt16(32_768)).toBe(false);
+
       expect(isNonZeroInt16(-32_769)).toBe(false);
+
       expect(isNonZeroInt16(65_536)).toBe(false);
+
       expect(isNonZeroInt16(-65_536)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isNonZeroInt16(Number.NaN)).toBe(false);
+
       expect(isNonZeroInt16(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroInt16(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroInt16(1.2)).toBe(false);
+
       expect(isNonZeroInt16(-3.4)).toBe(false);
     });
   });
@@ -93,7 +116,9 @@ describe('NonZeroInt16 test', () => {
   describe('NonZeroInt16.is', () => {
     test('same as isNonZeroInt16 function', () => {
       expect(NonZeroInt16.is(5)).toBe(isNonZeroInt16(5));
+
       expect(NonZeroInt16.is(0)).toBe(isNonZeroInt16(0));
+
       expect(NonZeroInt16.is(-1)).toBe(isNonZeroInt16(-1));
     });
   });
@@ -101,24 +126,31 @@ describe('NonZeroInt16 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroInt16.MIN_VALUE).toBe(-32_768);
+
       expect(NonZeroInt16.MAX_VALUE).toBe(32_767);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroInt16(100);
+
     const b = asNonZeroInt16(50);
+
     const c = asNonZeroInt16(-30);
 
     test('abs', () => {
       expect(NonZeroInt16.abs(a)).toBe(100);
+
       expect(NonZeroInt16.abs(c)).toBe(30);
     });
 
     test('min and max', () => {
       expect(NonZeroInt16.min(a, b)).toBe(50);
+
       expect(NonZeroInt16.max(a, b)).toBe(100);
+
       expect(NonZeroInt16.min(a, c)).toBe(-30);
+
       expect(NonZeroInt16.max(a, c)).toBe(100);
     });
 
@@ -129,6 +161,7 @@ describe('NonZeroInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(NonZeroInt16.add(a, b)).toBe(150);
     });
 
@@ -139,6 +172,7 @@ describe('NonZeroInt16 test', () => {
       );
 
       expect(result).toBe(-32_768); // clamped to min
+
       expect(NonZeroInt16.sub(a, b)).toBe(50);
     });
 
@@ -149,12 +183,15 @@ describe('NonZeroInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(NonZeroInt16.mul(asNonZeroInt16(10), asNonZeroInt16(5))).toBe(50);
     });
 
     test('div (floor division with clamping)', () => {
       expect(NonZeroInt16.div(a, asNonZeroInt16(50))).toBe(2);
+
       expect(NonZeroInt16.div(asNonZeroInt16(7), asNonZeroInt16(3))).toBe(2);
+
       expect(NonZeroInt16.div(asNonZeroInt16(-7), asNonZeroInt16(3))).toBe(-3);
     });
 
@@ -162,6 +199,7 @@ describe('NonZeroInt16 test', () => {
       const result = NonZeroInt16.pow(asNonZeroInt16(200), asNonZeroInt16(3));
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(NonZeroInt16.pow(asNonZeroInt16(2), asNonZeroInt16(3))).toBe(8);
     });
   });
@@ -169,15 +207,20 @@ describe('NonZeroInt16 test', () => {
   describe('random', () => {
     test('generates non-zero int16 values within specified range', () => {
       const min = -10;
+
       const max = 10;
 
       for (const _ of range(10)) {
         const result = NonZeroInt16.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(NonZeroInt16.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });
@@ -187,6 +230,7 @@ describe('NonZeroInt16 test', () => {
         const result = NonZeroInt16.random(-20, 20);
 
         expect(result).toBeGreaterThanOrEqual(-32_768);
+
         expect(result).toBeLessThanOrEqual(32_767);
       }
     });