ts-data-forge 5.0.1 → 5.1.1

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);
     });
 
@@ -62,35 +73,46 @@ 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);
+      assert.isTrue(isPositiveFiniteNumber(1));
+
+      assert.isTrue(isPositiveFiniteNumber(3.14));
+
+      assert.isTrue(isPositiveFiniteNumber(0.5));
+
+      assert.isTrue(isPositiveFiniteNumber(Number.MIN_VALUE));
+
+      assert.isTrue(isPositiveFiniteNumber(Number.MAX_VALUE));
     });
 
     test('correctly identifies zero', () => {
-      expect(isPositiveFiniteNumber(0)).toBe(false);
-      expect(isPositiveFiniteNumber(-0)).toBe(false);
+      assert.isFalse(isPositiveFiniteNumber(0));
+
+      assert.isFalse(isPositiveFiniteNumber(-0));
     });
 
     test('correctly identifies negative numbers', () => {
-      expect(isPositiveFiniteNumber(-1)).toBe(false);
-      expect(isPositiveFiniteNumber(-0.1)).toBe(false);
-      expect(isPositiveFiniteNumber(-Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(isPositiveFiniteNumber(-1));
+
+      assert.isFalse(isPositiveFiniteNumber(-0.1));
+
+      assert.isFalse(isPositiveFiniteNumber(-Number.MAX_VALUE));
     });
 
     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);
+      assert.isFalse(isPositiveFiniteNumber(Number.NaN));
+
+      assert.isFalse(isPositiveFiniteNumber(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isPositiveFiniteNumber(Number.NEGATIVE_INFINITY));
     });
   });
 
   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);
+
+        assert.isTrue(PositiveFiniteNumber.is(result));
+
         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

@@ -38,9 +38,11 @@ const {
  * @example
  *
  * ```ts
- * assert.ok(isPositiveInt(5));
- * assert.notOk(isPositiveInt(0));
- * assert.ok(PositiveInt.is(10));
+ * assert.isTrue(isPositiveInt(5));
+ *
+ * assert.isFalse(isPositiveInt(0));
+ *
+ * assert.isTrue(PositiveInt.is(10));
  * ```
  *
  * @param value - The value to check
@@ -60,8 +62,9 @@ export const isPositiveInt = is;
  * ```ts
  * const branded = asPositiveInt(7);
  *
- * assert(branded === 7);
- * assert.ok(PositiveInt.is(branded));
+ * assert.isTrue(branded === 7);
+ *
+ * assert.isTrue(PositiveInt.is(branded));
  * ```
  *
  * @param value - The value to cast
@@ -93,9 +96,11 @@ export const PositiveInt = {
    * @example
    *
    * ```ts
-   * assert.ok(isPositiveInt(5));
-   * assert.notOk(isPositiveInt(0));
-   * assert.ok(PositiveInt.is(10));
+   * assert.isTrue(isPositiveInt(5));
+   *
+   * assert.isFalse(isPositiveInt(0));
+   *
+   * assert.isTrue(PositiveInt.is(10));
    * ```
    *
    * @param value - The value to check
@@ -126,7 +131,7 @@ export const PositiveInt = {
    *   asPositiveInt(12),
    * );
    *
-   * assert(smallest === 3);
+   * assert.isTrue(smallest === 3);
    * ```
    *
    * @param values - The positive integers to compare (at least one required)
@@ -146,7 +151,7 @@ export const PositiveInt = {
    *   asPositiveInt(12),
    * );
    *
-   * assert(largest === 12);
+   * assert.isTrue(largest === 12);
    * ```
    *
    * @param values - The positive integers to compare (at least one required)
@@ -164,10 +169,12 @@ export const PositiveInt = {
    *
    * ```ts
    * const belowRange = PositiveInt.clamp(0);
+   *
    * const withinRange = PositiveInt.clamp(10);
    *
-   * assert(belowRange === 1);
-   * assert(withinRange === 10);
+   * assert.isTrue(belowRange === 1);
+   *
+   * assert.isTrue(withinRange === 10);
    * ```
    *
    * @param value - The number to clamp
@@ -185,11 +192,14 @@ 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);
+   * assert.isTrue(PositiveInt.is(randomValue));
+   *
+   * assert.isTrue(randomValue >= 3 && randomValue <= 6);
    * ```
    *
    * @param min - The minimum value (inclusive, must be >= 1)
@@ -206,10 +216,12 @@ export const PositiveInt = {
    *
    * ```ts
    * const base = asPositiveInt(2);
+   *
    * const exponent = asPositiveInt(4);
+   *
    * const power = PositiveInt.pow(base, exponent);
    *
-   * assert(power === 16);
+   * assert.isTrue(power === 16);
    * ```
    *
    * @param a - The base positive integer
@@ -226,7 +238,7 @@ export const PositiveInt = {
    * ```ts
    * const sum = PositiveInt.add(asPositiveInt(4), asPositiveInt(5));
    *
-   * assert(sum === 9);
+   * assert.isTrue(sum === 9);
    * ```
    *
    * @param a - First positive integer
@@ -246,7 +258,7 @@ export const PositiveInt = {
    * ```ts
    * const difference = PositiveInt.sub(asPositiveInt(5), asPositiveInt(7));
    *
-   * assert(difference === 1);
+   * assert.isTrue(difference === 1);
    * ```
    *
    * @param a - The minuend (positive integer)
@@ -263,7 +275,7 @@ export const PositiveInt = {
    * ```ts
    * const product = PositiveInt.mul(asPositiveInt(3), asPositiveInt(7));
    *
-   * assert(product === 21);
+   * assert.isTrue(product === 21);
    * ```
    *
    * @param a - First positive integer
@@ -284,10 +296,12 @@ 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);
+   * assert.isTrue(quotient === 4);
+   *
+   * assert.isTrue(clamped === 1);
    * ```
    *
    * @param a - The dividend (positive integer)

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);
     });
 
@@ -57,37 +70,50 @@ 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);
+      assert.isTrue(isPositiveInt(1));
+
+      assert.isTrue(isPositiveInt(2));
+
+      assert.isTrue(isPositiveInt(42));
+
+      assert.isTrue(isPositiveInt(100));
+
+      assert.isTrue(isPositiveInt(Number.MAX_SAFE_INTEGER));
     });
 
     test('correctly identifies zero', () => {
-      expect(isPositiveInt(0)).toBe(false);
-      expect(isPositiveInt(-0)).toBe(false);
+      assert.isFalse(isPositiveInt(0));
+
+      assert.isFalse(isPositiveInt(-0));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isPositiveInt(-1)).toBe(false);
-      expect(isPositiveInt(-42)).toBe(false);
-      expect(isPositiveInt(Number.MIN_SAFE_INTEGER)).toBe(false);
+      assert.isFalse(isPositiveInt(-1));
+
+      assert.isFalse(isPositiveInt(-42));
+
+      assert.isFalse(isPositiveInt(Number.MIN_SAFE_INTEGER));
     });
 
     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);
+      assert.isFalse(isPositiveInt(Number.NaN));
+
+      assert.isFalse(isPositiveInt(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isPositiveInt(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isPositiveInt(1.2));
+
+      assert.isFalse(isPositiveInt(-3.4));
     });
   });
 
   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);
+
+        assert.isTrue(PositiveInt.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         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);
       }
     });