@swoff/cli 0.3.6 → 0.3.8

package/dist/lib/generators/sw-sections/default-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"default-template.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/default-template.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,UAAU,kBAAkB;IAChC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CP,CAAC;AACH,CAAC"}
+{"version":3,"file":"default-template.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/default-template.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,UAAU,kBAAkB;IAChC,OAAO;;;;;;;;;;;;;;;2BAekB,CAAC;AAC5B,CAAC"}

package/dist/lib/generators/sw-sections/fetch-handler.js

@@ -1,211 +1,287 @@
 /**
  * Generates the SW fetch event handler with all caching strategies.
+ *
+ * Strategy dispatch tiers (highest to lowest priority):
+ *   1. X-SW-Strategy header — per-request override from fetchWithCache({ strategy })
+ *   2. URL pattern match — from features.serviceWorker.strategies in swoff.config.json
+ *   3. defaultStrategy — fallback from features.serviceWorker.defaultStrategy
+ *
+ * Each tier also carries: staleTime, maxCacheEntries, maxCacheAge
+ * Per-request values override route values, which override globals.
+ *
+ * With staleTime enabled, every strategy gains a "fresh" window:
+ *   - cache-first: returns cached immediately, background refresh if stale
+ *   - network-first: skips network if fresh, tries network if stale
+ *   - stale-while-revalidate: skips refresh if fresh, refreshes if stale
+ *   - cache-only: background refresh if stale (best effort)
+ *   - network-only: unaffected (never caches)
  */
 export function generateFetchHandler(swConfig, tagInvalidation) {
-    const { defaultStrategy, strategies, maxCacheEntries, maxCacheAge, navigationMode, spaEntry } = swConfig;
-    const hasTrim = (maxCacheEntries ?? 0) > 0 || (maxCacheAge ?? 0) > 0;
+    const { defaultStrategy, strategies, cacheStrategy = "all", staleTime, maxCacheEntries, maxCacheAge, navigationPreload, navigationMode, spaEntry } = swConfig;
     const navMode = navigationMode ?? "spa";
     const spaPath = spaEntry ?? "/index.html";
-    const navCode = navMode === "spa" ? `
-  if (request.mode === "navigate") {
-    const precache = await caches.open(CACHE_NAME);
-    const entry = await precache.match("${spaPath}");
-    if (entry) return entry;
-  }` : "";
-    const tagInvalidationCode = tagInvalidation ? `
-          const tagsHeader = event.request.headers.get("X-SW-Cache-Tags");
-          if (tagsHeader) {
-            const url = new URL(event.request.url).href;
-            const tags = tagsHeader.split(",").map((t) => t.trim());
-            await cacheTagUrl(url, tags);
-          }` : "";
     const staleVersionCode = tagInvalidation ? `
-    if (staleVersions.has(request.url)) {
-      event.waitUntil(refreshCache(runtimeCache, request).then(() => staleVersions.delete(request.url)));
+    cleanStaleVersions();
+    if (staleVersions.has(cacheKey(request))) {
+      event.waitUntil(refreshCache(request).then(() => staleVersions.delete(cacheKey(request))));
     }` : "";
-    const staleTagCode = tagInvalidation ? `
-      const tagsHeader = request.headers.get("X-SW-Cache-Tags");
-      if (tagsHeader) {
-        const url = new URL(request.url).href;
-        const tags = tagsHeader.split(",").map((t) => t.trim());
-        await cacheTagUrl(url, tags);
-      }` : "";
-    const trimCode = hasTrim ? `        await trimRuntimeCache(CACHE_NAME_RUNTIME);\n` : "";
-    const trimFunction = hasTrim ? `
-const MAX_CACHE_ENTRIES = ${maxCacheEntries ?? 0};
-const MAX_CACHE_AGE = ${maxCacheAge ?? 0};
-
-async function trimRuntimeCache(cacheName) {
-  const cache = await caches.open(cacheName);
-
-  if (MAX_CACHE_ENTRIES > 0) {
-    const keys = await cache.keys();
-    if (keys.length >= MAX_CACHE_ENTRIES) {
-      const toDelete = keys.slice(0, keys.length - MAX_CACHE_ENTRIES + 1);
-      await Promise.all(toDelete.map((key) => cache.delete(key)));
-    }
-  }
+    const tagCode = tagInvalidation ? `
+  const tagsHeader = request.headers.get("X-SW-Cache-Tags");
+  if (tagsHeader) {
+    const cacheKeyUrl = cacheKey(request);
+    const actualUrl = new URL(request.url).href;
+    const tags = tagsHeader.split(",").map((t) => t.trim());
+    await cacheTagUrl(cacheKeyUrl, actualUrl, tags);
+  }` : "";
+    const trimDecl = `const GLOBAL_MAX_ENTRIES = ${maxCacheEntries ?? 0};
+const GLOBAL_MAX_AGE = ${maxCacheAge ?? 0};
+const GLOBAL_STALE_TIME = ${staleTime ?? 0};`;
+    return `${trimDecl}
+// --- Cache Key ---
 
-  if (MAX_CACHE_AGE > 0) {
-    const keys = await cache.keys();
-    const now = Date.now();
-    for (const request of keys) {
-      const response = await cache.match(request);
-      const dateHeader = response?.headers.get("date");
-      if (dateHeader) {
-        const age = now - new Date(dateHeader).getTime();
-        if (age > MAX_CACHE_AGE) {
-          await cache.delete(request);
-        }
-      }
-    }
-  }
+function cacheKey(request) {
+  const key = request.headers.get("X-SW-Cache-Key");
+  if (key) return new URL("/__swc/" + key, self.location.origin).href;
+  return new URL(request.url).href;
 }
-` : "";
-    return `${trimFunction}
+
+// --- Cache Helpers ---
+
 async function fromPrecache(request) {
   const cache = await caches.open(CACHE_NAME);
-  return cache.match(request);
+  return cache.match(new URL(request.url).pathname);
 }
 
-function markFromCache(response) {
+async function fromRuntime(request) {
+  const cache = await caches.open(CACHE_NAME_RUNTIME);
+  return cache.match(cacheKey(request));
+}
+
+async function storeRuntime(request, response) {
+  const cache = await caches.open(CACHE_NAME_RUNTIME);
   const headers = new Headers(response.headers);
-  headers.set("X-SW-From-Cache", "true");
-  return new Response(response.body, {
+  headers.set("X-SW-Cached-At", String(Date.now()));
+  const cloned = new Response(response.body, {
     status: response.status,
     statusText: response.statusText,
     headers,
   });
+  await cache.put(cacheKey(request), cloned);
 }
 
-function isReadRequest(request) {
-  return request.headers.get("X-SW-Cache-Strategy") === "read";
+async function cacheResponse(request, response) {
+  await storeRuntime(request, response);${tagCode}
 }
 
-function determineCacheStrategy(request, customStrategies, defaultStrategy) {
-  const path = new URL(request.url).pathname;
-  for (const [pattern, strategy] of Object.entries(customStrategies)) {
-    if (path.startsWith(pattern.replace("*", ""))) return strategy;
+async function fromSpaFallback(request) {
+  if (request.mode === "navigate") {
+    const cache = await caches.open(CACHE_NAME);
+    return cache.match("${spaPath}");
   }
-  return defaultStrategy;
 }
 
-self.addEventListener("fetch", (event) => {
-  if (!isReadRequest(event.request)) return;
+// --- Response Helpers ---
 
-  const strategy = determineCacheStrategy(event.request, ${JSON.stringify(strategies)}, "${defaultStrategy}");
+function markFromCache(response) {
+  const headers = new Headers(response.headers);
+  headers.set("X-SW-From-Cache", "true");
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
 
-  if (strategy === "stale-while-revalidate" || event.request.headers.get("X-SW-Stale") === "true") {
-    event.respondWith(staleWhileRevalidate(event, event.request));
-    return;
-  }
+function isStale(response, staleTimeSeconds) {
+  if (!staleTimeSeconds || staleTimeSeconds <= 0) return false;
+  const cachedAt = response.headers.get("X-SW-Cached-At");
+  if (!cachedAt) return false;
+  return Date.now() - Number(cachedAt) > staleTimeSeconds * 1000;
+}
 
-  if (strategy === "network-first") {
-    event.respondWith(networkFirst(event, event.request));
-    return;
-  }
+// --- Strategy Selection (3-tier config resolution) ---
+
+function resolveStrategyEntry(entry) {
+  return typeof entry === "string" ? { strategy: entry } : entry;
+}
 
-  if (strategy === "cache-only") {
-    event.respondWith(cacheOnly(event, event.request));
-    return;
+function determineCacheStrategy(request, customStrategies, globalDefaults) {
+  const override = request.headers.get("X-SW-Strategy");
+  if (override) {
+    return {
+      strategy: override,
+      staleTime: Number(request.headers.get("X-SW-Stale-Time")) || globalDefaults.staleTime,
+      maxCacheEntries: Number(request.headers.get("X-SW-Max-Entries")) || globalDefaults.maxCacheEntries,
+      maxCacheAge: Number(request.headers.get("X-SW-Max-Age")) || globalDefaults.maxCacheAge,
+    };
+  }
+  const path = new URL(request.url).pathname;
+  for (const [pattern, entry] of Object.entries(customStrategies)) {
+    if (path.startsWith(pattern.replace("*", ""))) {
+      const resolved = resolveStrategyEntry(entry);
+      return {
+        strategy: resolved.strategy,
+        staleTime: resolved.staleTime ?? globalDefaults.staleTime,
+        maxCacheEntries: resolved.maxCacheEntries ?? globalDefaults.maxCacheEntries,
+        maxCacheAge: resolved.maxCacheAge ?? globalDefaults.maxCacheAge,
+      };
+    }
   }
+  return {
+    strategy: globalDefaults.defaultStrategy,
+    staleTime: globalDefaults.staleTime,
+    maxCacheEntries: globalDefaults.maxCacheEntries,
+    maxCacheAge: globalDefaults.maxCacheAge,
+  };
+}
 
-  if (strategy === "network-only") {
-    event.respondWith(networkOnly(event, event.request));
-    return;
+function applyStrategy(event, request, config) {
+  const { strategy, staleTime, maxCacheEntries, maxCacheAge } = config;
+  if (strategy === "stale-while-revalidate") {
+    event.respondWith(staleWhileRevalidate(event, request, staleTime, maxCacheEntries, maxCacheAge));
+  } else if (strategy === "network-first") {
+    event.respondWith(networkFirst(event, request, staleTime, maxCacheEntries, maxCacheAge));
+  } else if (strategy === "cache-only") {
+    event.respondWith(cacheOnly(event, request, staleTime, maxCacheEntries, maxCacheAge));
+  } else if (strategy === "network-only") {
+    event.respondWith(networkOnly(event, request));
+  } else {
+    event.respondWith(cacheFirst(event, request, staleTime, maxCacheEntries, maxCacheAge));
   }
+}
 
-  // cache-first (default)
-  event.respondWith(cacheFirst(event, event.request));
+self.addEventListener("fetch", (event) => {
+  const { request } = event;
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    if (!request.headers.get("X-SW-Cache-Key")) return;
+  }
+  ${cacheStrategy === "explicit-only" ? `if (!request.headers.get("X-SW-Cache-Strategy")) return;` : ""}
+  applyStrategy(event, request, determineCacheStrategy(event.request, ${JSON.stringify(strategies)}, { defaultStrategy: "${defaultStrategy}", staleTime: GLOBAL_STALE_TIME, maxCacheEntries: GLOBAL_MAX_ENTRIES, maxCacheAge: GLOBAL_MAX_AGE }));
 });
 
-async function cacheFirst(event, request) {
-  const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
+// --- Strategies ---
+
+${navigationPreload ? `
+async function fetchWithPreload(event, request) {
+  try {
+    const preload = await event.preloadResponse;
+    if (preload) return preload;
+  } catch {}
+  return fetch(request);
+}
+` : ""}const _fetch = ${navigationPreload ? "fetchWithPreload" : `(event, request) => fetch(request)`};
 
-  const cached = await runtimeCache.match(request);
+${generateTrimCode(maxCacheEntries, maxCacheAge)}
+function _trim(cacheName, maxEntries, maxAge) {
+${maxCacheEntries || maxCacheAge ? `  trimRuntimeCache(cacheName, maxEntries, maxAge);` : ""}
+}
+
+async function cacheFirst(event, request, staleTime, maxEntries, maxAge) {
+  const cached = await fromRuntime(request);
   if (cached) {${staleVersionCode}
+    if (isStale(cached, staleTime)) {
+      event.waitUntil(refreshCache(request));
+    }
     return markFromCache(cached);
   }
 
   const precached = await fromPrecache(request);
   if (precached) return markFromCache(precached);
-${navCode}
-  const response = await fetch(request);
+
+  const fallback = await fromSpaFallback(request);
+  if (fallback) return fallback;
+
+  const response = await _fetch(event, request);
   if (response.ok) {
-    const cloned = response.clone();
     event.waitUntil(
       (async () => {
-        await runtimeCache.put(request, cloned);${tagInvalidationCode}
-${trimCode}      })(),
+        await cacheResponse(request, response);
+        _trim(CACHE_NAME_RUNTIME, maxEntries, maxAge);
+      })(),
     );
   }
   return response;
 }
 
-async function networkFirst(event, request) {
-  const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
+async function networkFirst(event, request, staleTime, maxEntries, maxAge) {
+  // If cached and fresh (within staleTime), skip network entirely
+  if (staleTime > 0) {
+    const cached = await fromRuntime(request);
+    if (cached && !isStale(cached, staleTime)) {
+      return markFromCache(cached);
+    }
+  }
 
   try {
-    const response = await fetch(request);
+    const response = await _fetch(event, request);
     if (response.ok) {
-      const cloned = response.clone();
       event.waitUntil(
         (async () => {
-          await runtimeCache.put(request, cloned);${tagInvalidationCode}
-${trimCode}        })(),
+          await cacheResponse(request, response);
+          _trim(CACHE_NAME_RUNTIME, maxEntries, maxAge);
+        })(),
       );
     }
     return response;
   } catch {
-    const cached = await runtimeCache.match(request);
+    const cached = await fromRuntime(request);
     if (cached) return cached;
 
     const precached = await fromPrecache(request);
     if (precached) return precached;
-${navCode}
+
+    const fallback = await fromSpaFallback(request);
+    if (fallback) return fallback;
+
     throw new Error("Request failed and no cached response available");
   }
 }
 
-async function staleWhileRevalidate(event, request) {
-  const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
-  const cached = await runtimeCache.match(request);
-
+async function staleWhileRevalidate(event, request, staleTime, maxEntries, maxAge) {
+  const cached = await fromRuntime(request);
   if (cached) {
-    event.waitUntil(refreshCache(runtimeCache, request));
+    // Skip background refresh if still fresh
+    if (!isStale(cached, staleTime)) {
+      return markFromCache(cached);
+    }
+    event.waitUntil(refreshCache(request));
     return markFromCache(cached);
   }
 
   const precached = await fromPrecache(request);
   if (precached) {
-    event.waitUntil(refreshCache(runtimeCache, request));
+    event.waitUntil(refreshCache(request));
     return markFromCache(precached);
   }
 
-  const response = await fetch(request);
+  const response = await _fetch(event, request);
   if (response.ok) {
-    await runtimeCache.put(request, response.clone());${staleTagCode}
-${hasTrim ? "      await trimRuntimeCache(CACHE_NAME_RUNTIME);\n" : ""}  }
+    await cacheResponse(request, response);
+    _trim(CACHE_NAME_RUNTIME, maxEntries, maxAge);
+  }
   return response;
 }
 
-async function refreshCache(cache, request) {
+async function refreshCache(request) {
   try {
-    const response = await fetch(request);
+    const key = request.headers.get("X-SW-Cache-Key");
+    const fetchRequest = key ? new Request(new URL(request.url).href, { method: request.method, headers: request.headers, body: request.method !== "GET" ? request.body : undefined }) : request;
+    const response = await fetch(fetchRequest);
     if (response.ok) {
-      await cache.put(request, response.clone());
+      await storeRuntime(request, response);
     }
   } catch {
     // Background refresh failed - stale cache remains usable
   }
 }
 
-async function cacheOnly(event, request) {
-  const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
-
-  const byRequest = await runtimeCache.match(request);
-  if (byRequest) {${staleVersionCode}
-    return markFromCache(byRequest);
+async function cacheOnly(event, request, staleTime, maxEntries, maxAge) {
+  const cached = await fromRuntime(request);
+  if (cached) {${staleVersionCode}
+    if (isStale(cached, staleTime)) {
+      event.waitUntil(refreshCache(request));
+    }
+    return markFromCache(cached);
   }
 
   const precached = await fromPrecache(request);
@@ -215,7 +291,41 @@ async function cacheOnly(event, request) {
 }
 
 async function networkOnly(event, request) {
-  return fetch(request);
+  return _fetch(event, request);
 }`;
 }
+function generateTrimCode(maxCacheEntries, maxCacheAge) {
+    if (!maxCacheEntries && !maxCacheAge)
+        return "";
+    return `
+async function trimRuntimeCache(cacheName, maxEntries, maxAge) {
+  const _maxEntries = maxEntries ?? GLOBAL_MAX_ENTRIES;
+  const _maxAge = maxAge ?? GLOBAL_MAX_AGE;
+  const cache = await caches.open(cacheName);
+
+  if (_maxEntries > 0) {
+    const keys = await cache.keys();
+    if (keys.length >= _maxEntries) {
+      const toDelete = keys.slice(0, keys.length - _maxEntries + 1);
+      await Promise.all(toDelete.map((key) => cache.delete(key)));
+    }
+  }
+
+  if (_maxAge > 0) {
+    const keys = await cache.keys();
+    const now = Date.now();
+    for (const request of keys) {
+      const response = await cache.match(request);
+      const dateHeader = response?.headers.get("date");
+      if (dateHeader) {
+        const age = now - new Date(dateHeader).getTime();
+        if (age > _maxAge) {
+          await cache.delete(request);
+        }
+      }
+    }
+  }
+}
+`;
+}
 //# sourceMappingURL=fetch-handler.js.map

package/dist/lib/generators/sw-sections/fetch-handler.js.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/fetch-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,UAAU,oBAAoB,CAClC,QAAqK,EACrK,eAAwB;IAExB,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,eAAe,EAAE,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC;IAEzG,MAAM,OAAO,GAAG,CAAC,eAAe,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACrE,MAAM,OAAO,GAAG,cAAc,IAAI,KAAK,CAAC;IACxC,MAAM,OAAO,GAAG,QAAQ,IAAI,aAAa,CAAC;IAC1C,MAAM,OAAO,GAAG,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC;;;0CAGI,OAAO;;IAE7C,CAAC,CAAC,CAAC,EAAE,CAAC;IAER,MAAM,mBAAmB,GAAG,eAAe,CAAC,CAAC,CAAC;;;;;;YAMpC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEhB,MAAM,gBAAgB,GAAG,eAAe,CAAC,CAAC,CAAC;;;MAGvC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEV,MAAM,YAAY,GAAG,eAAe,CAAC,CAAC,CAAC;;;;;;QAMjC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEZ,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,uDAAuD,CAAC,CAAC,CAAC,EAAE,CAAC;IAExF,MAAM,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC;4BACL,eAAe,IAAI,CAAC;wBACxB,WAAW,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BvC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEL,OAAO,GAAG,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA+BmC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BzF,gBAAgB;;;;;;EAM/B,OAAO;;;;;;kDAMyC,mBAAmB;EACnE,QAAQ;;;;;;;;;;;;;;;oDAe0C,mBAAmB;EACrE,QAAQ;;;;;;;;;;EAUR,OAAO;;;;;;;;;;;;;;;;;;;;;;wDAsB+C,YAAY;EAClE,OAAO,CAAC,CAAC,CAAC,qDAAqD,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;oBAmBlD,gBAAgB;;;;;;;;;;;;EAYlC,CAAC;AACH,CAAC"}
+{"version":3,"file":"fetch-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/fetch-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,UAAU,oBAAoB,CAClC,QAA0V,EAC1V,eAAwB;IAExB,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,aAAa,GAAG,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,WAAW,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC;IAE9J,MAAM,OAAO,GAAG,cAAc,IAAI,KAAK,CAAC;IACxC,MAAM,OAAO,GAAG,QAAQ,IAAI,aAAa,CAAC;IAE1C,MAAM,gBAAgB,GAAG,eAAe,CAAC,CAAC,CAAC;;;;MAIvC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEV,MAAM,OAAO,GAAG,eAAe,CAAC,CAAC,CAAC;;;;;;;IAOhC,CAAC,CAAC,CAAC,EAAE,CAAC;IAER,MAAM,QAAQ,GAAG,8BAA8B,eAAe,IAAI,CAAC;yBAC5C,WAAW,IAAI,CAAC;4BACb,SAAS,IAAI,CAAC,GAAG,CAAC;IAE5C,OAAO,GAAG,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAkCsB,OAAO;;;;;;0BAMvB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+E7B,aAAa,KAAK,eAAe,CAAC,CAAC,CAAC,0DAA0D,CAAC,CAAC,CAAC,EAAE;wEAC/B,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,yBAAyB,eAAe;;;;;EAKxI,iBAAiB,CAAC,CAAC,CAAC;;;;;;;;CAQrB,CAAC,CAAC,CAAC,EAAE,kBAAkB,iBAAiB,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,oCAAoC;;EAEnG,gBAAgB,CAAC,eAAe,EAAE,WAAW,CAAC;;EAE9C,eAAe,IAAI,WAAW,CAAC,CAAC,CAAC,oDAAoD,CAAC,CAAC,CAAC,EAAE;;;;;iBAK3E,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmGhB,gBAAgB;;;;;;;;;;;;;;;EAe/B,CAAC;AACH,CAAC;AAED,SAAS,gBAAgB,CAAC,eAAmC,EAAE,WAA+B;IAC5F,IAAI,CAAC,eAAe,IAAI,CAAC,WAAW;QAAE,OAAO,EAAE,CAAC;IAEhD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BR,CAAC;AACF,CAAC"}

package/dist/lib/generators/sw-sections/install-handler.js

@@ -8,24 +8,26 @@ self.addEventListener("install", (event) => {
     (async () => {
       const cache = await caches.open(CACHE_NAME);
       let downloaded = 0;
+      let attempted = 0;
       for (const asset of ASSETS_TO_CACHE) {
+        attempted++;
         try {
           const request = new Request(asset.url, asset.options);
           await cache.add(request);
           downloaded++;
-          const percent = Math.round((downloaded / ASSETS_TO_CACHE.length) * 100);
-          const clients = await self.clients.matchAll({ includeUncontrolled: true });
-          clients.forEach((client) => {
-            client.postMessage({
-              type: "SW_PROGRESS",
-              percent,
-              downloaded,
-              total: ASSETS_TO_CACHE.length,
-            });
-          });
         } catch (err) {
           console.error(\`Failed to cache \${asset.url}:\`, err);
         }
+        const percent = Math.round((attempted / ASSETS_TO_CACHE.length) * 100);
+        const clients = await self.clients.matchAll({ includeUncontrolled: true });
+        clients.forEach((client) => {
+          client.postMessage({
+            type: "SW_PROGRESS",
+            percent,
+            downloaded,
+            total: ASSETS_TO_CACHE.length,
+          });
+        });
       }
       if (AUTO_SKIP_WAITING) self.skipWaiting();
     })(),

package/dist/lib/generators/sw-sections/install-handler.js.map

@@ -1 +1 @@
-{"version":3,"file":"install-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/install-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,UAAU,sBAAsB;IACpC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4BL,CAAC;AACL,CAAC"}
+{"version":3,"file":"install-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/install-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,UAAU,sBAAsB;IACpC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8BL,CAAC;AACL,CAAC"}

package/dist/lib/generators/sw-sections/server-push-handler.js

@@ -0,0 +1,114 @@
+/**
+ * Generates the SW push event connection handler.
+ * Opens an SSE (fetch+stream) or WebSocket connection from the SW,
+ * listens for "invalidate" events, and calls invalidateByTag().
+ */
+export function generateServerPushHandler(type, endpoint, reconnectDelayMs) {
+    if (type === "websocket") {
+        return `
+// --- Server Push Events (WebSocket) ---
+
+let pushWs = null;
+let pushReconnectTimer = null;
+
+async function connectPushEvents() {
+  try {
+    pushWs = new WebSocket("${endpoint}");
+    pushWs.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type === "invalidate" && data.tags) {
+          data.tags.forEach((tag) => invalidateByTag(tag));
+        }
+      } catch {}
+    };
+    pushWs.onclose = () => {
+      pushWs = null;
+      scheduleReconnect();
+    };
+    pushWs.onerror = () => {
+      pushWs?.close();
+    };
+  } catch {
+    scheduleReconnect();
+  }
+}
+
+function scheduleReconnect() {
+  if (pushReconnectTimer) clearTimeout(pushReconnectTimer);
+  pushReconnectTimer = setTimeout(connectPushEvents, ${reconnectDelayMs});
+}
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(connectPushEvents());
+});
+`;
+    }
+    // SSE: fetch + ReadableStream reader
+    return `
+// --- Server Push Events (SSE) ---
+
+let pushReconnectTimer = null;
+let pushAbortController = null;
+
+async function connectPushEvents() {
+  try {
+    pushAbortController = new AbortController();
+    const response = await fetch("${endpoint}", {
+      headers: { Accept: "text/event-stream" },
+      signal: pushAbortController.signal,
+    });
+    if (!response.ok || !response.body) {
+      scheduleReconnect();
+      return;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let eventType = "";
+    let dataStr = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+
+      const lines = buffer.split("\\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (line.startsWith("event: ")) {
+          eventType = line.slice(7).trim();
+        } else if (line.startsWith("data: ")) {
+          dataStr = line.slice(6);
+        } else if (line === "") {
+          if (eventType === "invalidate" && dataStr) {
+            try {
+              const parsed = JSON.parse(dataStr);
+              if (parsed.tags) {
+                parsed.tags.forEach((tag) => invalidateByTag(tag));
+              }
+            } catch {}
+          }
+          eventType = "";
+          dataStr = "";
+        }
+      }
+    }
+  } catch {
+    // Connection lost or aborted
+  }
+  scheduleReconnect();
+}
+
+function scheduleReconnect() {
+  if (pushReconnectTimer) clearTimeout(pushReconnectTimer);
+  pushReconnectTimer = setTimeout(connectPushEvents, ${reconnectDelayMs});
+}
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(connectPushEvents());
+});
+`;
+}
+//# sourceMappingURL=server-push-handler.js.map

package/dist/lib/generators/sw-sections/server-push-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-push-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/server-push-handler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,UAAU,yBAAyB,CACvC,IAAyB,EACzB,QAAgB,EAChB,gBAAwB;IAExB,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;QACzB,OAAO;;;;;;;;8BAQmB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;uDAuBiB,gBAAgB;;;;;;CAMtE,CAAC;IACA,CAAC;IAED,qCAAqC;IACrC,OAAO;;;;;;;;;oCAS2B,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAiDW,gBAAgB;;;;;;CAMtE,CAAC;AACF,CAAC"}