ts-data-forge 5.0.1 → 5.1.1

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

@@ -3,6 +3,7 @@ import { castDeepReadonly, castReadonly } from './cast-readonly.mjs';
 describe(castReadonly, () => {
   test('should cast mutable array to readonly', () => {
     const mutableArr = [1, 2, 3];
+
     const readonlyArr = castReadonly(mutableArr);
 
     expect(readonlyArr).toBe(mutableArr); // Same reference
@@ -12,6 +13,7 @@ describe(castReadonly, () => {
 
   test('should cast mutable object to readonly', () => {
     const mutableObj = { x: 1, y: 2 };
+
     const readonlyObj = castReadonly(mutableObj);
 
     expect(readonlyObj).toBe(mutableObj); // Same reference
@@ -21,20 +23,25 @@ describe(castReadonly, () => {
 
   test('should preserve the runtime value', () => {
     const original = { value: 42 };
+
     const readonly = castReadonly(original);
 
     expect(readonly.value).toBe(42);
-    expect(Object.is(readonly, original)).toBe(true);
+
+    assert.isTrue(Object.is(readonly, original));
   });
 
   test('castReadonly should work with primitives', () => {
     expect(castReadonly(42)).toBe(42);
+
     expect(castReadonly('hello')).toBe('hello');
-    expect(castReadonly(true)).toBe(true);
+
+    assert.isTrue(castReadonly(true));
   });
 
   test('castReadonly should work with null and undefined', () => {
     expect(castReadonly(null)).toBeNull();
+
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
     expect(castReadonly(undefined)).toBeUndefined();
   });
@@ -46,6 +53,7 @@ describe(castDeepReadonly, () => {
       a: { b: [1, 2, 3] },
       c: { d: { e: 'value' } },
     };
+
     const readonlyNested = castDeepReadonly(mutableNested);
 
     expect(readonlyNested).toBe(mutableNested); // Same reference
@@ -60,11 +68,14 @@ describe(castDeepReadonly, () => {
       users: [{ id: 1, profile: { name: 'Alice' } }],
       settings: { theme: 'dark', options: { debug: true } },
     };
+
     const readonly = castDeepReadonly(complex);
 
     expect(readonly).toBe(complex);
+
     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', () => {
@@ -72,21 +83,27 @@ describe(castDeepReadonly, () => {
       { id: 1, meta: { active: true } },
       { id: 2, meta: { active: false } },
     ];
+
     const readonly = castDeepReadonly(data);
 
     expect(readonly).toBe(data);
+
     expect(readonly[0]?.meta.active).toBe(true);
+
     expect(readonly[1]?.meta.active).toBe(false);
   });
 
   test('castDeepReadonly should work with primitives', () => {
     expect(castDeepReadonly(42)).toBe(42);
+
     expect(castDeepReadonly('hello')).toBe('hello');
-    expect(castDeepReadonly(true)).toBe(true);
+
+    assert.isTrue(castDeepReadonly(true));
   });
 
   test('castDeepReadonly should work with null and undefined', () => {
     expect(castDeepReadonly(null)).toBeNull();
+
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
     expect(castDeepReadonly(undefined)).toBeUndefined();
   });

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

@@ -3,28 +3,32 @@ 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', () => {
     const validateField = (value: string, isRequired: boolean): boolean => {
       const hasValue = value.trim().length > 0;
+
       return ifThen(isRequired, hasValue);
     };
 
-    expect(validateField('hello', true)).toBe(true); // required and has value
-    expect(validateField('', true)).toBe(false); // required but no value
-    expect(validateField('', false)).toBe(true); // not required, so valid
-    expect(validateField('hello', false)).toBe(true); // not required, has value
+    assert.isTrue(validateField('hello', true)); // required and has value
+
+    assert.isFalse(validateField('', true)); // required but no value
+
+    assert.isTrue(validateField('', false)); // not required, so valid
+
+    assert.isTrue(validateField('hello', false)); // not required, has value
   });
 
   test('should work for access control logic', () => {
@@ -35,10 +39,13 @@ describe(ifThen, () => {
       // If admin, then must have permission
       ifThen(isAdmin, hasPermission);
 
-    expect(checkPermission(true, true)).toBe(true); // admin with permission
-    expect(checkPermission(true, false)).toBe(false); // admin without permission
-    expect(checkPermission(false, true)).toBe(true); // non-admin with permission
-    expect(checkPermission(false, false)).toBe(true); // non-admin without permission
+    assert.isTrue(checkPermission(true, true)); // admin with permission
+
+    assert.isFalse(checkPermission(true, false)); // admin without permission
+
+    assert.isTrue(checkPermission(false, true)); // non-admin with permission
+
+    assert.isTrue(checkPermission(false, false)); // non-admin without permission
   });
 
   test('should work for contract validation', () => {
@@ -49,20 +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
-    expect(validateSubscription(true, false)).toBe(false); // premium without all features
-    expect(validateSubscription(false, true)).toBe(true); // non-premium with features
-    expect(validateSubscription(false, false)).toBe(true); // non-premium without features
+    assert.isTrue(validateSubscription(true, true)); // premium with all features
+
+    assert.isFalse(validateSubscription(true, false)); // premium without all features
+
+    assert.isTrue(validateSubscription(false, true)); // non-premium with 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
-    expect(validateChain(true, false, true)).toBe(false); // breaks at first implication
-    expect(validateChain(false, false, false)).toBe(true); // vacuously true chain
-    expect(validateChain(true, true, false)).toBe(false); // breaks at second implication
+    assert.isTrue(validateChain(true, true, true)); // valid chain
+
+    assert.isFalse(validateChain(true, false, true)); // breaks at first implication
+
+    assert.isTrue(validateChain(false, false, false)); // vacuously true chain
+
+    assert.isFalse(validateChain(true, true, false)); // breaks at second implication
   });
 
   test('should work with negation patterns', () => {
@@ -70,9 +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
-    expect(checkExpiredLogic(false, false)).toBe(false); // not expired but invalid
-    expect(checkExpiredLogic(true, true)).toBe(true); // expired but valid (vacuous)
-    expect(checkExpiredLogic(true, false)).toBe(true); // expired and invalid (vacuous)
+    assert.isTrue(checkExpiredLogic(false, true)); // not expired and valid
+
+    assert.isFalse(checkExpiredLogic(false, false)); // not expired but invalid
+
+    assert.isTrue(checkExpiredLogic(true, true)); // expired but valid (vacuous)
+
+    assert.isTrue(checkExpiredLogic(true, false)); // expired and invalid (vacuous)
   });
 });

package/src/others/map-nullable.mts

@@ -36,10 +36,13 @@ export function mapNullable<const A, const B>(
   switch (args.length) {
     case 2: {
       const [value, mapFn] = args;
+
       return value == null ? undefined : mapFn(value);
     }
+
     case 1: {
       const [mapFn] = args;
+
       return (value: A | null | undefined) => mapNullable(value, mapFn);
     }
   }

package/src/others/map-nullable.test.mts

@@ -38,6 +38,7 @@ describe(mapNullable, () => {
 
     test('should work with complex transformations', () => {
       const user = { name: 'Alice', age: 30 };
+
       const result = mapNullable(
         user,
         (u) => `${u.name} is ${u.age} years old`,
@@ -48,11 +49,13 @@ describe(mapNullable, () => {
 
     test('should work with nullable object properties', () => {
       const user: { name?: string } = { name: 'Bob' };
+
       const result = mapNullable(user.name, (name) => name.toUpperCase());
 
       expect(result).toBe('BOB');
 
       const userWithoutName: { name?: string } = {};
+
       const resultEmpty = mapNullable(userWithoutName.name, (name) =>
         name.toUpperCase(),
       );
@@ -100,6 +103,7 @@ describe(mapNullable, () => {
       );
 
       const user = { name: 'Charlie', age: 25 };
+
       const result1 = getName(user);
 
       expect(result1).toBe('Charlie');
@@ -111,6 +115,7 @@ describe(mapNullable, () => {
 
     test('should work with pipe composition', () => {
       const toUpperCase = mapNullable((s: string) => s.toUpperCase());
+
       const addGreeting = mapNullable((s: string) => `Hello, ${s}!`);
 
       const result = pipe('world').map(toUpperCase).map(addGreeting).value;
@@ -120,6 +125,7 @@ describe(mapNullable, () => {
 
     test('should handle null values in pipe composition', () => {
       const toUpperCase = mapNullable((s: string) => s.toUpperCase());
+
       const addGreeting = mapNullable((s: string) => `Hello, ${s}!`);
 
       const result = pipe(null as string | null)
@@ -131,7 +137,9 @@ describe(mapNullable, () => {
 
     test('should work with multiple transformations in pipe', () => {
       const toStr = mapNullable((n: number) => n.toString());
+
       const addPrefix = mapNullable((s: string) => `Number: ${s}`);
+
       const toUpperCase = mapNullable((s: string) => s.toUpperCase());
 
       const result = pipe(42 as number | null)
@@ -206,7 +214,9 @@ describe(mapNullable, () => {
       const getValue = (): string | null => 'hello';
 
       const step1 = mapNullable(getValue(), (s) => s.toUpperCase());
+
       const step2 = mapNullable(step1, (s) => s.length);
+
       const step3 = mapNullable(step2, (n) => n * 2);
 
       expect(step3).toBe(10); // 'HELLO'.length * 2 = 5 * 2 = 10
@@ -216,25 +226,33 @@ describe(mapNullable, () => {
       const getValue = (): string | null => null;
 
       const step1 = mapNullable(getValue(), (s) => s.toUpperCase());
+
       const step2 = mapNullable(step1, (s) => s.length);
+
       const step3 = mapNullable(step2, (n) => n * 2);
 
       expect(step1).toBeUndefined();
+
       expect(step2).toBeUndefined();
+
       expect(step3).toBeUndefined();
     });
 
     test('should work with curried functions in chain', () => {
       const toUpperCase = mapNullable((s: string) => s.toUpperCase());
+
       const getLength = mapNullable((s: string) => s.length);
+
       const double = mapNullable((n: number) => n * 2);
 
       const input1 = 'hello';
+
       const result1 = double(getLength(toUpperCase(input1)));
 
       expect(result1).toBe(10);
 
       const input2: string | null = null;
+
       const result2 = double(getLength(toUpperCase(input2)));
 
       expect(result2).toBeUndefined();
@@ -264,9 +282,11 @@ describe(mapNullable, () => {
       const extractUserName = mapNullable(
         (r: ApiResponse) => r.data?.user?.name,
       );
+
       const formatName = mapNullable((name: string) => `Mr. ${name}`);
 
       const userName = extractUserName(response);
+
       const formattedName = formatName(userName);
 
       expect(formattedName).toBe('Mr. John Doe');
@@ -284,15 +304,19 @@ describe(mapNullable, () => {
       };
 
       const extractAge = mapNullable((data: FormDataType) => data.age);
+
       const parseAge = mapNullable((ageStr: string) =>
         Number.parseInt(ageStr, 10),
       );
+
       const validateAge = mapNullable((age: number) =>
         age >= 18 ? age : null,
       );
 
       const extractedAge = extractAge(formData);
+
       const parsedAge = parseAge(extractedAge);
+
       const validAge = validateAge(parsedAge);
 
       expect(validAge).toBe(25);
@@ -310,14 +334,17 @@ describe(mapNullable, () => {
       };
 
       const extractAge = mapNullable((data: FormDataType) => data.age);
+
       const parseAge = mapNullable((ageStr: string) =>
         Number.parseInt(ageStr, 10),
       );
 
       const extractedAge = extractAge(incompleteFormData);
+
       const parsedAge = parseAge(extractedAge);
 
       expect(extractedAge).toBeUndefined();
+
       expect(parsedAge).toBeUndefined();
     });
   });

package/src/others/memoize-function.test.mts

@@ -3,67 +3,85 @@ import { memoizeFunction } from './memoize-function.mjs';
 describe(memoizeFunction, () => {
   test('should cache results for the same arguments', () => {
     const mockFn = vi.fn((x: number) => x * 2);
+
     const memoized = memoizeFunction(mockFn, (x) => x);
 
     // First call
     expect(memoized(5)).toBe(10);
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     // Second call with same argument - should use cache
     expect(memoized(5)).toBe(10);
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     // Call with different argument
     expect(memoized(3)).toBe(6);
+
     expect(mockFn).toHaveBeenCalledTimes(2);
   });
 
   test('should work with multiple arguments', () => {
     const mockFn = vi.fn((a: number, b: number) => a + b);
+
     const memoized = memoizeFunction(mockFn, (a, b) => `${a},${b}`);
 
     expect(memoized(2, 3)).toBe(5);
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     expect(memoized(2, 3)).toBe(5);
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     expect(memoized(3, 2)).toBe(5);
+
     expect(mockFn).toHaveBeenCalledTimes(2);
   });
 
   test('should handle functions that return undefined', () => {
     const mockFn = vi.fn((_x: number) => undefined);
+
     const memoized = memoizeFunction(mockFn, (x) => x);
 
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
     expect(memoized(5)).toBeUndefined();
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     // Should use cache even for undefined
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
     expect(memoized(5)).toBeUndefined();
+
     expect(mockFn).toHaveBeenCalledOnce();
   });
 
   test('should work with object arguments using primitive cache keys', () => {
     type User = Readonly<{ id: number; name: string }>;
+
     const mockFn = vi.fn((user: User) => `Hello ${user.name}`);
+
     const memoized = memoizeFunction(mockFn, (user) => user.id);
 
     const user1 = { id: 1, name: 'Alice' };
+
     const user2 = { id: 1, name: 'Bob' }; // Same id, different name
+
     const user3 = { id: 2, name: 'Charlie' };
 
     expect(memoized(user1)).toBe('Hello Alice');
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     // Same id, should use cache (even though name is different)
     expect(memoized(user2)).toBe('Hello Alice');
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     // Different id, should call function
     expect(memoized(user3)).toBe('Hello Charlie');
+
     expect(mockFn).toHaveBeenCalledTimes(2);
   });
 
@@ -75,6 +93,7 @@ describe(memoizeFunction, () => {
     );
 
     expect(withNumber('hello')).toBe(5);
+
     expect(withNumber('world')).toBe(5); // Same length, uses cache
 
     // Boolean key
@@ -84,57 +103,74 @@ describe(memoizeFunction, () => {
     );
 
     expect(withBoolean(5)).toBe(10);
+
     expect(withBoolean(3)).toBe(10); // Both positive, uses cache
+
     expect(withBoolean(-2)).toBe(-4); // Negative, new cache entry
 
     // Symbol key
     const sym1 = Symbol('test');
+
     const sym2 = Symbol('test');
+
     const withSymbol = memoizeFunction(
       (_s: symbol) => Math.random(),
       (s) => s,
     );
+
     const result1 = withSymbol(sym1);
 
     expect(withSymbol(sym1)).toBe(result1); // Same symbol, uses cache
+
     expect(withSymbol(sym2)).not.toBe(result1); // Different symbol
   });
 
   test('should handle null and undefined cache keys', () => {
     const mockFn = vi.fn((x: string | null | undefined) => x ?? 'default');
+
     const memoized = memoizeFunction(mockFn, (x) => x);
 
     expect(memoized(null)).toBe('default');
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     expect(memoized(null)).toBe('default');
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     expect(memoized(undefined)).toBe('default');
+
     expect(mockFn).toHaveBeenCalledTimes(2);
 
     expect(memoized(undefined)).toBe('default');
+
     expect(mockFn).toHaveBeenCalledTimes(2);
   });
 
   test('should maintain separate caches for different memoized functions', () => {
     const fn1 = vi.fn((x: number) => x * 2);
+
     const fn2 = vi.fn((x: number) => x * 3);
 
     const memoized1 = memoizeFunction(fn1, (x) => x);
+
     const memoized2 = memoizeFunction(fn2, (x) => x);
 
     expect(memoized1(5)).toBe(10);
+
     expect(memoized2(5)).toBe(15);
 
     expect(fn1).toHaveBeenCalledOnce();
+
     expect(fn2).toHaveBeenCalledOnce();
 
     // Each has its own cache
     expect(memoized1(5)).toBe(10);
+
     expect(memoized2(5)).toBe(15);
 
     expect(fn1).toHaveBeenCalledOnce();
+
     expect(fn2).toHaveBeenCalledOnce();
   });
 
@@ -155,18 +191,23 @@ describe(memoizeFunction, () => {
     );
 
     const args1 = { category: 'books', subcategory: 'fiction', id: 123 };
+
     const args2 = { category: 'books', subcategory: 'fiction', id: 123 };
+
     const args3 = { category: 'books', subcategory: 'fiction', id: 124 };
 
     expect(memoized(args1)).toBe('books/fiction/123');
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     // Same cache key, should use cache
     expect(memoized(args2)).toBe('books/fiction/123');
+
     expect(mockFn).toHaveBeenCalledOnce();
 
     // Different id, different cache key
     expect(memoized(args3)).toBe('books/fiction/124');
+
     expect(mockFn).toHaveBeenCalledTimes(2);
   });
 });

package/src/others/tuple.mts

@@ -7,28 +7,39 @@
  * ```ts
  * // Create a tuple with literal types preserved
  * const coordinates = tp(10, 20, 30);
+ *
  * expectType<typeof coordinates, readonly [10, 20, 30]>('=');
+ *
  * expectType<typeof coordinates, readonly number[]>('!=');
+ *
  * assert.deepStrictEqual(coordinates, [10, 20, 30]);
  *
  * // The following two are equivalent
  * const a = tp(1, 2);
+ *
  * const b = [1, 2] as const;
+ *
  * expectType<typeof a, typeof b>('=');
+ *
  * assert.deepStrictEqual(a, b);
  *
  * // Without tp, type would be number[]
  * const point = tp('x', 42, true);
+ *
  * expectType<typeof point, readonly ['x', 42, true]>('=');
+ *
  * assert.deepStrictEqual(point, ['x', 42, true]);
  *
  * // Useful for creating const tuples
  * const rgb = tp(255, 128, 0);
+ *
  * expectType<typeof rgb, readonly [255, 128, 0]>('=');
  *
- * assert(rgb[0] === 255);
- * assert(rgb[1] === 128);
- * assert(rgb[2] === 0);
+ * assert.isTrue(rgb[0] === 255);
+ *
+ * assert.isTrue(rgb[1] === 128);
+ *
+ * assert.isTrue(rgb[2] === 0);
  * ```
  *
  * @template T - A tuple type with literal types inferred from the arguments

package/src/others/unknown-to-string.mts

@@ -51,11 +51,13 @@ export const unknownToString = (
       if (!isNonNullish(value)) {
         return 'null';
       }
+
       try {
         const stringified =
           options?.prettyPrintObject === true
             ? JSON.stringify(value, undefined, 2)
             : JSON.stringify(value);
+
         return stringified;
       } catch (error) {
         return isError(error)

package/src/others/unknown-to-string.test.mts

@@ -5,6 +5,7 @@ describe(unknownToString, () => {
     const result = unknownToString('aaaaa');
 
     expect(result).toBe('aaaaa');
+
     expect(JSON.stringify('aaaaa')).toBe('"aaaaa"');
   });
 
@@ -12,6 +13,7 @@ describe(unknownToString, () => {
     const result = unknownToString(1);
 
     expect(result).toBe('1');
+
     expect(JSON.stringify(1)).toBe('1');
   });
 
@@ -19,6 +21,7 @@ describe(unknownToString, () => {
     const result = unknownToString(true);
 
     expect(result).toBe('true');
+
     expect(JSON.stringify(true)).toBe('true');
   });
 
@@ -26,6 +29,7 @@ describe(unknownToString, () => {
     const result = unknownToString(Symbol('sym'));
 
     expect(result).toBe('Symbol(sym)');
+
     expect(JSON.stringify(Symbol('sym'))).toBeUndefined();
   });
 
@@ -33,6 +37,7 @@ describe(unknownToString, () => {
     const result = unknownToString(() => 0);
 
     expect(result).toBe('() => 0');
+
     expect(JSON.stringify(() => 0)).toBeUndefined();
   });
 
@@ -40,6 +45,7 @@ describe(unknownToString, () => {
     const result = unknownToString(undefined);
 
     expect(result).toBe('undefined');
+
     expect(JSON.stringify(undefined)).toBeUndefined();
   });
 
@@ -47,6 +53,7 @@ describe(unknownToString, () => {
     const result = unknownToString(null);
 
     expect(result).toBe('null');
+
     expect(JSON.stringify(null)).toBe('null');
   });
 
@@ -54,6 +61,7 @@ describe(unknownToString, () => {
     const result = unknownToString({ a: { b: 1 } });
 
     expect(result).toBe('{"a":{"b":1}}');
+
     expect(JSON.stringify({ a: { b: 1 } })).toBe('{"a":{"b":1}}');
   });
 
@@ -77,7 +85,9 @@ describe(unknownToString, () => {
 
   test('circular reference returns error message', () => {
     const mut_circular: { a: number; self?: unknown } = { a: 1 };
+
     mut_circular.self = mut_circular;
+
     const result = unknownToString(mut_circular);
 
     // Should return an error message string instead of throwing