@sweidos/eidos 1.0.17 → 1.0.20

package/dist/eidos.es.js

@@ -1,333 +1,285 @@
-import { jsx, Fragment } from "react/jsx-runtime";
-import { useEffect, useRef, useSyncExternalStore } from "react";
-let _state;
-const _listeners = /* @__PURE__ */ new Set();
-function _notify() {
-  _listeners.forEach((fn) => fn());
-}
-function _set(updater) {
-  _state = { ..._state, ...updater(_state) };
-  _notify();
-}
-_state = {
-  isOnline: typeof navigator !== "undefined" ? navigator.onLine : true,
+import { jsx as B, Fragment as F } from "react/jsx-runtime";
+import { useEffect as U, useRef as N, useSyncExternalStore as $ } from "react";
+let y;
+const D = /* @__PURE__ */ new Set();
+function W() {
+  D.forEach((e) => e());
+}
+function g(e) {
+  y = { ...y, ...e(y) }, W();
+}
+y = {
+  isOnline: typeof navigator < "u" ? navigator.onLine : !0,
   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) => ({
+  setOnline: (e) => g(() => ({ isOnline: e })),
+  setSwStatus: (e, t) => g(() => ({ swStatus: e, swError: t })),
+  registerResource: (e, t) => g((n) => ({ resources: { ...n.resources, [e]: t } })),
+  updateResource: (e, t) => g((n) => ({
     resources: {
-      ...s.resources,
-      [url]: s.resources[url] ? { ...s.resources[url], ...update } : s.resources[url]
+      ...n.resources,
+      [e]: n.resources[e] ? { ...n.resources[e], ...t } : n.resources[e]
     }
   })),
-  unregisterResource: (url) => _set((s) => {
-    const { [url]: _removed, ...rest } = s.resources;
-    return { resources: rest };
+  unregisterResource: (e) => g((t) => {
+    const { [e]: n, ...r } = t.resources;
+    return { resources: r };
   }),
-  addQueueItem: (item) => _set((s) => ({ queue: [...s.queue, item] })),
-  updateQueueItem: (id, update) => _set((s) => ({
-    queue: s.queue.map((item) => item.id === id ? { ...item, ...update } : item)
+  addQueueItem: (e) => g((t) => ({ queue: [...t.queue, e] })),
+  updateQueueItem: (e, t) => g((n) => ({
+    queue: n.queue.map((r) => r.id === e ? { ...r, ...t } : r)
   })),
-  removeQueueItem: (id) => _set((s) => ({ queue: s.queue.filter((item) => item.id !== id) })),
-  hydrateQueue: (items) => _set(() => ({ queue: items }))
+  removeQueueItem: (e) => g((t) => ({ queue: t.queue.filter((n) => n.id !== e) })),
+  hydrateQueue: (e) => g(() => ({ queue: e }))
 };
-function _getState() {
-  return _state;
+function G() {
+  return y;
 }
-function _subscribe(listener) {
-  _listeners.add(listener);
-  return () => {
-    _listeners.delete(listener);
+function K(e) {
+  return D.add(e), () => {
+    D.delete(e);
   };
 }
-const useEidosStore = {
-  getState: _getState,
-  subscribe: _subscribe,
+const o = {
+  getState: G,
+  subscribe: K,
   // Test/devtools helper — merges partial state, preserves action methods.
-  setState: (partial) => {
-    const update = typeof partial === "function" ? partial(_state) : partial;
-    _state = { ..._state, ...update };
-    _notify();
+  setState: (e) => {
+    const t = typeof e == "function" ? e(y) : e;
+    y = { ...y, ...t }, W();
   }
 };
-let _registration = null;
-let _pendingMessages = [];
-function getSwRegistration() {
-  return _registration;
-}
-async function registerServiceWorker(swPath) {
-  if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) {
-    useEidosStore.getState().setSwStatus("unsupported");
+let w = null, Q = [];
+function V() {
+  return w;
+}
+async function Y(e) {
+  if (typeof navigator > "u" || !("serviceWorker" in navigator)) {
+    o.getState().setSwStatus("unsupported");
     return;
   }
-  const store = useEidosStore.getState();
-  store.setSwStatus("registering");
+  const t = o.getState();
+  t.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));
-    flushPendingMessages();
-  } catch (err) {
-    store.setSwStatus("error", String(err));
+    w = await navigator.serviceWorker.register(e, { scope: "/" }), await z(w), t.setSwStatus("active"), navigator.serviceWorker.addEventListener("message", J), window.addEventListener("online", () => t.setOnline(!0)), window.addEventListener("offline", () => t.setOnline(!1)), Z();
+  } catch (n) {
+    t.setSwStatus("error", String(n));
   }
 }
-function waitForActivation(reg) {
-  return new Promise((resolve) => {
-    if (reg.active) {
-      resolve();
+function z(e) {
+  return new Promise((t) => {
+    if (e.active) {
+      t();
       return;
     }
-    const sw = reg.installing ?? reg.waiting;
-    if (!sw) {
-      resolve();
+    const n = e.installing ?? e.waiting;
+    if (!n) {
+      t();
       return;
     }
-    const timer = setTimeout(resolve, 1e4);
-    sw.addEventListener("statechange", function handler() {
-      if (sw.state === "activated") {
-        clearTimeout(timer);
-        sw.removeEventListener("statechange", handler);
-        resolve();
-      }
+    const r = setTimeout(t, 1e4);
+    n.addEventListener("statechange", function s() {
+      n.state === "activated" && (clearTimeout(r), n.removeEventListener("statechange", s), t());
     });
   });
 }
-function sendToWorker(message) {
-  const sw = _registration == null ? void 0 : _registration.active;
-  if (sw) {
-    sw.postMessage(message);
-  } else {
-    _pendingMessages.push(message);
-  }
+function q(e) {
+  const t = w == null ? void 0 : w.active;
+  t ? t.postMessage(e) : Q.push(e);
 }
-let _bgSyncHandler = null;
-function registerBgSyncHandler(fn) {
-  _bgSyncHandler = fn;
+let O = null;
+function X(e) {
+  O = e;
 }
-function isBgSyncSupported() {
+function we() {
   try {
-    return typeof navigator !== "undefined" && "serviceWorker" in navigator && _registration !== null && "sync" in _registration;
+    return typeof navigator < "u" && "serviceWorker" in navigator && w !== null && "sync" in w;
   } catch {
-    return false;
+    return !1;
   }
 }
-function onSwMessage(event) {
-  const data = event.data;
-  if (!(data == null ? void 0 : data.type)) return;
-  const store = useEidosStore.getState();
-  const { type, url } = data;
-  if (type === "EIDOS_BACKGROUND_SYNC") {
-    _bgSyncHandler == null ? void 0 : _bgSyncHandler();
+function J(e) {
+  const t = e.data;
+  if (!(t != null && t.type)) return;
+  const n = o.getState(), { type: r, url: s } = t;
+  if (r === "EIDOS_BACKGROUND_SYNC") {
+    O == null || O();
     return;
   }
-  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;
+  if (s)
+    switch (r) {
+      case "EIDOS_CACHE_HIT": {
+        const i = n.resources[s];
+        n.updateResource(s, {
+          status: "fresh",
+          lastEvent: "cache-hit",
+          cacheHits: ((i == null ? void 0 : i.cacheHits) ?? 0) + 1
+        });
+        break;
+      }
+      case "EIDOS_CACHE_UPDATED": {
+        n.updateResource(s, {
+          status: "fresh",
+          lastEvent: "cache-updated",
+          cachedAt: Date.now()
+        });
+        break;
+      }
+      case "EIDOS_NETWORK_ERROR": {
+        n.updateResource(s, {
+          status: "error",
+          lastEvent: "network-error"
+        });
+        break;
+      }
     }
-  }
 }
-function setOfflineSimulation(enabled) {
-  sendToWorker({ type: "EIDOS_SIMULATE_OFFLINE", enabled });
-  useEidosStore.getState().setOnline(!enabled);
+function ge(e) {
+  q({ type: "EIDOS_SIMULATE_OFFLINE", enabled: e }), o.getState().setOnline(!e);
+}
+function Z() {
+  const e = w == null ? void 0 : w.active;
+  if (e) {
+    for (const t of Q) e.postMessage(t);
+    Q = [];
+  }
 }
-function flushPendingMessages() {
-  const sw = _registration == null ? void 0 : _registration.active;
-  if (!sw) return;
-  for (const msg of _pendingMessages) sw.postMessage(msg);
-  _pendingMessages = [];
+const R = /* @__PURE__ */ new Map();
+let x = null;
+function ye(e) {
+  x = e;
 }
-const _registry = /* @__PURE__ */ new Map();
-function isPattern(url) {
-  return url.includes("*") || /:[^/]+/.test(url);
+function S(e) {
+  return e.includes("*") || /:[^/]+/.test(e);
 }
-function patternToRegexStr(pattern) {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-  return "^" + escaped.replace(/\*\*/g, ".+").replace(/\*/g, "[^/]+").replace(/:[^/]+/g, "[^/]+") + "$";
+function ee(e) {
+  return "^" + e.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".+").replace(/\*/g, "[^/]+").replace(/:[^/]+/g, "[^/]+") + "$";
 }
-function _patternError(url, method) {
+function b(e, t) {
   return new Error(
-    `[eidos] resource('${url}') is a URL pattern — ${method}() is not supported on pattern handles. The SW intercepts matching requests automatically; call fetch(specificUrl) directly in your app code.`
+    `[eidos] resource('${e}') is a URL pattern — ${t}() is not supported on pattern handles. The SW intercepts matching requests automatically; call fetch(specificUrl) directly in your app code.`
   );
 }
-function resource(url, config) {
-  if (_registry.has(url)) {
-    return _registry.get(url);
-  }
-  const strategy = deriveStrategy(url, config);
-  const regexStr = isPattern(url) ? patternToRegexStr(url) : void 0;
-  const entry = {
-    url,
-    config,
-    strategy,
+function Se(e, t) {
+  if (R.has(e))
+    return R.get(e);
+  const n = te(e, t), r = S(e) ? ee(e) : void 0, s = {
+    url: e,
+    config: t,
+    strategy: n,
     status: "idle",
     cacheHits: 0,
     cacheMisses: 0
   };
-  useEidosStore.getState().registerResource(url, entry);
-  sendToWorker({
+  o.getState().registerResource(e, s), q({
     type: "EIDOS_REGISTER_RESOURCE",
-    url,
-    strategy: strategy.swStrategy,
-    cacheName: strategy.cacheName,
-    ...regexStr !== void 0 && { pattern: regexStr }
+    url: e,
+    strategy: n.swStrategy,
+    cacheName: n.cacheName,
+    ...r !== void 0 && { pattern: r }
   });
-  const handle = {
-    url,
-    config,
-    strategy,
+  const i = {
+    url: e,
+    config: t,
+    strategy: n,
     fetch: async () => {
-      if (isPattern(url)) throw _patternError(url, "fetch");
-      const store = useEidosStore.getState();
-      store.updateResource(url, { status: "fetching", fetchedAt: Date.now() });
-      const cache = await caches.open(strategy.cacheName).catch(() => null);
+      if (S(e)) throw b(e, "fetch");
+      const a = o.getState();
+      a.updateResource(e, { status: "fetching", fetchedAt: Date.now() });
+      const c = await caches.open(n.cacheName).catch(() => null);
       try {
-        if (strategy.swStrategy !== "network-first") {
-          const cached = cache ? await cache.match(url).catch(() => null) : null;
-          const current = useEidosStore.getState().resources[url];
-          const expired = config.maxAge !== void 0 && (current == null ? void 0 : current.cachedAt) !== void 0 && Date.now() - current.cachedAt > config.maxAge;
-          if (cached && !expired) {
-            store.updateResource(url, {
+        if (n.swStrategy !== "network-first") {
+          const d = c ? await c.match(e).catch(() => null) : null, f = o.getState().resources[e], E = t.maxAge !== void 0 && (f == null ? void 0 : f.cachedAt) !== void 0 && Date.now() - f.cachedAt > t.maxAge;
+          if (d && !E)
+            return a.updateResource(e, {
               status: "fresh",
               lastEvent: "cache-hit",
-              cacheHits: ((current == null ? void 0 : current.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 storeEntry = useEidosStore.getState().resources[url];
-          store.updateResource(url, {
-            cacheMisses: ((storeEntry == null ? void 0 : storeEntry.cacheMisses) ?? 0) + 1
+              cacheHits: ((f == null ? void 0 : f.cacheHits) ?? 0) + 1
+            }), n.swStrategy === "stale-while-revalidate" && fetch(e).then(async (P) => {
+              P.ok && c && (await c.put(e, P.clone()), o.getState().updateResource(e, {
+                cachedAt: Date.now(),
+                lastEvent: "cache-updated"
+              }));
+            }).catch(() => {
+            }), d;
+          const I = o.getState().resources[e];
+          a.updateResource(e, {
+            cacheMisses: ((I == null ? void 0 : I.cacheMisses) ?? 0) + 1
           });
         }
-        const response = await fetch(url);
-        if (response.ok) {
-          if (cache) await cache.put(url, response.clone());
-          store.updateResource(url, {
+        const u = await fetch(e);
+        if (u.ok)
+          return c && await c.put(e, u.clone()), a.updateResource(e, {
             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";
+          }), u;
+        a.updateResource(e, { status: u.status === 503 ? "offline" : "error" });
+        const l = u.headers.get("X-Eidos-Offline") === "true";
         throw new Error(
-          isOffline ? `offline: no cached response for ${url}` : `${response.status} ${response.statusText}`
+          l ? `offline: no cached response for ${e}` : `${u.status} ${u.statusText}`
         );
-      } catch (err) {
-        const fallback = cache ? await cache.match(url).catch(() => null) : null;
-        if (fallback) {
-          const current = useEidosStore.getState().resources[url];
-          store.updateResource(url, {
+      } catch (u) {
+        const l = c ? await c.match(e).catch(() => null) : null;
+        if (l) {
+          const d = o.getState().resources[e];
+          return a.updateResource(e, {
             status: "fresh",
             lastEvent: "cache-hit",
-            cacheHits: ((current == null ? void 0 : current.cacheHits) ?? 0) + 1
-          });
-          return fallback;
+            cacheHits: ((d == null ? void 0 : d.cacheHits) ?? 0) + 1
+          }), l;
         }
-        store.updateResource(url, { status: "error" });
-        throw err;
+        throw a.updateResource(e, { status: "error" }), u;
       }
     },
     json: async () => {
-      if (isPattern(url)) throw _patternError(url, "json");
-      const res = await handle.fetch();
-      return res.json();
+      if (S(e)) throw b(e, "json");
+      return (await i.fetch()).json();
     },
     query: () => {
-      if (isPattern(url)) throw _patternError(url, "query");
+      if (S(e)) throw b(e, "query");
       return {
-        queryKey: ["eidos", url],
-        queryFn: () => handle.json()
+        queryKey: ["eidos", e],
+        queryFn: () => i.json()
       };
     },
     prefetch: async () => {
-      if (isPattern(url)) throw _patternError(url, "prefetch");
-      await handle.fetch();
+      if (S(e)) throw b(e, "prefetch");
+      await i.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();
-        const patternRe = regexStr ? new RegExp(regexStr) : null;
-        const isCrossOrigin = url.startsWith("http");
+      q({ type: "EIDOS_CLEAR_CACHE", url: e });
+      const a = await caches.open(n.cacheName).catch(() => null);
+      if (a) {
+        const c = await a.keys(), u = r ? new RegExp(r) : null, l = e.startsWith("http");
         await Promise.all(
-          keys.filter((r) => {
-            const rUrl = r.url;
-            const p = new URL(rUrl).pathname;
-            if (patternRe) {
-              return patternRe.test(isCrossOrigin ? rUrl : p);
-            }
-            return isCrossOrigin ? rUrl === url : rUrl === url || p === url;
-          }).map((r) => cache.delete(r))
+          c.filter((d) => {
+            const f = d.url, E = new URL(f).pathname;
+            return u ? u.test(l ? f : E) : l ? f === e : f === e || E === e;
+          }).map((d) => a.delete(d))
         );
       }
-      if (!isPattern(url)) {
-        useEidosStore.getState().updateResource(url, {
-          status: "stale",
-          cachedAt: void 0,
-          lastEvent: "cache-cleared",
-          cacheHits: 0,
-          cacheMisses: 0
-        });
-      }
+      S(e) || o.getState().updateResource(e, {
+        status: "stale",
+        cachedAt: void 0,
+        lastEvent: "cache-cleared",
+        cacheHits: 0,
+        cacheMisses: 0
+      }), x == null || x(["eidos", e]);
     },
     unregister: () => {
-      _registry.delete(url);
-      sendToWorker({ type: "EIDOS_UNREGISTER_RESOURCE", url });
-      useEidosStore.getState().unregisterResource(url);
+      R.delete(e), q({ type: "EIDOS_UNREGISTER_RESOURCE", url: e }), o.getState().unregisterResource(e);
     }
   };
-  _registry.set(url, handle);
-  return handle;
+  return R.set(e, i), i;
 }
-function deriveStrategy(url, config) {
-  const explicit = config.strategy;
-  if (config.offline) return buildStrategy(explicit ?? "stale-while-revalidate", url, config.cacheName);
-  return buildStrategy(explicit ?? "network-first", url, config.cacheName);
+function te(e, t) {
+  const n = t.strategy;
+  return t.offline ? T(n ?? "stale-while-revalidate", e, t.cacheName) : T(n ?? "network-first", e, t.cacheName);
 }
-const STRATEGY_META = {
+const ne = {
   "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.",
@@ -374,383 +326,296 @@ new NetworkFirst({
 })`
   }
 };
-function buildStrategy(swStrategy, _url, cacheName) {
+function T(e, t, n) {
   return {
-    ...STRATEGY_META[swStrategy],
-    swStrategy,
-    cacheName: cacheName ?? "eidos-resources-v1"
+    ...ne[e],
+    swStrategy: e,
+    cacheName: n ?? "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 });
+const se = "eidos", re = 1, h = "action-queue";
+let A = null;
+function m() {
+  return A ? Promise.resolve(A) : new Promise((e, t) => {
+    const n = indexedDB.open(se, re);
+    n.onupgradeneeded = (r) => {
+      const s = r.target.result;
+      if (!s.objectStoreNames.contains(h)) {
+        const i = s.createObjectStore(h, { keyPath: "id" });
+        i.createIndex("status", "status", { unique: !1 }), i.createIndex("actionId", "actionId", { unique: !1 });
       }
-    };
-    req.onsuccess = () => {
-      _db = req.result;
-      resolve(req.result);
-    };
-    req.onerror = () => reject(req.error);
+    }, n.onsuccess = () => {
+      A = n.result, e(n.result);
+    }, n.onerror = () => t(n.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 ae(e) {
+  const t = await m();
+  return new Promise((n, r) => {
+    const s = t.transaction(h, "readwrite");
+    s.objectStore(h).add(e), s.oncomplete = () => n(), s.onerror = () => r(s.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 ie() {
+  const e = await m();
+  return new Promise((t, n) => {
+    const s = e.transaction(h, "readonly").objectStore(h).getAll();
+    s.onsuccess = () => t(s.result), s.onerror = () => n(s.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 k(e, t) {
+  const n = await m();
+  return new Promise((r, s) => {
+    const i = n.transaction(h, "readwrite"), a = i.objectStore(h), c = a.get(e);
+    c.onsuccess = () => {
+      c.result && a.put({ ...c.result, ...t });
+    }, i.oncomplete = () => r(), i.onerror = () => s(i.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);
+async function oe(e) {
+  const t = await m();
+  return new Promise((n, r) => {
+    const s = t.transaction(h, "readwrite");
+    s.objectStore(h).delete(e), s.oncomplete = () => n(), s.onerror = () => r(s.error);
   });
 }
-async function idbGetPendingItems() {
-  const db = await openDB();
-  return new Promise((resolve, reject) => {
-    const tx = db.transaction(QUEUE_STORE, "readonly");
-    const index = tx.objectStore(QUEUE_STORE).index("status");
-    const results = [];
-    let done = 0;
-    function finish(err) {
-      if (err) {
-        reject(err);
+async function ce() {
+  const e = await m();
+  return new Promise((t, n) => {
+    const s = e.transaction(h, "readonly").objectStore(h).index("status"), i = [];
+    let a = 0;
+    function c(d) {
+      if (d) {
+        n(d);
         return;
       }
-      if (++done === 2) resolve(results);
+      ++a === 2 && t(i);
     }
-    const pendingReq = index.openCursor(IDBKeyRange.only("pending"));
-    pendingReq.onsuccess = (e) => {
-      const cursor = e.target.result;
-      if (cursor) {
-        results.push(cursor.value);
-        cursor.continue();
-      } else finish();
-    };
-    pendingReq.onerror = () => finish(pendingReq.error);
-    const failedReq = index.openCursor(IDBKeyRange.only("failed"));
-    failedReq.onsuccess = (e) => {
-      const cursor = e.target.result;
-      if (cursor) {
-        results.push(cursor.value);
-        cursor.continue();
-      } else finish();
-    };
-    failedReq.onerror = () => finish(failedReq.error);
+    const u = s.openCursor(IDBKeyRange.only("pending"));
+    u.onsuccess = (d) => {
+      const f = d.target.result;
+      f ? (i.push(f.value), f.continue()) : c();
+    }, u.onerror = () => c(u.error);
+    const l = s.openCursor(IDBKeyRange.only("failed"));
+    l.onsuccess = (d) => {
+      const f = d.target.result;
+      f ? (i.push(f.value), f.continue()) : c();
+    }, l.onerror = () => c(l.error);
   });
 }
-async function idbClearQueue() {
-  const db = await openDB();
-  return new Promise((resolve, reject) => {
-    const tx = db.transaction(QUEUE_STORE, "readwrite");
-    tx.objectStore(QUEUE_STORE).clear();
-    tx.oncomplete = () => resolve();
-    tx.onerror = () => reject(tx.error);
+async function ue() {
+  const e = await m();
+  return new Promise((t, n) => {
+    const r = e.transaction(h, "readwrite");
+    r.objectStore(h).clear(), r.oncomplete = () => t(), r.onerror = () => n(r.error);
   });
 }
-const _actionRegistry = /* @__PURE__ */ new Map();
-function uid() {
+const H = /* @__PURE__ */ new Map();
+function L() {
   return crypto.randomUUID();
 }
-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, actionId, args, config);
-      }
+function me(e, t) {
+  const n = t.name || e.name || L();
+  H.set(n, e);
+  const r = async (...s) => {
+    const { isOnline: i } = o.getState();
+    if (t.reliability === "neverLose") {
+      if (!i)
+        return j(n, n, s, t);
       try {
-        return await fn(...args);
+        return await e(...s);
       } catch {
-        return persistAndQueue(actionId, actionId, args, config);
+        return j(n, n, s, t);
       }
     }
-    return fn(...args);
+    return e(...s);
   };
-  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,
+  return Object.defineProperty(r, "id", { value: n, writable: !1 }), Object.defineProperty(r, "config", { value: t, writable: !1 }), r;
+}
+async function j(e, t, n, r) {
+  const s = L(), i = {
+    id: s,
+    actionId: e,
+    actionName: t,
+    args: n,
     queuedAt: Date.now(),
     retryCount: 0,
-    maxRetries: config.maxRetries ?? 3,
+    maxRetries: r.maxRetries ?? 3,
     status: "pending"
   };
-  await idbAddToQueue(item);
-  useEidosStore.getState().addQueueItem(item);
+  await ae(i), o.getState().addQueueItem(i);
   try {
-    const reg = getSwRegistration();
-    if (reg && "sync" in reg) {
-      await reg.sync.register("eidos-queue-replay");
-    }
+    const a = V();
+    a && "sync" in a && await a.sync.register("eidos-queue-replay");
   } catch {
   }
   return {
-    queued: true,
-    id,
-    message: `"${actionName}" queued — will execute when online`
+    queued: !0,
+    id: s,
+    message: `"${t}" queued — will execute when online`
   };
 }
-function backoffMs(retryCount) {
-  const base = Math.min(2e3 * 2 ** retryCount, 3e5);
-  return base * (0.8 + Math.random() * 0.4);
+function de(e) {
+  return Math.min(2e3 * 2 ** e, 3e5) * (0.8 + Math.random() * 0.4);
 }
-let _replaying = false;
-async function replayQueue() {
-  const store = useEidosStore.getState();
-  if (!store.isOnline || _replaying) {
+let _ = !1;
+async function C() {
+  const e = o.getState();
+  if (!e.isOnline || _)
     return { attempted: 0, succeeded: 0, failed: 0, retrying: 0, skipped: 0 };
-  }
-  _replaying = true;
+  _ = !0;
   try {
-    return await _doReplayQueue(store);
+    return await fe(e);
   } finally {
-    _replaying = false;
+    _ = !1;
   }
 }
-async function _doReplayQueue(store) {
-  const candidates = await idbGetPendingItems();
-  const now = Date.now();
-  const pending = candidates.filter(
-    (item) => !item.nextRetryAt || item.nextRetryAt <= now
-  );
-  const result = { attempted: 0, succeeded: 0, failed: 0, retrying: 0, skipped: 0 };
-  const outcomes = await Promise.allSettled(
-    pending.map(async (item) => {
-      const fn = _actionRegistry.get(item.actionId);
-      if (!fn) return "skipped";
-      store.updateQueueItem(item.id, { status: "replaying" });
-      await idbUpdateQueueItem(item.id, { status: "replaying" });
+async function fe(e) {
+  const t = await ce(), n = Date.now(), r = t.filter(
+    (a) => !a.nextRetryAt || a.nextRetryAt <= n
+  ), s = { attempted: 0, succeeded: 0, failed: 0, retrying: 0, skipped: 0 }, i = await Promise.allSettled(
+    r.map(async (a) => {
+      const c = H.get(a.actionId);
+      if (!c) return "skipped";
+      e.updateQueueItem(a.id, { status: "replaying" }), await k(a.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);
-        return "succeeded";
-      } 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 });
-          return "failed";
-        } else {
-          const nextRetryAt = Date.now() + backoffMs(retryCount);
-          store.updateQueueItem(item.id, { status: "pending", retryCount, nextRetryAt });
-          await idbUpdateQueueItem(item.id, { status: "pending", retryCount, nextRetryAt });
-          return "retrying";
+        await c(...a.args);
+        const u = Date.now();
+        return e.updateQueueItem(a.id, { status: "succeeded", completedAt: u }), await k(a.id, { status: "succeeded", completedAt: u }), setTimeout(() => {
+          e.removeQueueItem(a.id), oe(a.id);
+        }, 3e3), "succeeded";
+      } catch (u) {
+        const l = a.retryCount + 1;
+        if (l >= a.maxRetries)
+          return e.updateQueueItem(a.id, { status: "failed", error: String(u), retryCount: l }), await k(a.id, { status: "failed", error: String(u), retryCount: l }), "failed";
+        {
+          const d = Date.now() + de(l);
+          return e.updateQueueItem(a.id, { status: "pending", retryCount: l, nextRetryAt: d }), await k(a.id, { status: "pending", retryCount: l, nextRetryAt: d }), "retrying";
         }
       }
     })
   );
-  for (const o of outcomes) {
-    const outcome = o.status === "fulfilled" ? o.value : "failed";
-    if (outcome === "skipped") {
-      result.skipped++;
-    } else {
-      result.attempted++;
-      result[outcome]++;
-    }
+  for (const a of i) {
+    const c = a.status === "fulfilled" ? a.value : "failed";
+    c === "skipped" ? s.skipped++ : (s.attempted++, s[c]++);
   }
-  return result;
-}
-async function clearQueue() {
-  await idbClearQueue();
-  useEidosStore.getState().hydrateQueue([]);
-}
-let _initialized = false;
-async function initEidos(config = {}) {
-  if (_initialized) return;
-  _initialized = true;
-  const swPath = config.swPath ?? "/eidos-sw.js";
-  const autoReplay = config.autoReplay ?? true;
+  return s;
+}
+async function ve() {
+  await ue(), o.getState().hydrateQueue([]);
+}
+let M = !1;
+async function le(e = {}) {
+  if (M) return;
+  M = !0;
+  const t = e.swPath ?? "/eidos-sw.js", n = e.autoReplay ?? !0;
   try {
-    const persisted = await idbGetQueue();
-    if (persisted.length > 0) {
-      useEidosStore.getState().hydrateQueue(persisted);
-    }
+    const r = await ie();
+    r.length > 0 && o.getState().hydrateQueue(r);
   } catch {
   }
   try {
-    await registerServiceWorker(swPath);
+    await Y(t);
   } catch {
   }
-  registerBgSyncHandler(() => {
-    if (useEidosStore.getState().isOnline) {
-      setTimeout(replayQueue, 200);
-    }
-  });
-  if (autoReplay) {
-    let prevIsOnline = useEidosStore.getState().isOnline;
-    useEidosStore.subscribe(() => {
-      const { isOnline } = useEidosStore.getState();
-      const justCameOnline = isOnline && !prevIsOnline;
-      prevIsOnline = isOnline;
-      if (justCameOnline) {
-        setTimeout(replayQueue, 600);
-      }
+  if (X(() => {
+    o.getState().isOnline && setTimeout(C, 200);
+  }), n) {
+    let r = o.getState().isOnline;
+    o.subscribe(() => {
+      const { isOnline: a } = o.getState(), c = a && !r;
+      r = a, c && setTimeout(C, 600);
     });
-    const store = useEidosStore.getState();
-    const hasPending = store.queue.some((q) => q.status === "pending" || q.status === "failed");
-    if (store.isOnline && hasPending) {
-      setTimeout(replayQueue, 1200);
-    }
+    const s = o.getState(), i = s.queue.some((a) => a.status === "pending" || a.status === "failed");
+    s.isOnline && i && setTimeout(C, 1200);
   }
 }
-function EidosProvider({ children, swPath, autoReplay }) {
-  useEffect(() => {
-    initEidos({ swPath, autoReplay });
-  }, []);
-  return /* @__PURE__ */ jsx(Fragment, { children });
-}
-function useStore(selector) {
-  const fn = selector ?? ((s) => s);
-  return useSyncExternalStore(useEidosStore.subscribe, () => fn(useEidosStore.getState()));
-}
-function useEidos() {
-  return useStore();
-}
-function useEidosResource(url) {
-  return useStore((s) => s.resources[url]);
-}
-function useEidosQueue() {
-  return useStore((s) => s.queue);
-}
-function useEidosAction(id) {
-  return useStore((s) => s.queue.find((item) => item.id === id));
-}
-function useEidosStatus() {
-  const isOnline = useStore((s) => s.isOnline);
-  const swStatus = useStore((s) => s.swStatus);
-  const swError = useStore((s) => s.swError);
-  return { isOnline, swStatus, swError };
-}
-function useEidosQueueStats() {
-  const pending = useStore((s) => s.queue.filter((q) => q.status === "pending").length);
-  const failed = useStore((s) => s.queue.filter((q) => q.status === "failed").length);
-  const replaying = useStore((s) => s.queue.filter((q) => q.status === "replaying").length);
-  const total = useStore((s) => s.queue.length);
-  return { pending, failed, replaying, total };
-}
-function useEidosOnDrain(callback) {
-  const total = useStore((s) => s.queue.length);
-  const prevRef = useRef(0);
-  const callbackRef = useRef(callback);
-  callbackRef.current = callback;
-  useEffect(() => {
-    if (prevRef.current > 0 && total === 0) {
-      callbackRef.current();
-    }
-    prevRef.current = total;
-  }, [total]);
+function Ee({ children: e, swPath: t, autoReplay: n }) {
+  return U(() => {
+    le({ swPath: t, autoReplay: n });
+  }, []), /* @__PURE__ */ B(F, { children: e });
+}
+function p(e) {
+  const t = e ?? ((n) => n);
+  return $(o.subscribe, () => t(o.getState()));
+}
+function Re() {
+  return p();
+}
+function be(e) {
+  return p((t) => t.resources[e]);
+}
+function ke() {
+  return p((e) => e.queue);
+}
+function qe(e) {
+  return p((t) => t.queue.find((n) => n.id === e));
+}
+function Oe() {
+  const e = p((r) => r.isOnline), t = p((r) => r.swStatus), n = p((r) => r.swError);
+  return { isOnline: e, swStatus: t, swError: n };
+}
+function xe() {
+  const e = p((s) => s.queue.filter((i) => i.status === "pending").length), t = p((s) => s.queue.filter((i) => i.status === "failed").length), n = p((s) => s.queue.filter((i) => i.status === "replaying").length), r = p((s) => s.queue.length);
+  return { pending: e, failed: t, replaying: n, total: r };
+}
+function Ie(e) {
+  const t = p((s) => s.queue.length), n = N(0), r = N(e);
+  r.current = e, U(() => {
+    n.current > 0 && t === 0 && r.current(), n.current = t;
+  }, [t]);
 }
-const VERSION = "1.0.12";
-function readable(selector) {
+const Ae = "1.0.12";
+function v(e) {
   return {
-    subscribe(run) {
-      run(selector(useEidosStore.getState()));
-      return useEidosStore.subscribe(() => run(selector(useEidosStore.getState())));
+    subscribe(t) {
+      return t(e(o.getState())), o.subscribe(() => t(e(o.getState())));
     },
     getState() {
-      return selector(useEidosStore.getState());
+      return e(o.getState());
     }
   };
 }
-const eidosStore = readable((s) => s);
-const eidosQueue = readable((s) => s.queue);
-const eidosStatus = readable((s) => ({
-  isOnline: s.isOnline,
-  swStatus: s.swStatus,
-  swError: s.swError
-}));
-const eidosQueueStats = readable((s) => ({
-  pending: s.queue.filter((q) => q.status === "pending").length,
-  failed: s.queue.filter((q) => q.status === "failed").length,
-  replaying: s.queue.filter((q) => q.status === "replaying").length,
-  total: s.queue.length
-}));
-function eidosResource(url) {
-  return readable((s) => s.resources[url]);
-}
-function eidosAction(id) {
-  return readable((s) => s.queue.find((item) => item.id === id));
+const _e = v((e) => e), Ce = v((e) => e.queue), De = v((e) => ({
+  isOnline: e.isOnline,
+  swStatus: e.swStatus,
+  swError: e.swError
+})), Qe = v((e) => {
+  let t = 0, n = 0, r = 0;
+  for (const s of e.queue)
+    s.status === "pending" ? t++ : s.status === "failed" ? n++ : s.status === "replaying" && r++;
+  return { pending: t, failed: n, replaying: r, total: e.queue.length };
+});
+function Pe(e) {
+  return v((t) => t.resources[e]);
+}
+function Ne(e) {
+  return v((t) => t.queue.find((n) => n.id === e));
 }
 export {
-  EidosProvider,
-  VERSION,
-  action,
-  clearQueue,
-  eidosAction,
-  eidosQueue,
-  eidosQueueStats,
-  eidosResource,
-  eidosStatus,
-  eidosStore,
-  initEidos,
-  isBgSyncSupported,
-  replayQueue,
-  resource,
-  setOfflineSimulation,
-  useEidos,
-  useEidosAction,
-  useEidosOnDrain,
-  useEidosQueue,
-  useEidosQueueStats,
-  useEidosResource,
-  useEidosStatus,
-  useEidosStore
+  Ee as EidosProvider,
+  Ae as VERSION,
+  me as action,
+  ve as clearQueue,
+  Ne as eidosAction,
+  Ce as eidosQueue,
+  Qe as eidosQueueStats,
+  Pe as eidosResource,
+  De as eidosStatus,
+  _e as eidosStore,
+  le as initEidos,
+  we as isBgSyncSupported,
+  C as replayQueue,
+  Se as resource,
+  ge as setOfflineSimulation,
+  ye as setQueryInvalidator,
+  Re as useEidos,
+  qe as useEidosAction,
+  Ie as useEidosOnDrain,
+  ke as useEidosQueue,
+  xe as useEidosQueueStats,
+  be as useEidosResource,
+  Oe as useEidosStatus,
+  o as useEidosStore
 };
 //# sourceMappingURL=eidos.es.js.map