ts-data-forge 5.1.0 → 5.1.1

package/src/number/num.mts

@@ -26,7 +26,7 @@ export namespace Num {
    *
    * const result = Num.from(input);
    *
-   * assert(result === 123.45);
+   * assert.isTrue(result === 123.45);
    * ```
    *
    * @param n The value to convert.
@@ -51,10 +51,10 @@ export namespace Num {
    *   // eslint-disable-next-line total-functions/no-partial-division
    *   const inverted = 1 / value;
    *
-   *   assert(inverted === 0.2);
+   *   assert.isTrue(inverted === 0.2);
    * }
    *
-   * assert.notOk(Num.isNonZero(0));
+   * assert.isFalse(Num.isNonZero(0));
    * ```
    *
    * @template N - The numeric literal type or number type to check
@@ -83,10 +83,10 @@ export namespace Num {
    * if (Num.isNonNegative(candidate)) {
    *   const index: number = candidate;
    *
-   *   assert(index === 10);
+   *   assert.isTrue(index === 10);
    * }
    *
-   * assert.notOk(Num.isNonNegative(-1));
+   * assert.isFalse(Num.isNonNegative(-1));
    * ```
    *
    * @template N - The numeric literal type or number type to check
@@ -111,10 +111,10 @@ export namespace Num {
    * const amount = 42;
    *
    * if (Num.isPositive(amount)) {
-   *   assert.ok(amount > 0);
+   *   assert.isTrue(amount > 0);
    * }
    *
-   * assert.notOk(Num.isPositive(0));
+   * assert.isFalse(Num.isPositive(0));
    * ```
    *
    * @template N - The numeric literal type or number type to check
@@ -135,9 +135,9 @@ export namespace Num {
    * ```ts
    * const isGrade = Num.isInRange(0, 100);
    *
-   * assert.ok(isGrade(50));
+   * assert.isTrue(isGrade(50));
    *
-   * assert.notOk(isGrade(100));
+   * assert.isFalse(isGrade(100));
    * ```
    *
    * @param lowerBound The lower bound (inclusive).
@@ -159,9 +159,9 @@ export namespace Num {
    * ```ts
    * const isPercentage = Num.isInRangeInclusive(0, 100);
    *
-   * assert.ok(isPercentage(100));
+   * assert.isTrue(isPercentage(100));
    *
-   * assert.notOk(isPercentage(-1));
+   * assert.isFalse(isPercentage(-1));
    * ```
    *
    * @param lowerBound The lower bound (inclusive).
@@ -219,11 +219,11 @@ export namespace Num {
    * ```ts
    * const indexGuard = Num.isUintInRange(0, 5);
    *
-   * assert.ok(indexGuard(3));
+   * assert.isTrue(indexGuard(3));
    *
-   * assert.notOk(indexGuard(5));
+   * assert.isFalse(indexGuard(5));
    *
-   * assert.notOk(indexGuard(-1));
+   * assert.isFalse(indexGuard(-1));
    * ```
    *
    * @template L - The lower bound as a SmallUint literal type
@@ -255,9 +255,9 @@ export namespace Num {
    * ```ts
    * const inclusiveGuard = Num.isUintInRangeInclusive(0, 5);
    *
-   * assert.ok(inclusiveGuard(5));
+   * assert.isTrue(inclusiveGuard(5));
    *
-   * assert.notOk(inclusiveGuard(6));
+   * assert.isFalse(inclusiveGuard(6));
    * ```
    *
    * @template L - The lower bound as a SmallUint literal type
@@ -284,15 +284,15 @@ export namespace Num {
    * @example
    *
    * ```ts
-   * assert(Num.clamp(150, 0, 100) === 100);
+   * assert.isTrue(Num.clamp(150, 0, 100) === 100);
    *
-   * assert(Num.clamp(-50, 0, 100) === 0);
+   * assert.isTrue(Num.clamp(-50, 0, 100) === 0);
    *
    * const clampToPercentage = Num.clamp(0, 100);
    *
-   * assert(clampToPercentage(75) === 75);
+   * assert.isTrue(clampToPercentage(75) === 75);
    *
-   * assert(clampToPercentage(150) === 100);
+   * assert.isTrue(clampToPercentage(150) === 100);
    * ```
    */
   export function clamp(

package/src/number/num.test.mts

@@ -93,7 +93,7 @@ describe('Num test', () => {
         expectType<typeof x, number>('=');
       }
 
-      expect(f(x)).toBe(true);
+      assert.isTrue(f(x));
     });
 
     test('falsy case', () => {
@@ -107,7 +107,7 @@ describe('Num test', () => {
         expectType<typeof x, number>('=');
       }
 
-      expect(f(x)).toBe(false);
+      assert.isFalse(f(x));
     });
   });
 
@@ -135,15 +135,15 @@ describe('Num test', () => {
     test('checks range (lower inclusive, upper exclusive)', () => {
       const inRange = Num.isInRange(0, 10);
 
-      expect(inRange(5)).toBe(true);
+      assert.isTrue(inRange(5));
 
-      expect(inRange(0)).toBe(true); // inclusive lower bound
+      assert.isTrue(inRange(0)); // inclusive lower bound
 
-      expect(inRange(10)).toBe(false); // exclusive upper bound
+      assert.isFalse(inRange(10)); // exclusive upper bound
 
-      expect(inRange(-1)).toBe(false);
+      assert.isFalse(inRange(-1));
 
-      expect(inRange(15)).toBe(false);
+      assert.isFalse(inRange(15));
     });
   });
 
@@ -151,15 +151,15 @@ describe('Num test', () => {
     test('checks range (inclusive)', () => {
       const inRange = Num.isInRangeInclusive(0, 10);
 
-      expect(inRange(5)).toBe(true);
+      assert.isTrue(inRange(5));
 
-      expect(inRange(0)).toBe(true); // inclusive
+      assert.isTrue(inRange(0)); // inclusive
 
-      expect(inRange(10)).toBe(true); // inclusive
+      assert.isTrue(inRange(10)); // inclusive
 
-      expect(inRange(-1)).toBe(false);
+      assert.isFalse(inRange(-1));
 
-      expect(inRange(15)).toBe(false);
+      assert.isFalse(inRange(15));
     });
   });
 
@@ -167,13 +167,13 @@ describe('Num test', () => {
     test('checks uint range (lower inclusive, upper exclusive)', () => {
       const inRange = Num.isUintInRange(0, 5);
 
-      expect(inRange(2)).toBe(true);
+      assert.isTrue(inRange(2));
 
-      expect(inRange(0)).toBe(true); // inclusive lower bound
+      assert.isTrue(inRange(0)); // inclusive lower bound
 
-      expect(inRange(5)).toBe(false); // exclusive upper bound
+      assert.isFalse(inRange(5)); // exclusive upper bound
 
-      expect(inRange(-1)).toBe(false);
+      assert.isFalse(inRange(-1));
     });
   });
 
@@ -185,33 +185,33 @@ describe('Num test', () => {
         expectType<typeof x, NonZeroNumber>('=');
       }
 
-      expect(Num.isNonZero(5)).toBe(true);
+      assert.isTrue(Num.isNonZero(5));
 
-      expect(Num.isNonZero(-3)).toBe(true);
+      assert.isTrue(Num.isNonZero(-3));
 
-      expect(Num.isNonZero(0)).toBe(false);
+      assert.isFalse(Num.isNonZero(0));
     });
   });
 
   describe('isNonNegative', () => {
     test('type guard for non-negative numbers', () => {
-      expect(Num.isNonNegative(5)).toBe(true);
+      assert.isTrue(Num.isNonNegative(5));
 
-      expect(Num.isNonNegative(0)).toBe(true);
+      assert.isTrue(Num.isNonNegative(0));
 
-      expect(Num.isNonNegative(-1)).toBe(false);
+      assert.isFalse(Num.isNonNegative(-1));
     });
   });
 
   describe('isPositive', () => {
     test('type guard for positive numbers', () => {
-      expect(Num.isPositive(5)).toBe(true);
+      assert.isTrue(Num.isPositive(5));
 
-      expect(Num.isPositive(0.1)).toBe(true);
+      assert.isTrue(Num.isPositive(0.1));
 
-      expect(Num.isPositive(0)).toBe(false);
+      assert.isFalse(Num.isPositive(0));
 
-      expect(Num.isPositive(-1)).toBe(false);
+      assert.isFalse(Num.isPositive(-1));
     });
   });
 

package/src/number/refined-number-utils.mts

@@ -224,8 +224,8 @@ export namespace TsDataForgeInternals {
       ElementType extends Int,
       MIN_VALUE extends number,
       MAX_VALUE extends number,
-      ElementTypeWithSmallInt extends
-        WithSmallInt<ElementType> = WithSmallInt<ElementType>,
+      ElementTypeWithSmallInt extends WithSmallInt<ElementType> =
+        WithSmallInt<ElementType>,
     > = Readonly<{
       MIN_VALUE: MIN_VALUE;
       MAX_VALUE: MAX_VALUE;
@@ -324,17 +324,17 @@ export namespace TsDataForgeInternals {
      *
      * const randomValue = intOps.random();
      *
-     * assert(sum === 10);
+     * assert.isTrue(sum === 10);
      *
-     * assert(difference === 2);
+     * assert.isTrue(difference === 2);
      *
-     * assert(product === 24);
+     * assert.isTrue(product === 24);
      *
-     * assert(quotient === 3);
+     * assert.isTrue(quotient === 3);
      *
-     * assert(roundedClamp === 2);
+     * assert.isTrue(roundedClamp === 2);
      *
-     * assert.ok(Number.isSafeInteger(randomValue));
+     * assert.isTrue(Number.isSafeInteger(randomValue));
      * ```
      *
      * @template ElementType - The integer branded type
@@ -552,15 +552,15 @@ export namespace TsDataForgeInternals {
      *
      * const nonZeroRandom = floatOps.randomNonZero();
      *
-     * assert(sum === 50);
+     * assert.isTrue(sum === 50);
      *
-     * assert(ratio === 5);
+     * assert.isTrue(ratio === 5);
      *
-     * assert.ok(clamped >= Number.MIN_VALUE);
+     * assert.isTrue(clamped >= Number.MIN_VALUE);
      *
-     * assert.ok(boundedRandom >= 10 && boundedRandom <= 20);
+     * assert.isTrue(boundedRandom >= 10 && boundedRandom <= 20);
      *
-     * assert.ok(nonZeroRandom > 0);
+     * assert.isTrue(nonZeroRandom > 0);
      * ```
      *
      * @template ElementType - The floating-point branded type

package/src/object/object.mts

@@ -22,9 +22,9 @@ export namespace Obj {
    *
    * const obj3 = { name: 'Alice', age: 31 };
    *
-   * assert.ok(Obj.shallowEq(obj1, obj2));
+   * assert.isTrue(Obj.shallowEq(obj1, obj2));
    *
-   * assert.notOk(Obj.shallowEq(obj1, obj3));
+   * assert.isFalse(Obj.shallowEq(obj1, obj3));
    *
    * // Custom equality function
    * const obj4 = { value: 1 };
@@ -39,7 +39,7 @@ export namespace Obj {
    *   return Object.is(a, b);
    * };
    *
-   * assert.ok(Obj.shallowEq(obj4, obj5, closeEnough));
+   * assert.isTrue(Obj.shallowEq(obj4, obj5, closeEnough));
    * ```
    *
    * @param a - The first record to compare
@@ -370,6 +370,7 @@ export namespace Obj {
         : TypeEq<Entries['length'], 0> extends true
           ? K
           : ValuesOfEntriesImpl<
+              // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
               K | Entries[0][1],
               List.Tail<Entries>,
               Decrement<RemainingNumRecursions>

package/src/object/object.test.mts

@@ -4,27 +4,27 @@ import { Obj } from './object.mjs';
 
 describe('shallowEq', () => {
   test('truthy case 1', () => {
-    expect(Obj.shallowEq({ x: 0 }, { x: 0 })).toBe(true);
+    assert.isTrue(Obj.shallowEq({ x: 0 }, { x: 0 }));
   });
 
   test('truthy case 2', () => {
-    expect(Obj.shallowEq({}, {})).toBe(true);
+    assert.isTrue(Obj.shallowEq({}, {}));
   });
 
   test('falsy case 1', () => {
-    expect(Obj.shallowEq({ x: 0 }, { x: 0, y: 0 })).toBe(false);
+    assert.isFalse(Obj.shallowEq({ x: 0 }, { x: 0, y: 0 }));
   });
 
   test('falsy case 2', () => {
-    expect(Obj.shallowEq({ x: 0, y: 0 }, { x: 0 })).toBe(false);
+    assert.isFalse(Obj.shallowEq({ x: 0, y: 0 }, { x: 0 }));
   });
 
   test('falsy case 3', () => {
-    expect(Obj.shallowEq({ x: 0 }, { y: 0 })).toBe(false);
+    assert.isFalse(Obj.shallowEq({ x: 0 }, { y: 0 }));
   });
 
   test('falsy case 4', () => {
-    expect(Obj.shallowEq({ x: [] }, { y: 0 })).toBe(false);
+    assert.isFalse(Obj.shallowEq({ x: [] }, { y: 0 }));
   });
 });
 

package/src/others/cast-mutable.test.mts

@@ -67,7 +67,7 @@ describe(castDeepMutable, () => {
       };
     };
 
-    expectType<typeof mut_state, MutableState>('~=');
+    expectType<typeof mut_state, MutableState>('=');
 
     mut_state.user.profile.tags.push('editor');
 

package/src/others/cast-readonly.test.mts

@@ -28,7 +28,7 @@ describe(castReadonly, () => {
 
     expect(readonly.value).toBe(42);
 
-    expect(Object.is(readonly, original)).toBe(true);
+    assert.isTrue(Object.is(readonly, original));
   });
 
   test('castReadonly should work with primitives', () => {
@@ -36,7 +36,7 @@ describe(castReadonly, () => {
 
     expect(castReadonly('hello')).toBe('hello');
 
-    expect(castReadonly(true)).toBe(true);
+    assert.isTrue(castReadonly(true));
   });
 
   test('castReadonly should work with null and undefined', () => {
@@ -75,7 +75,7 @@ describe(castDeepReadonly, () => {
 
     expect(readonly.users[0]?.profile.name).toBe('Alice');
 
-    expect(readonly.settings.options.debug).toBe(true);
+    assert.isTrue(readonly.settings.options.debug);
   });
 
   test('should work with arrays of objects', () => {
@@ -98,7 +98,7 @@ describe(castDeepReadonly, () => {
 
     expect(castDeepReadonly('hello')).toBe('hello');
 
-    expect(castDeepReadonly(true)).toBe(true);
+    assert.isTrue(castDeepReadonly(true));
   });
 
   test('castDeepReadonly should work with null and undefined', () => {

package/src/others/if-then.test.mts

@@ -3,16 +3,16 @@ import { ifThen } from './if-then.mjs';
 describe(ifThen, () => {
   test('should implement logical implication truth table', () => {
     // True antecedent, true consequent -> true
-    expect(ifThen(true, true)).toBe(true);
+    assert.isTrue(ifThen(true, true));
 
     // True antecedent, false consequent -> false
-    expect(ifThen(true, false)).toBe(false);
+    assert.isFalse(ifThen(true, false));
 
     // False antecedent, true consequent -> true (vacuously true)
-    expect(ifThen(false, true)).toBe(true);
+    assert.isTrue(ifThen(false, true));
 
     // False antecedent, false consequent -> true (vacuously true)
-    expect(ifThen(false, false)).toBe(true);
+    assert.isTrue(ifThen(false, false));
   });
 
   test('should work for validation logic', () => {
@@ -22,13 +22,13 @@ describe(ifThen, () => {
       return ifThen(isRequired, hasValue);
     };
 
-    expect(validateField('hello', true)).toBe(true); // required and has value
+    assert.isTrue(validateField('hello', true)); // required and has value
 
-    expect(validateField('', true)).toBe(false); // required but no value
+    assert.isFalse(validateField('', true)); // required but no value
 
-    expect(validateField('', false)).toBe(true); // not required, so valid
+    assert.isTrue(validateField('', false)); // not required, so valid
 
-    expect(validateField('hello', false)).toBe(true); // not required, has value
+    assert.isTrue(validateField('hello', false)); // not required, has value
   });
 
   test('should work for access control logic', () => {
@@ -39,13 +39,13 @@ describe(ifThen, () => {
       // If admin, then must have permission
       ifThen(isAdmin, hasPermission);
 
-    expect(checkPermission(true, true)).toBe(true); // admin with permission
+    assert.isTrue(checkPermission(true, true)); // admin with permission
 
-    expect(checkPermission(true, false)).toBe(false); // admin without permission
+    assert.isFalse(checkPermission(true, false)); // admin without permission
 
-    expect(checkPermission(false, true)).toBe(true); // non-admin with permission
+    assert.isTrue(checkPermission(false, true)); // non-admin with permission
 
-    expect(checkPermission(false, false)).toBe(true); // non-admin without permission
+    assert.isTrue(checkPermission(false, false)); // non-admin without permission
   });
 
   test('should work for contract validation', () => {
@@ -56,26 +56,26 @@ describe(ifThen, () => {
       // If premium, then all premium features must be enabled
       ifThen(isPremium, hasAllFeatures);
 
-    expect(validateSubscription(true, true)).toBe(true); // premium with all features
+    assert.isTrue(validateSubscription(true, true)); // premium with all features
 
-    expect(validateSubscription(true, false)).toBe(false); // premium without all features
+    assert.isFalse(validateSubscription(true, false)); // premium without all features
 
-    expect(validateSubscription(false, true)).toBe(true); // non-premium with features
+    assert.isTrue(validateSubscription(false, true)); // non-premium with features
 
-    expect(validateSubscription(false, false)).toBe(true); // non-premium without features
+    assert.isTrue(validateSubscription(false, false)); // non-premium without features
   });
 
   test('should work in chaining scenarios', () => {
     const validateChain = (a: boolean, b: boolean, c: boolean): boolean =>
       ifThen(a, b) && ifThen(b, c);
 
-    expect(validateChain(true, true, true)).toBe(true); // valid chain
+    assert.isTrue(validateChain(true, true, true)); // valid chain
 
-    expect(validateChain(true, false, true)).toBe(false); // breaks at first implication
+    assert.isFalse(validateChain(true, false, true)); // breaks at first implication
 
-    expect(validateChain(false, false, false)).toBe(true); // vacuously true chain
+    assert.isTrue(validateChain(false, false, false)); // vacuously true chain
 
-    expect(validateChain(true, true, false)).toBe(false); // breaks at second implication
+    assert.isFalse(validateChain(true, true, false)); // breaks at second implication
   });
 
   test('should work with negation patterns', () => {
@@ -83,12 +83,12 @@ describe(ifThen, () => {
       // "If not expired then valid" is equivalent to "expired OR valid"
       ifThen(!isExpired, isValid);
 
-    expect(checkExpiredLogic(false, true)).toBe(true); // not expired and valid
+    assert.isTrue(checkExpiredLogic(false, true)); // not expired and valid
 
-    expect(checkExpiredLogic(false, false)).toBe(false); // not expired but invalid
+    assert.isFalse(checkExpiredLogic(false, false)); // not expired but invalid
 
-    expect(checkExpiredLogic(true, true)).toBe(true); // expired but valid (vacuous)
+    assert.isTrue(checkExpiredLogic(true, true)); // expired but valid (vacuous)
 
-    expect(checkExpiredLogic(true, false)).toBe(true); // expired and invalid (vacuous)
+    assert.isTrue(checkExpiredLogic(true, false)); // expired and invalid (vacuous)
   });
 });

package/src/others/tuple.mts

@@ -35,11 +35,11 @@
  *
  * expectType<typeof rgb, readonly [255, 128, 0]>('=');
  *
- * assert(rgb[0] === 255);
+ * assert.isTrue(rgb[0] === 255);
  *
- * assert(rgb[1] === 128);
+ * assert.isTrue(rgb[1] === 128);
  *
- * assert(rgb[2] === 0);
+ * assert.isTrue(rgb[2] === 0);
  * ```
  *
  * @template T - A tuple type with literal types inferred from the arguments

package/src/promise/promise.mts

@@ -18,10 +18,10 @@ import { Result } from '../functional/index.mjs';
  *
  * const successResult = await successPromise;
  *
- * assert.ok(Result.isOk(successResult));
+ * assert.isTrue(Result.isOk(successResult));
  *
  * if (Result.isOk(successResult)) {
- *   assert(successResult.value === 42);
+ *   assert.isTrue(successResult.value === 42);
  * }
  *
  * // Create a promise that rejects with an error
@@ -33,10 +33,10 @@ import { Result } from '../functional/index.mjs';
  *
  * const errorResult = await errorPromise;
  *
- * assert.ok(Result.isErr(errorResult));
+ * assert.isTrue(Result.isErr(errorResult));
  *
  * if (Result.isErr(errorResult)) {
- *   assert(errorResult.value === 'Something went wrong');
+ *   assert.isTrue(errorResult.value === 'Something went wrong');
  * }
  * ```
  *

package/src/promise/promise.test.mts

@@ -12,11 +12,9 @@ describe(createPromise, () => {
 
     const result = await resultPromise;
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toBe(42);
-    }
+    expect(result.value).toBe(42);
   });
 
   test('resolves to Result.err when executor rejects', async () => {
@@ -26,11 +24,9 @@ describe(createPromise, () => {
       reject(rejection);
     });
 
-    expect(Result.isErr(result)).toBe(true);
+    assert.isTrue(Result.isErr(result));
 
-    if (Result.isErr(result)) {
-      expect(result.value).toBe(rejection);
-    }
+    expect(result.value).toBe(rejection);
   });
 
   test('supports non-Error rejection reasons', async () => {
@@ -38,12 +34,10 @@ describe(createPromise, () => {
       reject('failure');
     });
 
-    expect(Result.isErr(result)).toBe(true);
+    assert.isTrue(Result.isErr(result));
 
-    if (Result.isErr(result)) {
-      expectType<typeof result.value, string>('=');
+    expectType<typeof result.value, string>('=');
 
-      expect(result.value).toBe('failure');
-    }
+    expect(result.value).toBe('failure');
   });
 });