ts-data-forge 5.1.0 → 6.0.0

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

@@ -70,41 +70,41 @@ describe('PositiveInt test', () => {
 
   describe(isPositiveInt, () => {
     test('correctly identifies positive integers', () => {
-      expect(isPositiveInt(1)).toBe(true);
+      assert.isTrue(isPositiveInt(1));
 
-      expect(isPositiveInt(2)).toBe(true);
+      assert.isTrue(isPositiveInt(2));
 
-      expect(isPositiveInt(42)).toBe(true);
+      assert.isTrue(isPositiveInt(42));
 
-      expect(isPositiveInt(100)).toBe(true);
+      assert.isTrue(isPositiveInt(100));
 
-      expect(isPositiveInt(Number.MAX_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isPositiveInt(Number.MAX_SAFE_INTEGER));
     });
 
     test('correctly identifies zero', () => {
-      expect(isPositiveInt(0)).toBe(false);
+      assert.isFalse(isPositiveInt(0));
 
-      expect(isPositiveInt(-0)).toBe(false);
+      assert.isFalse(isPositiveInt(-0));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isPositiveInt(-1)).toBe(false);
+      assert.isFalse(isPositiveInt(-1));
 
-      expect(isPositiveInt(-42)).toBe(false);
+      assert.isFalse(isPositiveInt(-42));
 
-      expect(isPositiveInt(Number.MIN_SAFE_INTEGER)).toBe(false);
+      assert.isFalse(isPositiveInt(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isPositiveInt(Number.NaN)).toBe(false);
+      assert.isFalse(isPositiveInt(Number.NaN));
 
-      expect(isPositiveInt(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveInt(Number.POSITIVE_INFINITY));
 
-      expect(isPositiveInt(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveInt(Number.NEGATIVE_INFINITY));
 
-      expect(isPositiveInt(1.2)).toBe(false);
+      assert.isFalse(isPositiveInt(1.2));
 
-      expect(isPositiveInt(-3.4)).toBe(false);
+      assert.isFalse(isPositiveInt(-3.4));
     });
   });
 
@@ -191,9 +191,9 @@ describe('PositiveInt test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(PositiveInt.is(result)).toBe(true);
+        assert.isTrue(PositiveInt.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThan(0);
       }

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

@@ -79,39 +79,39 @@ describe('PositiveInt16 test', () => {
 
   describe(isPositiveInt16, () => {
     test('correctly identifies positive int16 values', () => {
-      expect(isPositiveInt16(1)).toBe(true);
+      assert.isTrue(isPositiveInt16(1));
 
-      expect(isPositiveInt16(1000)).toBe(true);
+      assert.isTrue(isPositiveInt16(1000));
 
-      expect(isPositiveInt16(32_767)).toBe(true);
+      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);
+      assert.isFalse(isPositiveInt16(32_768));
 
-      expect(isPositiveInt16(65_536)).toBe(false);
+      assert.isFalse(isPositiveInt16(65_536));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isPositiveInt16(-1)).toBe(false);
+      assert.isFalse(isPositiveInt16(-1));
 
-      expect(isPositiveInt16(-42)).toBe(false);
+      assert.isFalse(isPositiveInt16(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isPositiveInt16(Number.NaN)).toBe(false);
+      assert.isFalse(isPositiveInt16(Number.NaN));
 
-      expect(isPositiveInt16(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveInt16(Number.POSITIVE_INFINITY));
 
-      expect(isPositiveInt16(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveInt16(Number.NEGATIVE_INFINITY));
 
-      expect(isPositiveInt16(1.2)).toBe(false);
+      assert.isFalse(isPositiveInt16(1.2));
 
-      expect(isPositiveInt16(-3.4)).toBe(false);
+      assert.isFalse(isPositiveInt16(-3.4));
     });
   });
 
@@ -209,9 +209,9 @@ describe('PositiveInt16 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(PositiveInt16.is(result)).toBe(true);
+        assert.isTrue(PositiveInt16.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThan(0);
       }

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

@@ -79,39 +79,39 @@ describe('PositiveInt32 test', () => {
 
   describe(isPositiveInt32, () => {
     test('correctly identifies positive int32 values', () => {
-      expect(isPositiveInt32(1)).toBe(true);
+      assert.isTrue(isPositiveInt32(1));
 
-      expect(isPositiveInt32(1000)).toBe(true);
+      assert.isTrue(isPositiveInt32(1000));
 
-      expect(isPositiveInt32(2_147_483_647)).toBe(true);
+      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);
+      assert.isFalse(isPositiveInt32(2_147_483_648));
 
-      expect(isPositiveInt32(4_294_967_296)).toBe(false);
+      assert.isFalse(isPositiveInt32(4_294_967_296));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isPositiveInt32(-1)).toBe(false);
+      assert.isFalse(isPositiveInt32(-1));
 
-      expect(isPositiveInt32(-42)).toBe(false);
+      assert.isFalse(isPositiveInt32(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isPositiveInt32(Number.NaN)).toBe(false);
+      assert.isFalse(isPositiveInt32(Number.NaN));
 
-      expect(isPositiveInt32(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveInt32(Number.POSITIVE_INFINITY));
 
-      expect(isPositiveInt32(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveInt32(Number.NEGATIVE_INFINITY));
 
-      expect(isPositiveInt32(1.2)).toBe(false);
+      assert.isFalse(isPositiveInt32(1.2));
 
-      expect(isPositiveInt32(-3.4)).toBe(false);
+      assert.isFalse(isPositiveInt32(-3.4));
     });
   });
 
@@ -209,9 +209,9 @@ describe('PositiveInt32 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(PositiveInt32.is(result)).toBe(true);
+        assert.isTrue(PositiveInt32.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThan(0);
       }

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

@@ -38,13 +38,13 @@ const {
  * @example
  *
  * ```ts
- * assert.ok(isPositiveSafeInt(1));
+ * assert.isTrue(isPositiveSafeInt(1));
  *
- * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+ * assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
  *
- * assert.notOk(isPositiveSafeInt(0));
+ * assert.isFalse(isPositiveSafeInt(0));
  *
- * assert.ok(PositiveSafeInt.is(42));
+ * assert.isTrue(PositiveSafeInt.is(42));
  * ```
  *
  * @param value The value to check.
@@ -60,9 +60,9 @@ export const isPositiveSafeInt = is;
  * ```ts
  * const branded = asPositiveSafeInt(128);
  *
- * assert(branded === 128);
+ * assert.isTrue(branded === 128);
  *
- * assert.ok(PositiveSafeInt.is(branded));
+ * assert.isTrue(PositiveSafeInt.is(branded));
  * ```
  *
  * @param value The value to cast.
@@ -87,13 +87,13 @@ export const PositiveSafeInt = {
    * @example
    *
    * ```ts
-   * assert.ok(isPositiveSafeInt(1));
+   * assert.isTrue(isPositiveSafeInt(1));
    *
-   * assert.ok(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
+   * assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
    *
-   * assert.notOk(isPositiveSafeInt(0));
+   * assert.isFalse(isPositiveSafeInt(0));
    *
-   * assert.ok(PositiveSafeInt.is(42));
+   * assert.isTrue(PositiveSafeInt.is(42));
    * ```
    *
    * @param value The value to check.
@@ -127,7 +127,7 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(5),
    * );
    *
-   * assert(smallest === 5);
+   * assert.isTrue(smallest === 5);
    * ```
    *
    * @param a The first PositiveSafeInt.
@@ -147,7 +147,7 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(5),
    * );
    *
-   * assert(largest === 10);
+   * assert.isTrue(largest === 10);
    * ```
    *
    * @param a The first PositiveSafeInt.
@@ -168,11 +168,11 @@ export const PositiveSafeInt = {
    *
    * const aboveRange = PositiveSafeInt.clamp(Number.MAX_SAFE_INTEGER + 10);
    *
-   * assert(belowRange === 1);
+   * assert.isTrue(belowRange === 1);
    *
-   * assert(withinRange === 123);
+   * assert.isTrue(withinRange === 123);
    *
-   * assert(aboveRange === Number.MAX_SAFE_INTEGER);
+   * assert.isTrue(aboveRange === Number.MAX_SAFE_INTEGER);
    * ```
    *
    * @param value The number to clamp.
@@ -192,9 +192,9 @@ export const PositiveSafeInt = {
    *
    * const randomValue = PositiveSafeInt.random(min, max);
    *
-   * assert.ok(PositiveSafeInt.is(randomValue));
+   * assert.isTrue(PositiveSafeInt.is(randomValue));
    *
-   * assert.ok(randomValue >= 1 && randomValue <= 6);
+   * assert.isTrue(randomValue >= 1 && randomValue <= 6);
    * ```
    *
    * @returns A random PositiveSafeInt between 1 and MAX_SAFE_INTEGER.
@@ -213,7 +213,7 @@ export const PositiveSafeInt = {
    *
    * const power = PositiveSafeInt.pow(base, exponent);
    *
-   * assert(power === 27);
+   * assert.isTrue(power === 27);
    * ```
    *
    * @param a The base PositiveSafeInt.
@@ -233,9 +233,9 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(2048),
    * );
    *
-   * assert(sum === 3048);
+   * assert.isTrue(sum === 3048);
    *
-   * assert.ok(PositiveSafeInt.is(sum));
+   * assert.isTrue(PositiveSafeInt.is(sum));
    * ```
    *
    * @param a The first PositiveSafeInt.
@@ -255,9 +255,9 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(20),
    * );
    *
-   * assert(difference === 1);
+   * assert.isTrue(difference === 1);
    *
-   * assert.ok(PositiveSafeInt.is(difference));
+   * assert.isTrue(PositiveSafeInt.is(difference));
    * ```
    *
    * @param a The minuend PositiveSafeInt.
@@ -278,9 +278,9 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(20),
    * );
    *
-   * assert(product === 1000);
+   * assert.isTrue(product === 1000);
    *
-   * assert.ok(PositiveSafeInt.is(product));
+   * assert.isTrue(PositiveSafeInt.is(product));
    * ```
    *
    * @param a The first PositiveSafeInt.
@@ -305,9 +305,9 @@ export const PositiveSafeInt = {
    *   asPositiveSafeInt(50),
    * );
    *
-   * assert(quotient === 6);
+   * assert.isTrue(quotient === 6);
    *
-   * assert(clamped === 1);
+   * assert.isTrue(clamped === 1);
    * ```
    *
    * @param a The dividend PositiveSafeInt.

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

@@ -88,47 +88,47 @@ describe('PositiveSafeInt test', () => {
 
   describe(isPositiveSafeInt, () => {
     test('correctly identifies positive safe integers', () => {
-      expect(isPositiveSafeInt(1)).toBe(true);
+      assert.isTrue(isPositiveSafeInt(1));
 
-      expect(isPositiveSafeInt(2)).toBe(true);
+      assert.isTrue(isPositiveSafeInt(2));
 
-      expect(isPositiveSafeInt(42)).toBe(true);
+      assert.isTrue(isPositiveSafeInt(42));
 
-      expect(isPositiveSafeInt(100)).toBe(true);
+      assert.isTrue(isPositiveSafeInt(100));
 
-      expect(isPositiveSafeInt(Number.MAX_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isPositiveSafeInt(Number.MAX_SAFE_INTEGER));
     });
 
     test('correctly identifies zero', () => {
-      expect(isPositiveSafeInt(0)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(0));
 
-      expect(isPositiveSafeInt(-0)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(-0));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isPositiveSafeInt(-1)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(-1));
 
-      expect(isPositiveSafeInt(-42)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(-42));
 
-      expect(isPositiveSafeInt(Number.MIN_SAFE_INTEGER)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies values outside safe integer range', () => {
-      expect(isPositiveSafeInt(Number.MAX_SAFE_INTEGER + 1)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(Number.MAX_SAFE_INTEGER + 1));
 
-      expect(isPositiveSafeInt(Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(Number.MAX_VALUE));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isPositiveSafeInt(Number.NaN)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(Number.NaN));
 
-      expect(isPositiveSafeInt(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(Number.POSITIVE_INFINITY));
 
-      expect(isPositiveSafeInt(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(Number.NEGATIVE_INFINITY));
 
-      expect(isPositiveSafeInt(1.2)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(1.2));
 
-      expect(isPositiveSafeInt(-3.4)).toBe(false);
+      assert.isFalse(isPositiveSafeInt(-3.4));
     });
   });
 
@@ -236,9 +236,9 @@ describe('PositiveSafeInt test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(PositiveSafeInt.is(result)).toBe(true);
+        assert.isTrue(PositiveSafeInt.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThan(0);
       }

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

@@ -81,41 +81,41 @@ describe('PositiveUint16 test', () => {
 
   describe(isPositiveUint16, () => {
     test('correctly identifies positive uint16 values', () => {
-      expect(isPositiveUint16(1)).toBe(true);
+      assert.isTrue(isPositiveUint16(1));
 
-      expect(isPositiveUint16(1000)).toBe(true);
+      assert.isTrue(isPositiveUint16(1000));
 
-      expect(isPositiveUint16(65_535)).toBe(true);
+      assert.isTrue(isPositiveUint16(65_535));
 
-      expect(isPositiveUint16(32_768)).toBe(true);
+      assert.isTrue(isPositiveUint16(32_768));
     });
 
     test('correctly identifies zero', () => {
-      expect(isPositiveUint16(0)).toBe(false);
+      assert.isFalse(isPositiveUint16(0));
     });
 
     test('correctly identifies values outside uint16 range', () => {
-      expect(isPositiveUint16(65_536)).toBe(false);
+      assert.isFalse(isPositiveUint16(65_536));
 
-      expect(isPositiveUint16(100_000)).toBe(false);
+      assert.isFalse(isPositiveUint16(100_000));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isPositiveUint16(-1)).toBe(false);
+      assert.isFalse(isPositiveUint16(-1));
 
-      expect(isPositiveUint16(-42)).toBe(false);
+      assert.isFalse(isPositiveUint16(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isPositiveUint16(Number.NaN)).toBe(false);
+      assert.isFalse(isPositiveUint16(Number.NaN));
 
-      expect(isPositiveUint16(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveUint16(Number.POSITIVE_INFINITY));
 
-      expect(isPositiveUint16(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveUint16(Number.NEGATIVE_INFINITY));
 
-      expect(isPositiveUint16(1.2)).toBe(false);
+      assert.isFalse(isPositiveUint16(1.2));
 
-      expect(isPositiveUint16(-3.4)).toBe(false);
+      assert.isFalse(isPositiveUint16(-3.4));
     });
   });
 
@@ -217,9 +217,9 @@ describe('PositiveUint16 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(PositiveUint16.is(result)).toBe(true);
+        assert.isTrue(PositiveUint16.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThan(0);
       }

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

@@ -81,41 +81,41 @@ describe('PositiveUint32 test', () => {
 
   describe(isPositiveUint32, () => {
     test('correctly identifies positive uint32 values', () => {
-      expect(isPositiveUint32(1)).toBe(true);
+      assert.isTrue(isPositiveUint32(1));
 
-      expect(isPositiveUint32(1000)).toBe(true);
+      assert.isTrue(isPositiveUint32(1000));
 
-      expect(isPositiveUint32(4_294_967_295)).toBe(true);
+      assert.isTrue(isPositiveUint32(4_294_967_295));
 
-      expect(isPositiveUint32(2_147_483_648)).toBe(true);
+      assert.isTrue(isPositiveUint32(2_147_483_648));
     });
 
     test('correctly identifies zero', () => {
-      expect(isPositiveUint32(0)).toBe(false);
+      assert.isFalse(isPositiveUint32(0));
     });
 
     test('correctly identifies values outside uint32 range', () => {
-      expect(isPositiveUint32(4_294_967_296)).toBe(false);
+      assert.isFalse(isPositiveUint32(4_294_967_296));
 
-      expect(isPositiveUint32(10_000_000_000)).toBe(false);
+      assert.isFalse(isPositiveUint32(10_000_000_000));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isPositiveUint32(-1)).toBe(false);
+      assert.isFalse(isPositiveUint32(-1));
 
-      expect(isPositiveUint32(-42)).toBe(false);
+      assert.isFalse(isPositiveUint32(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isPositiveUint32(Number.NaN)).toBe(false);
+      assert.isFalse(isPositiveUint32(Number.NaN));
 
-      expect(isPositiveUint32(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveUint32(Number.POSITIVE_INFINITY));
 
-      expect(isPositiveUint32(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isPositiveUint32(Number.NEGATIVE_INFINITY));
 
-      expect(isPositiveUint32(1.2)).toBe(false);
+      assert.isFalse(isPositiveUint32(1.2));
 
-      expect(isPositiveUint32(-3.4)).toBe(false);
+      assert.isFalse(isPositiveUint32(-3.4));
     });
   });
 
@@ -220,9 +220,9 @@ describe('PositiveUint32 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(PositiveUint32.is(result)).toBe(true);
+        assert.isTrue(PositiveUint32.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThan(0);
       }