ts-data-forge 6.3.1 → 6.5.0

package/src/others/index.mts

@@ -1,6 +1,7 @@
 export * from './cast-mutable.mjs';
 export * from './cast-readonly.mjs';
 export * from './debounce-function.mjs';
+export * from './fast-deep-equal.mjs';
 export * from './if-then.mjs';
 export * from './map-nullable.mjs';
 export * from './memoize-function.mjs';

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

@@ -37,7 +37,7 @@ describe(mapNullable, () => {
     });
 
     test('should work with complex transformations', () => {
-      const user = { name: 'Alice', age: 30 };
+      const user = { name: 'Alice', age: 30 } as const;
 
       const result = mapNullable(
         user,
@@ -48,13 +48,13 @@ describe(mapNullable, () => {
     });
 
     test('should work with nullable object properties', () => {
-      const user: Readonly<{ name?: string }> = { name: 'Bob' };
+      const user: Readonly<{ name?: string }> = { name: 'Bob' } as const;
 
       const result = mapNullable(user.name, (name) => name.toUpperCase());
 
       expect(result).toBe('BOB');
 
-      const userWithoutName: Readonly<{ name?: string }> = {};
+      const userWithoutName: Readonly<{ name?: string }> = {} as const;
 
       const resultEmpty = mapNullable(userWithoutName.name, (name) =>
         name.toUpperCase(),
@@ -102,7 +102,7 @@ describe(mapNullable, () => {
         (u: Readonly<{ name: string; age: number }>) => u.name,
       );
 
-      const user = { name: 'Charlie', age: 25 };
+      const user = { name: 'Charlie', age: 25 } as const;
 
       const result1 = getName(user);
 
@@ -201,7 +201,7 @@ describe(mapNullable, () => {
       const data = {
         user: { profile: { name: 'Alice' } },
         settings: { theme: 'dark' },
-      };
+      } as const;
 
       const result = mapNullable(data, (d) => d.user.profile.name);
 
@@ -277,7 +277,7 @@ describe(mapNullable, () => {
             email: 'john@example.com',
           },
         },
-      };
+      } as const;
 
       const extractUserName = mapNullable(
         (r: ApiResponse) => r.data?.user?.name,
@@ -301,7 +301,7 @@ describe(mapNullable, () => {
       const formData: FormDataType = {
         email: 'test@example.com',
         age: '25',
-      };
+      } as const;
 
       const extractAge = mapNullable((data: FormDataType) => data.age);
 
@@ -331,7 +331,7 @@ describe(mapNullable, () => {
       const incompleteFormData: FormDataType = {
         email: 'test@example.com',
         // age is missing
-      };
+      } as const;
 
       const extractAge = mapNullable((data: FormDataType) => data.age);
 

package/src/others/memoize-function.mts

@@ -21,33 +21,51 @@
  *   key)
  * @param fn - The pure function to memoize
  * @param argsToCacheKey - Function that converts arguments to a unique cache
- *   key
+ *   key. Optional for zero-argument functions.
  * @returns A memoized version of the input function with the same signature
  *
  * @see https://en.wikipedia.org/wiki/Memoization
  */
-export const memoizeFunction = <
-  const A extends readonly unknown[],
+export function memoizeFunction<R>(fn: () => R): () => R;
+
+export function memoizeFunction<
+  Arg0,
+  const RestArgs extends readonly unknown[],
+  R,
+  K extends Primitive,
+>(
+  fn: (arg0: Arg0, ...args: RestArgs) => R,
+  argsToCacheKey: (arg0: Arg0, ...args: RestArgs) => K,
+): (arg0: Arg0, ...args: RestArgs) => R;
+
+export function memoizeFunction<
+  const Args extends readonly unknown[],
   R,
   K extends Primitive,
 >(
-  fn: (...args: A) => R,
-  argsToCacheKey: (...args: A) => K,
-): ((...args: A) => R) => {
-  const mut_cache = new Map<K, R>();
+  fn: (...args: Args) => R,
+  argsToCacheKey?: (...args: Args) => K,
+): (...args: Args) => R {
+  type CacheEntry = Readonly<{ value: R }>;
 
-  return (...args: A): R => {
-    const key = argsToCacheKey(...args);
+  const mut_cache = new Map<K | symbol, CacheEntry>();
 
-    if (mut_cache.has(key)) {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      return mut_cache.get(key)!;
-    } else {
-      const result = fn(...args);
+  const defaultKey = Symbol('memoize-default-key');
 
-      mut_cache.set(key, result);
+  return (...args: Args): R => {
+    const key: K | symbol =
+      argsToCacheKey === undefined ? defaultKey : argsToCacheKey(...args);
 
-      return result;
+    const cached = mut_cache.get(key);
+
+    if (cached !== undefined) {
+      return cached.value;
     }
+
+    const result = fn(...args);
+
+    mut_cache.set(key, { value: result });
+
+    return result;
   };
-};
+}

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

@@ -65,11 +65,11 @@ describe(memoizeFunction, () => {
 
     const memoized = memoizeFunction(mockFn, (user) => user.id);
 
-    const user1 = { id: 1, name: 'Alice' };
+    const user1 = { id: 1, name: 'Alice' } as const;
 
-    const user2 = { id: 1, name: 'Bob' }; // Same id, different name
+    const user2 = { id: 1, name: 'Bob' } as const; // Same id, different name
 
-    const user3 = { id: 2, name: 'Charlie' };
+    const user3 = { id: 2, name: 'Charlie' } as const;
 
     expect(memoized(user1)).toBe('Hello Alice');
 
@@ -148,6 +148,31 @@ describe(memoizeFunction, () => {
     expect(mockFn).toHaveBeenCalledTimes(2);
   });
 
+  test('should work with zero-argument functions without key mapper', () => {
+    const mockFn = vi.fn(() => Math.random());
+
+    const memoized = memoizeFunction(mockFn);
+
+    // First call
+    const result1 = memoized();
+
+    expect(mockFn).toHaveBeenCalledOnce();
+
+    // Second call - should use cache and return the same random value
+    const result2 = memoized();
+
+    expect(mockFn).toHaveBeenCalledOnce();
+
+    expect(result2).toBe(result1);
+
+    // Third call - still using cache
+    const result3 = memoized();
+
+    expect(mockFn).toHaveBeenCalledOnce();
+
+    expect(result3).toBe(result1);
+  });
+
   test('should maintain separate caches for different memoized functions', () => {
     const fn1 = vi.fn((x: number) => x * 2);
 
@@ -191,11 +216,23 @@ describe(memoizeFunction, () => {
       (args) => `${args.category}:${args.subcategory}:${args.id}`,
     );
 
-    const args1 = { category: 'books', subcategory: 'fiction', id: 123 };
-
-    const args2 = { category: 'books', subcategory: 'fiction', id: 123 };
-
-    const args3 = { category: 'books', subcategory: 'fiction', id: 124 };
+    const args1 = {
+      category: 'books',
+      subcategory: 'fiction',
+      id: 123,
+    } as const;
+
+    const args2 = {
+      category: 'books',
+      subcategory: 'fiction',
+      id: 123,
+    } as const;
+
+    const args3 = {
+      category: 'books',
+      subcategory: 'fiction',
+      id: 124,
+    } as const;
 
     expect(memoized(args1)).toBe('books/fiction/123');
 

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

@@ -62,7 +62,7 @@ describe(unknownToString, () => {
     });
 
     test('(args) => ({ ret: args })', () => {
-      const fn = (args: unknown): unknown => ({ ret: args });
+      const fn = (args: unknown): unknown => ({ ret: args }) as const;
 
       expect(unknownToString(fn)).toBe('(args) => ({ ret: args })');
 
@@ -72,7 +72,7 @@ describe(unknownToString, () => {
 
   describe('object', () => {
     test('object', () => {
-      const obj = { a: { b: 1 } };
+      const obj = { a: { b: 1 } } as const;
 
       expect(unknownToString(obj)).toBe('{"a":{"b":1}}');
 
@@ -80,7 +80,7 @@ describe(unknownToString, () => {
     });
 
     test('object(prettyPrint=true)', () => {
-      const obj = { a: { b: 1 } };
+      const obj = { a: { b: 1 } } as const;
 
       expect(unknownToString(obj, { prettyPrintObject: true })).toBe(
         dedent`
@@ -95,7 +95,7 @@ describe(unknownToString, () => {
 
     describe('array', () => {
       test('array of primitives', () => {
-        const arr = [1, 2, 3, 'test', true];
+        const arr = [1, 2, 3, 'test', true] as const;
 
         expect(unknownToString(arr)).toBe('[1,2,3,"test",true]');
 
@@ -103,7 +103,7 @@ describe(unknownToString, () => {
       });
 
       test('array of objects', () => {
-        const arr = [{ a: 1 }, { b: 2 }];
+        const arr = [{ a: 1 }, { b: 2 }] as const;
 
         expect(unknownToString(arr)).toBe('[{"a":1},{"b":2}]');
 
@@ -120,7 +120,7 @@ describe(unknownToString, () => {
         const nestedArray = [
           [1, 2],
           [3, 4],
-        ];
+        ] as const;
 
         expect(unknownToString(nestedArray)).toBe('[[1,2],[3,4]]');
 
@@ -128,7 +128,7 @@ describe(unknownToString, () => {
       });
 
       test('array with prettyPrint', () => {
-        const arr = [1, { a: 2 }, 3];
+        const arr = [1, { a: 2 }, 3] as const;
 
         expect(
           unknownToString(arr, {
@@ -288,7 +288,7 @@ describe(unknownToString, () => {
         // eslint-disable-next-line @typescript-eslint/only-throw-error
         throw 'custom failure';
       },
-    };
+    } as const;
 
     expect(unknownToString(value)).toBe('[Circular or Non-serializable]');
   });