@swoff/cli 0.0.2 → 0.2.0

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

@@ -0,0 +1,210 @@
+/**
+ * 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") {
+    event.respondWith(networkOnly(event, event.request));
+    return;
+  }
+
+  // cache-first (default)
+  event.respondWith(cacheFirst(event, event.request));
+});
+
+async function cacheFirst(event, request) {
+  const cache = await caches.open(CACHE_NAME);
+  const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
+  const url = new URL(request.url);
+
+  const byPath = await cache.match(url.pathname);
+  if (byPath) return byPath;
+
+  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 cache = await caches.open(CACHE_NAME);
+  const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
+
+  const byPath = await cache.match(new URL(request.url).pathname);
+  if (byPath) return byPath;
+
+  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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAgDtD,mBAAmB;EACrE,QAAQ;;;;;;;;;;;;;;;;;;oDAkB0C,mBAAmB;EACrE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DA8BgD,YAAY;EACpE,OAAO,CAAC,CAAC,CAAC,qDAAqD,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCpE,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"}