@swoff/cli 0.3.9 → 0.3.11

package/dist/runtime/server-push.js

@@ -0,0 +1,148 @@
+import { T, R } from "./utils.js";
+export function generateServerPushCode(ctx, pushType, endpoint, reconnectDelayMs) {
+    const { ext, ts } = ctx;
+    const invalidate = `
+  // Forward to SW for cache invalidation
+  if (navigator.serviceWorker.controller) {
+    for (const tag of tags) {
+      navigator.serviceWorker.controller.postMessage({ type: "INVALIDATE_TAG", tag });
+    }
+  }`;
+    const sseConnect = `
+  return new Promise((resolve) => {
+    fetch(API_BASE + "${endpoint}", {
+      headers: { Accept: "text/event-stream" },
+      credentials: "include",
+      signal: options.signal,
+    }).then(async (response) => {
+      if (!response.ok || !response.body) { resolve(); return; }
+      notifyStatus(true);
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let eventType = "";
+      let dataStr = "";
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.startsWith("event: ")) eventType = line.slice(7).trim();
+          else if (line.startsWith("data: ")) dataStr = line.slice(6);
+          else if (line === "" && eventType === "invalidate" && dataStr) {
+            try {
+              const p = JSON.parse(dataStr); if (p.tags) handleInvalidation(p.tags);
+            } catch {
+              // Handle invalidation data
+            }
+            eventType = ""; dataStr = "";
+          }
+        }
+      }
+    }).catch(() => {}).finally(() => {
+      notifyStatus(false);
+      resolve();
+    });
+  });`;
+    const wsConnect = `
+  return new Promise((resolve) => {
+    try {
+      const ws = new WebSocket(API_BASE + "${endpoint}");
+      ws.onopen = () => notifyStatus(true);
+      ws.onmessage = (event) => {
+        try { const d = JSON.parse(event.data); if (d.type === "invalidate" && d.tags) handleInvalidation(d.tags); } catch {}
+      };
+      ws.onclose = () => { notifyStatus(false); resolve(); };
+      ws.onerror = () => { ws.close(); resolve(); };
+      if (options.signal) {
+        options.signal.addEventListener("abort", () => ws.close());
+      }
+    } catch { resolve(); }
+  });`;
+    return `/**
+ * Swoff Server Push Events
+ *
+ * The service worker connects to ${endpoint} and invalidates cache tags
+ * when the server sends "invalidate" events — no polling needed.
+ * This client-side helper provides status tracking and a manual start/stop API.
+ *
+ * Usage:
+ *   import { startPushEvents, stopPushEvents, isPushConnected } from "./realtime/server-push.${ext}";
+ *   startPushEvents();
+ *
+ * Server sends:
+ *   event: invalidate
+ *   data: {"tags": ["todos", "todo:42"]}
+ */
+
+import { API_BASE } from "../config.${ext}";
+
+type PushEventOptions= {
+  signal${T(ts, "AbortSignal")};
+};
+
+let active${T(ts, "boolean")} = false;
+let swConnected${T(ts, "boolean")} = false;
+let reconnectTimer${T(ts, "ReturnType<typeof setTimeout> | null")} = null;
+
+function handleInvalidation(tags${T(ts, "string[]")})${R(ts, "void")}{${invalidate}
+  window.dispatchEvent(new CustomEvent("cache-invalidated", { detail: { tags } }));
+}
+
+function notifyStatus(connected${T(ts, "boolean")})${R(ts, "void")}{
+  window.dispatchEvent(new CustomEvent("push-events-status", { detail: { connected } }));
+}
+
+// Listen for SSE status from the SW
+if (typeof navigator !== "undefined" && navigator.serviceWorker) {
+  navigator.serviceWorker.addEventListener("message", (event) => {
+    if (event.data?.type === "SSE_STATUS") {
+      swConnected = event.data.connected;
+      notifyStatus(swConnected);
+    }
+  });
+}
+
+async function connect(options${T(ts, "PushEventOptions")} = {} as PushEventOptions)${R(ts, "Promise<void>")}{
+  ${pushType === "sse" ? sseConnect : wsConnect}
+}
+
+/** Start listening for server push events. Only connects when the SW is not active — the SW is the primary connection manager. Retries on connection loss with exponential backoff. */
+export async function startPushEvents(){
+  if (active) return;
+
+  // If SW is already controlling the page, skip client-side connection — the SW handles push events.
+  if (navigator.serviceWorker.controller) return;
+
+  // Listen for SW activation — if SW takes over, disconnect the client fallback.
+  const onControllerChange = () => { stopPushEvents(); };
+  navigator.serviceWorker.addEventListener("controllerchange", onControllerChange);
+
+  active = true;
+  let delay = ${reconnectDelayMs};
+  while (active) {
+    await connect();
+    if (!active) break;
+    await new Promise((r) => { reconnectTimer = setTimeout(r, delay); });
+    delay = Math.min(delay * 1.5, 30000); // cap at 30s
+  }
+
+  navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange);
+}
+
+/** Stop listening for push events. */
+export function stopPushEvents(){
+  active = false;
+  if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
+}
+
+/** Check if the push connection is currently established. */
+export function isPushConnected(){
+  return active || swConnected;
+}
+`;
+}
+//# sourceMappingURL=server-push.js.map

package/dist/runtime/server-push.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-push.js","sourceRoot":"","sources":["../../src/runtime/server-push.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,sBAAsB,CACpC,GAAmB,EACnB,QAAgB,EAChB,QAAgB,EAChB,gBAAwB;IAExB,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IAExB,MAAM,UAAU,GAAG;;;;;;IAMjB,CAAC;IAEH,MAAM,UAAU,GAAG;;wBAEG,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoC1B,CAAC;IAEL,MAAM,SAAS,GAAG;;;6CAGyB,QAAQ;;;;;;;;;;;MAW/C,CAAC;IAEL,OAAO;;;oCAG2B,QAAQ;;;;;gGAKoD,GAAG;;;;;;;;sCAQ7D,GAAG;;;UAG/B,CAAC,CAAC,EAAE,EAAE,aAAa,CAAC;;;YAGlB,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;iBACX,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;oBACb,CAAC,CAAC,EAAE,EAAE,sCAAsC,CAAC;;kCAE/B,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,UAAU;;;;iCAIjD,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC;;;;;;;;;;;;;;gCAclC,CAAC,CAAC,EAAE,EAAE,kBAAkB,CAAC,6BAA6B,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;IACxG,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;;;;;;;;;;;;;;;gBAe/B,gBAAgB;;;;;;;;;;;;;;;;;;;;;CAqB/B,CAAC;AACF,CAAC"}

package/dist/runtime/sw-injector.js

@@ -0,0 +1,236 @@
+import { T, R } from "./utils.js";
+export function generateSwInjectorCode(ctx) {
+    const { ext, ts, autoUpdate, autoActivate, versionEnabled } = ctx;
+    if (!versionEnabled) {
+        return `/**
+ * Swoff SW Injector (Simple Mode)
+ * Fixed SW URL with hash-based cache name — no versioned URLs or update events.
+ *
+ * Usage:
+ *   import { initServiceWorker } from './swoff/sw/injector.${ext}';
+ *   initServiceWorker();
+ *
+ * Window events:
+ *   sw-ready  - SW active and controlling page
+ *   sw-error  - SW registration failed
+ *
+ * Window properties:
+ *   window.currentSWVersion  - "simple"
+ *   window.swReady           - SW is active
+ *   window.swError           - Registration failed
+ */
+async function waitForController()${R(ts, "Promise<void>")}{
+  return new Promise<void>((resolve) => {
+    if (navigator.serviceWorker.controller) {
+      resolve();
+    } else {
+      const timeout = setTimeout(() => resolve(), 30000);
+      navigator.serviceWorker.addEventListener("controllerchange", () => {
+        clearTimeout(timeout);
+        resolve();
+      }, { once: true });
+    }
+  });
+}
+
+/** Register the SW with a fixed URL (non-versioned mode). Dispatches sw-ready/sw-error. */
+export async function initServiceWorker()${R(ts, "Promise<void>")}{
+  if (!("serviceWorker" in navigator)) {
+    console.warn("Service Workers not supported");
+    return;
+  }
+  try {
+    const registration = await navigator.serviceWorker.register("/sw.js");
+    window.currentSWVersion = "simple";
+    window.dispatchEvent(new CustomEvent("sw-version-detected"));
+    await waitForController();
+    window.dispatchEvent(new CustomEvent("sw-ready"));
+  } catch (error) {
+    console.error("Service Worker registration failed:", error);
+    window.swError = true;
+    window.dispatchEvent(new CustomEvent("sw-error"));
+  }
+}
+`;
+    }
+    return `/**
+ * Swoff SW Injector
+ * Framework-agnostic SW registration with versioned URLs and update flow.
+ *
+ * Usage:
+ *   import { initServiceWorker } from './swoff/sw/injector.${ext}';
+ *   initServiceWorker();
+ *
+ * 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
+ *   window.swReady               - SW is active
+ *   window.swError               - Registration failed
+ */
+const AUTO_UPDATE = ${autoUpdate};
+const AUTO_ACTIVATE = ${autoActivate};
+
+function semverCompare(a${T(ts, "string")}, b${T(ts, "string")})${R(ts, "number")}{
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] > pb[i]) return 1;
+    if (pa[i] < pb[i]) return -1;
+  }
+  return 0;
+}
+
+async function checkForUpdate() {
+  const response = await fetch("/version.json?t=" + Date.now());
+  if (!response.ok) {
+    throw new Error("Failed to fetch version.json");
+  }
+  return response.json();
+}
+
+async function waitForController()${R(ts, "Promise<void>")}{
+  return new Promise<void>((resolve) => {
+    if (navigator.serviceWorker.controller) {
+      resolve();
+    } else {
+      const timeout = setTimeout(() => resolve(), 30000);
+      navigator.serviceWorker.addEventListener("controllerchange", () => {
+        clearTimeout(timeout);
+        resolve();
+      }, { once: true });
+    }
+  });
+}
+
+async function doRegisterServiceWorker(version${T(ts, "string")})${R(ts, "Promise<ServiceWorkerRegistration>")}{
+  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"));
+  await waitForController();
+  window.dispatchEvent(new CustomEvent("sw-ready"));
+  return registration;
+}
+
+/** Register the SW with version checking and update flow. Checks version.json, handles updates, and dispatches sw-ready/sw-error events. */
+export async function initServiceWorker()${R(ts, "Promise<void>")}{
+  if (!("serviceWorker" in navigator)) {
+    console.warn("Service Workers not supported");
+    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 ?? undefined;
+        window.dispatchEvent(new CustomEvent("sw-version-detected"));
+        await waitForController();
+        if (!window.swReady) {
+          window.dispatchEvent(new CustomEvent("sw-ready"));
+        }
+      }
+    } else if (currentVersion && currentVersion !== manifest.version) {
+      window.swAvailableVersion = manifest.version;
+      window.swUpdateRequired =
+        semverCompare(currentVersion, manifest.minSupportedVersion || "0.0.0") < 0;
+
+      if (AUTO_UPDATE) {
+        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) {
+    try {
+      const existing = await navigator.serviceWorker.getRegistration();
+      if (existing && existing.active) {
+        window.currentSWVersion = localStorage.getItem("swRegisteredVersion") || "unknown";
+        window.dispatchEvent(new CustomEvent("sw-version-detected"));
+        await waitForController();
+        if (!window.swReady) {
+          window.dispatchEvent(new CustomEvent("sw-ready"));
+        }
+        return;
+      }
+    } catch {
+      // Handle the case where no existing active registration is found
+    }
+
+    console.error("Service Worker initialization failed:", error);
+    window.swError = true;
+    window.dispatchEvent(new CustomEvent("sw-error"));
+  }
+}
+
+/** Accept a pending SW update. Reloads the page once the new SW takes control. */
+export async function handleUpdateApproved(newVersion${T(ts, "string")})${R(ts, "Promise<void>")}{
+  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();
+    });
+  }
+}
+
+/** Activate a waiting SW without reloading. Useful when you handle the transition yourself. */
+export async function skipWaiting()${R(ts, "Promise<void>")}{
+  const registration = await navigator.serviceWorker.ready;
+  if (registration.waiting) {
+    registration.waiting.postMessage({ type: "SKIP_WAITING" });
+  }
+}
+`;
+}
+//# sourceMappingURL=sw-injector.js.map

package/dist/runtime/sw-injector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sw-injector.js","sourceRoot":"","sources":["../../src/runtime/sw-injector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,sBAAsB,CACpC,GAA6F;IAE7F,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,cAAc,EAAE,GAAG,GAAG,CAAC;IAElE,IAAI,CAAC,cAAc,EAAE,CAAC;QACpB,OAAO;;;;;8DAKmD,GAAG;;;;;;;;;;;;oCAY7B,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;2CAef,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;;;CAiBhE,CAAC;IACA,CAAC;IAED,OAAO;;;;;8DAKqD,GAAG;;;;;;;;;;;;;;;;;;;sBAmB3C,UAAU;wBACR,YAAY;;0BAEV,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC;;;;;;;;;;;;;;;;;;oCAkB7C,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;gDAcV,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,oCAAoC,CAAC;;;;;;;;;;;;;2CAanE,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAoFV,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;;qCAgB3D,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;CAM1D,CAAC;AACF,CAAC"}

package/dist/runtime/type-definitions.js

@@ -0,0 +1,138 @@
+export function generateTypeDefinitionsCode() {
+    return `
+// Background Sync API types
+interface SyncManager {
+  register(tag: string): Promise<void>;
+  getTags(): Promise<string[]>;
+}
+
+interface SyncEvent extends Event {
+  readonly tag: string;
+  readonly lastChance: boolean;
+}
+
+interface ServiceWorkerGlobalScope {
+  onsync: ((this: ServiceWorkerGlobalScope, ev: SyncEvent) => unknown) | null;
+}
+
+declare global {
+  // Network Information API
+  interface NetworkInformation extends EventTarget {
+    readonly effectiveType: "slow-2g" | "2g" | "3g" | "4g";
+    readonly type: "bluetooth" | "cellular" | "ethernet" | "none" | "wifi" | "wimax" | "other" | "unknown";
+    readonly downlink: number;
+    readonly downlinkMax: number;
+    readonly rtt: number;
+    readonly saveData: boolean;
+    onchange: ((this: NetworkInformation, ev: Event) => unknown) | null;
+  }
+
+  interface Navigator {
+    readonly connection?: NetworkInformation;
+  }
+
+  interface BeforeInstallPromptEvent extends Event {
+    prompt(): Promise<void>;
+    userChoice: Promise<{ outcome: "accepted" | "dismissed" }>;
+  }
+
+  interface WindowEventMap {
+    beforeinstallprompt: BeforeInstallPromptEvent;
+    "sw-update-available": CustomEvent<{ version: string }>;
+    "sw-progress": CustomEvent<{ percent: number; downloaded: number; total: number }>;
+    "sw-ready": CustomEvent;
+    "sw-error": CustomEvent;
+    "sw-version-detected": CustomEvent;
+    "sw-auth-state-change": CustomEvent;
+    "mutation-sync-complete": CustomEvent<{ succeeded: number; failed: number }>;
+    "mutation-queue-changed": CustomEvent;
+    "cache-invalidated": CustomEvent<{ tags?: string[] }>;
+    "fetch-count-changed": CustomEvent<{ count: number }>;
+    "mutation-state-changed": CustomEvent<{ id: string; status: string; error?: Error; data?: unknown }>;
+    "background-sync-complete": CustomEvent<{ succeeded: number; failed: number }>;
+    "swoff:reset-start": CustomEvent;
+    "swoff:reset-complete": CustomEvent<{ unregistered: boolean; reregistered: boolean; warnings: string[] }>;
+    "push-subscription-changed": CustomEvent<{ subscribed: boolean }>;
+    "push-permission-changed": CustomEvent<{ permission: NotificationPermission }>;
+  }
+
+  interface Window {
+    deferredInstallPrompt: BeforeInstallPromptEvent | null;
+    pwaInstallable?: boolean;
+    latestSWVersion?: string;
+    currentSWVersion?: string;
+    swRegisteredVersion?: string;
+    swAvailableVersion?: string;
+    swUpdateRequired?: boolean;
+    swMinSupportedVersion?: string;
+    swReady?: boolean;
+    swError?: boolean;
+    swAuthState?: "authenticated" | "unauthenticated" | "loading";
+    swCurrentUser?: Record<string, unknown> | null;
+    SyncManager?: { new(): SyncManager };
+  }
+
+  // Extend ServiceWorkerRegistration in the global scope for TS
+  interface ServiceWorkerRegistration {
+    readonly sync: SyncManager;
+  }
+}
+
+export interface FetchWithCacheOptions extends RequestInit {
+  strategy?: "read" | "mutation";
+  tags?: string[];
+}
+
+export type MutationStatus = "idle" | "pending" | "success" | "error";
+
+export interface MutationState {
+  id: string;
+  status: MutationStatus;
+  error: Error | null;
+  data: unknown;
+  timestamp: number;
+}
+
+export interface ResetSwoffOptions {
+  clearCache?: boolean;
+  clearIdb?: boolean;
+  clearStorage?: boolean;
+  unregisterSW?: boolean;
+}
+
+export interface GqlOptions {
+  variables?: Record<string, unknown>;
+  tags?: string[];
+  auth?: boolean;
+  queueOffline?: boolean;
+  invalidate?: 'auto' | string[] | false;
+}
+
+export interface GqlResult<T> {
+  data: T;
+  fromCache: boolean;
+}
+
+export interface MutationQueueItem {
+  id: string;
+  method: string;
+  url: string;
+  body: unknown;
+  bodyType?: "json" | "formdata" | "blob" | "buffer" | "text";
+  headers: Record<string, string>;
+  timestamp: number;
+  retryCount: number;
+  nextRetryAt?: number;
+  tags: string[];
+}
+
+export interface MutationQueueResult {
+  succeeded: number;
+  failed: number;
+  total?: number;
+}
+
+export {};
+`;
+}
+//# sourceMappingURL=type-definitions.js.map

package/dist/runtime/type-definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-definitions.js","sourceRoot":"","sources":["../../src/runtime/type-definitions.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,2BAA2B;IACzC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsIR,CAAC;AACF,CAAC"}

package/dist/runtime/utils.js

@@ -0,0 +1,27 @@
+export function T(ts, type) {
+    return ts ? `: ${type}` : "";
+}
+export function R(ts, type) {
+    return ts ? `: ${type} ` : " ";
+}
+export function G(ts, type) {
+    return ts ? `<${type}>` : "";
+}
+/** Generic type parameter (alias for G) */
+export function PT(ts, type) {
+    return G(ts, type);
+}
+/** Type assertion */
+export function AS(ts, type) {
+    return ts ? ` as ${type}` : "";
+}
+export function genHelpers(ctx) {
+    return {
+        T: (type) => T(ctx.ts, type),
+        R: (type) => R(ctx.ts, type),
+        G: (type) => G(ctx.ts, type),
+        PT: (type) => PT(ctx.ts, type),
+        AS: (type) => AS(ctx.ts, type),
+    };
+}
+//# sourceMappingURL=utils.js.map

package/dist/runtime/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/runtime/utils.ts"],"names":[],"mappings":"AAKA,MAAM,UAAU,CAAC,CAAC,EAAW,EAAE,IAAY;IACzC,OAAO,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AAC/B,CAAC;AAED,MAAM,UAAU,CAAC,CAAC,EAAW,EAAE,IAAY;IACzC,OAAO,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,CAAC,CAAC,EAAW,EAAE,IAAY;IACzC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;AAC/B,CAAC;AAED,2CAA2C;AAC3C,MAAM,UAAU,EAAE,CAAC,EAAW,EAAE,IAAY;IAC1C,OAAO,CAAC,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;AACrB,CAAC;AAED,qBAAqB;AACrB,MAAM,UAAU,EAAE,CAAC,EAAW,EAAE,IAAY;IAC1C,OAAO,EAAE,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,GAAmB;IAC5C,OAAO;QACL,CAAC,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC;QACpC,CAAC,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC;QACpC,CAAC,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC;QACpC,EAAE,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC;QACtC,EAAE,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC;KACvC,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swoff/cli",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "type": "module",
   "description": "CLI for Swoff - Offline-first web apps made easy",
   "bin": {
@@ -19,7 +19,6 @@
   "files": [
     "bin/",
     "dist/",
-    "docs/",
     "templates/"
   ],
   "keywords": [
@@ -32,7 +31,9 @@
   "license": "MIT",
   "dependencies": {},
   "devDependencies": {
+    "@resvg/resvg-wasm": "^2.6.2",
     "@types/node": "^25.9.1",
+    "jimp": "^1.6.0",
     "typescript": "^5.0.0",
     "vitest": "^4.1.7"
   }