@carlonicora/nextjs-jsonapi 6.13.0 → 6.14.0

package/src/offline/sync/__tests__/sync-root.spec.ts

@@ -1,7 +1,19 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { DeviceStore } from "../../store/DeviceStore";
 import { RootSync } from "../models/RootSync";
-import { artwork, fakeCacheStorage, npc, setUpSync, syncTestConfig, tearDownSync, TestModel } from "./sync-fixtures";
+import {
+  artwork,
+  book,
+  bookTypes,
+  Books,
+  fakeCacheStorage,
+  npc,
+  page,
+  setUpSync,
+  syncTestConfig,
+  tearDownSync,
+  TestModel,
+} from "./sync-fixtures";
 
 const { JsonApiGet } = vi.hoisted(() => ({ JsonApiGet: vi.fn() }));
 vi.mock("../../../unified/JsonApiRequest", () => ({
@@ -724,4 +736,175 @@ describe("syncAll", () => {
     now.mockRestore();
     localStorage.clear();
   });
+
+  describe("extra root kinds", () => {
+    const bookSetUp = (
+      kind: Partial<{ listSyncRoots: () => Promise<string[]>; typeEndpoints: any; syncModule: any }> = {},
+      primaryRoots: () => Promise<string[]> = async () => [],
+    ) =>
+      setUpSync({
+        listSyncRoots: primaryRoots,
+        types: [...syncTestConfig().types, ...bookTypes],
+        extraRootKinds: [{ module: Books, listSyncRoots: async () => ["b1"], ...kind }],
+      });
+
+    it("syncAll syncs extra-kind roots from {module}/:rootId/sync", async () => {
+      tearDownSync();
+      store = await bookSetUp();
+      serve({
+        "books/b1/sync": syncAnswer({ entries: [entry("books", "b1"), entry("pages", "p1")] }, "b1"),
+        "books/b1": oneAnswer(book("b1")),
+        "books/b1/pages?fetchAll=true": listAnswer([page("p1", "First")]),
+      });
+
+      await syncAll();
+
+      expect(JsonApiGet.mock.calls.map((call) => call[0].endpoint)).toEqual([
+        "books/b1/sync",
+        "books/b1",
+        "books/b1/pages?fetchAll=true",
+      ]);
+      expect(await store.getRecord("pages", "p1")).toMatchObject({ rootId: "b1" });
+      expect(await store.getRecord("books", "b1")).toMatchObject({ rootId: "b1" });
+    });
+
+    it("syncAll keeps an extra-kind root when a campaign root is removed", async () => {
+      tearDownSync();
+      let primary = ["C"];
+      store = await bookSetUp({}, async () => primary);
+      const at = new Date("2026-10-31T10:00:00.000Z");
+      await store.putRecord({
+        type: "roots",
+        id: "C",
+        rootId: "C",
+        resource: { type: "roots", id: "C" },
+        updatedAt: at,
+      });
+      await store.putRecord({ type: "npcs", id: "n1", rootId: "C", resource: npc("n1", "N"), updatedAt: at });
+      await store.putRecord({ type: "books", id: "b1", rootId: "b1", resource: book("b1"), updatedAt: at });
+      await store.putRecord({ type: "pages", id: "p1", rootId: "b1", resource: page("p1", "P"), updatedAt: at });
+      await store.setSyncState("b1", {
+        serverTime: new Date("2026-11-01T00:00:00.000Z"),
+        locked: false,
+        lockedFrom: null,
+      });
+      serve({
+        "books/b1/sync": syncAnswer({ entries: [entry("books", "b1"), entry("pages", "p1")] }, "b1"),
+      });
+
+      primary = [];
+      await syncAll();
+
+      expect(await store.getRecord("roots", "C")).toBeUndefined();
+      expect(await store.getRecord("npcs", "n1")).toBeUndefined();
+      expect(await store.getRecord("books", "b1")).toBeDefined();
+      expect(await store.getRecord("pages", "p1")).toBeDefined();
+    });
+
+    it("typeEndpoints replace the type's fetch under that kind and get the stored root record", async () => {
+      tearDownSync();
+      store = await bookSetUp({
+        typeEndpoints: [
+          {
+            module: { name: "npcs", model: TestModel },
+            endpoint: (root: { id: string; resource: any }) =>
+              `roots/${root.resource.attributes.parent}/npcs/as-participant`,
+          },
+        ],
+      });
+      await store.setSyncState("b1", {
+        serverTime: new Date("2026-10-30T00:00:00.000Z"),
+        locked: false,
+        lockedFrom: null,
+      });
+      serve({
+        "books/b1/sync": syncAnswer({ entries: [entry("books", "b1"), entry("npcs", "n1")] }, "b1"),
+        "books/b1": oneAnswer(book("b1", { parent: "R9" })),
+        "roots/R9/npcs/as-participant": listAnswer([npc("n1", "Alda", "R9"), npc("other", "Other", "R9")]),
+      });
+
+      await syncAll();
+
+      expect(JsonApiGet.mock.calls.map((call) => call[0].endpoint)).toEqual([
+        "books/b1/sync",
+        "books/b1",
+        "roots/R9/npcs/as-participant",
+      ]);
+      expect(await store.getRecord("npcs", "n1")).toMatchObject({ rootId: "b1" });
+      expect(await store.getRecord("npcs", "other")).toBeUndefined();
+    });
+
+    it("typeEndpoints build from the stored root record when the root record did not change", async () => {
+      tearDownSync();
+      store = await bookSetUp({
+        typeEndpoints: [
+          {
+            module: { name: "npcs", model: TestModel },
+            endpoint: (root: { id: string; resource: any }) =>
+              `roots/${root.resource.attributes.parent}/npcs/as-participant`,
+          },
+        ],
+      });
+      await store.putRecord({
+        type: "books",
+        id: "b1",
+        rootId: "b1",
+        resource: book("b1", { parent: "R7" }),
+        updatedAt: new Date("2026-10-20T00:00:00.000Z"),
+      });
+      await store.setSyncState("b1", {
+        serverTime: new Date("2026-10-30T00:00:00.000Z"),
+        locked: false,
+        lockedFrom: null,
+      });
+      serve({
+        "books/b1/sync": syncAnswer(
+          { entries: [entry("books", "b1", "2026-10-20T00:00:00.000Z"), entry("npcs", "n1")] },
+          "b1",
+        ),
+        "roots/R7/npcs/as-participant": listAnswer([npc("n1", "Alda", "R7")]),
+      });
+
+      await syncAll();
+
+      expect(JsonApiGet.mock.calls.map((call) => call[0].endpoint)).toEqual([
+        "books/b1/sync",
+        "roots/R7/npcs/as-participant",
+      ]);
+      expect(await store.getRecord("npcs", "n1")).toMatchObject({ rootId: "b1" });
+    });
+
+    it("rootCount counts primary roots only; progress total counts all", async () => {
+      tearDownSync();
+      store = await bookSetUp({ listSyncRoots: async () => ["b1", "b2"] }, async () => ["C"]);
+      serve({
+        "roots/C/sync": syncAnswer({ entries: [] }),
+        "books/b1/sync": syncAnswer({ entries: [] }, "b1"),
+        "books/b2/sync": syncAnswer({ entries: [] }, "b2"),
+      });
+      const totals = new Set<number>();
+      const unsubscribe = subscribeOfflineState((state) => {
+        if (state.syncProgress) totals.add(state.syncProgress.total);
+      });
+
+      await syncAll();
+      unsubscribe();
+
+      expect([...totals]).toEqual([3]);
+      expect(getOfflineState().rootCount).toBe(1);
+      localStorage.clear();
+    });
+
+    it("an extra kind with syncModule reads its sync answer through that module", async () => {
+      tearDownSync();
+      const BookSyncs = { name: "book-syncs", model: RootSync };
+      store = await bookSetUp({ syncModule: BookSyncs });
+      serve({ "books/b1/sync": syncAnswer({ entries: [] }, "b1") });
+
+      await syncAll();
+
+      expect(JsonApiGet.mock.calls[0][0]).toMatchObject({ endpoint: "books/b1/sync", classKey: BookSyncs });
+      localStorage.clear();
+    });
+  });
 });

package/src/offline/sync/known-roots.ts

@@ -1,28 +1,50 @@
-import { getOfflineConfig, getOfflineStore } from "../config";
+import { getOfflineConfig, getOfflineStore, rootKinds } from "../config";
 import { setOfflineState } from "../state";
 import type { DeviceStore } from "../store/DeviceStore";
 import { isRootLocked } from "../store/lifecycle";
 
 let _lastSyncRoots: string[] = [];
+let _lastExtraSyncRoots: string[] = [];
 
-/** Remembers the root records the last online `listSyncRoots()` returned. */
-export function rememberSyncRoots(ids: string[]): void {
+/**
+ * Remembers the root records the last online sync listed: `ids` of every kind, `extraIds` those
+ * of the `extraRootKinds` among them.
+ */
+export function rememberSyncRoots(ids: string[], extraIds: string[] = []): void {
   _lastSyncRoots = [...ids];
+  _lastExtraSyncRoots = [...extraIds];
 }
 
 /**
- * Every root record the device knows of: its stored root records, the root records with waiting
- * changes, and the last sync roots (a locked root record is never downloaded, so it may have
- * no stored record).
+ * Every root record the device knows of, of every kind: its stored root records, the root records
+ * with waiting changes, and the last sync roots (a locked root record is never downloaded, so it
+ * may have no stored record).
  */
 export async function knownRootIds(store: DeviceStore): Promise<string[]> {
   const config = getOfflineConfig();
   const ids = new Set<string>(_lastSyncRoots);
-  for (const record of await store.listRecords({ type: config.rootModule.name })) ids.add(record.id);
+  for (const kind of rootKinds(config)) {
+    for (const record of await store.listRecords({ type: kind.module.name })) ids.add(record.id);
+  }
   for (const entry of await store.queue()) ids.add(entry.rootId);
   return [...ids].sort();
 }
 
+/** The known root records of the `extraRootKinds`: stored, or listed by the last sync. */
+async function extraRootIds(store: DeviceStore): Promise<Set<string>> {
+  const ids = new Set<string>(_lastExtraSyncRoots);
+  for (const kind of getOfflineConfig().extraRootKinds ?? []) {
+    for (const record of await store.listRecords({ type: kind.module.name })) ids.add(record.id);
+  }
+  return ids;
+}
+
+/** `knownRootIds` without the root records of the `extraRootKinds` (the primary kind only). */
+export async function knownPrimaryRootIds(store: DeviceStore): Promise<string[]> {
+  const extra = await extraRootIds(store);
+  return (await knownRootIds(store)).filter((id) => !extra.has(id));
+}
+
 /** Recomputes `lockedRootIds` from the stored sync states, now. */
 export async function refreshLockedRoots(): Promise<void> {
   const config = getOfflineConfig();

package/src/offline/sync/runtime.ts

@@ -14,7 +14,7 @@ import { getOfflineState, isReconnecting, setOfflineState, setReconnecting, subs
 import { OFFLINE_REPLAY_HEADER } from "../types";
 import { refreshOfflineCounts } from "./counts";
 import { drainQueue } from "./drain-queue";
-import { knownRootIds, refreshLockedRoots } from "./known-roots";
+import { knownPrimaryRootIds, refreshLockedRoots } from "./known-roots";
 import { ROOT_SYNC_ENDPOINT } from "./models/RootSync";
 import { currentLocale } from "./session-refresh";
 import { syncAll } from "./sync-root";
@@ -32,7 +32,8 @@ const PROBE_INTERVAL_MS = 30_000;
 async function probeApi(): Promise<boolean> {
   const config = getOfflineConfig();
   const store = await getOfflineStore();
-  const [rootId] = await knownRootIds(store);
+  // A root record of the primary kind only (the extra kinds' roots answer elsewhere).
+  const [rootId] = await knownPrimaryRootIds(store);
   const endpoint = rootId
     ? new EndpointCreator({ endpoint: config.rootModule, id: rootId, childEndpoint: ROOT_SYNC_ENDPOINT })
     : new EndpointCreator({ endpoint: config.rootModule }).addAdditionalParam("page[size]", "1");

package/src/offline/sync/sync-root.ts

@@ -2,9 +2,10 @@ import { EndpointCreator } from "../../core/endpoint/EndpointCreator";
 import { ApiRequestDataTypeInterface } from "../../core/interfaces/ApiRequestDataTypeInterface";
 import { Modules } from "../../core/registry/ModuleRegistry";
 import { JsonApiGet } from "../../unified/JsonApiRequest";
-import { getOfflineConfig, getOfflineStore, isOfflineConfigured, writeOfflineLastSync } from "../config";
+import { getOfflineConfig, getOfflineStore, isOfflineConfigured, rootKinds, writeOfflineLastSync } from "../config";
 import { canReachApi, setOfflineState } from "../state";
 import type { DeviceStore, SkippedRecord, StoredRecord } from "../store/DeviceStore";
+import type { OfflineRootKind } from "../types";
 import { cacheArtworkImage, imageUrlOf, removeArtworkImage } from "./artwork-cache";
 import { knownRootIds, refreshLockedRoots, rememberSyncRoots } from "./known-roots";
 import { ROOT_SYNC_ENDPOINT, RootSync } from "./models/RootSync";
@@ -75,18 +76,19 @@ async function removeRootIfIdle(store: DeviceStore, rootId: string): Promise<voi
  * are replaced, and artwork images are downloaded. The sync state is stored only once every
  * fetch succeeded (or answered 403/404). A record with a waiting change is never overwritten.
  */
-export async function syncRoot(rootId: string): Promise<void> {
+export async function syncRoot(rootId: string, kind?: OfflineRootKind): Promise<void> {
   const config = getOfflineConfig();
+  const rootKind = kind ?? rootKinds(config)[0];
   const store = await getOfflineStore();
   const previous = await store.getSyncState(rootId);
 
   const syncEndpoint = new EndpointCreator({
-    endpoint: config.rootModule,
+    endpoint: rootKind.module,
     id: rootId,
     childEndpoint: ROOT_SYNC_ENDPOINT,
   }).generate();
   const syncResponse = await JsonApiGet({
-    classKey: Modules.RootSync,
+    classKey: rootKind.syncModule ?? Modules.RootSync,
     endpoint: syncEndpoint,
     language: currentLocale(),
   });
@@ -146,16 +148,35 @@ export async function syncRoot(rootId: string): Promise<void> {
   // Records the answers include whose type the device does not sync itself (the root record's
   // owner): kept for display only, so a local answer can include them as the server does.
   const included: any[] = [];
-  for (const typeConfig of config.types) {
+  // The root record of the kind is fetched before the other types: a kind's `typeEndpoints` are
+  // built from it.
+  const rootTypeName = rootKind.module.name;
+  const orderedTypes = [
+    ...config.types.filter((typeConfig) => typeConfig.module.name === rootTypeName),
+    ...config.types.filter((typeConfig) => typeConfig.module.name !== rootTypeName),
+  ];
+  const rootResource = async (): Promise<StoredRecord["resource"]> => {
+    const fresh = fetched.find((resource) => resource?.type === rootTypeName && resource?.id === rootId);
+    if (fresh) return fresh;
+    const storedRoot = await store.getRecord(rootTypeName, rootId);
+    if (storedRoot) return storedRoot.resource;
+    throw new Error(`[offline] ${rootTypeName} ${rootId}: the root record is needed to build the type endpoints`);
+  };
+  for (const typeConfig of orderedTypes) {
     const changedOfType = changed.filter((entry) => entry.type === typeConfig.module.name);
     if (changedOfType.length === 0) continue;
 
-    if (typeConfig.fetch === "root-list") {
+    const typeEndpoint = rootKind.typeEndpoints?.find((candidate) => candidate.module.name === typeConfig.module.name);
+    if (typeEndpoint) {
+      // One full list read under this kind, never with `updatedSince`.
+      const endpoint = typeEndpoint.endpoint({ id: rootId, resource: await rootResource() });
+      fetched.push(...(await fetchResources(typeConfig.module, endpoint, skipped, included)));
+    } else if (typeConfig.fetch === "root-list") {
       // One list read per type. With `updatedSince` when every changed record is inside the
       // window; without it when a record older than the window is missing or stale on the
       // device, so the whole list comes in the same single request (never one read per record).
       const endpoint = new EndpointCreator({
-        endpoint: config.rootModule,
+        endpoint: rootKind.module,
         id: rootId,
         childEndpoint: typeConfig.module,
       }).addAdditionalParam("fetchAll", "true");
@@ -284,31 +305,61 @@ export async function syncRoot(rootId: string): Promise<void> {
 }
 
 /**
- * Syncs every root record `listSyncRoots()` returns, then removes from the device the root records
- * that are no longer roots (unless they still have waiting changes). Does nothing offline.
+ * Syncs every root record of every kind (`listSyncRoots()` of the primary kind and of each
+ * `extraRootKinds` entry), then removes from the device the known root records no kind lists
+ * (unless they still have waiting changes). A kind whose list throws keeps its device copy
+ * unchanged; the primary kind's list throwing stops the sync. Does nothing offline.
  */
 export async function syncAll(): Promise<void> {
   if (!isOfflineConfigured()) return;
   const config = getOfflineConfig();
   if (!config.getUserId() || !canReachApi()) return;
 
-  let roots: string[];
+  const [primaryKind, ...extraKinds] = rootKinds(config);
+  let primaryRoots: string[];
   try {
-    roots = await config.listSyncRoots();
+    primaryRoots = await primaryKind.listSyncRoots();
   } catch (error) {
     console.warn("[offline] could not list the root records to sync", error);
     return;
   }
+  const work: { rootId: string; kind: OfflineRootKind }[] = primaryRoots.map((rootId) => ({
+    rootId,
+    kind: primaryKind,
+  }));
+  const extraRoots: string[] = [];
+  // Kinds whose list failed: their stored roots are kept as they are.
+  const unlistedKinds: OfflineRootKind[] = [];
+  for (const kind of extraKinds) {
+    try {
+      const ids = await kind.listSyncRoots();
+      extraRoots.push(...ids);
+      work.push(...ids.map((rootId) => ({ rootId, kind })));
+    } catch (error) {
+      console.warn(`[offline] could not list the ${kind.module.name} root records to sync`, error);
+      unlistedKinds.push(kind);
+    }
+  }
   if (!canReachApi()) return;
-  rememberSyncRoots(roots);
+  const kept = new Set(work.map((item) => item.rootId));
+  if (unlistedKinds.length > 0) {
+    const store = await getOfflineStore();
+    for (const kind of unlistedKinds) {
+      for (const record of await store.listRecords({ type: kind.module.name })) {
+        kept.add(record.id);
+        extraRoots.push(record.id);
+      }
+    }
+  }
+  rememberSyncRoots([...kept], extraRoots);
 
-  const total = roots.length;
+  const total = work.length;
   setOfflineState({ syncProgress: { done: 0, total } });
   try {
     let done = 0;
-    for (const rootId of roots) {
+    for (const { rootId, kind } of work) {
       try {
-        await syncRoot(rootId);
+        await syncRoot(rootId, kind);
       } catch (error) {
         console.warn(`[offline] sync of root record ${rootId} failed`, error);
         if (!canReachApi()) return;
@@ -318,16 +369,16 @@ export async function syncAll(): Promise<void> {
       }
     }
 
-    // Every root record was tried: this counts as the device's last sync.
+    // Every root record was tried: this counts as the device's last sync. The root count is the
+    // primary kind's (shown as the number of root records, e.g. campaigns).
     const finishedAt = Date.now();
     const userId = config.getUserId();
     if (userId) writeOfflineLastSync(userId, finishedAt);
-    setOfflineState({ lastSyncedAt: finishedAt, rootCount: total });
+    setOfflineState({ lastSyncedAt: finishedAt, rootCount: primaryRoots.length });
 
     const store = await getOfflineStore();
-    const rootSet = new Set(roots);
     for (const rootId of await knownRootIds(store)) {
-      if (!rootSet.has(rootId)) await removeRootIfIdle(store, rootId);
+      if (!kept.has(rootId)) await removeRootIfIdle(store, rootId);
     }
     await refreshLockedRoots();
   } finally {

package/src/offline/types.ts

@@ -1,5 +1,5 @@
 import type { ApiRequestDataTypeInterface } from "../core/interfaces/ApiRequestDataTypeInterface";
-import type { DeviceStore } from "./store/DeviceStore";
+import type { DeviceStore, StoredRecord } from "./store/DeviceStore";
 
 /** Header of a request the server runs as an offline replay. Never answered locally. */
 export const OFFLINE_REPLAY_HEADER = "x-offline-replay";
@@ -31,6 +31,37 @@ export type OfflineLinkedListFetch = {
   endpoint: (rootId: string, target: { type: string; id: string }) => string;
 };
 
+/** One more kind of root record beside `rootModule` (e.g. a notebook). Optional. */
+export type OfflineRootKind = {
+  /** The module of the root records of this kind. Sync reads `{module}/:rootId/sync`. */
+  module: ApiRequestDataTypeInterface;
+  /** The ids of the roots of this kind to keep on the device. Throw to keep the device copy unchanged. */
+  listSyncRoots: () => Promise<string[]>;
+  /**
+   * Per record type, the full list endpoint (query string included) that downloads every record of
+   * that type under one root of this kind, built from the stored root record. Replaces the type's
+   * `fetch` mode under this kind only. Never given `updatedSince`.
+   */
+  typeEndpoints?: {
+    module: ApiRequestDataTypeInterface;
+    endpoint: (root: { id: string; resource: StoredRecord["resource"] }) => string;
+  }[];
+  /** The module whose model reads this kind's sync answer. Default: the library's `RootSync` module (`root-syncs`). */
+  syncModule?: ApiRequestDataTypeInterface;
+};
+
+type LocalWriteBase = { store: DeviceStore; module: ApiRequestDataTypeInterface; id: string }; // store = the write's transaction
+
+/** What a generic local write (`afterLocalWrite`) did, inside its transaction. */
+export type OfflineLocalWriteContext =
+  | (LocalWriteBase & { method: "POST"; resource: StoredRecord["resource"]; previous: null })
+  | (LocalWriteBase & {
+      method: "PUT" | "PATCH";
+      resource: StoredRecord["resource"];
+      previous: StoredRecord["resource"];
+    })
+  | (LocalWriteBase & { method: "DELETE"; resource: null; previous: StoredRecord["resource"] });
+
 export type OfflineTypeConfig = {
   module: ApiRequestDataTypeInterface;
   /**
@@ -53,6 +84,11 @@ export type OfflineTypeConfig = {
   searchFields?: string[];
   /** The server's order with no `orderBy` (default `updatedAt DESC`). */
   defaultOrderBy?: string;
+  /**
+   * Called by the generic POST/PUT/PATCH/DELETE local answers inside the same transaction as the
+   * write and the enqueue (a throw rolls both back). Never called by sync or write-through.
+   */
+  afterLocalWrite?: (ctx: OfflineLocalWriteContext) => Promise<void>;
 };
 
 export type OfflineConfig = {
@@ -68,6 +104,8 @@ export type OfflineConfig = {
   routes: OfflineRoute[];
   /** Ids of the root records to keep on the device. */
   listSyncRoots: () => Promise<string[]>;
+  /** More kinds of root records beside `rootModule`, each synced and kept on its own (optional). */
+  extraRootKinds?: OfflineRootKind[];
   shellPath: (locale: string) => string;
   syncIntervalMs: number;
   /**

package/src/offline/write-through.ts

@@ -1,5 +1,5 @@
 import type { ApiData } from "../core/interfaces/ApiData";
-import { getOfflineConfig, getOfflineStore, OfflineUnavailableError } from "./config";
+import { getOfflineConfig, getOfflineStore, OfflineUnavailableError, rootKinds } from "./config";
 import { rootIdForResource, linkKindFor, linkKindsOf, linksOfKind } from "./generic-answers";
 import { splitApiUrl } from "./local-transport";
 import { matchPattern } from "./router";
@@ -158,8 +158,11 @@ export async function writeThrough(request: WriteThroughRequest, response: ApiDa
       return;
     }
 
-    const rootParams = matchPattern([config.rootModule, ":rootId"], path.split("/").slice(0, 2).join("/"));
-    const pathRootId = rootParams?.rootId;
+    // A path under a root record of any kind (`<root module>/:rootId/...`).
+    const rootSegments = path.split("/").slice(0, 2).join("/");
+    const pathRootId = rootKinds(config)
+      .map((kind) => matchPattern([kind.module, ":rootId"], rootSegments)?.rootId)
+      .find((rootId) => rootId !== undefined);
 
     const document = response.data;
     const primary = Array.isArray(document?.data) ? document.data : document?.data ? [document.data] : [];

package/dist/JsonApiRequest-WISJZSDE.js

@@ -1,26 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-
-
-
-
-var _chunkQKNGZDSQjs = require('./chunk-QKNGZDSQ.js');
-require('./chunk-7QVYU63E.js');
-
-
-
-
-
-
-
-
-
-
-
-exports.JsonApiDelete = _chunkQKNGZDSQjs.JsonApiDelete; exports.JsonApiGet = _chunkQKNGZDSQjs.JsonApiGet; exports.JsonApiPatch = _chunkQKNGZDSQjs.JsonApiPatch; exports.JsonApiPost = _chunkQKNGZDSQjs.JsonApiPost; exports.JsonApiPut = _chunkQKNGZDSQjs.JsonApiPut; exports.buildUrl = _chunkQKNGZDSQjs.buildUrl; exports.configureJsonApi = _chunkQKNGZDSQjs.configureJsonApi; exports.getApiUrl = _chunkQKNGZDSQjs.getApiUrl; exports.getAppUrl = _chunkQKNGZDSQjs.getAppUrl; exports.getTrackablePages = _chunkQKNGZDSQjs.getTrackablePages;
-//# sourceMappingURL=JsonApiRequest-WISJZSDE.js.map

package/dist/chunk-27LQDGNP.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/offline/state.ts","../src/offline/types.ts","../src/offline/config.ts"],"sourcesContent":["// Kept free of React: `directFetch` (every entry, server ones included) imports this module.\n// The hooks live in state-hooks.ts, exported only from the `./offline` entry.\n\nexport type OfflineState = {\n  online: boolean;\n  pending: number;\n  conflicts: number;\n  draining: boolean;\n  lockedRootIds: string[];\n  /**\n   * False once this browser was found unable to keep the device copy (no secure context, no\n   * private file storage, or the worker reports the OPFS APIs missing). Offline mode is then off\n   * for the rest of the page: `isOfflineConfigured()` answers false and nothing offline runs.\n   */\n  available: boolean;\n  /**\n   * Offline mode is on on this device for the signed-in user. Always true once configured\n   * without `OfflineConfig.requireOptIn`; otherwise the GM's per-device switch.\n   */\n  enabled: boolean;\n  /** The running full sync: root records done out of the total, null when no sync runs. */\n  syncProgress: { done: number; total: number } | null;\n  /** When the last full sync on this device finished (epoch ms), null when never. */\n  lastSyncedAt: number | null;\n  /** How many root records the last full sync kept on this device, null when unknown. */\n  rootCount: number | null;\n};\n\nexport const SERVER_SNAPSHOT: OfflineState = {\n  online: true,\n  pending: 0,\n  conflicts: 0,\n  draining: false,\n  lockedRootIds: [],\n  available: true,\n  enabled: false,\n  syncProgress: null,\n  lastSyncedAt: null,\n  rootCount: null,\n};\n\nlet _state: OfflineState = { ...SERVER_SNAPSHOT };\nconst _listeners = new Set<(s: OfflineState) => void>();\nlet _detachBrowserEvents: (() => void) | null = null;\n\nexport function getOfflineState(): OfflineState {\n  return _state;\n}\n\nexport function subscribeOfflineState(listener: (s: OfflineState) => void): () => void {\n  _listeners.add(listener);\n  return () => {\n    _listeners.delete(listener);\n  };\n}\n\nfunction sameValue(a: unknown, b: unknown): boolean {\n  if (Array.isArray(a) && Array.isArray(b)) {\n    return a.length === b.length && a.every((value, index) => value === b[index]);\n  }\n  return a === b;\n}\n\n// A reconnect attempt: a probe reached the API while the session is offline. The session stays\n// offline (spec § 4: offline \"until a sync succeeds\") while the drain and the sync run; their\n// reads and the change-set request go to the network meanwhile (`reachesNetworkWhileOffline`).\n// Any network failure (`online: false` set again) ends the attempt.\nlet _reconnecting = false;\nconst _passThroughUrls = new Set<string>();\n\n/** Whether a reconnect attempt (drain then sync, after a probe reached the API) is running. */\nexport function isReconnecting(): boolean {\n  return _reconnecting;\n}\n\n/** Starts or ends a reconnect attempt (the offline runtime). */\nexport function setReconnecting(value: boolean): void {\n  _reconnecting = value;\n  if (!value) _passThroughUrls.clear();\n}\n\n/** Lets one write (the drain's change-set request) reach the network during a reconnect attempt. */\nexport function allowWhileReconnecting(url: string): () => void {\n  _passThroughUrls.add(url);\n  return () => {\n    _passThroughUrls.delete(url);\n  };\n}\n\n/**\n * While the session is offline, whether a request still goes to the network: only during a\n * reconnect attempt, for a GET or a write the attempt let through. Any other write stays local\n * (queued), so it is sent after the waiting changes, in order.\n */\nexport function reachesNetworkWhileOffline(method: string, url: string): boolean {\n  if (!_reconnecting) return false;\n  return method.toUpperCase() === \"GET\" || _passThroughUrls.has(url);\n}\n\n/** The sync and the drain may talk to the API: online, or during a reconnect attempt. */\nexport function canReachApi(): boolean {\n  return _state.online || _reconnecting;\n}\n\n/** Applies a partial change. Listeners run once, and only when a value actually changed. */\nexport function setOfflineState(patch: Partial<OfflineState>): void {\n  if (patch.online === false) setReconnecting(false);\n  const changed = (Object.keys(patch) as (keyof OfflineState)[]).some(\n    (key) => patch[key] !== undefined && !sameValue(patch[key], _state[key]),\n  );\n  if (!changed) return;\n\n  _state = { ..._state, ...patch };\n  for (const listener of [..._listeners]) listener(_state);\n}\n\n/**\n * Follows the browser's offline event. Called by `configureOffline`, never at import, so an app\n * that does not opt in gets no listener. The browser's online event alone never brings the\n * session back online (spec § 4: offline \"until a sync succeeds\"): the runtime probes the API on\n * that event and goes online only when the probe reaches it.\n */\nexport function attachBrowserOnlineEvents(): void {\n  if (_detachBrowserEvents || typeof window === \"undefined\") return;\n\n  if (typeof navigator !== \"undefined\" && typeof navigator.onLine === \"boolean\") {\n    setOfflineState({ online: navigator.onLine });\n  }\n\n  const onOffline = () => setOfflineState({ online: false });\n  window.addEventListener(\"offline\", onOffline);\n  _detachBrowserEvents = () => {\n    window.removeEventListener(\"offline\", onOffline);\n  };\n}\n\n/** Test helper: back to the initial state, browser events detached, listeners kept. */\nexport function resetOfflineState(): void {\n  _detachBrowserEvents?.();\n  _detachBrowserEvents = null;\n  setReconnecting(false);\n  _state = { ...SERVER_SNAPSHOT };\n}\n","import type { ApiRequestDataTypeInterface } from \"../core/interfaces/ApiRequestDataTypeInterface\";\nimport type { DeviceStore } from \"./store/DeviceStore\";\n\n/** Header of a request the server runs as an offline replay. Never answered locally. */\nexport const OFFLINE_REPLAY_HEADER = \"x-offline-replay\";\n\nexport type OfflineMethod = \"GET\" | \"POST\" | \"PUT\" | \"PATCH\" | \"DELETE\";\n\n/** A Module (matched by its endpoint), a \":param\" capture, or a literal segment (\"playing\", \"merge\"). */\nexport type PatternSegment = ApiRequestDataTypeInterface | string;\n\n/** `url` (beyond the contract, optional): the absolute URL the request was made to, for the `links` of a list. */\nexport type OfflineRequest = { method: OfflineMethod; path: string; query: URLSearchParams; body?: any; url?: string };\n\n/** `body` is a JSON:API document, `undefined` for a 204. */\nexport type OfflineAnswer = { status: number; body: any };\n\nexport type LocalAnswerContext = { request: OfflineRequest; params: Record<string, string>; store: DeviceStore };\n\nexport type LocalAnswer = (ctx: LocalAnswerContext) => Promise<OfflineAnswer>;\n\nexport type OfflineRoute = { method: OfflineMethod; pattern: PatternSegment[]; answer: LocalAnswer; queue: boolean };\n\n/**\n * A type the API reads only as a list per target record: each changed record's target is the\n * other end of its sync link of `linkKind` (from the record to the target), and `endpoint`\n * builds that target's list path with `EndpointCreator`.\n */\nexport type OfflineLinkedListFetch = {\n  linkKind: string;\n  endpoint: (rootId: string, target: { type: string; id: string }) => string;\n};\n\nexport type OfflineTypeConfig = {\n  module: ApiRequestDataTypeInterface;\n  /**\n   * How the sync fetches the type's changed records: the root record's list (`root-list`), one\n   * GET per record (`by-id`), or (`linked-list`) the list of each record's target, found through\n   * the sync answer's links of `linkedList.linkKind` (e.g. player notes, read per target only).\n   */\n  fetch: \"root-list\" | \"by-id\" | \"linked-list\";\n  /** Required with `fetch: \"linked-list\"`. */\n  linkedList?: OfflineLinkedListFetch;\n  readOnly: boolean;\n  serverOwnedFields: string[];\n  /**\n   * Relationship name → Neo4j relationship type (`faction` → `MEMBER_OF`). A link the device\n   * writes from a request's relationships carries the mapped type, the kind synced links carry;\n   * an unmapped name is stored as the name itself.\n   */\n  relationshipKinds?: Record<string, string>;\n  /** The string attributes the server's fulltext index covers (default: every string attribute). */\n  searchFields?: string[];\n  /** The server's order with no `orderBy` (default `updatedAt DESC`). */\n  defaultOrderBy?: string;\n};\n\nexport type OfflineConfig = {\n  getUserId: () => string | undefined;\n  /**\n   * Offline mode is off on each device until the user turns it on (`turnOnOffline`), stored per\n   * user per device. Default (undefined/false): always on, every device keeps the copy.\n   */\n  requireOptIn?: boolean;\n  /** The module whose records own every other record (in Wyrdli, Modules.Campaign). */\n  rootModule: ApiRequestDataTypeInterface;\n  types: OfflineTypeConfig[];\n  routes: OfflineRoute[];\n  /** Ids of the root records to keep on the device. */\n  listSyncRoots: () => Promise<string[]>;\n  shellPath: (locale: string) => string;\n  syncIntervalMs: number;\n  /**\n   * Where the device worker loads SQLite from at run time (default `/offline-sqlite/index.mjs`).\n   * SQLite is never bundled: its own helper worker uses a computed URL that app bundlers refuse.\n   * The app serves the files of `dist/offline/sqlite/` at this URL's folder.\n   */\n  sqliteModuleUrl?: string;\n  /**\n   * Where the device-copy worker is started from (default `/offline-sqlite/device-worker.mjs`).\n   * It is a standalone file in `dist/offline/sqlite/`, never bundled by the app.\n   */\n  deviceWorkerUrl?: string;\n};\n\nexport const DEFAULT_SQLITE_MODULE_URL = \"/offline-sqlite/index.mjs\";\nexport const DEVICE_WORKER_FILE = \"device-worker.mjs\";\nexport const DEFAULT_DEVICE_WORKER_URL = `/offline-sqlite/${DEVICE_WORKER_FILE}`;\n\n/**\n * The files of `dist/offline/sqlite/` the app serves: the device worker and the SQLite files\n * copied from @sqlite.org/sqlite-wasm.\n */\nexport const OFFLINE_SQLITE_FILES = [\n  DEVICE_WORKER_FILE,\n  \"index.mjs\",\n  \"sqlite3.wasm\",\n  \"sqlite3-opfs-async-proxy.js\",\n] as const;\n\n/** Thrown by a local answer for something that only the server can do. Answered as a 503 \"needs-connection\". */\nexport class NeedsConnectionError extends Error {\n  readonly status = 503;\n  readonly code = \"needs-connection\";\n\n  constructor(message: string = \"Needs a connection\") {\n    super(message);\n    this.name = \"NeedsConnectionError\";\n  }\n}\n\n/** Segments joined with \"/\", modules by their endpoint. */\nexport function patternToString(pattern: PatternSegment[]): string {\n  return pattern.map((segment) => (typeof segment === \"string\" ? segment : segment.name)).join(\"/\");\n}\n","import { attachBrowserOnlineEvents, getOfflineState, setOfflineState } from \"./state\";\nimport type { DeviceStore } from \"./store/DeviceStore\";\nimport {\n  DEFAULT_DEVICE_WORKER_URL,\n  DEFAULT_SQLITE_MODULE_URL,\n  NeedsConnectionError,\n  type OfflineConfig,\n} from \"./types\";\n\n// Kept free of store, worker and React imports: `directFetch` reads `isOfflineConfigured()` on\n// every request, so this module is the only offline code an app that never opts in loads.\n\nlet _config: OfflineConfig | null = null;\nlet _opener: ((userId: string) => Promise<DeviceStore>) | null = null;\n// Registered by the `./offline` entry (configure.ts), so the store code is reachable only from it.\nlet _defaultOpener: ((userId: string) => Promise<DeviceStore>) | null = null;\nconst _stores = new Map<string, Promise<DeviceStore>>();\n// Users whose device store must not be opened again (logged out) until they sign in again.\nconst _blockedUsers = new Set<string>();\n// Per user: whether offline mode is on on this device (`requireOptIn`). Read from localStorage\n// once, since `isOfflineConfigured()` runs on every request.\nconst _enabledCache = new Map<string, boolean>();\n\nconst ENABLED_KEY_PREFIX = \"nja-offline-enabled:\";\nconst LAST_SYNC_KEY_PREFIX = \"nja-offline-last-sync:\";\n\nfunction readStorage(key: string): string | null {\n  try {\n    return typeof localStorage === \"undefined\" ? null : localStorage.getItem(key);\n  } catch {\n    return null;\n  }\n}\n\nfunction writeStorage(key: string, value: string | null): void {\n  try {\n    if (typeof localStorage === \"undefined\") return;\n    if (value === null) localStorage.removeItem(key);\n    else localStorage.setItem(key, value);\n  } catch {\n    // Storage can be blocked or full: the switch then lasts for this page only.\n  }\n}\n\n/**\n * The signed-in user's device store cannot be used: it could not be opened (opfs-sahpool holds\n * one connection per origin, so a second tab cannot open it) or the user logged out. A request\n * answered from the device copy then needs a connection (503 \"needs-connection\").\n */\nexport class DeviceStoreUnavailableError extends NeedsConnectionError {\n  constructor(message: string = \"The device copy is not available in this tab\") {\n    super(message);\n    this.name = \"DeviceStoreUnavailableError\";\n  }\n}\n\n/**\n * This browser cannot keep the device copy at all: not a secure context (https or `localhost`),\n * no private file storage (`navigator.storage.getDirectory`), or the worker reports the OPFS\n * APIs missing. Offline mode switches off for the page (`markOfflineUnavailable`). A failure on\n * a browser that can keep the copy (the file held by another tab) is a `DeviceStoreUnavailableError`.\n */\nexport class OfflineUnavailableError extends DeviceStoreUnavailableError {\n  constructor(reason: string) {\n    super(`Offline mode isn't available in this browser: ${reason}`);\n    this.name = \"OfflineUnavailableError\";\n  }\n}\n\n/**\n * Switches offline mode off for this page, once: one console warning, `available: false` in the\n * offline state. From then on `isOfflineConfigured()` answers false, so no request, sync, drain,\n * write-through or lock check touches the device copy again.\n */\nexport function markOfflineUnavailable(error: OfflineUnavailableError): void {\n  if (!getOfflineState().available) return;\n  console.warn(`[offline] ${error.message}. Offline mode is off in this browser.`);\n  setOfflineState({ available: false });\n}\n\n/** Whether this browser can keep the device copy (true until found otherwise). */\nexport function isOfflineAvailable(): boolean {\n  return getOfflineState().available;\n}\n\n/** Logout: the user's store is never opened again in this page until `unblockOfflineStore`. */\nexport function blockOfflineStore(userId: string): void {\n  _blockedUsers.add(userId);\n  _stores.delete(userId);\n}\n\n/** A sign-in (`onUserSignedIn`): the user's store may be opened again. */\nexport function unblockOfflineStore(userId: string): void {\n  _blockedUsers.delete(userId);\n}\n\nexport function isOfflineStoreBlocked(userId: string): boolean {\n  return _blockedUsers.has(userId);\n}\n\n/** Opts the app into offline mode. Without this call nothing offline runs. */\nexport function configureOffline(config: OfflineConfig): void {\n  _config = config;\n  attachBrowserOnlineEvents();\n  refreshOfflineDeviceState();\n}\n\n/**\n * Configured, the browser can keep the device copy (see `markOfflineUnavailable`), and offline\n * mode is on on this device for the signed-in user (see `requireOptIn`).\n */\nexport function isOfflineConfigured(): boolean {\n  return _config !== null && isOfflineAvailable() && isOfflineEnabledOnDevice(_config.getUserId());\n}\n\n/**\n * Whether offline mode is on on this device for `userId`. Always true without\n * `OfflineConfig.requireOptIn`; otherwise the stored switch, false with no user.\n */\nexport function isOfflineEnabledOnDevice(userId?: string | null): boolean {\n  if (!_config?.requireOptIn) return true;\n  if (!userId) return false;\n  let enabled = _enabledCache.get(userId);\n  if (enabled === undefined) {\n    enabled = readStorage(ENABLED_KEY_PREFIX + userId) === \"1\";\n    _enabledCache.set(userId, enabled);\n  }\n  return enabled;\n}\n\n/** Stores the device switch for `userId` (`turnOnOffline` / `turnOffOffline`). */\nexport function setOfflineEnabledOnDevice(userId: string, enabled: boolean): void {\n  writeStorage(ENABLED_KEY_PREFIX + userId, enabled ? \"1\" : null);\n  _enabledCache.set(userId, enabled);\n}\n\n/** When `userId`'s last full sync on this device finished (epoch ms), or null. */\nexport function readOfflineLastSync(userId: string): number | null {\n  const value = Number(readStorage(LAST_SYNC_KEY_PREFIX + userId));\n  return Number.isFinite(value) && value > 0 ? value : null;\n}\n\n/** Stores, or with null removes, when `userId`'s last full sync finished. */\nexport function writeOfflineLastSync(userId: string, at: number | null): void {\n  writeStorage(LAST_SYNC_KEY_PREFIX + userId, at === null ? null : String(at));\n}\n\n/**\n * Reads the device switch and the last sync time of the signed-in user into the offline state\n * (`enabled`, `lastSyncedAt`). Does nothing before `configureOffline`.\n */\nexport function refreshOfflineDeviceState(): void {\n  if (!_config) return;\n  const userId = _config.getUserId();\n  if (userId) _enabledCache.delete(userId);\n  setOfflineState({\n    enabled: isOfflineEnabledOnDevice(userId),\n    lastSyncedAt: userId ? readOfflineLastSync(userId) : null,\n  });\n}\n\nexport function getOfflineConfig(): OfflineConfig {\n  if (!_config) throw new Error(\"Offline mode is not configured. Call configureOffline() first.\");\n  return _config;\n}\n\n/** The browser opener, set by the `./offline` entry's `configureOffline`. */\nexport function setDefaultDeviceStoreOpener(opener: (userId: string) => Promise<DeviceStore>): void {\n  _defaultOpener = opener;\n}\n\n/** The URL the device worker loads SQLite from (`OfflineConfig.sqliteModuleUrl`). */\nexport function getSqliteModuleUrl(): string {\n  return _config?.sqliteModuleUrl ?? DEFAULT_SQLITE_MODULE_URL;\n}\n\n/** The URL the device worker is started from (`OfflineConfig.deviceWorkerUrl`). */\nexport function getDeviceWorkerUrl(): string {\n  return _config?.deviceWorkerUrl ?? DEFAULT_DEVICE_WORKER_URL;\n}\n\n/** Replaces how a user's device store is opened (tests pass `openMemoryDeviceStore`). */\nexport function setDeviceStoreOpener(opener: ((userId: string) => Promise<DeviceStore>) | null): void {\n  _opener = opener;\n  _stores.clear();\n}\n\n/**\n * The signed-in user's device store, opened once per user id. Only the signed-in user's file is\n * ever opened; with no signed-in user the request needs a connection.\n */\nexport async function getOfflineStore(): Promise<DeviceStore> {\n  const userId = getOfflineConfig().getUserId();\n  if (!userId) throw new NeedsConnectionError(\"No signed-in user\");\n  if (!isOfflineEnabledOnDevice(userId)) throw new DeviceStoreUnavailableError(\"Offline mode is off on this device\");\n  if (_blockedUsers.has(userId)) throw new DeviceStoreUnavailableError(\"The device copy was deleted at logout\");\n  if (!isOfflineAvailable()) throw new OfflineUnavailableError(\"it was found unable to keep the device copy\");\n\n  let store = _stores.get(userId);\n  if (!store) {\n    const opener = _opener ?? _defaultOpener;\n    if (!opener) throw new Error(\"No device store opener: configure offline mode through the ./offline entry.\");\n    store = opener(userId).catch((error) => {\n      if (error instanceof OfflineUnavailableError) markOfflineUnavailable(error);\n      if (error instanceof NeedsConnectionError) throw error;\n      console.warn(\"[offline] the device copy could not be opened\", error);\n      throw new DeviceStoreUnavailableError(\n        `The device copy could not be opened: ${String((error as Error)?.message ?? error)}`,\n      );\n    });\n    _stores.set(userId, store);\n    store.catch(() => _stores.delete(userId));\n  }\n  return store;\n}\n\n/** Forgets the opened store of a user (logout, deleted file). */\nexport function forgetOfflineStore(userId: string): void {\n  _stores.delete(userId);\n}\n\n/** Test helper: back to \"not configured\". */\nexport function resetOfflineConfig(): void {\n  _config = null;\n  _opener = null;\n  _stores.clear();\n  _blockedUsers.clear();\n  _enabledCache.clear();\n}\n"],"mappings":"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","names":[]}