@swoff/cli 0.3.9 → 0.3.11

package/dist/runtime/gql-wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gql-wrapper.js","sourceRoot":"","sources":["../../src/runtime/gql-wrapper.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AAEzC,MAAM,UAAU,sBAAsB,CACpC,GAAmB,EACnB,QAAgB;IAEhB,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IAExB,MAAM,gBAAgB,GAAG,EAAE;QACzB,CAAC,CAAC;;;;;;;;CAQL;QACG,CAAC,CAAC,EAAE,CAAC;IAEP,OAAO;;;;;;;8EAOqE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDA4BjC,GAAG;;EAEjD,gBAAgB;;iCAEe,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;gCAM1C,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC;;;;;;;6BAOtC,CAAC,CAAC,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,iBAAiB,CAAC;;;;;;;;8BAQ3C,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;oCAUrC,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC;SACrC,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC;WACb,CAAC,CAAC,EAAE,EAAE,YAAY,CAAC;GAC3B,CAAC,CAAC,EAAE,EAAE,uBAAuB,CAAC;;;;;;;0DAOyB,QAAQ;;;;;;;;;;;;;;;;;;8BAkBpC,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC;;;;gCAIT,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC;SACjC,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC;aACX,CAAC,CAAC,EAAE,EAAE,qCAAqC,CAAC;WAC9C,CAAC,CAAC,EAAE,EAAE,YAAY,CAAC;GAC3B,CAAC,CAAC,EAAE,EAAE,uBAAuB,CAAC;uBACV,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC;;;;iCAIA,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC;YAC/B,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC;aACd,CAAC,CAAC,EAAE,EAAE,qCAAqC,CAAC;WAC9C,CAAC,CAAC,EAAE,EAAE,YAAY,CAAC;GAC3B,CAAC,CAAC,EAAE,EAAE,uBAAuB,CAAC;uBACV,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC;;CAEhC,CAAC;AACF,CAAC"}

package/dist/runtime/invalidation-tags.js

@@ -0,0 +1,260 @@
+import { T, R } from "./utils.js";
+function escapeRegex(str) {
+    return str.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+}
+function compilePatternEntry(rawPattern, tagTemplates) {
+    const rawParts = rawPattern.split("/");
+    const parts = rawParts.filter((p) => p !== "");
+    const paramNames = [];
+    const regexParts = [];
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part === "**") {
+            regexParts.push("(?:\\/[^/]+)*");
+            continue;
+        }
+        if (regexParts.length > 0) {
+            regexParts.push("\\/");
+        }
+        if (part === "*") {
+            regexParts.push("[^/]+");
+        }
+        else if (part.startsWith(":")) {
+            paramNames.push(part.slice(1));
+            regexParts.push("([^/]+)");
+        }
+        else if (part.includes("{")) {
+            const close = part.indexOf("}");
+            if (close !== -1) {
+                const inner = part.slice(part.indexOf("{") + 1, close);
+                const alternatives = inner.split(",").map((s) => escapeRegex(s.trim()));
+                regexParts.push("(?:" + alternatives.join("|") + ")");
+            }
+            else {
+                regexParts.push(escapeRegex(part));
+            }
+        }
+        else {
+            regexParts.push(escapeRegex(part));
+        }
+    }
+    if (regexParts.length === 0)
+        return null;
+    const hasLeadingSlash = rawPattern.startsWith("/");
+    const regex = (hasLeadingSlash ? "^\\/" : "^") + regexParts.join("") + "$";
+    // Validate template params match captured params
+    const templatePlaceholders = new Set();
+    for (const tmpl of tagTemplates) {
+        const matches = tmpl.match(/\{(\w+)\}/g);
+        if (matches) {
+            for (const m of matches) {
+                templatePlaceholders.add(m.slice(1, -1));
+            }
+        }
+    }
+    for (const ph of templatePlaceholders) {
+        if (!paramNames.includes(ph)) {
+            return null;
+        }
+    }
+    return { regex, params: paramNames, templates: tagTemplates };
+}
+function generatePatternCode(patterns) {
+    const entries = [];
+    for (const [pattern, templates] of Object.entries(patterns)) {
+        const compiled = compilePatternEntry(pattern, templates);
+        if (compiled) {
+            entries.push(`  { re: new RegExp("${compiled.regex.replace(/\\/g, "\\\\")}"), params: ${JSON.stringify(compiled.params)}, templates: ${JSON.stringify(compiled.templates)} }`);
+        }
+    }
+    return "[\n" + entries.join(",\n") + "\n]";
+}
+function generateSingularizationCode(singularization) {
+    if (!singularization || Object.keys(singularization).length === 0)
+        return "null";
+    return JSON.stringify(singularization);
+}
+function generateCascadingCode(cascading) {
+    if (!cascading || Object.keys(cascading).length === 0)
+        return "null";
+    return JSON.stringify(cascading);
+}
+export function generateInvalidationTagsCode(ctx, prefixes, patterns, singularization, cascading) {
+    const { ext, ts } = ctx;
+    const patternCode = generatePatternCode(patterns);
+    const singularizationCode = generateSingularizationCode(singularization);
+    const cascadingCode = generateCascadingCode(cascading);
+    const prefixesCode = JSON.stringify(prefixes);
+    return `/**
+ * Swoff Invalidation Tags Helper
+ * Pattern-based tag generation from URLs with configurable glob patterns,
+ * prefix skipping, singularization, and cascading invalidation.
+ *
+ * Usage:
+ *   import { generateTags, invalidateUrl } from './swoff/cache/tags.${ext}';
+ *
+ *   // Generate tags from URL
+ *   generateTags("/api/todos");          // ["todos"]
+ *   generateTags("/api/todos/42");       // ["todos", "todo:42"]
+ *
+ *   // Use with fetch wrapper
+ *   const data = await fetchWithCache("/api/todos", {
+ *     tags: generateTags("/api/todos"),
+ *   });
+ *
+ *   // Invalidate after mutation
+ *   await invalidateUrl("/api/todos/42");
+ */
+
+import { invalidateByTags } from "./index.${ext}";
+${ts ? `
+interface TagPattern {
+  re: RegExp;
+  params: string[];
+  templates: string[];
+}
+` : ""}
+// Pattern entries compiled from swoff.config.json
+const TAG_PATTERNS${T(ts, "TagPattern[]")} = ${patternCode};
+
+// URL path prefixes to skip during tag generation
+const SKIP_PREFIXES = ${prefixesCode};
+
+// Custom singularization map (plural → singular)
+const SINGULARIZATION${T(ts, "Record<string, string> | null")} = ${singularizationCode};
+
+// Cascading invalidation map (tag → dependent tags)
+const CASCADING${T(ts, "Record<string, string[]> | null")} = ${cascadingCode};
+
+/** Generate cache invalidation tags from a URL path. Tries configured patterns first, falls back to segment-based generation. */
+export function generateTags(url${T(ts, "string | URL")})${R(ts, "string[]")}{
+  const parsed = typeof url === "string" ? new URL(url, window.location.origin) : url;
+  const path = parsed.pathname;
+
+  // Try configured patterns first
+  for (const entry of TAG_PATTERNS) {
+    const match = path.match(entry.re);
+    if (match) {
+      const params${T(ts, "Record<string, string>")} = {};
+      for (let i = 0; i < entry.params.length; i++) {
+        params[entry.params[i]] = match[i + 1];
+      }
+      return entry.templates.map((tmpl) => {
+        return tmpl.replace(/\\{(\\w+)\\}/g, (_, key) => params[key] ?? "");
+      });
+    }
+  }
+
+  // Fallback: segment-based generation
+  const segments = path.split("/").filter(Boolean);
+  if (segments.length === 0) return ["root"];
+
+  let startIdx = 0;
+  while (startIdx < segments.length && SKIP_PREFIXES.includes(segments[startIdx])) {
+    startIdx++;
+  }
+
+  const resourceSegments = segments.slice(startIdx);
+  if (resourceSegments.length === 0) return ["root"];
+
+  const tags = [];
+  tags.push(resourceSegments[0]);
+
+  if (resourceSegments.length >= 2 && !isNaN(Number(resourceSegments[1]))) {
+    const collection = resourceSegments[0];
+    const id = resourceSegments[1];
+    const singular = SINGULARIZATION && SINGULARIZATION[collection] !== undefined
+      ? SINGULARIZATION[collection]
+      : collection.replace(/s$/, "");
+    tags.push(\`\${singular}:\${id}\`);
+  }
+
+  for (let i = 2; i < resourceSegments.length; i++) {
+    if (isNaN(Number(resourceSegments[i]))) {
+      tags.push(resourceSegments[i]);
+    }
+  }
+
+  return tags;
+}
+
+/** Generate tags prefixed by HTTP method. e.g. POST /api/todos → ["post-todos"]. */
+export function generateTagsFromMethod(method${T(ts, "string")}, url${T(ts, "string | URL")})${R(ts, "string[]")}{
+  const tags = generateTags(url);
+  if (method === "GET" || method === "HEAD") return tags;
+  return tags.map((tag) => \`\${method.toLowerCase()}-\${tag}\`);
+}
+
+/** Invalidate cached responses related to a URL, including cascading dependencies. */
+export async function invalidateUrl(url${T(ts, "string | URL")})${R(ts, "Promise<void>")}{
+  const tags = generateTags(url);
+  const allTags = CASCADING ? expandCascading(tags) : tags;
+  await invalidateByTags(allTags);
+}
+
+/** Invalidate cached responses tagged with method-prefixed tags, including cascading dependencies. */
+export async function invalidateByMethod(method${T(ts, "string")}, url${T(ts, "string | URL")})${R(ts, "Promise<void>")}{
+  const tags = generateTagsFromMethod(method, url);
+  const allTags = CASCADING ? expandCascading(tags) : tags;
+  await invalidateByTags(allTags);
+}
+
+/** Expand tags with their cascading dependencies, deduplicated. */
+export function expandCascading(tags${T(ts, "string[]")})${R(ts, "string[]")}{
+  if (!CASCADING) return [...tags];
+  const result = new Set(tags);
+  for (const tag of tags) {
+    const deps = CASCADING[tag];
+    if (deps) {
+      for (const dep of deps) {
+        result.add(dep);
+      }
+    }
+  }
+  return [...result];
+}
+
+/** Introspect: get all URLs cached under a given tag. */
+export async function getUrlsForTag(tag${T(ts, "string")})${R(ts, "Promise<{ url: string; actualUrl: string }[]>")}{
+  const controller = navigator.serviceWorker?.controller;
+  if (!controller) return [];
+  return new Promise((resolve) => {
+    const channel = new MessageChannel();
+    channel.port1.onmessage = (event) => {
+      resolve(event.data.urls || []);
+    };
+    controller.postMessage(
+      { type: "GET_URLS_FOR_TAG", tag },
+      [channel.port2],
+    );
+  });
+}
+
+/** Introspect: get all tags associated with a given URL. */
+export async function getTagsForUrl(url${T(ts, "string")})${R(ts, "Promise<string[]>")}{
+  const controller = navigator.serviceWorker?.controller;
+  if (!controller) return [];
+  return new Promise((resolve) => {
+    const channel = new MessageChannel();
+    channel.port1.onmessage = (event) => {
+      resolve(event.data.tags || []);
+    };
+    controller.postMessage(
+      { type: "GET_TAGS_FOR_URL", url },
+      [channel.port2],
+    );
+  });
+}
+
+/** Invalidate all cached responses whose URL matches the given glob pattern. */
+export async function invalidateMatching(glob${T(ts, "string")})${R(ts, "Promise<void>")}{
+  const controller = navigator.serviceWorker?.controller;
+  if (!controller) return;
+  controller.postMessage({
+    type: "INVALIDATE_MATCHING",
+    glob,
+  });
+}
+`;
+}
+//# sourceMappingURL=invalidation-tags.js.map

package/dist/runtime/invalidation-tags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidation-tags.js","sourceRoot":"","sources":["../../src/runtime/invalidation-tags.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,YAAY,CAAC;AAQlC,SAAS,WAAW,CAAC,GAAW;IAC9B,OAAO,GAAG,CAAC,OAAO,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;AAClD,CAAC;AAED,SAAS,mBAAmB,CAC1B,UAAkB,EAClB,YAAsB;IAEtB,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACvC,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;IAC/C,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,MAAM,UAAU,GAAa,EAAE,CAAC;IAEhC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAEtB,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAClB,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YACjC,SAAS;QACX,CAAC;QAED,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1B,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,CAAC;QAED,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3B,CAAC;aAAM,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAChC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/B,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC7B,CAAC;aAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAChC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;gBACjB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;gBACvD,MAAM,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;gBACxE,UAAU,CAAC,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;YACxD,CAAC;iBAAM,CAAC;gBACN,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;YACrC,CAAC;QACH,CAAC;aAAM,CAAC;YACN,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IAED,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEzC,MAAM,eAAe,GAAG,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IACnD,MAAM,KAAK,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;IAE3E,iDAAiD;IACjD,MAAM,oBAAoB,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/C,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QAChC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACzC,IAAI,OAAO,EAAE,CAAC;YACZ,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;gBACxB,oBAAoB,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3C,CAAC;QACH,CAAC;IACH,CAAC;IACD,KAAK,MAAM,EAAE,IAAI,oBAAoB,EAAE,CAAC;QACtC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;AAChE,CAAC;AAED,SAAS,mBAAmB,CAAC,QAAkC;IAC7D,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,KAAK,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5D,MAAM,QAAQ,GAAG,mBAAmB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QACzD,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CACV,uBAAuB,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,eAAe,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,gBAAgB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CACjK,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;AAC7C,CAAC;AAED,SAAS,2BAA2B,CAClC,eAAuC;IAEvC,IAAI,CAAC,eAAe,IAAI,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,MAAM,KAAK,CAAC;QAC/D,OAAO,MAAM,CAAC;IAChB,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;AACzC,CAAC;AAED,SAAS,qBAAqB,CAAC,SAAmC;IAChE,IAAI,CAAC,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC;IACrE,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,4BAA4B,CAC1C,GAAmB,EACnB,QAAkB,EAClB,QAAkC,EAClC,eAAuC,EACvC,SAAmC;IAEnC,MAAM,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IAExB,MAAM,WAAW,GAAG,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAClD,MAAM,mBAAmB,GAAG,2BAA2B,CAAC,eAAe,CAAC,CAAC;IACzE,MAAM,aAAa,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;IACvD,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAE9C,OAAO;;;;;;uEAM8D,GAAG;;;;;;;;;;;;;;;4CAe9B,GAAG;EAC7C,EAAE,CAAC,CAAC,CAAC;;;;;;CAMN,CAAC,CAAC,CAAC,EAAE;;oBAEc,CAAC,CAAC,EAAE,EAAE,cAAc,CAAC,MAAM,WAAW;;;wBAGlC,YAAY;;;uBAGb,CAAC,CAAC,EAAE,EAAE,+BAA+B,CAAC,MAAM,mBAAmB;;;iBAGrE,CAAC,CAAC,EAAE,EAAE,iCAAiC,CAAC,MAAM,aAAa;;;kCAG1C,CAAC,CAAC,EAAE,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC;;;;;;;;oBAQxD,CAAC,CAAC,EAAE,EAAE,wBAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+CA4CJ,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC;;;;;;;yCAOvE,CAAC,CAAC,EAAE,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;iDAOvC,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;sCAOjF,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;yCAenC,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,+CAA+C,CAAC;;;;;;;;;;;;;;;;yCAgBzE,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,mBAAmB,CAAC;;;;;;;;;;;;;;;;+CAgBvC,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,eAAe,CAAC;;;;;;;;CAQvF,CAAC;AACF,CAAC"}

package/dist/runtime/mutation-queue.js

@@ -0,0 +1,304 @@
+import { T, R, PT, AS } from "./utils.js";
+export function generateMutationQueueCode(ctx, authEnabled, batchSize, batchDelayMs, maxRetries, retryBackoffMs) {
+    const { ext, ts } = ctx;
+    const importLines = authEnabled
+        ? `import { getAuth } from "../auth/store.${ext}";
+`
+        : "";
+    const additionalImports = `import { invalidateByTags } from "../cache/index.${ext}";
+${ts
+        ? `import type { MutationQueueItem } from "../swoff.d.ts";
+`
+        : ""}`;
+    const authReplayHeaders = authEnabled
+        ? `  const auth = await getAuth();
+  const authHeader${T(ts, "Record<string, string>")} = auth?.token ? { Authorization: \`Bearer \${auth.token}\` } : {};
+`
+        : "";
+    const authHeaderSpread = authEnabled
+        ? `            ...authHeader,\n`
+        : "            ";
+    const code = `/**
+ * Swoff Mutation Queue
+ * Queue offline writes and sync when connection returns.
+ * Supports configurable batch size, rate limiting, and exponential backoff.
+ *
+ * Usage:
+ *   import { queueMutation, processMutationQueue, flushMutations, getPendingCount } from './swoff/offline/queue.${ext}';
+ *
+ *   // Queue a mutation
+ *   await queueMutation({
+ *     method: "POST",
+ *     url: "/api/todos",
+ *     body: { title: "Grocery" },
+ *     tags: ["todos"],
+ *   });
+ *
+ *   // Flush queued mutations (e.g., after login)
+ *   await flushMutations();
+ *
+ *   // Auto-processes on online event
+ *
+ * Config:
+ *   batchSize: ${batchSize}      — mutations per progress event
+ *   batchDelayMs: ${batchDelayMs} — delay between mutations (rate limiting)
+ *   maxRetries: ${maxRetries}      — max retries before dropping
+ *   retryBackoffMs: ${retryBackoffMs} — exponential backoff base
+ */
+
+${importLines}${additionalImports}const DB_NAME = "swoff-queue";
+const STORE_NAME = "mutations";
+// Bump this when adding new indexes/stores for schema migration
+const DB_VERSION = 1;
+const BATCH_SIZE = ${batchSize};
+const BATCH_DELAY_MS = ${batchDelayMs};
+const MAX_RETRIES = ${maxRetries};
+const RETRY_BACKOFF_MS = ${retryBackoffMs};
+
+function sleep(ms${T(ts, "number")})${R(ts, "Promise<void>")}{
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+function openQueueDB()${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)) {
+        const store = db.createObjectStore(STORE_NAME, { keyPath: "id" });
+        store.createIndex("by-timestamp", "timestamp");
+      }
+    };
+    request.onsuccess = (e) => resolve((e.target${AS(ts, "IDBOpenDBRequest")}).result);
+    request.onerror = (e) => reject((e.target${AS(ts, "IDBRequest")}).error);
+  });
+}
+
+let isSyncing = false;
+
+/** Store a write operation in IndexedDB for later sync. Works offline — use it for POST/PUT/PATCH/DELETE when the user might be offline. */
+export async function queueMutation(mutation${T(ts, "Partial<MutationQueueItem>")})${R(ts, "Promise<void>")}{
+  const db = await openQueueDB();
+  const tx = db.transaction(STORE_NAME, "readwrite");
+  const store = tx.objectStore(STORE_NAME);
+
+  let body = mutation.body;
+  let bodyType = "json";
+  if (typeof body === "string") {
+    bodyType = "text";
+  } else if (body instanceof FormData) {
+    bodyType = "formdata";
+    body = [...body.entries()];
+  } else if (body instanceof Blob) {
+    bodyType = "blob";
+  } else if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+    bodyType = "buffer";
+  }
+
+  // Strip auth headers before storing — tokens must never persist in IDB
+  const safeHeaders${T(ts, "Record<string, string>")} = { ...(mutation.headers || {}) };
+  delete safeHeaders["authorization"];
+  delete safeHeaders["Authorization"];
+
+  store.add({
+    id: crypto.randomUUID(),
+    method: mutation.method,
+    url: mutation.url,
+    body,
+    bodyType,
+    headers: safeHeaders,
+    timestamp: Date.now(),
+    retryCount: 0,
+    nextRetryAt: 0,
+    tags: mutation.tags || [],
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+
+  window.dispatchEvent(new CustomEvent("mutation-queue-changed"));
+}
+
+/** Replay a single queued mutation. Uses the provided db connection if available. Returns true on success, false on failure. */
+async function replayMutation(item${T(ts, "MutationQueueItem")}, db${T(ts, "IDBDatabase | undefined")})${R(ts, "Promise<boolean>")}{
+  try {
+${authReplayHeaders}    let replayBody${T(ts, "BodyInit | null")}${ts ? " = null" : ""};
+    let contentType${T(ts, "string | undefined")};
+    const bt = item.bodyType || "json";
+    if (bt === "formdata") {
+      replayBody = new FormData();
+      for (const [key, value] of (item.body || [])${AS(ts, "[string, FormDataEntryValue][]")}) {
+        replayBody.append(key, value);
+      }
+    } else if (bt === "blob") {
+      replayBody = item.body${AS(ts, "BodyInit | null")};
+    } else if (bt === "buffer") {
+      replayBody = item.body instanceof ArrayBuffer ? new Uint8Array(item.body)${AS(ts, "BodyInit")} : item.body${AS(ts, "BodyInit")};
+    } else if (bt === "text") {
+      replayBody = item.body${AS(ts, "BodyInit | null")};
+    } else if (item.body != null) {
+      replayBody = JSON.stringify(item.body);
+      contentType = "application/json";
+    }
+    const response = await fetch(item.url, {
+      method: item.method,
+      headers: {
+        ...(contentType ? { "Content-Type": contentType } : {}),
+        ...item.headers,
+${authHeaderSpread}      },
+      ...(replayBody != null ? { body: replayBody } : {}),
+    });
+
+    if (!response.ok) throw new Error(\`HTTP \${response.status}\`);
+
+    if (item.tags && item.tags.length > 0) {
+      await invalidateByTags(item.tags);
+    }
+
+    await removeFromQueue(item.id, db);
+    return true;
+  } catch {
+    item.retryCount++;
+    item.nextRetryAt = Date.now() + RETRY_BACKOFF_MS * Math.pow(2, item.retryCount - 1);
+    await updateInQueue(item, db);
+    return false;
+  }
+}
+
+/** Process all queued mutations in order. Sends them to the server. Runs automatically when mutations are queued or on reconnection. Respects batchSize for progress reporting and batchDelayMs for rate limiting. */
+export async function processMutationQueue()${R(ts, "Promise<void>")}{
+  if (isSyncing) return;
+  isSyncing = true;
+
+  const db = await openQueueDB();
+  try {
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    const index = store.index("by-timestamp");
+    const queue${T(ts, "MutationQueueItem[]")} = await new Promise${PT(ts, "MutationQueueItem[]")}((resolve, reject) => {
+      const request = index.getAll();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+
+    if (queue.length === 0) return;
+
+    let succeeded = 0;
+    let failed = 0;
+    const total = queue.length;
+    let earliestRetry = Infinity;
+
+    for (const item of queue) {
+      if (item.retryCount >= MAX_RETRIES) {
+        await removeFromQueue(item.id, db);
+        failed++;
+        continue;
+      }
+
+      // Skip items whose backoff delay hasn't elapsed yet
+      if (item.nextRetryAt && Date.now() < item.nextRetryAt) {
+        if (item.nextRetryAt < earliestRetry) earliestRetry = item.nextRetryAt;
+        continue;
+      }
+
+      const ok = await replayMutation(item, db);
+      if (ok) {
+        succeeded++;
+      } else {
+        failed++;
+      }
+
+      // Rate limiting delay between mutations
+      if (BATCH_DELAY_MS > 0 && succeeded + failed < total) {
+        await sleep(BATCH_DELAY_MS);
+      }
+
+      // Emit progress after every BATCH_SIZE mutations
+      if ((succeeded + failed) % BATCH_SIZE === 0 || succeeded + failed === total) {
+        window.dispatchEvent(
+          new CustomEvent("mutation-sync-complete", {
+            detail: { succeeded, failed, total, current: succeeded + failed },
+          })
+        );
+      }
+    }
+
+    window.dispatchEvent(
+      new CustomEvent("mutation-sync-complete", {
+        detail: { succeeded, failed, total },
+      })
+    );
+
+    // Schedule retry when the earliest backoff timer expires
+    if (earliestRetry < Infinity && earliestRetry > Date.now()) {
+      setTimeout(() => {
+        if (!isSyncing) processMutationQueue();
+      }, earliestRetry - Date.now());
+    }
+  } finally {
+    db.close();
+    isSyncing = false;
+    window.dispatchEvent(new CustomEvent("mutation-queue-changed"));
+  }
+}
+
+/** Immediately process all queued mutations. Call this after re-login to flush mutations that failed due to auth expiry. */
+export async function flushMutations()${R(ts, "Promise<void>")}{
+  await processMutationQueue();
+}
+
+async function removeFromQueue(id${T(ts, "string")}, db${T(ts, "IDBDatabase | undefined")})${R(ts, "Promise<void>")}{
+  if (!db) db = await openQueueDB();
+  const tx = db.transaction(STORE_NAME, "readwrite");
+  tx.objectStore(STORE_NAME).delete(id);
+  await new Promise${PT(ts, "void")}((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+async function updateInQueue(item${T(ts, "MutationQueueItem")}, db${T(ts, "IDBDatabase | undefined")})${R(ts, "Promise<void>")}{
+  if (!db) db = await openQueueDB();
+  const tx = db.transaction(STORE_NAME, "readwrite");
+  tx.objectStore(STORE_NAME).put(item);
+  await new Promise${PT(ts, "void")}((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+
+/** Get the number of queued mutations waiting to be synced. Useful for showing a sync badge. */
+export async function getPendingCount()${R(ts, "Promise<number>")}{
+  const db = await openQueueDB();
+  return new Promise${PT(ts, "number")}((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const request = tx.objectStore(STORE_NAME).count();
+    request.onsuccess = () => resolve((request${AS(ts, "IDBRequest<number>")}).result);
+    request.onerror = () => reject((request${AS(ts, "IDBRequest")}).error);
+  });
+}
+
+/** Get the position of a mutation in the queue (0-based). Returns -1 if not found. */
+export async function getQueuePosition(id${T(ts, "string")})${R(ts, "Promise<number>")}{
+  const items = await getQueueItems();
+  return items.findIndex((item) => item.id === id);
+}
+
+/** Get all pending queue items with their details. */
+export async function getQueueItems()${R(ts, "Promise<MutationQueueItem[]>")}{
+  const db = await openQueueDB();
+  const tx = db.transaction(STORE_NAME, "readonly");
+  const store = tx.objectStore(STORE_NAME);
+  const index = store.index("by-timestamp");
+  return new Promise${PT(ts, "MutationQueueItem[]")}((resolve, reject) => {
+    const request = index.getAll();
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+`;
+    return code;
+}
+//# sourceMappingURL=mutation-queue.js.map

package/dist/runtime/mutation-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-queue.js","sourceRoot":"","sources":["../../src/runtime/mutation-queue.ts"],"names":[],"mappings":"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"}