ts-data-forge 6.3.1 → 6.4.0

package/dist/others/memoize-function.d.mts

@@ -21,10 +21,11 @@
  *   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 declare const memoizeFunction: <const A extends readonly unknown[], R, K extends Primitive>(fn: (...args: A) => R, argsToCacheKey: (...args: A) => K) => ((...args: A) => R);
+export declare function memoizeFunction<R>(fn: () => R): () => R;
+export declare 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;
 //# sourceMappingURL=memoize-function.d.mts.map

package/dist/others/memoize-function.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"memoize-function.d.mts","sourceRoot":"","sources":["../../src/others/memoize-function.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,GAC1B,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAClC,CAAC,EACD,CAAC,SAAS,SAAS,EAEnB,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,EACrB,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,KAChC,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAiBpB,CAAC"}
+{"version":3,"file":"memoize-function.d.mts","sourceRoot":"","sources":["../../src/others/memoize-function.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;AAEzD,wBAAgB,eAAe,CAC7B,IAAI,EACJ,KAAK,CAAC,QAAQ,SAAS,SAAS,OAAO,EAAE,EACzC,CAAC,EACD,CAAC,SAAS,SAAS,EAEnB,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,QAAQ,KAAK,CAAC,EACxC,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,QAAQ,KAAK,CAAC,GACnD,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,QAAQ,KAAK,CAAC,CAAC"}

package/dist/others/memoize-function.mjs

@@ -1,46 +1,17 @@
-/**
- * Creates a memoized version of a function that caches results based on input
- * arguments.
- *
- * The memoized function stores results in an internal Map and returns cached
- * values for repeated calls with the same arguments. This can significantly
- * improve performance for expensive computations or I/O operations.
- *
- * **Important considerations:**
- *
- * - The cache grows unbounded - consider memory implications for long-running
- *   applications
- * - Cache keys must be primitives (string, number, boolean, symbol, null,
- *   undefined, bigint)
- * - Object arguments require careful key generation to ensure uniqueness
- * - Pure functions only - memoizing functions with side effects can lead to bugs
- *
- * @template A - The tuple type of the function arguments
- * @template R - The return type of the function
- * @template K - The primitive type used as the cache key (must be valid Map
- *   key)
- * @param fn - The pure function to memoize
- * @param argsToCacheKey - Function that converts arguments to a unique cache
- *   key
- * @returns A memoized version of the input function with the same signature
- *
- * @see https://en.wikipedia.org/wiki/Memoization
- */
-const memoizeFunction = (fn, argsToCacheKey) => {
+function memoizeFunction(fn, argsToCacheKey) {
     const mut_cache = new Map();
+    const defaultKey = Symbol('memoize-default-key');
     return (...args) => {
-        const key = argsToCacheKey(...args);
-        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);
-            mut_cache.set(key, result);
-            return result;
+        const key = argsToCacheKey === undefined ? defaultKey : argsToCacheKey(...args);
+        const cached = mut_cache.get(key);
+        if (cached !== undefined) {
+            return cached.value;
         }
+        const result = fn(...args);
+        mut_cache.set(key, { value: result });
+        return result;
     };
-};
+}
 
 export { memoizeFunction };
 //# sourceMappingURL=memoize-function.mjs.map

package/dist/others/memoize-function.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"memoize-function.mjs","sources":["../../src/others/memoize-function.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;MACU,eAAe,GAAG,CAK7B,EAAqB,EACrB,cAAiC,KACV;AACvB,IAAA,MAAM,SAAS,GAAG,IAAI,GAAG,EAAQ;AAEjC,IAAA,OAAO,CAAC,GAAG,IAAO,KAAO;AACvB,QAAA,MAAM,GAAG,GAAG,cAAc,CAAC,GAAG,IAAI,CAAC;AAEnC,QAAA,IAAI,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;;AAEtB,YAAA,OAAO,SAAS,CAAC,GAAG,CAAC,GAAG,CAAE;QAC5B;aAAO;AACL,YAAA,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;AAE1B,YAAA,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC;AAE1B,YAAA,OAAO,MAAM;QACf;AACF,IAAA,CAAC;AACH;;;;"}
+{"version":3,"file":"memoize-function.mjs","sources":["../../src/others/memoize-function.mts"],"sourcesContent":[null],"names":[],"mappings":"AAwCM,SAAU,eAAe,CAK7B,EAAwB,EACxB,cAAqC,EAAA;AAIrC,IAAA,MAAM,SAAS,GAAG,IAAI,GAAG,EAA0B;AAEnD,IAAA,MAAM,UAAU,GAAG,MAAM,CAAC,qBAAqB,CAAC;AAEhD,IAAA,OAAO,CAAC,GAAG,IAAU,KAAO;AAC1B,QAAA,MAAM,GAAG,GACP,cAAc,KAAK,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC,GAAG,IAAI,CAAC;QAErE,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC;AAEjC,QAAA,IAAI,MAAM,KAAK,SAAS,EAAE;YACxB,OAAO,MAAM,CAAC,KAAK;QACrB;AAEA,QAAA,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;QAE1B,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAErC,QAAA,OAAO,MAAM;AACf,IAAA,CAAC;AACH;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "6.3.1",
+  "version": "6.4.0",
   "private": false,
   "keywords": [
     "typescript",

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

@@ -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);