ts-data-forge 5.0.1 → 5.1.1

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

@@ -10,7 +10,9 @@ describe('PositiveInt16 test', () => {
   describe(asPositiveInt16, () => {
     test('accepts valid positive int16 values', () => {
       expect(() => asPositiveInt16(1)).not.toThrow();
+
       expect(() => asPositiveInt16(1000)).not.toThrow();
+
       expect(() => asPositiveInt16(32_767)).not.toThrow(); // 2^15 - 1
     });
 
@@ -20,29 +22,37 @@ describe('PositiveInt16 test', () => {
 
     test('rejects values outside int16 range', () => {
       expect(() => asPositiveInt16(32_768)).toThrow(TypeError); // 2^15
+
       expect(() => asPositiveInt16(65_536)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asPositiveInt16(-1)).toThrow(TypeError);
+
       expect(() => asPositiveInt16(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asPositiveInt16(Number.NaN)).toThrow(TypeError);
+
       expect(() => asPositiveInt16(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveInt16(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveInt16(1.2)).toThrow(TypeError);
+
       expect(() => asPositiveInt16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asPositiveInt16(5)).toBe(5);
+
       expect(asPositiveInt16(1)).toBe(1);
+
       expect(asPositiveInt16(32_767)).toBe(32_767);
     });
 
@@ -69,38 +79,48 @@ describe('PositiveInt16 test', () => {
 
   describe(isPositiveInt16, () => {
     test('correctly identifies positive int16 values', () => {
-      expect(isPositiveInt16(1)).toBe(true);
-      expect(isPositiveInt16(1000)).toBe(true);
-      expect(isPositiveInt16(32_767)).toBe(true);
+      assert.isTrue(isPositiveInt16(1));
+
+      assert.isTrue(isPositiveInt16(1000));
+
+      assert.isTrue(isPositiveInt16(32_767));
     });
 
     test('correctly identifies zero', () => {
-      expect(isPositiveInt16(0)).toBe(false);
+      assert.isFalse(isPositiveInt16(0));
     });
 
     test('correctly identifies values outside int16 range', () => {
-      expect(isPositiveInt16(32_768)).toBe(false);
-      expect(isPositiveInt16(65_536)).toBe(false);
+      assert.isFalse(isPositiveInt16(32_768));
+
+      assert.isFalse(isPositiveInt16(65_536));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isPositiveInt16(-1)).toBe(false);
-      expect(isPositiveInt16(-42)).toBe(false);
+      assert.isFalse(isPositiveInt16(-1));
+
+      assert.isFalse(isPositiveInt16(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isPositiveInt16(Number.NaN)).toBe(false);
-      expect(isPositiveInt16(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isPositiveInt16(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isPositiveInt16(1.2)).toBe(false);
-      expect(isPositiveInt16(-3.4)).toBe(false);
+      assert.isFalse(isPositiveInt16(Number.NaN));
+
+      assert.isFalse(isPositiveInt16(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isPositiveInt16(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isPositiveInt16(1.2));
+
+      assert.isFalse(isPositiveInt16(-3.4));
     });
   });
 
   describe('PositiveInt16.is', () => {
     test('same as isPositiveInt16 function', () => {
       expect(PositiveInt16.is(5)).toBe(isPositiveInt16(5));
+
       expect(PositiveInt16.is(0)).toBe(isPositiveInt16(0));
+
       expect(PositiveInt16.is(-1)).toBe(isPositiveInt16(-1));
     });
   });
@@ -108,16 +128,19 @@ describe('PositiveInt16 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(PositiveInt16.MIN_VALUE).toBe(1);
+
       expect(PositiveInt16.MAX_VALUE).toBe(32_767);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asPositiveInt16(100);
+
     const b = asPositiveInt16(50);
 
     test('min and max', () => {
       expect(PositiveInt16.min(a, b)).toBe(50);
+
       expect(PositiveInt16.max(a, b)).toBe(100);
     });
 
@@ -128,11 +151,13 @@ describe('PositiveInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(PositiveInt16.add(a, b)).toBe(150);
     });
 
     test('sub (never goes below 1)', () => {
       expect(PositiveInt16.sub(a, b)).toBe(50);
+
       expect(PositiveInt16.sub(b, a)).toBe(1); // clamped to 1
     });
 
@@ -143,6 +168,7 @@ describe('PositiveInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(PositiveInt16.mul(asPositiveInt16(10), asPositiveInt16(5))).toBe(
         50,
       );
@@ -150,7 +176,9 @@ describe('PositiveInt16 test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(PositiveInt16.div(a, asPositiveInt16(50))).toBe(2);
+
       expect(PositiveInt16.div(asPositiveInt16(7), asPositiveInt16(3))).toBe(2);
+
       expect(PositiveInt16.div(asPositiveInt16(50), asPositiveInt16(100))).toBe(
         1,
       ); // floor(50/100) = 0, clamped to 1
@@ -163,6 +191,7 @@ describe('PositiveInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(PositiveInt16.pow(asPositiveInt16(2), asPositiveInt16(3))).toBe(8);
     });
   });
@@ -170,15 +199,20 @@ describe('PositiveInt16 test', () => {
   describe('random', () => {
     test('generates positive int16 values within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = PositiveInt16.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(PositiveInt16.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(PositiveInt16.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).toBeGreaterThan(0);
       }
     });
@@ -188,6 +222,7 @@ describe('PositiveInt16 test', () => {
         const result = PositiveInt16.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(32_767);
       }
     });

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

@@ -10,7 +10,9 @@ describe('PositiveInt32 test', () => {
   describe(asPositiveInt32, () => {
     test('accepts valid positive int32 values', () => {
       expect(() => asPositiveInt32(1)).not.toThrow();
+
       expect(() => asPositiveInt32(1000)).not.toThrow();
+
       expect(() => asPositiveInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
     });
 
@@ -20,29 +22,37 @@ describe('PositiveInt32 test', () => {
 
     test('rejects values outside int32 range', () => {
       expect(() => asPositiveInt32(2_147_483_648)).toThrow(TypeError); // 2^31
+
       expect(() => asPositiveInt32(4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects negative integers', () => {
       expect(() => asPositiveInt32(-1)).toThrow(TypeError);
+
       expect(() => asPositiveInt32(-42)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asPositiveInt32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asPositiveInt32(Number.POSITIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveInt32(Number.NEGATIVE_INFINITY)).toThrow(
         TypeError,
       );
+
       expect(() => asPositiveInt32(1.2)).toThrow(TypeError);
+
       expect(() => asPositiveInt32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asPositiveInt32(5)).toBe(5);
+
       expect(asPositiveInt32(1)).toBe(1);
+
       expect(asPositiveInt32(2_147_483_647)).toBe(2_147_483_647);
     });
 
@@ -69,38 +79,48 @@ describe('PositiveInt32 test', () => {
 
   describe(isPositiveInt32, () => {
     test('correctly identifies positive int32 values', () => {
-      expect(isPositiveInt32(1)).toBe(true);
-      expect(isPositiveInt32(1000)).toBe(true);
-      expect(isPositiveInt32(2_147_483_647)).toBe(true);
+      assert.isTrue(isPositiveInt32(1));
+
+      assert.isTrue(isPositiveInt32(1000));
+
+      assert.isTrue(isPositiveInt32(2_147_483_647));
     });
 
     test('correctly identifies zero', () => {
-      expect(isPositiveInt32(0)).toBe(false);
+      assert.isFalse(isPositiveInt32(0));
     });
 
     test('correctly identifies values outside int32 range', () => {
-      expect(isPositiveInt32(2_147_483_648)).toBe(false);
-      expect(isPositiveInt32(4_294_967_296)).toBe(false);
+      assert.isFalse(isPositiveInt32(2_147_483_648));
+
+      assert.isFalse(isPositiveInt32(4_294_967_296));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isPositiveInt32(-1)).toBe(false);
-      expect(isPositiveInt32(-42)).toBe(false);
+      assert.isFalse(isPositiveInt32(-1));
+
+      assert.isFalse(isPositiveInt32(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isPositiveInt32(Number.NaN)).toBe(false);
-      expect(isPositiveInt32(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isPositiveInt32(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isPositiveInt32(1.2)).toBe(false);
-      expect(isPositiveInt32(-3.4)).toBe(false);
+      assert.isFalse(isPositiveInt32(Number.NaN));
+
+      assert.isFalse(isPositiveInt32(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isPositiveInt32(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isPositiveInt32(1.2));
+
+      assert.isFalse(isPositiveInt32(-3.4));
     });
   });
 
   describe('PositiveInt32.is', () => {
     test('same as isPositiveInt32 function', () => {
       expect(PositiveInt32.is(5)).toBe(isPositiveInt32(5));
+
       expect(PositiveInt32.is(0)).toBe(isPositiveInt32(0));
+
       expect(PositiveInt32.is(-1)).toBe(isPositiveInt32(-1));
     });
   });
@@ -108,16 +128,19 @@ describe('PositiveInt32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(PositiveInt32.MIN_VALUE).toBe(1);
+
       expect(PositiveInt32.MAX_VALUE).toBe(2_147_483_647);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asPositiveInt32(1_000_000);
+
     const b = asPositiveInt32(500_000);
 
     test('min and max', () => {
       expect(PositiveInt32.min(a, b)).toBe(500_000);
+
       expect(PositiveInt32.max(a, b)).toBe(1_000_000);
     });
 
@@ -128,11 +151,13 @@ describe('PositiveInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(PositiveInt32.add(a, b)).toBe(1_500_000);
     });
 
     test('sub (never goes below 1)', () => {
       expect(PositiveInt32.sub(a, b)).toBe(500_000);
+
       expect(PositiveInt32.sub(b, a)).toBe(1); // clamped to 1
     });
 
@@ -143,6 +168,7 @@ describe('PositiveInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(PositiveInt32.mul(asPositiveInt32(1000), asPositiveInt32(5))).toBe(
         5000,
       );
@@ -150,7 +176,9 @@ describe('PositiveInt32 test', () => {
 
     test('div (floor division, never goes below 1)', () => {
       expect(PositiveInt32.div(a, asPositiveInt32(500_000))).toBe(2);
+
       expect(PositiveInt32.div(asPositiveInt32(7), asPositiveInt32(3))).toBe(2);
+
       expect(
         PositiveInt32.div(asPositiveInt32(500_000), asPositiveInt32(1_000_000)),
       ).toBe(1); // floor(500000/1000000) = 0, clamped to 1
@@ -163,6 +191,7 @@ describe('PositiveInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(PositiveInt32.pow(asPositiveInt32(2), asPositiveInt32(3))).toBe(8);
     });
   });
@@ -170,15 +199,20 @@ describe('PositiveInt32 test', () => {
   describe('random', () => {
     test('generates positive int32 values within specified range', () => {
       const min = 1;
+
       const max = 20;
 
       for (const _ of range(10)) {
         const result = PositiveInt32.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(PositiveInt32.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(PositiveInt32.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).toBeGreaterThan(0);
       }
     });
@@ -188,6 +222,7 @@ describe('PositiveInt32 test', () => {
         const result = PositiveInt32.random(1, 30);
 
         expect(result).toBeGreaterThanOrEqual(1);
+
         expect(result).toBeLessThanOrEqual(2_147_483_647);
       }
     });

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

@@ -26,7 +26,7 @@ const {
 >({
   integerOrSafeInteger: 'SafeInteger',
   MIN_VALUE: 1,
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-max-safe-integer
   MAX_VALUE: Number.MAX_SAFE_INTEGER as SafeUint,
   typeNameInMessage,
 } as const);
@@ -38,10 +38,13 @@ const {
  * @example
  *
  * ```ts
- * assert.ok(isPositiveSafeInt(1));
- * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
- * assert.notOk(isPositiveSafeInt(0));
- * assert.ok(PositiveSafeInt.is(42));
+ * assert.isTrue(isPositiveSafeInt(1));
+ *
+ * assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+ *
+ * assert.isFalse(isPositiveSafeInt(0));
+ *
+ * assert.isTrue(PositiveSafeInt.is(42));
  * ```
  *
  * @param value The value to check.
@@ -57,8 +60,9 @@ export const isPositiveSafeInt = is;
  * ```ts
  * const branded = asPositiveSafeInt(128);
  *
- * assert(branded === 128);
- * assert.ok(PositiveSafeInt.is(branded));
+ * assert.isTrue(branded === 128);
+ *
+ * assert.isTrue(PositiveSafeInt.is(branded));
  * ```
  *
  * @param value The value to cast.
@@ -83,10 +87,13 @@ export const PositiveSafeInt = {
    * @example
    *
    * ```ts
-   * assert.ok(isPositiveSafeInt(1));
-   * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
-   * assert.notOk(isPositiveSafeInt(0));
-   * assert.ok(PositiveSafeInt.is(42));
+   * assert.isTrue(isPositiveSafeInt(1));
+   *
+   * assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+   *
+   * assert.isFalse(isPositiveSafeInt(0));
+   *
+   * assert.isTrue(PositiveSafeInt.is(42));
    * ```
    *
    * @param value The value to check.
@@ -120,7 +127,7 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(5),
    * );
    *
-   * assert(smallest === 5);
+   * assert.isTrue(smallest === 5);
    * ```
    *
    * @param a The first PositiveSafeInt.
@@ -140,7 +147,7 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(5),
    * );
    *
-   * assert(largest === 10);
+   * assert.isTrue(largest === 10);
    * ```
    *
    * @param a The first PositiveSafeInt.
@@ -156,12 +163,16 @@ export const PositiveSafeInt = {
    *
    * ```ts
    * const belowRange = PositiveSafeInt.clamp(0);
+   *
    * const withinRange = PositiveSafeInt.clamp(123);
+   *
    * const aboveRange = PositiveSafeInt.clamp(Number.MAX_SAFE_INTEGER + 10);
    *
-   * assert(belowRange === 1);
-   * assert(withinRange === 123);
-   * assert(aboveRange === Number.MAX_SAFE_INTEGER);
+   * assert.isTrue(belowRange === 1);
+   *
+   * assert.isTrue(withinRange === 123);
+   *
+   * assert.isTrue(aboveRange === Number.MAX_SAFE_INTEGER);
    * ```
    *
    * @param value The number to clamp.
@@ -176,11 +187,14 @@ export const PositiveSafeInt = {
    *
    * ```ts
    * const min = asPositiveSafeInt(1);
+   *
    * const max = asPositiveSafeInt(6);
+   *
    * const randomValue = PositiveSafeInt.random(min, max);
    *
-   * assert.ok(PositiveSafeInt.is(randomValue));
-   * assert.ok(randomValue >= 1 && randomValue <= 6);
+   * assert.isTrue(PositiveSafeInt.is(randomValue));
+   *
+   * assert.isTrue(randomValue >= 1 && randomValue <= 6);
    * ```
    *
    * @returns A random PositiveSafeInt between 1 and MAX_SAFE_INTEGER.
@@ -194,10 +208,12 @@ export const PositiveSafeInt = {
    *
    * ```ts
    * const base = asPositiveSafeInt(3);
+   *
    * const exponent = asPositiveSafeInt(3);
+   *
    * const power = PositiveSafeInt.pow(base, exponent);
    *
-   * assert(power === 27);
+   * assert.isTrue(power === 27);
    * ```
    *
    * @param a The base PositiveSafeInt.
@@ -217,8 +233,9 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(2048),
    * );
    *
-   * assert(sum === 3048);
-   * assert.ok(PositiveSafeInt.is(sum));
+   * assert.isTrue(sum === 3048);
+   *
+   * assert.isTrue(PositiveSafeInt.is(sum));
    * ```
    *
    * @param a The first PositiveSafeInt.
@@ -238,8 +255,9 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(20),
    * );
    *
-   * assert(difference === 1);
-   * assert.ok(PositiveSafeInt.is(difference));
+   * assert.isTrue(difference === 1);
+   *
+   * assert.isTrue(PositiveSafeInt.is(difference));
    * ```
    *
    * @param a The minuend PositiveSafeInt.
@@ -260,8 +278,9 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(20),
    * );
    *
-   * assert(product === 1000);
-   * assert.ok(PositiveSafeInt.is(product));
+   * assert.isTrue(product === 1000);
+   *
+   * assert.isTrue(PositiveSafeInt.is(product));
    * ```
    *
    * @param a The first PositiveSafeInt.
@@ -280,13 +299,15 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(25),
    *   asPositiveSafeInt(4),
    * );
+   *
    * const clamped = PositiveSafeInt.div(
    *   asPositiveSafeInt(5),
    *   asPositiveSafeInt(50),
    * );
    *
-   * assert(quotient === 6);
-   * assert(clamped === 1);
+   * assert.isTrue(quotient === 6);
+   *
+   * assert.isTrue(clamped === 1);
    * ```
    *
    * @param a The dividend PositiveSafeInt.