@swoff/cli 0.3.13 → 0.3.14

package/dist/runtime/cache.js

@@ -1,17 +1,30 @@
 import { T, R } from "./utils.js";
-export function generateCacheCode(ctx) {
+function generateCascadingCode(cascading) {
+    if (!cascading || Object.keys(cascading).length === 0)
+        return "null";
+    return JSON.stringify(cascading);
+}
+export function generateCacheCode(ctx, cascading) {
     const { ext, ts } = ctx;
+    const cascadingCode = generateCascadingCode(cascading);
     return `/**
  * Swoff Cache Invalidation
- * Framework-agnostic cache tag invalidation.
+ * Framework-agnostic cache tag invalidation, URL-based invalidation,
+ * cascading dependency expansion, introspection, and glob matching.
  *
  * Usage:
- *   import { invalidateByTag, invalidateByTags } from './swoff/cache.${ext}';
+ *   import { invalidateByTag, invalidateByTags, invalidateUrl } from './swoff/cache/invalidate.${ext}';
  *
  *   // After a mutation, invalidate related cache
  *   await invalidateByTag("todos");
+ *   await invalidateUrl("/api/todos/42");
  */
 
+import { generateTags, generateTagsFromMethod } from "./tags.${ext}";
+
+// Cascading invalidation map (tag → dependent tags)
+const CASCADING${T(ts, "Record<string, string[]> | null")} = ${cascadingCode};
+
 /** Invalidate all cached responses tagged with the given tag. Sends INVALIDATE_TAG to the SW; the client-injector dispatches cache-invalidated on SW confirmation. */
 export async function invalidateByTag(tag${T(ts, "string")})${R(ts, "Promise<void>")}{
   if (!navigator.serviceWorker?.controller) return;
@@ -25,6 +38,81 @@ export async function invalidateByTag(tag${T(ts, "string")})${R(ts, "Promise<voi
 export async function invalidateByTags(tags${T(ts, "string[]")})${R(ts, "Promise<void>")}{
   await Promise.all(tags.map((tag) => invalidateByTag(tag)));
 }
+
+/** Expand tags with their cascading dependencies, deduplicated. */
+export function expandCascading(tags${T(ts, "string[]")})${R(ts, "string[]")}{
+  if (!CASCADING) return [...tags];
+  const result = new Set(tags);
+  for (const tag of tags) {
+    const deps = CASCADING[tag];
+    if (deps) {
+      for (const dep of deps) {
+        result.add(dep);
+      }
+    }
+  }
+  return [...result];
+}
+
+/** Invalidate cached responses related to a URL, including cascading dependencies. */
+export async function invalidateUrl(url${T(ts, "string | URL")})${R(ts, "Promise<void>")}{
+  const tags = generateTags(url);
+  const allTags = CASCADING ? expandCascading(tags) : tags;
+  await invalidateByTags(allTags);
+}
+
+/** Invalidate cached responses tagged with method-prefixed tags, including cascading dependencies. */
+export async function invalidateByMethod(method${T(ts, "string")}, url${T(ts, "string | URL")})${R(ts, "Promise<void>")}{
+  const tags = generateTagsFromMethod(method, url);
+  const allTags = CASCADING ? expandCascading(tags) : tags;
+  await invalidateByTags(allTags);
+}
+
+/** Invalidate all cached responses whose URL matches the given glob pattern. */
+export async function invalidateMatching(glob${T(ts, "string")})${R(ts, "Promise<void>")}{
+  const controller = navigator.serviceWorker?.controller;
+  if (!controller) return;
+  controller.postMessage({
+    type: "INVALIDATE_MATCHING",
+    glob,
+  });
+}
+
+/** Introspect: get all URLs cached under a given tag. */
+export async function getUrlsForTag(tag${T(ts, "string")})${R(ts, "Promise<{ url: string; actualUrl: string }[]>")}{
+  const controller = navigator.serviceWorker?.controller;
+  if (!controller) return [];
+  return new Promise((resolve) => {
+    const channel = new MessageChannel();
+    const timeout = setTimeout(() => { channel.port1.close(); resolve([]); }, 5000);
+    channel.port1.onmessage = (event) => {
+      clearTimeout(timeout);
+      resolve(event.data.urls || []);
+    };
+    controller.postMessage(
+      { type: "GET_URLS_FOR_TAG", tag },
+      [channel.port2],
+    );
+  });
+}
+
+/** Introspect: get all tags associated with a given URL. */
+export async function getTagsForUrl(url${T(ts, "string")})${R(ts, "Promise<string[]>")}{
+  const controller = navigator.serviceWorker?.controller;
+  if (!controller) return [];
+  return new Promise((resolve) => {
+    const channel = new MessageChannel();
+    const timeout = setTimeout(() => { channel.port1.close(); resolve([]); }, 5000);
+    channel.port1.onmessage = (event) => {
+      clearTimeout(timeout);
+      resolve(event.data.tags || []);
+    };
+    controller.postMessage(
+      { type: "GET_TAGS_FOR_URL", url },
+      [channel.port2],
+    );
+  });
+}
 `;
 }
 //# sourceMappingURL=cache.js.map

package/dist/runtime/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/runtime/cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,iBAAiB,CAAC,GAAmB;IACnD,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,OAAO;;;;;wEAK+D,GAAG;;;;;;;2CAOhC,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;6CASvC,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;CAGvF,CAAC;AACF,CAAC"}
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/runtime/cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,SAAS,qBAAqB,CAAC,SAAmC;IAChE,IAAI,CAAC,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC;IACrE,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,iBAAiB,CAC/B,GAAmB,EACnB,SAAmC;IAEnC,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,MAAM,aAAa,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAEvD,OAAO;;;;;;kGAMyF,GAAG;;;;;;;+DAOtC,GAAG;;;iBAGjD,CAAC,CAAC,EAAE,EAAE,iCAAiC,CAAC,MAAM,aAAa;;;2CAGjC,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;6CASvC,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;sCAKlD,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;yCAenC,CAAC,CAAC,EAAE,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;iDAOvC,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;+CAOxE,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;yCAU/C,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,+CAA+C,CAAC;;;;;;;;;;;;;;;;;;yCAkBzE,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,mBAAmB,CAAC;;;;;;;;;;;;;;;;CAgBrF,CAAC;AACF,CAAC"}

package/dist/runtime/client-injector-bundle.js

@@ -0,0 +1,314 @@
+export function generateClientInjectorBundleCode(ctx, autoActivate, swFilename, pwaEnabled, navMode, authEnabled, mutationQueueEnabled) {
+    const pwaCode = pwaEnabled ? `
+  // ── PWA Install Prompt ──
+  function setupPwaInstall() {
+    window.addEventListener("beforeinstallprompt", function (e) {
+      window.deferredInstallPrompt = e;
+      window.pwaInstallable = true;
+      e.preventDefault();
+      window.dispatchEvent(new CustomEvent("pwa-installable", { detail: { isInstallable: true } }));
+    });
+    window.addEventListener("appinstalled", function () {
+      window.deferredInstallPrompt = null;
+      window.pwaInstallable = false;
+      window.dispatchEvent(new CustomEvent("pwa-installed", { detail: { outcome: "accepted" } }));
+    });
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") { setupPwaInstall(); }` : "";
+    const ssrPrefetch = navMode === "ssr" ? `
+  // ── Auto-prefetch HTML on client-side navigation (SSR mode) ──
+  // Guards against missing prefetchCache — only active when the user includes the fetch/core module.
+  if (typeof history !== "undefined") {
+    var origPushState = history.pushState.bind(history);
+    history.pushState = function (data, unused, url) {
+      origPushState(data, unused, url);
+      if (typeof url === "string" && url.startsWith("/") && typeof prefetchCache === "function") {
+        prefetchCache(url);
+      }
+    };
+    var origReplaceState = history.replaceState.bind(history);
+    history.replaceState = function (data, unused, url) {
+      origReplaceState(data, unused, url);
+      if (typeof url === "string" && url.startsWith("/") && typeof prefetchCache === "function") {
+        prefetchCache(url);
+      }
+    };
+  }` : "";
+    return `(function () {
+  "use strict";
+
+  // ── Service Worker Registration ──
+  var AUTO_ACTIVATE = ${autoActivate};
+
+  function waitForController() {
+    return new Promise(function (resolve) {
+      if (navigator.serviceWorker.controller) {
+        resolve();
+      } else {
+        var timeout = setTimeout(function () { resolve(); }, 30000);
+        navigator.serviceWorker.addEventListener("controllerchange", function () {
+          clearTimeout(timeout);
+          resolve();
+        }, { once: true });
+      }
+    });
+  }
+
+  async function registerSW() {
+    if (!("serviceWorker" in navigator)) {
+      console.warn("Service Workers not supported");
+      return;
+    }
+    try {
+      var registration = await navigator.serviceWorker.register("/${swFilename}.js");
+      var swReadyDispatched = false;
+      if (registration.installing) {
+        var installingWorker = registration.installing;
+        installingWorker.addEventListener("statechange", function () {
+          if (installingWorker.state === "installed") {
+            if (AUTO_ACTIVATE) {
+              if (registration.waiting) {
+                registration.waiting.postMessage({ type: "SKIP_WAITING" });
+              }
+            }
+            swReadyDispatched = true;
+            window.dispatchEvent(new CustomEvent("sw-ready"));
+          }
+        });
+      }
+      await waitForController();
+      if (!swReadyDispatched) {
+        window.dispatchEvent(new CustomEvent("sw-ready"));
+      }
+    } catch (error) {
+      console.error("Service Worker registration failed:", error);
+      window.swError = true;
+      window.dispatchEvent(new CustomEvent("sw-error"));
+    }
+  }
+
+  // ── Connectivity ──
+  var CONNECTIVITY_EVENT = "app-connectivity-change";
+  var heartbeatIntervalId = null;
+  var HEARTBEAT_DELAY = 30000;
+  var _currentOnlineStatus = typeof navigator !== "undefined" ? navigator.onLine : true;
+
+  function getCurrentOnlineStatus() {
+    return _currentOnlineStatus;
+  }
+
+  function createTimeoutSignal(ms) {
+    if (typeof AbortSignal.timeout === "function") return AbortSignal.timeout(ms);
+    var ctrl = new AbortController();
+    setTimeout(function () { ctrl.abort(); }, ms);
+    return ctrl.signal;
+  }
+
+  async function verifyAndNotify() {
+    if (typeof window === "undefined") return false;
+    if (!navigator.onLine) {
+      dispatchState(false);
+      return false;
+    }
+    try {
+      await fetch("/" + Date.now() + "?hb=1", {
+        method: "HEAD",
+        cache: "no-cache",
+        signal: createTimeoutSignal(5000),
+      });
+      if (navigator.serviceWorker.controller) {
+        navigator.serviceWorker.controller.postMessage({ type: "ONLINE" });
+      }
+      dispatchState(true);
+      return true;
+    } catch (error) {
+      if (navigator.serviceWorker.controller) {
+        navigator.serviceWorker.controller.postMessage({ type: "OFFLINE" });
+      }
+      dispatchState(false);
+      return false;
+    }
+  }
+
+  function dispatchState(isTrulyOnline) {
+    _currentOnlineStatus = isTrulyOnline;
+    window.dispatchEvent(new CustomEvent(CONNECTIVITY_EVENT, { detail: { online: isTrulyOnline } }));
+  }
+
+  function startHeartbeat() {
+    if (heartbeatIntervalId) return;
+    heartbeatIntervalId = setInterval(async function () {
+      if (document.hidden) return;
+      await verifyAndNotify();
+    }, HEARTBEAT_DELAY);
+  }
+
+  function stopHeartbeat() {
+    if (!heartbeatIntervalId) return;
+    clearInterval(heartbeatIntervalId);
+    heartbeatIntervalId = null;
+  }
+
+  function forceRetry() {
+    stopHeartbeat();
+    return verifyAndNotify().then(function () {
+      startHeartbeat();
+    });
+  }
+
+  // ── Storage ──
+  async function getStorageEstimate() {
+    if (!navigator.storage || !navigator.storage.estimate) {
+      return { usage: 0, quota: 0, percentUsed: 0 };
+    }
+    var est = await navigator.storage.estimate();
+    var usage = est.usage || 0;
+    var quota = est.quota || 0;
+    var percentUsed = quota > 0 ? Math.round((usage / quota) * 100) : 0;
+    return { usage: usage, quota: quota, percentUsed: percentUsed };
+  }
+
+  function formatBytes(bytes) {
+    if (bytes === 0) return "0 B";
+    var units = ["B", "KB", "MB", "GB"];
+    var i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return (bytes / Math.pow(1024, i)).toFixed(1) + " " + units[i];
+  }
+
+  // ── Online / Offline / Visibility Listeners ──
+  if (typeof window !== "undefined") {
+    window.addEventListener("online", async function () {
+      await verifyAndNotify();
+      startHeartbeat();
+    });
+
+    window.addEventListener("offline", function () {
+      stopHeartbeat();
+      dispatchState(false);
+    });
+
+    document.addEventListener("visibilitychange", function () {
+      if (!document.hidden) {
+        verifyAndNotify();
+        startHeartbeat();
+      } else {
+        stopHeartbeat();
+      }
+    });
+
+    if (navigator.onLine) {
+      verifyAndNotify();
+      startHeartbeat();
+    } else {
+      queueMicrotask(function () { dispatchState(false); });
+    }
+  }
+
+  // ── Focus Listener (reactive strategy) ──
+  if (typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", function () {
+      if (document.visibilityState === "visible" && navigator.serviceWorker.controller) {
+        navigator.serviceWorker.controller.postMessage({ type: "FOCUS" });
+      }
+    });
+  }
+${pwaCode}${ssrPrefetch}
+  // ── SW Message Listener ──
+  if (typeof window !== "undefined" && "serviceWorker" in navigator) {
+    navigator.serviceWorker.addEventListener("message", function (event) {
+      if (event.data.type === "CACHE_UPDATED") {
+        window.dispatchEvent(new CustomEvent("swoff:cache-updated", { detail: { url: event.data.url } }));
+      }
+      if (event.data.type === "NAV_RETRY_SUCCESS") {
+        window.dispatchEvent(new CustomEvent("swoff:navigation-online", { detail: { url: event.data.url } }));
+      }
+      if (event.data.type === "OFFLINE_FALLBACK_ACTIVATED") {
+        window.dispatchEvent(new CustomEvent("swoff:offline-fallback", { detail: event.data.detail }));
+      }
+      if (event.data.type === "SW_PROGRESS") {
+        window.dispatchEvent(new CustomEvent("sw-progress", {
+          detail: { percent: event.data.percent, downloaded: event.data.downloaded, total: event.data.total },
+        }));
+      }
+      if (event.data.type === "SW_NOTIFICATION") {
+        window.dispatchEvent(new CustomEvent("swoff:notification", {
+          detail: { level: event.data.level, code: event.data.code, message: event.data.message },
+        }));
+      }
+${mutationQueueEnabled ? `
+      if (event.data.type === "BACKGROUND_SYNC_PROGRESS") {
+        window.dispatchEvent(new CustomEvent("mutation-sync-progress", { detail: event.data.detail }));
+      }
+      if (event.data.type === "BACKGROUND_SYNC_COMPLETE") {
+        var _d = event.data.detail;
+        window.dispatchEvent(new CustomEvent("mutation-sync-complete", { detail: { succeeded: _d.succeeded, failed: _d.failed } }));
+        if (_d.tags && _d.tags.length > 0) {
+          window.dispatchEvent(new CustomEvent("cache-invalidated", { detail: { tags: _d.tags } }));
+        }
+        window.dispatchEvent(new CustomEvent("mutation-queue-changed"));
+      }
+      if (event.data.type === "MUTATION_STORED" && window.swoff && typeof window.swoff.flushMutations === "function") {
+        window.swoff.flushMutations();
+      }` : ""}
+${authEnabled ? `
+      if (event.data.type === "AUTH_CLEARED" && window.swoff && typeof window.swoff.clearMemoryAuth === "function") {
+        window.swoff.clearMemoryAuth();
+        window.dispatchEvent(new CustomEvent("sw-auth-state-change", { detail: { type: "clear" } }));
+      }
+      if (event.data.type === "AUTH_FAILURE" && window.swoff && typeof window.swoff.ensureValidAuth === "function") {
+        (async function () {
+          var _refreshed = await window.swoff.ensureValidAuth();
+          if (!_refreshed) {
+            if (window.swoff && typeof window.swoff.clearQueue === "function") {
+              await window.swoff.clearQueue();
+            }
+            try {
+              var _names = ["swoff-runtime", "swoff-runtime-html"];
+              for (var _i = 0; _i < _names.length; _i++) {
+                var _cache = await caches.open(_names[_i]);
+                var _keys = await _cache.keys();
+                await Promise.all(_keys.map(function (k) { return _cache.delete(k); }));
+              }
+            } catch (e) {}
+            window.dispatchEvent(new CustomEvent("sw-auth-unauthorized"));
+          }
+        })();
+      }` : ""}
+      if (event.data.type === "TAG_INVALIDATED" && event.data.tag) {
+        window.dispatchEvent(new CustomEvent("cache-invalidated", {
+          detail: { tags: [event.data.tag] },
+        }));
+      }
+    });
+  }
+
+  // ── Main Entry ──
+  async function initServiceWorker() {
+    await registerSW();
+    var storage = await getStorageEstimate();
+    if (storage.percentUsed > 80) {
+      window.dispatchEvent(new CustomEvent("swoff:notification", {
+        detail: {
+          level: "warn",
+          code: "STORAGE_QUOTA_HIGH",
+          message: "Storage at " + storage.percentUsed + "% capacity (" + formatBytes(storage.usage) + " / " + formatBytes(storage.quota) + ")",
+        },
+      }));
+    }
+  }
+
+  // ── Bridge for swoff-api-bundle ──
+  if (typeof window !== "undefined") {
+    window.__SWOFF_FORCE_RETRY = forceRetry;
+  }
+
+  // ── Auto-initialize ──
+  if (typeof window !== "undefined" && "serviceWorker" in navigator) {
+    initServiceWorker().catch(function (err) {
+      console.warn("Swoff SW registration failed:", err);
+    });
+  }
+})();
+`;
+}
+//# sourceMappingURL=client-injector-bundle.js.map

package/dist/runtime/client-injector-bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-injector-bundle.js","sourceRoot":"","sources":["../../src/runtime/client-injector-bundle.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,gCAAgC,CAC9C,GAAmB,EACnB,YAAqB,EACrB,UAAkB,EAClB,UAAmB,EACnB,OAAgB,EAChB,WAAqB,EACrB,oBAA8B;IAE9B,MAAM,OAAO,GAAG,UAAU,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;+FAegE,CAAC,CAAC,CAAC,EAAE,CAAC;IAEnG,MAAM,WAAW,GAAG,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;IAkBtC,CAAC,CAAC,CAAC,EAAE,CAAC;IAER,OAAO;;;;wBAIe,YAAY;;;;;;;;;;;;;;;;;;;;;;oEAsBgC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwJ5E,OAAO,GAAG,WAAW;;;;;;;;;;;;;;;;;;;;;;;EAuBrB,oBAAoB,CAAC,CAAC,CAAC;;;;;;;;;;;;;;QAcjB,CAAC,CAAC,CAAC,EAAE;EACX,WAAW,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;QAuBR,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCZ,CAAC;AACF,CAAC"}