@arbidocs/react 0.5.111 → 0.5.112

package/dist/calendar/offline/outbox.js

@@ -0,0 +1,231 @@
+import { createOfflineSealer } from "@arbidocs/client";
+import { createRecordStore } from "../../offline-store/store.js";
+import { isBrowserOffline, isNetworkFailure } from "../../offline-store/network.js";
+import { wipeStore } from "../../offline-store/wipe.js";
+const OFFLINE_CALENDAR_DB = "arbi-offline-calendar";
+const CACHE_LIMIT = 200;
+class OfflineCalendarLockedError extends Error {
+  constructor() {
+    super("Sign in to open the calendar saved on this device");
+    this.name = "OfflineCalendarLockedError";
+  }
+}
+const store = createRecordStore(OFFLINE_CALENDAR_DB);
+const sealer = createOfflineSealer("arbi-offline-calendar-v1", {
+  locked: () => new OfflineCalendarLockedError()
+});
+function isCalendarOffline() {
+  return isBrowserOffline();
+}
+function isCalendarNetworkError(error) {
+  if (isNetworkFailure(error)) return true;
+  const status = error?.status;
+  return typeof status !== "number" && isBrowserOffline();
+}
+const cacheBucket = () => sealer.blind("bucket", "cache");
+const cacheKey = (key) => sealer.blind("cache", key);
+async function writeCalendarCache(key, data) {
+  const sealed = await sealer.sealJson({ key, data });
+  const now = Date.now();
+  await store.putRecord({
+    key: await cacheKey(key),
+    kind: "cache",
+    bucket: await cacheBucket(),
+    sortAt: now,
+    size: sealed.length,
+    lastAccess: now,
+    data: sealed
+  });
+  await evictCache();
+}
+async function readCalendarCache(key) {
+  try {
+    const blindKey = await cacheKey(key);
+    const record = await store.getRecord(blindKey);
+    if (!record) return null;
+    const opened = await sealer.openJson(record.data);
+    if (opened.key !== key) return null;
+    await store.putRecord({ ...record, lastAccess: Date.now() });
+    return opened.data;
+  } catch {
+    return null;
+  }
+}
+async function evictCache() {
+  const rows = (await store.allRecordAccess()).filter((r) => r.kind === "cache");
+  if (rows.length <= CACHE_LIMIT) return;
+  rows.sort((a, b) => a.lastAccess - b.lastAccess);
+  await store.deleteRecords(rows.slice(0, rows.length - CACHE_LIMIT).map((r) => r.key));
+}
+const outboxBucket = () => sealer.blind("bucket", "outbox");
+const outboxKey = (requestId) => sealer.blind("outbox", requestId);
+let seqCounter = 0;
+async function writeItem(item) {
+  const sealed = await sealer.sealJson(item);
+  await store.putRecord({
+    key: await outboxKey(item.requestId),
+    kind: "outbox",
+    bucket: await outboxBucket(),
+    sortAt: item.seq,
+    size: sealed.length,
+    lastAccess: Date.now(),
+    data: sealed
+  });
+}
+async function readItems() {
+  const records = await store.recordsInBucket(await outboxBucket());
+  const items = [];
+  for (const record of records) {
+    try {
+      items.push(await sealer.openJson(record.data));
+    } catch {
+    }
+  }
+  return items.sort((a, b) => a.seq - b.seq);
+}
+function newRequestId() {
+  return typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+async function enqueueCalendarWrite(op) {
+  const now = Date.now();
+  seqCounter = Math.max(seqCounter + 1, now * 1e3);
+  const item = {
+    requestId: newRequestId(),
+    op,
+    state: "queued",
+    attempts: 0,
+    createdAt: now,
+    seq: seqCounter
+  };
+  await writeItem(item);
+  notify("enqueued");
+  return { requestId: item.requestId };
+}
+async function listCalendarOutbox() {
+  try {
+    return (await readItems()).map(({ requestId, op, state, inDoubt, error }) => ({
+      requestId,
+      op,
+      state,
+      inDoubt,
+      error
+    }));
+  } catch {
+    return [];
+  }
+}
+function classify(error) {
+  if (isCalendarNetworkError(error)) return "offline";
+  const status = error?.status;
+  if (typeof status === "number" && status >= 500) return "retry";
+  return "failed";
+}
+function run(exec, item) {
+  const op = item.op;
+  switch (op.kind) {
+    case "create":
+      return exec.create(op.body, item.requestId);
+    case "update":
+      return exec.update(op.target, op.body, item.requestId);
+    case "delete":
+      return exec.delete(op.target, item.requestId);
+    case "respond":
+      return exec.respond(op.params, item.requestId);
+  }
+}
+let replaying = null;
+function replayCalendarOutbox(exec) {
+  if (replaying) return replaying;
+  const locks = typeof navigator !== "undefined" ? navigator.locks : void 0;
+  const run2 = locks?.request ? locks.request(
+    "arbi-calendar-outbox-replay",
+    () => replayOnce(exec)
+  ) : replayOnce(exec);
+  const current = run2.finally(() => {
+    replaying = null;
+  });
+  replaying = current;
+  return current;
+}
+async function replayOnce(exec) {
+  const result = { sent: 0, failed: 0, inDoubt: 0 };
+  for (const queued of await readItems()) {
+    if (queued.state !== "queued" && queued.state !== "sending") continue;
+    if (isCalendarOffline()) break;
+    let item = {
+      ...queued,
+      inDoubt: queued.inDoubt || queued.state === "sending"
+    };
+    if (item.op.kind === "create" && item.inDoubt && exec.findCreated) {
+      let found = false;
+      try {
+        found = await exec.findCreated(item.requestId, item.op.body);
+      } catch (error) {
+        if (classify(error) === "offline") break;
+      }
+      if (found) {
+        await store.deleteRecords([await outboxKey(item.requestId)]);
+        result.sent++;
+        continue;
+      }
+    }
+    item = { ...item, state: "sending", attempts: item.attempts + 1 };
+    await writeItem(item);
+    let outcome;
+    let message;
+    try {
+      await run(exec, item);
+      outcome = "sent";
+    } catch (error) {
+      outcome = classify(error);
+      message = error instanceof Error ? error.message : "The change could not be saved";
+    }
+    if (outcome === "sent") {
+      await store.deleteRecords([await outboxKey(item.requestId)]);
+      result.sent++;
+      continue;
+    }
+    if (outcome === "failed") {
+      await writeItem({ ...item, state: "failed", error: message });
+      result.failed++;
+      continue;
+    }
+    const inDoubt = item.inDoubt || item.op.kind === "create";
+    await writeItem({ ...item, state: "queued", inDoubt, error: message });
+    if (inDoubt) result.inDoubt++;
+    if (outcome === "offline") break;
+  }
+  notify();
+  return result;
+}
+const listeners = /* @__PURE__ */ new Set();
+function notify(change = "changed") {
+  for (const l of listeners) l(change);
+}
+function onCalendarOutboxChange(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+async function wipeCalendarOffline() {
+  await wipeStore(sealer, store);
+  notify();
+}
+async function claimCalendarOffline(userExtId) {
+  const owner = await store.getMeta("owner");
+  if (owner && owner !== userExtId) await wipeCalendarOffline();
+  await store.setMeta("owner", userExtId);
+}
+export {
+  OFFLINE_CALENDAR_DB,
+  claimCalendarOffline,
+  enqueueCalendarWrite,
+  isCalendarNetworkError,
+  isCalendarOffline,
+  listCalendarOutbox,
+  onCalendarOutboxChange,
+  readCalendarCache,
+  replayCalendarOutbox,
+  wipeCalendarOffline,
+  writeCalendarCache
+};
+//# sourceMappingURL=outbox.js.map

package/dist/calendar/offline/outbox.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/calendar/offline/outbox.ts"],
+  "sourcesContent": ["/**\n * The offline calendar: an encrypted IndexedDB cache of fetched calendar data (event windows,\n * calendars, settings) and an exactly-once Outbox of writes made while offline.\n *\n * Storage is the generic encrypted record store (`../../offline-store`) under its own database\n * (`arbi-offline-calendar`) and key namespace (`arbi-offline-calendar-v1`), keyed by the user's\n * identity like the offline mailbox: nothing readable is written to disk, and another account's\n * records are unreadable (and ignored).\n *\n * Outbox semantics (the calendar API has no request-id dedupe):\n *  - every write keeps the `requestId` it was given when queued, for its whole life;\n *  - replay is in order and stops at the first network failure (order is kept);\n *  - a refusal (4xx) is final: \"failed\", never retried automatically;\n *  - a network failure or 5xx keeps the write queued. For a create that may already have reached the\n *    server it is marked `inDoubt`; before re-sending an in-doubt create the executor's\n *    `findCreated` is asked whether the server already has it, and if so it is marked sent instead\n *    of being created twice. Updates, deletes and responses set absolute state, so a retry is safe;\n *  - a write left \"sending\" (tab closed mid-request) is treated as in doubt.\n *  - sent writes leave the Outbox.\n */\n\nimport { createOfflineSealer } from '@arbidocs/client'\nimport type { ScopedTarget } from '@arbidocs/sdk/browser'\nimport { createRecordStore } from '../../offline-store/store'\nimport { isBrowserOffline, isNetworkFailure } from '../../offline-store/network'\nimport { wipeStore } from '../../offline-store/wipe'\nimport type { CalendarPendingWrite, CalendarWriteOp } from '../support'\n\nexport const OFFLINE_CALENDAR_DB = 'arbi-offline-calendar'\nconst CACHE_LIMIT = 200\n\nclass OfflineCalendarLockedError extends Error {\n  constructor() {\n    super('Sign in to open the calendar saved on this device')\n    this.name = 'OfflineCalendarLockedError'\n  }\n}\n\ntype Kind = 'cache' | 'outbox'\nconst store = createRecordStore<Kind>(OFFLINE_CALENDAR_DB)\nconst sealer = createOfflineSealer('arbi-offline-calendar-v1', {\n  locked: () => new OfflineCalendarLockedError(),\n})\n\n// \u2500\u2500 network \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport function isCalendarOffline(): boolean {\n  return isBrowserOffline()\n}\n\n/** The request never got an HTTP answer (offline, host unreachable). */\nexport function isCalendarNetworkError(error: unknown): boolean {\n  if (isNetworkFailure(error)) return true\n  const status = (error as { status?: unknown } | null)?.status\n  return typeof status !== 'number' && isBrowserOffline()\n}\n\n// \u2500\u2500 cache \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nconst cacheBucket = () => sealer.blind('bucket', 'cache')\nconst cacheKey = (key: string) => sealer.blind('cache', key)\n\nexport async function writeCalendarCache(key: string, data: unknown): Promise<void> {\n  const sealed = await sealer.sealJson({ key, data })\n  const now = Date.now()\n  await store.putRecord({\n    key: await cacheKey(key),\n    kind: 'cache',\n    bucket: await cacheBucket(),\n    sortAt: now,\n    size: sealed.length,\n    lastAccess: now,\n    data: sealed,\n  })\n  await evictCache()\n}\n\nexport async function readCalendarCache<T>(key: string): Promise<T | null> {\n  try {\n    const blindKey = await cacheKey(key)\n    const record = await store.getRecord(blindKey)\n    if (!record) return null\n    const opened = await sealer.openJson<{ key: string; data: T }>(record.data)\n    if (opened.key !== key) return null\n    await store.putRecord({ ...record, lastAccess: Date.now() })\n    return opened.data\n  } catch {\n    // Locked, another account's record, or tampered: treat as not cached.\n    return null\n  }\n}\n\nasync function evictCache(): Promise<void> {\n  const rows = (await store.allRecordAccess()).filter((r) => r.kind === 'cache')\n  if (rows.length <= CACHE_LIMIT) return\n  rows.sort((a, b) => a.lastAccess - b.lastAccess)\n  await store.deleteRecords(rows.slice(0, rows.length - CACHE_LIMIT).map((r) => r.key))\n}\n\n// \u2500\u2500 outbox \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type CalendarOutboxOp = CalendarWriteOp\n\ntype CalendarOutboxState = 'queued' | 'sending' | 'sent' | 'failed'\n\ninterface CalendarOutboxItem {\n  requestId: string\n  op: CalendarOutboxOp\n  state: CalendarOutboxState\n  inDoubt?: boolean\n  error?: string\n  attempts: number\n  createdAt: number\n  seq: number\n}\n\ntype Op<K extends CalendarOutboxOp['kind']> = Extract<CalendarOutboxOp, { kind: K }>\n\nexport interface CalendarOutboxExecutor {\n  create(body: Op<'create'>['body'], requestId: string): Promise<unknown>\n  update(target: ScopedTarget, body: Op<'update'>['body'], requestId: string): Promise<unknown>\n  delete(target: Op<'delete'>['target'], requestId: string): Promise<unknown>\n  respond(params: Op<'respond'>['params'], requestId: string): Promise<unknown>\n  /** Whether an in-doubt create already reached the server (no server-side dedupe). */\n  findCreated?(requestId: string, body: Op<'create'>['body']): Promise<boolean>\n}\n\nconst outboxBucket = () => sealer.blind('bucket', 'outbox')\nconst outboxKey = (requestId: string) => sealer.blind('outbox', requestId)\nlet seqCounter = 0\n\nasync function writeItem(item: CalendarOutboxItem): Promise<void> {\n  const sealed = await sealer.sealJson(item)\n  await store.putRecord({\n    key: await outboxKey(item.requestId),\n    kind: 'outbox',\n    bucket: await outboxBucket(),\n    sortAt: item.seq,\n    size: sealed.length,\n    lastAccess: Date.now(),\n    data: sealed,\n  })\n}\n\nasync function readItems(): Promise<CalendarOutboxItem[]> {\n  const records = await store.recordsInBucket(await outboxBucket())\n  const items: CalendarOutboxItem[] = []\n  for (const record of records) {\n    try {\n      items.push(await sealer.openJson<CalendarOutboxItem>(record.data))\n    } catch {\n      // Sealed under a different identity: not this user's; ignore.\n    }\n  }\n  return items.sort((a, b) => a.seq - b.seq)\n}\n\nfunction newRequestId(): string {\n  return typeof crypto !== 'undefined' && 'randomUUID' in crypto\n    ? crypto.randomUUID()\n    : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`\n}\n\nexport async function enqueueCalendarWrite(op: CalendarOutboxOp): Promise<{ requestId: string }> {\n  const now = Date.now()\n  // Monotonic even when two writes are queued in the same millisecond.\n  seqCounter = Math.max(seqCounter + 1, now * 1000)\n  const item: CalendarOutboxItem = {\n    requestId: newRequestId(),\n    op,\n    state: 'queued',\n    attempts: 0,\n    createdAt: now,\n    seq: seqCounter,\n  }\n  await writeItem(item)\n  notify('enqueued')\n  return { requestId: item.requestId }\n}\n\nexport async function listCalendarOutbox(): Promise<CalendarPendingWrite[]> {\n  try {\n    return (await readItems()).map(({ requestId, op, state, inDoubt, error }) => ({\n      requestId,\n      op,\n      state,\n      inDoubt,\n      error,\n    }))\n  } catch {\n    return []\n  }\n}\n\ntype Outcome = 'sent' | 'offline' | 'retry' | 'failed'\n\nfunction classify(error: unknown): Outcome {\n  if (isCalendarNetworkError(error)) return 'offline'\n  const status = (error as { status?: number } | null)?.status\n  if (typeof status === 'number' && status >= 500) return 'retry'\n  return 'failed'\n}\n\nfunction run(exec: CalendarOutboxExecutor, item: CalendarOutboxItem): Promise<unknown> {\n  const op = item.op\n  switch (op.kind) {\n    case 'create':\n      return exec.create(op.body, item.requestId)\n    case 'update':\n      return exec.update(op.target, op.body, item.requestId)\n    case 'delete':\n      return exec.delete(op.target, item.requestId)\n    case 'respond':\n      return exec.respond(op.params, item.requestId)\n  }\n}\n\nlet replaying: Promise<{ sent: number; failed: number; inDoubt: number }> | null = null\n\n/**\n * Send queued writes in order. Concurrent calls in a tab share one run, and tabs take turns through a Web\n * Lock: two tabs replaying at once would both send the same queued create (exactly-once across tabs).\n */\nexport function replayCalendarOutbox(\n  exec: CalendarOutboxExecutor\n): Promise<{ sent: number; failed: number; inDoubt: number }> {\n  if (replaying) return replaying\n  type Result = { sent: number; failed: number; inDoubt: number }\n  const locks = typeof navigator !== 'undefined' ? navigator.locks : undefined\n  const run: Promise<Result> = locks?.request\n    ? (locks.request('arbi-calendar-outbox-replay', () =>\n        replayOnce(exec)\n      ) as unknown as Promise<Result>)\n    : replayOnce(exec)\n  const current = run.finally(() => {\n    replaying = null\n  })\n  replaying = current\n  return current\n}\n\nasync function replayOnce(\n  exec: CalendarOutboxExecutor\n): Promise<{ sent: number; failed: number; inDoubt: number }> {\n  const result = { sent: 0, failed: 0, inDoubt: 0 }\n  for (const queued of await readItems()) {\n    if (queued.state !== 'queued' && queued.state !== 'sending') continue\n    if (isCalendarOffline()) break\n    // Left \"sending\" by a closed tab: the request may have reached the server.\n    let item: CalendarOutboxItem = {\n      ...queued,\n      inDoubt: queued.inDoubt || queued.state === 'sending',\n    }\n    if (item.op.kind === 'create' && item.inDoubt && exec.findCreated) {\n      let found = false\n      try {\n        found = await exec.findCreated(item.requestId, item.op.body)\n      } catch (error) {\n        if (classify(error) === 'offline') break\n      }\n      if (found) {\n        await store.deleteRecords([await outboxKey(item.requestId)])\n        result.sent++\n        continue\n      }\n    }\n    item = { ...item, state: 'sending', attempts: item.attempts + 1 }\n    await writeItem(item)\n    let outcome: Outcome\n    let message: string | undefined\n    try {\n      await run(exec, item)\n      outcome = 'sent'\n    } catch (error) {\n      outcome = classify(error)\n      message = error instanceof Error ? error.message : 'The change could not be saved'\n    }\n    if (outcome === 'sent') {\n      await store.deleteRecords([await outboxKey(item.requestId)])\n      result.sent++\n      continue\n    }\n    if (outcome === 'failed') {\n      await writeItem({ ...item, state: 'failed', error: message })\n      result.failed++\n      continue\n    }\n    // Network or server error: keep it queued. A create may have been made: in doubt.\n    const inDoubt = item.inDoubt || item.op.kind === 'create'\n    await writeItem({ ...item, state: 'queued', inDoubt, error: message })\n    if (inDoubt) result.inDoubt++\n    if (outcome === 'offline') break\n  }\n  notify()\n  return result\n}\n\n// \u2500\u2500 change notifications + wipe \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type CalendarOutboxChange = 'enqueued' | 'changed'\nconst listeners = new Set<(change: CalendarOutboxChange) => void>()\nfunction notify(change: CalendarOutboxChange = 'changed') {\n  for (const l of listeners) l(change)\n}\n/** Subscribe to Outbox changes ('enqueued': a new write was queued); returns the unsubscribe. */\nexport function onCalendarOutboxChange(\n  listener: (change: CalendarOutboxChange) => void\n): () => void {\n  listeners.add(listener)\n  return () => listeners.delete(listener)\n}\n\nexport async function wipeCalendarOffline(): Promise<void> {\n  await wipeStore(sealer, store)\n  notify()\n}\n\n/**\n * Bind the offline calendar to the account signing in: a store another account wrote on this\n * device is removed (sealed to their key it is unreadable anyway, but its cache and queued writes\n * must not take space or linger).\n */\nexport async function claimCalendarOffline(userExtId: string): Promise<void> {\n  const owner = await store.getMeta<string>('owner')\n  if (owner && owner !== userExtId) await wipeCalendarOffline()\n  await store.setMeta('owner', userExtId)\n}\n"],
+  "mappings": "AAqBA,SAAS,2BAA2B;AAEpC,SAAS,yBAAyB;AAClC,SAAS,kBAAkB,wBAAwB;AACnD,SAAS,iBAAiB;AAGnB,MAAM,sBAAsB;AACnC,MAAM,cAAc;AAEpB,MAAM,mCAAmC,MAAM;AAAA,EAC7C,cAAc;AACZ,UAAM,mDAAmD;AACzD,SAAK,OAAO;AAAA,EACd;AACF;AAGA,MAAM,QAAQ,kBAAwB,mBAAmB;AACzD,MAAM,SAAS,oBAAoB,4BAA4B;AAAA,EAC7D,QAAQ,MAAM,IAAI,2BAA2B;AAC/C,CAAC;AAIM,SAAS,oBAA6B;AAC3C,SAAO,iBAAiB;AAC1B;AAGO,SAAS,uBAAuB,OAAyB;AAC9D,MAAI,iBAAiB,KAAK,EAAG,QAAO;AACpC,QAAM,SAAU,OAAuC;AACvD,SAAO,OAAO,WAAW,YAAY,iBAAiB;AACxD;AAIA,MAAM,cAAc,MAAM,OAAO,MAAM,UAAU,OAAO;AACxD,MAAM,WAAW,CAAC,QAAgB,OAAO,MAAM,SAAS,GAAG;AAE3D,eAAsB,mBAAmB,KAAa,MAA8B;AAClF,QAAM,SAAS,MAAM,OAAO,SAAS,EAAE,KAAK,KAAK,CAAC;AAClD,QAAM,MAAM,KAAK,IAAI;AACrB,QAAM,MAAM,UAAU;AAAA,IACpB,KAAK,MAAM,SAAS,GAAG;AAAA,IACvB,MAAM;AAAA,IACN,QAAQ,MAAM,YAAY;AAAA,IAC1B,QAAQ;AAAA,IACR,MAAM,OAAO;AAAA,IACb,YAAY;AAAA,IACZ,MAAM;AAAA,EACR,CAAC;AACD,QAAM,WAAW;AACnB;AAEA,eAAsB,kBAAqB,KAAgC;AACzE,MAAI;AACF,UAAM,WAAW,MAAM,SAAS,GAAG;AACnC,UAAM,SAAS,MAAM,MAAM,UAAU,QAAQ;AAC7C,QAAI,CAAC,OAAQ,QAAO;AACpB,UAAM,SAAS,MAAM,OAAO,SAAmC,OAAO,IAAI;AAC1E,QAAI,OAAO,QAAQ,IAAK,QAAO;AAC/B,UAAM,MAAM,UAAU,EAAE,GAAG,QAAQ,YAAY,KAAK,IAAI,EAAE,CAAC;AAC3D,WAAO,OAAO;AAAA,EAChB,QAAQ;AAEN,WAAO;AAAA,EACT;AACF;AAEA,eAAe,aAA4B;AACzC,QAAM,QAAQ,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAM,EAAE,SAAS,OAAO;AAC7E,MAAI,KAAK,UAAU,YAAa;AAChC,OAAK,KAAK,CAAC,GAAG,MAAM,EAAE,aAAa,EAAE,UAAU;AAC/C,QAAM,MAAM,cAAc,KAAK,MAAM,GAAG,KAAK,SAAS,WAAW,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC;AACtF;AA8BA,MAAM,eAAe,MAAM,OAAO,MAAM,UAAU,QAAQ;AAC1D,MAAM,YAAY,CAAC,cAAsB,OAAO,MAAM,UAAU,SAAS;AACzE,IAAI,aAAa;AAEjB,eAAe,UAAU,MAAyC;AAChE,QAAM,SAAS,MAAM,OAAO,SAAS,IAAI;AACzC,QAAM,MAAM,UAAU;AAAA,IACpB,KAAK,MAAM,UAAU,KAAK,SAAS;AAAA,IACnC,MAAM;AAAA,IACN,QAAQ,MAAM,aAAa;AAAA,IAC3B,QAAQ,KAAK;AAAA,IACb,MAAM,OAAO;AAAA,IACb,YAAY,KAAK,IAAI;AAAA,IACrB,MAAM;AAAA,EACR,CAAC;AACH;AAEA,eAAe,YAA2C;AACxD,QAAM,UAAU,MAAM,MAAM,gBAAgB,MAAM,aAAa,CAAC;AAChE,QAAM,QAA8B,CAAC;AACrC,aAAW,UAAU,SAAS;AAC5B,QAAI;AACF,YAAM,KAAK,MAAM,OAAO,SAA6B,OAAO,IAAI,CAAC;AAAA,IACnE,QAAQ;AAAA,IAER;AAAA,EACF;AACA,SAAO,MAAM,KAAK,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG;AAC3C;AAEA,SAAS,eAAuB;AAC9B,SAAO,OAAO,WAAW,eAAe,gBAAgB,SACpD,OAAO,WAAW,IAClB,GAAG,KAAK,IAAI,EAAE,SAAS,EAAE,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC,CAAC;AACvE;AAEA,eAAsB,qBAAqB,IAAsD;AAC/F,QAAM,MAAM,KAAK,IAAI;AAErB,eAAa,KAAK,IAAI,aAAa,GAAG,MAAM,GAAI;AAChD,QAAM,OAA2B;AAAA,IAC/B,WAAW,aAAa;AAAA,IACxB;AAAA,IACA,OAAO;AAAA,IACP,UAAU;AAAA,IACV,WAAW;AAAA,IACX,KAAK;AAAA,EACP;AACA,QAAM,UAAU,IAAI;AACpB,SAAO,UAAU;AACjB,SAAO,EAAE,WAAW,KAAK,UAAU;AACrC;AAEA,eAAsB,qBAAsD;AAC1E,MAAI;AACF,YAAQ,MAAM,UAAU,GAAG,IAAI,CAAC,EAAE,WAAW,IAAI,OAAO,SAAS,MAAM,OAAO;AAAA,MAC5E;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,EAAE;AAAA,EACJ,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAIA,SAAS,SAAS,OAAyB;AACzC,MAAI,uBAAuB,KAAK,EAAG,QAAO;AAC1C,QAAM,SAAU,OAAsC;AACtD,MAAI,OAAO,WAAW,YAAY,UAAU,IAAK,QAAO;AACxD,SAAO;AACT;AAEA,SAAS,IAAI,MAA8B,MAA4C;AACrF,QAAM,KAAK,KAAK;AAChB,UAAQ,GAAG,MAAM;AAAA,IACf,KAAK;AACH,aAAO,KAAK,OAAO,GAAG,MAAM,KAAK,SAAS;AAAA,IAC5C,KAAK;AACH,aAAO,KAAK,OAAO,GAAG,QAAQ,GAAG,MAAM,KAAK,SAAS;AAAA,IACvD,KAAK;AACH,aAAO,KAAK,OAAO,GAAG,QAAQ,KAAK,SAAS;AAAA,IAC9C,KAAK;AACH,aAAO,KAAK,QAAQ,GAAG,QAAQ,KAAK,SAAS;AAAA,EACjD;AACF;AAEA,IAAI,YAA+E;AAM5E,SAAS,qBACd,MAC4D;AAC5D,MAAI,UAAW,QAAO;AAEtB,QAAM,QAAQ,OAAO,cAAc,cAAc,UAAU,QAAQ;AACnE,QAAMA,OAAuB,OAAO,UAC/B,MAAM;AAAA,IAAQ;AAAA,IAA+B,MAC5C,WAAW,IAAI;AAAA,EACjB,IACA,WAAW,IAAI;AACnB,QAAM,UAAUA,KAAI,QAAQ,MAAM;AAChC,gBAAY;AAAA,EACd,CAAC;AACD,cAAY;AACZ,SAAO;AACT;AAEA,eAAe,WACb,MAC4D;AAC5D,QAAM,SAAS,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,EAAE;AAChD,aAAW,UAAU,MAAM,UAAU,GAAG;AACtC,QAAI,OAAO,UAAU,YAAY,OAAO,UAAU,UAAW;AAC7D,QAAI,kBAAkB,EAAG;AAEzB,QAAI,OAA2B;AAAA,MAC7B,GAAG;AAAA,MACH,SAAS,OAAO,WAAW,OAAO,UAAU;AAAA,IAC9C;AACA,QAAI,KAAK,GAAG,SAAS,YAAY,KAAK,WAAW,KAAK,aAAa;AACjE,UAAI,QAAQ;AACZ,UAAI;AACF,gBAAQ,MAAM,KAAK,YAAY,KAAK,WAAW,KAAK,GAAG,IAAI;AAAA,MAC7D,SAAS,OAAO;AACd,YAAI,SAAS,KAAK,MAAM,UAAW;AAAA,MACrC;AACA,UAAI,OAAO;AACT,cAAM,MAAM,cAAc,CAAC,MAAM,UAAU,KAAK,SAAS,CAAC,CAAC;AAC3D,eAAO;AACP;AAAA,MACF;AAAA,IACF;AACA,WAAO,EAAE,GAAG,MAAM,OAAO,WAAW,UAAU,KAAK,WAAW,EAAE;AAChE,UAAM,UAAU,IAAI;AACpB,QAAI;AACJ,QAAI;AACJ,QAAI;AACF,YAAM,IAAI,MAAM,IAAI;AACpB,gBAAU;AAAA,IACZ,SAAS,OAAO;AACd,gBAAU,SAAS,KAAK;AACxB,gBAAU,iBAAiB,QAAQ,MAAM,UAAU;AAAA,IACrD;AACA,QAAI,YAAY,QAAQ;AACtB,YAAM,MAAM,cAAc,CAAC,MAAM,UAAU,KAAK,SAAS,CAAC,CAAC;AAC3D,aAAO;AACP;AAAA,IACF;AACA,QAAI,YAAY,UAAU;AACxB,YAAM,UAAU,EAAE,GAAG,MAAM,OAAO,UAAU,OAAO,QAAQ,CAAC;AAC5D,aAAO;AACP;AAAA,IACF;AAEA,UAAM,UAAU,KAAK,WAAW,KAAK,GAAG,SAAS;AACjD,UAAM,UAAU,EAAE,GAAG,MAAM,OAAO,UAAU,SAAS,OAAO,QAAQ,CAAC;AACrE,QAAI,QAAS,QAAO;AACpB,QAAI,YAAY,UAAW;AAAA,EAC7B;AACA,SAAO;AACP,SAAO;AACT;AAKA,MAAM,YAAY,oBAAI,IAA4C;AAClE,SAAS,OAAO,SAA+B,WAAW;AACxD,aAAW,KAAK,UAAW,GAAE,MAAM;AACrC;AAEO,SAAS,uBACd,UACY;AACZ,YAAU,IAAI,QAAQ;AACtB,SAAO,MAAM,UAAU,OAAO,QAAQ;AACxC;AAEA,eAAsB,sBAAqC;AACzD,QAAM,UAAU,QAAQ,KAAK;AAC7B,SAAO;AACT;AAOA,eAAsB,qBAAqB,WAAkC;AAC3E,QAAM,QAAQ,MAAM,MAAM,QAAgB,OAAO;AACjD,MAAI,SAAS,UAAU,UAAW,OAAM,oBAAoB;AAC5D,QAAM,MAAM,QAAQ,SAAS,SAAS;AACxC;",
+  "names": ["run"]
+}

package/dist/calendar/offline/runtime.js

@@ -0,0 +1,109 @@
+import { useEffect } from "react";
+import { onlineManager, useQueryClient } from "@tanstack/react-query";
+import { logger } from "@arbidocs/client";
+import { notify } from "../../notifications/notify-store.js";
+import { useArbi } from "../../useArbi.js";
+import { useArbiSession } from "../../session/signed-in.js";
+import { calendarQueryKeys } from "../keys.js";
+import {
+  claimCalendarOffline,
+  onCalendarOutboxChange,
+  replayCalendarOutbox
+} from "./outbox.js";
+const day = (date, offset) => {
+  const t = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+  t.setUTCDate(t.getUTCDate() + offset);
+  return t.toISOString();
+};
+const calendarOutboxExecutor = (arbi) => ({
+  create: (body) => arbi.calendar.createEvent(body),
+  update: (target, body) => arbi.calendar.updateEvent(target, body),
+  delete: (target) => arbi.calendar.deleteEvent(target),
+  respond: (params) => arbi.calendar.respond(params),
+  /** No server dedupe: an in-doubt create counts as made if an event with its title and start exists. */
+  async findCreated(_requestId, body) {
+    const { title, start } = body;
+    const date = (start?.date_time ?? start?.date ?? "").slice(0, 10);
+    if (!title || !/^\d{4}-\d{2}-\d{2}$/.test(date)) return false;
+    const events = await arbi.calendar.listEvents({
+      start: day(date, -1),
+      end: day(date, 2)
+    });
+    return events.some(
+      (e) => e.title === title && (start?.date_time ? (e.start.date_time ?? "").slice(0, 16) === start.date_time.slice(0, 16) : e.start.date === start?.date)
+    );
+  }
+});
+const SYNC_CHANNEL = "arbi-calendar-outbox";
+function refreshCalendarQueries(queryClient) {
+  void queryClient.invalidateQueries({ queryKey: calendarQueryKeys.all() });
+}
+async function replay(arbi, queryClient) {
+  const result = await replayCalendarOutbox(calendarOutboxExecutor(arbi));
+  if (result.sent || result.failed) {
+    refreshCalendarQueries(queryClient);
+    try {
+      const channel = new BroadcastChannel(SYNC_CHANNEL);
+      channel.postMessage("synced");
+      channel.close();
+    } catch {
+    }
+  }
+  if (result.failed)
+    notify.error(
+      result.failed === 1 ? "A calendar change made offline could not be saved" : `${result.failed} calendar changes made offline could not be saved`
+    );
+}
+function useCalendarOfflineRuntime() {
+  const { status, serverSessionKey, user } = useArbiSession();
+  const userExtId = user?.external_id;
+  const authenticated = status === "signed-in";
+  const hasSession = !!serverSessionKey;
+  const arbi = useArbi();
+  const ready = authenticated && hasSession && arbi.isLoggedIn;
+  const queryClient = useQueryClient();
+  useEffect(() => {
+    if (!authenticated || !userExtId) return;
+    claimCalendarOffline(userExtId).catch(
+      (error) => logger.warn("[offline-calendar] could not bind the store", error)
+    );
+  }, [authenticated, userExtId]);
+  useEffect(() => {
+    if (!ready) return;
+    const run = () => {
+      if (!onlineManager.isOnline()) return;
+      replay(arbi, queryClient).catch(
+        (error) => logger.warn("[offline-calendar] replay failed", error)
+      );
+    };
+    run();
+    let wasOnline = onlineManager.isOnline();
+    const offOnline = onlineManager.subscribe((online) => {
+      if (online && !wasOnline) run();
+      wasOnline = online;
+    });
+    let queued = null;
+    const offOutbox = onCalendarOutboxChange((change) => {
+      if (change !== "enqueued") return;
+      if (queued) clearTimeout(queued);
+      queued = setTimeout(run, 2e3);
+    });
+    let channel = null;
+    try {
+      channel = new BroadcastChannel(SYNC_CHANNEL);
+      channel.onmessage = () => refreshCalendarQueries(queryClient);
+    } catch {
+      channel = null;
+    }
+    return () => {
+      channel?.close();
+      offOnline();
+      offOutbox();
+      if (queued) clearTimeout(queued);
+    };
+  }, [ready, arbi, queryClient]);
+}
+export {
+  useCalendarOfflineRuntime
+};
+//# sourceMappingURL=runtime.js.map

package/dist/calendar/offline/runtime.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/calendar/offline/runtime.ts"],
+  "sourcesContent": ["/**\n * useCalendarOfflineRuntime \u2014 mounted once by the host for a signed-in user. On reconnect (and at start,\n * when online with a live session) it replays the calendar Outbox (writes made offline) in order,\n * then refreshes the calendar queries.\n */\n\nimport { useEffect } from 'react'\nimport { onlineManager, useQueryClient, type QueryClient } from '@tanstack/react-query'\nimport type { Arbi } from '@arbidocs/sdk/browser'\nimport { logger } from '@arbidocs/client'\nimport { notify } from '../../notifications/notify-store'\nimport { useArbi } from '../../useArbi'\nimport { useArbiSession } from '../../session/signed-in'\nimport { calendarQueryKeys } from '../keys'\nimport {\n  claimCalendarOffline,\n  onCalendarOutboxChange,\n  replayCalendarOutbox,\n  type CalendarOutboxExecutor,\n} from './outbox'\n\nconst day = (date: string, offset: number) => {\n  const t = new Date(`${date}T00:00:00Z`)\n  t.setUTCDate(t.getUTCDate() + offset)\n  return t.toISOString()\n}\n\n/** Sends the queued writes on a signed-in session. */\nconst calendarOutboxExecutor = (arbi: Arbi): CalendarOutboxExecutor => ({\n  create: (body) => arbi.calendar.createEvent(body),\n  update: (target, body) => arbi.calendar.updateEvent(target, body),\n  delete: (target) => arbi.calendar.deleteEvent(target),\n  respond: (params) => arbi.calendar.respond(params),\n  /** No server dedupe: an in-doubt create counts as made if an event with its title and start exists. */\n  async findCreated(_requestId, body) {\n    const { title, start } = body\n    const date = (start?.date_time ?? start?.date ?? '').slice(0, 10)\n    if (!title || !/^\\d{4}-\\d{2}-\\d{2}$/.test(date)) return false\n    const events = await arbi.calendar.listEvents({\n      start: day(date, -1),\n      end: day(date, 2),\n    })\n    return events.some(\n      (e) =>\n        e.title === title &&\n        (start?.date_time\n          ? (e.start.date_time ?? '').slice(0, 16) === start.date_time.slice(0, 16)\n          : e.start.date === start?.date)\n    )\n  },\n})\n\n/** Tabs take turns replaying (Web Lock); the one that sent tells the others to refresh. */\nconst SYNC_CHANNEL = 'arbi-calendar-outbox'\n\nfunction refreshCalendarQueries(queryClient: QueryClient) {\n  // The outbox list is under the calendar keys too.\n  void queryClient.invalidateQueries({ queryKey: calendarQueryKeys.all() })\n}\n\nasync function replay(arbi: Arbi, queryClient: QueryClient): Promise<void> {\n  const result = await replayCalendarOutbox(calendarOutboxExecutor(arbi))\n  if (result.sent || result.failed) {\n    refreshCalendarQueries(queryClient)\n    try {\n      const channel = new BroadcastChannel(SYNC_CHANNEL)\n      channel.postMessage('synced')\n      channel.close()\n    } catch {\n      /* no BroadcastChannel: other tabs refresh on their next fetch */\n    }\n  }\n  if (result.failed)\n    notify.error(\n      result.failed === 1\n        ? 'A calendar change made offline could not be saved'\n        : `${result.failed} calendar changes made offline could not be saved`\n    )\n}\n\nexport function useCalendarOfflineRuntime(): void {\n  const { status, serverSessionKey, user } = useArbiSession()\n  const userExtId = user?.external_id\n  const authenticated = status === 'signed-in'\n  const hasSession = !!serverSessionKey\n  // The writes go out on the shared session's `Arbi`, once it holds the login.\n  const arbi = useArbi()\n  const ready = authenticated && hasSession && arbi.isLoggedIn\n  const queryClient = useQueryClient()\n\n  useEffect(() => {\n    if (!authenticated || !userExtId) return\n    claimCalendarOffline(userExtId).catch((error) =>\n      logger.warn('[offline-calendar] could not bind the store', error)\n    )\n  }, [authenticated, userExtId])\n\n  useEffect(() => {\n    if (!ready) return\n    const run = () => {\n      if (!onlineManager.isOnline()) return\n      replay(arbi, queryClient).catch((error) =>\n        logger.warn('[offline-calendar] replay failed', error)\n      )\n    }\n    run()\n    let wasOnline = onlineManager.isOnline()\n    const offOnline = onlineManager.subscribe((online) => {\n      if (online && !wasOnline) run()\n      wasOnline = online\n    })\n    // A write queued while online (e.g. the request failed mid-flight) goes out on the next change.\n    let queued: ReturnType<typeof setTimeout> | null = null\n    const offOutbox = onCalendarOutboxChange((change) => {\n      if (change !== 'enqueued') return\n      if (queued) clearTimeout(queued)\n      queued = setTimeout(run, 2_000)\n    })\n    let channel: BroadcastChannel | null = null\n    try {\n      channel = new BroadcastChannel(SYNC_CHANNEL)\n      channel.onmessage = () => refreshCalendarQueries(queryClient)\n    } catch {\n      channel = null\n    }\n    return () => {\n      channel?.close()\n      offOnline()\n      offOutbox()\n      if (queued) clearTimeout(queued)\n    }\n  }, [ready, arbi, queryClient])\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/calendar/offline/support.js

@@ -0,0 +1,41 @@
+import { ArbiApiError } from "@arbidocs/sdk/browser";
+import {
+  enqueueCalendarWrite,
+  isCalendarNetworkError,
+  isCalendarOffline,
+  listCalendarOutbox,
+  onCalendarOutboxChange,
+  readCalendarCache,
+  writeCalendarCache
+} from "./outbox.js";
+const calendarOfflineSupport = {
+  async read(key, fetch) {
+    const cacheKey = JSON.stringify(key);
+    if (!isCalendarOffline()) {
+      try {
+        const data = await fetch();
+        void writeCalendarCache(cacheKey, data).catch(() => {
+        });
+        return data;
+      } catch (err) {
+        if (!isCalendarNetworkError(err)) throw err;
+      }
+    }
+    const cached = await readCalendarCache(cacheKey).catch(
+      () => null
+    );
+    if (cached != null) return cached;
+    throw new ArbiApiError("You are offline and this view is not saved on this device");
+  },
+  async write(op, send) {
+    if (!isCalendarOffline()) return send();
+    const { requestId } = await enqueueCalendarWrite(op);
+    return { queued: true, requestId };
+  },
+  pending: listCalendarOutbox,
+  subscribe: (listener) => onCalendarOutboxChange(() => listener())
+};
+export {
+  calendarOfflineSupport
+};
+//# sourceMappingURL=support.js.map

package/dist/calendar/offline/support.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/calendar/offline/support.ts"],
+  "sourcesContent": ["/**\n * The calendar kept on this device, as the calendar hooks take it (the host's\n * `calendar.offline`): reads are remembered (encrypted) and answered from that copy when the\n * network is down; event writes made offline go to the outbox, which `useCalendarOfflineRuntime`\n * replays once back online.\n */\nimport { ArbiApiError } from '@arbidocs/sdk/browser'\nimport type { CalendarOfflineSupport } from '../support'\nimport {\n  enqueueCalendarWrite,\n  isCalendarNetworkError,\n  isCalendarOffline,\n  listCalendarOutbox,\n  onCalendarOutboxChange,\n  readCalendarCache,\n  writeCalendarCache,\n} from './outbox'\n\nexport const calendarOfflineSupport: CalendarOfflineSupport = {\n  async read(key, fetch) {\n    const cacheKey = JSON.stringify(key)\n    if (!isCalendarOffline()) {\n      try {\n        const data = await fetch()\n        void writeCalendarCache(cacheKey, data).catch(() => {})\n        return data\n      } catch (err) {\n        if (!isCalendarNetworkError(err)) throw err\n      }\n    }\n    const cached = await readCalendarCache<Awaited<ReturnType<typeof fetch>>>(cacheKey).catch(\n      () => null\n    )\n    if (cached != null) return cached\n    throw new ArbiApiError('You are offline and this view is not saved on this device')\n  },\n  async write(op, send) {\n    if (!isCalendarOffline()) return send()\n    const { requestId } = await enqueueCalendarWrite(op)\n    return { queued: true, requestId }\n  },\n  pending: listCalendarOutbox,\n  subscribe: (listener) => onCalendarOutboxChange(() => listener()),\n}\n"],
+  "mappings": "AAMA,SAAS,oBAAoB;AAE7B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEA,MAAM,yBAAiD;AAAA,EAC5D,MAAM,KAAK,KAAK,OAAO;AACrB,UAAM,WAAW,KAAK,UAAU,GAAG;AACnC,QAAI,CAAC,kBAAkB,GAAG;AACxB,UAAI;AACF,cAAM,OAAO,MAAM,MAAM;AACzB,aAAK,mBAAmB,UAAU,IAAI,EAAE,MAAM,MAAM;AAAA,QAAC,CAAC;AACtD,eAAO;AAAA,MACT,SAAS,KAAK;AACZ,YAAI,CAAC,uBAAuB,GAAG,EAAG,OAAM;AAAA,MAC1C;AAAA,IACF;AACA,UAAM,SAAS,MAAM,kBAAqD,QAAQ,EAAE;AAAA,MAClF,MAAM;AAAA,IACR;AACA,QAAI,UAAU,KAAM,QAAO;AAC3B,UAAM,IAAI,aAAa,2DAA2D;AAAA,EACpF;AAAA,EACA,MAAM,MAAM,IAAI,MAAM;AACpB,QAAI,CAAC,kBAAkB,EAAG,QAAO,KAAK;AACtC,UAAM,EAAE,UAAU,IAAI,MAAM,qBAAqB,EAAE;AACnD,WAAO,EAAE,QAAQ,MAAM,UAAU;AAAA,EACnC;AAAA,EACA,SAAS;AAAA,EACT,WAAW,CAAC,aAAa,uBAAuB,MAAM,SAAS,CAAC;AAClE;",
+  "names": []
+}

package/dist/calendar/support.js

@@ -0,0 +1,34 @@
+import { useMemo } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useArbi } from "../useArbi.js";
+import { useArbiHost } from "../host/config.js";
+import { connectorQueryKeys } from "../connectors/hooks.js";
+function isQueuedCalendarWrite(value) {
+  return !!value && typeof value === "object" && value.queued === true;
+}
+const NO_SUPPORT = {};
+function useCalendarSupport() {
+  const support = useArbiHost().calendar ?? NO_SUPPORT;
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  return useMemo(
+    () => ({
+      ...support,
+      connectors: support.connectors ?? {
+        authorize: (vendor, returnPath) => arbi.connectors.authorize(vendor, returnPath),
+        bridge: (vendor) => arbi.connectors.bridgeTokens({ vendor }),
+        connectedVendors: async () => (await qc.fetchQuery({
+          queryKey: connectorQueryKeys.mine(),
+          queryFn: () => arbi.connectors.mine(),
+          staleTime: 3e4
+        })).map((c) => c.vendor_key)
+      }
+    }),
+    [support, arbi, qc]
+  );
+}
+export {
+  isQueuedCalendarWrite,
+  useCalendarSupport
+};
+//# sourceMappingURL=support.js.map

package/dist/calendar/support.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/calendar/support.tsx"],
+  "sourcesContent": ["/**\n * What a host adds to the calendar hooks (the host configuration's `calendar`), all optional:\n * keeping the calendar on this device (offline reads and a write outbox), and where the OAuth of a\n * Google or Microsoft account comes back to. Without it the hooks read and write online only.\n * Accounts connect through the user's connectors (`arbi.connectors`) unless the host supplies its\n * own.\n */\n\nimport { useMemo } from 'react'\nimport { useQueryClient } from '@tanstack/react-query'\nimport { useArbi } from '../useArbi'\nimport { useArbiHost } from '../host/config'\nimport { connectorQueryKeys } from '../connectors/hooks'\nimport type {\n  EventCreateBody,\n  EventPatchBody,\n  RespondParams,\n  ScopedTarget,\n} from '@arbidocs/sdk/browser'\n\n/** A write the outbox can hold while offline. */\nexport type CalendarWriteOp =\n  | { kind: 'create'; body: EventCreateBody }\n  | { kind: 'update'; target: ScopedTarget; body: EventPatchBody }\n  | { kind: 'delete'; target: ScopedTarget & { notify?: boolean } }\n  | { kind: 'respond'; params: RespondParams }\n\n/** A write made offline: queued on this device and sent exactly once when back online. */\nexport interface QueuedCalendarWrite {\n  queued: true\n  requestId: string\n}\n\nexport function isQueuedCalendarWrite(value: unknown): value is QueuedCalendarWrite {\n  return !!value && typeof value === 'object' && (value as QueuedCalendarWrite).queued === true\n}\n\n/** A write waiting in the outbox (a queued create is drawn on the grid as pending). */\nexport interface CalendarPendingWrite {\n  requestId: string\n  op: CalendarWriteOp\n  state: string\n  inDoubt?: boolean\n  error?: string\n}\n\nexport interface CalendarOfflineSupport {\n  /**\n   * Run a read online and keep the result on this device; when the network is down, answer from\n   * that copy. `key` identifies the read (its query key).\n   */\n  read<T>(key: readonly unknown[], fetch: () => Promise<T>): Promise<T>\n  /** Send a write, or, offline, queue it and answer {@link QueuedCalendarWrite}. */\n  write<T>(op: CalendarWriteOp, send: () => Promise<T>): Promise<T | QueuedCalendarWrite>\n  /** The writes waiting in the outbox. */\n  pending(): Promise<CalendarPendingWrite[]>\n  /** Be told when the outbox changes. Returns the unsubscribe. */\n  subscribe(listener: () => void): () => void\n}\n\nexport interface CalendarConnectorSupport {\n  /** The URL that starts a connector's OAuth consent and comes back to `returnPath`. */\n  authorize(vendor: string, returnPath: string): Promise<string>\n  /** Hand this server session the connector's sealed grant (the server answered 401 without it). */\n  bridge(vendor: string): Promise<void>\n  /** The vendor keys of the user's connected connectors. */\n  connectedVendors(): Promise<string[]>\n}\n\nexport interface CalendarSupport {\n  offline?: CalendarOfflineSupport\n  connectors?: CalendarConnectorSupport\n  /** Where the OAuth consent returns to (default: the current page). */\n  oauthReturnPath?: string\n}\n\nconst NO_SUPPORT: CalendarSupport = {}\n\nexport function useCalendarSupport(): CalendarSupport {\n  const support = useArbiHost().calendar ?? NO_SUPPORT\n  const arbi = useArbi()\n  const qc = useQueryClient()\n  return useMemo<CalendarSupport>(\n    () => ({\n      ...support,\n      connectors: support.connectors ?? {\n        authorize: (vendor, returnPath) => arbi.connectors.authorize(vendor, returnPath),\n        bridge: (vendor) => arbi.connectors.bridgeTokens({ vendor }),\n        connectedVendors: async () =>\n          (\n            await qc.fetchQuery({\n              queryKey: connectorQueryKeys.mine(),\n              queryFn: () => arbi.connectors.mine(),\n              staleTime: 30_000,\n            })\n          ).map((c) => c.vendor_key),\n      },\n    }),\n    [support, arbi, qc]\n  )\n}\n"],
+  "mappings": "AAQA,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAC/B,SAAS,eAAe;AACxB,SAAS,mBAAmB;AAC5B,SAAS,0BAA0B;AAqB5B,SAAS,sBAAsB,OAA8C;AAClF,SAAO,CAAC,CAAC,SAAS,OAAO,UAAU,YAAa,MAA8B,WAAW;AAC3F;AAyCA,MAAM,aAA8B,CAAC;AAE9B,SAAS,qBAAsC;AACpD,QAAM,UAAU,YAAY,EAAE,YAAY;AAC1C,QAAM,OAAO,QAAQ;AACrB,QAAM,KAAK,eAAe;AAC1B,SAAO;AAAA,IACL,OAAO;AAAA,MACL,GAAG;AAAA,MACH,YAAY,QAAQ,cAAc;AAAA,QAChC,WAAW,CAAC,QAAQ,eAAe,KAAK,WAAW,UAAU,QAAQ,UAAU;AAAA,QAC/E,QAAQ,CAAC,WAAW,KAAK,WAAW,aAAa,EAAE,OAAO,CAAC;AAAA,QAC3D,kBAAkB,aAEd,MAAM,GAAG,WAAW;AAAA,UAClB,UAAU,mBAAmB,KAAK;AAAA,UAClC,SAAS,MAAM,KAAK,WAAW,KAAK;AAAA,UACpC,WAAW;AAAA,QACb,CAAC,GACD,IAAI,CAAC,MAAM,EAAE,UAAU;AAAA,MAC7B;AAAA,IACF;AAAA,IACA,CAAC,SAAS,MAAM,EAAE;AAAA,EACpB;AACF;",
+  "names": []
+}