@swoff/cli 0.1.0 → 0.2.1

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

@@ -0,0 +1,16 @@
+/**
+ * Generates the SW activate event handler (old cache cleanup).
+ */
+export function generateActivateHandler() {
+    return `
+self.addEventListener("activate", (event) => {
+  event.waitUntil(
+    caches.keys().then((keys) =>
+      Promise.all(
+        keys.filter((key) => key !== CACHE_NAME && key !== CACHE_NAME_RUNTIME).map((key) => caches.delete(key))
+      )
+    )
+  );
+});`;
+}
+//# sourceMappingURL=activate-handler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"activate-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/activate-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,UAAU,uBAAuB;IACrC,OAAO;;;;;;;;;IASL,CAAC;AACL,CAAC"}

package/dist/lib/generators/sw-sections/assemble-sw.js

@@ -0,0 +1,38 @@
+/**
+ * Assembles the complete service worker string from config and version.
+ * Calls individual section generators and performs placeholder replacement.
+ */
+import { getDefaultTemplate } from "./default-template.js";
+import { generateConfigHeader } from "./config-header.js";
+import { generateInstallHandler } from "./install-handler.js";
+import { generateActivateHandler } from "./activate-handler.js";
+import { generateMessageHandler } from "./message-handler.js";
+import { generateFetchHandler } from "./fetch-handler.js";
+import { generateTagManagement } from "./tag-management.js";
+import { generateBackgroundSyncHandler } from "./background-sync-handler.js";
+export function assembleSW(config, version) {
+    const { serviceWorker, features } = config;
+    const baseAssets = ["/", "/index.html"];
+    const pwaAssets = features.pwa ? ["/manifest.json"] : [];
+    const assetsToCache = [...baseAssets, ...pwaAssets];
+    let sw = getDefaultTemplate();
+    sw = sw.replace("// [[CACHE_NAME]]", `CACHE_NAME = 'sw-v${version}'`);
+    sw = sw.replace("// [[ASSETS_LIST]]", `ASSETS_TO_CACHE = ${JSON.stringify(assetsToCache.map((url) => ({ url, options: {} })), null, 2)}`);
+    sw = sw.replace("// [[AUTO_SKIP_WAITING]]", `const AUTO_SKIP_WAITING = ${config.serviceWorker.autoActivate};`);
+    sw = sw.replace("// [[FETCH_HANDLER]]", generateFetchHandler(serviceWorker, features.tagInvalidation));
+    sw = sw.replace("// [[ACTIVATE_HANDLER]]", generateActivateHandler());
+    sw = sw.replace("// [[INSTALL_HANDLER]]", generateInstallHandler());
+    sw = sw.replace("// [[MESSAGE_HANDLER]]", generateMessageHandler(features.tagInvalidation));
+    if (features.tagInvalidation) {
+        sw = sw.replace("// [[TAG_MANAGEMENT]]", generateTagManagement());
+    }
+    else {
+        sw = sw.replace("// [[TAG_MANAGEMENT]]", "");
+    }
+    sw = `${generateConfigHeader(config, version)}\n\n${sw}`;
+    if (features.backgroundSync) {
+        sw += `\n\n${generateBackgroundSyncHandler()}`;
+    }
+    return sw;
+}
+//# sourceMappingURL=assemble-sw.js.map

package/dist/lib/generators/sw-sections/assemble-sw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemble-sw.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/assemble-sw.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,6BAA6B,EAAE,MAAM,8BAA8B,CAAC;AAE7E,MAAM,UAAU,UAAU,CAAC,MAAmB,EAAE,OAAe;IAC7D,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC;IAE3C,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;IACxC,MAAM,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACzD,MAAM,aAAa,GAAG,CAAC,GAAG,UAAU,EAAE,GAAG,SAAS,CAAC,CAAC;IAEpD,IAAI,EAAE,GAAG,kBAAkB,EAAE,CAAC;IAE9B,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,mBAAmB,EAAE,qBAAqB,OAAO,GAAG,CAAC,CAAC;IACtE,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,oBAAoB,EAAE,qBAAqB,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IAC1I,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,0BAA0B,EAAE,6BAA6B,MAAM,CAAC,aAAa,CAAC,YAAY,GAAG,CAAC,CAAC;IAE/G,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,sBAAsB,EAAE,oBAAoB,CAAC,aAAa,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC;IACvG,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,yBAAyB,EAAE,uBAAuB,EAAE,CAAC,CAAC;IACtE,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,wBAAwB,EAAE,sBAAsB,EAAE,CAAC,CAAC;IACpE,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,wBAAwB,EAAE,sBAAsB,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC;IAE5F,IAAI,QAAQ,CAAC,eAAe,EAAE,CAAC;QAC7B,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,uBAAuB,EAAE,qBAAqB,EAAE,CAAC,CAAC;IACpE,CAAC;SAAM,CAAC;QACN,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,uBAAuB,EAAE,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED,EAAE,GAAG,GAAG,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;IAEzD,IAAI,QAAQ,CAAC,cAAc,EAAE,CAAC;QAC5B,EAAE,IAAI,OAAO,6BAA6B,EAAE,EAAE,CAAC;IACjD,CAAC;IAED,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/dist/lib/generators/sw-sections/background-sync-handler.js

@@ -0,0 +1,106 @@
+/**
+ * Generates Background Sync event handler for the SW.
+ * Processes mutation queue when browser sync fires.
+ */
+export function generateBackgroundSyncHandler() {
+    return `
+self.addEventListener("sync", (event) => {
+  if (event.tag === "sync-mutations") {
+    event.waitUntil(processMutationQueueInSW());
+  }
+});
+
+async function processMutationQueueInSW() {
+  const SW_DB_NAME = "swoff-queue";
+  const SW_STORE_NAME = "mutations";
+  const SW_MAX_RETRIES = 5;
+
+  let succeeded = 0;
+  let failed = 0;
+  const tagsToInvalidate = new Set();
+
+  try {
+    const db = await new Promise((resolve, reject) => {
+      const request = indexedDB.open(SW_DB_NAME, 1);
+      request.onupgradeneeded = (e) => {
+        const db = e.target.result;
+        if (!db.objectStoreNames.contains(SW_STORE_NAME)) {
+          const store = db.createObjectStore(SW_STORE_NAME, { keyPath: "id" });
+          store.createIndex("by-timestamp", "timestamp");
+        }
+      };
+      request.onsuccess = (e) => resolve(e.target.result);
+      request.onerror = (e) => reject(e.target.error);
+    });
+
+    const tx = db.transaction(SW_STORE_NAME, "readonly");
+    const store = tx.objectStore(SW_STORE_NAME);
+    const index = store.index("by-timestamp");
+    const queue = await new Promise((resolve, reject) => {
+      const request = index.getAll();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+
+    for (const item of queue) {
+      if (item.retryCount >= SW_MAX_RETRIES) {
+        await removeFromSWQueue(db, item.id);
+        failed++;
+        continue;
+      }
+      try {
+        const response = await fetch(item.url, {
+          method: item.method,
+          headers: { "Content-Type": "application/json", ...item.headers },
+          body: JSON.stringify(item.body),
+        });
+        if (!response.ok) throw new Error(\`HTTP \${response.status}\`);
+
+        if (item.tags) {
+          item.tags.forEach((tag) => tagsToInvalidate.add(tag));
+        }
+
+        await removeFromSWQueue(db, item.id);
+        succeeded++;
+      } catch {
+        item.retryCount++;
+        await updateInSWQueue(db, item);
+        failed++;
+      }
+    }
+  } catch (err) {
+    console.error("Background sync failed:", err);
+  }
+
+  for (const tag of tagsToInvalidate) {
+    await invalidateByTag(tag);
+  }
+
+  const clients = await self.clients.matchAll();
+  for (const client of clients) {
+    client.postMessage({
+      type: "BACKGROUND_SYNC_COMPLETE",
+      detail: { succeeded, failed, tags: [...tagsToInvalidate] },
+    });
+  }
+}
+
+async function removeFromSWQueue(db, id) {
+  const tx = db.transaction(SW_STORE_NAME, "readwrite");
+  tx.objectStore(SW_STORE_NAME).delete(id);
+  await new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+async function updateInSWQueue(db, item) {
+  const tx = db.transaction(SW_STORE_NAME, "readwrite");
+  tx.objectStore(SW_STORE_NAME).put(item);
+  await new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}`;
+}
+//# sourceMappingURL=background-sync-handler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"background-sync-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/background-sync-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,UAAU,6BAA6B;IAC3C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkGP,CAAC;AACH,CAAC"}

package/dist/lib/generators/sw-sections/config-header.js

@@ -0,0 +1,15 @@
+/**
+ * Generates the SW file header comment with config metadata.
+ */
+export function generateConfigHeader(config, resolvedVersion) {
+    return `/**
+ * Swoff Service Worker - Auto-Generated
+ * Generated from swoff.config.json
+ * DO NOT EDIT MANUALLY
+ * Version: ${resolvedVersion}
+ * Features: versionedSw=${config.features.versionedSw}, offlineReads=${config.features.offlineReads}, mutationQueue=${config.features.mutationQueue}, backgroundSync=${config.features.backgroundSync}, tagInvalidation=${config.features.tagInvalidation}
+ * Default Strategy: ${config.serviceWorker.defaultStrategy}
+ * See: https://swoff.netlify.app/docs
+ */`;
+}
+//# sourceMappingURL=config-header.js.map

package/dist/lib/generators/sw-sections/config-header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-header.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/config-header.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,UAAU,oBAAoB,CAAC,MAAmB,EAAE,eAAuB;IAC/E,OAAO;;;;cAIK,eAAe;2BACF,MAAM,CAAC,QAAQ,CAAC,WAAW,kBAAkB,MAAM,CAAC,QAAQ,CAAC,YAAY,mBAAmB,MAAM,CAAC,QAAQ,CAAC,aAAa,oBAAoB,MAAM,CAAC,QAAQ,CAAC,cAAc,qBAAqB,MAAM,CAAC,QAAQ,CAAC,eAAe;uBACnO,MAAM,CAAC,aAAa,CAAC,eAAe;;IAEvD,CAAC;AACL,CAAC"}

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

@@ -0,0 +1,51 @@
+/**
+ * Default SW template with placeholder markers.
+ * Placeholders are replaced during generation with feature-specific code.
+ */
+export function getDefaultTemplate() {
+    return `let CACHE_NAME = "";
+let ASSETS_TO_CACHE = [];
+
+// [[CACHE_NAME]]
+// [[ASSETS_LIST]]
+// [[AUTO_SKIP_WAITING]]
+
+const CACHE_NAME_RUNTIME = "swoff-runtime";
+
+// [[INSTALL_HANDLER]]
+// [[ACTIVATE_HANDLER]]
+// [[MESSAGE_HANDLER]]
+// [[FETCH_HANDLER]]
+// [[TAG_MANAGEMENT]]
+
+const SWOFF = {
+  cache: {
+    async get(key) {
+      const cache = await caches.open(CACHE_NAME);
+      return cache.match(key);
+    },
+    async put(request, response) {
+      const cache = await caches.open(CACHE_NAME);
+      await cache.put(request, response);
+    },
+    async delete(request) {
+      const cache = await caches.open(CACHE_NAME);
+      return cache.delete(request);
+    }
+  },
+  network: {
+    async fetch(request, options = {}) {
+      try {
+        return await fetch(request, options);
+      } catch (error) {
+        throw new Error(\`Network request failed: \${error.message}\`);
+      }
+    }
+  }
+};
+
+if (typeof self !== 'undefined') {
+  self.SWOFF = SWOFF;
+}`;
+}
+//# sourceMappingURL=default-template.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,203 @@
+/**
+ * Generates the SW fetch event handler with all caching strategies.
+ */
+export function generateFetchHandler(swConfig, tagInvalidation) {
+    const { defaultStrategy, strategies, maxCacheEntries, maxCacheAge } = swConfig;
+    const hasTrim = (maxCacheEntries ?? 0) > 0 || (maxCacheAge ?? 0) > 0;
+    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 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)));
+    }
+  }
+
+  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);
+        }
+      }
+    }
+  }
+}
+` : "";
+    return `${trimFunction}
+function isReadRequest(request) {
+  const strategy = request.headers.get("X-SW-Cache-Strategy");
+  if (strategy === "read") return true;
+  if (strategy === "mutation") return false;
+  return request.method === "GET" || request.method === "HEAD";
+}
+
+function determineCacheStrategy(request, customStrategies, defaultStrategy) {
+  const url = request.url;
+  for (const [pattern, strategy] of Object.entries(customStrategies)) {
+    if (url.includes(pattern.replace("*", ""))) return strategy;
+  }
+  return defaultStrategy;
+}
+
+self.addEventListener("fetch", (event) => {
+  if (!isReadRequest(event.request)) return;
+
+  const strategy = determineCacheStrategy(event.request, ${JSON.stringify(strategies)}, "${defaultStrategy}");
+
+  if (strategy === "stale-while-revalidate" || event.request.headers.get("X-SW-Stale") === "true") {
+    event.respondWith(staleWhileRevalidate(event, event.request));
+    return;
+  }
+
+  if (strategy === "network-first") {
+    event.respondWith(networkFirst(event, event.request));
+    return;
+  }
+
+  if (strategy === "cache-only") {
+    event.respondWith(cacheOnly(event, event.request));
+    return;
+  }
+
+  if (strategy === "network-only") {
+
+  if (strategy === "network-only") {
+    event.respondWith(networkOnly(event, event.request));
+    return;
+  }
+
+  // cache-first (default)
+  event.respondWith(cacheFirst(event, event.request));
+});
+
+async function cacheFirst(event, request) {
+  const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
+
+  const byRequest = await runtimeCache.match(request);
+  if (byRequest) return byRequest;
+
+  if (request.mode === "navigate") {
+    const spa = await cache.match("/index.html");
+    if (spa) return spa;
+  }
+
+  try {
+    const response = await fetch(request);
+    if (response.ok) {
+      const cloned = response.clone();
+      event.waitUntil(
+        (async () => {
+          await runtimeCache.put(request, cloned);${tagInvalidationCode}
+${trimCode}        })(),
+      );
+    }
+    return response;
+  } catch {
+    return new Response("Offline: content not available", { status: 503 });
+  }
+}
+
+async function networkFirst(event, request) {
+  const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
+
+  try {
+    const response = await fetch(request);
+    if (response.ok) {
+      const cloned = response.clone();
+      event.waitUntil(
+        (async () => {
+          await runtimeCache.put(request, cloned);${tagInvalidationCode}
+${trimCode}        })(),
+      );
+    }
+    return response;
+  } catch {
+    const cached = await runtimeCache.match(request);
+    if (cached) return cached;
+
+    if (request.mode === "navigate") {
+      const cache = await caches.open(CACHE_NAME);
+      const spa = await cache.match("/index.html");
+      if (spa) return spa;
+    }
+
+    return new Response("Offline: content not available", { status: 503 });
+  }
+}
+
+async function staleWhileRevalidate(event, request) {
+  const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
+  const cached = await runtimeCache.match(request);
+
+  if (cached) {
+    event.waitUntil(refreshCache(runtimeCache, request));
+    return cached;
+  }
+
+  try {
+    const response = await fetch(request);
+    if (response.ok) {
+      await runtimeCache.put(request, response.clone());${staleTagCode}
+${hasTrim ? "      await trimRuntimeCache(CACHE_NAME_RUNTIME);\n" : ""}    }
+    return response;
+  } catch {
+    return new Response("Offline: content not available", { status: 503 });
+  }
+}
+
+async function refreshCache(cache, request) {
+  try {
+    const response = await fetch(request);
+    if (response.ok) {
+      await cache.put(request, response.clone());
+    }
+  } 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) return byRequest;
+
+  return new Response("Not in cache", { status: 404 });
+}
+
+async function networkOnly(event, request) {
+  try {
+    return await fetch(request);
+  } catch {
+    return new Response("Network error", { status: 503 });
+  }
+}`;
+}
+//# sourceMappingURL=fetch-handler.js.map

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

@@ -0,0 +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,QAAyH,EACzH,eAAwB;IAExB,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,eAAe,EAAE,WAAW,EAAE,GAAG,QAAQ,CAAC;IAE/E,MAAM,OAAO,GAAG,CAAC,eAAe,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IAErE,MAAM,mBAAmB,GAAG,eAAe,CAAC,CAAC,CAAC;;;;;;YAMpC,CAAC,CAAC,CAAC,EAAE,CAAC;IAEhB,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;;;;;;;;;;;;;;;;;;;2DAmBmC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDA6CtD,mBAAmB;EACrE,QAAQ;;;;;;;;;;;;;;;;;;oDAkB0C,mBAAmB;EACrE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DA8BgD,YAAY;EACpE,OAAO,CAAC,CAAC,CAAC,qDAAqD,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCpE,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,35 @@
+/**
+ * Generates the SW install event handler (asset pre-caching with progress).
+ */
+export function generateInstallHandler() {
+    return `
+self.addEventListener("install", (event) => {
+  event.waitUntil(
+    (async () => {
+      const cache = await caches.open(CACHE_NAME);
+      let downloaded = 0;
+      for (const asset of ASSETS_TO_CACHE) {
+        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);
+        }
+      }
+      if (AUTO_SKIP_WAITING) self.skipWaiting();
+    })(),
+  );
+});`;
+}
+//# sourceMappingURL=install-handler.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,20 @@
+/**
+ * Generates the SW message event handler (SKIP_WAITING, INVALIDATE_TAG).
+ */
+export function generateMessageHandler(tagInvalidation) {
+    let code = `
+self.addEventListener("message", (event) => {
+  if (event.data.type === "SKIP_WAITING") {
+    self.skipWaiting();
+  }`;
+    if (tagInvalidation) {
+        code += `
+  if (event.data.type === "INVALIDATE_TAG" && event.data.tag) {
+    event.waitUntil(invalidateByTag(event.data.tag));
+  }`;
+    }
+    code += `
+});`;
+    return code;
+}
+//# sourceMappingURL=message-handler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"message-handler.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/message-handler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,UAAU,sBAAsB,CAAC,eAAwB;IAC7D,IAAI,IAAI,GAAG;;;;IAIT,CAAC;IAEH,IAAI,eAAe,EAAE,CAAC;QACpB,IAAI,IAAI;;;IAGR,CAAC;IACH,CAAC;IAED,IAAI,IAAI;IACN,CAAC;IACH,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/lib/generators/sw-sections/tag-management.js

@@ -0,0 +1,69 @@
+/**
+ * Generates IndexedDB-based tag invalidation logic for the SW.
+ */
+export function generateTagManagement() {
+    return `
+const TAG_DB_NAME = "swoff-cache-tags";
+const TAG_STORE_NAME = "tags";
+
+function openTagDB() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(TAG_DB_NAME, 1);
+    request.onupgradeneeded = (e) => {
+      const db = e.target.result;
+      if (!db.objectStoreNames.contains(TAG_STORE_NAME)) {
+        const store = db.createObjectStore(TAG_STORE_NAME, { keyPath: "url" });
+        store.createIndex("by-tag", "tags", { multiEntry: true });
+      }
+    };
+    request.onsuccess = (e) => resolve(e.target.result);
+    request.onerror = (e) => reject(e.target.error);
+  });
+}
+
+async function cacheTagUrl(url, tags) {
+  const db = await openTagDB();
+  const tx = db.transaction(TAG_STORE_NAME, "readwrite");
+  const store = tx.objectStore(TAG_STORE_NAME);
+  store.put({ url, tags });
+  await new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+async function invalidateByTag(tag) {
+  const db = await openTagDB();
+  const tx = db.transaction(TAG_STORE_NAME, "readonly");
+  const store = tx.objectStore(TAG_STORE_NAME);
+  const index = store.index("by-tag");
+  const entries = await new Promise((resolve, reject) => {
+    const request = index.getAll(tag);
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+  await db.close();
+
+  const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
+  for (const entry of entries) {
+    await runtimeCache.delete(entry.url);
+  }
+
+  const writeDb = await openTagDB();
+  const writeTx = writeDb.transaction(TAG_STORE_NAME, "readwrite");
+  const writeStore = writeTx.objectStore(TAG_STORE_NAME);
+  for (const entry of entries) {
+    writeStore.delete(entry.url);
+  }
+  await new Promise((resolve, reject) => {
+    writeTx.oncomplete = () => resolve();
+    writeTx.onerror = () => reject(writeTx.error);
+  });
+
+  const clients = await self.clients.matchAll();
+  clients.forEach((client) => {
+    client.postMessage({ type: "TAG_INVALIDATED", tag });
+  });
+}`;
+}
+//# sourceMappingURL=tag-management.js.map

package/dist/lib/generators/sw-sections/tag-management.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-management.js","sourceRoot":"","sources":["../../../../src/lib/generators/sw-sections/tag-management.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,UAAU,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8DP,CAAC;AACH,CAAC"}