@carlonicora/nextjs-jsonapi 6.12.1 → 6.13.0

package/dist/chunk-7DBJTNSU.mjs

@@ -0,0 +1,1049 @@
+import {
+  DeviceStoreUnavailableError,
+  OfflineUnavailableError,
+  forgetOfflineStore,
+  getDeviceWorkerUrl,
+  getSqliteModuleUrl,
+  isOfflineAvailable,
+  isOfflineStoreBlocked,
+  markOfflineUnavailable,
+  refreshOfflineDeviceState,
+  unblockOfflineStore
+} from "./chunk-27LQDGNP.mjs";
+import {
+  __name
+} from "./chunk-PAWJFY3S.mjs";
+
+// src/offline/sync/artwork-cache.ts
+var IMAGES_CACHE_SUFFIX = "-images";
+var OFFLINE_CACHE_MARKER = "-offline-";
+async function imagesCacheName() {
+  if (typeof caches === "undefined") return void 0;
+  const keys = await caches.keys();
+  const existing = keys.find((key) => key.endsWith(IMAGES_CACHE_SUFFIX));
+  if (existing) return existing;
+  const offline = keys.find((key) => key.includes(OFFLINE_CACHE_MARKER));
+  if (!offline) return void 0;
+  return `${offline.slice(0, offline.indexOf(OFFLINE_CACHE_MARKER))}${IMAGES_CACHE_SUFFIX}`;
+}
+__name(imagesCacheName, "imagesCacheName");
+function imageUrlOf(resource) {
+  const url = resource?.attributes?.imageUrl;
+  return typeof url === "string" && url.length > 0 ? url : void 0;
+}
+__name(imageUrlOf, "imageUrlOf");
+async function cacheArtworkImage(url, previousUrl) {
+  const name = await imagesCacheName();
+  if (!name) return;
+  const cache = await caches.open(name);
+  if (previousUrl && previousUrl !== url) await cache.delete(previousUrl);
+  if (await cache.match(url)) return;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      console.warn("[offline] could not download an artwork image", url, response.status);
+      return;
+    }
+    await cache.put(url, response);
+  } catch (error) {
+    console.warn("[offline] could not download an artwork image", url, error);
+  }
+}
+__name(cacheArtworkImage, "cacheArtworkImage");
+async function removeArtworkImage(url) {
+  const name = await imagesCacheName();
+  if (!name) return;
+  const cache = await caches.open(name);
+  await cache.delete(url);
+}
+__name(removeArtworkImage, "removeArtworkImage");
+async function deleteImagesCaches() {
+  if (typeof caches === "undefined") return;
+  const keys = await caches.keys();
+  await Promise.all(keys.filter((key) => key.endsWith(IMAGES_CACHE_SUFFIX)).map((key) => caches.delete(key)));
+}
+__name(deleteImagesCaches, "deleteImagesCaches");
+
+// src/offline/store/schema.ts
+var DEVICE_STORE_SCHEMA_VERSION = 3;
+var DEVICE_STORE_RESET = [
+  `DROP TABLE IF EXISTS records`,
+  `DROP TABLE IF EXISTS record_campaigns`,
+  `DROP TABLE IF EXISTS record_roots`,
+  `DROP TABLE IF EXISTS links`,
+  `DROP TABLE IF EXISTS queue`,
+  `DROP TABLE IF EXISTS conflicts`,
+  `DROP TABLE IF EXISTS sync_state`,
+  `DROP TABLE IF EXISTS skipped_records`
+];
+var DEVICE_STORE_SCHEMA = [
+  `CREATE TABLE IF NOT EXISTS records (
+    type TEXT NOT NULL,
+    id TEXT NOT NULL,
+    root_id TEXT NOT NULL,
+    resource TEXT NOT NULL,
+    updated_at TEXT,
+    base TEXT,
+    local_only INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (type, id)
+  )`,
+  `CREATE INDEX IF NOT EXISTS records_type_root ON records (type, root_id)`,
+  `CREATE TABLE IF NOT EXISTS record_roots (
+    type TEXT NOT NULL,
+    id TEXT NOT NULL,
+    root_id TEXT NOT NULL,
+    PRIMARY KEY (type, id, root_id)
+  )`,
+  `CREATE INDEX IF NOT EXISTS record_roots_root ON record_roots (root_id, type)`,
+  `CREATE TABLE IF NOT EXISTS links (
+    from_id TEXT NOT NULL,
+    from_type TEXT NOT NULL,
+    to_id TEXT NOT NULL,
+    to_type TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    props TEXT NOT NULL DEFAULT '{}',
+    root_id TEXT,
+    PRIMARY KEY (from_id, to_id, kind)
+  )`,
+  `CREATE INDEX IF NOT EXISTS links_from ON links (from_id)`,
+  `CREATE INDEX IF NOT EXISTS links_to ON links (to_id)`,
+  `CREATE INDEX IF NOT EXISTS links_root ON links (root_id)`,
+  `CREATE TABLE IF NOT EXISTS queue (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    root_id TEXT NOT NULL,
+    request TEXT NOT NULL,
+    base TEXT,
+    created_at TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'pending',
+    package_id TEXT
+  )`,
+  `CREATE INDEX IF NOT EXISTS queue_status_seq ON queue (status, seq)`,
+  `CREATE TABLE IF NOT EXISTS conflicts (
+    id TEXT PRIMARY KEY,
+    queue_seq INTEGER NOT NULL,
+    root_id TEXT,
+    kind TEXT NOT NULL,
+    record_type TEXT,
+    record_id TEXT,
+    mine TEXT,
+    theirs TEXT,
+    base TEXT,
+    merged TEXT,
+    fields TEXT NOT NULL DEFAULT '[]',
+    blocks TEXT,
+    reason TEXT
+  )`,
+  `CREATE TABLE IF NOT EXISTS sync_state (
+    root_id TEXT PRIMARY KEY,
+    server_time TEXT,
+    locked INTEGER NOT NULL DEFAULT 0,
+    locked_from TEXT
+  )`,
+  `CREATE TABLE IF NOT EXISTS skipped_records (
+    root_id TEXT NOT NULL,
+    type TEXT NOT NULL,
+    id TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (root_id, type, id)
+  )`,
+  `PRAGMA user_version = ${DEVICE_STORE_SCHEMA_VERSION}`
+];
+
+// src/offline/store/sql-device-store.ts
+var toJson = /* @__PURE__ */ __name((value) => value === void 0 || value === null ? null : JSON.stringify(value), "toJson");
+var fromJson = /* @__PURE__ */ __name((value) => value === null || value === void 0 ? null : JSON.parse(String(value)), "fromJson");
+var toIso = /* @__PURE__ */ __name((value) => value ? value.toISOString() : null, "toIso");
+var fromIso = /* @__PURE__ */ __name((value) => value === null || value === void 0 ? null : new Date(String(value)), "fromIso");
+var newId = /* @__PURE__ */ __name(() => typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`, "newId");
+var rowToRecord = /* @__PURE__ */ __name((row) => ({
+  type: String(row.type),
+  id: String(row.id),
+  rootId: String(row.root_id),
+  resource: fromJson(row.resource),
+  updatedAt: fromIso(row.updated_at),
+  base: fromJson(row.base),
+  localOnly: Number(row.local_only) === 1
+}), "rowToRecord");
+var rowToLink = /* @__PURE__ */ __name((row) => ({
+  fromType: String(row.from_type),
+  fromId: String(row.from_id),
+  toType: String(row.to_type),
+  toId: String(row.to_id),
+  kind: String(row.kind),
+  props: fromJson(row.props) ?? {}
+}), "rowToLink");
+var rowToQueueEntry = /* @__PURE__ */ __name((row) => {
+  const request = fromJson(row.request) ?? {};
+  const entry = {
+    seq: Number(row.seq),
+    rootId: String(row.root_id),
+    method: request.method,
+    path: request.path,
+    base: fromJson(row.base),
+    createdAt: new Date(String(row.created_at)),
+    status: String(row.status)
+  };
+  if (request.body !== void 0) entry.body = request.body;
+  if (request.recordType !== void 0) entry.recordType = request.recordType;
+  if (request.recordId !== void 0) entry.recordId = request.recordId;
+  if (request.resolution !== void 0) entry.resolution = request.resolution;
+  if (row.package_id !== null && row.package_id !== void 0) entry.packageId = String(row.package_id);
+  return entry;
+}, "rowToQueueEntry");
+var rowToConflict = /* @__PURE__ */ __name((row) => {
+  const conflict = {
+    id: String(row.id),
+    queueSeq: Number(row.queue_seq),
+    kind: String(row.kind),
+    mine: fromJson(row.mine),
+    theirs: fromJson(row.theirs),
+    base: fromJson(row.base),
+    fields: fromJson(row.fields) ?? []
+  };
+  if (row.record_type !== null && row.record_type !== void 0) conflict.recordType = String(row.record_type);
+  if (row.record_id !== null && row.record_id !== void 0) conflict.recordId = String(row.record_id);
+  const merged = fromJson(row.merged);
+  if (merged !== null) conflict.merged = merged;
+  const blocks = fromJson(row.blocks);
+  if (blocks !== null) conflict.blocks = blocks;
+  if (row.reason !== null && row.reason !== void 0) conflict.reason = String(row.reason);
+  return conflict;
+}, "rowToConflict");
+var createOperations = /* @__PURE__ */ __name((exec, hooks) => {
+  const insertLink = /* @__PURE__ */ __name(async (link, rootId) => {
+    await exec(
+      `INSERT OR REPLACE INTO links (from_id, from_type, to_id, to_type, kind, props, root_id) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [link.fromId, link.fromType, link.toId, link.toType, link.kind, JSON.stringify(link.props ?? {}), rootId]
+    );
+  }, "insertLink");
+  const deleteRecordEverywhere = /* @__PURE__ */ __name(async (type, id) => {
+    await exec(`DELETE FROM records WHERE type = ? AND id = ?`, [type, id]);
+    await exec(`DELETE FROM record_roots WHERE type = ? AND id = ?`, [type, id]);
+    await exec(`DELETE FROM links WHERE from_id = ? OR to_id = ?`, [id, id]);
+  }, "deleteRecordEverywhere");
+  return {
+    async getRecord(type, id) {
+      const rows = await exec(`SELECT * FROM records WHERE type = ? AND id = ?`, [type, id]);
+      return rows[0] ? rowToRecord(rows[0]) : void 0;
+    },
+    async listRecords(filter) {
+      if (filter.ids && filter.ids.length === 0) return [];
+      const where = ["type = ?"];
+      const bind = [filter.type];
+      if (filter.rootId !== void 0) {
+        where.push(
+          "EXISTS (SELECT 1 FROM record_roots rc WHERE rc.type = records.type AND rc.id = records.id AND rc.root_id = ?)"
+        );
+        bind.push(filter.rootId);
+      }
+      if (filter.ids) {
+        where.push(`id IN (${filter.ids.map(() => "?").join(", ")})`);
+        bind.push(...filter.ids);
+      }
+      const rows = await exec(`SELECT * FROM records WHERE ${where.join(" AND ")} ORDER BY rowid`, bind);
+      return rows.map(rowToRecord);
+    },
+    async putRecord(record) {
+      await exec(
+        `INSERT INTO records (type, id, root_id, resource, updated_at, base, local_only) VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (type, id) DO UPDATE SET resource = excluded.resource, updated_at = excluded.updated_at,
+           base = excluded.base, local_only = excluded.local_only`,
+        [
+          record.type,
+          record.id,
+          record.rootId,
+          JSON.stringify(record.resource),
+          toIso(record.updatedAt),
+          toJson(record.base),
+          record.localOnly ? 1 : 0
+        ]
+      );
+      await exec(`INSERT OR IGNORE INTO record_roots (type, id, root_id) VALUES (?, ?, ?)`, [
+        record.type,
+        record.id,
+        record.rootId
+      ]);
+    },
+    async deleteRecord(type, id) {
+      await deleteRecordEverywhere(type, id);
+    },
+    async removeRecordFromRoot(type, id, rootId) {
+      await exec(`DELETE FROM record_roots WHERE type = ? AND id = ? AND root_id = ?`, [type, id, rootId]);
+      const left = await exec(`SELECT root_id FROM record_roots WHERE type = ? AND id = ? ORDER BY root_id`, [
+        type,
+        id
+      ]);
+      if (left.length === 0) {
+        await deleteRecordEverywhere(type, id);
+        return;
+      }
+      await exec(`UPDATE records SET root_id = ? WHERE type = ? AND id = ? AND root_id = ?`, [
+        String(left[0].root_id),
+        type,
+        id,
+        rootId
+      ]);
+    },
+    async linksFrom(fromId, kind) {
+      const rows = kind === void 0 ? await exec(`SELECT * FROM links WHERE from_id = ? ORDER BY rowid`, [fromId]) : await exec(`SELECT * FROM links WHERE from_id = ? AND kind = ? ORDER BY rowid`, [fromId, kind]);
+      return rows.map(rowToLink);
+    },
+    async linksTo(toId, kind) {
+      const rows = kind === void 0 ? await exec(`SELECT * FROM links WHERE to_id = ? ORDER BY rowid`, [toId]) : await exec(`SELECT * FROM links WHERE to_id = ? AND kind = ? ORDER BY rowid`, [toId, kind]);
+      return rows.map(rowToLink);
+    },
+    async replaceRootLinks(rootId, links) {
+      await exec(`DELETE FROM links WHERE root_id = ?`, [rootId]);
+      for (const link of links) await insertLink(link, rootId);
+    },
+    async putLink(link) {
+      const owner = await exec(`SELECT root_id FROM records WHERE id IN (?, ?) ORDER BY id = ? DESC LIMIT 1`, [
+        link.fromId,
+        link.toId,
+        link.fromId
+      ]);
+      await insertLink(link, owner[0] ? String(owner[0].root_id) : null);
+    },
+    async deleteLink(link) {
+      await exec(`DELETE FROM links WHERE from_id = ? AND to_id = ? AND kind = ?`, [link.fromId, link.toId, link.kind]);
+    },
+    async enqueue(entry) {
+      if (hooks.beforeEnqueue) await hooks.beforeEnqueue();
+      const request = {
+        method: entry.method,
+        path: entry.path,
+        body: entry.body,
+        recordType: entry.recordType,
+        recordId: entry.recordId,
+        resolution: entry.resolution
+      };
+      const rows = await exec(
+        `INSERT INTO queue (root_id, request, base, created_at, status) VALUES (?, ?, ?, ?, 'pending') RETURNING seq`,
+        [entry.rootId, JSON.stringify(request), toJson(entry.base), (/* @__PURE__ */ new Date()).toISOString()]
+      );
+      return Number(rows[0].seq);
+    },
+    async queue(filter) {
+      const rows = filter?.status ? await exec(`SELECT * FROM queue WHERE status = ? ORDER BY seq`, [filter.status]) : await exec(`SELECT * FROM queue ORDER BY seq`);
+      return rows.map(rowToQueueEntry);
+    },
+    async setQueueStatus(seq, status) {
+      await exec(`UPDATE queue SET status = ? WHERE seq = ?`, [status, seq]);
+    },
+    async setQueuePackage(seqs, packageId) {
+      if (seqs.length === 0) return;
+      await exec(`UPDATE queue SET package_id = ? WHERE seq IN (${seqs.map(() => "?").join(", ")})`, [
+        packageId,
+        ...seqs
+      ]);
+    },
+    async removeQueueEntry(seq) {
+      await exec(`DELETE FROM queue WHERE seq = ?`, [seq]);
+    },
+    async addConflict(c) {
+      const id = newId();
+      const owner = await exec(`SELECT root_id FROM queue WHERE seq = ?`, [c.queueSeq]);
+      await exec(
+        `INSERT INTO conflicts (id, queue_seq, root_id, kind, record_type, record_id, mine, theirs, base, merged, fields, blocks, reason)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          id,
+          c.queueSeq,
+          owner[0] ? String(owner[0].root_id) : null,
+          c.kind,
+          c.recordType ?? null,
+          c.recordId ?? null,
+          toJson(c.mine),
+          toJson(c.theirs),
+          toJson(c.base),
+          toJson(c.merged),
+          JSON.stringify(c.fields ?? []),
+          toJson(c.blocks),
+          c.reason ?? null
+        ]
+      );
+      return id;
+    },
+    async conflicts() {
+      const rows = await exec(`SELECT * FROM conflicts ORDER BY queue_seq, rowid`);
+      return rows.map(rowToConflict);
+    },
+    async removeConflict(id) {
+      await exec(`DELETE FROM conflicts WHERE id = ?`, [id]);
+    },
+    async getSyncState(rootId) {
+      const rows = await exec(`SELECT * FROM sync_state WHERE root_id = ?`, [rootId]);
+      if (!rows[0]) return { serverTime: null, locked: false, lockedFrom: null };
+      return {
+        serverTime: fromIso(rows[0].server_time),
+        locked: Number(rows[0].locked) === 1,
+        lockedFrom: fromIso(rows[0].locked_from)
+      };
+    },
+    async setSyncState(rootId, s) {
+      await exec(`INSERT OR REPLACE INTO sync_state (root_id, server_time, locked, locked_from) VALUES (?, ?, ?, ?)`, [
+        rootId,
+        toIso(s.serverTime),
+        s.locked ? 1 : 0,
+        toIso(s.lockedFrom)
+      ]);
+    },
+    async skippedRecords(rootId) {
+      const rows = await exec(`SELECT * FROM skipped_records WHERE root_id = ? ORDER BY type, id`, [rootId]);
+      return rows.map((row) => ({
+        type: String(row.type),
+        id: String(row.id),
+        updatedAt: new Date(String(row.updated_at))
+      }));
+    },
+    async setSkippedRecords(rootId, records) {
+      await exec(`DELETE FROM skipped_records WHERE root_id = ?`, [rootId]);
+      for (const record of records) {
+        await exec(`INSERT OR REPLACE INTO skipped_records (root_id, type, id, updated_at) VALUES (?, ?, ?, ?)`, [
+          rootId,
+          record.type,
+          record.id,
+          record.updatedAt.toISOString()
+        ]);
+      }
+    },
+    async removeRoot(rootId) {
+      const waiting = await exec(`SELECT COUNT(*) AS n FROM queue WHERE root_id = ?`, [rootId]);
+      if (Number(waiting[0]?.n ?? 0) > 0) return;
+      await exec(`DELETE FROM links WHERE root_id = ?`, [rootId]);
+      await exec(`DELETE FROM record_roots WHERE root_id = ?`, [rootId]);
+      const orphans = `SELECT id FROM records r WHERE NOT EXISTS (SELECT 1 FROM record_roots rc WHERE rc.type = r.type AND rc.id = r.id)`;
+      await exec(`DELETE FROM links WHERE from_id IN (${orphans}) OR to_id IN (${orphans})`);
+      await exec(
+        `DELETE FROM records WHERE NOT EXISTS (SELECT 1 FROM record_roots rc WHERE rc.type = records.type AND rc.id = records.id)`
+      );
+      await exec(
+        `UPDATE records SET root_id = (SELECT MIN(rc.root_id) FROM record_roots rc WHERE rc.type = records.type AND rc.id = records.id) WHERE root_id = ?`,
+        [rootId]
+      );
+      await exec(`DELETE FROM conflicts WHERE root_id = ?`, [rootId]);
+      await exec(`DELETE FROM sync_state WHERE root_id = ?`, [rootId]);
+      await exec(`DELETE FROM skipped_records WHERE root_id = ?`, [rootId]);
+    },
+    async queueSize() {
+      const rows = await exec(`SELECT COUNT(*) AS n FROM queue`);
+      return Number(rows[0]?.n ?? 0);
+    }
+  };
+}, "createOperations");
+var nestedStore = /* @__PURE__ */ __name((ops) => {
+  const { queueSize: _queueSize, ...rest } = ops;
+  const store = { ...rest, transaction: /* @__PURE__ */ __name((fn) => fn(store), "transaction") };
+  return store;
+}, "nestedStore");
+async function createSqlDeviceStore(exec, hooks = {}) {
+  const exclusive = hooks.exclusive ?? ((fn) => fn());
+  await exclusive(async () => {
+    const version = Number((await exec(`PRAGMA user_version`))[0]?.user_version ?? 0);
+    if (version > 0 && version < DEVICE_STORE_SCHEMA_VERSION) {
+      for (const statement of DEVICE_STORE_RESET) await exec(statement);
+    }
+    for (const statement of DEVICE_STORE_SCHEMA) await exec(statement);
+  });
+  const ops = createOperations(exec, hooks);
+  let tail = Promise.resolve();
+  const serialised = /* @__PURE__ */ __name((fn) => {
+    const run = tail.then(
+      () => exclusive(fn),
+      () => exclusive(fn)
+    );
+    tail = run.catch(() => void 0);
+    return run;
+  }, "serialised");
+  const settleQueue = /* @__PURE__ */ __name(async () => {
+    if (hooks.afterQueueChange) await hooks.afterQueueChange(await ops.queueSize());
+  }, "settleQueue");
+  const store = {
+    getRecord: /* @__PURE__ */ __name((type, id) => serialised(() => ops.getRecord(type, id)), "getRecord"),
+    listRecords: /* @__PURE__ */ __name((filter) => serialised(() => ops.listRecords(filter)), "listRecords"),
+    putRecord: /* @__PURE__ */ __name((record) => serialised(() => ops.putRecord(record)), "putRecord"),
+    deleteRecord: /* @__PURE__ */ __name((type, id) => serialised(() => ops.deleteRecord(type, id)), "deleteRecord"),
+    removeRecordFromRoot: /* @__PURE__ */ __name((type, id, rootId) => serialised(() => ops.removeRecordFromRoot(type, id, rootId)), "removeRecordFromRoot"),
+    linksFrom: /* @__PURE__ */ __name((fromId, kind) => serialised(() => ops.linksFrom(fromId, kind)), "linksFrom"),
+    linksTo: /* @__PURE__ */ __name((toId, kind) => serialised(() => ops.linksTo(toId, kind)), "linksTo"),
+    replaceRootLinks: /* @__PURE__ */ __name((rootId, links) => serialised(async () => {
+      await exec("BEGIN");
+      try {
+        await ops.replaceRootLinks(rootId, links);
+        await exec("COMMIT");
+      } catch (error) {
+        await exec("ROLLBACK");
+        throw error;
+      }
+    }), "replaceRootLinks"),
+    putLink: /* @__PURE__ */ __name((link) => serialised(() => ops.putLink(link)), "putLink"),
+    deleteLink: /* @__PURE__ */ __name((link) => serialised(() => ops.deleteLink(link)), "deleteLink"),
+    enqueue: /* @__PURE__ */ __name((entry) => serialised(() => ops.enqueue(entry)), "enqueue"),
+    queue: /* @__PURE__ */ __name((filter) => serialised(() => ops.queue(filter)), "queue"),
+    setQueueStatus: /* @__PURE__ */ __name((seq, status) => serialised(() => ops.setQueueStatus(seq, status)), "setQueueStatus"),
+    setQueuePackage: /* @__PURE__ */ __name((seqs, packageId) => serialised(() => ops.setQueuePackage(seqs, packageId)), "setQueuePackage"),
+    removeQueueEntry: /* @__PURE__ */ __name((seq) => serialised(async () => {
+      await ops.removeQueueEntry(seq);
+      await settleQueue();
+    }), "removeQueueEntry"),
+    addConflict: /* @__PURE__ */ __name((c) => serialised(() => ops.addConflict(c)), "addConflict"),
+    conflicts: /* @__PURE__ */ __name(() => serialised(() => ops.conflicts()), "conflicts"),
+    removeConflict: /* @__PURE__ */ __name((id) => serialised(() => ops.removeConflict(id)), "removeConflict"),
+    getSyncState: /* @__PURE__ */ __name((rootId) => serialised(() => ops.getSyncState(rootId)), "getSyncState"),
+    setSyncState: /* @__PURE__ */ __name((rootId, s) => serialised(() => ops.setSyncState(rootId, s)), "setSyncState"),
+    skippedRecords: /* @__PURE__ */ __name((rootId) => serialised(() => ops.skippedRecords(rootId)), "skippedRecords"),
+    setSkippedRecords: /* @__PURE__ */ __name((rootId, records) => serialised(() => ops.setSkippedRecords(rootId, records)), "setSkippedRecords"),
+    removeRoot: /* @__PURE__ */ __name((rootId) => serialised(async () => {
+      await exec("BEGIN");
+      try {
+        await ops.removeRoot(rootId);
+        await exec("COMMIT");
+      } catch (error) {
+        await exec("ROLLBACK");
+        throw error;
+      }
+      await settleQueue();
+    }), "removeRoot"),
+    transaction: /* @__PURE__ */ __name((fn) => serialised(async () => {
+      await exec("BEGIN");
+      let result;
+      try {
+        result = await fn(nestedStore(ops));
+        await exec("COMMIT");
+      } catch (error) {
+        await exec("ROLLBACK");
+        await settleQueue();
+        throw error;
+      }
+      await settleQueue();
+      return result;
+    }), "transaction")
+  };
+  return store;
+}
+__name(createSqlDeviceStore, "createSqlDeviceStore");
+
+// src/offline/store/shared-database.ts
+var LEASE_TIMEOUT_MS = 3e4;
+var EXEC_TIMEOUT_MS = 3e4;
+var OPEN_RETRY_MS = 1e4;
+var lockName = /* @__PURE__ */ __name((userId) => `nja-offline-db:${userId}`, "lockName");
+var channelName = /* @__PURE__ */ __name((userId) => `nja-offline-db:${userId}`, "channelName");
+var newId2 = /* @__PURE__ */ __name(() => globalThis.crypto.randomUUID(), "newId");
+function canShareDatabase() {
+  return typeof BroadcastChannel !== "undefined" && typeof navigator !== "undefined" && typeof navigator.locks?.request === "function";
+}
+__name(canShareDatabase, "canShareDatabase");
+var isHeldElsewhere = /* @__PURE__ */ __name((error) => /NoModificationAllowedError|Access Handles cannot be created|createSyncAccessHandle/i.test(
+  String(error?.message ?? error)
+), "isHeldElsewhere");
+async function openWithRetry(openLocal) {
+  const deadline = Date.now() + OPEN_RETRY_MS;
+  for (let wait = 100; ; wait = Math.min(wait * 2, 1e3)) {
+    try {
+      return await openLocal();
+    } catch (error) {
+      if (!isHeldElsewhere(error) || Date.now() >= deadline) throw error;
+      await new Promise((resolve) => setTimeout(resolve, wait));
+    }
+  }
+}
+__name(openWithRetry, "openWithRetry");
+function createMutex() {
+  let tail = Promise.resolve();
+  return (fn) => {
+    const run = tail.then(fn, fn);
+    tail = run.catch(() => void 0);
+    return run;
+  };
+}
+__name(createMutex, "createMutex");
+async function openSharedDatabase(userId, openLocal, onShutdown) {
+  const channel = new BroadcastChannel(channelName(userId));
+  const post = /* @__PURE__ */ __name((message) => channel.postMessage(message), "post");
+  const mutex = createMutex();
+  let local;
+  let created = false;
+  let closed = false;
+  let releaseLock;
+  const lockAbort = new AbortController();
+  const leases = /* @__PURE__ */ new Map();
+  const waitingLeases = /* @__PURE__ */ new Map();
+  const waitingResults = /* @__PURE__ */ new Map();
+  let currentLease;
+  const isHolder = /* @__PURE__ */ __name(() => local !== void 0, "isHolder");
+  const runGranted = /* @__PURE__ */ __name(async (id) => {
+    const waiting = waitingLeases.get(id);
+    if (!waiting) {
+      post({ kind: "release", id });
+      return;
+    }
+    waitingLeases.delete(id);
+    currentLease = id;
+    try {
+      waiting.resolve(await waiting.run());
+    } catch (error) {
+      waiting.reject(error);
+    } finally {
+      currentLease = void 0;
+      post({ kind: "release", id });
+    }
+  }, "runGranted");
+  channel.onmessage = (event) => {
+    const message = event.data;
+    if (closed) return;
+    switch (message.kind) {
+      case "holder":
+        if (!isHolder()) for (const id of waitingLeases.keys()) post({ kind: "lease", id });
+        return;
+      case "lease":
+        if (!isHolder() || leases.has(message.id)) return;
+        void mutex(
+          () => new Promise((done) => {
+            const timer = setTimeout(() => finish(), LEASE_TIMEOUT_MS);
+            const finish = /* @__PURE__ */ __name(() => {
+              clearTimeout(timer);
+              leases.delete(message.id);
+              done();
+            }, "finish");
+            leases.set(message.id, finish);
+            post({ kind: "granted", id: message.id });
+          })
+        );
+        return;
+      case "granted":
+        if (!isHolder()) void runGranted(message.id);
+        return;
+      case "release":
+        leases.get(message.id)?.();
+        return;
+      case "exec":
+        if (!isHolder() || !leases.has(message.lease)) return;
+        local.exec(message.sql, message.bind).then((rows) => post({ kind: "result", id: message.id, ok: true, rows })).catch(
+          (error) => post({ kind: "result", id: message.id, ok: false, error: String(error?.message ?? error) })
+        );
+        return;
+      case "result": {
+        const waiting = waitingResults.get(message.id);
+        if (!waiting) return;
+        waitingResults.delete(message.id);
+        if (message.ok) waiting.resolve(message.rows);
+        else waiting.reject(new Error(message.error));
+        return;
+      }
+      case "shutdown":
+        void close().finally(() => onShutdown?.());
+        return;
+    }
+  };
+  const becomeHolder = /* @__PURE__ */ __name(async () => {
+    local = await openWithRetry(openLocal);
+    created = local.created;
+    for (const [id, waiting] of waitingLeases) {
+      waitingLeases.delete(id);
+      mutex(waiting.run).then(waiting.resolve, waiting.reject);
+    }
+    post({ kind: "holder" });
+  }, "becomeHolder");
+  const holdLock = /* @__PURE__ */ __name(async () => {
+    if (closed) return;
+    await becomeHolder();
+    await new Promise((resolve) => releaseLock = resolve);
+  }, "holdLock");
+  let opened;
+  const isFree = await new Promise((answer) => {
+    navigator.locks.request(lockName(userId), { ifAvailable: true }, async (lock) => {
+      if (!lock) {
+        answer(false);
+        return;
+      }
+      answer(true);
+      opened = becomeHolder();
+      try {
+        await opened;
+      } catch {
+        return;
+      }
+      await new Promise((resolve) => releaseLock = resolve);
+    }).catch(() => answer(false));
+  });
+  if (isFree) {
+    try {
+      await opened;
+    } catch (error) {
+      closed = true;
+      channel.close();
+      throw error;
+    }
+  } else {
+    navigator.locks.request(lockName(userId), { signal: lockAbort.signal }, holdLock).catch((error) => {
+      if (error?.name !== "AbortError")
+        console.warn("[offline] taking over the device copy failed", error);
+    });
+  }
+  const remoteExec = /* @__PURE__ */ __name((sql, bind) => {
+    if (closed) return Promise.reject(new Error("The device database is closed."));
+    const lease = currentLease;
+    if (!lease) return exclusive(() => remoteExec(sql, bind));
+    const id = newId2();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        waitingResults.delete(id);
+        reject(new Error("The page holding the device copy did not answer."));
+      }, EXEC_TIMEOUT_MS);
+      waitingResults.set(id, {
+        resolve: /* @__PURE__ */ __name((rows) => {
+          clearTimeout(timer);
+          resolve(rows);
+        }, "resolve"),
+        reject: /* @__PURE__ */ __name((error) => {
+          clearTimeout(timer);
+          reject(error);
+        }, "reject")
+      });
+      post({ kind: "exec", id, lease, sql, bind });
+    });
+  }, "remoteExec");
+  const exclusive = /* @__PURE__ */ __name((fn) => {
+    if (closed) return Promise.reject(new Error("The device database is closed."));
+    if (isHolder()) return mutex(fn);
+    const id = newId2();
+    return new Promise((resolve, reject) => {
+      waitingLeases.set(id, {
+        run: fn,
+        resolve,
+        reject
+      });
+      post({ kind: "lease", id });
+    });
+  }, "exclusive");
+  const exec = /* @__PURE__ */ __name((sql, bind) => isHolder() ? local.exec(sql, bind) : remoteExec(sql, bind), "exec");
+  async function close() {
+    if (closed) return;
+    closed = true;
+    lockAbort.abort();
+    const error = new Error("The device database is closed.");
+    for (const waiting of waitingLeases.values()) waiting.reject(error);
+    for (const waiting of waitingResults.values()) waiting.reject(error);
+    waitingLeases.clear();
+    waitingResults.clear();
+    for (const finish of [...leases.values()]) finish();
+    try {
+      if (local) await local.close();
+    } finally {
+      local = void 0;
+      releaseLock?.();
+      channel.close();
+    }
+  }
+  __name(close, "close");
+  return {
+    get created() {
+      return created;
+    },
+    exec,
+    exclusive,
+    close
+  };
+}
+__name(openSharedDatabase, "openSharedDatabase");
+async function withDatabaseReleased(userId, fn) {
+  if (!canShareDatabase()) return fn();
+  const channel = new BroadcastChannel(channelName(userId));
+  channel.postMessage({ kind: "shutdown" });
+  channel.close();
+  return navigator.locks.request(lockName(userId), () => fn());
+}
+__name(withDatabaseReleased, "withDatabaseReleased");
+
+// src/offline/store/worker-client.ts
+async function openWorkerDatabase(userId, fileName, urls) {
+  const worker = new Worker(urls.workerUrl, { type: "module" });
+  const { sqliteModuleUrl } = urls;
+  const pending = /* @__PURE__ */ new Map();
+  let nextId = 1;
+  let closed = false;
+  worker.onmessage = (event) => {
+    const response = event.data;
+    const waiting = pending.get(response.id);
+    if (!waiting) return;
+    pending.delete(response.id);
+    if (response.ok) waiting.resolve(response.result);
+    else waiting.reject(new Error(response.error));
+  };
+  worker.onerror = (event) => {
+    const error = new Error(event.message || "The device database worker failed.");
+    for (const waiting of pending.values()) waiting.reject(error);
+    pending.clear();
+  };
+  const send = /* @__PURE__ */ __name((request) => {
+    if (closed) return Promise.reject(new Error("The device database is closed."));
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      worker.postMessage({ ...request, id });
+    });
+  }, "send");
+  let opened;
+  try {
+    opened = await send({ op: "open", userId, fileName, sqliteModuleUrl });
+  } catch (error) {
+    worker.terminate();
+    throw error;
+  }
+  return {
+    created: opened.created,
+    exec: /* @__PURE__ */ __name((sql, bind) => send({ op: "exec", sql, bind }), "exec"),
+    close: /* @__PURE__ */ __name(async () => {
+      if (closed) return;
+      try {
+        await send({ op: "close" });
+      } finally {
+        closed = true;
+        worker.terminate();
+      }
+    }, "close")
+  };
+}
+__name(openWorkerDatabase, "openWorkerDatabase");
+
+// src/offline/store/lifecycle.ts
+var FILE_PREFIX = "nja-offline-";
+var deviceFileName = /* @__PURE__ */ __name((userId) => `${FILE_PREFIX}${userId}.sqlite3`, "deviceFileName");
+var pendingMarkerName = /* @__PURE__ */ __name((userId) => `${FILE_PREFIX}${userId}.pending`, "pendingMarkerName");
+var IMAGES_OWNER_PREFIX = "nja-offline-images-owner-";
+var imagesOwnerName = /* @__PURE__ */ __name((userId) => `${IMAGES_OWNER_PREFIX}${userId}`, "imagesOwnerName");
+var FILE_PATTERN = /^nja-offline-(.+)\.(?:sqlite3(?:-journal|-wal|-shm)?|pending)$/;
+var POOL_PATTERN = /^\.nja-offline-(.+)$/;
+var missingDeviceStorage = /* @__PURE__ */ __name(() => {
+  if (typeof window !== "undefined" && window.isSecureContext === false) {
+    return "the page is not served from a secure origin (https or localhost)";
+  }
+  if (typeof navigator === "undefined" || typeof navigator.storage?.getDirectory !== "function") {
+    return "the browser offers no private file storage";
+  }
+  return null;
+}, "missingDeviceStorage");
+var assertDeviceStorage = /* @__PURE__ */ __name(() => {
+  const reason = missingDeviceStorage();
+  if (reason) throw new OfflineUnavailableError(reason);
+}, "assertDeviceStorage");
+var OPFS_MISSING = /Missing required OPFS APIs/i;
+var defaultBackend = {
+  getDirectory: /* @__PURE__ */ __name(async () => {
+    assertDeviceStorage();
+    try {
+      return await navigator.storage.getDirectory();
+    } catch (error) {
+      if (error?.name === "SecurityError") {
+        throw new OfflineUnavailableError("the browser refused its private file storage");
+      }
+      throw error;
+    }
+  }, "getDirectory"),
+  openDatabase: /* @__PURE__ */ __name(async (userId, fileName) => {
+    assertDeviceStorage();
+    const openLocal = /* @__PURE__ */ __name(() => openWorkerDatabase(userId, fileName, {
+      workerUrl: getDeviceWorkerUrl(),
+      sqliteModuleUrl: getSqliteModuleUrl()
+    }), "openLocal");
+    try {
+      if (!canShareDatabase()) return await openLocal();
+      return await openSharedDatabase(userId, openLocal, () => forgetClosedStore(userId));
+    } catch (error) {
+      if (OPFS_MISSING.test(String(error?.message ?? error))) {
+        throw new OfflineUnavailableError("the browser lacks the file access the device copy needs (OPFS)");
+      }
+      throw error;
+    }
+  }, "openDatabase"),
+  requestPersistence: /* @__PURE__ */ __name(async () => {
+    if (typeof navigator !== "undefined" && navigator.storage?.persist) await navigator.storage.persist();
+  }, "requestPersistence")
+};
+var backend = defaultBackend;
+var current;
+function setDeviceStoreBackend(next) {
+  backend = next ? { ...defaultBackend, ...next } : defaultBackend;
+  current = void 0;
+}
+__name(setDeviceStoreBackend, "setDeviceStoreBackend");
+var entryExists = /* @__PURE__ */ __name(async (directory, name) => {
+  for await (const key of directory.keys()) if (key === name) return true;
+  return false;
+}, "entryExists");
+var removeIfPresent = /* @__PURE__ */ __name(async (directory, name) => {
+  try {
+    await directory.removeEntry(name, { recursive: true });
+  } catch (error) {
+    if (error?.name !== "NotFoundError") throw error;
+  }
+}, "removeIfPresent");
+var entriesOf = /* @__PURE__ */ __name(async (directory, userId) => {
+  const names = [];
+  for await (const key of directory.keys()) if (userIdOf(key) === userId) names.push(key);
+  return names;
+}, "entriesOf");
+var deviceDirectory = /* @__PURE__ */ __name(async () => {
+  if (!isOfflineAvailable()) return void 0;
+  try {
+    return await backend.getDirectory();
+  } catch (error) {
+    if (!(error instanceof OfflineUnavailableError)) throw error;
+    markOfflineUnavailable(error);
+    return void 0;
+  }
+}, "deviceDirectory");
+var userIdOf = /* @__PURE__ */ __name((name) => FILE_PATTERN.exec(name)?.[1] ?? POOL_PATTERN.exec(name)?.[1], "userIdOf");
+var closeCurrent = /* @__PURE__ */ __name(async () => {
+  const open = current;
+  current = void 0;
+  if (!open) return;
+  try {
+    await (await open.database).close();
+  } catch {
+  }
+}, "closeCurrent");
+function openDeviceStore(userId) {
+  if (!userId) return Promise.reject(new Error("openDeviceStore needs the signed-in user id."));
+  if (isOfflineStoreBlocked(userId)) {
+    return Promise.reject(new DeviceStoreUnavailableError("The device copy was deleted at logout"));
+  }
+  if (!isOfflineAvailable()) {
+    return Promise.reject(new OfflineUnavailableError("it was found unable to keep the device copy"));
+  }
+  if (current?.userId === userId) return current.store;
+  const previous = closeCurrent();
+  const database = previous.then(() => backend.openDatabase(userId, deviceFileName(userId))).catch((error) => {
+    if (error instanceof OfflineUnavailableError) markOfflineUnavailable(error);
+    throw error;
+  });
+  const store = database.then(async (opened) => {
+    if (opened.created) await backend.requestPersistence();
+    return createSqlDeviceStore(opened.exec, {
+      exclusive: opened.exclusive,
+      beforeEnqueue: /* @__PURE__ */ __name(async () => {
+        const directory = await backend.getDirectory();
+        await directory.getFileHandle(pendingMarkerName(userId), { create: true });
+      }, "beforeEnqueue"),
+      afterQueueChange: /* @__PURE__ */ __name(async (entries) => {
+        if (entries > 0) return;
+        await removeIfPresent(await backend.getDirectory(), pendingMarkerName(userId));
+      }, "afterQueueChange")
+    });
+  });
+  const open = { userId, store, database };
+  current = open;
+  store.catch(() => {
+    if (current === open) current = void 0;
+  });
+  return store;
+}
+__name(openDeviceStore, "openDeviceStore");
+var sqlite3Promise;
+async function openMemoryDatabase() {
+  sqlite3Promise ??= import(
+    /* webpackIgnore: true */
+    /* turbopackIgnore: true */
+    "@sqlite.org/sqlite-wasm"
+  ).then(
+    (module) => module.default()
+  );
+  const sqlite3 = await sqlite3Promise;
+  const db = new sqlite3.oo1.DB(":memory:", "c");
+  return {
+    created: true,
+    exec: /* @__PURE__ */ __name(async (sql, bind) => db.exec({
+      sql,
+      bind: bind && bind.length ? bind : void 0,
+      rowMode: "object",
+      returnValue: "resultRows"
+    }), "exec"),
+    close: /* @__PURE__ */ __name(async () => {
+      db.close();
+    }, "close")
+  };
+}
+__name(openMemoryDatabase, "openMemoryDatabase");
+async function openMemoryDeviceStore() {
+  const database = await openMemoryDatabase();
+  return createSqlDeviceStore(database.exec);
+}
+__name(openMemoryDeviceStore, "openMemoryDeviceStore");
+function forgetClosedStore(userId) {
+  if (current?.userId === userId) current = void 0;
+  forgetOfflineStore(userId);
+  refreshOfflineDeviceState();
+}
+__name(forgetClosedStore, "forgetClosedStore");
+async function deleteDeviceStore(userId) {
+  if (current?.userId === userId) await closeCurrent();
+  const directory = await deviceDirectory();
+  if (!directory) return;
+  const remove = /* @__PURE__ */ __name(async () => {
+    const names = await entriesOf(directory, userId);
+    const marker = pendingMarkerName(userId);
+    for (const name of names) if (name !== marker) await removeIfPresent(directory, name);
+    await removeIfPresent(directory, marker);
+  }, "remove");
+  if (backend === defaultBackend) await withDatabaseReleased(userId, remove);
+  else await remove();
+}
+__name(deleteDeviceStore, "deleteDeviceStore");
+async function hasUnsentChanges(userId) {
+  if (current?.userId === userId) {
+    const store = await current.store;
+    if ((await store.queue()).length > 0) return true;
+  }
+  const directory = await deviceDirectory();
+  if (!directory) return false;
+  return entryExists(directory, pendingMarkerName(userId));
+}
+__name(hasUnsentChanges, "hasUnsentChanges");
+async function onUserSignedIn(userId) {
+  unblockOfflineStore(userId);
+  if (current && current.userId !== userId) await closeCurrent();
+  const directory = await deviceDirectory();
+  if (!directory) return;
+  const others = /* @__PURE__ */ new Set();
+  const imageOwners = [];
+  for await (const key of directory.keys()) {
+    if (key.startsWith(IMAGES_OWNER_PREFIX)) {
+      imageOwners.push(key);
+      continue;
+    }
+    const owner = userIdOf(key);
+    if (owner && owner !== userId) others.add(owner);
+  }
+  if (!imageOwners.includes(imagesOwnerName(userId))) {
+    await deleteImagesCaches();
+    for (const name of imageOwners) await removeIfPresent(directory, name);
+    await directory.getFileHandle(imagesOwnerName(userId), { create: true });
+  }
+  for (const other of others) {
+    if (await entryExists(directory, pendingMarkerName(other))) continue;
+    await deleteDeviceStore(other);
+  }
+}
+__name(onUserSignedIn, "onUserSignedIn");
+function isRootLocked(s, now) {
+  if (s.locked) return true;
+  return s.lockedFrom !== null && s.lockedFrom.getTime() <= now.getTime();
+}
+__name(isRootLocked, "isRootLocked");
+
+export {
+  imageUrlOf,
+  cacheArtworkImage,
+  removeArtworkImage,
+  deleteImagesCaches,
+  setDeviceStoreBackend,
+  openDeviceStore,
+  openMemoryDatabase,
+  openMemoryDeviceStore,
+  deleteDeviceStore,
+  hasUnsentChanges,
+  onUserSignedIn,
+  isRootLocked
+};
+//# sourceMappingURL=chunk-7DBJTNSU.mjs.map