@swoff/cli 0.1.0 → 0.2.1

package/dist/lib/generators/file-generators/sw-injector.js

@@ -0,0 +1,201 @@
+/**
+ * Generates sw-injector.{js|ts} - client-side SW registration with version checking.
+ */
+import { writeFile } from "./context.js";
+export function generateSwInjector(ctx) {
+    const autoRegister = ctx.config.serviceWorker.autoRegister;
+    const autoActivate = ctx.config.serviceWorker.autoActivate;
+    const ext = ctx.ext;
+    const code = `/**
+ * Swoff Service Worker Injector
+ * Framework-agnostic client registration with version checking.
+ *
+ * Usage:
+ *   import { initServiceWorker } from './swoff/sw-injector.${ext}';
+ *
+ *   // Call in your app entry point (e.g., main.tsx, app.js):
+ *   initServiceWorker();
+ *
+ *   // Or defer until after onboarding, but still call initServiceWorker():
+ *   // (edit the shouldRegister function below instead)
+ *
+ * Window events:
+ *   sw-version-detected  - Version info available on window
+ *   sw-update-available  - New version ready for user consent (detail: { version })
+ *   sw-progress          - Download progress (detail: { percent, downloaded, total })
+ *   sw-ready             - SW active and controlling page
+ *   sw-error             - SW registration failed
+ *
+ * Window properties:
+ *   window.latestSWVersion       - Latest version from version.json
+ *   window.currentSWVersion      - Active SW version
+ *   window.swAvailableVersion    - Pending update version
+ *   window.swUpdateRequired      - Forced update needed (version < minSupportedVersion)
+ *   window.swMinSupportedVersion - Minimum supported version from version.json
+ *   window.swReady               - SW is active
+ *   window.swError               - Registration failed
+ */
+
+const AUTO_REGISTER = ${autoRegister};
+const AUTO_ACTIVATE = ${autoActivate};
+
+async function checkForUpdate() {
+  const response = await fetch("/version.json");
+  if (!response.ok) {
+    throw new Error("Failed to fetch version.json");
+  }
+  return response.json();
+}
+
+async function doRegisterServiceWorker(version) {
+  const swUrl = \`/sw-v\${version}.js\`;
+  const registration = await navigator.serviceWorker.register(swUrl);
+  localStorage.setItem("swRegisteredVersion", version);
+  window.currentSWVersion = version;
+  window.swRegisteredVersion = version;
+  window.dispatchEvent(new CustomEvent("sw-version-detected"));
+  window.dispatchEvent(new CustomEvent("sw-ready"));
+  return registration;
+}
+
+function shouldRegister() {
+  // Add custom preconditions here. Return false to prevent registration.
+  // Examples:
+  //   if (!localStorage.getItem("onboarding-complete")) return false;
+  //   if (navigator.connection?.effectiveType === "slow-2g") return false;
+
+  return true;
+}
+
+export async function initServiceWorker() {
+  if (!("serviceWorker" in navigator)) {
+    console.warn("Service Workers not supported");
+    return;
+  }
+
+  if (!shouldRegister()) return;
+
+  try {
+    const manifest = await checkForUpdate();
+    const currentVersion = localStorage.getItem("swRegisteredVersion");
+    window.latestSWVersion = manifest.version;
+    window.swMinSupportedVersion = manifest.minSupportedVersion || "0.0.0";
+
+    if (currentVersion === manifest.version) {
+      const registration = await navigator.serviceWorker.getRegistration();
+      if (registration && registration.active) {
+        window.currentSWVersion = currentVersion;
+        window.dispatchEvent(new CustomEvent("sw-version-detected"));
+        window.dispatchEvent(new CustomEvent("sw-ready"));
+      }
+    } else if (currentVersion && currentVersion !== manifest.version) {
+      window.swAvailableVersion = manifest.version;
+      window.swUpdateRequired =
+        currentVersion < (manifest.minSupportedVersion || "0.0.0");
+
+      if (AUTO_REGISTER) {
+        const registration = await navigator.serviceWorker.getRegistration();
+        if (registration && registration.waiting) {
+          if (AUTO_ACTIVATE) {
+            registration.waiting.postMessage({ type: "SKIP_WAITING" });
+          } else {
+            window.dispatchEvent(
+              new CustomEvent("sw-update-available", {
+                detail: { version: manifest.version },
+              })
+            );
+          }
+        } else {
+          const newReg = await doRegisterServiceWorker(manifest.version);
+          if (AUTO_ACTIVATE && newReg.waiting) {
+            newReg.waiting.postMessage({ type: "SKIP_WAITING" });
+          } else {
+            window.dispatchEvent(
+              new CustomEvent("sw-update-available", {
+                detail: { version: manifest.version },
+              })
+            );
+          }
+        }
+      } else {
+        window.dispatchEvent(
+          new CustomEvent("sw-update-available", {
+            detail: { version: manifest.version },
+          })
+        );
+      }
+    } else {
+      await doRegisterServiceWorker(manifest.version);
+    }
+  } catch (error) {
+    // Offline or version.json fetch failed — try using existing registration
+    try {
+      const existing = await navigator.serviceWorker.getRegistration();
+      if (existing && existing.active) {
+        window.currentSWVersion = localStorage.getItem("swRegisteredVersion") || "unknown";
+        window.dispatchEvent(new CustomEvent("sw-version-detected"));
+        window.dispatchEvent(new CustomEvent("sw-ready"));
+        return;
+      }
+    } catch {
+      // Registration check also failed, nothing we can do
+    }
+
+    console.error("Service Worker initialization failed:", error);
+    window.swError = true;
+    window.dispatchEvent(new CustomEvent("sw-error"));
+  }
+}
+
+export async function handleUpdateApproved(newVersion) {
+  const registration = await navigator.serviceWorker.getRegistration();
+  if (registration && registration.waiting) {
+    registration.waiting.postMessage({ type: "SKIP_WAITING" });
+    registration.addEventListener("controllerchange", () => {
+      window.location.reload();
+    });
+  } else {
+    await doRegisterServiceWorker(newVersion);
+    navigator.serviceWorker.addEventListener("controllerchange", () => {
+      window.location.reload();
+    });
+  }
+}
+
+export async function skipWaiting() {
+  const registration = await navigator.serviceWorker.ready;
+  if (registration.waiting) {
+    registration.waiting.postMessage({ type: "SKIP_WAITING" });
+  }
+}
+
+if (typeof window !== "undefined" && "serviceWorker" in navigator) {
+  navigator.serviceWorker.addEventListener("message", (event) => {
+    if (event.data.type === "SW_PROGRESS") {
+      const { percent, downloaded, total } = event.data;
+      window.dispatchEvent(
+        new CustomEvent("sw-progress", {
+          detail: { percent, downloaded, total },
+        })
+      );
+    }
+    if (event.data.type === "BACKGROUND_SYNC_COMPLETE") {
+      const { succeeded, failed, tags } = event.data.detail;
+      window.dispatchEvent(
+        new CustomEvent("mutation-sync-complete", {
+          detail: { succeeded, failed },
+        })
+      );
+      if (tags && tags.length > 0) {
+        window.dispatchEvent(
+          new CustomEvent("cache-invalidated", { detail: { tags } })
+        );
+      }
+      window.dispatchEvent(new CustomEvent("mutation-queue-changed"));
+    }
+  });
+}
+`;
+    writeFile(ctx, `sw-injector.${ext}`, code);
+}
+//# sourceMappingURL=sw-injector.js.map

package/dist/lib/generators/file-generators/sw-injector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sw-injector.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/sw-injector.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,kBAAkB,CAAC,GAAqB;IACtD,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,YAAY,CAAC;IAC3D,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,YAAY,CAAC;IAC3D,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IAEpB,MAAM,IAAI,GAAG;;;;;8DAK+C,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;wBAyBzC,YAAY;wBACZ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8JnC,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,eAAe,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC7C,CAAC"}

package/dist/lib/generators/file-generators/sw-template.js

@@ -0,0 +1,143 @@
+/**
+ * Generates sw-template.js - the SW template with placeholders.
+ */
+import { writeFile } from "./context.js";
+export function generateSwTemplate(ctx) {
+    const code = `/**
+ * Swoff Service Worker Template
+ *
+ * This file is processed by swoff/sw-generator.js to create
+ * a versioned service worker. Placeholders are replaced during build.
+ *
+ * Placeholders:
+ *   // [[CACHE_NAME]]       - Replaced with versioned cache name
+ *   // [[ASSETS_LIST]]      - Replaced with assets to cache
+ *   // [[AUTO_SKIP_WAITING]] - Replaced with autoActivate config
+ *
+ * You can customize this template before running the build script.
+ */
+
+let CACHE_NAME = "";
+let ASSETS_TO_CACHE = [];
+
+// [[CACHE_NAME]]
+// [[ASSETS_LIST]]
+// [[AUTO_SKIP_WAITING]]
+
+const CACHE_NAME_RUNTIME = "swoff-runtime";
+
+// Install - download assets with progress tracking
+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();
+    })(),
+  );
+});
+
+// Activate - clean old caches
+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))
+      )
+    )
+  );
+});
+
+// Message - skip waiting and cache invalidation
+self.addEventListener("message", (event) => {
+  if (event.data.type === "SKIP_WAITING") {
+    self.skipWaiting();
+  }
+});
+
+// Fetch - cache strategies
+self.addEventListener("fetch", (event) => {
+  if (event.request.method !== "GET" && event.request.method !== "HEAD") return;
+
+  event.respondWith(
+    (async () => {
+      const cache = await caches.open(CACHE_NAME);
+      const runtimeCache = await caches.open(CACHE_NAME_RUNTIME);
+      const url = new URL(event.request.url);
+
+      const byPath = await cache.match(url.pathname);
+      if (byPath) return byPath;
+
+      const byRequest = await runtimeCache.match(event.request);
+      if (byRequest) return byRequest;
+
+      if (event.request.mode === "navigate") {
+        const spa = await cache.match("/index.html");
+        if (spa) return spa;
+      }
+
+      try {
+        const response = await fetch(event.request);
+        if (response.ok) {
+          await runtimeCache.put(event.request, response.clone());
+        }
+        return response;
+      } catch {
+        return new Response("Offline: content not available", { status: 503 });
+      }
+    })(),
+  );
+});
+
+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;
+}
+`;
+    writeFile(ctx, "sw-template.js", code);
+}
+//# sourceMappingURL=sw-template.js.map

package/dist/lib/generators/file-generators/sw-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sw-template.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/sw-template.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,kBAAkB,CAAC,GAAqB;IACtD,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsId,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,gBAAgB,EAAE,IAAI,CAAC,CAAC;AACzC,CAAC"}

package/dist/lib/generators/file-generators/type-definitions.js

@@ -0,0 +1,69 @@
+/**
+ * Generates swoff.d.ts - TypeScript type declarations.
+ */
+import { writeFile } from "./context.js";
+export function generateTypeDefinitions(ctx) {
+    if (ctx.ext !== "ts")
+        return;
+    const code = `interface BeforeInstallPromptEvent extends Event {
+  prompt(): Promise<void>;
+  userChoice: Promise<{ outcome: "accepted" | "dismissed" }>;
+}
+
+declare global {
+  interface Window {
+    deferredInstallPrompt: BeforeInstallPromptEvent | null;
+    latestSWVersion?: string;
+    currentSWVersion?: string;
+    swRegisteredVersion?: string;
+    swAvailableVersion?: string;
+    swUpdateRequired?: boolean;
+    swMinSupportedVersion?: string;
+    swReady?: boolean;
+    swError?: boolean;
+  }
+}
+
+export interface SWOFFCache {
+  get(key: Request | string): Promise<Response | undefined>;
+  put(request: Request | string, response: Response): Promise<void>;
+  delete(request: Request | string): Promise<boolean>;
+}
+
+export interface SWOFF {
+  cache: SWOFFCache;
+  network: {
+    fetch(request: Request | string, options?: RequestInit): Promise<Response>;
+  };
+}
+
+export interface FetchWithCacheOptions extends RequestInit {
+  strategy?: "read" | "mutation";
+  tags?: string[];
+  staleWhileRevalidate?: boolean;
+}
+
+export interface MutationQueueItem {
+  id: string;
+  method: string;
+  url: string;
+  body: unknown;
+  headers: Record<string, string>;
+  previousData: unknown | null;
+  timestamp: number;
+  retryCount: number;
+  tags: string[];
+  storeName: string | null;
+  tempId: string | null;
+}
+
+export interface MutationQueueResult {
+  succeeded: number;
+  failed: number;
+}
+
+export {};
+`;
+    writeFile(ctx, "swoff.d.ts", code);
+}
+//# sourceMappingURL=type-definitions.js.map

package/dist/lib/generators/file-generators/type-definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-definitions.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/type-definitions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,uBAAuB,CAAC,GAAqB;IAC3D,IAAI,GAAG,CAAC,GAAG,KAAK,IAAI;QAAE,OAAO;IAE7B,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Dd,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;AACrC,CAAC"}