ts-data-forge 5.0.1 → 5.1.1

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

@@ -35,9 +35,11 @@ const {
  * @example
  *
  * ```ts
- * assert.ok(isUint(4));
- * assert.notOk(isUint(-1));
- * assert.ok(Uint.is(0));
+ * assert.isTrue(isUint(4));
+ *
+ * assert.isFalse(isUint(-1));
+ *
+ * assert.isTrue(Uint.is(0));
  * ```
  *
  * @param value The value to check.
@@ -53,8 +55,9 @@ export const isUint = is;
  * ```ts
  * const branded = asUint(12);
  *
- * assert(branded === 12);
- * assert.ok(Uint.is(branded));
+ * assert.isTrue(branded === 12);
+ *
+ * assert.isTrue(Uint.is(branded));
  * ```
  *
  * @param value The value to cast.
@@ -77,9 +80,11 @@ export const Uint = {
    * @example
    *
    * ```ts
-   * assert.ok(isUint(4));
-   * assert.notOk(isUint(-1));
-   * assert.ok(Uint.is(0));
+   * assert.isTrue(isUint(4));
+   *
+   * assert.isFalse(isUint(-1));
+   *
+   * assert.isTrue(Uint.is(0));
    * ```
    *
    * @param value The value to check.
@@ -103,7 +108,7 @@ export const Uint = {
    * ```ts
    * const smallest = Uint.min(asUint(7), asUint(3));
    *
-   * assert(smallest === 3);
+   * assert.isTrue(smallest === 3);
    * ```
    *
    * @param a The first Uint.
@@ -120,7 +125,7 @@ export const Uint = {
    * ```ts
    * const largest = Uint.max(asUint(7), asUint(3));
    *
-   * assert(largest === 7);
+   * assert.isTrue(largest === 7);
    * ```
    *
    * @param a The first Uint.
@@ -136,10 +141,12 @@ export const Uint = {
    *
    * ```ts
    * const clampedNegative = Uint.clamp(-5);
+   *
    * const clampedPositive = Uint.clamp(42);
    *
-   * assert(clampedNegative === 0);
-   * assert(clampedPositive === 42);
+   * assert.isTrue(clampedNegative === 0);
+   *
+   * assert.isTrue(clampedPositive === 42);
    * ```
    *
    * @param value The number to clamp.
@@ -154,11 +161,14 @@ 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);
+   * assert.isTrue(Uint.is(randomValue));
+   *
+   * assert.isTrue(randomValue >= 0 && randomValue <= 3);
    * ```
    *
    * @returns A random non-negative integer as a Uint.
@@ -172,10 +182,12 @@ export const Uint = {
    *
    * ```ts
    * const base = asUint(2);
+   *
    * const exponent = asUint(5);
+   *
    * const power = Uint.pow(base, exponent);
    *
-   * assert(power === 32);
+   * assert.isTrue(power === 32);
    * ```
    *
    * @param a The base Uint.
@@ -192,7 +204,7 @@ export const Uint = {
    * ```ts
    * const sum = Uint.add(asUint(5), asUint(8));
    *
-   * assert(sum === 13);
+   * assert.isTrue(sum === 13);
    * ```
    *
    * @param a The first Uint.
@@ -209,7 +221,7 @@ export const Uint = {
    * ```ts
    * const difference = Uint.sub(asUint(5), asUint(8));
    *
-   * assert(difference === 0);
+   * assert.isTrue(difference === 0);
    * ```
    *
    * @param a The minuend Uint.
@@ -226,7 +238,7 @@ export const Uint = {
    * ```ts
    * const product = Uint.mul(asUint(7), asUint(6));
    *
-   * assert(product === 42);
+   * assert.isTrue(product === 42);
    * ```
    *
    * @param a The first Uint.
@@ -243,7 +255,7 @@ export const Uint = {
    * ```ts
    * const quotient = Uint.div(asUint(10), asUint(4));
    *
-   * assert(quotient === 2);
+   * assert.isTrue(quotient === 2);
    * ```
    *
    * @param a The dividend Uint.

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);
     });
 
@@ -48,32 +60,44 @@ 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);
+      assert.isTrue(isUint(0));
+
+      assert.isTrue(isUint(1));
+
+      assert.isTrue(isUint(42));
+
+      assert.isTrue(isUint(100));
+
+      assert.isTrue(isUint(Number.MAX_SAFE_INTEGER));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isUint(-1)).toBe(false);
-      expect(isUint(-42)).toBe(false);
-      expect(isUint(Number.MIN_SAFE_INTEGER)).toBe(false);
+      assert.isFalse(isUint(-1));
+
+      assert.isFalse(isUint(-42));
+
+      assert.isFalse(isUint(Number.MIN_SAFE_INTEGER));
     });
 
     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);
+      assert.isFalse(isUint(Number.NaN));
+
+      assert.isFalse(isUint(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isUint(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isUint(1.2));
+
+      assert.isFalse(isUint(-3.4));
     });
   });
 
   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);
+
+        assert.isTrue(Uint.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         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);
     });
 
@@ -54,35 +65,46 @@ 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);
+      assert.isTrue(isUint16(0));
+
+      assert.isTrue(isUint16(1));
+
+      assert.isTrue(isUint16(65_535));
+
+      assert.isTrue(isUint16(32_768));
     });
 
     test('correctly identifies values outside uint16 range', () => {
-      expect(isUint16(65_536)).toBe(false);
-      expect(isUint16(100_000)).toBe(false);
+      assert.isFalse(isUint16(65_536));
+
+      assert.isFalse(isUint16(100_000));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isUint16(-1)).toBe(false);
-      expect(isUint16(-42)).toBe(false);
+      assert.isFalse(isUint16(-1));
+
+      assert.isFalse(isUint16(-42));
     });
 
     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);
+      assert.isFalse(isUint16(Number.NaN));
+
+      assert.isFalse(isUint16(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isUint16(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isUint16(1.2));
+
+      assert.isFalse(isUint16(-3.4));
     });
   });
 
   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);
+
+        assert.isTrue(Uint16.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         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);
       }
     });