@carlonicora/nextjs-jsonapi 6.12.2 → 6.13.1

package/dist/offline/index.js

@@ -0,0 +1,1052 @@
+"use client";
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+var _chunkB6JGKDP2js = require('../chunk-B6JGKDP2.js');
+
+
+
+
+
+
+
+
+
+
+
+var _chunkPXDUJ47Njs = require('../chunk-PXDUJ47N.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkW62MHDWMjs = require('../chunk-W62MHDWM.js');
+
+
+
+var _chunkGB6DBFYYjs = require('../chunk-GB6DBFYY.js');
+
+
+
+
+
+
+var _chunkBZ5J2FIVjs = require('../chunk-BZ5J2FIV.js');
+require('../chunk-PV4Z5W6V.js');
+
+
+var _chunkKMW7UNL2js = require('../chunk-KMW7UNL2.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkMHB36MYEjs = require('../chunk-MHB36MYE.js');
+
+
+
+
+var _chunkQKNGZDSQjs = require('../chunk-QKNGZDSQ.js');
+
+
+var _chunkLXKSUWAVjs = require('../chunk-LXKSUWAV.js');
+
+
+var _chunk7QVYU63Ejs = require('../chunk-7QVYU63E.js');
+
+// src/offline/configure.ts
+function configureOffline2(config) {
+  _chunkMHB36MYEjs.setDefaultDeviceStoreOpener.call(void 0, 
+    (userId) => Promise.resolve().then(() => _interopRequireWildcard(require("../lifecycle-4GUOTB46.js"))).then((lifecycle) => lifecycle.openDeviceStore(userId))
+  );
+  _chunkMHB36MYEjs.configureOffline.call(void 0, config);
+}
+_chunk7QVYU63Ejs.__name.call(void 0, configureOffline2, "configureOffline");
+
+// src/offline/sync/session-refresh.ts
+var _cookiesnext = require('cookies-next');
+function currentLocale() {
+  if (typeof window === "undefined") return _chunkBZ5J2FIVjs.getI18nDefaultLocale.call(void 0, );
+  const first = window.location.pathname.split("/").filter(Boolean)[0];
+  return first && _chunkBZ5J2FIVjs.getI18nSupportedLocales.call(void 0, ).includes(first) ? first : _chunkBZ5J2FIVjs.getI18nDefaultLocale.call(void 0, );
+}
+_chunk7QVYU63Ejs.__name.call(void 0, currentLocale, "currentLocale");
+async function refreshSession() {
+  try {
+    await fetch(_chunkMHB36MYEjs.getOfflineConfig.call(void 0, ).shellPath(currentLocale()), { cache: "no-store", credentials: "same-origin" });
+  } catch (e) {
+    return "unreachable";
+  }
+  const token = await _cookiesnext.getCookie.call(void 0, "token");
+  return token ? "ok" : "expired";
+}
+_chunk7QVYU63Ejs.__name.call(void 0, refreshSession, "refreshSession");
+
+// src/offline/sync/sync-root.ts
+var SyncInterruptedError = class extends Error {
+  static {
+    _chunk7QVYU63Ejs.__name.call(void 0, this, "SyncInterruptedError");
+  }
+};
+function assertStillOnline() {
+  if (!_chunkMHB36MYEjs.canReachApi.call(void 0, )) throw new SyncInterruptedError("The connection dropped during the sync");
+}
+_chunk7QVYU63Ejs.__name.call(void 0, assertStillOnline, "assertStillOnline");
+var isSkippable = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, (status) => status === 403 || status === 404, "isSkippable");
+async function fetchResources(module, endpoint, skipped, included) {
+  const response = await _chunkQKNGZDSQjs.JsonApiGet.call(void 0, { 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(..._nullishCoalesce(_optionalChain([response, 'access', _ => _.raw, 'optionalAccess', _2 => _2.included]), () => ( [])));
+  const data = _optionalChain([response, 'access', _3 => _3.raw, 'optionalAccess', _4 => _4.data]);
+  if (!data) return [];
+  return Array.isArray(data) ? data : [data];
+}
+_chunk7QVYU63Ejs.__name.call(void 0, fetchResources, "fetchResources");
+async function imagesOfRoot(store, rootId) {
+  const images = [];
+  for (const typeConfig of _chunkMHB36MYEjs.getOfflineConfig.call(void 0, ).types) {
+    for (const record of await store.listRecords({ type: typeConfig.module.name, rootId })) {
+      const url = _chunkPXDUJ47Njs.imageUrlOf.call(void 0, record.resource);
+      if (url) images.push({ type: record.type, id: record.id, url });
+    }
+  }
+  return images;
+}
+_chunk7QVYU63Ejs.__name.call(void 0, 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 _chunkPXDUJ47Njs.removeArtworkImage.call(void 0, image.url);
+  }
+}
+_chunk7QVYU63Ejs.__name.call(void 0, removeRootIfIdle, "removeRootIfIdle");
+async function syncRoot(rootId) {
+  const config = _chunkMHB36MYEjs.getOfflineConfig.call(void 0, );
+  const store = await _chunkMHB36MYEjs.getOfflineStore.call(void 0, );
+  const previous = await store.getSyncState(rootId);
+  const syncEndpoint = new (0, _chunkBZ5J2FIVjs.EndpointCreator)({
+    endpoint: config.rootModule,
+    id: rootId,
+    childEndpoint: _chunkBZ5J2FIVjs.ROOT_SYNC_ENDPOINT
+  }).generate();
+  const syncResponse = await _chunkQKNGZDSQjs.JsonApiGet.call(void 0, {
+    classKey: _chunkBZ5J2FIVjs.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: _nullishCoalesce(sync.lockedFrom, () => ( null))
+    });
+    await _chunkB6JGKDP2js.refreshLockedRoots.call(void 0, );
+    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) => [_chunkB6JGKDP2js.recordKeyOf.call(void 0, entry.type, entry.id), entry.updatedAt]));
+  const since = previous.serverTime;
+  const inWindow = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, (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(_chunkB6JGKDP2js.recordKeyOf.call(void 0, record.type, record.id), record);
+    }
+  }
+  const previouslySkipped = new Map(
+    (await store.skippedRecords(rootId)).map((record) => [_chunkB6JGKDP2js.recordKeyOf.call(void 0, record.type, record.id), record.updatedAt])
+  );
+  const isStale = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, (entry) => {
+    const key = _chunkB6JGKDP2js.recordKeyOf.call(void 0, 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 (0, _chunkBZ5J2FIVjs.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(_chunkB6JGKDP2js.recordKeyOf.call(void 0, 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) => _optionalChain([resource, 'optionalAccess', _5 => _5.type]) === typeConfig.module.name && changedIds.has(resource.id))
+        );
+      }
+    } else {
+      for (const entry of changedOfType) {
+        const endpoint = new (0, _chunkBZ5J2FIVjs.EndpointCreator)({ endpoint: typeConfig.module, id: entry.id }).generate();
+        fetched.push(...await fetchResources(typeConfig.module, endpoint, skipped, included));
+      }
+    }
+  }
+  const fetchedKeys = new Set(fetched.map((resource) => _chunkB6JGKDP2js.recordKeyOf.call(void 0, _optionalChain([resource, 'optionalAccess', _6 => _6.type]), _optionalChain([resource, 'optionalAccess', _7 => _7.id]))));
+  const previousImageUrls = /* @__PURE__ */ new Map();
+  const removedImageUrls = [];
+  await store.transaction(async (tx) => {
+    const waiting = _chunkB6JGKDP2js.waitingRecordKeys.call(void 0, await tx.queue(), typeNames);
+    for (const typeConfig of config.types) {
+      for (const record of await tx.listRecords({ type: typeConfig.module.name, rootId })) {
+        const key = _chunkB6JGKDP2js.recordKeyOf.call(void 0, 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 = _chunkPXDUJ47Njs.imageUrlOf.call(void 0, record.resource);
+        if (url && !await tx.getRecord(record.type, record.id)) removedImageUrls.push(url);
+      }
+    }
+    for (const resource of fetched) {
+      const key = _chunkB6JGKDP2js.recordKeyOf.call(void 0, _optionalChain([resource, 'optionalAccess', _8 => _8.type]), _optionalChain([resource, 'optionalAccess', _9 => _9.id]));
+      if (!entryUpdatedAt.has(key)) continue;
+      if (waiting.has(key)) continue;
+      const existing = await tx.getRecord(resource.type, resource.id);
+      const previousUrl = _chunkPXDUJ47Njs.imageUrlOf.call(void 0, _optionalChain([existing, 'optionalAccess', _10 => _10.resource]));
+      if (previousUrl) previousImageUrls.set(key, previousUrl);
+      await tx.putRecord({
+        type: resource.type,
+        id: resource.id,
+        rootId,
+        resource,
+        updatedAt: _nullishCoalesce(entryUpdatedAt.get(key), () => ( null)),
+        base: null,
+        localOnly: false
+      });
+    }
+    for (const resource of included) {
+      if (!_optionalChain([resource, 'optionalAccess', _11 => _11.type]) || !_optionalChain([resource, 'optionalAccess', _12 => _12.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) => _chunkB6JGKDP2js.recordKeyOf.call(void 0, entry.type, entry.id)));
+    for (const entry of entries) {
+      const key = _chunkB6JGKDP2js.recordKeyOf.call(void 0, 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: _nullishCoalesce(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 _chunkPXDUJ47Njs.removeArtworkImage.call(void 0, url);
+  for (const typeConfig of config.types) {
+    for (const record of await store.listRecords({ type: typeConfig.module.name, rootId })) {
+      const url = _chunkPXDUJ47Njs.imageUrlOf.call(void 0, record.resource);
+      if (url) await _chunkPXDUJ47Njs.cacheArtworkImage.call(void 0, url, previousImageUrls.get(_chunkB6JGKDP2js.recordKeyOf.call(void 0, record.type, record.id)));
+    }
+  }
+  await _chunkB6JGKDP2js.refreshLockedRoots.call(void 0, );
+}
+_chunk7QVYU63Ejs.__name.call(void 0, syncRoot, "syncRoot");
+async function syncAll() {
+  if (!_chunkMHB36MYEjs.isOfflineConfigured.call(void 0, )) return;
+  const config = _chunkMHB36MYEjs.getOfflineConfig.call(void 0, );
+  if (!config.getUserId() || !_chunkMHB36MYEjs.canReachApi.call(void 0, )) return;
+  let roots;
+  try {
+    roots = await config.listSyncRoots();
+  } catch (error) {
+    console.warn("[offline] could not list the root records to sync", error);
+    return;
+  }
+  if (!_chunkMHB36MYEjs.canReachApi.call(void 0, )) return;
+  _chunkB6JGKDP2js.rememberSyncRoots.call(void 0, roots);
+  const total = roots.length;
+  _chunkMHB36MYEjs.setOfflineState.call(void 0, { 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 (!_chunkMHB36MYEjs.canReachApi.call(void 0, )) return;
+      } finally {
+        done += 1;
+        _chunkMHB36MYEjs.setOfflineState.call(void 0, { syncProgress: { done, total } });
+      }
+    }
+    const finishedAt = Date.now();
+    const userId = config.getUserId();
+    if (userId) _chunkMHB36MYEjs.writeOfflineLastSync.call(void 0, userId, finishedAt);
+    _chunkMHB36MYEjs.setOfflineState.call(void 0, { lastSyncedAt: finishedAt, rootCount: total });
+    const store = await _chunkMHB36MYEjs.getOfflineStore.call(void 0, );
+    const rootSet = new Set(roots);
+    for (const rootId of await _chunkB6JGKDP2js.knownRootIds.call(void 0, store)) {
+      if (!rootSet.has(rootId)) await removeRootIfIdle(store, rootId);
+    }
+    await _chunkB6JGKDP2js.refreshLockedRoots.call(void 0, );
+  } finally {
+    _chunkMHB36MYEjs.setOfflineState.call(void 0, { syncProgress: null });
+  }
+}
+_chunk7QVYU63Ejs.__name.call(void 0, syncAll, "syncAll");
+
+// src/offline/sync/counts.ts
+var _react = require('react');
+var EMPTY = [];
+var _conflicts = EMPTY;
+var _listeners = /* @__PURE__ */ new Set();
+function subscribe(listener) {
+  _listeners.add(listener);
+  return () => {
+    _listeners.delete(listener);
+  };
+}
+_chunk7QVYU63Ejs.__name.call(void 0, subscribe, "subscribe");
+async function refreshOfflineCounts(store) {
+  if (!store) {
+    if (!_chunkMHB36MYEjs.isOfflineConfigured.call(void 0, ) || !_chunkMHB36MYEjs.getOfflineConfig.call(void 0, ).getUserId()) return;
+    store = await _chunkMHB36MYEjs.getOfflineStore.call(void 0, );
+  }
+  const entries = await store.queue();
+  _conflicts = await store.conflicts();
+  for (const listener of [..._listeners]) listener();
+  _chunkMHB36MYEjs.setOfflineState.call(void 0, {
+    pending: entries.filter((entry) => entry.status !== "conflict").length,
+    conflicts: _conflicts.length
+  });
+}
+_chunk7QVYU63Ejs.__name.call(void 0, refreshOfflineCounts, "refreshOfflineCounts");
+function useConflicts() {
+  return _react.useSyncExternalStore.call(void 0, 
+    subscribe,
+    () => _conflicts,
+    () => EMPTY
+  );
+}
+_chunk7QVYU63Ejs.__name.call(void 0, useConflicts, "useConflicts");
+
+// src/offline/sync/drain-queue.ts
+var syncedTypeNames = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, () => new Set(_chunkMHB36MYEjs.getOfflineConfig.call(void 0, ).types.map((typeConfig) => typeConfig.module.name)), "syncedTypeNames");
+function withoutServerOwnedFields(body) {
+  const data = _optionalChain([body, 'optionalAccess', _13 => _13.data]);
+  if (!data) return body;
+  const owned = new Map(
+    _chunkMHB36MYEjs.getOfflineConfig.call(void 0, ).types.map((typeConfig) => [typeConfig.module.name, typeConfig.serverOwnedFields])
+  );
+  const strip = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, (resource) => {
+    const fields = _nullishCoalesce(owned.get(_optionalChain([resource, 'optionalAccess', _14 => _14.type])), () => ( []));
+    if (!_optionalChain([resource, 'optionalAccess', _15 => _15.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) };
+}
+_chunk7QVYU63Ejs.__name.call(void 0, 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 = _nullishCoalesce(entry.base, () => ( null));
+  if (entry.resolution) change.resolution = entry.resolution;
+  return change;
+}
+_chunk7QVYU63Ejs.__name.call(void 0, toChange, "toChange");
+function mergedResource(current, merged) {
+  if (!merged || !_optionalChain([current, 'optionalAccess', _16 => _16.type])) return void 0;
+  return { ...current, attributes: { ..._nullishCoalesce(current.attributes, () => ( {})), ...merged } };
+}
+_chunk7QVYU63Ejs.__name.call(void 0, mergedResource, "mergedResource");
+function newPackageId() {
+  return globalThis.crypto.randomUUID();
+}
+_chunk7QVYU63Ejs.__name.call(void 0, newPackageId, "newPackageId");
+function packageIdFor(entries) {
+  return _nullishCoalesce(_optionalChain([entries, 'access', _17 => _17.find, 'call', _18 => _18((entry) => entry.packageId), 'optionalAccess', _19 => _19.packageId]), () => ( newPackageId()));
+}
+_chunk7QVYU63Ejs.__name.call(void 0, packageIdFor, "packageIdFor");
+async function entriesToSend(store) {
+  const all = await store.queue();
+  const typeNames = syncedTypeNames();
+  const blocked = _chunkB6JGKDP2js.waitingRecordKeys.call(void 0, 
+    all.filter((entry) => entry.status === "conflict"),
+    typeNames
+  );
+  const lockedIds = new Set(_chunkMHB36MYEjs.getOfflineState.call(void 0, ).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 (_chunkB6JGKDP2js.recordKeysOfEntry.call(void 0, entry, typeNames).some((key) => blocked.has(key))) continue;
+    if (!lockedByRoot.has(entry.rootId)) {
+      lockedByRoot.set(
+        entry.rootId,
+        lockedIds.has(entry.rootId) || _chunkPXDUJ47Njs.isRootLocked.call(void 0, await store.getSyncState(entry.rootId), now)
+      );
+    }
+    if (lockedByRoot.get(entry.rootId)) continue;
+    result.push(entry);
+  }
+  return result.sort((a, b) => a.seq - b.seq);
+}
+_chunk7QVYU63Ejs.__name.call(void 0, entriesToSend, "entriesToSend");
+async function applyResult(store, entry, result) {
+  if (result.status === "applied") {
+    await store.removeQueueEntry(entry.seq);
+    const typeNames = syncedTypeNames();
+    const stillWaiting = _chunkB6JGKDP2js.waitingRecordKeys.call(void 0, await store.queue(), typeNames);
+    for (const key of _chunkB6JGKDP2js.recordKeysOfEntry.call(void 0, 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 _chunkB6JGKDP2js.writeThrough.call(void 0, 
+        { method: entry.method, url: entry.path },
+        { ok: true, status: 200, statusText: "OK", data: result.response }
+      );
+    } else if (entry.method === "DELETE") {
+      await _chunkB6JGKDP2js.writeThrough.call(void 0, 
+        { 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" : _nullishCoalesce(result.conflict, () => ( "fields")),
+      recordType: entry.recordType,
+      recordId: entry.recordId,
+      mine: _nullishCoalesce(entry.body, () => ( null)),
+      theirs: _nullishCoalesce(result.current, () => ( null)),
+      base: _nullishCoalesce(entry.base, () => ( null)),
+      merged: mergedResource(result.current, result.merged),
+      fields: _nullishCoalesce(result.conflictFields, () => ( [])),
+      blocks: result.conflictBlocks,
+      reason: result.detail
+    });
+    await store.setQueueStatus(entry.seq, "conflict");
+    return "conflict";
+  }
+  await store.setQueueStatus(entry.seq, "pending");
+  return "pending";
+}
+_chunk7QVYU63Ejs.__name.call(void 0, applyResult, "applyResult");
+async function drain() {
+  const outcome = { applied: 0, conflicts: 0, stoppedForLogin: false };
+  if (!_chunkMHB36MYEjs.isOfflineConfigured.call(void 0, ) || !_chunkMHB36MYEjs.getOfflineConfig.call(void 0, ).getUserId()) return outcome;
+  const store = await _chunkMHB36MYEjs.getOfflineStore.call(void 0, );
+  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 };
+  _chunkMHB36MYEjs.setOfflineState.call(void 0, { 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 (0, _chunkBZ5J2FIVjs.EndpointCreator)({ endpoint: _chunkBZ5J2FIVjs.Modules.OfflineChangeSet }).generate();
+    const release = _chunkMHB36MYEjs.allowWhileReconnecting.call(void 0, _chunkQKNGZDSQjs.buildUrl.call(void 0, endpoint));
+    let response;
+    try {
+      response = await _chunkQKNGZDSQjs.JsonApiPost.call(void 0, {
+        classKey: _chunkBZ5J2FIVjs.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");
+    }
+    _chunkMHB36MYEjs.setOfflineState.call(void 0, { draining: false });
+    await refreshOfflineCounts(store);
+  }
+}
+_chunk7QVYU63Ejs.__name.call(void 0, drain, "drain");
+var _inFlight;
+function drainQueue() {
+  if (!_inFlight) {
+    _inFlight = drain().finally(() => {
+      _inFlight = void 0;
+    });
+  }
+  return _inFlight;
+}
+_chunk7QVYU63Ejs.__name.call(void 0, drainQueue, "drainQueue");
+
+// src/offline/sync/conflicts.ts
+function updatedAtOf(resource) {
+  const value = _optionalChain([resource, 'optionalAccess', _20 => _20.attributes, 'optionalAccess', _21 => _21.updatedAt]);
+  if (!value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+_chunk7QVYU63Ejs.__name.call(void 0, 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 = { ..._nullishCoalesce(_optionalChain([record, 'access', _22 => _22.resource, 'optionalAccess', _23 => _23.attributes]), () => ( {})) };
+  const relationships = { ..._nullishCoalesce(_optionalChain([record, 'access', _24 => _24.resource, 'optionalAccess', _25 => _25.relationships]), () => ( {})) };
+  for (const [field, choice] of Object.entries(choices)) {
+    const source = choice === "theirs" ? conflict.theirs : choice === "merged" ? _optionalChain([mergedBody, 'optionalAccess', _26 => _26.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 } });
+}
+_chunk7QVYU63Ejs.__name.call(void 0, 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`);
+}
+_chunk7QVYU63Ejs.__name.call(void 0, rootIdOf, "rootIdOf");
+function collectionPath(recordType) {
+  const module = _optionalChain([_chunkMHB36MYEjs.getOfflineConfig.call(void 0, ), 'access', _27 => _27.types, 'access', _28 => _28.find, 'call', _29 => _29((typeConfig) => typeConfig.module.name === recordType), 'optionalAccess', _30 => _30.module]);
+  return new (0, _chunkBZ5J2FIVjs.EndpointCreator)({ endpoint: _nullishCoalesce(module, () => ( recordType)) }).generate();
+}
+_chunk7QVYU63Ejs.__name.call(void 0, collectionPath, "collectionPath");
+async function requeueOriginal(store, conflict, entry, fallbackMethod, resolution) {
+  const method = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _31 => _31.method]), () => ( fallbackMethod));
+  const body = method === "DELETE" ? void 0 : _nullishCoalesce(_nullishCoalesce(_optionalChain([entry, 'optionalAccess', _32 => _32.body]), () => ( conflict.mine)), () => ( void 0));
+  await store.enqueue({
+    rootId: await rootIdOf(store, conflict, entry),
+    method,
+    path: _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _33 => _33.path]), () => ( new (0, _chunkBZ5J2FIVjs.EndpointCreator)({ endpoint: collectionPath(conflict.recordType), id: conflict.recordId }).generate())),
+    ...body !== void 0 ? { body } : {},
+    recordType: _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _34 => _34.recordType]), () => ( conflict.recordType)),
+    recordId: _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _35 => _35.recordId]), () => ( conflict.recordId)),
+    base: entry ? entry.base : _nullishCoalesce(conflict.base, () => ( null)),
+    // QueueEntry["resolution"] is the store's copy of OfflineChange["resolution"].
+    resolution
+  });
+  if (entry) await store.removeQueueEntry(entry.seq);
+}
+_chunk7QVYU63Ejs.__name.call(void 0, requeueOriginal, "requeueOriginal");
+async function resolve(store, conflict, choice) {
+  const entry = (await store.queue()).find((candidate) => candidate.seq === conflict.queueSeq);
+  const dropEntry = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, 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 = _nullishCoalesce(conflict.mine, () => ( _optionalChain([entry, 'optionalAccess', _36 => _36.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 (_optionalChain([body, 'optionalAccess', _37 => _37.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);
+}
+_chunk7QVYU63Ejs.__name.call(void 0, resolve, "resolve");
+async function resolveConflict(id, choice) {
+  const store = await _chunkMHB36MYEjs.getOfflineStore.call(void 0, );
+  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 (_chunkMHB36MYEjs.getOfflineState.call(void 0, ).online) {
+    drainQueue().catch((error) => console.warn("[offline] sending the resolved change failed", error));
+  }
+}
+_chunk7QVYU63Ejs.__name.call(void 0, resolveConflict, "resolveConflict");
+
+// src/offline/sync/runtime.ts
+
+var LOCK_CHECK_INTERVAL_MS = 6e4;
+var PROBE_INTERVAL_MS = 3e4;
+async function probeApi() {
+  const config = _chunkMHB36MYEjs.getOfflineConfig.call(void 0, );
+  const store = await _chunkMHB36MYEjs.getOfflineStore.call(void 0, );
+  const [rootId] = await _chunkB6JGKDP2js.knownRootIds.call(void 0, store);
+  const endpoint = rootId ? new (0, _chunkBZ5J2FIVjs.EndpointCreator)({ endpoint: config.rootModule, id: rootId, childEndpoint: _chunkBZ5J2FIVjs.ROOT_SYNC_ENDPOINT }) : new (0, _chunkBZ5J2FIVjs.EndpointCreator)({ endpoint: config.rootModule }).addAdditionalParam("page[size]", "1");
+  const response = await _chunkKMW7UNL2js.directFetch.call(void 0, {
+    method: "GET",
+    url: _chunkQKNGZDSQjs.buildUrl.call(void 0, endpoint.generate()),
+    token: await _chunkLXKSUWAVjs.getClientToken.call(void 0, ),
+    language: currentLocale(),
+    additionalHeaders: { [_chunkMHB36MYEjs.OFFLINE_REPLAY_HEADER]: "1" }
+  });
+  return !response.networkError;
+}
+_chunk7QVYU63Ejs.__name.call(void 0, probeApi, "probeApi");
+var LOGIN_RELOAD_KEY = "nja-offline-login-reload";
+var _reloadedForSignIn;
+async function signInFingerprint() {
+  const token = await _cookiesnext.getCookie.call(void 0, "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);
+}
+_chunk7QVYU63Ejs.__name.call(void 0, signInFingerprint, "signInFingerprint");
+var readReloadMarker = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, () => {
+  try {
+    return window.sessionStorage.getItem(LOGIN_RELOAD_KEY);
+  } catch (e2) {
+    return null;
+  }
+}, "readReloadMarker");
+var writeReloadMarker = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, (value) => {
+  try {
+    if (value === null) window.sessionStorage.removeItem(LOGIN_RELOAD_KEY);
+    else window.sessionStorage.setItem(LOGIN_RELOAD_KEY, value);
+  } catch (e3) {
+  }
+}, "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);
+  }
+}
+_chunk7QVYU63Ejs.__name.call(void 0, signInExpired, "signInExpired");
+var warnUnlessUnavailable = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, (message) => (error) => {
+  if (!(error instanceof _chunkMHB36MYEjs.OfflineUnavailableError)) console.warn(message, error);
+}, "warnUnlessUnavailable");
+var _runningRuntimes = /* @__PURE__ */ new Set();
+function stopOfflineRuntime() {
+  for (const stop of [..._runningRuntimes]) stop();
+}
+_chunk7QVYU63Ejs.__name.call(void 0, stopOfflineRuntime, "stopOfflineRuntime");
+function startOfflineRuntime() {
+  _chunkMHB36MYEjs.refreshOfflineDeviceState.call(void 0, );
+  if (!_chunkMHB36MYEjs.isOfflineConfigured.call(void 0, )) return () => {
+  };
+  const config = _chunkMHB36MYEjs.getOfflineConfig.call(void 0, );
+  let running;
+  let goingOnlineAfterSync = false;
+  const run = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, (reconnect) => {
+    if (!running) {
+      running = (async () => {
+        let succeeded = false;
+        if (reconnect) _chunkMHB36MYEjs.setReconnecting.call(void 0, true);
+        try {
+          const drained = await drainQueue();
+          if (drained.stoppedForLogin) {
+            await signInExpired();
+            return;
+          }
+          writeReloadMarker(null);
+          if (reconnect ? !_chunkMHB36MYEjs.isReconnecting.call(void 0, ) : !_chunkMHB36MYEjs.getOfflineState.call(void 0, ).online) return;
+          await syncAll();
+          succeeded = reconnect && _chunkMHB36MYEjs.isReconnecting.call(void 0, );
+        } catch (error) {
+          warnUnlessUnavailable("[offline] background sync failed")(error);
+        } finally {
+          if (reconnect) _chunkMHB36MYEjs.setReconnecting.call(void 0, false);
+          running = void 0;
+          if (succeeded) {
+            goingOnlineAfterSync = true;
+            _chunkMHB36MYEjs.setOfflineState.call(void 0, { online: true });
+            goingOnlineAfterSync = false;
+            if (_chunkMHB36MYEjs.getOfflineState.call(void 0, ).pending > 0) {
+              drainQueue().catch(warnUnlessUnavailable("[offline] sending the waiting changes failed"));
+            }
+          }
+        }
+      })();
+    }
+    return running;
+  }, "run");
+  const runOnline = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, () => run(false), "runOnline");
+  let probing = false;
+  const probe = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, async () => {
+    if (probing || running || _chunkMHB36MYEjs.getOfflineState.call(void 0, ).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__ */ _chunk7QVYU63Ejs.__name.call(void 0, () => void probe(), "onBrowserOnline");
+  if (typeof window !== "undefined") window.addEventListener("online", onBrowserOnline);
+  let wasOnline = _chunkMHB36MYEjs.getOfflineState.call(void 0, ).online;
+  const unsubscribe = _chunkMHB36MYEjs.subscribeOfflineState.call(void 0, (state) => {
+    if (!state.available) {
+      stop();
+      return;
+    }
+    if (state.online && !wasOnline && !goingOnlineAfterSync) void runOnline();
+    wasOnline = state.online;
+  });
+  void _chunkB6JGKDP2js.refreshLockedRoots.call(void 0, ).catch(warnUnlessUnavailable("[offline] lock check failed"));
+  void refreshOfflineCounts().catch(warnUnlessUnavailable("[offline] reading the queue failed"));
+  if (_chunkMHB36MYEjs.getOfflineState.call(void 0, ).online) void runOnline();
+  const syncTimer = setInterval(() => {
+    if (_chunkMHB36MYEjs.getOfflineState.call(void 0, ).online) void runOnline();
+  }, config.syncIntervalMs);
+  const probeTimer = setInterval(() => void probe(), PROBE_INTERVAL_MS);
+  const lockTimer = setInterval(() => {
+    void _chunkB6JGKDP2js.refreshLockedRoots.call(void 0, ).catch(warnUnlessUnavailable("[offline] lock check failed"));
+  }, LOCK_CHECK_INTERVAL_MS);
+  const stop = /* @__PURE__ */ _chunk7QVYU63Ejs.__name.call(void 0, () => {
+    _runningRuntimes.delete(stop);
+    clearInterval(syncTimer);
+    clearInterval(probeTimer);
+    clearInterval(lockTimer);
+    if (typeof window !== "undefined") window.removeEventListener("online", onBrowserOnline);
+    unsubscribe();
+  }, "stop");
+  _runningRuntimes.add(stop);
+  return stop;
+}
+_chunk7QVYU63Ejs.__name.call(void 0, startOfflineRuntime, "startOfflineRuntime");
+
+// src/offline/logout.ts
+async function prepareOfflineLogout() {
+  if (!_chunkMHB36MYEjs.isOfflineConfigured.call(void 0, )) return { pending: 0 };
+  if (!_chunkMHB36MYEjs.getOfflineConfig.call(void 0, ).getUserId()) return { pending: 0 };
+  const store = await _chunkMHB36MYEjs.getOfflineStore.call(void 0, );
+  const entries = await store.queue();
+  return { pending: entries.length };
+}
+_chunk7QVYU63Ejs.__name.call(void 0, prepareOfflineLogout, "prepareOfflineLogout");
+async function finishOfflineLogout(userId) {
+  stopOfflineRuntime();
+  _chunkMHB36MYEjs.blockOfflineStore.call(void 0, userId);
+  const { deleteDeviceStore: deleteDeviceStore2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("../lifecycle-4GUOTB46.js")));
+  await deleteDeviceStore2(userId);
+  await _chunkPXDUJ47Njs.deleteImagesCaches.call(void 0, );
+  _chunkMHB36MYEjs.setOfflineEnabledOnDevice.call(void 0, userId, false);
+  _chunkMHB36MYEjs.writeOfflineLastSync.call(void 0, userId, null);
+  _chunkMHB36MYEjs.setOfflineState.call(void 0, { enabled: false, syncProgress: null, lastSyncedAt: null, rootCount: null });
+}
+_chunk7QVYU63Ejs.__name.call(void 0, finishOfflineLogout, "finishOfflineLogout");
+
+// src/offline/device-switch.ts
+function signedInUserId() {
+  const userId = _chunkMHB36MYEjs.getOfflineConfig.call(void 0, ).getUserId();
+  if (!userId) throw new Error("No signed-in user");
+  return userId;
+}
+_chunk7QVYU63Ejs.__name.call(void 0, signedInUserId, "signedInUserId");
+async function turnOnOffline() {
+  const userId = signedInUserId();
+  _chunkMHB36MYEjs.setOfflineEnabledOnDevice.call(void 0, userId, true);
+  _chunkMHB36MYEjs.setOfflineState.call(void 0, { enabled: true });
+  try {
+    await _optionalChain([navigator, 'access', _38 => _38.storage, 'optionalAccess', _39 => _39.persist, 'optionalCall', _40 => _40()]);
+  } catch (e4) {
+  }
+}
+_chunk7QVYU63Ejs.__name.call(void 0, turnOnOffline, "turnOnOffline");
+async function turnOffOffline() {
+  const userId = signedInUserId();
+  if (_chunkMHB36MYEjs.isOfflineAvailable.call(void 0, )) {
+    let pending = 0;
+    try {
+      const store = await _chunkMHB36MYEjs.getOfflineStore.call(void 0, );
+      pending = (await store.queue()).length;
+    } catch (e5) {
+      const { hasUnsentChanges: hasUnsentChanges2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("../lifecycle-4GUOTB46.js")));
+      if (await hasUnsentChanges2(userId).catch(() => false)) pending = 1;
+    }
+    if (pending > 0) return { turnedOff: false, pending };
+  }
+  _chunkMHB36MYEjs.setOfflineEnabledOnDevice.call(void 0, userId, false);
+  if (_chunkMHB36MYEjs.isOfflineAvailable.call(void 0, )) {
+    stopOfflineRuntime();
+    try {
+      const { deleteDeviceStore: deleteDeviceStore2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("../lifecycle-4GUOTB46.js")));
+      await deleteDeviceStore2(userId);
+      await _chunkPXDUJ47Njs.deleteImagesCaches.call(void 0, );
+    } catch (error) {
+      console.warn("[offline] the device copy could not be deleted", error);
+    }
+    _chunkMHB36MYEjs.forgetOfflineStore.call(void 0, userId);
+  }
+  _chunkMHB36MYEjs.writeOfflineLastSync.call(void 0, userId, null);
+  _chunkMHB36MYEjs.setOfflineState.call(void 0, { enabled: false, syncProgress: null, lastSyncedAt: null, rootCount: null });
+  return { turnedOff: true };
+}
+_chunk7QVYU63Ejs.__name.call(void 0, turnOffOffline, "turnOffOffline");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_DEVICE_WORKER_URL = _chunkMHB36MYEjs.DEFAULT_DEVICE_WORKER_URL; exports.DEFAULT_SQLITE_MODULE_URL = _chunkMHB36MYEjs.DEFAULT_SQLITE_MODULE_URL; exports.DEVICE_WORKER_FILE = _chunkMHB36MYEjs.DEVICE_WORKER_FILE; exports.DeviceStoreUnavailableError = _chunkMHB36MYEjs.DeviceStoreUnavailableError; exports.NeedsConnectionError = _chunkMHB36MYEjs.NeedsConnectionError; exports.OFFLINE_REPLAY_HEADER = _chunkMHB36MYEjs.OFFLINE_REPLAY_HEADER; exports.OFFLINE_SQLITE_FILES = _chunkMHB36MYEjs.OFFLINE_SQLITE_FILES; exports.OfflineUnavailableError = _chunkMHB36MYEjs.OfflineUnavailableError; exports.SERVER_DEFAULT_ORDER_BY = _chunkW62MHDWMjs.SERVER_DEFAULT_ORDER_BY; exports.configureOffline = configureOffline2; exports.deleteDeviceStore = _chunkPXDUJ47Njs.deleteDeviceStore; exports.drainQueue = drainQueue; exports.errorAnswer = _chunkW62MHDWMjs.errorAnswer; exports.finishOfflineLogout = finishOfflineLogout; exports.forgetOfflineStore = _chunkMHB36MYEjs.forgetOfflineStore; exports.getOfflineConfig = _chunkMHB36MYEjs.getOfflineConfig; exports.getOfflineState = _chunkMHB36MYEjs.getOfflineState; exports.getOfflineStore = _chunkMHB36MYEjs.getOfflineStore; exports.hasUnsentChanges = _chunkPXDUJ47Njs.hasUnsentChanges; exports.includedFor = _chunkW62MHDWMjs.includedFor; exports.isOfflineAvailable = _chunkMHB36MYEjs.isOfflineAvailable; exports.isOfflineConfigured = _chunkMHB36MYEjs.isOfflineConfigured; exports.isOfflineEnabledOnDevice = _chunkMHB36MYEjs.isOfflineEnabledOnDevice; exports.isRootLocked = _chunkPXDUJ47Njs.isRootLocked; exports.linkKindFor = _chunkW62MHDWMjs.linkKindFor; exports.linkKindsOf = _chunkW62MHDWMjs.linkKindsOf; exports.linksOfKind = _chunkW62MHDWMjs.linksOfKind; exports.listAnswer = _chunkW62MHDWMjs.listAnswer; exports.localTransport = _chunkW62MHDWMjs.localTransport; exports.matchPattern = _chunkW62MHDWMjs.matchPattern; exports.matchRoute = _chunkW62MHDWMjs.matchRoute; exports.mergeResource = _chunkW62MHDWMjs.mergeResource; exports.needsConnectionAnswer = _chunkW62MHDWMjs.needsConnectionAnswer; exports.notFoundAnswer = _chunkW62MHDWMjs.notFoundAnswer; exports.onUserSignedIn = _chunkPXDUJ47Njs.onUserSignedIn; exports.openDeviceStore = _chunkPXDUJ47Njs.openDeviceStore; exports.openMemoryDeviceStore = _chunkPXDUJ47Njs.openMemoryDeviceStore; exports.orderRecords = _chunkW62MHDWMjs.orderRecords; exports.orderedListAnswer = _chunkW62MHDWMjs.orderedListAnswer; exports.patternToString = _chunkMHB36MYEjs.patternToString; exports.prepareOfflineLogout = prepareOfflineLogout; exports.refreshOfflineDeviceState = _chunkMHB36MYEjs.refreshOfflineDeviceState; exports.resolveConflict = resolveConflict; exports.resourceFromDocument = _chunkW62MHDWMjs.resourceFromDocument; exports.resourceListAnswer = _chunkW62MHDWMjs.resourceListAnswer; exports.searchRecords = _chunkW62MHDWMjs.searchRecords; exports.setDeviceStoreOpener = _chunkMHB36MYEjs.setDeviceStoreOpener; exports.setOfflineState = _chunkMHB36MYEjs.setOfflineState; exports.singleAnswer = _chunkW62MHDWMjs.singleAnswer; exports.startOfflineRuntime = startOfflineRuntime; exports.stopOfflineRuntime = stopOfflineRuntime; exports.subscribeOfflineState = _chunkMHB36MYEjs.subscribeOfflineState; exports.syncAll = syncAll; exports.syncRoot = syncRoot; exports.turnOffOffline = turnOffOffline; exports.turnOnOffline = turnOnOffline; exports.useConflicts = useConflicts; exports.useNeedsConnection = _chunkGB6DBFYYjs.useNeedsConnection; exports.useOfflineState = _chunkGB6DBFYYjs.useOfflineState; exports.writeThrough = _chunkB6JGKDP2js.writeThrough;
+//# sourceMappingURL=index.js.map