@carlonicora/nextjs-jsonapi 6.12.1 → 6.13.0

package/dist/offline/index.mjs

@@ -0,0 +1,1052 @@
+"use client";
+import {
+  knownRootIds,
+  recordKeyOf,
+  recordKeysOfEntry,
+  refreshLockedRoots,
+  rememberSyncRoots,
+  waitingRecordKeys,
+  writeThrough
+} from "../chunk-YRKIFYOE.mjs";
+import {
+  cacheArtworkImage,
+  deleteDeviceStore,
+  deleteImagesCaches,
+  hasUnsentChanges,
+  imageUrlOf,
+  isRootLocked,
+  onUserSignedIn,
+  openDeviceStore,
+  openMemoryDeviceStore,
+  removeArtworkImage
+} from "../chunk-7DBJTNSU.mjs";
+import {
+  SERVER_DEFAULT_ORDER_BY,
+  errorAnswer,
+  includedFor,
+  linkKindFor,
+  linkKindsOf,
+  linksOfKind,
+  listAnswer,
+  localTransport,
+  matchPattern,
+  matchRoute,
+  mergeResource,
+  needsConnectionAnswer,
+  notFoundAnswer,
+  orderRecords,
+  orderedListAnswer,
+  resourceFromDocument,
+  resourceListAnswer,
+  searchRecords,
+  singleAnswer
+} from "../chunk-7JZHPMGW.mjs";
+import {
+  useNeedsConnection,
+  useOfflineState
+} from "../chunk-XXP3TQHF.mjs";
+import {
+  EndpointCreator,
+  Modules,
+  ROOT_SYNC_ENDPOINT,
+  getI18nDefaultLocale,
+  getI18nSupportedLocales
+} from "../chunk-6JUCIWDC.mjs";
+import "../chunk-DOCIFE6A.mjs";
+import {
+  directFetch
+} from "../chunk-ZLTOUZN2.mjs";
+import {
+  DEFAULT_DEVICE_WORKER_URL,
+  DEFAULT_SQLITE_MODULE_URL,
+  DEVICE_WORKER_FILE,
+  DeviceStoreUnavailableError,
+  NeedsConnectionError,
+  OFFLINE_REPLAY_HEADER,
+  OFFLINE_SQLITE_FILES,
+  OfflineUnavailableError,
+  allowWhileReconnecting,
+  blockOfflineStore,
+  canReachApi,
+  configureOffline,
+  forgetOfflineStore,
+  getOfflineConfig,
+  getOfflineState,
+  getOfflineStore,
+  isOfflineAvailable,
+  isOfflineConfigured,
+  isOfflineEnabledOnDevice,
+  isReconnecting,
+  patternToString,
+  refreshOfflineDeviceState,
+  setDefaultDeviceStoreOpener,
+  setDeviceStoreOpener,
+  setOfflineEnabledOnDevice,
+  setOfflineState,
+  setReconnecting,
+  subscribeOfflineState,
+  writeOfflineLastSync
+} from "../chunk-27LQDGNP.mjs";
+import {
+  JsonApiGet,
+  JsonApiPost,
+  buildUrl
+} from "../chunk-DGWOVYEC.mjs";
+import {
+  getClientToken
+} from "../chunk-AUXK7QSA.mjs";
+import {
+  __name
+} from "../chunk-PAWJFY3S.mjs";
+
+// src/offline/configure.ts
+function configureOffline2(config) {
+  setDefaultDeviceStoreOpener(
+    (userId) => import("../lifecycle-LKGPRBS7.mjs").then((lifecycle) => lifecycle.openDeviceStore(userId))
+  );
+  configureOffline(config);
+}
+__name(configureOffline2, "configureOffline");
+
+// src/offline/sync/session-refresh.ts
+import { getCookie } from "cookies-next";
+function currentLocale() {
+  if (typeof window === "undefined") return getI18nDefaultLocale();
+  const first = window.location.pathname.split("/").filter(Boolean)[0];
+  return first && getI18nSupportedLocales().includes(first) ? first : getI18nDefaultLocale();
+}
+__name(currentLocale, "currentLocale");
+async function refreshSession() {
+  try {
+    await fetch(getOfflineConfig().shellPath(currentLocale()), { cache: "no-store", credentials: "same-origin" });
+  } catch {
+    return "unreachable";
+  }
+  const token = await getCookie("token");
+  return token ? "ok" : "expired";
+}
+__name(refreshSession, "refreshSession");
+
+// src/offline/sync/sync-root.ts
+var SyncInterruptedError = class extends Error {
+  static {
+    __name(this, "SyncInterruptedError");
+  }
+};
+function assertStillOnline() {
+  if (!canReachApi()) throw new SyncInterruptedError("The connection dropped during the sync");
+}
+__name(assertStillOnline, "assertStillOnline");
+var isSkippable = /* @__PURE__ */ __name((status) => status === 403 || status === 404, "isSkippable");
+async function fetchResources(module, endpoint, skipped, included) {
+  const response = await JsonApiGet({ classKey: module, endpoint, language: currentLocale() });
+  assertStillOnline();
+  if (!response.ok) {
+    if (isSkippable(response.response)) {
+      skipped.push(endpoint);
+      return [];
+    }
+    throw new Error(`[offline] GET ${endpoint} answered ${response.response}`);
+  }
+  included.push(...response.raw?.included ?? []);
+  const data = response.raw?.data;
+  if (!data) return [];
+  return Array.isArray(data) ? data : [data];
+}
+__name(fetchResources, "fetchResources");
+async function imagesOfRoot(store, rootId) {
+  const images = [];
+  for (const typeConfig of getOfflineConfig().types) {
+    for (const record of await store.listRecords({ type: typeConfig.module.name, rootId })) {
+      const url = imageUrlOf(record.resource);
+      if (url) images.push({ type: record.type, id: record.id, url });
+    }
+  }
+  return images;
+}
+__name(imagesOfRoot, "imagesOfRoot");
+async function removeRootIfIdle(store, rootId) {
+  if ((await store.queue()).some((entry) => entry.rootId === rootId)) return;
+  const images = await imagesOfRoot(store, rootId);
+  await store.removeRoot(rootId);
+  for (const image of images) {
+    if (!await store.getRecord(image.type, image.id)) await removeArtworkImage(image.url);
+  }
+}
+__name(removeRootIfIdle, "removeRootIfIdle");
+async function syncRoot(rootId) {
+  const config = getOfflineConfig();
+  const store = await getOfflineStore();
+  const previous = await store.getSyncState(rootId);
+  const syncEndpoint = new EndpointCreator({
+    endpoint: config.rootModule,
+    id: rootId,
+    childEndpoint: ROOT_SYNC_ENDPOINT
+  }).generate();
+  const syncResponse = await JsonApiGet({
+    classKey: Modules.RootSync,
+    endpoint: syncEndpoint,
+    language: currentLocale()
+  });
+  assertStillOnline();
+  if (!syncResponse.ok) {
+    if (isSkippable(syncResponse.response)) {
+      await removeRootIfIdle(store, rootId);
+      return;
+    }
+    throw new Error(`[offline] GET ${syncEndpoint} answered ${syncResponse.response}`);
+  }
+  const sync = syncResponse.data;
+  if (sync.locked) {
+    await store.setSyncState(rootId, {
+      serverTime: previous.serverTime,
+      locked: true,
+      lockedFrom: sync.lockedFrom ?? null
+    });
+    await refreshLockedRoots();
+    return;
+  }
+  const typeNames = new Set(config.types.map((typeConfig) => typeConfig.module.name));
+  const entries = sync.entries.filter((entry) => typeNames.has(entry.type));
+  const entryUpdatedAt = new Map(entries.map((entry) => [recordKeyOf(entry.type, entry.id), entry.updatedAt]));
+  const since = previous.serverTime;
+  const inWindow = /* @__PURE__ */ __name((entry) => !since || entry.updatedAt.getTime() > since.getTime(), "inWindow");
+  const stored = /* @__PURE__ */ new Map();
+  for (const typeConfig of config.types) {
+    for (const record of await store.listRecords({ type: typeConfig.module.name, rootId })) {
+      stored.set(recordKeyOf(record.type, record.id), record);
+    }
+  }
+  const previouslySkipped = new Map(
+    (await store.skippedRecords(rootId)).map((record) => [recordKeyOf(record.type, record.id), record.updatedAt])
+  );
+  const isStale = /* @__PURE__ */ __name((entry) => {
+    const key = recordKeyOf(entry.type, entry.id);
+    const record = stored.get(key);
+    if (record && record.updatedAt !== null) return false;
+    const skippedAt = previouslySkipped.get(key);
+    return !skippedAt || entry.updatedAt.getTime() > skippedAt.getTime();
+  }, "isStale");
+  const changed = entries.filter((entry) => inWindow(entry) || isStale(entry));
+  const skipped = [];
+  const fetched = [];
+  const included = [];
+  for (const typeConfig of config.types) {
+    const changedOfType = changed.filter((entry) => entry.type === typeConfig.module.name);
+    if (changedOfType.length === 0) continue;
+    if (typeConfig.fetch === "root-list") {
+      const endpoint = new EndpointCreator({
+        endpoint: config.rootModule,
+        id: rootId,
+        childEndpoint: typeConfig.module
+      }).addAdditionalParam("fetchAll", "true");
+      if (since && changedOfType.every(inWindow)) endpoint.addAdditionalParam("updatedSince", since.toISOString());
+      fetched.push(...await fetchResources(typeConfig.module, endpoint.generate(), skipped, included));
+    } else if (typeConfig.fetch === "linked-list") {
+      if (!typeConfig.linkedList) throw new Error(`[offline] ${typeConfig.module.name}: linked-list needs linkedList`);
+      const { linkKind, endpoint } = typeConfig.linkedList;
+      const changedIds = new Set(changedOfType.map((entry) => entry.id));
+      const targets = /* @__PURE__ */ new Map();
+      for (const link of sync.links) {
+        if (link.kind !== linkKind || link.fromType !== typeConfig.module.name || !changedIds.has(link.fromId))
+          continue;
+        targets.set(recordKeyOf(link.toType, link.toId), { type: link.toType, id: link.toId });
+      }
+      for (const target of targets.values()) {
+        const resources = await fetchResources(typeConfig.module, endpoint(rootId, target), skipped, included);
+        fetched.push(
+          ...resources.filter((resource) => resource?.type === typeConfig.module.name && changedIds.has(resource.id))
+        );
+      }
+    } else {
+      for (const entry of changedOfType) {
+        const endpoint = new EndpointCreator({ endpoint: typeConfig.module, id: entry.id }).generate();
+        fetched.push(...await fetchResources(typeConfig.module, endpoint, skipped, included));
+      }
+    }
+  }
+  const fetchedKeys = new Set(fetched.map((resource) => recordKeyOf(resource?.type, resource?.id)));
+  const previousImageUrls = /* @__PURE__ */ new Map();
+  const removedImageUrls = [];
+  await store.transaction(async (tx) => {
+    const waiting = waitingRecordKeys(await tx.queue(), typeNames);
+    for (const typeConfig of config.types) {
+      for (const record of await tx.listRecords({ type: typeConfig.module.name, rootId })) {
+        const key = recordKeyOf(record.type, record.id);
+        if (waiting.has(key)) {
+          if (record.updatedAt !== null) await tx.putRecord({ ...record, updatedAt: null });
+          continue;
+        }
+        if (entryUpdatedAt.has(key)) continue;
+        await tx.removeRecordFromRoot(record.type, record.id, rootId);
+        const url = imageUrlOf(record.resource);
+        if (url && !await tx.getRecord(record.type, record.id)) removedImageUrls.push(url);
+      }
+    }
+    for (const resource of fetched) {
+      const key = recordKeyOf(resource?.type, resource?.id);
+      if (!entryUpdatedAt.has(key)) continue;
+      if (waiting.has(key)) continue;
+      const existing = await tx.getRecord(resource.type, resource.id);
+      const previousUrl = imageUrlOf(existing?.resource);
+      if (previousUrl) previousImageUrls.set(key, previousUrl);
+      await tx.putRecord({
+        type: resource.type,
+        id: resource.id,
+        rootId,
+        resource,
+        updatedAt: entryUpdatedAt.get(key) ?? null,
+        base: null,
+        localOnly: false
+      });
+    }
+    for (const resource of included) {
+      if (!resource?.type || !resource?.id || typeNames.has(resource.type)) continue;
+      await tx.putRecord({
+        type: resource.type,
+        id: resource.id,
+        rootId,
+        resource,
+        updatedAt: null,
+        base: null,
+        localOnly: false
+      });
+    }
+    const skippedRecords = [];
+    const changedKeys = new Set(changed.map((entry) => recordKeyOf(entry.type, entry.id)));
+    for (const entry of entries) {
+      const key = recordKeyOf(entry.type, entry.id);
+      if (waiting.has(key) || fetchedKeys.has(key)) continue;
+      if (changedKeys.has(key)) skippedRecords.push({ type: entry.type, id: entry.id, updatedAt: entry.updatedAt });
+      else {
+        const skippedAt = previouslySkipped.get(key);
+        if (skippedAt) skippedRecords.push({ type: entry.type, id: entry.id, updatedAt: skippedAt });
+      }
+    }
+    await tx.setSkippedRecords(rootId, skippedRecords);
+    await tx.replaceRootLinks(rootId, sync.links);
+    await tx.setSyncState(rootId, {
+      serverTime: sync.serverTime,
+      locked: false,
+      lockedFrom: sync.lockedFrom ?? null
+    });
+  });
+  if (skipped.length > 0) {
+    console.warn(`[offline] root record ${rootId}: skipped records the GM cannot read:`, skipped.join(", "));
+  }
+  for (const url of removedImageUrls) await removeArtworkImage(url);
+  for (const typeConfig of config.types) {
+    for (const record of await store.listRecords({ type: typeConfig.module.name, rootId })) {
+      const url = imageUrlOf(record.resource);
+      if (url) await cacheArtworkImage(url, previousImageUrls.get(recordKeyOf(record.type, record.id)));
+    }
+  }
+  await refreshLockedRoots();
+}
+__name(syncRoot, "syncRoot");
+async function syncAll() {
+  if (!isOfflineConfigured()) return;
+  const config = getOfflineConfig();
+  if (!config.getUserId() || !canReachApi()) return;
+  let roots;
+  try {
+    roots = await config.listSyncRoots();
+  } catch (error) {
+    console.warn("[offline] could not list the root records to sync", error);
+    return;
+  }
+  if (!canReachApi()) return;
+  rememberSyncRoots(roots);
+  const total = roots.length;
+  setOfflineState({ syncProgress: { done: 0, total } });
+  try {
+    let done = 0;
+    for (const rootId of roots) {
+      try {
+        await syncRoot(rootId);
+      } catch (error) {
+        console.warn(`[offline] sync of root record ${rootId} failed`, error);
+        if (!canReachApi()) return;
+      } finally {
+        done += 1;
+        setOfflineState({ syncProgress: { done, total } });
+      }
+    }
+    const finishedAt = Date.now();
+    const userId = config.getUserId();
+    if (userId) writeOfflineLastSync(userId, finishedAt);
+    setOfflineState({ lastSyncedAt: finishedAt, rootCount: total });
+    const store = await getOfflineStore();
+    const rootSet = new Set(roots);
+    for (const rootId of await knownRootIds(store)) {
+      if (!rootSet.has(rootId)) await removeRootIfIdle(store, rootId);
+    }
+    await refreshLockedRoots();
+  } finally {
+    setOfflineState({ syncProgress: null });
+  }
+}
+__name(syncAll, "syncAll");
+
+// src/offline/sync/counts.ts
+import { useSyncExternalStore } from "react";
+var EMPTY = [];
+var _conflicts = EMPTY;
+var _listeners = /* @__PURE__ */ new Set();
+function subscribe(listener) {
+  _listeners.add(listener);
+  return () => {
+    _listeners.delete(listener);
+  };
+}
+__name(subscribe, "subscribe");
+async function refreshOfflineCounts(store) {
+  if (!store) {
+    if (!isOfflineConfigured() || !getOfflineConfig().getUserId()) return;
+    store = await getOfflineStore();
+  }
+  const entries = await store.queue();
+  _conflicts = await store.conflicts();
+  for (const listener of [..._listeners]) listener();
+  setOfflineState({
+    pending: entries.filter((entry) => entry.status !== "conflict").length,
+    conflicts: _conflicts.length
+  });
+}
+__name(refreshOfflineCounts, "refreshOfflineCounts");
+function useConflicts() {
+  return useSyncExternalStore(
+    subscribe,
+    () => _conflicts,
+    () => EMPTY
+  );
+}
+__name(useConflicts, "useConflicts");
+
+// src/offline/sync/drain-queue.ts
+var syncedTypeNames = /* @__PURE__ */ __name(() => new Set(getOfflineConfig().types.map((typeConfig) => typeConfig.module.name)), "syncedTypeNames");
+function withoutServerOwnedFields(body) {
+  const data = body?.data;
+  if (!data) return body;
+  const owned = new Map(
+    getOfflineConfig().types.map((typeConfig) => [typeConfig.module.name, typeConfig.serverOwnedFields])
+  );
+  const strip = /* @__PURE__ */ __name((resource) => {
+    const fields = owned.get(resource?.type) ?? [];
+    if (!resource?.attributes || fields.length === 0) return resource;
+    const attributes = { ...resource.attributes };
+    for (const field of fields) delete attributes[field];
+    return { ...resource, attributes };
+  }, "strip");
+  return { ...body, data: Array.isArray(data) ? data.map(strip) : strip(data) };
+}
+__name(withoutServerOwnedFields, "withoutServerOwnedFields");
+function toChange(entry) {
+  const change = { seq: entry.seq, method: entry.method, path: entry.path };
+  if (entry.body !== void 0) change.body = withoutServerOwnedFields(entry.body);
+  if (entry.recordType) change.recordType = entry.recordType;
+  if (entry.recordId) change.recordId = entry.recordId;
+  change.base = entry.base ?? null;
+  if (entry.resolution) change.resolution = entry.resolution;
+  return change;
+}
+__name(toChange, "toChange");
+function mergedResource(current, merged) {
+  if (!merged || !current?.type) return void 0;
+  return { ...current, attributes: { ...current.attributes ?? {}, ...merged } };
+}
+__name(mergedResource, "mergedResource");
+function newPackageId() {
+  return globalThis.crypto.randomUUID();
+}
+__name(newPackageId, "newPackageId");
+function packageIdFor(entries) {
+  return entries.find((entry) => entry.packageId)?.packageId ?? newPackageId();
+}
+__name(packageIdFor, "packageIdFor");
+async function entriesToSend(store) {
+  const all = await store.queue();
+  const typeNames = syncedTypeNames();
+  const blocked = waitingRecordKeys(
+    all.filter((entry) => entry.status === "conflict"),
+    typeNames
+  );
+  const lockedIds = new Set(getOfflineState().lockedRootIds);
+  const lockedByRoot = /* @__PURE__ */ new Map();
+  const now = /* @__PURE__ */ new Date();
+  const result = [];
+  for (const entry of all) {
+    if (entry.status !== "pending" && entry.status !== "sending") continue;
+    if (recordKeysOfEntry(entry, typeNames).some((key) => blocked.has(key))) continue;
+    if (!lockedByRoot.has(entry.rootId)) {
+      lockedByRoot.set(
+        entry.rootId,
+        lockedIds.has(entry.rootId) || isRootLocked(await store.getSyncState(entry.rootId), now)
+      );
+    }
+    if (lockedByRoot.get(entry.rootId)) continue;
+    result.push(entry);
+  }
+  return result.sort((a, b) => a.seq - b.seq);
+}
+__name(entriesToSend, "entriesToSend");
+async function applyResult(store, entry, result) {
+  if (result.status === "applied") {
+    await store.removeQueueEntry(entry.seq);
+    const typeNames = syncedTypeNames();
+    const stillWaiting = waitingRecordKeys(await store.queue(), typeNames);
+    for (const key of recordKeysOfEntry(entry, typeNames)) {
+      if (stillWaiting.has(key)) continue;
+      const separator = key.indexOf(":");
+      const record = await store.getRecord(key.slice(0, separator), key.slice(separator + 1));
+      if (record && (record.base !== null || record.localOnly)) {
+        await store.putRecord({ ...record, base: null, localOnly: false });
+      }
+    }
+    if (result.response) {
+      await writeThrough(
+        { method: entry.method, url: entry.path },
+        { ok: true, status: 200, statusText: "OK", data: result.response }
+      );
+    } else if (entry.method === "DELETE") {
+      await writeThrough(
+        { method: entry.method, url: entry.path },
+        { ok: true, status: 204, statusText: "OK", data: void 0 }
+      );
+    }
+    return "applied";
+  }
+  if (result.status === "conflict" || result.status === "could-not-apply") {
+    await store.addConflict({
+      queueSeq: entry.seq,
+      kind: result.status === "could-not-apply" ? "could-not-apply" : result.conflict ?? "fields",
+      recordType: entry.recordType,
+      recordId: entry.recordId,
+      mine: entry.body ?? null,
+      theirs: result.current ?? null,
+      base: entry.base ?? null,
+      merged: mergedResource(result.current, result.merged),
+      fields: result.conflictFields ?? [],
+      blocks: result.conflictBlocks,
+      reason: result.detail
+    });
+    await store.setQueueStatus(entry.seq, "conflict");
+    return "conflict";
+  }
+  await store.setQueueStatus(entry.seq, "pending");
+  return "pending";
+}
+__name(applyResult, "applyResult");
+async function drain() {
+  const outcome = { applied: 0, conflicts: 0, stoppedForLogin: false };
+  if (!isOfflineConfigured() || !getOfflineConfig().getUserId()) return outcome;
+  const store = await getOfflineStore();
+  const entries = await entriesToSend(store);
+  if (entries.length === 0) return outcome;
+  const session = await refreshSession();
+  if (session === "unreachable") return outcome;
+  if (session === "expired") return { ...outcome, stoppedForLogin: true };
+  setOfflineState({ draining: true });
+  const handled = /* @__PURE__ */ new Set();
+  try {
+    const packageId = packageIdFor(entries);
+    await store.setQueuePackage(
+      entries.map((entry) => entry.seq),
+      packageId
+    );
+    for (const entry of entries) await store.setQueueStatus(entry.seq, "sending");
+    const endpoint = new EndpointCreator({ endpoint: Modules.OfflineChangeSet }).generate();
+    const release = allowWhileReconnecting(buildUrl(endpoint));
+    let response;
+    try {
+      response = await JsonApiPost({
+        classKey: Modules.OfflineChangeSet,
+        endpoint,
+        body: { id: packageId, changes: entries.map(toChange) },
+        language: currentLocale()
+      });
+    } finally {
+      release();
+    }
+    if (!response.ok) {
+      if (response.response === 401) outcome.stoppedForLogin = true;
+      return outcome;
+    }
+    await store.setQueuePackage(
+      entries.map((entry) => entry.seq),
+      null
+    );
+    const results = new Map(response.data.results.map((result) => [result.seq, result]));
+    for (const entry of entries) {
+      const result = results.get(entry.seq);
+      const status = result ? await applyResult(store, entry, result) : "pending";
+      if (!result) await store.setQueueStatus(entry.seq, "pending");
+      handled.add(entry.seq);
+      if (status === "applied") outcome.applied++;
+      if (status === "conflict") outcome.conflicts++;
+    }
+    return outcome;
+  } catch (error) {
+    console.error("[offline] sending the waiting changes failed", error);
+    return outcome;
+  } finally {
+    for (const entry of entries) {
+      if (!handled.has(entry.seq)) await store.setQueueStatus(entry.seq, "pending");
+    }
+    setOfflineState({ draining: false });
+    await refreshOfflineCounts(store);
+  }
+}
+__name(drain, "drain");
+var _inFlight;
+function drainQueue() {
+  if (!_inFlight) {
+    _inFlight = drain().finally(() => {
+      _inFlight = void 0;
+    });
+  }
+  return _inFlight;
+}
+__name(drainQueue, "drainQueue");
+
+// src/offline/sync/conflicts.ts
+function updatedAtOf(resource) {
+  const value = resource?.attributes?.updatedAt;
+  if (!value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+__name(updatedAtOf, "updatedAtOf");
+async function applyChoicesToRecord(store, conflict, choices, mergedBody) {
+  if (!conflict.recordType || !conflict.recordId) return;
+  const record = await store.getRecord(conflict.recordType, conflict.recordId);
+  if (!record) return;
+  const attributes = { ...record.resource?.attributes ?? {} };
+  const relationships = { ...record.resource?.relationships ?? {} };
+  for (const [field, choice] of Object.entries(choices)) {
+    const source = choice === "theirs" ? conflict.theirs : choice === "merged" ? mergedBody?.data : void 0;
+    if (!source) continue;
+    if (source.attributes && field in source.attributes) attributes[field] = source.attributes[field];
+    else if (source.relationships && field in source.relationships) relationships[field] = source.relationships[field];
+  }
+  await store.putRecord({ ...record, resource: { ...record.resource, attributes, relationships } });
+}
+__name(applyChoicesToRecord, "applyChoicesToRecord");
+async function rootIdOf(store, conflict, entry) {
+  if (entry) return entry.rootId;
+  if (conflict.recordType && conflict.recordId) {
+    const record = await store.getRecord(conflict.recordType, conflict.recordId);
+    if (record) return record.rootId;
+  }
+  throw new Error(`[offline] conflict ${conflict.id} belongs to no root record on this device`);
+}
+__name(rootIdOf, "rootIdOf");
+function collectionPath(recordType) {
+  const module = getOfflineConfig().types.find((typeConfig) => typeConfig.module.name === recordType)?.module;
+  return new EndpointCreator({ endpoint: module ?? recordType }).generate();
+}
+__name(collectionPath, "collectionPath");
+async function requeueOriginal(store, conflict, entry, fallbackMethod, resolution) {
+  const method = entry?.method ?? fallbackMethod;
+  const body = method === "DELETE" ? void 0 : entry?.body ?? conflict.mine ?? void 0;
+  await store.enqueue({
+    rootId: await rootIdOf(store, conflict, entry),
+    method,
+    path: entry?.path ?? new EndpointCreator({ endpoint: collectionPath(conflict.recordType), id: conflict.recordId }).generate(),
+    ...body !== void 0 ? { body } : {},
+    recordType: entry?.recordType ?? conflict.recordType,
+    recordId: entry?.recordId ?? conflict.recordId,
+    base: entry ? entry.base : conflict.base ?? null,
+    // QueueEntry["resolution"] is the store's copy of OfflineChange["resolution"].
+    resolution
+  });
+  if (entry) await store.removeQueueEntry(entry.seq);
+}
+__name(requeueOriginal, "requeueOriginal");
+async function resolve(store, conflict, choice) {
+  const entry = (await store.queue()).find((candidate) => candidate.seq === conflict.queueSeq);
+  const dropEntry = /* @__PURE__ */ __name(async () => {
+    if (entry) await store.removeQueueEntry(entry.seq);
+  }, "dropEntry");
+  switch (choice.kind) {
+    case "mine":
+    case "fields": {
+      if (choice.kind === "fields" && Object.values(choice.choices).every((value) => value === "theirs")) {
+        return resolve(store, conflict, { kind: "theirs" });
+      }
+      const resolution = choice.kind === "mine" ? { kind: "mine" } : {
+        kind: "merged",
+        choices: choice.choices,
+        ...choice.mergedBody !== void 0 ? { mergedBody: choice.mergedBody } : {}
+      };
+      await requeueOriginal(store, conflict, entry, "PATCH", resolution);
+      if (choice.kind === "fields") await applyChoicesToRecord(store, conflict, choice.choices, choice.mergedBody);
+      break;
+    }
+    case "theirs": {
+      await dropEntry();
+      if (conflict.recordType && conflict.recordId) {
+        if (conflict.theirs) {
+          await store.putRecord({
+            type: conflict.recordType,
+            id: conflict.recordId,
+            rootId: await rootIdOf(store, conflict, entry),
+            resource: conflict.theirs,
+            updatedAt: updatedAtOf(conflict.theirs),
+            base: null,
+            localOnly: false
+          });
+        } else {
+          await store.deleteRecord(conflict.recordType, conflict.recordId);
+        }
+      }
+      break;
+    }
+    case "restore": {
+      if (!conflict.recordType) throw new Error(`[offline] conflict ${conflict.id} has no record to restore`);
+      const body = conflict.mine ?? entry?.body;
+      const rootId = await rootIdOf(store, conflict, entry);
+      await store.enqueue({
+        rootId,
+        method: "POST",
+        path: collectionPath(conflict.recordType),
+        body,
+        recordType: conflict.recordType,
+        recordId: conflict.recordId,
+        base: null
+      });
+      await dropEntry();
+      if (conflict.recordId) {
+        const record = await store.getRecord(conflict.recordType, conflict.recordId);
+        if (record) await store.putRecord({ ...record, base: null, localOnly: true });
+        else if (body?.data)
+          await store.putRecord({
+            type: conflict.recordType,
+            id: conflict.recordId,
+            rootId,
+            resource: body.data,
+            updatedAt: null,
+            base: null,
+            localOnly: true
+          });
+      }
+      break;
+    }
+    case "accept-deletion": {
+      await dropEntry();
+      if (conflict.recordType && conflict.recordId) await store.deleteRecord(conflict.recordType, conflict.recordId);
+      break;
+    }
+    case "delete-anyway": {
+      await requeueOriginal(store, conflict, entry, "DELETE", { kind: "mine" });
+      break;
+    }
+    case "retry": {
+      if (entry) await store.setQueueStatus(entry.seq, "pending");
+      break;
+    }
+    case "discard": {
+      await dropEntry();
+      break;
+    }
+  }
+  await store.removeConflict(conflict.id);
+}
+__name(resolve, "resolve");
+async function resolveConflict(id, choice) {
+  const store = await getOfflineStore();
+  const conflict = (await store.conflicts()).find((candidate) => candidate.id === id);
+  if (!conflict) throw new Error(`[offline] no conflict ${id}`);
+  await store.transaction((tx) => resolve(tx, conflict, choice));
+  await refreshOfflineCounts(store);
+  if (getOfflineState().online) {
+    drainQueue().catch((error) => console.warn("[offline] sending the resolved change failed", error));
+  }
+}
+__name(resolveConflict, "resolveConflict");
+
+// src/offline/sync/runtime.ts
+import { getCookie as getCookie2 } from "cookies-next";
+var LOCK_CHECK_INTERVAL_MS = 6e4;
+var PROBE_INTERVAL_MS = 3e4;
+async function probeApi() {
+  const config = getOfflineConfig();
+  const store = await getOfflineStore();
+  const [rootId] = await knownRootIds(store);
+  const endpoint = rootId ? new EndpointCreator({ endpoint: config.rootModule, id: rootId, childEndpoint: ROOT_SYNC_ENDPOINT }) : new EndpointCreator({ endpoint: config.rootModule }).addAdditionalParam("page[size]", "1");
+  const response = await directFetch({
+    method: "GET",
+    url: buildUrl(endpoint.generate()),
+    token: await getClientToken(),
+    language: currentLocale(),
+    additionalHeaders: { [OFFLINE_REPLAY_HEADER]: "1" }
+  });
+  return !response.networkError;
+}
+__name(probeApi, "probeApi");
+var LOGIN_RELOAD_KEY = "nja-offline-login-reload";
+var _reloadedForSignIn;
+async function signInFingerprint() {
+  const token = await getCookie2("token");
+  if (!token) return "none";
+  let hash = 5381;
+  for (const char of String(token)) hash = (hash * 33 ^ char.charCodeAt(0)) >>> 0;
+  return hash.toString(36);
+}
+__name(signInFingerprint, "signInFingerprint");
+var readReloadMarker = /* @__PURE__ */ __name(() => {
+  try {
+    return window.sessionStorage.getItem(LOGIN_RELOAD_KEY);
+  } catch {
+    return null;
+  }
+}, "readReloadMarker");
+var writeReloadMarker = /* @__PURE__ */ __name((value) => {
+  try {
+    if (value === null) window.sessionStorage.removeItem(LOGIN_RELOAD_KEY);
+    else window.sessionStorage.setItem(LOGIN_RELOAD_KEY, value);
+  } catch {
+  }
+}, "writeReloadMarker");
+async function signInExpired() {
+  const signIn = await signInFingerprint();
+  if (_reloadedForSignIn === signIn || readReloadMarker() === signIn) {
+    console.warn("[offline] the sign-in expired; log in again to send the waiting changes");
+    return;
+  }
+  _reloadedForSignIn = signIn;
+  writeReloadMarker(signIn);
+  try {
+    window.location.reload();
+  } catch (error) {
+    console.warn("[offline] the sign-in expired; log in again to send the waiting changes", error);
+  }
+}
+__name(signInExpired, "signInExpired");
+var warnUnlessUnavailable = /* @__PURE__ */ __name((message) => (error) => {
+  if (!(error instanceof OfflineUnavailableError)) console.warn(message, error);
+}, "warnUnlessUnavailable");
+var _runningRuntimes = /* @__PURE__ */ new Set();
+function stopOfflineRuntime() {
+  for (const stop of [..._runningRuntimes]) stop();
+}
+__name(stopOfflineRuntime, "stopOfflineRuntime");
+function startOfflineRuntime() {
+  refreshOfflineDeviceState();
+  if (!isOfflineConfigured()) return () => {
+  };
+  const config = getOfflineConfig();
+  let running;
+  let goingOnlineAfterSync = false;
+  const run = /* @__PURE__ */ __name((reconnect) => {
+    if (!running) {
+      running = (async () => {
+        let succeeded = false;
+        if (reconnect) setReconnecting(true);
+        try {
+          const drained = await drainQueue();
+          if (drained.stoppedForLogin) {
+            await signInExpired();
+            return;
+          }
+          writeReloadMarker(null);
+          if (reconnect ? !isReconnecting() : !getOfflineState().online) return;
+          await syncAll();
+          succeeded = reconnect && isReconnecting();
+        } catch (error) {
+          warnUnlessUnavailable("[offline] background sync failed")(error);
+        } finally {
+          if (reconnect) setReconnecting(false);
+          running = void 0;
+          if (succeeded) {
+            goingOnlineAfterSync = true;
+            setOfflineState({ online: true });
+            goingOnlineAfterSync = false;
+            if (getOfflineState().pending > 0) {
+              drainQueue().catch(warnUnlessUnavailable("[offline] sending the waiting changes failed"));
+            }
+          }
+        }
+      })();
+    }
+    return running;
+  }, "run");
+  const runOnline = /* @__PURE__ */ __name(() => run(false), "runOnline");
+  let probing = false;
+  const probe = /* @__PURE__ */ __name(async () => {
+    if (probing || running || getOfflineState().online) return;
+    if (typeof navigator !== "undefined" && navigator.onLine === false) return;
+    probing = true;
+    try {
+      if (await probeApi()) await run(true);
+    } catch (error) {
+      warnUnlessUnavailable("[offline] probing the API failed")(error);
+    } finally {
+      probing = false;
+    }
+  }, "probe");
+  const onBrowserOnline = /* @__PURE__ */ __name(() => void probe(), "onBrowserOnline");
+  if (typeof window !== "undefined") window.addEventListener("online", onBrowserOnline);
+  let wasOnline = getOfflineState().online;
+  const unsubscribe = subscribeOfflineState((state) => {
+    if (!state.available) {
+      stop();
+      return;
+    }
+    if (state.online && !wasOnline && !goingOnlineAfterSync) void runOnline();
+    wasOnline = state.online;
+  });
+  void refreshLockedRoots().catch(warnUnlessUnavailable("[offline] lock check failed"));
+  void refreshOfflineCounts().catch(warnUnlessUnavailable("[offline] reading the queue failed"));
+  if (getOfflineState().online) void runOnline();
+  const syncTimer = setInterval(() => {
+    if (getOfflineState().online) void runOnline();
+  }, config.syncIntervalMs);
+  const probeTimer = setInterval(() => void probe(), PROBE_INTERVAL_MS);
+  const lockTimer = setInterval(() => {
+    void refreshLockedRoots().catch(warnUnlessUnavailable("[offline] lock check failed"));
+  }, LOCK_CHECK_INTERVAL_MS);
+  const stop = /* @__PURE__ */ __name(() => {
+    _runningRuntimes.delete(stop);
+    clearInterval(syncTimer);
+    clearInterval(probeTimer);
+    clearInterval(lockTimer);
+    if (typeof window !== "undefined") window.removeEventListener("online", onBrowserOnline);
+    unsubscribe();
+  }, "stop");
+  _runningRuntimes.add(stop);
+  return stop;
+}
+__name(startOfflineRuntime, "startOfflineRuntime");
+
+// src/offline/logout.ts
+async function prepareOfflineLogout() {
+  if (!isOfflineConfigured()) return { pending: 0 };
+  if (!getOfflineConfig().getUserId()) return { pending: 0 };
+  const store = await getOfflineStore();
+  const entries = await store.queue();
+  return { pending: entries.length };
+}
+__name(prepareOfflineLogout, "prepareOfflineLogout");
+async function finishOfflineLogout(userId) {
+  stopOfflineRuntime();
+  blockOfflineStore(userId);
+  const { deleteDeviceStore: deleteDeviceStore2 } = await import("../lifecycle-LKGPRBS7.mjs");
+  await deleteDeviceStore2(userId);
+  await deleteImagesCaches();
+  setOfflineEnabledOnDevice(userId, false);
+  writeOfflineLastSync(userId, null);
+  setOfflineState({ enabled: false, syncProgress: null, lastSyncedAt: null, rootCount: null });
+}
+__name(finishOfflineLogout, "finishOfflineLogout");
+
+// src/offline/device-switch.ts
+function signedInUserId() {
+  const userId = getOfflineConfig().getUserId();
+  if (!userId) throw new Error("No signed-in user");
+  return userId;
+}
+__name(signedInUserId, "signedInUserId");
+async function turnOnOffline() {
+  const userId = signedInUserId();
+  setOfflineEnabledOnDevice(userId, true);
+  setOfflineState({ enabled: true });
+  try {
+    await navigator.storage?.persist?.();
+  } catch {
+  }
+}
+__name(turnOnOffline, "turnOnOffline");
+async function turnOffOffline() {
+  const userId = signedInUserId();
+  if (isOfflineAvailable()) {
+    let pending = 0;
+    try {
+      const store = await getOfflineStore();
+      pending = (await store.queue()).length;
+    } catch {
+      const { hasUnsentChanges: hasUnsentChanges2 } = await import("../lifecycle-LKGPRBS7.mjs");
+      if (await hasUnsentChanges2(userId).catch(() => false)) pending = 1;
+    }
+    if (pending > 0) return { turnedOff: false, pending };
+  }
+  setOfflineEnabledOnDevice(userId, false);
+  if (isOfflineAvailable()) {
+    stopOfflineRuntime();
+    try {
+      const { deleteDeviceStore: deleteDeviceStore2 } = await import("../lifecycle-LKGPRBS7.mjs");
+      await deleteDeviceStore2(userId);
+      await deleteImagesCaches();
+    } catch (error) {
+      console.warn("[offline] the device copy could not be deleted", error);
+    }
+    forgetOfflineStore(userId);
+  }
+  writeOfflineLastSync(userId, null);
+  setOfflineState({ enabled: false, syncProgress: null, lastSyncedAt: null, rootCount: null });
+  return { turnedOff: true };
+}
+__name(turnOffOffline, "turnOffOffline");
+export {
+  DEFAULT_DEVICE_WORKER_URL,
+  DEFAULT_SQLITE_MODULE_URL,
+  DEVICE_WORKER_FILE,
+  DeviceStoreUnavailableError,
+  NeedsConnectionError,
+  OFFLINE_REPLAY_HEADER,
+  OFFLINE_SQLITE_FILES,
+  OfflineUnavailableError,
+  SERVER_DEFAULT_ORDER_BY,
+  configureOffline2 as configureOffline,
+  deleteDeviceStore,
+  drainQueue,
+  errorAnswer,
+  finishOfflineLogout,
+  forgetOfflineStore,
+  getOfflineConfig,
+  getOfflineState,
+  getOfflineStore,
+  hasUnsentChanges,
+  includedFor,
+  isOfflineAvailable,
+  isOfflineConfigured,
+  isOfflineEnabledOnDevice,
+  isRootLocked,
+  linkKindFor,
+  linkKindsOf,
+  linksOfKind,
+  listAnswer,
+  localTransport,
+  matchPattern,
+  matchRoute,
+  mergeResource,
+  needsConnectionAnswer,
+  notFoundAnswer,
+  onUserSignedIn,
+  openDeviceStore,
+  openMemoryDeviceStore,
+  orderRecords,
+  orderedListAnswer,
+  patternToString,
+  prepareOfflineLogout,
+  refreshOfflineDeviceState,
+  resolveConflict,
+  resourceFromDocument,
+  resourceListAnswer,
+  searchRecords,
+  setDeviceStoreOpener,
+  setOfflineState,
+  singleAnswer,
+  startOfflineRuntime,
+  stopOfflineRuntime,
+  subscribeOfflineState,
+  syncAll,
+  syncRoot,
+  turnOffOffline,
+  turnOnOffline,
+  useConflicts,
+  useNeedsConnection,
+  useOfflineState,
+  writeThrough
+};
+//# sourceMappingURL=index.mjs.map