ts-data-forge 5.0.0 → 5.1.0

package/src/number/branded-types/safe-uint.test.mts

@@ -6,35 +6,49 @@ describe('SafeUint test', () => {
   describe(asSafeUint, () => {
     test('accepts valid safe unsigned integers', () => {
       expect(() => asSafeUint(0)).not.toThrow();
+
       expect(() => asSafeUint(1)).not.toThrow();
+
       expect(() => asSafeUint(42)).not.toThrow();
+
       expect(() => asSafeUint(100)).not.toThrow();
+
       expect(() => asSafeUint(Number.MAX_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects negative numbers', () => {
       expect(() => asSafeUint(-1)).toThrow(TypeError);
+
       expect(() => asSafeUint(-42)).toThrow(TypeError);
+
       expect(() => asSafeUint(Number.MIN_SAFE_INTEGER)).toThrow(TypeError);
     });
 
     test('rejects values outside safe integer range', () => {
       expect(() => asSafeUint(Number.MAX_SAFE_INTEGER + 1)).toThrow(TypeError);
+
       expect(() => asSafeUint(Number.MAX_VALUE)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asSafeUint(Number.NaN)).toThrow(TypeError);
+
       expect(() => asSafeUint(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asSafeUint(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asSafeUint(1.2)).toThrow(TypeError);
+
       expect(() => asSafeUint(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asSafeUint(5)).toBe(5);
+
       expect(asSafeUint(0)).toBe(0);
+
       expect(asSafeUint(10)).toBe(10);
+
       expect(asSafeUint(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
     });
 
@@ -55,28 +69,39 @@ describe('SafeUint test', () => {
   describe(isSafeUint, () => {
     test('correctly identifies safe unsigned integers', () => {
       expect(isSafeUint(0)).toBe(true);
+
       expect(isSafeUint(1)).toBe(true);
+
       expect(isSafeUint(42)).toBe(true);
+
       expect(isSafeUint(100)).toBe(true);
+
       expect(isSafeUint(Number.MAX_SAFE_INTEGER)).toBe(true);
     });
 
     test('correctly identifies negative numbers', () => {
       expect(isSafeUint(-1)).toBe(false);
+
       expect(isSafeUint(-42)).toBe(false);
+
       expect(isSafeUint(Number.MIN_SAFE_INTEGER)).toBe(false);
     });
 
     test('correctly identifies values outside safe integer range', () => {
       expect(isSafeUint(Number.MAX_SAFE_INTEGER + 1)).toBe(false);
+
       expect(isSafeUint(Number.MAX_VALUE)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isSafeUint(Number.NaN)).toBe(false);
+
       expect(isSafeUint(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isSafeUint(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isSafeUint(1.2)).toBe(false);
+
       expect(isSafeUint(-3.4)).toBe(false);
     });
   });
@@ -84,7 +109,9 @@ describe('SafeUint test', () => {
   describe('SafeUint.is', () => {
     test('same as isSafeUint function', () => {
       expect(SafeUint.is(5)).toBe(isSafeUint(5));
+
       expect(SafeUint.is(-1)).toBe(isSafeUint(-1));
+
       expect(SafeUint.is(0)).toBe(isSafeUint(0));
     });
   });
@@ -92,33 +119,43 @@ describe('SafeUint test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(SafeUint.MIN_VALUE).toBe(0);
+
       expect(SafeUint.MAX_VALUE).toBe(Number.MAX_SAFE_INTEGER);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asSafeUint(5);
+
     const b = asSafeUint(2);
+
     const c = asSafeUint(0);
 
     test('min and max', () => {
       expect(SafeUint.min(a, b)).toBe(2);
+
       expect(SafeUint.max(a, b)).toBe(5);
+
       expect(SafeUint.min(a, c)).toBe(0);
+
       expect(SafeUint.max(a, c)).toBe(5);
     });
 
     test('add (clamped to safe uint range)', () => {
       const largeValue = asSafeUint(Number.MAX_SAFE_INTEGER - 1);
+
       const result = SafeUint.add(largeValue, asSafeUint(10));
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(SafeUint.add(a, b)).toBe(7);
     });
 
     test('sub (never goes below 0)', () => {
       expect(SafeUint.sub(a, b)).toBe(3);
+
       expect(SafeUint.sub(b, a)).toBe(0); // clamped to 0
+
       expect(SafeUint.sub(c, a)).toBe(0); // clamped to 0
     });
 
@@ -126,15 +163,19 @@ describe('SafeUint test', () => {
       const largeValue = asSafeUint(
         Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER)),
       );
+
       const result = SafeUint.mul(largeValue, largeValue);
 
       expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
+
       expect(SafeUint.mul(asSafeUint(10), asSafeUint(5))).toBe(50);
     });
 
     test('div (floor division, never goes below 0)', () => {
       expect(SafeUint.div(a, b)).toBe(2);
+
       expect(SafeUint.div(asSafeUint(7), asSafeUint(3))).toBe(2);
+
       expect(SafeUint.div(b, a)).toBe(0); // floor(2/5) = 0
     });
 
@@ -142,6 +183,7 @@ describe('SafeUint test', () => {
       const result = SafeUint.pow(asSafeUint(1000), asSafeUint(10));
 
       expect(result).toBe(Number.MAX_SAFE_INTEGER); // clamped to max
+
       expect(SafeUint.pow(asSafeUint(2), asSafeUint(3))).toBe(8);
     });
   });
@@ -149,15 +191,20 @@ describe('SafeUint test', () => {
   describe('random', () => {
     test('generates safe unsigned integers within specified range', () => {
       const min = 0;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = SafeUint.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(SafeUint.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).toBeGreaterThanOrEqual(0);
       }
     });
@@ -167,6 +214,7 @@ describe('SafeUint test', () => {
         const result = SafeUint.random(0, 30);
 
         expect(result).toBeGreaterThanOrEqual(0);
+
         expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
       }
     });

package/src/number/branded-types/uint.mts

@@ -36,7 +36,9 @@ const {
  *
  * ```ts
  * assert.ok(isUint(4));
+ *
  * assert.notOk(isUint(-1));
+ *
  * assert.ok(Uint.is(0));
  * ```
  *
@@ -54,6 +56,7 @@ export const isUint = is;
  * const branded = asUint(12);
  *
  * assert(branded === 12);
+ *
  * assert.ok(Uint.is(branded));
  * ```
  *
@@ -78,7 +81,9 @@ export const Uint = {
    *
    * ```ts
    * assert.ok(isUint(4));
+   *
    * assert.notOk(isUint(-1));
+   *
    * assert.ok(Uint.is(0));
    * ```
    *
@@ -136,9 +141,11 @@ export const Uint = {
    *
    * ```ts
    * const clampedNegative = Uint.clamp(-5);
+   *
    * const clampedPositive = Uint.clamp(42);
    *
    * assert(clampedNegative === 0);
+   *
    * assert(clampedPositive === 42);
    * ```
    *
@@ -154,10 +161,13 @@ export const Uint = {
    *
    * ```ts
    * const min = asUint(0);
+   *
    * const max = asUint(3);
+   *
    * const randomValue = Uint.random(min, max);
    *
    * assert.ok(Uint.is(randomValue));
+   *
    * assert.ok(randomValue >= 0 && randomValue <= 3);
    * ```
    *
@@ -172,7 +182,9 @@ export const Uint = {
    *
    * ```ts
    * const base = asUint(2);
+   *
    * const exponent = asUint(5);
+   *
    * const power = Uint.pow(base, exponent);
    *
    * assert(power === 32);

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

@@ -6,29 +6,41 @@ describe('Uint test', () => {
   describe(asUint, () => {
     test('accepts valid unsigned integers', () => {
       expect(() => asUint(0)).not.toThrow();
+
       expect(() => asUint(1)).not.toThrow();
+
       expect(() => asUint(42)).not.toThrow();
+
       expect(() => asUint(100)).not.toThrow();
+
       expect(() => asUint(Number.MAX_SAFE_INTEGER)).not.toThrow();
     });
 
     test('rejects negative integers', () => {
       expect(() => asUint(-1)).toThrow(TypeError);
+
       expect(() => asUint(-42)).toThrow(TypeError);
+
       expect(() => asUint(Number.MIN_SAFE_INTEGER)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asUint(Number.NaN)).toThrow(TypeError);
+
       expect(() => asUint(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asUint(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asUint(1.2)).toThrow(TypeError);
+
       expect(() => asUint(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asUint(5)).toBe(5);
+
       expect(asUint(0)).toBe(0);
+
       expect(asUint(10)).toBe(10);
     });
 
@@ -49,23 +61,33 @@ describe('Uint test', () => {
   describe(isUint, () => {
     test('correctly identifies unsigned integers', () => {
       expect(isUint(0)).toBe(true);
+
       expect(isUint(1)).toBe(true);
+
       expect(isUint(42)).toBe(true);
+
       expect(isUint(100)).toBe(true);
+
       expect(isUint(Number.MAX_SAFE_INTEGER)).toBe(true);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isUint(-1)).toBe(false);
+
       expect(isUint(-42)).toBe(false);
+
       expect(isUint(Number.MIN_SAFE_INTEGER)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isUint(Number.NaN)).toBe(false);
+
       expect(isUint(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isUint(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isUint(1.2)).toBe(false);
+
       expect(isUint(-3.4)).toBe(false);
     });
   });
@@ -73,7 +95,9 @@ describe('Uint test', () => {
   describe('Uint.is', () => {
     test('same as isUint function', () => {
       expect(Uint.is(5)).toBe(isUint(5));
+
       expect(Uint.is(-1)).toBe(isUint(-1));
+
       expect(Uint.is(0)).toBe(isUint(0));
     });
   });
@@ -86,41 +110,54 @@ describe('Uint test', () => {
 
   describe('mathematical operations', () => {
     const a = asUint(5);
+
     const b = asUint(2);
+
     const c = asUint(0);
 
     test('min and max', () => {
       expect(Uint.min(a, b)).toBe(2);
+
       expect(Uint.max(a, b)).toBe(5);
+
       expect(Uint.min(a, c)).toBe(0);
+
       expect(Uint.max(a, c)).toBe(5);
     });
 
     test('add (never goes below 0)', () => {
       expect(Uint.add(a, b)).toBe(7);
+
       expect(Uint.add(a, c)).toBe(5);
     });
 
     test('sub (never goes below 0)', () => {
       expect(Uint.sub(a, b)).toBe(3);
+
       expect(Uint.sub(b, a)).toBe(0); // clamped to 0
+
       expect(Uint.sub(c, a)).toBe(0); // clamped to 0
     });
 
     test('mul (never goes below 0)', () => {
       expect(Uint.mul(a, b)).toBe(10);
+
       expect(Uint.mul(a, c)).toBe(0);
     });
 
     test('div (floor division, never goes below 0)', () => {
       expect(Uint.div(a, b)).toBe(2);
+
       expect(Uint.div(asUint(7), asUint(3))).toBe(2);
+
       expect(Uint.div(b, a)).toBe(0); // floor(2/5) = 0
     });
 
     test('pow (never goes below 0)', () => {
       expect(Uint.pow(asUint(2), asUint(3))).toBe(8);
+
       expect(Uint.pow(asUint(3), asUint(2))).toBe(9);
+
       expect(Uint.pow(asUint(5), asUint(0))).toBe(1);
     });
   });
@@ -128,15 +165,20 @@ describe('Uint test', () => {
   describe('random', () => {
     test('generates unsigned integers within specified range', () => {
       const min = 0;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = Uint.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(Uint.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).toBeGreaterThanOrEqual(0);
       }
     });
@@ -146,6 +188,7 @@ describe('Uint test', () => {
         const result = Uint.random(0, 30);
 
         expect(result).toBeGreaterThanOrEqual(0);
+
         expect(result).toBeLessThanOrEqual(30);
       }
     });

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

@@ -7,32 +7,43 @@ describe('Uint16 test', () => {
   describe(asUint16, () => {
     test('accepts valid uint16 values', () => {
       expect(() => asUint16(0)).not.toThrow();
+
       expect(() => asUint16(1)).not.toThrow();
+
       expect(() => asUint16(65_535)).not.toThrow(); // 2^16 - 1
+
       expect(() => asUint16(32_768)).not.toThrow(); // 2^15
     });
 
     test('rejects values outside uint16 range', () => {
       expect(() => asUint16(65_536)).toThrow(TypeError); // 2^16
+
       expect(() => asUint16(100_000)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asUint16(-1)).toThrow(TypeError);
+
       expect(() => asUint16(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asUint16(Number.NaN)).toThrow(TypeError);
+
       expect(() => asUint16(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asUint16(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asUint16(1.2)).toThrow(TypeError);
+
       expect(() => asUint16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asUint16(5)).toBe(5);
+
       expect(asUint16(0)).toBe(0);
+
       expect(asUint16(65_535)).toBe(65_535);
     });
 
@@ -55,26 +66,35 @@ describe('Uint16 test', () => {
   describe(isUint16, () => {
     test('correctly identifies uint16 values', () => {
       expect(isUint16(0)).toBe(true);
+
       expect(isUint16(1)).toBe(true);
+
       expect(isUint16(65_535)).toBe(true);
+
       expect(isUint16(32_768)).toBe(true);
     });
 
     test('correctly identifies values outside uint16 range', () => {
       expect(isUint16(65_536)).toBe(false);
+
       expect(isUint16(100_000)).toBe(false);
     });
 
     test('correctly identifies negative integers', () => {
       expect(isUint16(-1)).toBe(false);
+
       expect(isUint16(-42)).toBe(false);
     });
 
     test('correctly identifies non-integers', () => {
       expect(isUint16(Number.NaN)).toBe(false);
+
       expect(isUint16(Number.POSITIVE_INFINITY)).toBe(false);
+
       expect(isUint16(Number.NEGATIVE_INFINITY)).toBe(false);
+
       expect(isUint16(1.2)).toBe(false);
+
       expect(isUint16(-3.4)).toBe(false);
     });
   });
@@ -82,7 +102,9 @@ describe('Uint16 test', () => {
   describe('Uint16.is', () => {
     test('same as isUint16 function', () => {
       expect(Uint16.is(5)).toBe(isUint16(5));
+
       expect(Uint16.is(65_536)).toBe(isUint16(65_536));
+
       expect(Uint16.is(-1)).toBe(isUint16(-1));
     });
   });
@@ -90,19 +112,25 @@ describe('Uint16 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(Uint16.MIN_VALUE).toBe(0);
+
       expect(Uint16.MAX_VALUE).toBe(65_535);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asUint16(100);
+
     const b = asUint16(50);
+
     const c = asUint16(0);
 
     test('min and max', () => {
       expect(Uint16.min(a, b)).toBe(50);
+
       expect(Uint16.max(a, b)).toBe(100);
+
       expect(Uint16.min(a, c)).toBe(0);
+
       expect(Uint16.max(a, c)).toBe(100);
     });
 
@@ -110,12 +138,15 @@ describe('Uint16 test', () => {
       const result = Uint16.add(asUint16(65_000), asUint16(1000));
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(Uint16.add(a, b)).toBe(150);
     });
 
     test('sub (never goes below 0)', () => {
       expect(Uint16.sub(a, b)).toBe(50);
+
       expect(Uint16.sub(b, a)).toBe(0); // clamped to 0
+
       expect(Uint16.sub(c, a)).toBe(0); // clamped to 0
     });
 
@@ -123,12 +154,15 @@ describe('Uint16 test', () => {
       const result = Uint16.mul(asUint16(1000), asUint16(100));
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(Uint16.mul(asUint16(10), asUint16(5))).toBe(50);
     });
 
     test('div (floor division, never goes below 0)', () => {
       expect(Uint16.div(a, asNonZeroUint16(50))).toBe(2);
+
       expect(Uint16.div(asUint16(7), asNonZeroUint16(3))).toBe(2);
+
       expect(Uint16.div(asUint16(50), asNonZeroUint16(100))).toBe(0); // floor(50/100) = 0
     });
 
@@ -136,6 +170,7 @@ describe('Uint16 test', () => {
       const result = Uint16.pow(asUint16(256), asUint16(3));
 
       expect(result).toBe(65_535); // clamped to max
+
       expect(Uint16.pow(asUint16(2), asUint16(3))).toBe(8);
     });
   });
@@ -143,15 +178,20 @@ describe('Uint16 test', () => {
   describe('random', () => {
     test('generates uint16 values within specified range', () => {
       const min = 0;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = Uint16.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
+
         expect(Uint16.is(result)).toBe(true);
+
         expect(Number.isInteger(result)).toBe(true);
+
         expect(result).toBeGreaterThanOrEqual(0);
       }
     });
@@ -161,6 +201,7 @@ describe('Uint16 test', () => {
         const result = Uint16.random(0, 30);
 
         expect(result).toBeGreaterThanOrEqual(0);
+
         expect(result).toBeLessThanOrEqual(65_535);
       }
     });