tannerlinsley · June 6, 2025 16:54 · Jun 6, 2025
diff --git a/README.md b/README.md
@@ -0,0 +1,9 @@
+`createCachedFn` function wraps any function fn in a cache that is scoped to the current “event” (via getEvent()), ensuring repeat calls with the same arguments during that event return cached results instead of recomputing.
+
+Summary:
+	•	Caches function results per event.
+	•	Uses fn.toString() and JSON.stringify(args) as cache keys.
+	•	Stores cache in a per-event __cachedStorage map.
+	•	Avoids recomputation for repeated calls with the same arguments during the same event.
+
+It’s ideal for optimizing repeated pure function calls during a single request or lifecycle event.
diff --git a/createCachedFn.ts b/createCachedFn.ts
@@ -0,0 +1,42 @@
+export function createCachedFn<T extends (...args: any[]) => any>(fn: T) {
+  return (...args: Parameters<T>): ReturnType<T> => {
+    const event = getEvent(); // Retrieve the event dynamically
+
+    // Ensure __cachedStorage exists on the event
+    if (!event.__cachedStorage) {
+      event.__cachedStorage = new Map<string, any>();
+    }
+
+    const cache = event.__cachedStorage;
+    const fnKey = fn.toString(); // Unique key for the function
+    const argsKey = JSON.stringify(args); // Unique key for the arguments
+
+    // Ensure a cache exists for this specific function
+    if (!cache.has(fnKey)) {
+      cache.set(fnKey, new Map());
+    }
+
+    const fnCache = cache.get(fnKey);
+
+    // Check for cached result
+    if (fnCache.has(argsKey)) {
+      return fnCache.get(argsKey);
+    }
+
+    // Compute result, store in cache
+    const result = fn(...args);
+    fnCache.set(argsKey, result);
+
+    return result;
+  };
+}
+
+// Example usage
+const myFn = (x: number, y: number) => x + y;
+
+const cachedFn = createCachedFn(myFn);
+
+// Calling the cached function
+console.log(cachedFn(5, 3)); // Calls myFn(5, 3) and caches
+console.log(cachedFn(5, 3)); // Returns cached value
+console.log(cachedFn(2, 4)); // Calls myFn(2, 4) - Different params