ts-data-forge 5.0.0 → 5.1.0

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,27 +7,38 @@
  * ```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);
  * ```
  *

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

@@ -1,3 +1,4 @@
+import { isError } from '@sindresorhus/is';
 import { isNonNullish } from '../guard/index.mjs';
 
 /**
@@ -50,14 +51,16 @@ 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 Error.isError(error)
+        return isError(error)
           ? error.message
           : '[Circular or Non-serializable]';
       }

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

package/src/promise/promise.mts

@@ -17,7 +17,9 @@ import { Result } from '../functional/index.mjs';
  * });
  *
  * const successResult = await successPromise;
+ *
  * assert.ok(Result.isOk(successResult));
+ *
  * if (Result.isOk(successResult)) {
  *   assert(successResult.value === 42);
  * }
@@ -30,7 +32,9 @@ import { Result } from '../functional/index.mjs';
  * });
  *
  * const errorResult = await errorPromise;
+ *
  * assert.ok(Result.isErr(errorResult));
+ *
  * if (Result.isErr(errorResult)) {
  *   assert(errorResult.value === 'Something went wrong');
  * }

package/src/promise/promise.test.mts

@@ -21,6 +21,7 @@ describe(createPromise, () => {
 
   test('resolves to Result.err when executor rejects', async () => {
     const rejection = new Error('boom');
+
     const result = await createPromise<number, Error>((_resolve, reject) => {
       reject(rejection);
     });