steddy 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,4 +1,4 @@
-import { createContext, useMemo, useRef, useCallback, useSyncExternalStore, useState, useContext } from 'react';
+import { createContext, useRef, useEffect, useMemo, useCallback, useSyncExternalStore, useState, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
 // src/useSteddy.ts
@@ -6,6 +6,9 @@ import { jsx } from 'react/jsx-runtime';
 // src/coordinator.ts
 var DEDUP_WINDOW_MS = 2e3;
 var UNSUBSCRIBE_GRACE_MS = 0;
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
 function isAbortError(error) {
   return typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
 }
@@ -13,7 +16,16 @@ function createCoordinator(store) {
   const registered = /* @__PURE__ */ new Map();
   const inflight = /* @__PURE__ */ new Map();
   const releaseTimers = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
   let generation = 0;
+  function emit(event) {
+    if (listeners.size === 0) {
+      return;
+    }
+    for (const listener of listeners) {
+      listener(event);
+    }
+  }
   function cancelRelease(serializedKey) {
     const timer = releaseTimers.get(serializedKey);
     if (timer == null) {
@@ -27,6 +39,11 @@ function createCoordinator(store) {
     if (!current) {
       return;
     }
+    emit({
+      type: "abort",
+      key: serializedKey,
+      ms: now() - current.startedAt
+    });
     current.controller.abort();
     current.settle();
     inflight.delete(serializedKey);
@@ -38,9 +55,13 @@ function createCoordinator(store) {
     }
   }
   const coordinator = {
-    register(serializedKey, key, fetcher) {
+    register(serializedKey, key, fetcher, options) {
       cancelRelease(serializedKey);
-      registered.set(serializedKey, { key, fetcher });
+      registered.set(serializedKey, {
+        key,
+        fetcher,
+        staleTime: options?.staleTime ?? DEDUP_WINDOW_MS
+      });
     },
     unregister(serializedKey) {
       cancelRelease(serializedKey);
@@ -61,7 +82,9 @@ function createCoordinator(store) {
     async revalidate(serializedKey, fetcher, options) {
       if (!options?.force) {
         const entry = store.get(serializedKey);
-        if (entry && !entry.isValidating && entry.error == null && entry.data !== void 0 && Date.now() - entry.timestamp < DEDUP_WINDOW_MS) {
+        const staleTime = registered.get(serializedKey)?.staleTime ?? DEDUP_WINDOW_MS;
+        if (entry && !entry.isValidating && entry.error == null && entry.hasData && Date.now() - entry.timestamp < staleTime) {
+          emit({ type: "dedup", key: serializedKey });
           return;
         }
       }
@@ -85,15 +108,19 @@ function createCoordinator(store) {
           settleWaiter();
         }
       };
+      const startedAt = now();
       inflight.set(serializedKey, {
         controller,
         generation: currentGeneration,
         waiter,
-        settle
+        settle,
+        startedAt
       });
+      emit({ type: "start", key: serializedKey });
       const previous = store.get(serializedKey);
       store.set(serializedKey, {
         data: previous?.data,
+        hasData: previous?.hasData ?? false,
         error: previous?.error,
         timestamp: previous?.timestamp ?? 0,
         isValidating: true
@@ -107,10 +134,16 @@ function createCoordinator(store) {
         inflight.delete(serializedKey);
         store.set(serializedKey, {
           data,
+          hasData: true,
           error: void 0,
           timestamp: Date.now(),
           isValidating: false
         });
+        emit({
+          type: "write",
+          key: serializedKey,
+          ms: now() - startedAt
+        });
       } catch (error) {
         const stillCurrent = inflight.get(serializedKey)?.generation === currentGeneration;
         if (!stillCurrent || controller.signal.aborted || isAbortError(error)) {
@@ -120,10 +153,16 @@ function createCoordinator(store) {
         const current = store.get(serializedKey);
         store.set(serializedKey, {
           data: current?.data,
+          hasData: current?.hasData ?? false,
           error,
           timestamp: current?.timestamp ?? 0,
           isValidating: false
         });
+        emit({
+          type: "error",
+          key: serializedKey,
+          ms: now() - startedAt
+        });
         throw error;
       } finally {
         settle();
@@ -143,7 +182,7 @@ function createCoordinator(store) {
       abortInternal(serializedKey, true);
     },
     evict(options) {
-      const now = Date.now();
+      const now2 = Date.now();
       const removable = [];
       for (const key of store.keys()) {
         if (inflight.has(key) || store.subscriberCount(key) > 0) {
@@ -158,7 +197,7 @@ function createCoordinator(store) {
       const victims = /* @__PURE__ */ new Set();
       if (options.maxAge != null) {
         for (const item of removable) {
-          if (now - item.timestamp >= options.maxAge) {
+          if (now2 - item.timestamp >= options.maxAge) {
             victims.add(item.key);
           }
         }
@@ -193,6 +232,12 @@ function createCoordinator(store) {
         abortInternal(key, false);
       }
       registered.clear();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
     }
   };
   return coordinator;
@@ -201,6 +246,7 @@ function createCoordinator(store) {
 // src/store.ts
 var EMPTY_SNAPSHOT = Object.freeze({
   data: void 0,
+  hasData: false,
   error: void 0,
   timestamp: 0,
   isValidating: false
@@ -222,6 +268,10 @@ function createStore() {
       return entries.get(key);
     },
     set(key, entry) {
+      const existing = entries.get(key);
+      if (existing && Object.is(existing.data, entry.data) && existing.hasData === entry.hasData && existing.error === entry.error && existing.timestamp === entry.timestamp && existing.isValidating === entry.isValidating) {
+        return;
+      }
       entries.set(key, entry);
       emit(key);
     },
@@ -323,6 +373,7 @@ function createMutate(store, coordinator) {
       if (isThenable(next)) {
         store.set(serialized, {
           data: currentData,
+          hasData: previous?.hasData ?? false,
           error: previous?.error,
           timestamp: previous?.timestamp ?? 0,
           isValidating: true
@@ -330,6 +381,7 @@ function createMutate(store, coordinator) {
         const resolved = await next;
         store.set(serialized, {
           data: resolved,
+          hasData: true,
           error: void 0,
           timestamp: Date.now(),
           isValidating: revalidate
@@ -337,6 +389,7 @@ function createMutate(store, coordinator) {
       } else {
         store.set(serialized, {
           data: next,
+          hasData: true,
           error: void 0,
           timestamp: Date.now(),
           isValidating: revalidate
@@ -353,6 +406,7 @@ function createMutate(store, coordinator) {
         const current = store.get(serialized);
         store.set(serialized, {
           data: current?.data,
+          hasData: current?.hasData ?? false,
           error,
           timestamp: current?.timestamp ?? Date.now(),
           isValidating: false
@@ -384,24 +438,44 @@ function SteddyProvider({
   cache,
   children
 }) {
-  const value = useMemo(() => {
-    if (cache) {
-      hydrateAll(cache, store);
+  const hydratedFingerprint = useRef(null);
+  useEffect(() => {
+    if (!cache) {
+      hydratedFingerprint.current = null;
+      return;
+    }
+    const fingerprint = JSON.stringify(cache);
+    if (hydratedFingerprint.current === fingerprint) {
+      return;
     }
-    return {
+    hydratedFingerprint.current = fingerprint;
+    hydrateAll(cache, store);
+  }, [cache, store]);
+  const value = useMemo(
+    () => ({
       store,
       coordinator,
       mutate: createMutate(store, coordinator)
-    };
-  }, [store, coordinator, cache]);
+    }),
+    [store, coordinator]
+  );
   return /* @__PURE__ */ jsx(SteddyContext.Provider, { value, children });
 }
+var warnedDefaultOnServer = false;
 function useSteddyRuntime() {
-  return useContext(SteddyContext);
+  const runtime = useContext(SteddyContext);
+  if (process.env.NODE_ENV !== "production" && typeof window === "undefined" && runtime === defaultRuntime && !warnedDefaultOnServer) {
+    warnedDefaultOnServer = true;
+    console.warn(
+      "[steddy] useSteddy on the server without SteddyProvider shares one cache across requests. Use createRuntime() per request."
+    );
+  }
+  return runtime;
 }
 function hydrate(key, data, store = defaultStore) {
   store.set(serializeKey(key), {
     data,
+    hasData: true,
     error: void 0,
     timestamp: 0,
     isValidating: false
@@ -411,7 +485,7 @@ function dump(store = defaultStore) {
   const snapshot = {};
   for (const key of store.keys()) {
     const entry = store.get(key);
-    if (!entry || entry.data === void 0) {
+    if (!entry?.hasData) {
       continue;
     }
     snapshot[key] = { data: entry.data, timestamp: entry.timestamp };
@@ -422,12 +496,23 @@ function hydrateAll(snapshot, store = defaultStore) {
   for (const [key, payload] of Object.entries(snapshot)) {
     store.set(key, {
       data: payload.data,
+      hasData: true,
       error: void 0,
-      timestamp: 0,
+      timestamp: payload.timestamp,
       isValidating: false
     });
   }
 }
+async function prefetch(key, fetcher, runtime = defaultRuntime) {
+  const serialized = serializeKey(key);
+  runtime.coordinator.register(serialized, key, fetcher);
+  try {
+    await runtime.coordinator.revalidate(serialized);
+  } catch {
+  } finally {
+    runtime.coordinator.unregister(serialized);
+  }
+}
 function clear(key, runtime = defaultRuntime) {
   if (key === void 0) {
     for (const active of runtime.coordinator.getRegisteredKeys()) {
@@ -466,11 +551,15 @@ function useSteddy(key, fetcher, options) {
   fetcherRef.current = fetcher;
   const keyRef = useRef(key);
   keyRef.current = key;
+  const staleTime = options?.staleTime ?? DEDUP_WINDOW_MS;
+  const staleTimeRef = useRef(staleTime);
+  staleTimeRef.current = staleTime;
   if (serialized != null && key != null) {
     coordinator.register(
       serialized,
       key,
-      (k, ctx) => fetcherRef.current(k, ctx)
+      (k, ctx) => fetcherRef.current(k, ctx),
+      { staleTime: staleTimeRef.current }
     );
   }
   const subscribe = useCallback(
@@ -483,7 +572,8 @@ function useSteddy(key, fetcher, options) {
       coordinator.register(
         serialized,
         originalKey,
-        (k, ctx) => fetcherRef.current(k, ctx)
+        (k, ctx) => fetcherRef.current(k, ctx),
+        { staleTime: staleTimeRef.current }
       );
       const unsubscribe = store.subscribe(serialized, onStoreChange);
       if (!coordinator.isInFlight(serialized)) {
@@ -519,15 +609,15 @@ function useSteddy(key, fetcher, options) {
   const previousRef = useRef(
     void 0
   );
-  if (serialized != null && snapshot.data !== void 0) {
+  if (serialized != null && snapshot.hasData) {
     previousRef.current = { serialized, data: snapshot.data };
   }
-  const data = keepPreviousData && serialized != null && snapshot.data === void 0 && snapshot.error == null && previousRef.current != null && previousRef.current.serialized !== serialized ? previousRef.current.data : snapshot.data;
+  const data = keepPreviousData && serialized != null && !snapshot.hasData && snapshot.error == null && previousRef.current != null && previousRef.current.serialized !== serialized ? previousRef.current.data : snapshot.data;
   if (options?.suspense && serialized != null) {
     if (snapshot.error != null) {
       throw snapshot.error;
     }
-    if (snapshot.data === void 0 && data === void 0) {
+    if (!snapshot.hasData && data === void 0) {
       const waiter = coordinator.getInFlightPromise(serialized) ?? coordinator.revalidate(serialized).catch(() => {
       });
       throw waiter;
@@ -536,7 +626,7 @@ function useSteddy(key, fetcher, options) {
   return {
     data,
     error: snapshot.error,
-    isLoading: serialized != null && data === void 0 && snapshot.error == null,
+    isLoading: serialized != null && !snapshot.hasData && snapshot.error == null && data === void 0,
     isValidating: snapshot.isValidating,
     mutate: boundMutate
   };
@@ -627,7 +717,7 @@ function useSteddyInfinite(getKey, fetcher, options) {
     );
     const fingerprint = currentPages.map((page) => {
       const entry = store.getSnapshot(page.serialized);
-      return `${page.serialized}:${entry.timestamp}:${entry.isValidating ? 1 : 0}:${entry.error == null ? 0 : 1}:${entry.data === void 0 ? 0 : 1}`;
+      return `${page.serialized}:${entry.timestamp}:${entry.isValidating ? 1 : 0}:${entry.error == null ? 0 : 1}:${entry.hasData ? 1 : 0}`;
     }).join("|");
     if (snapshotRef.current.fingerprint === fingerprint) {
       return snapshotRef.current;
@@ -644,7 +734,7 @@ function useSteddyInfinite(getKey, fetcher, options) {
       if (entry.error != null && error === void 0) {
         error = entry.error;
       }
-      if (entry.data === void 0) {
+      if (!entry.hasData) {
         missing = true;
         break;
       }
@@ -711,6 +801,7 @@ function useSteddyInfinite(getKey, fetcher, options) {
           }
           store.set(page.serialized, {
             data: pagesValue[index],
+            hasData: true,
             error: void 0,
             timestamp: Date.now(),
             isValidating: revalidate
@@ -740,7 +831,7 @@ function useSteddyInfinite(getKey, fetcher, options) {
   return {
     data: snapshot.data,
     error: snapshot.error,
-    isLoading: first != null && firstEntry?.data === void 0 && firstEntry?.error == null,
+    isLoading: first != null && !firstEntry?.hasData && firstEntry?.error == null,
     isValidating: snapshot.isValidating,
     size,
     setSize,
@@ -748,23 +839,37 @@ function useSteddyInfinite(getKey, fetcher, options) {
   };
 }
 
+// src/plugins/subscribedKeys.ts
+function keysWithSubscribers(keys, store) {
+  return keys.filter((key) => store.subscriberCount(key) > 0);
+}
+
 // src/plugins/focus.ts
-function focusRevalidate(coordinator) {
-  const onFocus = () => {
-    for (const key of coordinator.getRegisteredKeys()) {
+function focusRevalidate(coordinator, store) {
+  const run = () => {
+    if (typeof document !== "undefined" && document.visibilityState !== "visible") {
+      return;
+    }
+    const keys = store ? keysWithSubscribers(coordinator.getRegisteredKeys(), store) : coordinator.getRegisteredKeys();
+    for (const key of keys) {
       void coordinator.revalidate(key);
     }
   };
-  window.addEventListener("focus", onFocus);
+  if (typeof document === "undefined") {
+    return () => {
+    };
+  }
+  document.addEventListener("visibilitychange", run);
   return () => {
-    window.removeEventListener("focus", onFocus);
+    document.removeEventListener("visibilitychange", run);
   };
 }
 
 // src/plugins/reconnect.ts
-function reconnectRevalidate(coordinator) {
+function reconnectRevalidate(coordinator, store) {
   const onOnline = () => {
-    for (const key of coordinator.getRegisteredKeys()) {
+    const keys = store ? keysWithSubscribers(coordinator.getRegisteredKeys(), store) : coordinator.getRegisteredKeys();
+    for (const key of keys) {
       void coordinator.revalidate(key);
     }
   };
@@ -841,6 +946,67 @@ function ttlEvict(coordinator, options) {
   };
 }
 
-export { DEDUP_WINDOW_MS, SteddyProvider, UNSUBSCRIBE_GRACE_MS, clear, createCoordinator, createMutate, createRuntime, createStore, defaultCoordinator, defaultStore, dump, focusRevalidate, hydrate, hydrateAll, mutate, pollingRevalidate, reconnectRevalidate, retryOnError, serializeKey, ttlEvict, useSteddy, useSteddyInfinite };
+// src/plugins/measure.ts
+function measurePerf(coordinator, onEvent) {
+  const snap = {
+    starts: 0,
+    aborts: 0,
+    dedups: 0,
+    writes: 0,
+    errors: 0,
+    totalMs: 0
+  };
+  const stop = coordinator.subscribe((event) => {
+    switch (event.type) {
+      case "start":
+        snap.starts += 1;
+        break;
+      case "abort":
+        snap.aborts += 1;
+        snap.totalMs += event.ms;
+        break;
+      case "dedup":
+        snap.dedups += 1;
+        break;
+      case "write":
+        snap.writes += 1;
+        snap.totalMs += event.ms;
+        break;
+      case "error":
+        snap.errors += 1;
+        snap.totalMs += event.ms;
+        break;
+    }
+    onEvent?.(event);
+  });
+  return {
+    snapshot: () => ({ ...snap }),
+    reset() {
+      snap.starts = 0;
+      snap.aborts = 0;
+      snap.dedups = 0;
+      snap.writes = 0;
+      snap.errors = 0;
+      snap.totalMs = 0;
+    },
+    stop
+  };
+}
+
+// src/plugins/attachDefaults.ts
+function attachDefaults(coordinator, store, options) {
+  const stops = [
+    focusRevalidate(coordinator, store),
+    reconnectRevalidate(coordinator, store),
+    ttlEvict(coordinator, options?.ttl ?? { maxAge: 3e5 })
+  ];
+  return () => {
+    for (const stop of stops) {
+      stop();
+    }
+  };
+}
+
+export { DEDUP_WINDOW_MS, SteddyProvider, UNSUBSCRIBE_GRACE_MS, attachDefaults, clear, createCoordinator, createMutate, createRuntime, createStore, defaultCoordinator, defaultStore, dump, focusRevalidate, hydrate, hydrateAll, measurePerf, mutate, pollingRevalidate, prefetch, reconnectRevalidate, retryOnError, serializeKey, ttlEvict, useSteddy, useSteddyInfinite };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map