@sweidos/eidos 0.1.0

package/dist/eidos.es.js

@@ -0,0 +1,880 @@
+import require$$0, { useEffect } from "react";
+import { jsx, Fragment } from "react/jsx-runtime";
+const __vite_import_meta_env__$1 = {};
+const createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const destroy = () => {
+    if ((__vite_import_meta_env__$1 ? "production" : void 0) !== "production") {
+      console.warn(
+        "[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected."
+      );
+    }
+    listeners.clear();
+  };
+  const api = { setState, getState, getInitialState, subscribe, destroy };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+const createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var withSelector = { exports: {} };
+var withSelector_production = {};
+var shim = { exports: {} };
+var useSyncExternalStoreShim_production = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_production;
+function requireUseSyncExternalStoreShim_production() {
+  if (hasRequiredUseSyncExternalStoreShim_production) return useSyncExternalStoreShim_production;
+  hasRequiredUseSyncExternalStoreShim_production = 1;
+  var React = require$$0;
+  function is(x, y) {
+    return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+  }
+  var objectIs = "function" === typeof Object.is ? Object.is : is, useState = React.useState, useEffect2 = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue2 = React.useDebugValue;
+  function useSyncExternalStore$2(subscribe, getSnapshot) {
+    var value = getSnapshot(), _useState = useState({ inst: { value, getSnapshot } }), inst = _useState[0].inst, forceUpdate = _useState[1];
+    useLayoutEffect(
+      function() {
+        inst.value = value;
+        inst.getSnapshot = getSnapshot;
+        checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+      },
+      [subscribe, value, getSnapshot]
+    );
+    useEffect2(
+      function() {
+        checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        return subscribe(function() {
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        });
+      },
+      [subscribe]
+    );
+    useDebugValue2(value);
+    return value;
+  }
+  function checkIfSnapshotChanged(inst) {
+    var latestGetSnapshot = inst.getSnapshot;
+    inst = inst.value;
+    try {
+      var nextValue = latestGetSnapshot();
+      return !objectIs(inst, nextValue);
+    } catch (error) {
+      return true;
+    }
+  }
+  function useSyncExternalStore$1(subscribe, getSnapshot) {
+    return getSnapshot();
+  }
+  var shim2 = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+  useSyncExternalStoreShim_production.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim2;
+  return useSyncExternalStoreShim_production;
+}
+var useSyncExternalStoreShim_development = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_development;
+function requireUseSyncExternalStoreShim_development() {
+  if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+  hasRequiredUseSyncExternalStoreShim_development = 1;
+  "production" !== process.env.NODE_ENV && function() {
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    function useSyncExternalStore$2(subscribe, getSnapshot) {
+      didWarnOld18Alpha || void 0 === React.startTransition || (didWarnOld18Alpha = true, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var value = getSnapshot();
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedValue = getSnapshot();
+        objectIs(value, cachedValue) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), didWarnUncachedGetSnapshot = true);
+      }
+      cachedValue = useState({
+        inst: { value, getSnapshot }
+      });
+      var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
+      useLayoutEffect(
+        function() {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        },
+        [subscribe, value, getSnapshot]
+      );
+      useEffect2(
+        function() {
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          return subscribe(function() {
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          });
+        },
+        [subscribe]
+      );
+      useDebugValue2(value);
+      return value;
+    }
+    function checkIfSnapshotChanged(inst) {
+      var latestGetSnapshot = inst.getSnapshot;
+      inst = inst.value;
+      try {
+        var nextValue = latestGetSnapshot();
+        return !objectIs(inst, nextValue);
+      } catch (error) {
+        return true;
+      }
+    }
+    function useSyncExternalStore$1(subscribe, getSnapshot) {
+      return getSnapshot();
+    }
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var React = require$$0, objectIs = "function" === typeof Object.is ? Object.is : is, useState = React.useState, useEffect2 = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue2 = React.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim2 = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+    useSyncExternalStoreShim_development.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim2;
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }();
+  return useSyncExternalStoreShim_development;
+}
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim) return shim.exports;
+  hasRequiredShim = 1;
+  if (process.env.NODE_ENV === "production") {
+    shim.exports = requireUseSyncExternalStoreShim_production();
+  } else {
+    shim.exports = requireUseSyncExternalStoreShim_development();
+  }
+  return shim.exports;
+}
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredWithSelector_production;
+function requireWithSelector_production() {
+  if (hasRequiredWithSelector_production) return withSelector_production;
+  hasRequiredWithSelector_production = 1;
+  var React = require$$0, shim2 = requireShim();
+  function is(x, y) {
+    return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+  }
+  var objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim2.useSyncExternalStore, useRef = React.useRef, useEffect2 = React.useEffect, useMemo = React.useMemo, useDebugValue2 = React.useDebugValue;
+  withSelector_production.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+    var instRef = useRef(null);
+    if (null === instRef.current) {
+      var inst = { hasValue: false, value: null };
+      instRef.current = inst;
+    } else inst = instRef.current;
+    instRef = useMemo(
+      function() {
+        function memoizedSelector(nextSnapshot) {
+          if (!hasMemo) {
+            hasMemo = true;
+            memoizedSnapshot = nextSnapshot;
+            nextSnapshot = selector(nextSnapshot);
+            if (void 0 !== isEqual && inst.hasValue) {
+              var currentSelection = inst.value;
+              if (isEqual(currentSelection, nextSnapshot))
+                return memoizedSelection = currentSelection;
+            }
+            return memoizedSelection = nextSnapshot;
+          }
+          currentSelection = memoizedSelection;
+          if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+          var nextSelection = selector(nextSnapshot);
+          if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
+            return memoizedSnapshot = nextSnapshot, currentSelection;
+          memoizedSnapshot = nextSnapshot;
+          return memoizedSelection = nextSelection;
+        }
+        var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+        return [
+          function() {
+            return memoizedSelector(getSnapshot());
+          },
+          null === maybeGetServerSnapshot ? void 0 : function() {
+            return memoizedSelector(maybeGetServerSnapshot());
+          }
+        ];
+      },
+      [getSnapshot, getServerSnapshot, selector, isEqual]
+    );
+    var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+    useEffect2(
+      function() {
+        inst.hasValue = true;
+        inst.value = value;
+      },
+      [value]
+    );
+    useDebugValue2(value);
+    return value;
+  };
+  return withSelector_production;
+}
+var withSelector_development = {};
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredWithSelector_development;
+function requireWithSelector_development() {
+  if (hasRequiredWithSelector_development) return withSelector_development;
+  hasRequiredWithSelector_development = 1;
+  "production" !== process.env.NODE_ENV && function() {
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var React = require$$0, shim2 = requireShim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim2.useSyncExternalStore, useRef = React.useRef, useEffect2 = React.useEffect, useMemo = React.useMemo, useDebugValue2 = React.useDebugValue;
+    withSelector_development.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+      var instRef = useRef(null);
+      if (null === instRef.current) {
+        var inst = { hasValue: false, value: null };
+        instRef.current = inst;
+      } else inst = instRef.current;
+      instRef = useMemo(
+        function() {
+          function memoizedSelector(nextSnapshot) {
+            if (!hasMemo) {
+              hasMemo = true;
+              memoizedSnapshot = nextSnapshot;
+              nextSnapshot = selector(nextSnapshot);
+              if (void 0 !== isEqual && inst.hasValue) {
+                var currentSelection = inst.value;
+                if (isEqual(currentSelection, nextSnapshot))
+                  return memoizedSelection = currentSelection;
+              }
+              return memoizedSelection = nextSnapshot;
+            }
+            currentSelection = memoizedSelection;
+            if (objectIs(memoizedSnapshot, nextSnapshot))
+              return currentSelection;
+            var nextSelection = selector(nextSnapshot);
+            if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
+              return memoizedSnapshot = nextSnapshot, currentSelection;
+            memoizedSnapshot = nextSnapshot;
+            return memoizedSelection = nextSelection;
+          }
+          var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+          return [
+            function() {
+              return memoizedSelector(getSnapshot());
+            },
+            null === maybeGetServerSnapshot ? void 0 : function() {
+              return memoizedSelector(maybeGetServerSnapshot());
+            }
+          ];
+        },
+        [getSnapshot, getServerSnapshot, selector, isEqual]
+      );
+      var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+      useEffect2(
+        function() {
+          inst.hasValue = true;
+          inst.value = value;
+        },
+        [value]
+      );
+      useDebugValue2(value);
+      return value;
+    };
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }();
+  return withSelector_development;
+}
+if (process.env.NODE_ENV === "production") {
+  withSelector.exports = requireWithSelector_production();
+} else {
+  withSelector.exports = requireWithSelector_development();
+}
+var withSelectorExports = withSelector.exports;
+const useSyncExternalStoreExports = /* @__PURE__ */ getDefaultExportFromCjs(withSelectorExports);
+const __vite_import_meta_env__ = {};
+const { useDebugValue } = require$$0;
+const { useSyncExternalStoreWithSelector } = useSyncExternalStoreExports;
+let didWarnAboutEqualityFn = false;
+const identity = (arg) => arg;
+function useStore(api, selector = identity, equalityFn) {
+  if ((__vite_import_meta_env__ ? "production" : void 0) !== "production" && equalityFn && !didWarnAboutEqualityFn) {
+    console.warn(
+      "[DEPRECATED] Use `createWithEqualityFn` instead of `create` or use `useStoreWithEqualityFn` instead of `useStore`. They can be imported from 'zustand/traditional'. https://github.com/pmndrs/zustand/discussions/1937"
+    );
+    didWarnAboutEqualityFn = true;
+  }
+  const slice = useSyncExternalStoreWithSelector(
+    api.subscribe,
+    api.getState,
+    api.getServerState || api.getInitialState,
+    selector,
+    equalityFn
+  );
+  useDebugValue(slice);
+  return slice;
+}
+const createImpl = (createState) => {
+  if ((__vite_import_meta_env__ ? "production" : void 0) !== "production" && typeof createState !== "function") {
+    console.warn(
+      "[DEPRECATED] Passing a vanilla store will be unsupported in a future version. Instead use `import { useStore } from 'zustand'`."
+    );
+  }
+  const api = typeof createState === "function" ? createStore(createState) : createState;
+  const useBoundStore = (selector, equalityFn) => useStore(api, selector, equalityFn);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+const create = (createState) => createState ? createImpl(createState) : createImpl;
+const useEidosStore = create((set) => ({
+  isOnline: typeof navigator !== "undefined" ? navigator.onLine : true,
+  swStatus: "idle",
+  swError: void 0,
+  resources: {},
+  queue: [],
+  setOnline: (isOnline) => set({ isOnline }),
+  setSwStatus: (swStatus, swError) => set({ swStatus, swError }),
+  registerResource: (url, entry) => set((s) => ({ resources: { ...s.resources, [url]: entry } })),
+  updateResource: (url, update) => set((s) => ({
+    resources: {
+      ...s.resources,
+      [url]: s.resources[url] ? { ...s.resources[url], ...update } : s.resources[url]
+    }
+  })),
+  unregisterResource: (url) => set((s) => {
+    const { [url]: _removed, ...rest } = s.resources;
+    return { resources: rest };
+  }),
+  addQueueItem: (item) => set((s) => ({ queue: [...s.queue, item] })),
+  updateQueueItem: (id, update) => set((s) => ({
+    queue: s.queue.map((item) => item.id === id ? { ...item, ...update } : item)
+  })),
+  removeQueueItem: (id) => set((s) => ({ queue: s.queue.filter((item) => item.id !== id) })),
+  hydrateQueue: (items) => set({ queue: items })
+}));
+let _registration = null;
+async function registerServiceWorker(swPath) {
+  if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) {
+    useEidosStore.getState().setSwStatus("unsupported");
+    return;
+  }
+  const store = useEidosStore.getState();
+  store.setSwStatus("registering");
+  try {
+    _registration = await navigator.serviceWorker.register(swPath, { scope: "/" });
+    await waitForActivation(_registration);
+    store.setSwStatus("active");
+    navigator.serviceWorker.addEventListener("message", onSwMessage);
+    window.addEventListener("online", () => store.setOnline(true));
+    window.addEventListener("offline", () => store.setOnline(false));
+    flushResourceRegistrations();
+  } catch (err) {
+    store.setSwStatus("error", String(err));
+  }
+}
+function waitForActivation(reg) {
+  return new Promise((resolve) => {
+    if (reg.active) {
+      resolve();
+      return;
+    }
+    const sw = reg.installing ?? reg.waiting;
+    if (!sw) {
+      resolve();
+      return;
+    }
+    sw.addEventListener("statechange", function handler() {
+      if (sw.state === "activated") {
+        sw.removeEventListener("statechange", handler);
+        resolve();
+      }
+    });
+  });
+}
+function sendToWorker(message) {
+  const sw = _registration == null ? void 0 : _registration.active;
+  if (sw) sw.postMessage(message);
+}
+function onSwMessage(event) {
+  const data = event.data;
+  if (!(data == null ? void 0 : data.type)) return;
+  const store = useEidosStore.getState();
+  const { type, url } = data;
+  if (!url) return;
+  switch (type) {
+    case "EIDOS_CACHE_HIT": {
+      const current = store.resources[url];
+      store.updateResource(url, {
+        status: "fresh",
+        lastEvent: "cache-hit",
+        cacheHits: ((current == null ? void 0 : current.cacheHits) ?? 0) + 1
+      });
+      break;
+    }
+    case "EIDOS_CACHE_UPDATED": {
+      store.updateResource(url, {
+        status: "fresh",
+        lastEvent: "cache-updated",
+        cachedAt: Date.now()
+      });
+      break;
+    }
+    case "EIDOS_NETWORK_ERROR": {
+      store.updateResource(url, {
+        status: "error",
+        lastEvent: "network-error"
+      });
+      break;
+    }
+  }
+}
+function setOfflineSimulation(enabled) {
+  sendToWorker({ type: "EIDOS_SIMULATE_OFFLINE", enabled });
+  useEidosStore.getState().setOnline(!enabled);
+}
+function flushResourceRegistrations() {
+  const { resources } = useEidosStore.getState();
+  Object.values(resources).forEach((entry) => {
+    sendToWorker({
+      type: "EIDOS_REGISTER_RESOURCE",
+      url: entry.url,
+      strategy: entry.strategy.swStrategy,
+      cacheName: entry.strategy.cacheName
+    });
+  });
+}
+const _registry = /* @__PURE__ */ new Map();
+function resource(url, config) {
+  if (_registry.has(url)) return _registry.get(url);
+  const strategy = deriveStrategy(url, config);
+  const entry = {
+    url,
+    config,
+    strategy,
+    status: "idle",
+    cacheHits: 0,
+    cacheMisses: 0
+  };
+  useEidosStore.getState().registerResource(url, entry);
+  sendToWorker({
+    type: "EIDOS_REGISTER_RESOURCE",
+    url,
+    strategy: strategy.swStrategy,
+    cacheName: strategy.cacheName
+  });
+  const handle = {
+    url,
+    config,
+    strategy,
+    fetch: async () => {
+      const store = useEidosStore.getState();
+      store.updateResource(url, { status: "fetching", fetchedAt: Date.now() });
+      try {
+        const cache = await caches.open(strategy.cacheName).catch(() => null);
+        const cached = cache ? await cache.match(url).catch(() => null) : null;
+        if (cached) {
+          const current2 = useEidosStore.getState().resources[url];
+          store.updateResource(url, {
+            status: "fresh",
+            lastEvent: "cache-hit",
+            cacheHits: ((current2 == null ? void 0 : current2.cacheHits) ?? 0) + 1
+          });
+          if (strategy.swStrategy === "stale-while-revalidate") {
+            fetch(url).then(async (resp) => {
+              if (resp.ok && cache) {
+                await cache.put(url, resp.clone());
+                useEidosStore.getState().updateResource(url, {
+                  cachedAt: Date.now(),
+                  lastEvent: "cache-updated"
+                });
+              }
+            }).catch(() => {
+            });
+          }
+          return cached;
+        }
+        const current = useEidosStore.getState().resources[url];
+        store.updateResource(url, {
+          cacheMisses: ((current == null ? void 0 : current.cacheMisses) ?? 0) + 1
+        });
+        const response = await fetch(url);
+        if (response.ok) {
+          if (cache) await cache.put(url, response.clone());
+          store.updateResource(url, {
+            status: "fresh",
+            cachedAt: Date.now(),
+            lastEvent: "cache-updated"
+          });
+          return response;
+        }
+        store.updateResource(url, { status: response.status === 503 ? "offline" : "error" });
+        const isOffline = response.headers.get("X-Eidos-Offline") === "true";
+        throw new Error(
+          isOffline ? `offline: no cached response for ${url}` : `${response.status} ${response.statusText}`
+        );
+      } catch (err) {
+        const cache = await caches.open(strategy.cacheName).catch(() => null);
+        const fallback = cache ? await cache.match(url).catch(() => null) : null;
+        if (fallback) {
+          const current = useEidosStore.getState().resources[url];
+          store.updateResource(url, {
+            status: "fresh",
+            lastEvent: "cache-hit",
+            cacheHits: ((current == null ? void 0 : current.cacheHits) ?? 0) + 1
+          });
+          return fallback;
+        }
+        store.updateResource(url, { status: "error" });
+        throw err;
+      }
+    },
+    json: async () => {
+      const res = await handle.fetch();
+      return res.json();
+    },
+    query: () => ({
+      queryKey: ["eidos", url],
+      queryFn: () => handle.json()
+    }),
+    prefetch: async () => {
+      await handle.fetch();
+    },
+    invalidate: async () => {
+      sendToWorker({ type: "EIDOS_CLEAR_CACHE", url });
+      const cache = await caches.open(strategy.cacheName).catch(() => null);
+      if (cache) {
+        const keys = await cache.keys();
+        await Promise.all(
+          keys.filter((r) => new URL(r.url).pathname === url).map((r) => cache.delete(r))
+        );
+      }
+      useEidosStore.getState().updateResource(url, {
+        status: "stale",
+        cachedAt: void 0,
+        lastEvent: "cache-cleared",
+        cacheHits: 0,
+        cacheMisses: 0
+      });
+    }
+  };
+  _registry.set(url, handle);
+  return handle;
+}
+function deriveStrategy(url, config) {
+  const explicit = config.strategy;
+  if (config.offline) return buildStrategy(explicit ?? "stale-while-revalidate");
+  return buildStrategy(explicit ?? "network-first");
+}
+const STRATEGY_META = {
+  "stale-while-revalidate": {
+    name: "StaleWhileRevalidate",
+    reasoning: "offline: true signals resilience. SWR returns cached data instantly while revalidating in the background — the best tradeoff between speed and freshness for offline-capable resources.",
+    behavior: [
+      "Cache hit → return immediately, kick off background revalidation",
+      "Cache miss → fetch from network, cache the response, return it",
+      "Offline → return cached version if available, 503 if not",
+      "Reconnect → next request triggers a background refresh"
+    ],
+    equivalentCode: `// Workbox equivalent
+new StaleWhileRevalidate({
+  cacheName: 'eidos-resources-v1',
+  plugins: [new ExpirationPlugin({ maxEntries: 60 })],
+})`
+  },
+  "cache-first": {
+    name: "CacheFirst",
+    reasoning: "cache-first maximises speed and offline availability. Network is consulted only on cache miss. Best for static or infrequently-updated data.",
+    behavior: [
+      "Cache hit → return immediately, no network request made",
+      "Cache miss → fetch from network, cache the response, return it",
+      "Offline → return cached version, 503 if cache is empty",
+      "Cache never expires unless explicitly invalidated"
+    ],
+    equivalentCode: `// Workbox equivalent
+new CacheFirst({
+  cacheName: 'eidos-resources-v1',
+  plugins: [new ExpirationPlugin({ maxEntries: 60 })],
+})`
+  },
+  "network-first": {
+    name: "NetworkFirst",
+    reasoning: "network-first prioritises fresh data. Cache acts as a safety net when offline. Best for frequently-updated resources where stale data causes problems.",
+    behavior: [
+      "Always try network first",
+      "Network success → update cache, return fresh response",
+      "Network failure → fall back to cached version",
+      "Offline with empty cache → return 503 error response"
+    ],
+    equivalentCode: `// Workbox equivalent
+new NetworkFirst({
+  cacheName: 'eidos-resources-v1',
+  networkTimeoutSeconds: 3,
+})`
+  }
+};
+function buildStrategy(swStrategy, _url) {
+  return {
+    ...STRATEGY_META[swStrategy],
+    swStrategy,
+    cacheName: "eidos-resources-v1"
+  };
+}
+const DB_NAME = "eidos";
+const DB_VERSION = 1;
+const QUEUE_STORE = "action-queue";
+let _db = null;
+function openDB() {
+  if (_db) return Promise.resolve(_db);
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      if (!db.objectStoreNames.contains(QUEUE_STORE)) {
+        const store = db.createObjectStore(QUEUE_STORE, { keyPath: "id" });
+        store.createIndex("status", "status", { unique: false });
+        store.createIndex("actionId", "actionId", { unique: false });
+      }
+    };
+    req.onsuccess = () => {
+      _db = req.result;
+      resolve(req.result);
+    };
+    req.onerror = () => reject(req.error);
+  });
+}
+async function idbAddToQueue(item) {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(QUEUE_STORE, "readwrite");
+    tx.objectStore(QUEUE_STORE).add(item);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+async function idbGetQueue() {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(QUEUE_STORE, "readonly");
+    const req = tx.objectStore(QUEUE_STORE).getAll();
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function idbUpdateQueueItem(id, update) {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(QUEUE_STORE, "readwrite");
+    const store = tx.objectStore(QUEUE_STORE);
+    const get = store.get(id);
+    get.onsuccess = () => {
+      if (get.result) store.put({ ...get.result, ...update });
+    };
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+async function idbRemoveFromQueue(id) {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(QUEUE_STORE, "readwrite");
+    tx.objectStore(QUEUE_STORE).delete(id);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+const _actionRegistry = /* @__PURE__ */ new Map();
+function uid() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+}
+function action(fn, config) {
+  const actionId = config.name ?? fn.name ?? uid();
+  _actionRegistry.set(actionId, fn);
+  const wrapped = async (...args) => {
+    const { isOnline } = useEidosStore.getState();
+    if (config.reliability === "neverLose") {
+      if (!isOnline) {
+        return persistAndQueue(actionId, fn.name || actionId, args, config);
+      }
+      try {
+        return await fn(...args);
+      } catch {
+        return persistAndQueue(actionId, fn.name || actionId, args, config);
+      }
+    }
+    return fn(...args);
+  };
+  Object.defineProperty(wrapped, "id", { value: actionId, writable: false });
+  Object.defineProperty(wrapped, "config", { value: config, writable: false });
+  return wrapped;
+}
+async function persistAndQueue(actionId, actionName, args, config) {
+  const id = uid();
+  const item = {
+    id,
+    actionId,
+    actionName,
+    args,
+    queuedAt: Date.now(),
+    retryCount: 0,
+    maxRetries: config.maxRetries ?? 3,
+    status: "pending"
+  };
+  await idbAddToQueue(item);
+  useEidosStore.getState().addQueueItem(item);
+  return {
+    queued: true,
+    id,
+    message: `"${actionName}" queued — will execute when online`
+  };
+}
+async function replayQueue() {
+  const store = useEidosStore.getState();
+  if (!store.isOnline) return;
+  const queue = await idbGetQueue();
+  const pending = queue.filter(
+    (item) => item.status === "pending" || item.status === "failed"
+  );
+  for (const item of pending) {
+    const fn = _actionRegistry.get(item.actionId);
+    if (!fn) continue;
+    store.updateQueueItem(item.id, { status: "replaying" });
+    await idbUpdateQueueItem(item.id, { status: "replaying" });
+    try {
+      await fn(...item.args);
+      const completedAt = Date.now();
+      store.updateQueueItem(item.id, { status: "succeeded", completedAt });
+      await idbUpdateQueueItem(item.id, { status: "succeeded", completedAt });
+      setTimeout(() => {
+        store.removeQueueItem(item.id);
+        idbRemoveFromQueue(item.id);
+      }, 3e3);
+    } catch (err) {
+      const retryCount = item.retryCount + 1;
+      if (retryCount >= item.maxRetries) {
+        store.updateQueueItem(item.id, {
+          status: "failed",
+          error: String(err),
+          retryCount
+        });
+        await idbUpdateQueueItem(item.id, {
+          status: "failed",
+          error: String(err),
+          retryCount
+        });
+      } else {
+        store.updateQueueItem(item.id, { status: "pending", retryCount });
+        await idbUpdateQueueItem(item.id, { status: "pending", retryCount });
+      }
+    }
+  }
+}
+let _initialized = false;
+async function initEidos(config = {}) {
+  if (_initialized) return;
+  _initialized = true;
+  const swPath = config.swPath ?? "/eidos-sw.js";
+  const autoReplay = config.autoReplay ?? true;
+  try {
+    const persisted = await idbGetQueue();
+    if (persisted.length > 0) {
+      useEidosStore.getState().hydrateQueue(persisted);
+    }
+  } catch {
+  }
+  try {
+    await registerServiceWorker(swPath);
+  } catch {
+  }
+  if (autoReplay) {
+    let prevIsOnline = useEidosStore.getState().isOnline;
+    useEidosStore.subscribe((state) => {
+      const justCameOnline = state.isOnline && !prevIsOnline;
+      prevIsOnline = state.isOnline;
+      if (justCameOnline) {
+        setTimeout(replayQueue, 600);
+      }
+    });
+    const store = useEidosStore.getState();
+    const hasPending = store.queue.some((q) => q.status === "pending" || q.status === "failed");
+    if (store.isOnline && hasPending) {
+      setTimeout(replayQueue, 1200);
+    }
+  }
+}
+function EidosProvider({ children, swPath, autoReplay }) {
+  useEffect(() => {
+    initEidos({ swPath, autoReplay });
+  }, []);
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+function useEidos() {
+  return useEidosStore();
+}
+function useEidosResource(url) {
+  return useEidosStore((s) => s.resources[url]);
+}
+function useEidosQueue() {
+  return useEidosStore((s) => s.queue);
+}
+function useEidosStatus() {
+  return useEidosStore((s) => ({
+    isOnline: s.isOnline,
+    swStatus: s.swStatus,
+    swError: s.swError
+  }));
+}
+export {
+  EidosProvider,
+  action,
+  initEidos,
+  replayQueue,
+  resource,
+  setOfflineSimulation,
+  useEidos,
+  useEidosQueue,
+  useEidosResource,
+  useEidosStatus,
+  useEidosStore
+};
+//# sourceMappingURL=eidos.es.js.map