@swoff/cli 0.3.8 → 0.3.10

package/dist/runtime/auth-store.js

@@ -0,0 +1,273 @@
+import { T, R, PT, AS } from "./utils.js";
+function generateWithAuthHeaders(authType, ts) {
+    const hd = T(ts, "Headers");
+    const a = T(ts, "AuthData | null");
+    switch (authType) {
+        case "cookie":
+            return `/** Inject auth headers. For cookie auth, credentials are handled via AUTH_WITH_CREDENTIALS. */
+export function withAuthHeaders(headers${hd}, _auth${a})${hd}{
+  return headers;
+}`;
+        case "bearer":
+            return `/** Inject Bearer token into request headers. */
+export function withAuthHeaders(headers${hd}, auth${a})${hd}{
+  if (auth?.token) {
+    headers.set("Authorization", \`Bearer \${auth.token}\`);
+  }
+  return headers;
+}`;
+        case "custom":
+            return `/** Inject custom auth headers. Edit this function to match your backend. */
+export function withAuthHeaders(headers${hd}, auth${a})${hd}{
+  // --- EDIT THIS BLOCK FOR YOUR BACKEND ---
+  // if (auth?.token) {
+  //   headers.set("X-Auth-Token", auth.token);
+  // }
+  // --- END OF EDITABLE BLOCK ---
+  return headers;
+}`;
+        default:
+            return `export function withAuthHeaders(headers${hd}, auth${a})${hd}{
+  if (auth?.token) {
+    headers.set("Authorization", \`Bearer \${auth.token}\`);
+  }
+  return headers;
+}`;
+    }
+}
+function generateIsAuthUrl(refreshPath, userEndpoint, ts) {
+    return `/** Check if a URL is an auth endpoint that should bypass the SW cache. */
+export function isAuthUrl(url${T(ts, "string")})${R(ts, "boolean")}{
+  const authPaths = [
+    "/login",
+    "/logout",
+    "/register",
+    "/api/login",
+    "/api/logout",
+    "/api/register",
+    "${refreshPath}",
+    "${userEndpoint}",
+  ];
+  return authPaths.some((path) => url.includes(path));
+}`;
+}
+function generateEnsureValidAuth(cookieAuth, ts, refreshPath, ext) {
+    const tokenArg = cookieAuth ? "" : "auth?.token";
+    return `/** Try to restore the session after page refresh — delegates to refreshSession() in ./user.${ext}. */
+let restorePromise${T(ts, "Promise<AuthData | null> | null")} = null;
+
+async function tryRestoreSession()${R(ts, "Promise<AuthData | null>")}{
+  if (restorePromise) {
+    try { return await restorePromise; } finally { restorePromise = null; }
+  }
+  restorePromise = (async () => {
+    try {
+      const response = await refreshSession();
+      if (!response.ok) return null;
+      const data = await response.json();
+      const userData = await loadUserData();
+      const auth = { ...userData, token: data.token, expiresAt: data.expiresAt };
+      await setAuth(auth);
+      return auth;
+    } catch { return null; }
+  })();
+  try { return await restorePromise; } finally { restorePromise = null; }
+}
+
+let refreshPromise${T(ts, "Promise<AuthData | null> | null")} = null;
+
+export async function ensureValidAuth()${R(ts, "Promise<AuthData | null>")}{
+  const auth = await getAuth();
+  if (!auth) return null;
+
+  // Token missing after page refresh — try silent session restoration
+  if (!auth.token) {
+    return tryRestoreSession();
+  }
+
+  if (!auth.expiresAt || Date.now() < auth.expiresAt) return auth;
+
+  if (!refreshPromise) {
+    refreshPromise = (async () => {
+      try {
+          const response = await refreshSession(${tokenArg});
+        if (!response.ok) {
+          await clearAuth();
+          window.dispatchEvent(new CustomEvent("sw-auth-unauthorized"));
+          return null;
+        }
+
+        const data = await response.json();
+        const updated = { ...auth, token: data.token, expiresAt: data.expiresAt };
+        await setAuth(updated);
+        return updated;
+      } catch {
+        await clearAuth();
+        window.dispatchEvent(new CustomEvent("sw-auth-unauthorized"));
+        return null;
+      }
+    })();
+  }
+
+  try {
+    return await refreshPromise;
+  } finally {
+    refreshPromise = null;
+  }
+}`;
+}
+export function generateAuthStoreCode(ctx, authType, refreshPath, userEndpoint) {
+    const { ext, ts } = ctx;
+    const authDataInterface = ts
+        ? `export interface AuthData {
+  token?: string;
+  user?: Record<string, unknown>;
+  expiresAt?: number;
+}
+
+export interface AuthResponse extends Record<string, unknown> {
+  // Uncomment and type the fields your backend's login response returns:
+  // token: string;
+  // user: Record<string, unknown>;
+  // expiresAt?: number;
+}
+
+`
+        : "";
+    const createAuthFromResponseBlock = ts
+        ? `/** Extract AuthData from your backend's login response. Edit this function to match your backend's response shape. */
+export function createAuthFromResponse(response: AuthResponse): AuthData {
+  // --- EDIT THIS TO MATCH YOUR BACKEND ---
+  const data = response as Record<string, unknown>;
+  return {
+    token: data.token as string,
+    user: data.user as Record<string, unknown> | undefined,
+    expiresAt: data.expiresAt as number | undefined,
+  };
+  // --- END OF EDITABLE BLOCK ---
+}
+`
+        : `/** Extract AuthData from your backend's login response. Edit this function to match your backend's response shape. */
+export function createAuthFromResponse(response) {
+  // --- EDIT THIS TO MATCH YOUR BACKEND ---
+  return {
+    token: response.token,
+    user: response.user,
+    expiresAt: response.expiresAt,
+  };
+  // --- END OF EDITABLE BLOCK ---
+}
+`;
+    return `/**
+ * Auth Store — Token in memory only; user info in IndexedDB for offline access.
+ *
+ * Security:
+ *   The Bearer token lives in JavaScript memory and is cleared on page refresh.
+ *   Only { user, expiresAt } is persisted to IndexedDB so the app can display
+ *   user info offline. After a page refresh, re-login is required.
+ *
+ * Usage:
+ *   import { setAuth, getAuth, clearAuth, isAuthValid } from "./auth/store.${ext}";
+ *
+ *   await setAuth({ token, user, expiresAt });
+ *   const auth = await getAuth();
+ *   await clearAuth();
+ */
+
+import { refreshSession } from "./user.${ext}";
+
+${authDataInterface}const DB_NAME = "swoff-auth";
+const STORE_NAME = "auth";
+// Bump this when adding new indexes/stores for schema migration
+const DB_VERSION = 1;
+
+let memoryAuth${T(ts, "AuthData | null")} = null;
+
+${createAuthFromResponseBlock}
+function openAuthDB()${R(ts, "Promise<IDBDatabase>")}{
+  return new Promise${PT(ts, "IDBDatabase")}((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onupgradeneeded = (e) => {
+      const db = (e.target${AS(ts, "IDBOpenDBRequest")}).result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: "key" });
+      }
+    };
+    request.onsuccess = (e) => resolve((e.target${AS(ts, "IDBOpenDBRequest")}).result);
+    request.onerror = (e) => reject((e.target${AS(ts, "IDBRequest")}).error);
+  });
+}
+
+async function persistUserData(authData${T(ts, "AuthData | null")})${R(ts, "Promise<void>")}{
+  // Only persist { user, expiresAt } — never the token
+  const userData = { user: authData?.user, expiresAt: authData?.expiresAt };
+  const db = await openAuthDB();
+  return new Promise${PT(ts, "void")}((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    const request = store.put({ key: "session", value: userData });
+    request.onsuccess = () => resolve();
+    request.onerror = () => reject((request${AS(ts, "IDBRequest")}).error);
+  });
+}
+
+async function loadUserData()${R(ts, "Promise<{ user?: Record<string, unknown>; expiresAt?: number } | null>")}{
+  const db = await openAuthDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    const request = store.get("session");
+    request.onsuccess = () => resolve((request${AS(ts, "IDBRequest")}).result?.value ?? null);
+    request.onerror = () => reject((request${AS(ts, "IDBRequest")}).error);
+  });
+}
+
+async function clearPersistedData()${R(ts, "Promise<void>")}{
+  const db = await openAuthDB();
+  return new Promise${PT(ts, "void")}((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    const request = store.delete("session");
+    request.onsuccess = () => resolve();
+    request.onerror = () => reject((request${AS(ts, "IDBRequest")}).error);
+  });
+}
+
+/** Store auth data in memory and persist user info to IndexedDB for offline access. */
+export async function setAuth(authData${T(ts, "AuthData")})${R(ts, "Promise<void>")}{
+  memoryAuth = authData;
+  await persistUserData(authData);
+}
+
+/** Get auth data from memory (or IndexedDB if memory is empty after page refresh). */
+export async function getAuth()${R(ts, "Promise<AuthData | null>")}{
+  if (memoryAuth) return memoryAuth;
+
+  const userData = await loadUserData();
+  if (userData) {
+    memoryAuth = userData;
+  }
+  return memoryAuth;
+}
+
+/** Clear auth from memory and IndexedDB. Call on logout or 401. */
+export async function clearAuth()${R(ts, "Promise<void>")}{
+  memoryAuth = null;
+  await clearPersistedData();
+}
+
+/** Check if auth exists and has not expired. Returns true if no expiresAt is set. */
+export function isAuthValid(auth${T(ts, "AuthData | null")})${R(ts, "boolean")}{
+  if (!auth) return false;
+  if (!auth.expiresAt) return true;
+  return Date.now() < auth.expiresAt;
+}
+
+${authType === "cookie" ? `export const AUTH_WITH_CREDENTIALS = true;` : `export const AUTH_WITH_CREDENTIALS = false;`}
+
+${generateWithAuthHeaders(authType, ts)}
+${generateIsAuthUrl(refreshPath, userEndpoint, ts)}
+${generateEnsureValidAuth(authType === "cookie", ts, refreshPath, ext)}
+`;
+}
+//# sourceMappingURL=auth-store.js.map

package/dist/runtime/auth-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-store.js","sourceRoot":"","sources":["../../src/runtime/auth-store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAE1C,SAAS,uBAAuB,CAC9B,QAAgB,EAChB,EAAW;IAEX,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;IAC5B,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,iBAAiB,CAAC,CAAC;IACnC,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,QAAQ;YACX,OAAO;yCAC4B,EAAE,UAAU,CAAC,IAAI,EAAE;;EAE1D,CAAC;QACC,KAAK,QAAQ;YACX,OAAO;yCAC4B,EAAE,SAAS,CAAC,IAAI,EAAE;;;;;EAKzD,CAAC;QACC,KAAK,QAAQ;YACX,OAAO;yCAC4B,EAAE,SAAS,CAAC,IAAI,EAAE;;;;;;;EAOzD,CAAC;QACC;YACE,OAAO,0CAA0C,EAAE,SAAS,CAAC,IAAI,EAAE;;;;;EAKvE,CAAC;IACD,CAAC;AACH,CAAC;AAED,SAAS,iBAAiB,CACxB,WAAmB,EACnB,YAAoB,EACpB,EAAW;IAEX,OAAO;+BACsB,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;;;;;;;OAQ3D,WAAW;OACX,YAAY;;;EAGjB,CAAC;AACH,CAAC;AAED,SAAS,uBAAuB,CAC9B,UAAmB,EACnB,EAAW,EACX,WAAmB,EACnB,GAAW;IAEX,MAAM,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;IACjD,OAAO,+FAA+F,GAAG;oBACvF,CAAC,CAAC,EAAE,EAAE,iCAAiC,CAAC;;oCAExB,CAAC,CAAC,EAAE,EAAE,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;oBAkBjD,CAAC,CAAC,EAAE,EAAE,iCAAiC,CAAC;;yCAEnB,CAAC,CAAC,EAAE,EAAE,0BAA0B,CAAC;;;;;;;;;;;;;;kDAcxB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;EAwBxD,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB,CACnC,GAAmB,EACnB,QAAgB,EAChB,WAAmB,EACnB,YAAoB;IAEpB,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IAExB,MAAM,iBAAiB,GAAG,EAAE;QAC1B,CAAC,CAAC;;;;;;;;;;;;;CAaL;QACG,CAAC,CAAC,EAAE,CAAC;IAEP,MAAM,2BAA2B,GAAG,EAAE;QACpC,CAAC,CAAC;;;;;;;;;;;CAWL;QACG,CAAC,CAAC;;;;;;;;;;CAUL,CAAC;IAEA,OAAO;;;;;;;;;8EASqE,GAAG;;;;;;;yCAOxC,GAAG;;EAE1C,iBAAiB;;;;;gBAKH,CAAC,CAAC,EAAE,EAAE,iBAAiB,CAAC;;EAEtC,2BAA2B;uBACN,CAAC,CAAC,EAAE,EAAE,sBAAsB,CAAC;sBAC9B,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC;;;4BAGf,EAAE,CAAC,EAAE,EAAE,kBAAkB,CAAC;;;;;kDAKJ,EAAE,CAAC,EAAE,EAAE,kBAAkB,CAAC;+CAC7B,EAAE,CAAC,EAAE,EAAE,YAAY,CAAC;;;;yCAI1B,CAAC,CAAC,EAAE,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;sBAIrE,EAAE,CAAC,EAAE,EAAE,MAAM,CAAC;;;;;6CAKS,EAAE,CAAC,EAAE,EAAE,YAAY,CAAC;;;;+BAIlC,CAAC,CAAC,EAAE,EAAE,wEAAwE,CAAC;;;;;;gDAM9D,EAAE,CAAC,EAAE,EAAE,YAAY,CAAC;6CACvB,EAAE,CAAC,EAAE,EAAE,YAAY,CAAC;;;;qCAI5B,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;sBAErC,EAAE,CAAC,EAAE,EAAE,MAAM,CAAC;;;;;6CAKS,EAAE,CAAC,EAAE,EAAE,YAAY,CAAC;;;;;wCAKzB,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;iCAMlD,CAAC,CAAC,EAAE,EAAE,0BAA0B,CAAC;;;;;;;;;;;mCAW/B,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;kCAMvB,CAAC,CAAC,EAAE,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;;;;;EAM5E,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,4CAA4C,CAAC,CAAC,CAAC,6CAA6C;;EAEpH,uBAAuB,CAAC,QAAQ,EAAE,EAAE,CAAC;EACrC,iBAAiB,CAAC,WAAW,EAAE,YAAY,EAAE,EAAE,CAAC;EAChD,uBAAuB,CAAC,QAAQ,KAAK,QAAQ,EAAE,EAAE,EAAE,WAAW,EAAE,GAAG,CAAC;CACrE,CAAC;AACF,CAAC"}

package/dist/runtime/auth-user.js

@@ -0,0 +1,168 @@
+import { T, R, PT, AS } from "./utils.js";
+export function generateAuthUserCode(ctx, refreshPath, userEndpoint, authType) {
+    const { ext, ts } = ctx;
+    const cookieAuth = authType === "cookie";
+    const authTypeName = cookieAuth ? "cookie" : "bearer";
+    const refreshDocs = cookieAuth
+        ? ` *
+ * Cookie auth: credentials ("include") are automatically sent with the request.
+ *   The browser attaches the session cookie — no token management needed.
+ *   Change method, URL, headers, or body below if your server expects something different.
+ *   Example: if your refresh endpoint expects a specific content-type, add:
+ *     headers: { "Content-Type": "application/x-www-form-urlencoded" },
+ *   Example: if your endpoint uses PUT instead of POST:
+ *     method: "PUT",`
+        : ` *
+ * Bearer auth: the optional \`token\` parameter is passed by auth/store.ts when the user
+ *   has an existing session. The generated template adds "Authorization: Bearer <token>".
+ *   If your refresh endpoint doesn't need the token (e.g., uses a refresh token cookie),
+ *   simply remove the \`token\` parameter and the header logic below.
+ *   To send a refresh token in the body instead:
+ *     body: JSON.stringify({ refreshToken: "..." }),
+ *   To change the content type:
+ *     headers: { "Content-Type": "application/x-www-form-urlencoded" },`;
+    const userDocs = cookieAuth
+        ? ` *
+ * Cookie auth: credentials ("include") sends the session cookie automatically.
+ *   Edit the URL, method, or headers below if your user endpoint differs.
+ *   Example: if your server uses /api/v1/me with a different method:
+ *     const response = await fetch(API_BASE + "/api/v1/me", {
+ *       method: "GET",
+ *       credentials: "include",
+ *     });`
+        : ` *
+ * Bearer auth: add the Authorization header using the user's token.
+ *   Get the token from auth/store.ts:
+ *     import { getAuth } from "./store.${ext}";
+ *     const auth = await getAuth();
+ *     const response = await fetch(API_BASE + "${userEndpoint}", {
+ *       headers: { "Authorization": \`Bearer \${auth?.token}\` },
+ *     });
+ *   If your endpoint uses a different method or body, edit accordingly below.`;
+    return `/**
+ * Auth User — refresh session and fetch current user.
+ *
+ * This file is YOUR control panel for auth HTTP calls. swoff generates sensible
+ * defaults based on your swoff.config.json auth type (cookie/bearer), then you
+ * edit the functions below to match your server exactly.
+ *
+ * Both functions are imported by swoff's auth store (auth/store.${ext}) so your
+ * edits flow through to session refresh, 401 retry, and user caching.
+ *
+ * Usage:
+ *   import { refreshSession, fetchCurrentUser, cacheUser, getCachedUser, clearCachedUser } from "./auth/user.${ext}";
+ *
+ *   // Refresh the session (called automatically by the auth store)
+ *   const response = await refreshSession();
+ *   const data = await response.json();
+ *
+ *   // Fetch and cache the current user
+ *   const user = await fetchCurrentUser();
+ *
+ *   // Get cached user (offline-capable)
+ *   const cached = await getCachedUser();
+ *
+ *   // Clear on logout
+ *   await clearCachedUser();
+ */
+
+import { API_BASE } from "../config.${ext}";
+
+const DB_NAME = "swoff-auth-user";
+const STORE_NAME = "current-user";
+// Bump this when adding new indexes/stores for schema migration
+const DB_VERSION = 1;
+
+function openAuthDB()${R(ts, "Promise<IDBDatabase>")}{
+  return new Promise${PT(ts, "IDBDatabase")}((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onupgradeneeded = (e) => {
+      const db = (e.target${AS(ts, "IDBOpenDBRequest")}).result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: "key" });
+      }
+    };
+    request.onsuccess = (e) => resolve((e.target${AS(ts, "IDBOpenDBRequest")}).result);
+    request.onerror = (e) => reject((e.target${AS(ts, "IDBRequest")}).error);
+  });
+}
+
+/**
+ * Refresh the auth session.
+ *
+ * Called automatically by auth/store.{{ext}} when the access token expires
+ * (ensureValidAuth) or to restore a session after page reload (tryRestoreSession).
+ *
+ * ${authTypeName} defaults:${refreshDocs}
+ *
+ * ${cookieAuth ? "" : "@param token - Bearer token from the existing session (only passed for bearer auth)."}
+ * @returns A fetch Response. The auth store reads response.json() to extract
+ *          { token, expiresAt } and merges them with cached user data.
+ */
+export async function refreshSession(${cookieAuth ? "" : "token" + T(ts, "string")})${R(ts, "Promise<Response>")}{
+  ${cookieAuth
+        ? `return fetch(API_BASE + "${refreshPath}", {
+    method: "POST",
+    credentials: "include" as RequestCredentials,
+  });`
+        : `const headers${T(ts, "Record<string, string>")} = { "Content-Type": "application/json" };
+  if (token) headers["Authorization"] = \`Bearer \${token}\`;
+  return fetch(API_BASE + "${refreshPath}", {
+    method: "POST",
+    headers,
+  });`}
+}
+
+/**${userDocs}
+ */
+export async function fetchCurrentUser()${R(ts, "Promise<Record<string, unknown>>")}{
+  ${cookieAuth
+        ? `const response = await fetch(API_BASE + "${userEndpoint}", {
+    credentials: "include" as RequestCredentials,
+  });`
+        : `const response = await fetch(API_BASE + "${userEndpoint}");`}
+  if (!response.ok) throw new Error("Failed to fetch user");
+
+  const user = await response.json();
+  await cacheUser(user);
+  return user;
+}
+
+/** Persist user data to IndexedDB for offline access. */
+export async function cacheUser(user${T(ts, "Record<string, unknown>")})${R(ts, "Promise<void>")}{
+  const db = await openAuthDB();
+  return new Promise<void>((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    store.put({ key: "user", value: user });
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+/** Load user data from IndexedDB cache (no token — only user object survives refresh). */
+export async function getCachedUser()${R(ts, "Promise<Record<string, unknown> | null>")}{
+  const db = await openAuthDB();
+  return new Promise${PT(ts, "Record<string, unknown> | null")}((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    const request = store.get("user");
+    request.onsuccess = () => resolve((request${AS(ts, "IDBRequest")}).result?.value ?? null);
+    request.onerror = () => reject((request${AS(ts, "IDBRequest")}).error);
+  });
+}
+
+/** Remove user data from IndexedDB cache. Call on logout. */
+export async function clearCachedUser()${R(ts, "Promise<void>")}{
+  const db = await openAuthDB();
+  return new Promise${PT(ts, "void")}((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    store.delete("user");
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject((tx${AS(ts, "IDBTransaction")}).error);
+  });
+}
+`;
+}
+//# sourceMappingURL=auth-user.js.map

package/dist/runtime/auth-user.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-user.js","sourceRoot":"","sources":["../../src/runtime/auth-user.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,UAAU,oBAAoB,CAClC,GAAmB,EACnB,WAAmB,EACnB,YAAoB,EACpB,QAAgB;IAEhB,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,MAAM,UAAU,GAAG,QAAQ,KAAK,QAAQ,CAAC;IACzC,MAAM,YAAY,GAAG,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC;IAEtD,MAAM,WAAW,GAAG,UAAU;QAC5B,CAAC,CAAC;;;;;;;sBAOgB;QAClB,CAAC,CAAC;;;;;;;;yEAQmE,CAAC;IAExE,MAAM,QAAQ,GAAG,UAAU;QACzB,CAAC,CAAC;;;;;;;WAOK;QACP,CAAC,CAAC;;;0CAGoC,GAAG;;kDAEK,YAAY;;;+EAGiB,CAAC;IAE9E,OAAO;;;;;;;mEAO0D,GAAG;;;;gHAI0C,GAAG;;;;;;;;;;;;;;;;sCAgB7E,GAAG;;;;;;;uBAOlB,CAAC,CAAC,EAAE,EAAE,sBAAsB,CAAC;sBAC9B,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC;;;4BAGf,EAAE,CAAC,EAAE,EAAE,kBAAkB,CAAC;;;;;kDAKJ,EAAE,CAAC,EAAE,EAAE,kBAAkB,CAAC;+CAC7B,EAAE,CAAC,EAAE,EAAE,YAAY,CAAC;;;;;;;;;;KAU9D,YAAY,aAAa,WAAW;;KAEpC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,sFAAsF;;;;uCAItE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,GAAC,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,mBAAmB,CAAC;IAC1G,UAAU;QACV,CAAC,CAAC,4BAA4B,WAAW;;;MAGvC;QACF,CAAC,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,wBAAwB,CAAC;;6BAExB,WAAW;;;MAGlC;;;KAGD,QAAQ;;0CAE6B,CAAC,CAAC,EAAE,EAAE,kCAAkC,CAAC;IAC/E,UAAU;QACV,CAAC,CAAC,4CAA4C,YAAY;;MAExD;QACF,CAAC,CAAC,4CAA4C,YAAY,KAAK;;;;;;;;;sCAS7B,CAAC,CAAC,EAAE,EAAE,yBAAyB,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;uCAYzD,CAAC,CAAC,EAAE,EAAE,yCAAyC,CAAC;;sBAEjE,EAAE,CAAC,EAAE,EAAE,gCAAgC,CAAC;;;;gDAId,EAAE,CAAC,EAAE,EAAE,YAAY,CAAC;6CACvB,EAAE,CAAC,EAAE,EAAE,YAAY,CAAC;;;;;yCAKxB,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;sBAEzC,EAAE,CAAC,EAAE,EAAE,MAAM,CAAC;;;;;mCAKD,EAAE,CAAC,EAAE,EAAE,gBAAgB,CAAC;;;CAG1D,CAAC;AACF,CAAC"}

package/dist/runtime/background-sync.js

@@ -0,0 +1,59 @@
+import { T, R } from "./utils.js";
+export function generateBackgroundSyncCode(ctx) {
+    const { ext, ts } = ctx;
+    return `/**
+ * Swoff Background Sync
+ * Register sync events for processing mutation queue after tab close.
+ * Falls back to online event listener in unsupported browsers.
+ *
+ * Usage:
+ *   import { syncWhenPossible } from './swoff/background-sync.${ext}';
+ *
+ *   await syncWhenPossible({
+ *     method: "POST",
+ *     url: "/api/todos",
+ *     body: { title: "Grocery" },
+ *     tags: ["todos"],
+ *     tags: ["todos"],
+ *   });
+ */
+
+import { queueMutation, processMutationQueue, getPendingCount } from "./queue.${ext}";
+
+const SYNC_TAG = "sync-mutations";
+
+async function registerSync()${R(ts, "Promise<void>")}{
+  if (!("serviceWorker" in navigator) || !("SyncManager" in window)) {
+    window.addEventListener("online", processMutationQueue, { once: true });
+    return;
+  }
+
+  try {
+    const registration = await navigator.serviceWorker.ready;
+    await registration.sync.register(SYNC_TAG);
+  } catch {
+    window.addEventListener("online", processMutationQueue, { once: true });
+  }
+}
+
+/** Queue a mutation and register a background sync event so it runs even after tab close. */
+export async function syncWhenPossible(mutation${T(ts, "object")})${R(ts, "Promise<void>")}{
+  await queueMutation(mutation);
+  await registerSync();
+}
+
+/** Re-register a background sync if mutations are still pending. Called automatically after each sync cycle. */
+export async function retrySync()${R(ts, "Promise<void>")}{
+  if (!("serviceWorker" in navigator) || !("SyncManager" in window)) return;
+  const count = await getPendingCount();
+  if (count > 0) {
+    await registerSync();
+  }
+}
+
+if (typeof window !== "undefined") {
+  window.addEventListener("mutation-sync-complete", retrySync);
+}
+`;
+}
+//# sourceMappingURL=background-sync.js.map

package/dist/runtime/background-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"background-sync.js","sourceRoot":"","sources":["../../src/runtime/background-sync.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAElC,MAAM,UAAU,0BAA0B,CAAC,GAAmB;IAC5D,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IACxB,OAAO;;;;;;iEAMwD,GAAG;;;;;;;;;;;gFAWY,GAAG;;;;+BAIpD,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;;;;;iDAeJ,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;mCAMvD,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;;;;CAWxD,CAAC;AACF,CAAC"}

package/dist/runtime/cache.js

@@ -0,0 +1,30 @@
+import { T, R } from "./utils.js";
+export function generateCacheCode(ctx) {
+    const { ext, ts } = ctx;
+    return `/**
+ * Swoff Cache Invalidation
+ * Framework-agnostic cache tag invalidation.
+ *
+ * Usage:
+ *   import { invalidateByTag, invalidateByTags } from './swoff/cache.${ext}';
+ *
+ *   // After a mutation, invalidate related cache
+ *   await invalidateByTag("todos");
+ */
+
+/** 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;
+  navigator.serviceWorker.controller.postMessage({
+    type: "INVALIDATE_TAG",
+    tag,
+  });
+}
+
+/** Invalidate all cached responses matching any of the given tags. */
+export async function invalidateByTags(tags${T(ts, "string[]")})${R(ts, "Promise<void>")}{
+  await Promise.all(tags.map((tag) => invalidateByTag(tag)));
+}
+`;
+}
+//# sourceMappingURL=cache.js.map

package/dist/runtime/cache.js.map

@@ -0,0 +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"}