ts-data-forge 5.0.1 → 5.1.1

package/src/number/num.test.mts

@@ -16,16 +16,22 @@ const testClamp = (
 describe('Num test', () => {
   describe('clamp', () => {
     testClamp([0, 2], 2.3, 2);
+
     testClamp([0, 2], -0.5, 0);
+
     testClamp([0, 2], 1.5, 1.5);
+
     testClamp([0, 2], Number.NaN, 0);
 
     test('should support regular usage with three parameters', () => {
       expectTypeOf(Num.clamp(15, 0, 10)).toEqualTypeOf<number>();
 
       expect(Num.clamp(15, 0, 10)).toBe(10);
+
       expect(Num.clamp(-5, 0, 10)).toBe(0);
+
       expect(Num.clamp(5, 0, 10)).toBe(5);
+
       expect(Num.clamp(Number.NaN, 0, 10)).toBe(0);
     });
 
@@ -52,19 +58,25 @@ describe('Num test', () => {
 
       // Invalid (non-finite) values return the lower bound
       expect(clampTo5_15(Number.POSITIVE_INFINITY)).toBe(5);
+
       expect(clampTo5_15(Number.NEGATIVE_INFINITY)).toBe(5);
+
       expect(clampTo5_15(Number.NaN)).toBe(5);
     });
 
     test('should work with negative ranges', () => {
       expect(Num.clamp(-15, -10, -5)).toBe(-10);
+
       expect(Num.clamp(-7, -10, -5)).toBe(-7);
+
       expect(Num.clamp(0, -10, -5)).toBe(-5);
 
       const clampNegative = Num.clamp(-10, -5);
 
       expect(clampNegative(-15)).toBe(-10);
+
       expect(clampNegative(-7)).toBe(-7);
+
       expect(clampNegative(0)).toBe(-5);
     });
   });
@@ -72,40 +84,49 @@ describe('Num test', () => {
   describe('isUintInRangeInclusive', () => {
     test('truthy case', () => {
       const f = Num.isUintInRangeInclusive(0, 4);
+
       const x: number = 2;
+
       if (f(x)) {
         expectType<typeof x, 0 | 1 | 2 | 3 | 4>('=');
       } else {
         expectType<typeof x, number>('=');
       }
 
-      expect(f(x)).toBe(true);
+      assert.isTrue(f(x));
     });
 
     test('falsy case', () => {
       const f = Num.isUintInRangeInclusive(0, 4);
+
       const x: number = 100;
+
       if (f(x)) {
         expectType<typeof x, 0 | 1 | 2 | 3 | 4>('=');
       } else {
         expectType<typeof x, number>('=');
       }
 
-      expect(f(x)).toBe(false);
+      assert.isFalse(f(x));
     });
   });
 
   describe('from', () => {
     test('converts string to number', () => {
       expect(Num.from('123')).toBe(123);
+
       expect(Num.from('123.45')).toBe(123.45);
+
       expect(Num.from('-42')).toBe(-42);
     });
 
     test('handles edge cases', () => {
       expect(Num.from('')).toBe(0);
+
       expect(Num.from('abc')).toBeNaN();
+
       expect(Num.from(true)).toBe(1);
+
       expect(Num.from(false)).toBe(0);
     });
   });
@@ -114,11 +135,15 @@ describe('Num test', () => {
     test('checks range (lower inclusive, upper exclusive)', () => {
       const inRange = Num.isInRange(0, 10);
 
-      expect(inRange(5)).toBe(true);
-      expect(inRange(0)).toBe(true); // inclusive lower bound
-      expect(inRange(10)).toBe(false); // exclusive upper bound
-      expect(inRange(-1)).toBe(false);
-      expect(inRange(15)).toBe(false);
+      assert.isTrue(inRange(5));
+
+      assert.isTrue(inRange(0)); // inclusive lower bound
+
+      assert.isFalse(inRange(10)); // exclusive upper bound
+
+      assert.isFalse(inRange(-1));
+
+      assert.isFalse(inRange(15));
     });
   });
 
@@ -126,11 +151,15 @@ describe('Num test', () => {
     test('checks range (inclusive)', () => {
       const inRange = Num.isInRangeInclusive(0, 10);
 
-      expect(inRange(5)).toBe(true);
-      expect(inRange(0)).toBe(true); // inclusive
-      expect(inRange(10)).toBe(true); // inclusive
-      expect(inRange(-1)).toBe(false);
-      expect(inRange(15)).toBe(false);
+      assert.isTrue(inRange(5));
+
+      assert.isTrue(inRange(0)); // inclusive
+
+      assert.isTrue(inRange(10)); // inclusive
+
+      assert.isFalse(inRange(-1));
+
+      assert.isFalse(inRange(15));
     });
   });
 
@@ -138,47 +167,60 @@ describe('Num test', () => {
     test('checks uint range (lower inclusive, upper exclusive)', () => {
       const inRange = Num.isUintInRange(0, 5);
 
-      expect(inRange(2)).toBe(true);
-      expect(inRange(0)).toBe(true); // inclusive lower bound
-      expect(inRange(5)).toBe(false); // exclusive upper bound
-      expect(inRange(-1)).toBe(false);
+      assert.isTrue(inRange(2));
+
+      assert.isTrue(inRange(0)); // inclusive lower bound
+
+      assert.isFalse(inRange(5)); // exclusive upper bound
+
+      assert.isFalse(inRange(-1));
     });
   });
 
   describe('isNonZero', () => {
     test('type guard for non-zero numbers', () => {
       const x: number = 5;
+
       if (Num.isNonZero(x)) {
         expectType<typeof x, NonZeroNumber>('=');
       }
 
-      expect(Num.isNonZero(5)).toBe(true);
-      expect(Num.isNonZero(-3)).toBe(true);
-      expect(Num.isNonZero(0)).toBe(false);
+      assert.isTrue(Num.isNonZero(5));
+
+      assert.isTrue(Num.isNonZero(-3));
+
+      assert.isFalse(Num.isNonZero(0));
     });
   });
 
   describe('isNonNegative', () => {
     test('type guard for non-negative numbers', () => {
-      expect(Num.isNonNegative(5)).toBe(true);
-      expect(Num.isNonNegative(0)).toBe(true);
-      expect(Num.isNonNegative(-1)).toBe(false);
+      assert.isTrue(Num.isNonNegative(5));
+
+      assert.isTrue(Num.isNonNegative(0));
+
+      assert.isFalse(Num.isNonNegative(-1));
     });
   });
 
   describe('isPositive', () => {
     test('type guard for positive numbers', () => {
-      expect(Num.isPositive(5)).toBe(true);
-      expect(Num.isPositive(0.1)).toBe(true);
-      expect(Num.isPositive(0)).toBe(false);
-      expect(Num.isPositive(-1)).toBe(false);
+      assert.isTrue(Num.isPositive(5));
+
+      assert.isTrue(Num.isPositive(0.1));
+
+      assert.isFalse(Num.isPositive(0));
+
+      assert.isFalse(Num.isPositive(-1));
     });
   });
 
   describe('div', () => {
     test('basic division', () => {
       expect(Num.div(10, 2)).toBe(5);
+
       expect(Num.div(7, 3)).toBe(7 / 3);
+
       expect(Num.div(-10, 2)).toBe(-5);
     });
   });
@@ -186,8 +228,11 @@ describe('Num test', () => {
   describe('divInt', () => {
     test('integer division (floor)', () => {
       expect(Num.divInt(10, 3)).toBe(3);
+
       expect(Num.divInt(7, 2)).toBe(3);
+
       expect(Num.divInt(-7, 2)).toBe(-4); // floor division
+
       expect(Num.divInt(10.7, asNonZeroFiniteNumber(3.2))).toBe(3); // floors both operands
     });
   });
@@ -195,8 +240,11 @@ describe('Num test', () => {
   describe('roundAt', () => {
     test('rounds to specified decimal places', () => {
       expect(Num.roundAt(3.141_59, 2)).toBe(3.14);
+
       expect(Num.roundAt(3.141_59, 3)).toBe(3.142);
+
       expect(Num.roundAt(2.555, 2)).toBe(2.56);
+
       expect(Num.roundAt(123.456, 1)).toBe(123.5);
     });
   });
@@ -204,9 +252,13 @@ describe('Num test', () => {
   describe('roundToInt', () => {
     test('rounds to nearest integer', () => {
       expect(Num.roundToInt(3.4)).toBe(3);
+
       expect(Num.roundToInt(3.6)).toBe(4);
+
       expect(Num.roundToInt(2.5)).toBe(3);
+
       expect(Num.roundToInt(-2.3)).toBe(-1); // bitwise behavior: -2.3 + 0.5 = -1.8, then floor with bitwise OR
+
       expect(Num.roundToInt(-2.7)).toBe(-2); // bitwise behavior: -2.7 + 0.5 = -2.2, then floor with bitwise OR
     });
   });
@@ -216,16 +268,19 @@ describe('Num test', () => {
       const round2 = Num.round(2);
 
       expect(round2(3.141_59)).toBe(3.14);
+
       expect(round2(2.556)).toBe(2.56);
 
       const round1 = Num.round(1);
 
       expect(round1(3.141_59)).toBe(3.1);
+
       expect(round1(2.56)).toBe(2.6);
 
       const round3 = Num.round(3);
 
       expect(round3(3.1416)).toBe(3.142);
+
       expect(round3(2.7182)).toBe(2.718);
     });
   });
@@ -233,8 +288,11 @@ describe('Num test', () => {
   describe('mapNaN2Undefined', () => {
     test('maps NaN to undefined', () => {
       expect(Num.mapNaN2Undefined(5)).toBe(5);
+
       expect(Num.mapNaN2Undefined(0)).toBe(0);
+
       expect(Num.mapNaN2Undefined(-3.14)).toBe(-3.14);
+
       expect(Num.mapNaN2Undefined(Number.NaN)).toBeUndefined();
     });
   });
@@ -242,7 +300,9 @@ describe('Num test', () => {
   describe('increment', () => {
     test('increments SmallUint values', () => {
       expect(Num.increment(0)).toBe(1);
+
       expect(Num.increment(5)).toBe(6);
+
       expect(Num.increment(38)).toBe(39);
     });
   });
@@ -250,7 +310,9 @@ describe('Num test', () => {
   describe('decrement', () => {
     test('decrements PositiveSmallInt values', () => {
       expect(Num.decrement(1)).toBe(0);
+
       expect(Num.decrement(5)).toBe(4);
+
       expect(Num.decrement(39)).toBe(38);
     });
   });

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

@@ -36,6 +36,7 @@ export namespace TsDataForgeInternals {
         if (!is(a)) {
           throw new TypeError(`Expected ${typeNameInErrorMessage}, got: ${a}`);
         }
+
         return a;
       };
 
@@ -223,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;
@@ -308,20 +309,32 @@ export namespace TsDataForgeInternals {
      * } as const);
      *
      * const six = intOps.castType(6);
+     *
      * const four = intOps.castType(4);
+     *
      * const sum = intOps.add(six, four);
+     *
      * const difference = intOps.sub(six, four);
+     *
      * const product = intOps.mul(six, four);
+     *
      * const quotient = intOps.div(six, intOps.castType(2));
+     *
      * const roundedClamp = intOps.clamp(1.5);
+     *
      * const randomValue = intOps.random();
      *
-     * assert(sum === 10);
-     * assert(difference === 2);
-     * assert(product === 24);
-     * assert(quotient === 3);
-     * assert(roundedClamp === 2);
-     * assert.ok(Number.isSafeInteger(randomValue));
+     * assert.isTrue(sum === 10);
+     *
+     * assert.isTrue(difference === 2);
+     *
+     * assert.isTrue(product === 24);
+     *
+     * assert.isTrue(quotient === 3);
+     *
+     * assert.isTrue(roundedClamp === 2);
+     *
+     * assert.isTrue(Number.isSafeInteger(randomValue));
      * ```
      *
      * @template ElementType - The integer branded type
@@ -437,6 +450,7 @@ export namespace TsDataForgeInternals {
       ): ElementType => {
         while (true) {
           const r = randomImpl(min, max);
+
           if (Num.isNonZero(r)) return clampOrCastFn(r);
         }
       };
@@ -522,21 +536,31 @@ export namespace TsDataForgeInternals {
      * } as const);
      *
      * const fortyTwo = floatOps.castType(42.5);
+     *
      * const seven = floatOps.castType(7.5);
+     *
      * const sum = floatOps.add(fortyTwo, seven);
+     *
      * const ratio = floatOps.div(sum, floatOps.castType(10));
+     *
      * const clamped = floatOps.clamp(0);
+     *
      * const boundedRandom = floatOps.random(
      *   floatOps.castType(10),
      *   floatOps.castType(20),
      * );
+     *
      * const nonZeroRandom = floatOps.randomNonZero();
      *
-     * assert(sum === 50);
-     * assert(ratio === 5);
-     * assert.ok(clamped >= Number.MIN_VALUE);
-     * assert.ok(boundedRandom >= 10 && boundedRandom <= 20);
-     * assert.ok(nonZeroRandom > 0);
+     * assert.isTrue(sum === 50);
+     *
+     * assert.isTrue(ratio === 5);
+     *
+     * assert.isTrue(clamped >= Number.MIN_VALUE);
+     *
+     * assert.isTrue(boundedRandom >= 10 && boundedRandom <= 20);
+     *
+     * assert.isTrue(nonZeroRandom > 0);
      * ```
      *
      * @template ElementType - The floating-point branded type
@@ -624,6 +648,7 @@ export namespace TsDataForgeInternals {
       ): ElementType => {
         while (true) {
           const r = random(min, max);
+
           if (isNonZero(r)) return r;
         }
       };

package/src/object/object.mts

@@ -17,24 +17,29 @@ export namespace Obj {
    *
    * ```ts
    * const obj1 = { name: 'Alice', age: 30 };
+   *
    * const obj2 = { name: 'Alice', age: 30 };
+   *
    * const obj3 = { name: 'Alice', age: 31 };
    *
-   * assert.ok(Obj.shallowEq(obj1, obj2));
-   * assert.notOk(Obj.shallowEq(obj1, obj3));
+   * assert.isTrue(Obj.shallowEq(obj1, obj2));
+   *
+   * assert.isFalse(Obj.shallowEq(obj1, obj3));
    *
    * // Custom equality function
    * const obj4 = { value: 1 };
+   *
    * const obj5 = { value: 1.00001 };
    *
    * const closeEnough = (a: unknown, b: unknown): boolean => {
    *   if (typeof a === 'number' && typeof b === 'number') {
    *     return Math.abs(a - b) < 0.001;
    *   }
+   *
    *   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
@@ -50,6 +55,7 @@ export namespace Obj {
     eq: (x: unknown, y: unknown) => boolean = Object.is,
   ): boolean => {
     const aEntries = Object.entries(a);
+
     const bEntries = Object.entries(b);
 
     if (aEntries.length !== bEntries.length) return false;
@@ -78,6 +84,7 @@ export namespace Obj {
    *
    * // Direct usage
    * const publicInfo = Obj.pick(user, ['id', 'name', 'role']);
+   *
    * assert.deepStrictEqual(publicInfo, {
    *   id: 1,
    *   name: 'Bob',
@@ -122,6 +129,7 @@ export namespace Obj {
     switch (args.length) {
       case 2: {
         const [record, keys] = args;
+
         const keysSet = new Set<keyof R>(keys);
 
         return (
@@ -134,6 +142,7 @@ export namespace Obj {
 
       case 1: {
         const [keys] = args;
+
         return (record: R) => pick(record, keys);
       }
     }
@@ -161,6 +170,7 @@ export namespace Obj {
    *
    * // Direct usage - remove sensitive fields
    * const safeUser = Obj.omit(user, ['password', 'internalNote']);
+   *
    * assert.deepStrictEqual(safeUser, {
    *   id: 1,
    *   name: 'Charlie',
@@ -206,6 +216,7 @@ export namespace Obj {
     switch (args.length) {
       case 2: {
         const [record, keys] = args;
+
         const keysSet = new Set<keyof R>(keys);
 
         return (
@@ -218,12 +229,14 @@ export namespace Obj {
 
       case 1: {
         const [keys] = args;
+
         return <R2 extends UnknownRecord>(record: R2) => {
           // eslint-disable-next-line total-functions/no-unsafe-type-assertion
           const result = omit(record, keys as readonly (keyof R2)[]) as Omit<
             R2,
             ArrayElement<Keys>
           >;
+
           return result;
         };
       }
@@ -253,6 +266,7 @@ export namespace Obj {
    * ] as const;
    *
    * const obj1 = Obj.fromEntries(entries1);
+   *
    * assert.deepStrictEqual(obj1, {
    *   name: 'David',
    *   age: 25,
@@ -266,6 +280,7 @@ export namespace Obj {
    * ];
    *
    * const obj2 = Obj.fromEntries(dynamicEntries);
+   *
    * assert.deepStrictEqual(obj2, { x: 10, y: 20 });
    * ```
    *
@@ -355,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 }));
   });
 });
 
@@ -38,6 +38,7 @@ describe('pick', () => {
 
   test('pick should support curried form', () => {
     const pickAB = Obj.pick(['a', 'b']);
+
     const result = pickAB({ a: 1, b: 2, c: 3, d: 4 });
 
     assert.deepStrictEqual(result, { a: 1, b: 2 });
@@ -45,6 +46,7 @@ describe('pick', () => {
 
   test('pick should work with pipe when curried', () => {
     const pickIdAndName = Obj.pick(['id', 'name']);
+
     const user = { id: 1, name: 'Alice', email: 'alice@example.com', age: 30 };
 
     const result = pipe(user).map(pickIdAndName).value;
@@ -54,6 +56,7 @@ describe('pick', () => {
 
   test('pick should handle empty keys in curried form', () => {
     const pickNone = Obj.pick([]);
+
     const result = pickNone({ a: 1, b: 2 });
 
     assert.deepStrictEqual(result, {});
@@ -61,6 +64,7 @@ describe('pick', () => {
 
   test('pick should work for records that only partially contain the key in curried form', () => {
     const pickVisible = Obj.pick(['name', 'age']);
+
     const user = {
       id: 1,
       name: 'Alice',
@@ -85,6 +89,7 @@ describe('omit', () => {
 
   test('omit should support curried form', () => {
     const omitC = Obj.omit(['c']);
+
     const result = omitC({ a: 1, b: 2, c: 3, d: 4 });
 
     assert.deepStrictEqual(result, { a: 1, b: 2, d: 4 });
@@ -92,6 +97,7 @@ describe('omit', () => {
 
   test('omit should work with pipe when curried', () => {
     const omitSensitive = Obj.omit(['password', 'email']);
+
     const user = {
       id: 1,
       name: 'Alice',
@@ -106,7 +112,9 @@ describe('omit', () => {
 
   test('omit should handle empty keys in curried form', () => {
     const omitNone = Obj.omit([]);
+
     const original = { a: 1, b: 2, c: 3 };
+
     const result = omitNone(original);
 
     assert.deepStrictEqual(result, original);
@@ -114,6 +122,7 @@ describe('omit', () => {
 
   test('should omit multiple keys in curried form', () => {
     const omitBAndD = Obj.omit(['b', 'd']);
+
     const result = omitBAndD({ a: 1, b: 2, c: 3, d: 4, e: 5 });
 
     assert.deepStrictEqual(result, { a: 1, c: 3, e: 5 });
@@ -121,6 +130,7 @@ describe('omit', () => {
 
   test('omit should work for records that only partially contain the key in curried form', () => {
     const omitSensitive = Obj.omit(['password', 'email']);
+
     const user = {
       id: 1,
       name: 'Alice',

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

@@ -4,6 +4,7 @@ import { castDeepMutable, castMutable } from './cast-mutable.mjs';
 describe(castMutable, () => {
   test('should allow mutating arrays that were readonly', () => {
     const readonlyArray: readonly number[] = [1, 2, 3];
+
     const mut_array = castMutable(readonlyArray);
 
     expectType<typeof mut_array, number[]>('=');
@@ -11,6 +12,7 @@ describe(castMutable, () => {
     mut_array.push(4);
 
     assert.deepStrictEqual(mut_array, [1, 2, 3, 4]);
+
     assert.deepStrictEqual(readonlyArray, [1, 2, 3, 4]);
   });
 
@@ -21,12 +23,15 @@ describe(castMutable, () => {
     };
 
     const mut_user = castMutable(readonlyUser);
+
     expectType<typeof mut_user, { name: string; age: number }>('=');
 
     mut_user.age = 31;
+
     mut_user.name = 'Bob';
 
     assert.deepStrictEqual(mut_user, { name: 'Bob', age: 31 });
+
     assert.deepStrictEqual(readonlyUser, { name: 'Bob', age: 31 });
   });
 });
@@ -62,15 +67,17 @@ describe(castDeepMutable, () => {
       };
     };
 
-    expectType<typeof mut_state, MutableState>('~=');
+    expectType<typeof mut_state, MutableState>('=');
 
     mut_state.user.profile.tags.push('editor');
+
     mut_state.user.profile.name = 'Bob';
 
     assert.deepStrictEqual(mut_state.user.profile, {
       name: 'Bob',
       tags: ['admin', 'owner', 'editor'],
     });
+
     assert.deepStrictEqual(readonlyState.user.profile.tags, [
       'admin',
       'owner',