ts-data-forge 5.0.0 → 5.1.0

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

@@ -10,8 +10,11 @@ describe('NonZeroUint32 test', () => {
   describe(asNonZeroUint32, () => {
     test('accepts valid non-zero uint32 values', () => {
       expect(() => asNonZeroUint32(1)).not.toThrow();
+
       expect(() => asNonZeroUint32(1000)).not.toThrow();
+
       expect(() => asNonZeroUint32(4_294_967_295)).not.toThrow(); // 2^32 - 1
+
       expect(() => asNonZeroUint32(2_147_483_648)).not.toThrow(); // 2^31
     });
 
@@ -21,29 +24,37 @@ describe('NonZeroUint32 test', () => {
 
     test('rejects values outside uint32 range', () => {
       expect(() => asNonZeroUint32(4_294_967_296)).toThrow(TypeError); // 2^32
+
       expect(() => asNonZeroUint32(10_000_000_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asNonZeroUint32(-1)).toThrow(TypeError);
+
       expect(() => asNonZeroUint32(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroUint32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroUint32(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroUint32(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asNonZeroUint32(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroUint32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroUint32(5)).toBe(5);
+
       expect(asNonZeroUint32(1)).toBe(1);
+
       expect(asNonZeroUint32(4_294_967_295)).toBe(4_294_967_295);
     });
 
@@ -71,8 +82,11 @@ describe('NonZeroUint32 test', () => {
   describe(isNonZeroUint32, () => {
     test('correctly identifies non-zero uint32 values', () => {
       expect(isNonZeroUint32(1)).toBe(true);
+
       expect(isNonZeroUint32(1000)).toBe(true);
+
       expect(isNonZeroUint32(4_294_967_295)).toBe(true);
+
       expect(isNonZeroUint32(2_147_483_648)).toBe(true);
     });
 
@@ -82,19 +96,25 @@ describe('NonZeroUint32 test', () => {
 
     test('correctly identifies values outside uint32 range', () => {
       expect(isNonZeroUint32(4_294_967_296)).toBe(false);
+
       expect(isNonZeroUint32(10_000_000_000)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isNonZeroUint32(-1)).toBe(false);
+
       expect(isNonZeroUint32(-42)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isNonZeroUint32(Number.NaN)).toBe(false);
+
       expect(isNonZeroUint32(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroUint32(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isNonZeroUint32(1.2)).toBe(false);
+
       expect(isNonZeroUint32(-3.4)).toBe(false);
     });
   });
@@ -102,7 +122,9 @@ describe('NonZeroUint32 test', () => {
   describe('NonZeroUint32.is', () => {
     test('same as isNonZeroUint32 function', () => {
       expect(NonZeroUint32.is(5)).toBe(isNonZeroUint32(5));
+
       expect(NonZeroUint32.is(0)).toBe(isNonZeroUint32(0));
+
       expect(NonZeroUint32.is(-1)).toBe(isNonZeroUint32(-1));
     });
   });
@@ -110,16 +132,19 @@ describe('NonZeroUint32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroUint32.MIN_VALUE).toBe(1);
+
       expect(NonZeroUint32.MAX_VALUE).toBe(4_294_967_295);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroUint32(1_000_000);
+
     const b = asNonZeroUint32(500_000);
 
     test('min and max', () => {
       expect(NonZeroUint32.min(a, b)).toBe(500_000);
+
       expect(NonZeroUint32.max(a, b)).toBe(1_000_000);
     });
 
@@ -130,11 +155,13 @@ describe('NonZeroUint32 test', () => {
       );
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(NonZeroUint32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (never goes below 1)', () => {
       expect(NonZeroUint32.sub(a, b)).toBe(500_000);
+
       expect(NonZeroUint32.sub(b, a)).toBe(1); // clamped to 1
     });
 
@@ -145,6 +172,7 @@ describe('NonZeroUint32 test', () => {
       );
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(NonZeroUint32.mul(asNonZeroUint32(1000), asNonZeroUint32(5))).toBe(
         5000,
       );
@@ -152,7 +180,9 @@ describe('NonZeroUint32 test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(NonZeroUint32.div(a, asNonZeroUint32(500_000))).toBe(2);
+
       expect(NonZeroUint32.div(asNonZeroUint32(7), asNonZeroUint32(3))).toBe(2);
+
       expect(
         NonZeroUint32.div(asNonZeroUint32(500_000), asNonZeroUint32(1_000_000)),
       ).toBe(1); // floor(500000/1000000) = 0, clamped to 1
@@ -165,6 +195,7 @@ describe('NonZeroUint32 test', () => {
       );
 
       expect(result).toBe(4_294_967_295); // clamped to max
+
       expect(NonZeroUint32.pow(asNonZeroUint32(2), asNonZeroUint32(3))).toBe(8);
     });
   });
@@ -172,15 +203,20 @@ describe('NonZeroUint32 test', () => {
   describe('random', () => {
     test('generates non-zero uint32 values within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = NonZeroUint32.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(NonZeroUint32.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).not.toBe(0);
       }
     });
@@ -190,6 +226,7 @@ describe('NonZeroUint32 test', () => {
         const result = NonZeroUint32.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(4_294_967_295);
       }
     });

package/src/number/branded-types/positive-finite-number.test.mts

@@ -10,20 +10,27 @@ describe('PositiveFiniteNumber test', () => {
   describe(asPositiveFiniteNumber, () => {
     test('accepts valid positive finite numbers', () => {
       expect(() => asPositiveFiniteNumber(1)).not.toThrow();
+
       expect(() => asPositiveFiniteNumber(3.14)).not.toThrow();
+
       expect(() => asPositiveFiniteNumber(0.5)).not.toThrow();
+
       expect(() => asPositiveFiniteNumber(Number.MIN_VALUE)).not.toThrow();
+
       expect(() => asPositiveFiniteNumber(Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects zero', () => {
       expect(() => asPositiveFiniteNumber(0)).toThrow(TypeError);
+
       expect(() => asPositiveFiniteNumber(-0)).toThrow(TypeError);
     });
 
     test('rejects negative numbers', () => {
       expect(() => asPositiveFiniteNumber(-1)).toThrow(TypeError);
+
       expect(() => asPositiveFiniteNumber(-0.1)).toThrow(TypeError);
+
       expect(() => asPositiveFiniteNumber(-Number.MAX_VALUE)).toThrow(
         TypeError,
       );
@@ -31,9 +38,11 @@ describe('PositiveFiniteNumber test', () => {
 
     test('rejects non-finite numbers', () => {
       expect(() => asPositiveFiniteNumber(Number.NaN)).toThrow(TypeError);
+
       expect(() => asPositiveFiniteNumber(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveFiniteNumber(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
@@ -41,7 +50,9 @@ describe('PositiveFiniteNumber test', () => {
 
     test('returns the same value for valid inputs', () => {
       expect(asPositiveFiniteNumber(5.5)).toBe(5.5);
+
       expect(asPositiveFiniteNumber(1)).toBe(1);
+
       expect(asPositiveFiniteNumber(10)).toBe(10);
     });
 
@@ -63,26 +74,35 @@ describe('PositiveFiniteNumber test', () => {
   describe(isPositiveFiniteNumber, () => {
     test('correctly identifies positive finite numbers', () => {
       expect(isPositiveFiniteNumber(1)).toBe(true);
+
       expect(isPositiveFiniteNumber(3.14)).toBe(true);
+
       expect(isPositiveFiniteNumber(0.5)).toBe(true);
+
       expect(isPositiveFiniteNumber(Number.MIN_VALUE)).toBe(true);
+
       expect(isPositiveFiniteNumber(Number.MAX_VALUE)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
       expect(isPositiveFiniteNumber(0)).toBe(false);
+
       expect(isPositiveFiniteNumber(-0)).toBe(false);
     });
 
     test('correctly identifies negative numbers', () => {
       expect(isPositiveFiniteNumber(-1)).toBe(false);
+
       expect(isPositiveFiniteNumber(-0.1)).toBe(false);
+
       expect(isPositiveFiniteNumber(-Number.MAX_VALUE)).toBe(false);
     });
 
     test('correctly identifies non-finite numbers', () => {
       expect(isPositiveFiniteNumber(Number.NaN)).toBe(false);
+
       expect(isPositiveFiniteNumber(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isPositiveFiniteNumber(Number.NEGATIVE_INFINITY)).toBe(false);
     });
   });
@@ -90,7 +110,9 @@ describe('PositiveFiniteNumber test', () => {
   describe('PositiveFiniteNumber.is', () => {
     test('same as isPositiveFiniteNumber function', () => {
       expect(PositiveFiniteNumber.is(5)).toBe(isPositiveFiniteNumber(5));
+
       expect(PositiveFiniteNumber.is(0)).toBe(isPositiveFiniteNumber(0));
+
       expect(PositiveFiniteNumber.is(-1)).toBe(isPositiveFiniteNumber(-1));
     });
   });
@@ -103,32 +125,45 @@ describe('PositiveFiniteNumber test', () => {
 
   describe('mathematical operations', () => {
     const a = asPositiveFiniteNumber(5.5);
+
     const b = asPositiveFiniteNumber(2.5);
+
     const c = asPositiveFiniteNumber(0.5);
 
     test('min and max', () => {
       expect(PositiveFiniteNumber.min(a, b)).toBe(2.5);
+
       expect(PositiveFiniteNumber.max(a, b)).toBe(5.5);
+
       expect(PositiveFiniteNumber.min(a, c)).toBe(0.5);
+
       expect(PositiveFiniteNumber.max(a, c)).toBe(5.5);
     });
 
     test('floor, ceil, round', () => {
       expect(PositiveFiniteNumber.floor(a)).toBe(5);
+
       expect(PositiveFiniteNumber.ceil(a)).toBe(6);
+
       expect(PositiveFiniteNumber.round(a)).toBe(6);
+
       expect(PositiveFiniteNumber.floor(b)).toBe(2);
+
       expect(PositiveFiniteNumber.ceil(b)).toBe(3);
+
       expect(PositiveFiniteNumber.round(b)).toBe(3);
 
       // Test edge case with values less than 1
       expect(PositiveFiniteNumber.floor(c)).toBe(0);
+
       expect(PositiveFiniteNumber.ceil(c)).toBe(1);
+
       expect(PositiveFiniteNumber.round(c)).toBe(1);
     });
 
     test('add (always greater than 0)', () => {
       expect(PositiveFiniteNumber.add(a, b)).toBe(8);
+
       expect(PositiveFiniteNumber.add(a, c)).toBe(6);
     });
 
@@ -144,11 +179,13 @@ describe('PositiveFiniteNumber test', () => {
 
     test('mul (always greater than 0)', () => {
       expect(PositiveFiniteNumber.mul(a, b)).toBe(13.75);
+
       expect(PositiveFiniteNumber.mul(a, c)).toBe(2.75);
     });
 
     test('div (always greater than 0)', () => {
       expect(PositiveFiniteNumber.div(a, b)).toBe(2.2);
+
       expect(PositiveFiniteNumber.div(a, asPositiveFiniteNumber(2))).toBe(2.75);
     });
 
@@ -159,6 +196,7 @@ describe('PositiveFiniteNumber test', () => {
           asPositiveFiniteNumber(3),
         ),
       ).toBe(8);
+
       expect(
         PositiveFiniteNumber.pow(
           asPositiveFiniteNumber(3),
@@ -171,27 +209,34 @@ describe('PositiveFiniteNumber test', () => {
   describe('random', () => {
     test('generates positive numbers within specified range', () => {
       const min = asPositiveFiniteNumber(1.5);
+
       const max = asPositiveFiniteNumber(10.3);
 
       for (const _ of range(10)) {
         const result = PositiveFiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(PositiveFiniteNumber.is(result)).toBe(true);
+
         expect(result).toBeGreaterThan(0);
       }
     });
 
     test('generates numbers starting from MIN_VALUE', () => {
       const min = asPositiveFiniteNumber(Number.MIN_VALUE);
+
       const max = asPositiveFiniteNumber(1);
 
       for (const _ of range(10)) {
         const result = PositiveFiniteNumber.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(Number.MIN_VALUE);
+
         expect(result).toBeLessThanOrEqual(1);
+
         expect(result).toBeGreaterThan(0);
       }
     });

package/src/number/branded-types/positive-int.mts

@@ -39,7 +39,9 @@ const {
  *
  * ```ts
  * assert.ok(isPositiveInt(5));
+ *
  * assert.notOk(isPositiveInt(0));
+ *
  * assert.ok(PositiveInt.is(10));
  * ```
  *
@@ -61,6 +63,7 @@ export const isPositiveInt = is;
  * const branded = asPositiveInt(7);
  *
  * assert(branded === 7);
+ *
  * assert.ok(PositiveInt.is(branded));
  * ```
  *
@@ -94,7 +97,9 @@ export const PositiveInt = {
    *
    * ```ts
    * assert.ok(isPositiveInt(5));
+   *
    * assert.notOk(isPositiveInt(0));
+   *
    * assert.ok(PositiveInt.is(10));
    * ```
    *
@@ -164,9 +169,11 @@ export const PositiveInt = {
    *
    * ```ts
    * const belowRange = PositiveInt.clamp(0);
+   *
    * const withinRange = PositiveInt.clamp(10);
    *
    * assert(belowRange === 1);
+   *
    * assert(withinRange === 10);
    * ```
    *
@@ -185,10 +192,13 @@ export const PositiveInt = {
    *
    * ```ts
    * const min = asPositiveInt(3);
+   *
    * const max = asPositiveInt(6);
+   *
    * const randomValue = PositiveInt.random(min, max);
    *
    * assert.ok(PositiveInt.is(randomValue));
+   *
    * assert.ok(randomValue >= 3 && randomValue <= 6);
    * ```
    *
@@ -206,7 +216,9 @@ export const PositiveInt = {
    *
    * ```ts
    * const base = asPositiveInt(2);
+   *
    * const exponent = asPositiveInt(4);
+   *
    * const power = PositiveInt.pow(base, exponent);
    *
    * assert(power === 16);
@@ -284,9 +296,11 @@ export const PositiveInt = {
    *
    * ```ts
    * const quotient = PositiveInt.div(asPositiveInt(9), asPositiveInt(2));
+   *
    * const clamped = PositiveInt.div(asPositiveInt(3), asPositiveInt(10));
    *
    * assert(quotient === 4);
+   *
    * assert(clamped === 1);
    * ```
    *

package/src/number/branded-types/positive-int.test.mts

@@ -6,34 +6,47 @@ describe('PositiveInt test', () => {
   describe(asPositiveInt, () => {
     test('accepts valid positive integers', () => {
       expect(() => asPositiveInt(1)).not.toThrow();
+
       expect(() => asPositiveInt(2)).not.toThrow();
+
       expect(() => asPositiveInt(42)).not.toThrow();
+
       expect(() => asPositiveInt(100)).not.toThrow();
+
       expect(() => asPositiveInt(Number.MAX_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects zero', () => {
       expect(() => asPositiveInt(0)).toThrow(TypeError);
+
       expect(() => asPositiveInt(-0)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asPositiveInt(-1)).toThrow(TypeError);
+
       expect(() => asPositiveInt(-42)).toThrow(TypeError);
+
       expect(() => asPositiveInt(Number.MIN_SAFE_INTEGER)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asPositiveInt(Number.NaN)).toThrow(TypeError);
+
       expect(() => asPositiveInt(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asPositiveInt(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asPositiveInt(1.2)).toThrow(TypeError);
+
       expect(() => asPositiveInt(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asPositiveInt(5)).toBe(5);
+
       expect(asPositiveInt(1)).toBe(1);
+
       expect(asPositiveInt(10)).toBe(10);
     });
 
@@ -58,28 +71,39 @@ describe('PositiveInt test', () => {
   describe(isPositiveInt, () => {
     test('correctly identifies positive integers', () => {
       expect(isPositiveInt(1)).toBe(true);
+
       expect(isPositiveInt(2)).toBe(true);
+
       expect(isPositiveInt(42)).toBe(true);
+
       expect(isPositiveInt(100)).toBe(true);
+
       expect(isPositiveInt(Number.MAX_SAFE_INTEGER)).toBe(true);
     });
 
     test('correctly identifies zero', () => {
       expect(isPositiveInt(0)).toBe(false);
+
       expect(isPositiveInt(-0)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isPositiveInt(-1)).toBe(false);
+
       expect(isPositiveInt(-42)).toBe(false);
+
       expect(isPositiveInt(Number.MIN_SAFE_INTEGER)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isPositiveInt(Number.NaN)).toBe(false);
+
       expect(isPositiveInt(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isPositiveInt(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isPositiveInt(1.2)).toBe(false);
+
       expect(isPositiveInt(-3.4)).toBe(false);
     });
   });
@@ -87,7 +111,9 @@ describe('PositiveInt test', () => {
   describe('PositiveInt.is', () => {
     test('same as isPositiveInt function', () => {
       expect(PositiveInt.is(5)).toBe(isPositiveInt(5));
+
       expect(PositiveInt.is(0)).toBe(isPositiveInt(0));
+
       expect(PositiveInt.is(-10)).toBe(isPositiveInt(-10));
     });
   });
@@ -100,41 +126,54 @@ describe('PositiveInt test', () => {
 
   describe('mathematical operations', () => {
     const a = asPositiveInt(5);
+
     const b = asPositiveInt(2);
+
     const c = asPositiveInt(1);
 
     test('min and max', () => {
       expect(PositiveInt.min(a, b)).toBe(2);
+
       expect(PositiveInt.max(a, b)).toBe(5);
+
       expect(PositiveInt.min(a, c)).toBe(1);
+
       expect(PositiveInt.max(a, c)).toBe(5);
     });
 
     test('add (never goes below 1)', () => {
       expect(PositiveInt.add(a, b)).toBe(7);
+
       expect(PositiveInt.add(a, c)).toBe(6);
     });
 
     test('sub (never goes below 1)', () => {
       expect(PositiveInt.sub(a, b)).toBe(3);
+
       expect(PositiveInt.sub(b, a)).toBe(1); // clamped to 1
+
       expect(PositiveInt.sub(c, a)).toBe(1); // clamped to 1
     });
 
     test('mul (never goes below 1)', () => {
       expect(PositiveInt.mul(a, b)).toBe(10);
+
       expect(PositiveInt.mul(a, c)).toBe(5);
     });
 
     test('div (floor division, never goes below 1)', () => {
       expect(PositiveInt.div(a, b)).toBe(2);
+
       expect(PositiveInt.div(asPositiveInt(7), asPositiveInt(3))).toBe(2);
+
       expect(PositiveInt.div(b, a)).toBe(1); // floor(2/5) = 0, but clamped to 1
     });
 
     test('pow (never goes below 1)', () => {
       expect(PositiveInt.pow(asPositiveInt(2), asPositiveInt(3))).toBe(8);
+
       expect(PositiveInt.pow(asPositiveInt(3), asPositiveInt(2))).toBe(9);
+
       expect(PositiveInt.pow(asPositiveInt(5), asPositiveInt(1))).toBe(5);
     });
   });
@@ -142,28 +181,36 @@ describe('PositiveInt test', () => {
   describe('random', () => {
     test('generates positive integers within specified range', () => {
       const min = 1;
+
       const max = 10;
 
       for (const _ of range(10)) {
         const result = PositiveInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(PositiveInt.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).toBeGreaterThan(0);
       }
     });
 
     test('generates integers starting from 1', () => {
       const min = 1;
+
       const max = 5;
 
       for (const _ of range(10)) {
         const result = PositiveInt.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(5);
+
         expect(result).toBeGreaterThan(0);
       }
     });