ts-data-forge 5.1.0 → 5.1.1

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

@@ -42,11 +42,11 @@ const {
  * @example
  *
  * ```ts
- * assert.ok(isSafeInt(Number.MAX_SAFE_INTEGER));
+ * assert.isTrue(isSafeInt(Number.MAX_SAFE_INTEGER));
  *
- * assert.notOk(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
+ * assert.isFalse(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
  *
- * assert.ok(SafeInt.is(Number.MIN_SAFE_INTEGER));
+ * assert.isTrue(SafeInt.is(Number.MIN_SAFE_INTEGER));
  * ```
  *
  * @param value - The value to check
@@ -66,9 +66,9 @@ export const isSafeInt = is;
  * ```ts
  * const branded = asSafeInt(123);
  *
- * assert(branded === 123);
+ * assert.isTrue(branded === 123);
  *
- * assert.ok(SafeInt.is(branded));
+ * assert.isTrue(SafeInt.is(branded));
  * ```
  *
  * @param value - The value to cast
@@ -100,11 +100,11 @@ export const SafeInt = {
    * @example
    *
    * ```ts
-   * assert.ok(isSafeInt(Number.MAX_SAFE_INTEGER));
+   * assert.isTrue(isSafeInt(Number.MAX_SAFE_INTEGER));
    *
-   * assert.notOk(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
+   * assert.isFalse(isSafeInt(Number.MAX_SAFE_INTEGER + 0.5));
    *
-   * assert.ok(SafeInt.is(Number.MIN_SAFE_INTEGER));
+   * assert.isTrue(SafeInt.is(Number.MIN_SAFE_INTEGER));
    * ```
    *
    * @param value - The value to check
@@ -140,9 +140,9 @@ export const SafeInt = {
    *
    * const absolute = SafeInt.abs(negative);
    *
-   * assert(absolute === 900);
+   * assert.isTrue(absolute === 900);
    *
-   * assert.ok(SafeInt.is(absolute));
+   * assert.isTrue(SafeInt.is(absolute));
    * ```
    *
    * @param a - The safe integer value
@@ -158,7 +158,7 @@ export const SafeInt = {
    * ```ts
    * const smallest = SafeInt.min(asSafeInt(25), asSafeInt(-14), asSafeInt(99));
    *
-   * assert(smallest === -14);
+   * assert.isTrue(smallest === -14);
    * ```
    *
    * @param values - The safe integers to compare (at least one required)
@@ -174,7 +174,7 @@ export const SafeInt = {
    * ```ts
    * const largest = SafeInt.max(asSafeInt(25), asSafeInt(-14), asSafeInt(99));
    *
-   * assert(largest === 99);
+   * assert.isTrue(largest === 99);
    * ```
    *
    * @param values - The safe integers to compare (at least one required)
@@ -194,11 +194,11 @@ export const SafeInt = {
    *
    * const belowRange = SafeInt.clamp(-1e20);
    *
-   * assert(aboveRange === Number.MAX_SAFE_INTEGER);
+   * assert.isTrue(aboveRange === Number.MAX_SAFE_INTEGER);
    *
-   * assert(withinRange === 123);
+   * assert.isTrue(withinRange === 123);
    *
-   * assert(belowRange === Number.MIN_SAFE_INTEGER);
+   * assert.isTrue(belowRange === Number.MIN_SAFE_INTEGER);
    * ```
    *
    * @param value The number to clamp.
@@ -222,9 +222,9 @@ export const SafeInt = {
    *
    * const randomValue = SafeInt.random(min, max);
    *
-   * assert.ok(SafeInt.is(randomValue));
+   * assert.isTrue(SafeInt.is(randomValue));
    *
-   * assert.ok(randomValue >= -10 && randomValue <= 10);
+   * assert.isTrue(randomValue >= -10 && randomValue <= 10);
    * ```
    *
    * @param min - The minimum value (inclusive)
@@ -245,9 +245,9 @@ export const SafeInt = {
    *
    * const power = SafeInt.pow(base, exponent);
    *
-   * assert(power === 243);
+   * assert.isTrue(power === 243);
    *
-   * assert.ok(SafeInt.is(power));
+   * assert.isTrue(SafeInt.is(power));
    * ```
    *
    * @param a The base SafeInt.
@@ -264,9 +264,9 @@ export const SafeInt = {
    * ```ts
    * const sum = SafeInt.add(asSafeInt(9), asSafeInt(4));
    *
-   * assert(sum === 13);
+   * assert.isTrue(sum === 13);
    *
-   * assert.ok(SafeInt.is(sum));
+   * assert.isTrue(SafeInt.is(sum));
    * ```
    *
    * @param a The first SafeInt.
@@ -283,9 +283,9 @@ export const SafeInt = {
    * ```ts
    * const difference = SafeInt.sub(asSafeInt(9), asSafeInt(14));
    *
-   * assert(difference === -5);
+   * assert.isTrue(difference === -5);
    *
-   * assert.ok(SafeInt.is(difference));
+   * assert.isTrue(SafeInt.is(difference));
    * ```
    *
    * @param a The minuend SafeInt.
@@ -302,9 +302,9 @@ export const SafeInt = {
    * ```ts
    * const product = SafeInt.mul(asSafeInt(-8), asSafeInt(7));
    *
-   * assert(product === -56);
+   * assert.isTrue(product === -56);
    *
-   * assert.ok(SafeInt.is(product));
+   * assert.isTrue(SafeInt.is(product));
    * ```
    *
    * @param a The first SafeInt.
@@ -324,9 +324,9 @@ export const SafeInt = {
    * ```ts
    * const quotient = SafeInt.div(asSafeInt(-17), asSafeInt(5));
    *
-   * assert(quotient === -4);
+   * assert.isTrue(quotient === -4);
    *
-   * assert.ok(SafeInt.is(quotient));
+   * assert.isTrue(SafeInt.is(quotient));
    * ```
    *
    * @param a - The dividend

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

@@ -69,41 +69,41 @@ describe('SafeInt test', () => {
 
   describe('SafeInt.is', () => {
     test('correctly identifies safe integers', () => {
-      expect(SafeInt.is(0)).toBe(true);
+      assert.isTrue(SafeInt.is(0));
 
-      expect(SafeInt.is(1)).toBe(true);
+      assert.isTrue(SafeInt.is(1));
 
-      expect(SafeInt.is(-1)).toBe(true);
+      assert.isTrue(SafeInt.is(-1));
 
-      expect(SafeInt.is(42)).toBe(true);
+      assert.isTrue(SafeInt.is(42));
 
-      expect(SafeInt.is(-42)).toBe(true);
+      assert.isTrue(SafeInt.is(-42));
 
-      expect(SafeInt.is(Number.MAX_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(SafeInt.is(Number.MAX_SAFE_INTEGER));
 
-      expect(SafeInt.is(Number.MIN_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(SafeInt.is(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies values outside safe integer range', () => {
-      expect(SafeInt.is(Number.MAX_SAFE_INTEGER + 1)).toBe(false);
+      assert.isFalse(SafeInt.is(Number.MAX_SAFE_INTEGER + 1));
 
-      expect(SafeInt.is(Number.MIN_SAFE_INTEGER - 1)).toBe(false);
+      assert.isFalse(SafeInt.is(Number.MIN_SAFE_INTEGER - 1));
 
-      expect(SafeInt.is(Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(SafeInt.is(Number.MAX_VALUE));
 
-      expect(SafeInt.is(-Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(SafeInt.is(-Number.MAX_VALUE));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(SafeInt.is(Number.NaN)).toBe(false);
+      assert.isFalse(SafeInt.is(Number.NaN));
 
-      expect(SafeInt.is(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(SafeInt.is(Number.POSITIVE_INFINITY));
 
-      expect(SafeInt.is(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(SafeInt.is(Number.NEGATIVE_INFINITY));
 
-      expect(SafeInt.is(1.2)).toBe(false);
+      assert.isFalse(SafeInt.is(1.2));
 
-      expect(SafeInt.is(-3.4)).toBe(false);
+      assert.isFalse(SafeInt.is(-3.4));
     });
   });
 
@@ -202,9 +202,9 @@ describe('SafeInt test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(SafeInt.is(result)).toBe(true);
+        assert.isTrue(SafeInt.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
       }
     });
 

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

@@ -68,41 +68,41 @@ describe('SafeUint test', () => {
 
   describe(isSafeUint, () => {
     test('correctly identifies safe unsigned integers', () => {
-      expect(isSafeUint(0)).toBe(true);
+      assert.isTrue(isSafeUint(0));
 
-      expect(isSafeUint(1)).toBe(true);
+      assert.isTrue(isSafeUint(1));
 
-      expect(isSafeUint(42)).toBe(true);
+      assert.isTrue(isSafeUint(42));
 
-      expect(isSafeUint(100)).toBe(true);
+      assert.isTrue(isSafeUint(100));
 
-      expect(isSafeUint(Number.MAX_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isSafeUint(Number.MAX_SAFE_INTEGER));
     });
 
     test('correctly identifies negative numbers', () => {
-      expect(isSafeUint(-1)).toBe(false);
+      assert.isFalse(isSafeUint(-1));
 
-      expect(isSafeUint(-42)).toBe(false);
+      assert.isFalse(isSafeUint(-42));
 
-      expect(isSafeUint(Number.MIN_SAFE_INTEGER)).toBe(false);
+      assert.isFalse(isSafeUint(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies values outside safe integer range', () => {
-      expect(isSafeUint(Number.MAX_SAFE_INTEGER + 1)).toBe(false);
+      assert.isFalse(isSafeUint(Number.MAX_SAFE_INTEGER + 1));
 
-      expect(isSafeUint(Number.MAX_VALUE)).toBe(false);
+      assert.isFalse(isSafeUint(Number.MAX_VALUE));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isSafeUint(Number.NaN)).toBe(false);
+      assert.isFalse(isSafeUint(Number.NaN));
 
-      expect(isSafeUint(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isSafeUint(Number.POSITIVE_INFINITY));
 
-      expect(isSafeUint(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isSafeUint(Number.NEGATIVE_INFINITY));
 
-      expect(isSafeUint(1.2)).toBe(false);
+      assert.isFalse(isSafeUint(1.2));
 
-      expect(isSafeUint(-3.4)).toBe(false);
+      assert.isFalse(isSafeUint(-3.4));
     });
   });
 
@@ -201,9 +201,9 @@ describe('SafeUint test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(SafeUint.is(result)).toBe(true);
+        assert.isTrue(SafeUint.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThanOrEqual(0);
       }

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

@@ -35,11 +35,11 @@ const {
  * @example
  *
  * ```ts
- * assert.ok(isUint(4));
+ * assert.isTrue(isUint(4));
  *
- * assert.notOk(isUint(-1));
+ * assert.isFalse(isUint(-1));
  *
- * assert.ok(Uint.is(0));
+ * assert.isTrue(Uint.is(0));
  * ```
  *
  * @param value The value to check.
@@ -55,9 +55,9 @@ export const isUint = is;
  * ```ts
  * const branded = asUint(12);
  *
- * assert(branded === 12);
+ * assert.isTrue(branded === 12);
  *
- * assert.ok(Uint.is(branded));
+ * assert.isTrue(Uint.is(branded));
  * ```
  *
  * @param value The value to cast.
@@ -80,11 +80,11 @@ export const Uint = {
    * @example
    *
    * ```ts
-   * assert.ok(isUint(4));
+   * assert.isTrue(isUint(4));
    *
-   * assert.notOk(isUint(-1));
+   * assert.isFalse(isUint(-1));
    *
-   * assert.ok(Uint.is(0));
+   * assert.isTrue(Uint.is(0));
    * ```
    *
    * @param value The value to check.
@@ -108,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.
@@ -125,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.
@@ -144,9 +144,9 @@ export const Uint = {
    *
    * const clampedPositive = Uint.clamp(42);
    *
-   * assert(clampedNegative === 0);
+   * assert.isTrue(clampedNegative === 0);
    *
-   * assert(clampedPositive === 42);
+   * assert.isTrue(clampedPositive === 42);
    * ```
    *
    * @param value The number to clamp.
@@ -166,9 +166,9 @@ export const Uint = {
    *
    * const randomValue = Uint.random(min, max);
    *
-   * assert.ok(Uint.is(randomValue));
+   * assert.isTrue(Uint.is(randomValue));
    *
-   * assert.ok(randomValue >= 0 && randomValue <= 3);
+   * assert.isTrue(randomValue >= 0 && randomValue <= 3);
    * ```
    *
    * @returns A random non-negative integer as a Uint.
@@ -187,7 +187,7 @@ export const Uint = {
    *
    * const power = Uint.pow(base, exponent);
    *
-   * assert(power === 32);
+   * assert.isTrue(power === 32);
    * ```
    *
    * @param a The base Uint.
@@ -204,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.
@@ -221,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.
@@ -238,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.
@@ -255,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

@@ -60,35 +60,35 @@ describe('Uint test', () => {
 
   describe(isUint, () => {
     test('correctly identifies unsigned integers', () => {
-      expect(isUint(0)).toBe(true);
+      assert.isTrue(isUint(0));
 
-      expect(isUint(1)).toBe(true);
+      assert.isTrue(isUint(1));
 
-      expect(isUint(42)).toBe(true);
+      assert.isTrue(isUint(42));
 
-      expect(isUint(100)).toBe(true);
+      assert.isTrue(isUint(100));
 
-      expect(isUint(Number.MAX_SAFE_INTEGER)).toBe(true);
+      assert.isTrue(isUint(Number.MAX_SAFE_INTEGER));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isUint(-1)).toBe(false);
+      assert.isFalse(isUint(-1));
 
-      expect(isUint(-42)).toBe(false);
+      assert.isFalse(isUint(-42));
 
-      expect(isUint(Number.MIN_SAFE_INTEGER)).toBe(false);
+      assert.isFalse(isUint(Number.MIN_SAFE_INTEGER));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isUint(Number.NaN)).toBe(false);
+      assert.isFalse(isUint(Number.NaN));
 
-      expect(isUint(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isUint(Number.POSITIVE_INFINITY));
 
-      expect(isUint(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isUint(Number.NEGATIVE_INFINITY));
 
-      expect(isUint(1.2)).toBe(false);
+      assert.isFalse(isUint(1.2));
 
-      expect(isUint(-3.4)).toBe(false);
+      assert.isFalse(isUint(-3.4));
     });
   });
 
@@ -175,9 +175,9 @@ describe('Uint test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(Uint.is(result)).toBe(true);
+        assert.isTrue(Uint.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThanOrEqual(0);
       }

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

@@ -65,37 +65,37 @@ describe('Uint16 test', () => {
 
   describe(isUint16, () => {
     test('correctly identifies uint16 values', () => {
-      expect(isUint16(0)).toBe(true);
+      assert.isTrue(isUint16(0));
 
-      expect(isUint16(1)).toBe(true);
+      assert.isTrue(isUint16(1));
 
-      expect(isUint16(65_535)).toBe(true);
+      assert.isTrue(isUint16(65_535));
 
-      expect(isUint16(32_768)).toBe(true);
+      assert.isTrue(isUint16(32_768));
     });
 
     test('correctly identifies values outside uint16 range', () => {
-      expect(isUint16(65_536)).toBe(false);
+      assert.isFalse(isUint16(65_536));
 
-      expect(isUint16(100_000)).toBe(false);
+      assert.isFalse(isUint16(100_000));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isUint16(-1)).toBe(false);
+      assert.isFalse(isUint16(-1));
 
-      expect(isUint16(-42)).toBe(false);
+      assert.isFalse(isUint16(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isUint16(Number.NaN)).toBe(false);
+      assert.isFalse(isUint16(Number.NaN));
 
-      expect(isUint16(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isUint16(Number.POSITIVE_INFINITY));
 
-      expect(isUint16(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isUint16(Number.NEGATIVE_INFINITY));
 
-      expect(isUint16(1.2)).toBe(false);
+      assert.isFalse(isUint16(1.2));
 
-      expect(isUint16(-3.4)).toBe(false);
+      assert.isFalse(isUint16(-3.4));
     });
   });
 
@@ -188,9 +188,9 @@ describe('Uint16 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(Uint16.is(result)).toBe(true);
+        assert.isTrue(Uint16.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThanOrEqual(0);
       }

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

@@ -65,37 +65,37 @@ describe('Uint32 test', () => {
 
   describe(isUint32, () => {
     test('correctly identifies uint32 values', () => {
-      expect(isUint32(0)).toBe(true);
+      assert.isTrue(isUint32(0));
 
-      expect(isUint32(1)).toBe(true);
+      assert.isTrue(isUint32(1));
 
-      expect(isUint32(4_294_967_295)).toBe(true);
+      assert.isTrue(isUint32(4_294_967_295));
 
-      expect(isUint32(2_147_483_648)).toBe(true);
+      assert.isTrue(isUint32(2_147_483_648));
     });
 
     test('correctly identifies values outside uint32 range', () => {
-      expect(isUint32(4_294_967_296)).toBe(false);
+      assert.isFalse(isUint32(4_294_967_296));
 
-      expect(isUint32(10_000_000_000)).toBe(false);
+      assert.isFalse(isUint32(10_000_000_000));
     });
 
     test('correctly identifies negative integers', () => {
-      expect(isUint32(-1)).toBe(false);
+      assert.isFalse(isUint32(-1));
 
-      expect(isUint32(-42)).toBe(false);
+      assert.isFalse(isUint32(-42));
     });
 
     test('correctly identifies non-integers', () => {
-      expect(isUint32(Number.NaN)).toBe(false);
+      assert.isFalse(isUint32(Number.NaN));
 
-      expect(isUint32(Number.POSITIVE_INFINITY)).toBe(false);
+      assert.isFalse(isUint32(Number.POSITIVE_INFINITY));
 
-      expect(isUint32(Number.NEGATIVE_INFINITY)).toBe(false);
+      assert.isFalse(isUint32(Number.NEGATIVE_INFINITY));
 
-      expect(isUint32(1.2)).toBe(false);
+      assert.isFalse(isUint32(1.2));
 
-      expect(isUint32(-3.4)).toBe(false);
+      assert.isFalse(isUint32(-3.4));
     });
   });
 
@@ -188,9 +188,9 @@ describe('Uint32 test', () => {
 
         expect(result).toBeLessThanOrEqual(max);
 
-        expect(Uint32.is(result)).toBe(true);
+        assert.isTrue(Uint32.is(result));
 
-        expect(Number.isInteger(result)).toBe(true);
+        assert.isTrue(Number.isInteger(result));
 
         expect(result).toBeGreaterThanOrEqual(0);
       }

package/src/number/enum/int8.test.mts

@@ -185,7 +185,7 @@ describe('Int8 test', () => {
 
       expect(result).toBeLessThanOrEqual(max);
 
-      expect(Number.isInteger(result)).toBe(true);
+      assert.isTrue(Number.isInteger(result));
     });
   });
 });

package/src/number/enum/uint8.test.mts

@@ -167,7 +167,7 @@ describe('Uint8 test', () => {
 
       expect(result).toBeLessThanOrEqual(max);
 
-      expect(Number.isInteger(result)).toBe(true);
+      assert.isTrue(Number.isInteger(result));
     });
   });
 });