@carlonicora/nextjs-jsonapi 6.12.2 → 6.13.1

package/dist/chunk-7JZHPMGW.mjs

@@ -0,0 +1,704 @@
+import {
+  CURRENT_USER_STORAGE_KEY,
+  getClientApiUrl
+} from "./chunk-DOCIFE6A.mjs";
+import {
+  NeedsConnectionError,
+  getOfflineConfig,
+  getOfflineState,
+  getOfflineStore,
+  setOfflineState
+} from "./chunk-27LQDGNP.mjs";
+import {
+  getApiUrl
+} from "./chunk-DGWOVYEC.mjs";
+import {
+  __name
+} from "./chunk-PAWJFY3S.mjs";
+
+// src/offline/generic-answers.ts
+var DEFAULT_PAGE_SIZE = 25;
+function errorAnswer(status, title, detail, code) {
+  return {
+    status,
+    body: { errors: [{ status: String(status), ...code ? { code } : {}, title, detail }] }
+  };
+}
+__name(errorAnswer, "errorAnswer");
+function needsConnectionAnswer(detail = "Needs a connection") {
+  return errorAnswer(503, "Needs a connection", detail, "needs-connection");
+}
+__name(needsConnectionAnswer, "needsConnectionAnswer");
+function notFoundAnswer(detail) {
+  return errorAnswer(404, "Not found", detail);
+}
+__name(notFoundAnswer, "notFoundAnswer");
+async function singleAnswer(store, record, status = 200) {
+  return { status, body: { data: record.resource, included: await includedFor(store, [record]) } };
+}
+__name(singleAnswer, "singleAnswer");
+function isRootWriteLocked(rootId) {
+  return !!rootId && getOfflineState().lockedRootIds.includes(rootId);
+}
+__name(isRootWriteLocked, "isRootWriteLocked");
+function identifiersOf(relationship) {
+  const data = relationship?.data;
+  if (!data) return [];
+  return (Array.isArray(data) ? data : [data]).filter((item) => item && item.type && item.id);
+}
+__name(identifiersOf, "identifiersOf");
+function linkedIds(links, id) {
+  return links.map(
+    (link) => link.fromId === id ? { type: link.toType, id: link.toId } : { type: link.fromType, id: link.fromId }
+  );
+}
+__name(linkedIds, "linkedIds");
+function relationshipTargets(resource) {
+  const targets = [];
+  for (const relationship of Object.values(resource?.relationships ?? {})) {
+    const data = relationship?.data;
+    for (const ref of Array.isArray(data) ? data : data ? [data] : []) {
+      if (ref?.type && ref?.id) targets.push({ type: ref.type, id: ref.id });
+    }
+  }
+  return targets;
+}
+__name(relationshipTargets, "relationshipTargets");
+async function includedFor(store, records) {
+  const level = new Map(records.map((record) => [`${record.type}:${record.id}`, 0]));
+  const included = [];
+  const add = /* @__PURE__ */ __name(async (target, atLevel) => {
+    const key = `${target.type}:${target.id}`;
+    if (level.has(key)) return;
+    level.set(key, atLevel);
+    const stored = await store.getRecord(target.type, target.id);
+    const resource = stored?.resource ?? signedInUserResource(target);
+    if (resource) included.push({ resource, level: atLevel });
+  }, "add");
+  for (const record of records) {
+    const links = [...await store.linksFrom(record.id), ...await store.linksTo(record.id)];
+    for (const target of linkedIds(links, record.id)) await add(target, 1);
+  }
+  for (const record of records) {
+    for (const target of relationshipTargets(record.resource)) await add(target, 1);
+  }
+  for (const entry of included.filter((candidate) => candidate.level === 1)) {
+    for (const target of relationshipTargets(entry.resource)) await add(target, 2);
+  }
+  return included.map((entry) => entry.resource);
+}
+__name(includedFor, "includedFor");
+function signedInUserResource(target) {
+  try {
+    if (target.id !== getOfflineConfig().getUserId()) return void 0;
+    const stored = JSON.parse(window.localStorage.getItem(CURRENT_USER_STORAGE_KEY) ?? "null");
+    const user = stored?.jsonApi;
+    if (user?.type !== target.type || user?.id !== target.id) return void 0;
+    return { type: user.type, id: user.id, attributes: user.attributes ?? {}, meta: user.meta };
+  } catch {
+    return void 0;
+  }
+}
+__name(signedInUserResource, "signedInUserResource");
+function attributeOf(record, name) {
+  const value = record.resource?.attributes?.[name];
+  if (value !== void 0 && value !== null) return value;
+  if (name === "updatedAt") return record.updatedAt ?? null;
+  return value;
+}
+__name(attributeOf, "attributeOf");
+var SERVER_DEFAULT_ORDER_BY = "updatedAt DESC";
+var ORDER_BY = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s+(ASC|DESC))?$/i;
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}(T|$)/;
+function comparable(value) {
+  if (value instanceof Date) return value.getTime();
+  if (typeof value === "string" && ISO_DATE.test(value)) {
+    const time = Date.parse(value);
+    if (!Number.isNaN(time)) return time;
+  }
+  return value;
+}
+__name(comparable, "comparable");
+function compareAscending(left, right) {
+  const a = comparable(left);
+  const b = comparable(right);
+  const aNull = a === void 0 || a === null;
+  const bNull = b === void 0 || b === null;
+  if (aNull || bNull) return aNull === bNull ? 0 : aNull ? 1 : -1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "boolean" && typeof b === "boolean") return Number(a) - Number(b);
+  const x = String(a);
+  const y = String(b);
+  return x < y ? -1 : x > y ? 1 : 0;
+}
+__name(compareAscending, "compareAscending");
+function searchRecords(records, query, options = {}) {
+  const term = query.get("search");
+  if (term === null || term === void 0 || term.trim() === "") return records;
+  const tokens = term.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+  if (tokens.length === 0) return records;
+  return records.filter((record) => {
+    const attributes = record.resource?.attributes ?? {};
+    const fields = options.searchFields ?? Object.keys(attributes);
+    const texts = fields.map((field) => attributes[field]).filter((value) => typeof value === "string").map((value) => value.toLowerCase());
+    return tokens.every((token) => texts.some((text) => text.includes(token)));
+  });
+}
+__name(searchRecords, "searchRecords");
+function orderRecords(records, query, options = {}) {
+  const requested = query.get("orderBy")?.trim();
+  const value = requested || options.defaultOrderBy?.trim() || SERVER_DEFAULT_ORDER_BY;
+  const match = ORDER_BY.exec(value);
+  if (!match) return null;
+  const field = match[1];
+  const desc = match[2]?.toUpperCase() === "DESC";
+  return [...records].sort((left, right) => {
+    const order = compareAscending(attributeOf(left, field), attributeOf(right, field));
+    return desc ? -order : order;
+  });
+}
+__name(orderRecords, "orderRecords");
+function linkUrl(base, query, changes) {
+  const params = new URLSearchParams(query);
+  for (const [key, value] of Object.entries(changes)) {
+    if (value === void 0) params.delete(key);
+    else params.set(key, value);
+  }
+  const search = params.toString().replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/%2C/g, ",");
+  return search ? `${base}?${search}` : base;
+}
+__name(linkUrl, "linkUrl");
+async function listAnswer(ctx, records, options = {}) {
+  const { request, store } = ctx;
+  const base = request.url ? request.url.split("?")[0] : request.path;
+  const sorted = orderRecords(searchRecords(records, request.query, options), request.query, options);
+  if (!sorted) {
+    return errorAnswer(400, "Bad Request", "Invalid orderBy");
+  }
+  if (request.query.get("fetchAll") === "true") {
+    return {
+      status: 200,
+      body: {
+        data: sorted.map((record) => record.resource),
+        included: await includedFor(store, sorted),
+        links: { self: linkUrl(base, request.query, {}) },
+        meta: { total: sorted.length }
+      }
+    };
+  }
+  const size = Number(request.query.get("page[size]")) || DEFAULT_PAGE_SIZE;
+  const offset = Number(request.query.get("page[offset]")) || 0;
+  const page = sorted.slice(offset, offset + size);
+  const links = {
+    self: linkUrl(base, request.query, { "page[size]": String(size), "page[offset]": void 0 })
+  };
+  if (offset + size < sorted.length) {
+    links.next = linkUrl(base, request.query, { "page[size]": String(size), "page[offset]": String(offset + size) });
+  }
+  if (offset > 0) {
+    links.prev = linkUrl(base, request.query, {
+      "page[size]": String(size),
+      "page[offset]": String(Math.max(0, offset - size))
+    });
+    links.previous = links.prev;
+  }
+  return {
+    status: 200,
+    body: {
+      data: page.map((record) => record.resource),
+      included: await includedFor(store, page),
+      links,
+      meta: { total: sorted.length }
+    }
+  };
+}
+__name(listAnswer, "listAnswer");
+async function orderedListAnswer(store, records) {
+  return {
+    status: 200,
+    body: {
+      data: records.map((record) => record.resource),
+      included: await includedFor(store, records),
+      meta: { total: records.length }
+    }
+  };
+}
+__name(orderedListAnswer, "orderedListAnswer");
+function resourceListAnswer(resources) {
+  return { status: 200, body: { data: resources, included: [] } };
+}
+__name(resourceListAnswer, "resourceListAnswer");
+function listOptionsOf(typeConfig) {
+  return { searchFields: typeConfig.searchFields, defaultOrderBy: typeConfig.defaultOrderBy };
+}
+__name(listOptionsOf, "listOptionsOf");
+function linkKindFor(typeConfig, name) {
+  return typeConfig?.relationshipKinds?.[name] ?? name;
+}
+__name(linkKindFor, "linkKindFor");
+function linkKindsOf(typeConfig, name) {
+  const mapped = typeConfig?.relationshipKinds?.[name];
+  return mapped ? [name, mapped] : void 0;
+}
+__name(linkKindsOf, "linkKindsOf");
+async function linksOfKind(store, id, kinds, direction = "both") {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const kind of new Set(kinds)) {
+    const links = [
+      ...direction !== "in" ? await store.linksFrom(id, kind) : [],
+      ...direction !== "out" ? await store.linksTo(id, kind) : []
+    ];
+    for (const link of links) {
+      const key = `${link.fromId}|${link.toId}|${link.kind}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      result.push(link);
+    }
+  }
+  return result;
+}
+__name(linksOfKind, "linksOfKind");
+function typeConfigOf(config, type) {
+  return config.types.find((typeConfig) => typeConfig.module.name === type);
+}
+__name(typeConfigOf, "typeConfigOf");
+function relationshipNamesToward(resource, type) {
+  return Object.entries(resource?.relationships ?? {}).filter(([, relationship]) => identifiersOf(relationship).some((identifier) => identifier.type === type)).map(([name]) => name);
+}
+__name(relationshipNamesToward, "relationshipNamesToward");
+function notOnDeviceAnswer(type, id) {
+  return needsConnectionAnswer(`${type} ${id} is not on this device`);
+}
+__name(notOnDeviceAnswer, "notOnDeviceAnswer");
+async function getOne(ctx, type) {
+  const record = await ctx.store.getRecord(type, ctx.params.id);
+  if (!record) return notOnDeviceAnswer(type, ctx.params.id);
+  return singleAnswer(ctx.store, record);
+}
+__name(getOne, "getOne");
+async function rootList(ctx, config, typeConfig) {
+  const rootType = config.rootModule.name;
+  const rootId = ctx.params.rootId;
+  if (!await ctx.store.getRecord(rootType, rootId)) return notOnDeviceAnswer(rootType, rootId);
+  const records = await ctx.store.listRecords({ type: typeConfig.module.name, rootId });
+  return listAnswer(ctx, records, listOptionsOf(typeConfig));
+}
+__name(rootList, "rootList");
+async function relatedList(ctx, config, typeConfig) {
+  const type = typeConfig.module.name;
+  const { parentType, parentId } = ctx.params;
+  const parent = await ctx.store.getRecord(parentType, parentId);
+  if (!parent) return notOnDeviceAnswer(parentType, parentId);
+  const links = [...await ctx.store.linksFrom(parentId), ...await ctx.store.linksTo(parentId)].filter(
+    (link) => link.fromId === parentId ? link.toType === type : link.fromType === type
+  );
+  const candidates = await ctx.store.listRecords({
+    type,
+    ids: [...new Set(links.map((link) => link.fromId === parentId ? link.toId : link.fromId))]
+  });
+  const kinds = /* @__PURE__ */ new Set();
+  let anyKind = false;
+  const collect = /* @__PURE__ */ __name((owner, names) => {
+    for (const name of names) {
+      const known = linkKindsOf(owner, name);
+      if (known) known.forEach((kind) => kinds.add(kind));
+      else anyKind = true;
+    }
+  }, "collect");
+  collect(typeConfig, [
+    ...new Set(candidates.flatMap((record) => relationshipNamesToward(record.resource, parentType)))
+  ]);
+  collect(typeConfigOf(config, parentType), relationshipNamesToward(parent.resource, type));
+  const accepted = anyKind || kinds.size === 0 ? links : links.filter((link) => kinds.has(link.kind));
+  const ids = new Set(accepted.map((link) => link.fromId === parentId ? link.toId : link.fromId));
+  return listAnswer(
+    ctx,
+    candidates.filter((record) => ids.has(record.id)),
+    listOptionsOf(typeConfig)
+  );
+}
+__name(relatedList, "relatedList");
+async function rootIdForResource(store, config, resource) {
+  const rootType = config.rootModule.name;
+  if (resource?.type === rootType && resource.id) return resource.id;
+  const identifiers = Object.values(resource?.relationships ?? {}).flatMap(identifiersOf);
+  const root = identifiers.find((identifier) => identifier.type === rootType);
+  if (root) return root.id;
+  for (const identifier of identifiers) {
+    const stored = await store.getRecord(identifier.type, identifier.id);
+    if (stored?.rootId) return stored.rootId;
+  }
+  return void 0;
+}
+__name(rootIdForResource, "rootIdForResource");
+async function linkRelationships(store, typeConfig, record, before, after) {
+  for (const [name, relationship] of Object.entries(after)) {
+    const previous = new Map(identifiersOf(before[name]).map((identifier) => [identifier.id, identifier]));
+    const next = new Map(identifiersOf(relationship).map((identifier) => [identifier.id, identifier]));
+    const kinds = linkKindsOf(typeConfig, name);
+    for (const [id] of previous) {
+      if (next.has(id)) continue;
+      const links = kinds ? await linksOfKind(store, record.id, kinds, "both") : [...await store.linksFrom(record.id), ...await store.linksTo(record.id)];
+      for (const link of links) {
+        if (link.fromId === id || link.toId === id) {
+          await store.deleteLink({ fromId: link.fromId, toId: link.toId, kind: link.kind });
+        }
+      }
+    }
+    for (const [id, identifier] of next) {
+      if (previous.has(id)) continue;
+      await store.putLink({
+        fromType: record.type,
+        fromId: record.id,
+        toType: identifier.type,
+        toId: id,
+        kind: linkKindFor(typeConfig, name),
+        props: {}
+      });
+    }
+  }
+}
+__name(linkRelationships, "linkRelationships");
+function resourceFromDocument(document, identity) {
+  const data = document?.data ?? {};
+  const resource = { type: identity.type, id: identity.id };
+  if (data.attributes) resource.attributes = { ...data.attributes };
+  if (data.relationships) resource.relationships = { ...data.relationships };
+  if (data.meta) resource.meta = { ...data.meta };
+  return resource;
+}
+__name(resourceFromDocument, "resourceFromDocument");
+function mergeResource(before, identity, data) {
+  const previous = before ?? identity;
+  const resource = {
+    ...previous,
+    type: identity.type,
+    id: identity.id,
+    attributes: { ...previous.attributes ?? {}, ...data?.attributes ?? {} },
+    relationships: { ...previous.relationships ?? {}, ...data?.relationships ?? {} }
+  };
+  if (data?.meta) resource.meta = { ...previous.meta ?? {}, ...data.meta };
+  return resource;
+}
+__name(mergeResource, "mergeResource");
+function newId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  return `local-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+__name(newId, "newId");
+async function create(ctx, config, type) {
+  const typeConfig = typeConfigOf(config, type);
+  const id = ctx.request.body?.data?.id ?? newId();
+  const resource = resourceFromDocument(ctx.request.body, { type, id });
+  const rootId = await rootIdForResource(ctx.store, config, resource);
+  if (!rootId) return needsConnectionAnswer(`A new ${type} that belongs to no root record needs a connection`);
+  if (isRootWriteLocked(rootId)) return needsConnectionAnswer("The root record is locked");
+  const record = { type, id, rootId, resource, updatedAt: null, base: null, localOnly: true };
+  await ctx.store.transaction(async (store) => {
+    await store.putRecord(record);
+    await linkRelationships(store, typeConfig, { type, id }, {}, resource.relationships ?? {});
+    await store.enqueue({
+      rootId,
+      method: ctx.request.method,
+      path: queuePath(ctx),
+      body: ctx.request.body,
+      base: null
+    });
+  });
+  return singleAnswer(ctx.store, record, 201);
+}
+__name(create, "create");
+async function update(ctx, config, type) {
+  const id = ctx.params.id;
+  const existing = await ctx.store.getRecord(type, id);
+  if (!existing) return notOnDeviceAnswer(type, id);
+  if (isRootWriteLocked(existing.rootId)) return needsConnectionAnswer("The root record is locked");
+  const data = ctx.request.body?.data ?? {};
+  const before = existing.resource ?? { type, id };
+  const resource = mergeResource(before, { type, id }, data);
+  const base = existing.localOnly ? null : existing.base ?? before;
+  const record = { ...existing, resource, base, localOnly: existing.localOnly };
+  await ctx.store.transaction(async (store) => {
+    await store.putRecord(record);
+    await linkRelationships(
+      store,
+      typeConfigOf(config, type),
+      { type, id },
+      before.relationships ?? {},
+      data.relationships ?? {}
+    );
+    await store.enqueue({
+      rootId: existing.rootId,
+      method: ctx.request.method,
+      path: queuePath(ctx),
+      body: ctx.request.body,
+      recordType: type,
+      recordId: id,
+      base
+    });
+  });
+  return singleAnswer(ctx.store, record);
+}
+__name(update, "update");
+async function remove(ctx, type) {
+  const id = ctx.params.id;
+  const existing = await ctx.store.getRecord(type, id);
+  if (!existing) return notOnDeviceAnswer(type, id);
+  if (isRootWriteLocked(existing.rootId)) return needsConnectionAnswer("The root record is locked");
+  const base = existing.localOnly ? null : existing.base ?? existing.resource;
+  await ctx.store.transaction(async (store) => {
+    const links = [...await store.linksFrom(id), ...await store.linksTo(id)];
+    for (const link of links) await store.deleteLink({ fromId: link.fromId, toId: link.toId, kind: link.kind });
+    await store.deleteRecord(type, id);
+    await store.enqueue({
+      rootId: existing.rootId,
+      method: "DELETE",
+      path: queuePath(ctx),
+      recordType: type,
+      recordId: id,
+      base
+    });
+  });
+  return { status: 204, body: void 0 };
+}
+__name(remove, "remove");
+function queuePath(ctx) {
+  const query = ctx.request.query.toString();
+  return query ? `${ctx.request.path}?${query}` : ctx.request.path;
+}
+__name(queuePath, "queuePath");
+function readOnlyGuard(typeConfig, answer) {
+  return async (ctx) => typeConfig.readOnly ? needsConnectionAnswer(`${typeConfig.module.name} is read-only offline`) : answer(ctx);
+}
+__name(readOnlyGuard, "readOnlyGuard");
+function buildGenericRoutes(config) {
+  const routes = [];
+  const route = /* @__PURE__ */ __name((method, pattern, answer) => routes.push({ method, pattern, answer, queue: false }), "route");
+  for (const typeConfig of config.types) {
+    const type = typeConfig.module.name;
+    route("GET", [typeConfig.module, ":id"], (ctx) => getOne(ctx, type));
+    route("GET", [config.rootModule, ":rootId", typeConfig.module], (ctx) => rootList(ctx, config, typeConfig));
+    route(
+      "POST",
+      [typeConfig.module],
+      readOnlyGuard(typeConfig, (ctx) => create(ctx, config, type))
+    );
+    route(
+      "PUT",
+      [typeConfig.module, ":id"],
+      readOnlyGuard(typeConfig, (ctx) => update(ctx, config, type))
+    );
+    route(
+      "PATCH",
+      [typeConfig.module, ":id"],
+      readOnlyGuard(typeConfig, (ctx) => update(ctx, config, type))
+    );
+    route(
+      "DELETE",
+      [typeConfig.module, ":id"],
+      readOnlyGuard(typeConfig, (ctx) => remove(ctx, type))
+    );
+  }
+  for (const typeConfig of config.types) {
+    route("GET", [":parentType", ":parentId", typeConfig.module], (ctx) => relatedList(ctx, config, typeConfig));
+  }
+  return routes;
+}
+__name(buildGenericRoutes, "buildGenericRoutes");
+
+// src/offline/router.ts
+function splitPath(path) {
+  const withoutQuery = path.split("?")[0].split("#")[0];
+  return withoutQuery.split("/").filter((segment) => segment.length > 0);
+}
+__name(splitPath, "splitPath");
+function expandPattern(pattern) {
+  return pattern.flatMap((segment) => splitPath(typeof segment === "string" ? segment : segment.name));
+}
+__name(expandPattern, "expandPattern");
+function matchPattern(pattern, path) {
+  const expected = expandPattern(pattern);
+  const actual = splitPath(path);
+  if (expected.length !== actual.length) return null;
+  const params = {};
+  for (let index = 0; index < expected.length; index++) {
+    const segment = expected[index];
+    const value = decodeURIComponent(actual[index]);
+    if (segment.startsWith(":")) {
+      params[segment.slice(1)] = value;
+    } else if (segment !== value) {
+      return null;
+    }
+  }
+  return params;
+}
+__name(matchPattern, "matchPattern");
+function matchRoute(routes, method, path) {
+  for (const route of routes) {
+    if (route.method !== method) continue;
+    const params = matchPattern(route.pattern, path);
+    if (params) return { route, params };
+  }
+  return null;
+}
+__name(matchRoute, "matchRoute");
+
+// src/offline/local-transport.ts
+var METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+function apiBases() {
+  const bases = [];
+  for (const read of [getApiUrl, getClientApiUrl]) {
+    try {
+      const base = read();
+      if (base) bases.push(base);
+    } catch {
+    }
+  }
+  return bases;
+}
+__name(apiBases, "apiBases");
+function splitApiUrl(url) {
+  let relative;
+  for (const base of apiBases()) {
+    if (url.startsWith(base)) {
+      relative = url.slice(base.length);
+      break;
+    }
+  }
+  if (relative === void 0) {
+    try {
+      const parsed = new URL(url);
+      relative = `${parsed.pathname}${parsed.search}`;
+    } catch {
+      relative = url;
+    }
+  }
+  const [pathPart, ...queryParts] = relative.split("?");
+  return {
+    path: pathPart.replace(/^\/+/, "").replace(/\/+$/, ""),
+    query: new URLSearchParams(queryParts.join("?"))
+  };
+}
+__name(splitApiUrl, "splitApiUrl");
+function toApiData(answer) {
+  const ok = answer.status >= 200 && answer.status < 300;
+  return {
+    ok,
+    status: answer.status,
+    statusText: ok ? "OK" : answer.status === 503 ? "Service Unavailable" : "Error",
+    data: answer.body
+  };
+}
+__name(toApiData, "toApiData");
+async function rootIdForCustomWrite(store, pattern, params, rootSegmentParam) {
+  const config = getOfflineConfig();
+  if (rootSegmentParam && params[rootSegmentParam]) return params[rootSegmentParam];
+  for (const value of Object.values(params)) {
+    for (const typeConfig of config.types) {
+      const stored = await store.getRecord(typeConfig.module.name, value);
+      if (stored?.rootId) return stored.rootId;
+    }
+  }
+  return rootIdForResource(store, config, pattern.body?.data);
+}
+__name(rootIdForCustomWrite, "rootIdForCustomWrite");
+async function refreshPendingCount(store) {
+  const entries = await store.queue();
+  setOfflineState({ pending: entries.filter((entry) => entry.status !== "conflict").length });
+}
+__name(refreshPendingCount, "refreshPendingCount");
+async function localTransport(request) {
+  try {
+    const method = request.method.toUpperCase();
+    if (!METHODS.includes(method)) return toApiData(needsConnectionAnswer());
+    if (request.files) return toApiData(needsConnectionAnswer("Uploading files needs a connection"));
+    const config = getOfflineConfig();
+    const { path, query } = splitApiUrl(request.url);
+    const offlineRequest = { method, path, query, body: request.body, url: request.url };
+    const custom = matchRoute(config.routes, method, path);
+    const match = custom ?? matchRoute(buildGenericRoutes(config), method, path);
+    if (!match) return toApiData(needsConnectionAnswer(`${method} ${path} has no offline answer`));
+    let store;
+    try {
+      store = await getOfflineStore();
+    } catch (error) {
+      if (error instanceof NeedsConnectionError) return toApiData(needsConnectionAnswer(error.message));
+      console.warn("[offline] the device copy could not be opened", error);
+      return toApiData(needsConnectionAnswer("The device copy is not available in this tab"));
+    }
+    const ctx = { request: offlineRequest, params: match.params, store };
+    const customRootId = /* @__PURE__ */ __name(async (route) => {
+      const rootIndex = route.pattern.findIndex(
+        (segment) => typeof segment !== "string" && segment.name === config.rootModule.name
+      );
+      const next = rootIndex >= 0 ? route.pattern[rootIndex + 1] : void 0;
+      const rootParam = typeof next === "string" && next.startsWith(":") ? next.slice(1) : void 0;
+      return rootIdForCustomWrite(store, offlineRequest, match.params, rootParam);
+    }, "customRootId");
+    if (!custom || !custom.route.queue) {
+      if (custom && method !== "GET") {
+        const rootId2 = await customRootId(custom.route);
+        if (rootId2 && isRootWriteLocked(rootId2)) {
+          return toApiData(needsConnectionAnswer("The root record is locked"));
+        }
+      }
+      const answer2 = await match.route.answer(ctx);
+      if (method !== "GET") await refreshPendingCount(store);
+      return toApiData(answer2);
+    }
+    const rootId = await customRootId(custom.route);
+    if (!rootId) return toApiData(needsConnectionAnswer(`${method} ${path} belongs to no root record on this device`));
+    if (isRootWriteLocked(rootId)) return toApiData(needsConnectionAnswer("The root record is locked"));
+    const answer = await store.transaction(async (transactionStore) => {
+      const result = await custom.route.answer({ ...ctx, store: transactionStore });
+      if (result.status >= 200 && result.status < 300) {
+        await transactionStore.enqueue({
+          rootId,
+          method,
+          path: queuePath(ctx),
+          body: request.body,
+          base: null
+        });
+      }
+      return result;
+    });
+    await refreshPendingCount(store);
+    return toApiData(answer);
+  } catch (error) {
+    if (error instanceof NeedsConnectionError) return toApiData(needsConnectionAnswer(error.message));
+    console.error("[offline] local answer failed", error);
+    return toApiData({
+      status: 500,
+      body: {
+        errors: [{ status: "500", title: "Offline answer failed", detail: String(error?.message ?? error) }]
+      }
+    });
+  }
+}
+__name(localTransport, "localTransport");
+
+export {
+  errorAnswer,
+  needsConnectionAnswer,
+  notFoundAnswer,
+  singleAnswer,
+  includedFor,
+  SERVER_DEFAULT_ORDER_BY,
+  searchRecords,
+  orderRecords,
+  listAnswer,
+  orderedListAnswer,
+  resourceListAnswer,
+  linkKindFor,
+  linkKindsOf,
+  linksOfKind,
+  rootIdForResource,
+  resourceFromDocument,
+  mergeResource,
+  matchPattern,
+  matchRoute,
+  splitApiUrl,
+  localTransport
+};
+//# sourceMappingURL=chunk-7JZHPMGW.mjs.map