@swoff/cli 0.3.0 → 0.3.2

package/dist/lib/generators/file-generators/fetch-wrapper.js

@@ -3,12 +3,13 @@
  */
 import { writeFile } from "./context.js";
 export function generateFetchWrapper(ctx) {
+    const ext = ctx.ext;
     const code = `/**
  * Swoff Fetch Wrapper
  * Framework-agnostic fetch with cache strategy, tags, and query deduplication.
  *
  * Usage:
- *   import { fetchWithCache } from './swoff/fetch-wrapper.js';
+ *   import { fetchWithCache } from './swoff/fetch-wrapper.${ext}';
  *
  *   // GET - cached with tag
  *   const todos = await fetchWithCache("/api/todos", { tags: ["todos"] }).then(r => r.json());
@@ -75,6 +76,6 @@ export async function fetchWithCacheOrQueue(input, options = {}) {
   return fetchWithCache(input, options);
 }
 `;
-    writeFile(ctx, "fetch-wrapper.js", code);
+    writeFile(ctx, `fetch-wrapper.${ext}`, code);
 }
 //# sourceMappingURL=fetch-wrapper.js.map

package/dist/lib/generators/file-generators/fetch-wrapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-wrapper.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/fetch-wrapper.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,oBAAoB,CAAC,GAAqB;IACxD,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEd,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,kBAAkB,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC"}
+{"version":3,"file":"fetch-wrapper.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/fetch-wrapper.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,oBAAoB,CAAC,GAAqB;IACxD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,IAAI,GAAG;;;;;6DAK8C,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkE/D,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,iBAAiB,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC/C,CAAC"}

package/dist/lib/generators/file-generators/indexeddb.js

@@ -3,6 +3,7 @@
  */
 import { writeFile } from "./context.js";
 export function generateIndexedDB(ctx) {
+    const ext = ctx.ext;
     const dbName = ctx.config.features.indexeddb?.name || "app-db";
     const stores = ctx.config.features.indexeddb?.stores || [];
     const storesCode = stores.length > 0
@@ -19,7 +20,7 @@ export function generateIndexedDB(ctx) {
  * Database initialization with schema migrations.
  *
  * Usage:
- *   import { openDB } from './swoff/indexeddb.js';
+ *   import { openDB } from './swoff/indexeddb.${ext}';
  *
  *   const db = await openDB();
  */
@@ -68,6 +69,6 @@ export async function monitorStorage() {
   };
 }
 `;
-    writeFile(ctx, "indexeddb.js", code);
+    writeFile(ctx, `indexeddb.${ext}`, code);
 }
 //# sourceMappingURL=indexeddb.js.map

package/dist/lib/generators/file-generators/indexeddb.js.map

@@ -1 +1 @@
-{"version":3,"file":"indexeddb.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/indexeddb.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,IAAI,QAAQ,CAAC;IAC/D,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,EAAE,CAAC;IAE3D,MAAM,UAAU,GACd,MAAM,CAAC,MAAM,GAAG,CAAC;QACf,CAAC,CAAC,MAAM;aACH,GAAG,CACF,CAAC,KAAa,EAAE,CAAS,EAAE,EAAE,CAC3B,0BAA0B,CAAC,GAAG,CAAC,sCAAsC,KAAK,iCAAiC,CAC9G;aACA,IAAI,CAAC,MAAM,CAAC;QACjB,CAAC,CAAC;;;;WAIG,CAAC;IAEV,MAAM,IAAI,GAAG;;;;;;;;;;mBAUI,MAAM;;;;;;;;;;;EAWvB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCX,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC"}
+{"version":3,"file":"indexeddb.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/indexeddb.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,IAAI,QAAQ,CAAC;IAC/D,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,EAAE,CAAC;IAE3D,MAAM,UAAU,GACd,MAAM,CAAC,MAAM,GAAG,CAAC;QACf,CAAC,CAAC,MAAM;aACH,GAAG,CACF,CAAC,KAAa,EAAE,CAAS,EAAE,EAAE,CAC3B,0BAA0B,CAAC,GAAG,CAAC,sCAAsC,KAAK,iCAAiC,CAC9G;aACA,IAAI,CAAC,MAAM,CAAC;QACjB,CAAC,CAAC;;;;WAIG,CAAC;IAEV,MAAM,IAAI,GAAG;;;;;iDAKkC,GAAG;;;;;mBAKjC,MAAM;;;;;;;;;;;EAWvB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCX,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC"}

package/dist/lib/generators/file-generators/invalidation-tags.js

@@ -3,12 +3,13 @@
  */
 import { writeFile } from "./context.js";
 export function generateInvalidationTags(ctx) {
+    const ext = ctx.ext;
     const code = `/**
  * Swoff Invalidation Tags Helper
  * URL-based tag generation from REST endpoints for automatic cache invalidation.
  *
  * Usage:
- *   import { generateTags, invalidateUrl } from './swoff/invalidation-tags.js';
+ *   import { generateTags, invalidateUrl } from './swoff/invalidation-tags.${ext}';
  *
  *   // Generate tags from URL
  *   generateTags("/api/todos");          // ["todos"]
@@ -24,7 +25,7 @@ export function generateInvalidationTags(ctx) {
  *   await invalidateUrl("/api/todos/42");
  */
 
-import { invalidateByTag, invalidateByTags } from "./cache.js";
+import { invalidateByTag, invalidateByTags } from "./cache.${ext}";
 
 export function generateTags(url) {
   const parsed = typeof url === "string" ? new URL(url, window.location.origin) : url;
@@ -86,6 +87,6 @@ export async function invalidateByMethod(method, url) {
   await invalidateByTags(tags);
 }
 `;
-    writeFile(ctx, "invalidation-tags.js", code);
+    writeFile(ctx, `invalidation-tags.${ext}`, code);
 }
 //# sourceMappingURL=invalidation-tags.js.map

package/dist/lib/generators/file-generators/invalidation-tags.js.map

@@ -1 +1 @@
-{"version":3,"file":"invalidation-tags.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/invalidation-tags.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,wBAAwB,CAAC,GAAqB;IAC5D,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFd,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,sBAAsB,EAAE,IAAI,CAAC,CAAC;AAC/C,CAAC"}
+{"version":3,"file":"invalidation-tags.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/invalidation-tags.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,wBAAwB,CAAC,GAAqB;IAC5D,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,IAAI,GAAG;;;;;8EAK+D,GAAG;;;;;;;;;;;;;;;;6DAgBpB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6D/D,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,qBAAqB,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AACnD,CAAC"}

package/dist/lib/generators/file-generators/mutation-queue.js

@@ -3,12 +3,13 @@
  */
 import { writeFile } from "./context.js";
 export function generateMutationQueue(ctx) {
+    const ext = ctx.ext;
     const code = `/**
  * Swoff Mutation Queue
  * Queue offline writes and sync when connection returns.
  *
  * Usage:
- *   import { queueMutation, processMutationQueue, getPendingCount } from './swoff/mutation-queue.js';
+ *   import { queueMutation, processMutationQueue, getPendingCount } from './swoff/mutation-queue.${ext}';
  *
  *   // Queue a mutation
  *   await queueMutation({
@@ -116,7 +117,7 @@ export async function processMutationQueue() {
         }
 
         if (item.tags && item.tags.length > 0) {
-          const { invalidateByTags } = await import("./cache.js");
+          const { invalidateByTags } = await import("./cache.${ext}");
           await invalidateByTags(item.tags);
         }
 
@@ -164,16 +165,16 @@ async function rollbackMutation(item) {
   if (!item.storeName) return;
 
   if (item.method === "POST" && item.tempId) {
-    const { deleteRecord } = await import("./store.js");
+    const { deleteRecord } = await import("./store.${ext}");
     await deleteRecord(item.storeName, item.tempId);
   } else if (
     (item.method === "PUT" || item.method === "PATCH") &&
     item.previousData
   ) {
-    const { putRecord } = await import("./store.js");
+    const { putRecord } = await import("./store.${ext}");
     await putRecord(item.storeName, { ...item.previousData, $synced: true });
   } else if (item.method === "DELETE" && item.tempId && item.previousData) {
-    const { putRecord } = await import("./store.js");
+    const { putRecord } = await import("./store.${ext}");
     await putRecord(item.storeName, { ...item.previousData, $synced: true });
   }
 
@@ -190,7 +191,7 @@ async function rollbackMutation(item) {
 }
 
 async function reconcileRecord(storeName, tempId, serverData) {
-  const { getRecord, putRecord, deleteRecord } = await import("./store.js");
+  const { getRecord, putRecord, deleteRecord } = await import("./store.${ext}");
   const existing = await getRecord(storeName, tempId);
   if (!existing) return;
 
@@ -221,6 +222,6 @@ export async function getPendingCount() {
 
 window.addEventListener("online", processMutationQueue);
 `;
-    writeFile(ctx, "mutation-queue.js", code);
+    writeFile(ctx, `mutation-queue.${ext}`, code);
 }
 //# sourceMappingURL=mutation-queue.js.map

package/dist/lib/generators/file-generators/mutation-queue.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutation-queue.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/mutation-queue.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,qBAAqB,CAAC,GAAqB;IACzD,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyNd,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,mBAAmB,EAAE,IAAI,CAAC,CAAC;AAC5C,CAAC"}
+{"version":3,"file":"mutation-queue.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/mutation-queue.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,qBAAqB,CAAC,GAAqB;IACzD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,IAAI,GAAG;;;;;oGAKqF,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DA4GxC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAgDb,GAAG;;;;;;kDAMN,GAAG;;;kDAGH,GAAG;;;;;;;;;;;;;;;;;yEAiBoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B3E,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,kBAAkB,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAChD,CAAC"}

package/dist/lib/generators/file-generators/pwa-install.js

@@ -1,70 +1,26 @@
 /**
- * Generates pwa-install.js - PWA install prompt handler.
+ * Generates pwa-install.{js|ts} - PWA install prompt utility.
  */
 import { writeFile } from "./context.js";
 export function generatePwaInstall(ctx) {
-    const preventDefault = ctx.config.features.pwa?.preventDefaultInstall ?? false;
+    const ext = ctx.ext;
     const code = `/**
- * Swoff PWA Install Prompt Handler
- * Captures beforeinstallprompt event and provides manual install trigger.
+ * Swoff PWA Install Prompt
+ * Manual install trigger and installability check.
+ * Event listeners are registered in sw-injector at app entry.
  *
  * Usage:
- *   import { isInstallable, promptInstall } from './swoff/pwa-install.js';
+ *   import { isInstallable, promptInstall } from './swoff/pwa-install.${ext}';
  *
- *   // Listen for installable event
- *   window.addEventListener('pwa-installable', (e) => {
- *     console.log('PWA can be installed:', e.detail.isInstallable);
- *     // Show your custom install button
- *   });
- *
- *   // When user clicks install button
- *   async function onInstallClick() {
+ *   if (isInstallable()) {
  *     const result = await promptInstall();
- *     console.log('User choice:', result);
+ *     console.log('User choice:', result.outcome);
  *   }
  *
- * Window events:
- *   pwa-installable  - PWA can be installed (detail: { isInstallable: true })
- *   pwa-installed    - User accepted install (detail: { outcome: 'accepted' })
- *   pwa-dismissed    - User dismissed install (detail: { outcome: 'dismissed' })
- *
- * Window properties:
+ * Window properties (set by sw-injector):
  *   window.deferredInstallPrompt - The captured BeforeInstallPromptEvent
- *   window.pwaInstallable        - Whether PWA can be installed
  */
 
-const PREVENT_DEFAULT_INSTALL = ${preventDefault};
-
-window.addEventListener("beforeinstallprompt", (e) => {
-  // Always capture the event so we never lose it
-  window.deferredInstallPrompt = e;
-  window.pwaInstallable = true;
-
-  if (PREVENT_DEFAULT_INSTALL) {
-    // Suppress browser's native prompt
-    e.preventDefault();
-  }
-  // When false, browser shows native prompt naturally
-  // but we still capture the event for manual triggering
-
-  window.dispatchEvent(
-    new CustomEvent("pwa-installable", {
-      detail: { isInstallable: true },
-    })
-  );
-});
-
-window.addEventListener("appinstalled", () => {
-  window.deferredInstallPrompt = null;
-  window.pwaInstallable = false;
-
-  window.dispatchEvent(
-    new CustomEvent("pwa-installed", {
-      detail: { outcome: "accepted" },
-    })
-  );
-});
-
 export function isInstallable() {
   return !!window.deferredInstallPrompt;
 }
@@ -97,6 +53,6 @@ export async function promptInstall() {
   return choice;
 }
 `;
-    writeFile(ctx, "pwa-install.js", code);
+    writeFile(ctx, `pwa-install.${ext}`, code);
 }
 //# sourceMappingURL=pwa-install.js.map

package/dist/lib/generators/file-generators/pwa-install.js.map

@@ -1 +1 @@
-{"version":3,"file":"pwa-install.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/pwa-install.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,kBAAkB,CAAC,GAAqB;IACtD,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,qBAAqB,IAAI,KAAK,CAAC;IAE/E,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA6BmB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+D/C,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,gBAAgB,EAAE,IAAI,CAAC,CAAC;AACzC,CAAC"}
+{"version":3,"file":"pwa-install.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/pwa-install.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,kBAAkB,CAAC,GAAqB;IACtD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IAEpB,MAAM,IAAI,GAAG;;;;;;yEAM0D,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0C3E,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,eAAe,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC7C,CAAC"}

package/dist/lib/generators/file-generators/reconcile.js

@@ -3,17 +3,18 @@
  */
 import { writeFile } from "./context.js";
 export function generateReconcile(ctx) {
+    const ext = ctx.ext;
     const code = `/**
  * Swoff ID Reconciliation
  * Update local records with server data after mutation sync.
  *
  * Usage:
- *   import { reconcileRecord } from './swoff/reconcile.js';
+ *   import { reconcileRecord } from './swoff/reconcile.${ext}';
  *
  *   await reconcileRecord('todos', 'temp_abc123', serverData);
  */
 
-import { getRecord, putRecord, deleteRecord } from './store.js';
+import { getRecord, putRecord, deleteRecord } from './store.${ext}';
 
 export async function reconcileRecord(storeName, tempId, serverData) {
   const existing = await getRecord(storeName, tempId);
@@ -49,6 +50,6 @@ export async function reconcileReferences(storeName, oldId, newId) {
   // }
 }
 `;
-    writeFile(ctx, "reconcile.js", code);
+    writeFile(ctx, `reconcile.${ext}`, code);
 }
 //# sourceMappingURL=reconcile.js.map

package/dist/lib/generators/file-generators/reconcile.js.map

@@ -1 +1 @@
-{"version":3,"file":"reconcile.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/reconcile.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Cd,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC"}
+{"version":3,"file":"reconcile.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/reconcile.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,IAAI,GAAG;;;;;0DAK2C,GAAG;;;;;8DAKC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmChE,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC"}

package/dist/lib/generators/file-generators/store.js

@@ -3,13 +3,14 @@
  */
 import { writeFile } from "./context.js";
 export function generateStore(ctx) {
+    const ext = ctx.ext;
     const dbName = ctx.config.features.indexeddb?.name || "app-db";
     const code = `/**
  * Swoff IndexedDB Store
  * Generic CRUD operations for app's IndexedDB database.
  *
  * Usage:
- *   import { getRecord, putRecord, deleteRecord, openAppDB } from './swoff/store.js';
+ *   import { getRecord, putRecord, deleteRecord, openAppDB } from './swoff/store.${ext}';
  *
  *   const record = await getRecord('todos', 'todo-123');
  *   await putRecord('todos', { id: 'todo-123', title: 'New task', $synced: false });
@@ -70,6 +71,6 @@ export async function getAllRecords(storeName) {
   });
 }
 `;
-    writeFile(ctx, "store.js", code);
+    writeFile(ctx, `store.${ext}`, code);
 }
 //# sourceMappingURL=store.js.map

package/dist/lib/generators/file-generators/store.js.map

@@ -1 +1 @@
-{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/store.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,aAAa,CAAC,GAAqB;IACjD,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,IAAI,QAAQ,CAAC;IAE/D,MAAM,IAAI,GAAG;;;;;;;;;;;;mBAYI,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDxB,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;AACnC,CAAC"}
+{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../src/lib/generators/file-generators/store.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAoB,SAAS,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,UAAU,aAAa,CAAC,GAAqB;IACjD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IACpB,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,IAAI,QAAQ,CAAC;IAE/D,MAAM,IAAI,GAAG;;;;;oFAKqE,GAAG;;;;;;;mBAOpE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDxB,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC"}

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

@@ -1,14 +1,17 @@
 /**
- * Generates sw-injector.{js|ts} - client-side SW registration with version checking.
+ * Generates sw-injector.{js|ts} - client-side SW registration + PWA + cross-tab sync.
  */
 import { writeFile } from "./context.js";
 export function generateSwInjector(ctx) {
     const autoRegister = ctx.config.serviceWorker.autoRegister;
     const autoActivate = ctx.config.serviceWorker.autoActivate;
+    const pwaEnabled = ctx.config.features.pwa.enabled;
+    const preventDefaultInstall = ctx.config.features.pwa.preventDefaultInstall;
+    const crossTabSync = ctx.config.features.crossTabSync;
     const ext = ctx.ext;
     const code = `/**
- * Swoff Service Worker Injector
- * Framework-agnostic client registration with version checking.
+ * Swoff SW Injector
+ * Framework-agnostic SW registration, PWA install support, and cross-tab sync.
  *
  * Usage:
  *   import { initServiceWorker } from './swoff/sw-injector.${ext}';
@@ -16,15 +19,15 @@ export function generateSwInjector(ctx) {
  *   // 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
+ *   pwa-installable      - PWA can be installed (detail: { isInstallable: true })
+ *   pwa-installed        - User accepted install (detail: { outcome: 'accepted' })
+ *   cache-invalidated    - Cache entries with given tags cleared (detail: { tags })
  *
  * Window properties:
  *   window.latestSWVersion       - Latest version from version.json
@@ -34,11 +37,15 @@ export function generateSwInjector(ctx) {
  *   window.swMinSupportedVersion - Minimum supported version from version.json
  *   window.swReady               - SW is active
  *   window.swError               - Registration failed
+ *   window.deferredInstallPrompt - Captured BeforeInstallPromptEvent
+ *   window.pwaInstallable        - Whether PWA can be installed
  */
 
 const AUTO_REGISTER = ${autoRegister};
 const AUTO_ACTIVATE = ${autoActivate};
 
+// --- SW Registration ---
+
 async function checkForUpdate() {
   const response = await fetch("/version.json");
   if (!response.ok) {
@@ -47,6 +54,16 @@ async function checkForUpdate() {
   return response.json();
 }
 
+async function waitForController() {
+  return new Promise((resolve) => {
+    if (navigator.serviceWorker.controller) {
+      resolve();
+    } else {
+      navigator.serviceWorker.addEventListener("controllerchange", resolve, { once: true });
+    }
+  });
+}
+
 async function doRegisterServiceWorker(version) {
   const swUrl = \`/sw-v\${version}.js\`;
   const registration = await navigator.serviceWorker.register(swUrl);
@@ -54,16 +71,12 @@ async function doRegisterServiceWorker(version) {
   window.currentSWVersion = version;
   window.swRegisteredVersion = version;
   window.dispatchEvent(new CustomEvent("sw-version-detected"));
+  await waitForController();
   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;
 }
 
@@ -86,7 +99,10 @@ export async function initServiceWorker() {
       if (registration && registration.active) {
         window.currentSWVersion = currentVersion;
         window.dispatchEvent(new CustomEvent("sw-version-detected"));
-        window.dispatchEvent(new CustomEvent("sw-ready"));
+        await waitForController();
+        if (!window.swReady) {
+          window.dispatchEvent(new CustomEvent("sw-ready"));
+        }
       }
     } else if (currentVersion && currentVersion !== manifest.version) {
       window.swAvailableVersion = manifest.version;
@@ -128,18 +144,18 @@ export async function initServiceWorker() {
       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"));
+        await waitForController();
+        if (!window.swReady) {
+          window.dispatchEvent(new CustomEvent("sw-ready"));
+        }
         return;
       }
-    } catch {
-      // Registration check also failed, nothing we can do
-    }
+    } catch {}
 
     console.error("Service Worker initialization failed:", error);
     window.swError = true;
@@ -169,6 +185,35 @@ export async function skipWaiting() {
   }
 }
 
+// --- PWA Install Support ---
+${pwaEnabled ? `
+window.addEventListener("beforeinstallprompt", (e) => {
+  window.deferredInstallPrompt = e;
+  window.pwaInstallable = true;
+
+  if (${preventDefaultInstall}) {
+    e.preventDefault();
+  }
+
+  window.dispatchEvent(
+    new CustomEvent("pwa-installable", {
+      detail: { isInstallable: true },
+    })
+  );
+});
+
+window.addEventListener("appinstalled", () => {
+  window.deferredInstallPrompt = null;
+  window.pwaInstallable = false;
+
+  window.dispatchEvent(
+    new CustomEvent("pwa-installed", {
+      detail: { outcome: "accepted" },
+    })
+  );
+});
+` : ""}
+// --- SW Message Listener ---
 if (typeof window !== "undefined" && "serviceWorker" in navigator) {
   navigator.serviceWorker.addEventListener("message", (event) => {
     if (event.data.type === "SW_PROGRESS") {
@@ -193,7 +238,15 @@ if (typeof window !== "undefined" && "serviceWorker" in navigator) {
       }
       window.dispatchEvent(new CustomEvent("mutation-queue-changed"));
     }
-  });
+${crossTabSync ? `
+    if (event.data.type === "TAG_INVALIDATED" && event.data.tag) {
+      window.dispatchEvent(
+        new CustomEvent("cache-invalidated", {
+          detail: { tags: [event.data.tag] },
+        })
+      );
+    }
+` : ""}  });
 }
 `;
     writeFile(ctx, `sw-injector.${ext}`, code);

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

@@ -1 +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"}
+{"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,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC;IACnD,MAAM,qBAAqB,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,qBAAqB,CAAC;IAC5E,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC;IACtD,MAAM,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC;IAEpB,MAAM,IAAI,GAAG;;;;;8DAK+C,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2BzC,YAAY;wBACZ,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgJlC,UAAU,CAAC,CAAC,CAAC;;;;;QAKP,qBAAqB;;;;;;;;;;;;;;;;;;;;;CAqB5B,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BJ,YAAY,CAAC,CAAC,CAAC;;;;;;;;CAQhB,CAAC,CAAC,CAAC,EAAE;;CAEL,CAAC;IAEA,SAAS,CAAC,GAAG,EAAE,eAAe,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;AAC7C,CAAC"}

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

@@ -1,139 +1,16 @@
 /**
- * Generates sw-template.js - the SW template with placeholders.
+ * Generates sw-template.js - the SW template with config features baked in.
+ * Placeholders are replaced during build by sw-generator.js.
  */
 import { writeFile } from "./context.js";
+import { assembleSW } from "../sw-sections/assemble-sw.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 cached = await runtimeCache.match(event.request);
-      if (cached) return cached;
-
-      if (event.request.mode === "navigate") {
-        const spa = await cache.match("/index.html");
-        if (spa) return spa;
-      }
-
-      const response = await fetch(event.request);
-      if (response.ok) {
-        await runtimeCache.put(event.request, response.clone());
-      }
-      return response;
-    })(),
-  );
-});
-
-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;
-}
-`;
+    const placeholderVersion = "0.0.0";
+    const full = assembleSW(ctx.config, placeholderVersion);
+    let code = full;
+    code = code.replace(`CACHE_NAME = 'sw-v${placeholderVersion}'`, "// [[CACHE_NAME]]");
+    code = code.replace(/^ASSETS_TO_CACHE = \[[\s\S]*?\]$/m, "// [[ASSETS_LIST]]");
+    code = code.replace(/^const AUTO_SKIP_WAITING = (true|false);?$/m, "// [[AUTO_SKIP_WAITING]]");
     writeFile(ctx, "sw-template.js", code);
 }
 //# sourceMappingURL=sw-template.js.map