ts-data-forge 5.0.1 → 5.1.1

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

@@ -10,8 +10,11 @@ describe('NonZeroInt16 test', () => {
   describe(asNonZeroInt16, () => {
     test('accepts valid non-zero int16 values', () => {
       expect(() => asNonZeroInt16(1)).not.toThrow();
+
       expect(() => asNonZeroInt16(-1)).not.toThrow();
+
       expect(() => asNonZeroInt16(32_767)).not.toThrow(); // 2^15 - 1
+
       expect(() => asNonZeroInt16(-32_768)).not.toThrow(); // -2^15
     });
 
@@ -21,23 +24,33 @@ describe('NonZeroInt16 test', () => {
 
     test('rejects values outside int16 range', () => {
       expect(() => asNonZeroInt16(32_768)).toThrow(TypeError); // 2^15
+
       expect(() => asNonZeroInt16(-32_769)).toThrow(TypeError); // -2^15 - 1
+
       expect(() => asNonZeroInt16(65_536)).toThrow(TypeError);
+
       expect(() => asNonZeroInt16(-65_536)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroInt16(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroInt16(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt16(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt16(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroInt16(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroInt16(5)).toBe(5);
+
       expect(asNonZeroInt16(-10)).toBe(-10);
+
       expect(asNonZeroInt16(32_767)).toBe(32_767);
+
       expect(asNonZeroInt16(-32_768)).toBe(-32_768);
     });
 
@@ -64,36 +77,48 @@ describe('NonZeroInt16 test', () => {
 
   describe(isNonZeroInt16, () => {
     test('correctly identifies non-zero int16 values', () => {
-      expect(isNonZeroInt16(1)).toBe(true);
-      expect(isNonZeroInt16(-1)).toBe(true);
-      expect(isNonZeroInt16(32_767)).toBe(true);
-      expect(isNonZeroInt16(-32_768)).toBe(true);
+      assert.isTrue(isNonZeroInt16(1));
+
+      assert.isTrue(isNonZeroInt16(-1));
+
+      assert.isTrue(isNonZeroInt16(32_767));
+
+      assert.isTrue(isNonZeroInt16(-32_768));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroInt16(0)).toBe(false);
+      assert.isFalse(isNonZeroInt16(0));
     });
 
     test('correctly identifies values outside int16 range', () => {
-      expect(isNonZeroInt16(32_768)).toBe(false);
-      expect(isNonZeroInt16(-32_769)).toBe(false);
-      expect(isNonZeroInt16(65_536)).toBe(false);
-      expect(isNonZeroInt16(-65_536)).toBe(false);
+      assert.isFalse(isNonZeroInt16(32_768));
+
+      assert.isFalse(isNonZeroInt16(-32_769));
+
+      assert.isFalse(isNonZeroInt16(65_536));
+
+      assert.isFalse(isNonZeroInt16(-65_536));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroInt16(Number.NaN)).toBe(false);
-      expect(isNonZeroInt16(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isNonZeroInt16(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isNonZeroInt16(1.2)).toBe(false);
-      expect(isNonZeroInt16(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroInt16(Number.NaN));
+
+      assert.isFalse(isNonZeroInt16(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isNonZeroInt16(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isNonZeroInt16(1.2));
+
+      assert.isFalse(isNonZeroInt16(-3.4));
     });
   });
 
   describe('NonZeroInt16.is', () => {
     test('same as isNonZeroInt16 function', () => {
       expect(NonZeroInt16.is(5)).toBe(isNonZeroInt16(5));
+
       expect(NonZeroInt16.is(0)).toBe(isNonZeroInt16(0));
+
       expect(NonZeroInt16.is(-1)).toBe(isNonZeroInt16(-1));
     });
   });
@@ -101,24 +126,31 @@ describe('NonZeroInt16 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroInt16.MIN_VALUE).toBe(-32_768);
+
       expect(NonZeroInt16.MAX_VALUE).toBe(32_767);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroInt16(100);
+
     const b = asNonZeroInt16(50);
+
     const c = asNonZeroInt16(-30);
 
     test('abs', () => {
       expect(NonZeroInt16.abs(a)).toBe(100);
+
       expect(NonZeroInt16.abs(c)).toBe(30);
     });
 
     test('min and max', () => {
       expect(NonZeroInt16.min(a, b)).toBe(50);
+
       expect(NonZeroInt16.max(a, b)).toBe(100);
+
       expect(NonZeroInt16.min(a, c)).toBe(-30);
+
       expect(NonZeroInt16.max(a, c)).toBe(100);
     });
 
@@ -129,6 +161,7 @@ describe('NonZeroInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(NonZeroInt16.add(a, b)).toBe(150);
     });
 
@@ -139,6 +172,7 @@ describe('NonZeroInt16 test', () => {
       );
 
       expect(result).toBe(-32_768); // clamped to min
+
       expect(NonZeroInt16.sub(a, b)).toBe(50);
     });
 
@@ -149,12 +183,15 @@ describe('NonZeroInt16 test', () => {
       );
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(NonZeroInt16.mul(asNonZeroInt16(10), asNonZeroInt16(5))).toBe(50);
     });
 
     test('div (floor division with clamping)', () => {
       expect(NonZeroInt16.div(a, asNonZeroInt16(50))).toBe(2);
+
       expect(NonZeroInt16.div(asNonZeroInt16(7), asNonZeroInt16(3))).toBe(2);
+
       expect(NonZeroInt16.div(asNonZeroInt16(-7), asNonZeroInt16(3))).toBe(-3);
     });
 
@@ -162,6 +199,7 @@ describe('NonZeroInt16 test', () => {
       const result = NonZeroInt16.pow(asNonZeroInt16(200), asNonZeroInt16(3));
 
       expect(result).toBe(32_767); // clamped to max
+
       expect(NonZeroInt16.pow(asNonZeroInt16(2), asNonZeroInt16(3))).toBe(8);
     });
   });
@@ -169,15 +207,20 @@ describe('NonZeroInt16 test', () => {
   describe('random', () => {
     test('generates non-zero int16 values within specified range', () => {
       const min = -10;
+
       const max = 10;
 
       for (const _ of range(10)) {
         const result = NonZeroInt16.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroInt16.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonZeroInt16.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).not.toBe(0);
       }
     });
@@ -187,6 +230,7 @@ describe('NonZeroInt16 test', () => {
         const result = NonZeroInt16.random(-20, 20);
 
         expect(result).toBeGreaterThanOrEqual(-32_768);
+
         expect(result).toBeLessThanOrEqual(32_767);
       }
     });

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

@@ -10,8 +10,11 @@ describe('NonZeroInt32 test', () => {
   describe(asNonZeroInt32, () => {
     test('accepts valid non-zero int32 values', () => {
       expect(() => asNonZeroInt32(1)).not.toThrow();
+
       expect(() => asNonZeroInt32(-1)).not.toThrow();
+
       expect(() => asNonZeroInt32(2_147_483_647)).not.toThrow(); // 2^31 - 1
+
       expect(() => asNonZeroInt32(-2_147_483_648)).not.toThrow(); // -2^31
     });
 
@@ -21,23 +24,33 @@ describe('NonZeroInt32 test', () => {
 
     test('rejects values outside int32 range', () => {
       expect(() => asNonZeroInt32(2_147_483_648)).toThrow(TypeError); // 2^31
+
       expect(() => asNonZeroInt32(-2_147_483_649)).toThrow(TypeError); // -2^31 - 1
+
       expect(() => asNonZeroInt32(4_294_967_296)).toThrow(TypeError);
+
       expect(() => asNonZeroInt32(-4_294_967_296)).toThrow(TypeError);
     });
 
     test('rejects non-integers', () => {
       expect(() => asNonZeroInt32(Number.NaN)).toThrow(TypeError);
+
       expect(() => asNonZeroInt32(Number.POSITIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt32(Number.NEGATIVE_INFINITY)).toThrow(TypeError);
+
       expect(() => asNonZeroInt32(1.2)).toThrow(TypeError);
+
       expect(() => asNonZeroInt32(-3.4)).toThrow(TypeError);
     });
 
     test('returns the same value for valid inputs', () => {
       expect(asNonZeroInt32(5)).toBe(5);
+
       expect(asNonZeroInt32(-10)).toBe(-10);
+
       expect(asNonZeroInt32(2_147_483_647)).toBe(2_147_483_647);
+
       expect(asNonZeroInt32(-2_147_483_648)).toBe(-2_147_483_648);
     });
 
@@ -64,36 +77,48 @@ describe('NonZeroInt32 test', () => {
 
   describe(isNonZeroInt32, () => {
     test('correctly identifies non-zero int32 values', () => {
-      expect(isNonZeroInt32(1)).toBe(true);
-      expect(isNonZeroInt32(-1)).toBe(true);
-      expect(isNonZeroInt32(2_147_483_647)).toBe(true);
-      expect(isNonZeroInt32(-2_147_483_648)).toBe(true);
+      assert.isTrue(isNonZeroInt32(1));
+
+      assert.isTrue(isNonZeroInt32(-1));
+
+      assert.isTrue(isNonZeroInt32(2_147_483_647));
+
+      assert.isTrue(isNonZeroInt32(-2_147_483_648));
     });
 
     test('correctly identifies zero', () => {
-      expect(isNonZeroInt32(0)).toBe(false);
+      assert.isFalse(isNonZeroInt32(0));
     });
 
     test('correctly identifies values outside int32 range', () => {
-      expect(isNonZeroInt32(2_147_483_648)).toBe(false);
-      expect(isNonZeroInt32(-2_147_483_649)).toBe(false);
-      expect(isNonZeroInt32(4_294_967_296)).toBe(false);
-      expect(isNonZeroInt32(-4_294_967_296)).toBe(false);
+      assert.isFalse(isNonZeroInt32(2_147_483_648));
+
+      assert.isFalse(isNonZeroInt32(-2_147_483_649));
+
+      assert.isFalse(isNonZeroInt32(4_294_967_296));
+
+      assert.isFalse(isNonZeroInt32(-4_294_967_296));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isNonZeroInt32(Number.NaN)).toBe(false);
-      expect(isNonZeroInt32(Number.POSITIVE_INFINITY)).toBe(false);
-      expect(isNonZeroInt32(Number.NEGATIVE_INFINITY)).toBe(false);
-      expect(isNonZeroInt32(1.2)).toBe(false);
-      expect(isNonZeroInt32(-3.4)).toBe(false);
+      assert.isFalse(isNonZeroInt32(Number.NaN));
+
+      assert.isFalse(isNonZeroInt32(Number.POSITIVE_INFINITY));
+
+      assert.isFalse(isNonZeroInt32(Number.NEGATIVE_INFINITY));
+
+      assert.isFalse(isNonZeroInt32(1.2));
+
+      assert.isFalse(isNonZeroInt32(-3.4));
     });
   });
 
   describe('NonZeroInt32.is', () => {
     test('same as isNonZeroInt32 function', () => {
       expect(NonZeroInt32.is(5)).toBe(isNonZeroInt32(5));
+
       expect(NonZeroInt32.is(0)).toBe(isNonZeroInt32(0));
+
       expect(NonZeroInt32.is(-1)).toBe(isNonZeroInt32(-1));
     });
   });
@@ -101,24 +126,31 @@ describe('NonZeroInt32 test', () => {
   describe('constants', () => {
     test('MIN_VALUE and MAX_VALUE', () => {
       expect(NonZeroInt32.MIN_VALUE).toBe(-2_147_483_648);
+
       expect(NonZeroInt32.MAX_VALUE).toBe(2_147_483_647);
     });
   });
 
   describe('mathematical operations', () => {
     const a = asNonZeroInt32(1_000_000);
+
     const b = asNonZeroInt32(500_000);
+
     const c = asNonZeroInt32(-300_000);
 
     test('abs', () => {
       expect(NonZeroInt32.abs(a)).toBe(1_000_000);
+
       expect(NonZeroInt32.abs(c)).toBe(300_000);
     });
 
     test('min and max', () => {
       expect(NonZeroInt32.min(a, b)).toBe(500_000);
+
       expect(NonZeroInt32.max(a, b)).toBe(1_000_000);
+
       expect(NonZeroInt32.min(a, c)).toBe(-300_000);
+
       expect(NonZeroInt32.max(a, c)).toBe(1_000_000);
     });
 
@@ -129,6 +161,7 @@ describe('NonZeroInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(NonZeroInt32.add(a, b)).toBe(1_500_000);
     });
 
@@ -139,6 +172,7 @@ describe('NonZeroInt32 test', () => {
       );
 
       expect(result).toBe(-2_147_483_648); // clamped to min
+
       expect(NonZeroInt32.sub(a, b)).toBe(500_000);
     });
 
@@ -149,6 +183,7 @@ describe('NonZeroInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(NonZeroInt32.mul(asNonZeroInt32(1000), asNonZeroInt32(5))).toBe(
         5000,
       );
@@ -156,7 +191,9 @@ describe('NonZeroInt32 test', () => {
 
     test('div (floor division with clamping)', () => {
       expect(NonZeroInt32.div(a, asNonZeroInt32(500_000))).toBe(2);
+
       expect(NonZeroInt32.div(asNonZeroInt32(7), asNonZeroInt32(3))).toBe(2);
+
       expect(NonZeroInt32.div(asNonZeroInt32(-7), asNonZeroInt32(3))).toBe(-3);
     });
 
@@ -167,6 +204,7 @@ describe('NonZeroInt32 test', () => {
       );
 
       expect(result).toBe(2_147_483_647); // clamped to max
+
       expect(NonZeroInt32.pow(asNonZeroInt32(2), asNonZeroInt32(3))).toBe(8);
     });
   });
@@ -174,15 +212,20 @@ describe('NonZeroInt32 test', () => {
   describe('random', () => {
     test('generates non-zero int32 values within specified range', () => {
       const min = -10;
+
       const max = 10;
 
       for (const _ of range(10)) {
         const result = NonZeroInt32.random(min, max);
 
         expect(result).toBeGreaterThanOrEqual(min);
+
         expect(result).toBeLessThanOrEqual(max);
-        expect(NonZeroInt32.is(result)).toBe(true);
-        expect(Number.isInteger(result)).toBe(true);
+
+        assert.isTrue(NonZeroInt32.is(result));
+
+        assert.isTrue(Number.isInteger(result));
+
         expect(result).not.toBe(0);
       }
     });
@@ -192,6 +235,7 @@ describe('NonZeroInt32 test', () => {
         const result = NonZeroInt32.random(-20, 20);
 
         expect(result).toBeGreaterThanOrEqual(-2_147_483_648);
+
         expect(result).toBeLessThanOrEqual(2_147_483_647);
       }
     });

package/src/number/branded-types/non-zero-safe-int.mts

@@ -27,9 +27,9 @@ const {
 >({
   integerOrSafeInteger: 'SafeInteger',
   nonZero: true,
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion, math/prefer-number-min-safe-integer
   MIN_VALUE: Number.MIN_SAFE_INTEGER as SafeInt,
-  // 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);