steddy 0.1.0

package/dist/index.js

@@ -0,0 +1,764 @@
+import { createContext, useMemo, useRef, useCallback, useSyncExternalStore, useState, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/useSteddy.ts
+
+// src/coordinator.ts
+var DEDUP_WINDOW_MS = 2e3;
+function isAbortError(error) {
+  return typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+function createCoordinator(store) {
+  const registered = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  let generation = 0;
+  function abortInternal(serializedKey, markIdle) {
+    const current = inflight.get(serializedKey);
+    if (!current) {
+      return;
+    }
+    current.controller.abort();
+    current.settle();
+    inflight.delete(serializedKey);
+    if (markIdle) {
+      const entry = store.get(serializedKey);
+      if (entry?.isValidating) {
+        store.set(serializedKey, { ...entry, isValidating: false });
+      }
+    }
+  }
+  const coordinator = {
+    register(serializedKey, key, fetcher) {
+      registered.set(serializedKey, { key, fetcher });
+    },
+    unregister(serializedKey) {
+      registered.delete(serializedKey);
+    },
+    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) {
+          return;
+        }
+      }
+      abortInternal(serializedKey, false);
+      const record = registered.get(serializedKey);
+      const key = record?.key ?? serializedKey;
+      const run = fetcher ?? record?.fetcher;
+      if (!run) {
+        return;
+      }
+      const controller = new AbortController();
+      const currentGeneration = ++generation;
+      let settled = false;
+      let settleWaiter;
+      const waiter = new Promise((resolve) => {
+        settleWaiter = resolve;
+      });
+      const settle = () => {
+        if (!settled) {
+          settled = true;
+          settleWaiter();
+        }
+      };
+      inflight.set(serializedKey, {
+        controller,
+        generation: currentGeneration,
+        waiter,
+        settle
+      });
+      const previous = store.get(serializedKey);
+      store.set(serializedKey, {
+        data: previous?.data,
+        error: previous?.error,
+        timestamp: previous?.timestamp ?? 0,
+        isValidating: true
+      });
+      try {
+        const data = await run(key, { signal: controller.signal });
+        const stillCurrent = inflight.get(serializedKey)?.generation === currentGeneration;
+        if (!stillCurrent || controller.signal.aborted) {
+          return;
+        }
+        inflight.delete(serializedKey);
+        store.set(serializedKey, {
+          data,
+          error: void 0,
+          timestamp: Date.now(),
+          isValidating: false
+        });
+      } catch (error) {
+        const stillCurrent = inflight.get(serializedKey)?.generation === currentGeneration;
+        if (!stillCurrent || controller.signal.aborted || isAbortError(error)) {
+          return;
+        }
+        inflight.delete(serializedKey);
+        const current = store.get(serializedKey);
+        store.set(serializedKey, {
+          data: current?.data,
+          error,
+          timestamp: current?.timestamp ?? 0,
+          isValidating: false
+        });
+        throw error;
+      } finally {
+        settle();
+      }
+    },
+    isInFlight(serializedKey) {
+      return inflight.has(serializedKey);
+    },
+    getInFlightPromise(serializedKey) {
+      return inflight.get(serializedKey)?.waiter;
+    },
+    getRegisteredKeys() {
+      return [...registered.keys()];
+    },
+    abort(serializedKey) {
+      abortInternal(serializedKey, true);
+    },
+    evict(options) {
+      const now = Date.now();
+      const removable = [];
+      for (const key of store.keys()) {
+        if (inflight.has(key) || store.subscriberCount(key) > 0) {
+          continue;
+        }
+        const entry = store.get(key);
+        if (!entry) {
+          continue;
+        }
+        removable.push({ key, timestamp: entry.timestamp });
+      }
+      const victims = /* @__PURE__ */ new Set();
+      if (options.maxAge != null) {
+        for (const item of removable) {
+          if (now - item.timestamp >= options.maxAge) {
+            victims.add(item.key);
+          }
+        }
+      }
+      if (options.maxKeys != null) {
+        const liveCount = store.keys().filter((key) => !victims.has(key)).length;
+        let over = liveCount - options.maxKeys;
+        if (over > 0) {
+          const extra = removable.filter((item) => !victims.has(item.key)).sort((a, b) => a.timestamp - b.timestamp);
+          for (const item of extra) {
+            if (over <= 0) {
+              break;
+            }
+            victims.add(item.key);
+            over -= 1;
+          }
+        }
+      }
+      for (const key of victims) {
+        abortInternal(key, false);
+        registered.delete(key);
+        store.delete(key);
+      }
+      return [...victims];
+    },
+    reset() {
+      for (const key of [...inflight.keys()]) {
+        abortInternal(key, false);
+      }
+      registered.clear();
+    }
+  };
+  return coordinator;
+}
+
+// src/store.ts
+var EMPTY_SNAPSHOT = Object.freeze({
+  data: void 0,
+  error: void 0,
+  timestamp: 0,
+  isValidating: false
+});
+function createStore() {
+  const entries = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  function emit(key) {
+    const subs = listeners.get(key);
+    if (!subs) {
+      return;
+    }
+    for (const callback of subs) {
+      callback();
+    }
+  }
+  return {
+    get(key) {
+      return entries.get(key);
+    },
+    set(key, entry) {
+      entries.set(key, entry);
+      emit(key);
+    },
+    delete(key) {
+      const existed = entries.delete(key);
+      if (existed) {
+        emit(key);
+      }
+    },
+    subscribe(key, callback) {
+      let subs = listeners.get(key);
+      if (!subs) {
+        subs = /* @__PURE__ */ new Set();
+        listeners.set(key, subs);
+      }
+      subs.add(callback);
+      return () => {
+        const current = listeners.get(key);
+        if (!current) {
+          return;
+        }
+        current.delete(callback);
+        if (current.size === 0) {
+          listeners.delete(key);
+        }
+      };
+    },
+    getSnapshot(key) {
+      return entries.get(key) ?? EMPTY_SNAPSHOT;
+    },
+    subscriberCount(key) {
+      return listeners.get(key)?.size ?? 0;
+    },
+    keys() {
+      return [...entries.keys()];
+    },
+    clear() {
+      const keys = /* @__PURE__ */ new Set([...entries.keys(), ...listeners.keys()]);
+      entries.clear();
+      for (const key of keys) {
+        emit(key);
+      }
+    }
+  };
+}
+
+// src/defaults.ts
+var defaultStore = createStore();
+var defaultCoordinator = createCoordinator(defaultStore);
+
+// src/key.ts
+function serializeKey(key) {
+  if (typeof key === "string") {
+    return key;
+  }
+  return JSON.stringify(key);
+}
+function keysShallowEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return false;
+  }
+  if (typeof a === "string" || typeof b === "string") {
+    return a === b;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (!Object.is(a[i], b[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/mutate.ts
+function isThenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function createMutate(store, coordinator) {
+  return async function mutate2(key, updater, options) {
+    const revalidate = options?.revalidate ?? true;
+    const rollbackOnError = options?.rollbackOnError ?? true;
+    const serialized = serializeKey(key);
+    const previous = store.get(serialized);
+    const restore = () => {
+      if (previous === void 0) {
+        store.delete(serialized);
+      } else {
+        store.set(serialized, previous);
+      }
+    };
+    try {
+      const currentData = previous?.data;
+      const next = typeof updater === "function" ? updater(currentData) : updater;
+      if (isThenable(next)) {
+        store.set(serialized, {
+          data: currentData,
+          error: previous?.error,
+          timestamp: previous?.timestamp ?? 0,
+          isValidating: true
+        });
+        const resolved = await next;
+        store.set(serialized, {
+          data: resolved,
+          error: void 0,
+          timestamp: Date.now(),
+          isValidating: revalidate
+        });
+      } else {
+        store.set(serialized, {
+          data: next,
+          error: void 0,
+          timestamp: Date.now(),
+          isValidating: revalidate
+        });
+      }
+      if (revalidate) {
+        await coordinator.revalidate(serialized, void 0, { force: true });
+      }
+      return store.get(serialized)?.data;
+    } catch (error) {
+      if (rollbackOnError) {
+        restore();
+      } else {
+        const current = store.get(serialized);
+        store.set(serialized, {
+          data: current?.data,
+          error,
+          timestamp: current?.timestamp ?? Date.now(),
+          isValidating: false
+        });
+      }
+      throw error;
+    }
+  };
+}
+var mutate = createMutate(defaultStore, defaultCoordinator);
+function createRuntime() {
+  const store = createStore();
+  const coordinator = createCoordinator(store);
+  return {
+    store,
+    coordinator,
+    mutate: createMutate(store, coordinator)
+  };
+}
+var defaultRuntime = {
+  store: defaultStore,
+  coordinator: defaultCoordinator,
+  mutate: createMutate(defaultStore, defaultCoordinator)
+};
+var SteddyContext = createContext(defaultRuntime);
+function SteddyProvider({
+  store,
+  coordinator,
+  cache,
+  children
+}) {
+  const value = useMemo(() => {
+    if (cache) {
+      hydrateAll(cache, store);
+    }
+    return {
+      store,
+      coordinator,
+      mutate: createMutate(store, coordinator)
+    };
+  }, [store, coordinator, cache]);
+  return /* @__PURE__ */ jsx(SteddyContext.Provider, { value, children });
+}
+function useSteddyRuntime() {
+  return useContext(SteddyContext);
+}
+function hydrate(key, data, store = defaultStore) {
+  store.set(serializeKey(key), {
+    data,
+    error: void 0,
+    timestamp: 0,
+    isValidating: false
+  });
+}
+function dump(store = defaultStore) {
+  const snapshot = {};
+  for (const key of store.keys()) {
+    const entry = store.get(key);
+    if (!entry || entry.data === void 0) {
+      continue;
+    }
+    snapshot[key] = { data: entry.data, timestamp: entry.timestamp };
+  }
+  return snapshot;
+}
+function hydrateAll(snapshot, store = defaultStore) {
+  for (const [key, payload] of Object.entries(snapshot)) {
+    store.set(key, {
+      data: payload.data,
+      error: void 0,
+      timestamp: 0,
+      isValidating: false
+    });
+  }
+}
+function clear(key, runtime = defaultRuntime) {
+  if (key === void 0) {
+    for (const active of runtime.coordinator.getRegisteredKeys()) {
+      runtime.coordinator.abort(active);
+    }
+    runtime.coordinator.reset();
+    runtime.store.clear();
+    return;
+  }
+  const serialized = serializeKey(key);
+  runtime.coordinator.abort(serialized);
+  runtime.coordinator.unregister(serialized);
+  runtime.store.delete(serialized);
+}
+
+// src/useSteddy.ts
+function useSerializedKey(key) {
+  const prevKey = useRef(null);
+  const prevSerialized = useRef(null);
+  if (key == null) {
+    prevKey.current = null;
+    prevSerialized.current = null;
+    return null;
+  }
+  if (prevSerialized.current != null && keysShallowEqual(prevKey.current, key)) {
+    return prevSerialized.current;
+  }
+  prevKey.current = key;
+  prevSerialized.current = serializeKey(key);
+  return prevSerialized.current;
+}
+function useSteddy(key, fetcher, options) {
+  const { store, coordinator, mutate: runtimeMutate } = useSteddyRuntime();
+  const serialized = useSerializedKey(key);
+  const fetcherRef = useRef(fetcher);
+  fetcherRef.current = fetcher;
+  const keyRef = useRef(key);
+  keyRef.current = key;
+  if (serialized != null && key != null) {
+    coordinator.register(
+      serialized,
+      key,
+      (k, ctx) => fetcherRef.current(k, ctx)
+    );
+  }
+  const subscribe = useCallback(
+    (onStoreChange) => {
+      if (serialized == null || keyRef.current == null) {
+        return () => {
+        };
+      }
+      const originalKey = keyRef.current;
+      coordinator.register(
+        serialized,
+        originalKey,
+        (k, ctx) => fetcherRef.current(k, ctx)
+      );
+      const unsubscribe = store.subscribe(serialized, onStoreChange);
+      if (!coordinator.isInFlight(serialized)) {
+        void coordinator.revalidate(serialized).catch(() => {
+        });
+      }
+      return () => {
+        unsubscribe();
+        if (store.subscriberCount(serialized) === 0) {
+          coordinator.abort(serialized);
+          coordinator.unregister(serialized);
+        }
+      };
+    },
+    [serialized, store, coordinator]
+  );
+  const getSnapshot = useCallback(() => {
+    if (serialized == null) {
+      return EMPTY_SNAPSHOT;
+    }
+    return store.getSnapshot(serialized);
+  }, [serialized, store]);
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const boundMutate = useCallback(
+    (updater, mutateOptions) => {
+      if (keyRef.current == null) {
+        return Promise.resolve(void 0);
+      }
+      return runtimeMutate(keyRef.current, updater, mutateOptions);
+    },
+    [runtimeMutate]
+  );
+  if (options?.suspense && serialized != null) {
+    if (snapshot.error != null) {
+      throw snapshot.error;
+    }
+    if (snapshot.data === void 0) {
+      const waiter = coordinator.getInFlightPromise(serialized) ?? coordinator.revalidate(serialized).catch(() => {
+      });
+      throw waiter;
+    }
+  }
+  return {
+    data: snapshot.data,
+    error: snapshot.error,
+    isLoading: serialized != null && snapshot.data === void 0 && snapshot.error == null,
+    isValidating: snapshot.isValidating,
+    mutate: boundMutate
+  };
+}
+function collectPages(getKey, getData, size) {
+  const pages = [];
+  let previous;
+  for (let index = 0; index < size; index++) {
+    const key = getKey(index, previous);
+    if (key == null) {
+      break;
+    }
+    const serialized = serializeKey(key);
+    pages.push({ key, serialized });
+    previous = getData(serialized);
+  }
+  return pages;
+}
+function useSteddyInfinite(getKey, fetcher, options) {
+  const { store, coordinator, mutate: runtimeMutate } = useSteddyRuntime();
+  const [size, setSizeState] = useState(options?.initialSize ?? 1);
+  const fetcherRef = useRef(fetcher);
+  fetcherRef.current = fetcher;
+  const getKeyRef = useRef(getKey);
+  getKeyRef.current = getKey;
+  const pages = collectPages(
+    getKey,
+    (serialized) => store.get(serialized)?.data,
+    size
+  );
+  const serializedList = pages.map((page) => page.serialized).join("\0");
+  for (const page of pages) {
+    coordinator.register(
+      page.serialized,
+      page.key,
+      (k, ctx) => fetcherRef.current(k, ctx)
+    );
+  }
+  const subscribe = useCallback(
+    (onStoreChange) => {
+      const currentPages = collectPages(
+        getKeyRef.current,
+        (serialized) => store.get(serialized)?.data,
+        size
+      );
+      const unsubscribes = currentPages.map((page) => {
+        coordinator.register(
+          page.serialized,
+          page.key,
+          (k, ctx) => fetcherRef.current(k, ctx)
+        );
+        if (!coordinator.isInFlight(page.serialized)) {
+          void coordinator.revalidate(page.serialized).catch(() => {
+          });
+        }
+        return store.subscribe(page.serialized, onStoreChange);
+      });
+      return () => {
+        for (const [index, page] of currentPages.entries()) {
+          unsubscribes[index]?.();
+          if (store.subscriberCount(page.serialized) === 0) {
+            coordinator.abort(page.serialized);
+            coordinator.unregister(page.serialized);
+          }
+        }
+      };
+    },
+    [serializedList, size, store, coordinator]
+  );
+  const snapshotRef = useRef({
+    fingerprint: "",
+    data: void 0,
+    error: void 0,
+    isValidating: false
+  });
+  const getSnapshot = useCallback(() => {
+    const currentPages = collectPages(
+      getKeyRef.current,
+      (serialized) => store.get(serialized)?.data,
+      size
+    );
+    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}`;
+    }).join("|");
+    if (snapshotRef.current.fingerprint === fingerprint) {
+      return snapshotRef.current;
+    }
+    const loaded = [];
+    let error;
+    let isValidating = false;
+    let missing = false;
+    for (const page of currentPages) {
+      const entry = store.getSnapshot(page.serialized);
+      if (entry.isValidating) {
+        isValidating = true;
+      }
+      if (entry.error != null && error === void 0) {
+        error = entry.error;
+      }
+      if (entry.data === void 0) {
+        missing = true;
+        break;
+      }
+      loaded.push(entry.data);
+    }
+    snapshotRef.current = {
+      fingerprint,
+      data: missing && loaded.length === 0 ? void 0 : loaded,
+      error,
+      isValidating
+    };
+    return snapshotRef.current;
+  }, [serializedList, size, store]);
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const setSize = useCallback(
+    (next) => {
+      setSizeState(
+        (current) => typeof next === "function" ? next(current) : next
+      );
+    },
+    []
+  );
+  const boundMutate = useCallback(
+    async (updater, mutateOptions) => {
+      const currentPages = collectPages(
+        getKeyRef.current,
+        (serialized) => store.get(serialized)?.data,
+        size
+      );
+      const first2 = currentPages[0];
+      if (!first2) {
+        return void 0;
+      }
+      if (updater !== void 0 && typeof updater !== "function") {
+        const pagesValue = updater;
+        const firstPage = pagesValue[0];
+        if (firstPage !== void 0) {
+          await runtimeMutate(first2.key, firstPage, mutateOptions);
+        }
+        return pagesValue;
+      }
+      await Promise.all(
+        currentPages.map(
+          (page) => coordinator.revalidate(page.serialized, void 0, { force: true }).catch(() => {
+          })
+        )
+      );
+      return currentPages.map((page) => store.get(page.serialized)?.data).filter((page) => page !== void 0);
+    },
+    [coordinator, runtimeMutate, size, store]
+  );
+  const first = pages[0];
+  const firstEntry = first ? store.getSnapshot(first.serialized) : void 0;
+  return {
+    data: snapshot.data,
+    error: snapshot.error,
+    isLoading: first != null && firstEntry?.data === void 0 && firstEntry?.error == null,
+    isValidating: snapshot.isValidating,
+    size,
+    setSize,
+    mutate: boundMutate
+  };
+}
+
+// src/plugins/focus.ts
+function focusRevalidate(coordinator) {
+  const onFocus = () => {
+    for (const key of coordinator.getRegisteredKeys()) {
+      void coordinator.revalidate(key);
+    }
+  };
+  window.addEventListener("focus", onFocus);
+  return () => {
+    window.removeEventListener("focus", onFocus);
+  };
+}
+
+// src/plugins/reconnect.ts
+function reconnectRevalidate(coordinator) {
+  const onOnline = () => {
+    for (const key of coordinator.getRegisteredKeys()) {
+      void coordinator.revalidate(key);
+    }
+  };
+  window.addEventListener("online", onOnline);
+  return () => {
+    window.removeEventListener("online", onOnline);
+  };
+}
+
+// src/plugins/polling.ts
+function pollingRevalidate(coordinator, key, interval) {
+  const id = setInterval(() => {
+    void coordinator.revalidate(key);
+  }, interval);
+  return () => {
+    clearInterval(id);
+  };
+}
+
+// src/plugins/retry.ts
+function isAbortError2(error) {
+  return typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const id = setTimeout(resolve, ms);
+    const onAbort = () => {
+      clearTimeout(id);
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function retryOnError(_coordinator, options) {
+  return (fetcher) => async (key, context) => {
+    let lastError;
+    for (let attempt = 0; attempt < options.attempts; attempt++) {
+      if (context.signal.aborted) {
+        throw context.signal.reason ?? new DOMException("Aborted", "AbortError");
+      }
+      try {
+        return await fetcher(key, context);
+      } catch (error) {
+        lastError = error;
+        if (isAbortError2(error) || attempt === options.attempts - 1) {
+          break;
+        }
+        await sleep(options.backoff * 2 ** attempt, context.signal);
+      }
+    }
+    throw lastError;
+  };
+}
+
+// src/plugins/ttl.ts
+function ttlEvict(coordinator, options) {
+  const maxAge = options.maxAge;
+  const maxKeys = options.maxKeys;
+  const evictOptions = {
+    ...maxAge != null ? { maxAge } : {},
+    ...maxKeys != null ? { maxKeys } : {}
+  };
+  const tick = () => {
+    coordinator.evict(evictOptions);
+  };
+  tick();
+  const id = setInterval(tick, options.interval ?? 3e4);
+  return () => {
+    clearInterval(id);
+  };
+}
+
+export { DEDUP_WINDOW_MS, SteddyProvider, clear, createCoordinator, createMutate, createRuntime, createStore, defaultCoordinator, defaultStore, dump, focusRevalidate, hydrate, hydrateAll, mutate, pollingRevalidate, reconnectRevalidate, retryOnError, serializeKey, ttlEvict, useSteddy, useSteddyInfinite };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map