feat: add caches and keyed version

src/cache/keyed.ts

@@ -0,0 +1,16 @@
+import { CacheValue } from "../lib/cache-ref";
+import { suspendOnPromise } from "../lib/suspend";
+
+export interface KeyedCacheStorage<K, T> {
+  get(key: K): CacheValue<T> | undefined | null;
+  set(key: K, value: CacheValue<T>): void;
+}
+
+export const createKeyedCache = <K, T>(
+  storage: KeyedCacheStorage<K, T> = new Map()
+) => {
+  const use = (key: K, fn: () => Promise<T>) =>
+    suspendOnPromise(fn, storage.get(key), (value) => storage.set(key, value));
+
+  return { use, storage };
+};

src/cache/single-value.ts

@@ -0,0 +1,15 @@
+import { CacheValue } from "../lib/cache-ref";
+import { suspendOnPromise } from "../lib/suspend";
+
+export const createSingleValueCache = <T>() => {
+  const storage = {
+    current: null as CacheValue<T> | null,
+  };
+
+  const use = (fn: () => Promise<T>) =>
+    suspendOnPromise(fn, storage.current, (value) => {
+      storage.current = value;
+    });
+
+  return { use, storage };
+};

src/index.ts

@@ -1 +1,4 @@
-export { createSingleValueSuspense } from "./single-value";
+export { createKeyedCache } from "./cache/keyed";
+export { createSingleValueCache } from "./cache/single-value";
+export { createKeyedSuspense } from "./suspense/keyed";
+export { createSingleValueSuspense } from "./suspense/single-value";

src/suspend.ts → src/lib/suspend.ts

@@ -1,12 +1,16 @@
 import { CacheValue } from "./cache-ref";
 
+// We wrap the `fn` in an async function to avoid
+// throwing sync errors.
+const callPromiseFn = async <T>(fn: () => Promise<T>) => await fn();
+
 export const suspendOnPromise = <T>(
   fn: () => Promise<T>,
-  cachedValue: CacheValue<T> | null,
+  cachedValue: CacheValue<T> | undefined | null,
   storeInCache: (value: CacheValue<T>) => void
 ) => {
   if (!cachedValue) {
-    const promise = fn().then(
+    const promise = callPromiseFn(fn).then(
       (value) => storeInCache({ status: "fulfilled", value }),
       (error) => storeInCache({ status: "rejected", error })
     );

src/suspense/keyed.ts

@@ -0,0 +1,14 @@
+import { createKeyedCache } from "../cache/keyed";
+
+export const createKeyedSuspense = <K extends string, T>(
+  fn: (key: K) => Promise<T>
+) => {
+  const cache = createKeyedCache<K, T>();
+
+  const useKeyedSuspense = (key: K) => {
+    const value = cache.use(key, () => fn(key));
+    return { value, cache };
+  };
+
+  return useKeyedSuspense;
+};

src/suspense/single-value.ts

@@ -0,0 +1,12 @@
+import { createSingleValueCache } from "../cache/single-value";
+
+export const createSingleValueSuspense = <T>(fn: () => Promise<T>) => {
+  const cache = createSingleValueCache<T>();
+
+  const useSingleValueSuspense = () => {
+    const value = cache.use(fn);
+    return { value, cache };
+  };
+
+  return useSingleValueSuspense;
+};