@sweidos/eidos 1.0.16 → 1.0.19

package/dist/eidos-sw.js

@@ -1,229 +1,213 @@
-// eidos-sw.js — Eidos Service Worker v0.1.0
-// Two responsibilities:
-//   1. App shell caching — dashboard works offline after first visit
-//   2. API resource caching — strategies declared via resource()
-
-const CACHE_VERSION = 'v1'
-const SHELL_CACHE   = `eidos-shell-${CACHE_VERSION}`
-const API_CACHE     = `eidos-resources-${CACHE_VERSION}`
-
+const CACHE_VERSION = "v1";
+const CACHE_PREFIX = "eidos";
 const runtimeConfig = {
-  resources: new Map(),   // pathname → { strategy, cacheName }
-  simulateOffline: false,
-}
-
-// ── Install ───────────────────────────────────────────────────────────────────
-
-self.addEventListener('install', (event) => {
-  event.waitUntil(self.skipWaiting())
-})
-
-// ── Activate ──────────────────────────────────────────────────────────────────
-
-self.addEventListener('activate', (event) => {
+  resources: /* @__PURE__ */ new Map(),
+  simulateOffline: false
+};
+self.addEventListener("install", (event) => {
+  event.waitUntil(self.skipWaiting());
+});
+self.addEventListener("activate", (event) => {
   event.waitUntil(
     Promise.all([
       self.clients.claim(),
-      caches.keys().then((keys) =>
-        Promise.all(
-          keys
-            .filter((k) => k.startsWith('eidos') && k !== SHELL_CACHE && k !== API_CACHE)
-            .map((k) => caches.delete(k))
+      // Purge stale caches from previous versions
+      caches.keys().then(
+        (keys) => Promise.all(
+          keys.filter((k) => k.startsWith(CACHE_PREFIX) && !k.endsWith(CACHE_VERSION)).map((k) => caches.delete(k))
         )
-      ),
+      )
     ])
-  )
-})
-
-// ── Message channel ───────────────────────────────────────────────────────────
-
-self.addEventListener('message', (event) => {
-  const data = event.data
-  if (!data?.type) return
-
+  );
+});
+self.addEventListener("message", (event) => {
+  const data = event.data;
+  if (!data?.type) return;
   switch (data.type) {
-    case 'EIDOS_REGISTER_RESOURCE':
-      runtimeConfig.resources.set(data.url, {
+    case "EIDOS_REGISTER_RESOURCE": {
+      const url = data.url;
+      const patternSrc = data.pattern;
+      runtimeConfig.resources.set(url, {
         strategy: data.strategy,
-        cacheName: data.cacheName ?? API_CACHE,
-      })
-      event.source?.postMessage({ type: 'EIDOS_RESOURCE_REGISTERED', url: data.url })
-      break
-
-    case 'EIDOS_UNREGISTER_RESOURCE':
-      runtimeConfig.resources.delete(data.url)
-      break
-
-    case 'EIDOS_SIMULATE_OFFLINE':
-      runtimeConfig.simulateOffline = data.enabled
-      break
-
-    case 'EIDOS_CLEAR_CACHE': {
-      caches.open(API_CACHE).then(async (cache) => {
-        if (data.url) {
-          const keys = await cache.keys()
+        cacheName: data.cacheName ?? `${CACHE_PREFIX}-resources-${CACHE_VERSION}`,
+        ...patternSrc !== void 0 && { pattern: new RegExp(patternSrc) }
+      });
+      event.source?.postMessage({ type: "EIDOS_RESOURCE_REGISTERED", url });
+      break;
+    }
+    case "EIDOS_UNREGISTER_RESOURCE": {
+      runtimeConfig.resources.delete(data.url);
+      break;
+    }
+    case "EIDOS_SIMULATE_OFFLINE": {
+      runtimeConfig.simulateOffline = data.enabled;
+      break;
+    }
+    case "EIDOS_CLEAR_CACHE": {
+      const targetUrl = data.url;
+      const reg = targetUrl ? runtimeConfig.resources.get(targetUrl) : void 0;
+      const cacheName = reg?.cacheName ?? `${CACHE_PREFIX}-resources-${CACHE_VERSION}`;
+      caches.open(cacheName).then(async (cache) => {
+        if (targetUrl) {
+          const keys = await cache.keys();
+          const isCrossOrigin = targetUrl.startsWith("http");
           await Promise.all(
-            keys.filter((r) => new URL(r.url).pathname === data.url).map((r) => cache.delete(r))
-          )
+            keys.filter((req) => {
+              const reqUrl = req.url;
+              const p = new URL(reqUrl).pathname;
+              if (reg?.pattern) {
+                return reg.pattern.test(isCrossOrigin ? reqUrl : p);
+              }
+              return isCrossOrigin ? reqUrl === targetUrl : p === targetUrl;
+            }).map((req) => cache.delete(req))
+          );
         } else {
-          const keys = await cache.keys()
-          await Promise.all(keys.map((k) => cache.delete(k)))
+          await cache.keys().then((keys) => Promise.all(keys.map((k) => cache.delete(k))));
         }
-        notifyClients({ type: 'EIDOS_CACHE_CLEARED', url: data.url })
-      })
-      break
+        notifyClients({ type: "EIDOS_CACHE_CLEARED", url: targetUrl });
+      });
+      break;
     }
-
-    case 'EIDOS_PING':
-      event.source?.postMessage({ type: 'EIDOS_PONG' })
-      break
+    case "EIDOS_PING":
+      event.source?.postMessage({ type: "EIDOS_PONG" });
+      break;
   }
-})
-
-// ── Fetch interception ────────────────────────────────────────────────────────
-
-self.addEventListener('fetch', (event) => {
-  if (event.request.method !== 'GET') return
-
-  const url      = new URL(event.request.url)
-  const pathname = url.pathname
-
-  // 1. Registered API resources
-  const reg = runtimeConfig.resources.get(pathname)
-  if (reg) {
-    event.respondWith(handleApiResource(event.request, pathname, reg))
-    return
+});
+self.addEventListener("fetch", (event) => {
+  if (event.request.method !== "GET") return;
+  const requestUrl = event.request.url;
+  const pathname = new URL(requestUrl).pathname;
+  let reg = runtimeConfig.resources.get(requestUrl) ?? runtimeConfig.resources.get(pathname);
+  if (!reg) {
+    for (const [key, registration] of runtimeConfig.resources) {
+      if (!registration.pattern) continue;
+      const target = key.startsWith("http") ? requestUrl : pathname;
+      if (registration.pattern.test(target)) {
+        reg = registration;
+        break;
+      }
+    }
   }
-
-  // 2. App shell — same-origin non-API assets (HTML, JS, CSS, fonts, images)
-  //    Stale-while-revalidate: serve from cache instantly, refresh in background.
-  if (url.origin === self.location.origin && !pathname.startsWith('/api/')) {
-    event.respondWith(appShell(event.request))
+  if (!reg) return;
+  if (reg.strategy === "stale-while-revalidate" && !runtimeConfig.simulateOffline) {
+    event.respondWith(staleWhileRevalidate(event, event.request, pathname, reg.cacheName));
+    return;
   }
-})
-
-// ── App shell strategy ────────────────────────────────────────────────────────
-
-async function appShell(request) {
-  const cache  = await caches.open(SHELL_CACHE)
-  const cached = await cache.match(request)
-
-  const refresh = fetch(request)
-    .then((resp) => {
-      if (resp.ok) cache.put(request, resp.clone())
-      return resp
-    })
-    .catch(() => null)
-
-  if (cached) {
-    refresh // update in background
-    return cached
+  event.respondWith(handleFetch(event.request, pathname, reg));
+});
+async function handleFetch(request, pathname, reg) {
+  if (runtimeConfig.simulateOffline) {
+    return serveOffline(request, pathname, reg.cacheName);
   }
-
-  const fresh = await refresh
-  return fresh ?? new Response(
-    '<html><body><h2>Offline</h2><p>Visit this page while online first.</p></body></html>',
-    { status: 503, headers: { 'Content-Type': 'text/html' } }
-  )
-}
-
-// ── API caching strategies ────────────────────────────────────────────────────
-
-async function handleApiResource(request, pathname, reg) {
-  if (runtimeConfig.simulateOffline) return serveOffline(request, pathname, reg.cacheName)
-
   switch (reg.strategy) {
-    case 'cache-first':            return cacheFirst(request, pathname, reg.cacheName)
-    case 'stale-while-revalidate': return staleWhileRevalidate(request, pathname, reg.cacheName)
-    case 'network-first':          return networkFirst(request, pathname, reg.cacheName)
-    default:                       return fetch(request)
+    case "cache-first":
+      return cacheFirst(request, pathname, reg.cacheName);
+    case "stale-while-revalidate":
+      return staleWhileRevalidate(null, request, pathname, reg.cacheName);
+    case "network-first":
+      return networkFirst(request, pathname, reg.cacheName);
+    default:
+      return fetch(request);
   }
 }
-
 async function cacheFirst(request, pathname, cacheName) {
-  const cache  = await caches.open(cacheName)
-  const cached = await cache.match(request)
+  const cache = await caches.open(cacheName);
+  const cached = await cache.match(request);
   if (cached) {
-    notifyClients({ type: 'EIDOS_CACHE_HIT', url: pathname, strategy: 'cache-first' })
-    return cached
+    notifyClients({ type: "EIDOS_CACHE_HIT", url: pathname, strategy: "cache-first" });
+    return cached;
   }
   try {
-    const response = await fetch(request)
+    const response = await fetch(request);
     if (response.ok) {
-      await cache.put(request, response.clone())
-      notifyClients({ type: 'EIDOS_CACHE_UPDATED', url: pathname, strategy: 'cache-first' })
+      await cache.put(request, response.clone());
+      notifyClients({ type: "EIDOS_CACHE_UPDATED", url: pathname, strategy: "cache-first" });
     }
-    return response
+    return response;
   } catch {
-    notifyClients({ type: 'EIDOS_NETWORK_ERROR', url: pathname })
-    return offlineErrorResponse(pathname)
+    notifyClients({ type: "EIDOS_NETWORK_ERROR", url: pathname });
+    return offlineErrorResponse(pathname);
   }
 }
-
-async function staleWhileRevalidate(request, pathname, cacheName) {
-  const cache  = await caches.open(cacheName)
-  const cached = await cache.match(request)
-
-  const revalidate = fetch(request)
-    .then(async (resp) => {
-      if (resp.ok) {
-        await cache.put(request, resp.clone())
-        notifyClients({ type: 'EIDOS_CACHE_UPDATED', url: pathname, strategy: 'stale-while-revalidate' })
-      }
-      return resp
-    })
-    .catch(() => {
-      notifyClients({ type: 'EIDOS_NETWORK_ERROR', url: pathname })
-      return null
-    })
-
+async function staleWhileRevalidate(event, request, pathname, cacheName) {
+  const cache = await caches.open(cacheName);
+  const cached = await cache.match(request);
+  const revalidatePromise = fetch(request).then(async (response) => {
+    if (response.ok) {
+      await cache.put(request, response.clone());
+      notifyClients({
+        type: "EIDOS_CACHE_UPDATED",
+        url: pathname,
+        strategy: "stale-while-revalidate"
+      });
+    }
+    return response;
+  }).catch(() => {
+    notifyClients({ type: "EIDOS_NETWORK_ERROR", url: pathname, strategy: "stale-while-revalidate" });
+  });
   if (cached) {
-    notifyClients({ type: 'EIDOS_CACHE_HIT', url: pathname, strategy: 'stale-while-revalidate' })
-    return cached
+    event?.waitUntil(revalidatePromise);
+    notifyClients({
+      type: "EIDOS_CACHE_HIT",
+      url: pathname,
+      strategy: "stale-while-revalidate"
+    });
+    return cached;
   }
-
-  const fresh = await revalidate
-  return fresh ?? offlineErrorResponse(pathname)
+  const fresh = await revalidatePromise;
+  return fresh ?? offlineErrorResponse(pathname);
 }
-
 async function networkFirst(request, pathname, cacheName) {
-  const cache = await caches.open(cacheName)
+  const cache = await caches.open(cacheName);
   try {
-    const response = await fetch(request)
+    const response = await fetch(request, { signal: AbortSignal.timeout(3e3) });
     if (response.ok) {
-      await cache.put(request, response.clone())
-      notifyClients({ type: 'EIDOS_CACHE_UPDATED', url: pathname, strategy: 'network-first' })
+      await cache.put(request, response.clone());
+      notifyClients({ type: "EIDOS_CACHE_UPDATED", url: pathname, strategy: "network-first" });
     }
-    return response
+    return response;
   } catch {
-    const cached = await cache.match(request)
+    const cached = await cache.match(request);
     if (cached) {
-      notifyClients({ type: 'EIDOS_CACHE_HIT', url: pathname, strategy: 'network-first' })
-      return cached
+      notifyClients({ type: "EIDOS_CACHE_HIT", url: pathname, strategy: "network-first" });
+      return cached;
     }
-    notifyClients({ type: 'EIDOS_NETWORK_ERROR', url: pathname })
-    return offlineErrorResponse(pathname)
+    notifyClients({ type: "EIDOS_NETWORK_ERROR", url: pathname });
+    return offlineErrorResponse(pathname);
   }
 }
-
 async function serveOffline(request, pathname, cacheName) {
-  const cache  = await caches.open(cacheName)
-  const cached = await cache.match(request)
+  const cache = await caches.open(cacheName);
+  const cached = await cache.match(request);
   if (cached) {
-    notifyClients({ type: 'EIDOS_CACHE_HIT', url: pathname, strategy: 'offline-simulation', simulated: true })
-    return cached
+    notifyClients({ type: "EIDOS_CACHE_HIT", url: pathname, strategy: "offline-simulation", simulated: true });
+    return cached;
   }
-  return offlineErrorResponse(pathname)
+  return offlineErrorResponse(pathname);
 }
-
 function offlineErrorResponse(pathname) {
   return new Response(
-    JSON.stringify({ error: 'offline', message: `No cached response for ${pathname}`, eidos: true }),
-    { status: 503, headers: { 'Content-Type': 'application/json', 'X-Eidos-Offline': 'true' } }
-  )
+    JSON.stringify({
+      error: "offline",
+      message: `No cached response available for ${pathname}`,
+      eidos: true
+    }),
+    {
+      status: 503,
+      headers: {
+        "Content-Type": "application/json",
+        "X-Eidos-Offline": "true"
+      }
+    }
+  );
 }
-
 async function notifyClients(message) {
-  const clients = await self.clients.matchAll({ includeUncontrolled: true })
-  clients.forEach((c) => c.postMessage(message))
+  const clients = await self.clients.matchAll({ includeUncontrolled: true });
+  clients.forEach((client) => client.postMessage(message));
 }
+self.addEventListener("sync", (event) => {
+  const syncEvent = event;
+  if (syncEvent.tag === "eidos-queue-replay") {
+    syncEvent.waitUntil(notifyClients({ type: "EIDOS_BACKGROUND_SYNC" }));
+  }
+});

package/dist/eidos.cjs.js

@@ -58,6 +58,9 @@ const useEidosStore = {
 };
 let _registration = null;
 let _pendingMessages = [];
+function getSwRegistration() {
+  return _registration;
+}
 async function registerServiceWorker(swPath) {
   if (typeof navigator === "undefined" || !("serviceWorker" in navigator)) {
     useEidosStore.getState().setSwStatus("unsupported");
@@ -106,11 +109,26 @@ function sendToWorker(message) {
     _pendingMessages.push(message);
   }
 }
+let _bgSyncHandler = null;
+function registerBgSyncHandler(fn) {
+  _bgSyncHandler = fn;
+}
+function isBgSyncSupported() {
+  try {
+    return typeof navigator !== "undefined" && "serviceWorker" in navigator && _registration !== null && "sync" in _registration;
+  } catch {
+    return false;
+  }
+}
 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();
+    return;
+  }
   if (!url) return;
   switch (type) {
     case "EIDOS_CACHE_HIT": {
@@ -150,6 +168,10 @@ function flushPendingMessages() {
   _pendingMessages = [];
 }
 const _registry = /* @__PURE__ */ new Map();
+let _queryInvalidator = null;
+function setQueryInvalidator(fn) {
+  _queryInvalidator = fn;
+}
 function isPattern(url) {
   return url.includes("*") || /:[^/]+/.test(url);
 }
@@ -296,6 +318,7 @@ function resource(url, config) {
           cacheMisses: 0
         });
       }
+      _queryInvalidator == null ? void 0 : _queryInvalidator(["eidos", url]);
     },
     unregister: () => {
       _registry.delete(url);
@@ -512,6 +535,13 @@ async function persistAndQueue(actionId, actionName, args, config) {
   };
   await idbAddToQueue(item);
   useEidosStore.getState().addQueueItem(item);
+  try {
+    const reg = getSwRegistration();
+    if (reg && "sync" in reg) {
+      await reg.sync.register("eidos-queue-replay");
+    }
+  } catch {
+  }
   return {
     queued: true,
     id,
@@ -605,6 +635,11 @@ async function initEidos(config = {}) {
     await registerServiceWorker(swPath);
   } catch {
   }
+  registerBgSyncHandler(() => {
+    if (useEidosStore.getState().isOnline) {
+      setTimeout(replayQueue, 200);
+    }
+  });
   if (autoReplay) {
     let prevIsOnline = useEidosStore.getState().isOnline;
     useEidosStore.subscribe(() => {
@@ -711,9 +746,11 @@ exports.eidosResource = eidosResource;
 exports.eidosStatus = eidosStatus;
 exports.eidosStore = eidosStore;
 exports.initEidos = initEidos;
+exports.isBgSyncSupported = isBgSyncSupported;
 exports.replayQueue = replayQueue;
 exports.resource = resource;
 exports.setOfflineSimulation = setOfflineSimulation;
+exports.setQueryInvalidator = setQueryInvalidator;
 exports.useEidos = useEidos;
 exports.useEidosAction = useEidosAction;
 exports.useEidosOnDrain = useEidosOnDrain;