@supersoniks/concorde 5.0.2 → 5.0.3

package/docs/docs-mock-api-sw.js

@@ -0,0 +1,724 @@
+"use strict";
+(() => {
+  // src/docs/mock-api/urls.ts
+  var DOCS_MOCK_API_BASE = "/docs-mock-api";
+  var DOCS_MOCK_GEO_SERVICE = `${DOCS_MOCK_API_BASE}/geo/`;
+  var DOCS_MOCK_JOKES_SERVICE = `${DOCS_MOCK_API_BASE}/jokes`;
+
+  // src/docs/mock-api/api-config-mock.ts
+  var DOCS_MOCK_TOKEN_VALID = "docs-mock-valid-token";
+  var DOCS_MOCK_TOKEN_STALE = "docs-mock-stale-token";
+  var DOCS_MOCK_TOKEN_FRESH = "docs-mock-fresh-token";
+  var DOCS_MOCK_BASIC_USER = "demo";
+  var DOCS_MOCK_BASIC_PASSWORD = "secret";
+  var DOCS_MOCK_EVENTS_API_TOKEN = "docs-mock-events-token";
+  var WORDING_CATALOG = {
+    "api-config.greeting": { fr: "Bonjour", en: "Hello" },
+    "api-config.farewell": { fr: "Au revoir", en: "Goodbye" },
+    "api-config.hint": {
+      fr: "Libell\xE9s servis par le mock /wording/labels",
+      en: "Labels served by mock /wording/labels"
+    }
+  };
+  function json(body, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("Content-Type", "application/json; charset=utf-8");
+    headers.set("Access-Control-Allow-Origin", "*");
+    headers.set("X-Docs-Mock-Api", "concorde-api-config");
+    return new Response(JSON.stringify(body), { ...init, headers });
+  }
+  function parseAuthorization(request) {
+    const header = request.headers.get("authorization");
+    if (!header) return { kind: "none" };
+    const basic = header.match(/^Basic\s+(.+)$/i);
+    if (basic) {
+      try {
+        const decoded = atob(basic[1]);
+        const sep = decoded.indexOf(":");
+        if (sep < 0) return { kind: "none" };
+        return {
+          kind: "basic",
+          user: decoded.slice(0, sep),
+          password: decoded.slice(sep + 1)
+        };
+      } catch {
+        return { kind: "none" };
+      }
+    }
+    const bearer = header.match(/^Bearer\s+(.+)$/i);
+    if (bearer) return { kind: "bearer", token: bearer[1].trim() };
+    return { kind: "none" };
+  }
+  function isValidBasic(auth) {
+    return auth.kind === "basic" && auth.user === DOCS_MOCK_BASIC_USER && auth.password === DOCS_MOCK_BASIC_PASSWORD;
+  }
+  function wordingLabels(url) {
+    const lang = url.searchParams.get("lang") || "fr";
+    const labels = url.searchParams.getAll("labels[]").length ? url.searchParams.getAll("labels[]") : url.searchParams.getAll("labels");
+    const result = {};
+    for (const key of labels) {
+      const entry = WORDING_CATALOG[key];
+      result[key] = entry?.[lang] ?? entry?.en ?? `[missing:${key}]`;
+    }
+    return json({ lang, labels: result, ...result });
+  }
+  function handleApiConfigMockRequest(request, subPath, method) {
+    if (subPath === "/auth/token" && method === "GET") {
+      const auth = parseAuthorization(request);
+      if (isValidBasic(auth)) {
+        return json({
+          token: DOCS_MOCK_TOKEN_FRESH,
+          source: "basic",
+          serviceHost: new URL(request.url).searchParams.get("serviceHost")
+        });
+      }
+      if (auth.kind === "bearer" && auth.token === DOCS_MOCK_EVENTS_API_TOKEN) {
+        return json({
+          token: DOCS_MOCK_TOKEN_FRESH,
+          source: "eventsApiToken"
+        });
+      }
+      return json({ error: "Unauthorized" }, { status: 401 });
+    }
+    if (subPath === "/api/config/protected" && method === "GET") {
+      const auth = parseAuthorization(request);
+      if (auth.kind === "bearer") {
+        if (auth.token === DOCS_MOCK_TOKEN_STALE) {
+          return json({ error: "Token expired", code: "token_stale" }, { status: 498 });
+        }
+        if (auth.token === DOCS_MOCK_TOKEN_VALID || auth.token === DOCS_MOCK_TOKEN_FRESH) {
+          return json({
+            ok: true,
+            message: "Protected resource",
+            tokenUsed: auth.token
+          });
+        }
+      }
+      if (isValidBasic(auth)) {
+        return json({
+          ok: true,
+          message: "Protected resource (basic)",
+          tokenUsed: null
+        });
+      }
+      return json({ error: "Unauthorized" }, { status: 401 });
+    }
+    if ((subPath === "/wording/labels" || subPath.startsWith("/wording/labels")) && method === "GET") {
+      return wordingLabels(new URL(request.url));
+    }
+    return null;
+  }
+  var API_CONFIG_MOCK_PATHS = [
+    `${DOCS_MOCK_API_BASE}/auth/token`,
+    `${DOCS_MOCK_API_BASE}/api/config/protected`,
+    `${DOCS_MOCK_API_BASE}/wording/labels`
+  ];
+
+  // src/docs/mock-api/fixtures.ts
+  var reqresAvatar = (seed) => `https://i.pravatar.cc/150?u=${encodeURIComponent(seed)}`;
+  var REQRES_EXTRA_NAMES = [
+    ["Michael", "Lawson"],
+    ["Tobias", "Funke"],
+    ["Lindsay", "Funke"],
+    ["Maeby", "Funke"],
+    ["George", "Michael"],
+    ["Annye", "Vang"],
+    ["Rachel", "Howe"],
+    ["Terry", "Medhurst"],
+    ["Bette", "Haag"],
+    ["Lester", "Solomon"],
+    ["April", "Douglas"],
+    ["Marian", "Roberts"],
+    ["Kathryn", "Murphy"],
+    ["Gloria", "Armstrong"],
+    ["Adam", "Bradley"],
+    ["Angela", "Hicks"],
+    ["Rose", "Wheeler"],
+    ["Sara", "Berry"],
+    ["Glen", "Kuhn"],
+    ["Roger", "Cox"]
+  ];
+  function buildReqresUser(id, first_name, last_name) {
+    const slug = `${first_name}-${last_name}`.toLowerCase();
+    return {
+      id,
+      email: `${first_name.toLowerCase()}.${last_name.toLowerCase()}@example.com`,
+      first_name,
+      last_name,
+      avatar: reqresAvatar(slug)
+    };
+  }
+  var DOCS_REQRES_USERS = [
+    buildReqresUser(1, "George", "Bluth"),
+    buildReqresUser(2, "Janet", "Weaver"),
+    buildReqresUser(3, "Emma", "Wong"),
+    buildReqresUser(4, "Eve", "Holt"),
+    ...REQRES_EXTRA_NAMES.map(
+      ([first_name, last_name], index) => buildReqresUser(5 + index, first_name, last_name)
+    )
+  ];
+  function filterDocsUsers(users, query) {
+    const q = query?.trim().toLowerCase();
+    if (!q) return users;
+    return users.filter((user) => {
+      const haystack = `${user.first_name} ${user.last_name} ${user.email}`.toLowerCase();
+      return haystack.includes(q);
+    });
+  }
+  var DOCS_GEO_COMMUNES = [
+    { nom: "Paris", code: "75056" },
+    { nom: "Lyon", code: "69123" },
+    { nom: "Marseille", code: "13055" },
+    { nom: "Toulouse", code: "31555" },
+    { nom: "Lille", code: "59350" },
+    { nom: "Bordeaux", code: "33063" },
+    { nom: "Nantes", code: "44109" },
+    { nom: "Strasbourg", code: "67482" },
+    { nom: "Montpellier", code: "34172" },
+    { nom: "Rennes", code: "35238" }
+  ];
+  var jokeFlags = (partial = {}) => ({
+    nsfw: false,
+    religious: false,
+    political: false,
+    racist: false,
+    sexist: false,
+    explicit: false,
+    ...partial
+  });
+  var SAMPLE_JOKES = [
+    {
+      categories: ["Programming"],
+      createdAt: "2020-01-01 00:00:00",
+      id: 1,
+      lang: "en",
+      joke: "Why do programmers prefer dark mode? Because light attracts bugs.",
+      flags: jokeFlags(),
+      safe: true,
+      type: "single"
+    },
+    {
+      categories: ["Misc"],
+      createdAt: "2020-01-02 00:00:00",
+      id: 2,
+      lang: "en",
+      joke: "I told my computer I needed a break \u2014 it said: no problem, I'll go to sleep.",
+      flags: jokeFlags({ nsfw: true }),
+      safe: false,
+      type: "single"
+    },
+    {
+      categories: ["Pun"],
+      createdAt: "2020-01-03 00:00:00",
+      id: 3,
+      lang: "en",
+      joke: "Concorde docs run offline: even the API is a local joke.",
+      flags: jokeFlags(),
+      safe: true,
+      type: "single"
+    },
+    {
+      categories: ["Animals"],
+      createdAt: "2020-01-04 00:00:00",
+      id: 4,
+      lang: "en",
+      joke: "The dog ate my homework and my pull request.",
+      flags: jokeFlags({ political: true }),
+      safe: true,
+      type: "single"
+    },
+    {
+      categories: ["Animals", "Pun"],
+      createdAt: "2020-01-05 00:00:00",
+      id: 5,
+      lang: "fr",
+      joke: "Quel est le chien pr\xE9f\xE9r\xE9 des d\xE9veloppeurs ? Le labrador Retriever.",
+      flags: jokeFlags(),
+      safe: true,
+      type: "single"
+    },
+    {
+      categories: ["Animals"],
+      createdAt: "2020-01-06 00:00:00",
+      id: 6,
+      lang: "fr",
+      joke: "Un chat et un chien discutent de TypeScript : le chien dit \xAB woof \xBB, le chat compile.",
+      flags: jokeFlags({ racist: true }),
+      safe: false,
+      type: "single"
+    },
+    {
+      categories: ["Misc"],
+      createdAt: "2020-01-07 00:00:00",
+      id: 7,
+      lang: "fr",
+      joke: "Pourquoi les blagues offline sont-elles fiables ? Parce qu'elles passent par le Service Worker.",
+      flags: jokeFlags({ religious: true }),
+      safe: true,
+      type: "single"
+    },
+    {
+      categories: ["Programming"],
+      createdAt: "2020-01-08 00:00:00",
+      id: 8,
+      lang: "fr",
+      joke: "Mon compilateur et mon chien : tous deux ignorent mes commandes jusqu'au build.",
+      flags: jokeFlags({ sexist: true }),
+      safe: false,
+      type: "single"
+    },
+    {
+      categories: ["Misc"],
+      createdAt: "2020-01-09 00:00:00",
+      id: 9,
+      lang: "en",
+      joke: "A SQL query walks into a bar, walks up to two tables and asks: Can I join you?",
+      flags: jokeFlags({ explicit: true }),
+      safe: false,
+      type: "single"
+    },
+    {
+      categories: ["Pun"],
+      createdAt: "2020-01-10 00:00:00",
+      id: 10,
+      lang: "fr",
+      joke: "J'ai cherch\xE9 \xAB chien \xBB dans la doc : le mock API a r\xE9pondu.",
+      flags: jokeFlags(),
+      safe: true,
+      type: "single"
+    },
+    {
+      categories: ["Misc"],
+      createdAt: "2020-01-11 00:00:00",
+      id: 11,
+      lang: "en",
+      joke: "There are only two hard things in Computer Science: cache invalidation and naming things.",
+      flags: jokeFlags({ political: true, explicit: true }),
+      safe: false,
+      type: "single"
+    },
+    {
+      categories: ["Animals"],
+      createdAt: "2020-01-12 00:00:00",
+      id: 12,
+      lang: "fr",
+      joke: "Le golden retriever a r\xE9cup\xE9r\xE9 la donn\xE9e du publisher.",
+      flags: jokeFlags({ racist: true, sexist: true }),
+      safe: false,
+      type: "two-liner",
+      setup: "Pourquoi le chien aime Concorde ?",
+      delivery: "Parce qu'il sait fetch."
+    },
+    {
+      categories: ["Misc"],
+      createdAt: "2020-01-13 00:00:00",
+      id: 13,
+      lang: "en",
+      joke: "My code and my conscience: both have too many warnings.",
+      flags: jokeFlags(),
+      safe: true,
+      type: "single"
+    },
+    {
+      categories: ["Programming"],
+      createdAt: "2020-01-14 00:00:00",
+      id: 14,
+      lang: "en",
+      joke: "Git blame is just a mirror.",
+      flags: jokeFlags({ religious: true, political: true }),
+      safe: false,
+      type: "single"
+    }
+  ];
+  function parseBlacklistFlags(url) {
+    const keys = /* @__PURE__ */ new Set();
+    const valid = [
+      "nsfw",
+      "religious",
+      "political",
+      "racist",
+      "sexist",
+      "explicit"
+    ];
+    const add = (raw) => {
+      raw.split(",").map((s) => s.trim().toLowerCase()).forEach((part) => {
+        if (valid.includes(part)) keys.add(part);
+      });
+    };
+    url.searchParams.getAll("blacklistFlags").forEach(add);
+    const single = url.searchParams.get("blacklistFlags");
+    if (single) add(single);
+    return [...keys];
+  }
+  function applyJokeBlacklist(jokes, blacklist) {
+    if (!blacklist.length) return jokes;
+    return jokes.filter(
+      (j) => !blacklist.some((flag) => j.flags[flag] === true)
+    );
+  }
+  function filterDocsJokes(jokes, url) {
+    let pool = jokes;
+    const contains = url.searchParams.get("contains")?.trim().toLowerCase();
+    if (contains) {
+      pool = pool.filter((j) => {
+        const haystack = [j.joke, j.setup, j.delivery, ...j.categories].filter(Boolean).join(" ").toLowerCase();
+        return haystack.includes(contains);
+      });
+    }
+    const lang = url.searchParams.get("lang")?.trim().toLowerCase();
+    if (lang === "fr" || lang === "en") {
+      pool = pool.filter((j) => j.lang === lang);
+    }
+    pool = applyJokeBlacklist(pool, parseBlacklistFlags(url));
+    return pool;
+  }
+  function buildJokeApiResponse(url) {
+    const pool = filterDocsJokes(SAMPLE_JOKES, url);
+    const amount = Math.max(
+      1,
+      parseInt(url.searchParams.get("amount") || "10", 10)
+    );
+    const hasOffset = url.searchParams.has("offset");
+    const limit = Math.max(
+      1,
+      parseInt(
+        url.searchParams.get("limit") || url.searchParams.get("per_page") || String(amount),
+        10
+      )
+    );
+    const offset = Math.max(0, parseInt(url.searchParams.get("offset") || "0", 10));
+    const start = hasOffset ? offset : 0;
+    const count = hasOffset ? limit : amount;
+    const jokes = pool.slice(start, start + count).map((j, i) => ({
+      ...j,
+      id: start + i + 1
+    }));
+    return { error: false, amount: jokes.length, jokes };
+  }
+
+  // src/docs/mock-api/fixtures-jsonata.ts
+  var avatar = (seed) => `https://i.pravatar.cc/150?u=${encodeURIComponent(seed)}`;
+  var DOCS_SPACE_CAT_MISSIONS = [
+    {
+      id: 1,
+      name: "Captain Whiskers",
+      planet: "Mars",
+      mission: "Laser hunt",
+      points: 40,
+      avatar: avatar("captain-whiskers")
+    },
+    {
+      id: 2,
+      name: "Captain Whiskers",
+      planet: "Mars",
+      mission: "Dust nap",
+      points: 25,
+      avatar: avatar("captain-whiskers")
+    },
+    {
+      id: 3,
+      name: "Nebula Paws",
+      planet: "Europa",
+      mission: "Ice fishing",
+      points: 55,
+      avatar: avatar("nebula-paws")
+    },
+    {
+      id: 4,
+      name: "Astro Mittens",
+      planet: "Titan",
+      mission: "Methane surf",
+      points: 33,
+      avatar: avatar("astro-mittens")
+    },
+    {
+      id: 5,
+      name: "Nebula Paws",
+      planet: "Europa",
+      mission: "Comet chase",
+      points: 20,
+      avatar: avatar("nebula-paws")
+    },
+    {
+      id: 6,
+      name: "Professor Meowington",
+      planet: "Venus",
+      mission: "Cloud tasting",
+      points: 48,
+      avatar: avatar("prof-meowington")
+    },
+    {
+      id: 7,
+      name: "Astro Mittens",
+      planet: "Titan",
+      mission: "Antenna polish",
+      points: 12,
+      avatar: avatar("astro-mittens")
+    },
+    {
+      id: 8,
+      name: "Zero-G Socks",
+      planet: "Moon",
+      mission: "Flag knitting",
+      points: 61,
+      avatar: avatar("zero-g-socks")
+    }
+  ];
+  var DOCS_COFFEE_BAGS = [
+    { id: 1, origin: "Ethiopia", roast: "light", kg: 12, farm: "Yirgacheffe Hills" },
+    { id: 2, origin: "Ethiopia", roast: "medium", kg: 8, farm: "Sidamo Ridge" },
+    { id: 3, origin: "Colombia", roast: "medium", kg: 15, farm: "Huila Valley" },
+    { id: 4, origin: "Colombia", roast: "dark", kg: 6, farm: "Cauca Peak" },
+    { id: 5, origin: "Brazil", roast: "dark", kg: 22, farm: "Minas Gerais" },
+    { id: 6, origin: "Brazil", roast: "medium", kg: 10, farm: "Cerrado" },
+    { id: 7, origin: "Guatemala", roast: "light", kg: 9, farm: "Antigua" },
+    { id: 8, origin: "Guatemala", roast: "dark", kg: 5, farm: "Huehuetenango" },
+    { id: 9, origin: "Ethiopia", roast: "light", kg: 4, farm: "Guji Forest" }
+  ];
+  function filterCoffeeBags(bags, roast) {
+    const r = roast?.trim().toLowerCase();
+    if (!r || r === "all") return bags;
+    return bags.filter((b) => b.roast === r);
+  }
+  var DOCS_MARKET_ORDER_LINES = [
+    { id: 1, name: "Heirloom tomatoes", qty: 4, unitPrice: 3.5, category: "veg" },
+    { id: 2, name: "Sourdough loaf", qty: 2, unitPrice: 6, category: "bakery" },
+    { id: 3, name: "Goat cheese", qty: 1, unitPrice: 8.5, category: "dairy" },
+    { id: 4, name: "Honey jar", qty: 3, unitPrice: 5.2, category: "pantry" },
+    { id: 5, name: "Sunflowers", qty: 5, unitPrice: 2, category: "flowers" },
+    { id: 6, name: "Free-range eggs", qty: 2, unitPrice: 4.8, category: "dairy" }
+  ];
+
+  // src/docs/mock-api/router.ts
+  var DOCS_MOCK_API_PREFIX = "/docs-mock-api";
+  function json2(body, init = {}) {
+    const { delayMs = 0, ...responseInit } = init;
+    const headers = new Headers(responseInit.headers);
+    headers.set("Content-Type", "application/json; charset=utf-8");
+    headers.set("Access-Control-Allow-Origin", "*");
+    headers.set("X-Docs-Mock-Api", "concorde");
+    const build = () => new Response(JSON.stringify(body), { ...responseInit, headers });
+    if (delayMs <= 0) return Promise.resolve(build());
+    return new Promise(
+      (resolve) => setTimeout(() => resolve(build()), delayMs)
+    );
+  }
+  function paginateUsers(url) {
+    const perPage = Math.max(
+      1,
+      parseInt(
+        url.searchParams.get("per_page") || url.searchParams.get("limit") || "6",
+        10
+      )
+    );
+    const pool = filterDocsUsers(DOCS_REQRES_USERS, url.searchParams.get("q"));
+    const total = pool.length;
+    let start;
+    let page;
+    if (url.searchParams.has("offset")) {
+      start = Math.max(0, parseInt(url.searchParams.get("offset") || "0", 10));
+      page = Math.floor(start / perPage) + 1;
+    } else {
+      page = Math.max(1, parseInt(url.searchParams.get("page") || "1", 10));
+      start = (page - 1) * perPage;
+    }
+    const data = pool.slice(start, start + perPage);
+    return {
+      page,
+      per_page: perPage,
+      total,
+      total_pages: Math.max(1, Math.ceil(total / perPage)),
+      data
+    };
+  }
+  async function parseRegisterFields(request) {
+    const contentType = (request.headers.get("content-type") || "").toLowerCase();
+    if (contentType.includes("multipart/form-data")) {
+      const fd = await request.formData();
+      return {
+        email: String(fd.get("email") ?? ""),
+        password: String(fd.get("password") ?? "")
+      };
+    }
+    if (contentType.includes("application/x-www-form-urlencoded")) {
+      const text2 = await request.text();
+      const params = new URLSearchParams(text2);
+      return {
+        email: params.get("email") ?? "",
+        password: params.get("password") ?? ""
+      };
+    }
+    const text = await request.text();
+    if (!text.trim()) return {};
+    try {
+      const parsed = JSON.parse(text);
+      return {
+        email: parsed.email != null ? String(parsed.email) : "",
+        password: parsed.password != null ? String(parsed.password) : ""
+      };
+    } catch {
+      const params = new URLSearchParams(text);
+      if (params.has("email") || params.has("password")) {
+        return {
+          email: params.get("email") ?? "",
+          password: params.get("password") ?? ""
+        };
+      }
+      return {};
+    }
+  }
+  function registerOkBody(fields, nested = false) {
+    const payload = {
+      id: 4,
+      token: "docs-mock-register-token",
+      email: fields.email
+    };
+    return nested ? { data: payload } : payload;
+  }
+  function geoCommunes(url) {
+    const limit = Math.max(
+      1,
+      parseInt(url.searchParams.get("limit") || "5", 10)
+    );
+    const offset = Math.max(0, parseInt(url.searchParams.get("offset") || "0", 10));
+    const needle = (url.searchParams.get("nom") || url.searchParams.get("text") || url.searchParams.get("q") || url.searchParams.get("code") || "").trim().toLowerCase();
+    const rows = needle ? DOCS_GEO_COMMUNES.filter(
+      (row) => row.nom.toLowerCase().includes(needle) || row.code.toLowerCase().includes(needle)
+    ) : DOCS_GEO_COMMUNES;
+    return rows.slice(offset, offset + limit);
+  }
+  async function handleDocsMockApiRequest(request) {
+    const url = new URL(request.url);
+    if (!url.pathname.startsWith(DOCS_MOCK_API_PREFIX)) return null;
+    const subPath = url.pathname.slice(DOCS_MOCK_API_PREFIX.length) || "/";
+    const method = request.method.toUpperCase();
+    if (subPath === "/health") {
+      return json2({ ok: true, service: "concorde-docs-mock-api" });
+    }
+    const apiConfigResponse = handleApiConfigMockRequest(request, subPath, method);
+    if (apiConfigResponse) return apiConfigResponse;
+    if ((subPath === "/api/register" || subPath === "/api/register/nested") && method === "POST") {
+      const body = await parseRegisterFields(request);
+      if (!body.email?.trim() || !body.password?.trim()) {
+        return json2(
+          {
+            messages: [
+              {
+                content: "email and password are required",
+                status: "error"
+              }
+            ]
+          },
+          { status: 400 }
+        );
+      }
+      return json2(
+        registerOkBody(
+          { email: body.email.trim(), password: body.password.trim() },
+          subPath === "/api/register/nested"
+        )
+      );
+    }
+    const sessionSyncMatch = subPath.match(/^\/api\/sessions\/([^/]+)\/sync$/);
+    if (sessionSyncMatch && method === "POST") {
+      const sessionId = decodeURIComponent(sessionSyncMatch[1]);
+      let body = {};
+      try {
+        const text = await request.text();
+        if (text.trim()) {
+          body = JSON.parse(text);
+        }
+      } catch {
+        body = {};
+      }
+      return json2({
+        ok: true,
+        sessionId,
+        serverTime: Date.now(),
+        echo: body
+      });
+    }
+    if (subPath === "/api/register/echo" && method === "GET") {
+      const email = url.searchParams.get("email") ?? "";
+      const password = url.searchParams.get("password") ?? "";
+      if (!email.trim() || !password.trim()) {
+        return json2(
+          {
+            messages: [
+              {
+                content: "email and password query params are required",
+                status: "error"
+              }
+            ]
+          },
+          { status: 400 }
+        );
+      }
+      return json2({
+        method: "GET",
+        query: { email, password },
+        email,
+        note: 'sonic-submit method="get" appends form fields to the endpoint URL'
+      });
+    }
+    if (method !== "GET") {
+      return json2({ error: "Method not allowed" }, { status: 405 });
+    }
+    const userMatch = subPath.match(/^\/api\/users\/(\d+)$/);
+    if (userMatch) {
+      const id = parseInt(userMatch[1], 10);
+      const user = DOCS_REQRES_USERS.find((u) => u.id === id) ?? DOCS_REQRES_USERS[0];
+      const body = { data: { ...user, id } };
+      return json2(body);
+    }
+    if (subPath === "/api/users") {
+      return json2(paginateUsers(url));
+    }
+    if (subPath === "/api/space-cats") {
+      return json2({
+        data: DOCS_SPACE_CAT_MISSIONS,
+        total: DOCS_SPACE_CAT_MISSIONS.length
+      });
+    }
+    if (subPath === "/api/coffee-bags") {
+      const roast = url.searchParams.get("roast");
+      const data = filterCoffeeBags(DOCS_COFFEE_BAGS, roast);
+      return json2({ data, total: data.length });
+    }
+    if (subPath === "/api/market-order") {
+      return json2({
+        data: DOCS_MARKET_ORDER_LINES,
+        total: DOCS_MARKET_ORDER_LINES.length
+      });
+    }
+    if (subPath === "/geo/communes" || subPath.startsWith("/geo/communes")) {
+      return json2(geoCommunes(url), {
+        headers: { "X-Fetched-At": (/* @__PURE__ */ new Date()).toISOString() }
+      });
+    }
+    const jokeMatch = subPath.match(/^\/jokes\/joke\/([^/]+)$/);
+    if (jokeMatch) {
+      return json2(buildJokeApiResponse(url));
+    }
+    return json2({ error: "Not found", path: subPath }, { status: 404 });
+  }
+
+  // src/docs/mock-api/service-worker.ts
+  self.addEventListener("install", (event) => {
+    event.waitUntil(self.skipWaiting());
+  });
+  self.addEventListener("activate", (event) => {
+    event.waitUntil(self.clients.claim());
+  });
+  self.addEventListener("fetch", (event) => {
+    const { request } = event;
+    event.respondWith(
+      (async () => {
+        const mocked = await handleDocsMockApiRequest(request);
+        if (mocked) return mocked;
+        return fetch(request);
+      })()
+    );
+  });
+})();
+//# sourceMappingURL=docs-mock-api-sw.js.map