@arbidocs/react 0.5.110 → 0.5.112

package/dist/mail/offline/hooks.js

@@ -0,0 +1,104 @@
+import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { logger } from "@arbidocs/client";
+import { useArbi } from "../../useArbi.js";
+import { useArbiSession } from "../../session/signed-in.js";
+import { listLocalDrafts } from "./drafts.js";
+import { flushOutbox, isMailSyncRunning, syncOfflineMailbox } from "./live.js";
+import { listOutbox } from "./outbox.js";
+import { listMailChanges } from "./changes.js";
+import {
+  getOfflineMailSettings,
+  onOfflineMailChange,
+  setOfflineMailSettings
+} from "./settings.js";
+import { getOfflineMailStatus } from "./sync.js";
+function useStoreValue(load, initial, changes) {
+  const [value, setValue] = useState(initial);
+  const key = changes.join(",");
+  useEffect(() => {
+    let alive = true;
+    const read = () => load().then((next) => alive && setValue(next)).catch((error) => logger.warn("[offline-mail] read failed", error));
+    void read();
+    const off = onOfflineMailChange((change) => {
+      if (change === "wiped") setValue(initial);
+      if (change === "wiped" || key.split(",").includes(change)) void read();
+    });
+    return () => {
+      alive = false;
+      off();
+    };
+  }, [key, load, initial]);
+  return value;
+}
+function useOfflineMailSettings() {
+  const userExtId = useArbiSession().user?.external_id;
+  const subscribe = useCallback(
+    (onChange) => onOfflineMailChange((change) => {
+      if (change === "settings") onChange();
+    }),
+    []
+  );
+  const raw = useSyncExternalStore(
+    subscribe,
+    () => JSON.stringify([userExtId, getOfflineMailSettings(userExtId)])
+  );
+  const settings = useMemo(() => JSON.parse(raw)[1], [raw]);
+  const update = useCallback(
+    (patch) => void setOfflineMailSettings(userExtId, patch),
+    [userExtId]
+  );
+  return [settings, update];
+}
+const EMPTY_STATUS = { messages: 0, bytes: 0, skipped: [] };
+function useOfflineMailStatus() {
+  const status = useStoreValue(getOfflineMailStatus, EMPTY_STATUS, ["status", "mailbox"]);
+  const [syncing, setSyncing] = useState(isMailSyncRunning);
+  useEffect(
+    () => onOfflineMailChange((change) => {
+      if (change === "status") setSyncing(isMailSyncRunning());
+    }),
+    []
+  );
+  return { ...status, syncing };
+}
+const NO_ITEMS = [];
+function useOutbox(enabled = true) {
+  const load = useCallback(() => enabled ? listOutbox() : Promise.resolve(NO_ITEMS), [enabled]);
+  return useStoreValue(load, NO_ITEMS, ["outbox"]);
+}
+const NO_CHANGES = [];
+function usePendingMailChanges(enabled = true) {
+  const load = useCallback(
+    () => enabled ? listMailChanges() : Promise.resolve(NO_CHANGES),
+    [enabled]
+  );
+  return useStoreValue(load, NO_CHANGES, ["changes"]);
+}
+const NO_DRAFTS = [];
+function useLocalDrafts(accountId) {
+  const load = useCallback(
+    () => accountId ? listLocalDrafts(accountId) : Promise.resolve(NO_DRAFTS),
+    [accountId]
+  );
+  return useStoreValue(load, NO_DRAFTS, ["drafts"]);
+}
+function useFlushOutbox() {
+  const arbi = useArbi();
+  const queryClient = useQueryClient();
+  return useCallback(() => flushOutbox({ arbi, queryClient }), [arbi, queryClient]);
+}
+function useSyncOfflineMailbox() {
+  const arbi = useArbi();
+  return useCallback((options) => syncOfflineMailbox({ arbi }, options), [arbi]);
+}
+export {
+  useFlushOutbox,
+  useLocalDrafts,
+  useOfflineMailSettings,
+  useOfflineMailStatus,
+  useOutbox,
+  usePendingMailChanges,
+  useSyncOfflineMailbox
+};
+//# sourceMappingURL=hooks.js.map

package/dist/mail/offline/hooks.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mail/offline/hooks.ts"],
+  "sourcesContent": ["/**\n * React bindings for the offline mailbox: the per-device settings, sync status, the Outbox, the\n * changes made offline and the drafts kept on this device. Every hook re-reads when the store changes in this tab or another.\n */\n\nimport { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from 'react'\nimport { useQueryClient } from '@tanstack/react-query'\nimport { logger } from '@arbidocs/client'\nimport { useArbi } from '../../useArbi'\nimport { useArbiSession } from '../../session/signed-in'\nimport { listLocalDrafts, type LocalDraft } from './drafts'\nimport { flushOutbox, isMailSyncRunning, syncOfflineMailbox } from './live'\nimport { listOutbox, type OutboxItem } from './outbox'\nimport { listMailChanges, type PendingMailChange } from './changes'\nimport {\n  getOfflineMailSettings,\n  onOfflineMailChange,\n  setOfflineMailSettings,\n  type OfflineMailChange,\n  type OfflineMailSettings,\n} from './settings'\nimport { getOfflineMailStatus, type OfflineMailStatus } from './sync'\n\n/** Re-run `load` on mount and whenever one of `changes` happens; errors leave the last value. */\nfunction useStoreValue<T>(load: () => Promise<T>, initial: T, changes: OfflineMailChange[]): T {\n  const [value, setValue] = useState<T>(initial)\n  const key = changes.join(',')\n  useEffect(() => {\n    let alive = true\n    const read = () =>\n      load()\n        .then((next) => alive && setValue(next))\n        .catch((error) => logger.warn('[offline-mail] read failed', error))\n    void read()\n    const off = onOfflineMailChange((change) => {\n      if (change === 'wiped') setValue(initial)\n      if (change === 'wiped' || key.split(',').includes(change)) void read()\n    })\n    return () => {\n      alive = false\n      off()\n    }\n  }, [key, load, initial])\n  return value\n}\n\nexport function useOfflineMailSettings(): [\n  OfflineMailSettings,\n  (patch: Partial<OfflineMailSettings>) => void,\n] {\n  const userExtId = useArbiSession().user?.external_id\n  const subscribe = useCallback(\n    (onChange: () => void) =>\n      onOfflineMailChange((change) => {\n        if (change === 'settings') onChange()\n      }),\n    []\n  )\n  // Snapshot as a string so useSyncExternalStore sees a stable value between changes; the user is\n  // part of it because the settings are per user.\n  const raw = useSyncExternalStore(subscribe, () =>\n    JSON.stringify([userExtId, getOfflineMailSettings(userExtId)])\n  )\n  const settings = useMemo(() => (JSON.parse(raw) as [unknown, OfflineMailSettings])[1], [raw])\n  const update = useCallback(\n    (patch: Partial<OfflineMailSettings>) => void setOfflineMailSettings(userExtId, patch),\n    [userExtId]\n  )\n  return [settings, update]\n}\n\nconst EMPTY_STATUS: OfflineMailStatus = { messages: 0, bytes: 0, skipped: [] }\n\nexport function useOfflineMailStatus(): OfflineMailStatus & { syncing: boolean } {\n  const status = useStoreValue(getOfflineMailStatus, EMPTY_STATUS, ['status', 'mailbox'])\n  const [syncing, setSyncing] = useState(isMailSyncRunning)\n  useEffect(\n    () =>\n      onOfflineMailChange((change) => {\n        if (change === 'status') setSyncing(isMailSyncRunning())\n      }),\n    []\n  )\n  return { ...status, syncing }\n}\n\nconst NO_ITEMS: OutboxItem[] = []\n/** The Outbox, oldest first. `enabled: false` skips reading the store (Mail switched off). */\nexport function useOutbox(enabled = true): OutboxItem[] {\n  const load = useCallback(() => (enabled ? listOutbox() : Promise.resolve(NO_ITEMS)), [enabled])\n  return useStoreValue(load, NO_ITEMS, ['outbox'])\n}\n\nconst NO_CHANGES: PendingMailChange[] = []\n/**\n * The changes made offline that wait for a connection, oldest first. `enabled: false` skips\n * reading the store (Mail switched off).\n */\nexport function usePendingMailChanges(enabled = true): PendingMailChange[] {\n  const load = useCallback(\n    () => (enabled ? listMailChanges() : Promise.resolve(NO_CHANGES)),\n    [enabled]\n  )\n  return useStoreValue(load, NO_CHANGES, ['changes'])\n}\n\nconst NO_DRAFTS: LocalDraft[] = []\nexport function useLocalDrafts(accountId: string | undefined): LocalDraft[] {\n  const load = useCallback(\n    () => (accountId ? listLocalDrafts(accountId) : Promise.resolve(NO_DRAFTS)),\n    [accountId]\n  )\n  return useStoreValue(load, NO_DRAFTS, ['drafts'])\n}\n\n/** Send what waits in the Outbox now (\"Send now\"), on the session in scope. */\nexport function useFlushOutbox(): () => Promise<void> {\n  const arbi = useArbi()\n  const queryClient = useQueryClient()\n  return useCallback(() => flushOutbox({ arbi, queryClient }), [arbi, queryClient])\n}\n\n/** One sync pass of the offline mailbox now (\"Sync now\": `{ full: true }`). */\nexport function useSyncOfflineMailbox(): (options?: { full?: boolean }) => Promise<void> {\n  const arbi = useArbi()\n  return useCallback((options) => syncOfflineMailbox({ arbi }, options), [arbi])\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mail/offline/index.js

@@ -0,0 +1,48 @@
+import { offlineMailReads } from "./reads.js";
+import {
+  useOfflineMailActive,
+  useOfflineMailRuntime
+} from "./runtime.js";
+import {
+  useOfflineMailSettings,
+  useOfflineMailStatus,
+  useOutbox,
+  usePendingMailChanges,
+  useLocalDrafts,
+  useFlushOutbox,
+  useSyncOfflineMailbox
+} from "./hooks.js";
+import { OUTBOX_FOLDER } from "./live.js";
+import { enqueueOutbox, deleteOutboxItem, retryOutboxItem } from "./outbox.js";
+import { saveLocalDraft, deleteLocalDraft } from "./drafts.js";
+import {
+  hasPendingMailChange,
+  queueMailChange
+} from "./changes.js";
+import { loadAttachment } from "./mailbox.js";
+import { wipeOfflineMail } from "./wipe.js";
+import { confirmLosingOfflineMail } from "./confirm-sign-out.js";
+export {
+  OUTBOX_FOLDER,
+  confirmLosingOfflineMail,
+  deleteLocalDraft,
+  deleteOutboxItem,
+  enqueueOutbox,
+  hasPendingMailChange,
+  loadAttachment as loadOfflineMailAttachment,
+  offlineMailReads,
+  queueMailChange,
+  retryOutboxItem,
+  saveLocalDraft,
+  useFlushOutbox,
+  useLocalDrafts,
+  useOfflineMailActive,
+  useOfflineMailRuntime,
+  useOfflineMailSettings,
+  useOfflineMailStatus,
+  useOutbox,
+  usePendingMailChanges,
+  useSyncOfflineMailbox,
+  wipeOfflineMail
+};
+//# sourceMappingURL=index.js.map

package/dist/mail/offline/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mail/offline/index.ts"],
+  "sourcesContent": ["/**\n * Mail kept on this device: reading offline (the last 7 days by default, adjustable per device),\n * the Outbox (sends that wait for a connection and go out exactly once, in order), changes made\n * offline (read, moved, trashed, deleted; applied in order on reconnect), drafts written offline,\n * and the sync that keeps the device copy current. All\n * of it is sealed at rest to the signed-in user's key (`arbi-offline-mail-v1`), bound to that\n * account, and removed on sign-out (`wipeOfflineMail`).\n *\n * A host turns it on with three pieces: `offlineMailReads` as its mail client's reads, the\n * `useOfflineMailRuntime` hook mounted once, and `wipeOfflineMail` on sign-out. The mailbox kit's\n * device storage (`offlineMailSupport` in `@arbidocs/blocks/connect`) is built on the rest.\n */\n\nexport { offlineMailReads, type OfflineMailReadsOptions } from './reads'\nexport {\n  useOfflineMailActive,\n  useOfflineMailRuntime,\n  type OfflineMailRuntimeOptions,\n} from './runtime'\nexport {\n  useOfflineMailSettings,\n  useOfflineMailStatus,\n  useOutbox,\n  usePendingMailChanges,\n  useLocalDrafts,\n  useFlushOutbox,\n  useSyncOfflineMailbox,\n} from './hooks'\nexport { OUTBOX_FOLDER } from './live'\nexport { enqueueOutbox, deleteOutboxItem, retryOutboxItem, type OutboxItem } from './outbox'\nexport { saveLocalDraft, deleteLocalDraft, type LocalDraft } from './drafts'\nexport {\n  hasPendingMailChange,\n  queueMailChange,\n  type MailChange,\n  type PendingMailChange,\n} from './changes'\nexport { loadAttachment as loadOfflineMailAttachment } from './mailbox'\nexport { type OfflineMailScope, type OfflineMailSettings } from './settings'\nexport { type OfflineMailStatus } from './sync'\nexport { wipeOfflineMail } from './wipe'\nexport { confirmLosingOfflineMail } from './confirm-sign-out'\n"],
+  "mappings": "AAaA,SAAS,wBAAsD;AAC/D;AAAA,EACE;AAAA,EACA;AAAA,OAEK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB;AAC9B,SAAS,eAAe,kBAAkB,uBAAwC;AAClF,SAAS,gBAAgB,wBAAyC;AAClE;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AACP,SAA2B,sBAAiC;AAG5D,SAAS,uBAAuB;AAChC,SAAS,gCAAgC;",
+  "names": []
+}

package/dist/mail/offline/live.js

@@ -0,0 +1,233 @@
+import { sendMailFile } from "../filing.js";
+import { primeOnArbi } from "../../queued-writes.js";
+import { onlineManager } from "@tanstack/react-query";
+import { logger } from "@arbidocs/client";
+import { notify } from "../../notifications/notify-store.js";
+import { accountPath, mailJson } from "../client.js";
+import { mailQueryKeys } from "../hooks.js";
+import { syncLocalDrafts } from "./drafts.js";
+import { applyMailChangesOnce } from "./changes.js";
+import { flushOutboxOnce, listOutbox, purgeSentOutbox } from "./outbox.js";
+import { getOfflineMailSettings, notifyOfflineMailChange } from "./settings.js";
+import { requestPersistentStorage } from "../../documents/offline-documents.js";
+import { syncMailbox } from "./sync.js";
+const OUTBOX_FOLDER = "outbox";
+function sessionUser(arbi) {
+  return arbi.session?.getState().user?.external_id ?? null;
+}
+function hasLiveSession(arbi) {
+  return !!arbi.session?.getState().serverSessionKey;
+}
+function canReachMail(arbi) {
+  return onlineManager.isOnline() && hasLiveSession(arbi);
+}
+const unlocked = { nativeUnlocked: true };
+function mailCall(arbi, path, init = {}) {
+  return mailJson((p, i) => arbi.mail.fetch(p, i, unlocked), path, init);
+}
+function liveTransport(arbi) {
+  const unlock = async (account) => {
+    if (!hasLiveSession(arbi))
+      throw Object.assign(new Error("Sign in to unlock your mailbox"), { status: 401 });
+    await arbi.mail.unlockAccount(account);
+  };
+  return {
+    policy: () => mailCall(arbi, "/policy"),
+    accounts: () => mailCall(arbi, "/accounts"),
+    unlock,
+    folders: (account) => mailCall(arbi, `${accountPath(account.id)}/folders`),
+    messages: (account, folderId, cursor) => mailCall(
+      arbi,
+      `${accountPath(account.id)}/messages?${new URLSearchParams({
+        folder_id: folderId,
+        q: "",
+        limit: "100",
+        ...cursor ? { cursor } : {}
+      })}`
+    ),
+    message: async (account, messageId) => {
+      const path = `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}`;
+      try {
+        return await mailCall(arbi, path);
+      } catch (error) {
+        if (error.status !== 401 || account.provider !== "native")
+          throw error;
+        if (hasLiveSession(arbi)) await arbi.mail.unlockNative();
+        return mailCall(arbi, path);
+      }
+    },
+    attachment: async (account, messageId, attachmentId) => {
+      const response = await arbi.mail.fetch(
+        `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`,
+        {},
+        unlocked
+      );
+      return new Uint8Array(await response.arrayBuffer());
+    }
+  };
+}
+function liveSender(arbi) {
+  const transport = liveTransport(arbi);
+  return {
+    prepareSecure: async (item) => {
+      if (item.account.provider !== "native")
+        throw new Error("Choose your native inbox to send securely");
+      return arbi.secureMail.prepare(item.compose, item.account, item.requestId);
+    },
+    unlock: async (account) => {
+      if (account.provider !== "native") await transport.unlock(account);
+    },
+    send: (item) => item.secure ? mailJson((p, i) => arbi.mail.fetch(p, i), "/secure/send", {
+      method: "POST",
+      body: JSON.stringify(item.securePayload)
+    }) : mailJson(
+      (p, i) => arbi.mail.fetch(p, i),
+      `${accountPath(item.account.id)}/send`,
+      {
+        method: "POST",
+        body: JSON.stringify({ ...item.compose, request_id: item.requestId })
+      }
+    )
+  };
+}
+function liveChangeSender(arbi) {
+  return {
+    unlock: (account) => liveTransport(arbi).unlock(account),
+    apply: async ({ account, messageId, change }) => {
+      if (change.kind === "file") {
+        const { kind: _, ...request } = change;
+        await sendMailFile(
+          (p, i) => arbi.mail.fetch(p, i),
+          primeOnArbi(arbi),
+          account,
+          messageId,
+          request
+        );
+        return;
+      }
+      await mailJson(
+        (p, i) => arbi.mail.fetch(p, i),
+        `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}`,
+        change.kind === "delete" ? { method: "DELETE" } : { method: "PATCH", body: JSON.stringify(change.update) }
+      );
+    }
+  };
+}
+const localLocks = /* @__PURE__ */ new Set();
+async function exclusive(name, fn) {
+  if (typeof navigator !== "undefined" && navigator.locks?.request) {
+    return navigator.locks.request(name, { ifAvailable: true }, async (lock) => {
+      if (!lock) return false;
+      await fn();
+      return true;
+    });
+  }
+  if (localLocks.has(name)) return false;
+  localLocks.add(name);
+  try {
+    await fn();
+    return true;
+  } finally {
+    localLocks.delete(name);
+  }
+}
+let retryTimer = null;
+async function sendOutbox({ arbi, queryClient, openOutbox }) {
+  const result = await flushOutboxOnce(liveSender(arbi), () => onlineManager.isOnline());
+  if (result.sent > 0) void queryClient.invalidateQueries({ queryKey: mailQueryKeys.all() });
+  const remaining = (await listOutbox()).filter((i) => i.status !== "sent");
+  if (result.failed > 0) {
+    notify.error(
+      result.failed === 1 ? "A message in your Outbox couldn't be sent" : `${result.failed} messages in your Outbox couldn't be sent`,
+      {
+        description: "Open the Outbox to see why, then retry, edit or delete it.",
+        ...openOutbox && { action: { label: "Open Outbox", onClick: openOutbox } }
+      }
+    );
+  } else if (result.sent > 0 && remaining.length === 0) {
+    notify.success(
+      result.sent === 1 ? "Your Outbox message was sent" : `${result.sent} Outbox messages sent`
+    );
+  }
+  setTimeout(() => void purgeSentOutbox(3e4), 31e3);
+}
+async function applyChanges({ arbi, queryClient }) {
+  const result = await applyMailChangesOnce(liveChangeSender(arbi), () => onlineManager.isOnline());
+  if (result.applied + result.gone + result.refused.length > 0)
+    void queryClient.invalidateQueries({ queryKey: mailQueryKeys.all() });
+  if (result.gone > 0)
+    notify.info(
+      result.gone === 1 ? "A message you changed offline was already gone from the server" : `${result.gone} messages you changed offline were already gone from the server`
+    );
+  if (result.refused.length > 0)
+    notify.error(
+      result.refused.length === 1 ? "A change you made offline couldn't be applied" : `${result.refused.length} changes you made offline couldn't be applied`,
+      { description: result.refused[0].error }
+    );
+}
+async function flushOutbox(context) {
+  if (!canReachMail(context.arbi)) return;
+  const ran = await exclusive("arbi-mail-outbox", async () => {
+    await sendOutbox(context);
+    await applyChanges(context);
+  });
+  if (!ran) {
+    if (retryTimer) clearTimeout(retryTimer);
+    retryTimer = setTimeout(() => void flushOutbox(context), 3e3);
+  }
+}
+async function uploadOfflineDrafts({
+  arbi,
+  queryClient
+}) {
+  if (!canReachMail(arbi)) return;
+  await exclusive("arbi-mail-drafts", async () => {
+    const uploaded = await syncLocalDrafts(
+      ({ accountId, compose }) => mailJson(
+        (p, i) => arbi.mail.fetch(p, i),
+        `${accountPath(accountId)}/drafts`,
+        {
+          method: "POST",
+          body: JSON.stringify(compose)
+        }
+      )
+    );
+    if (uploaded > 0) {
+      void queryClient.invalidateQueries({ queryKey: mailQueryKeys.allMessages() });
+      notify.success(
+        uploaded === 1 ? "Your offline draft was saved to Drafts" : `${uploaded} offline drafts were saved to Drafts`
+      );
+    }
+  });
+}
+let syncing = false;
+function isMailSyncRunning() {
+  return syncing;
+}
+async function syncOfflineMailbox({ arbi }, options = {}) {
+  const latest = () => getOfflineMailSettings(sessionUser(arbi));
+  const settings = latest();
+  if (!settings.enabled || !canReachMail(arbi)) return;
+  void requestPersistentStorage();
+  await exclusive("arbi-mail-sync", async () => {
+    syncing = true;
+    notifyOfflineMailChange("status");
+    try {
+      await syncMailbox(liveTransport(arbi), latest(), { ...options, latest });
+    } catch (error) {
+      logger.error("[offline-mail] sync failed", error);
+    } finally {
+      syncing = false;
+      notifyOfflineMailChange("status");
+    }
+  });
+}
+export {
+  OUTBOX_FOLDER,
+  flushOutbox,
+  isMailSyncRunning,
+  sessionUser,
+  syncOfflineMailbox,
+  uploadOfflineDrafts
+};
+//# sourceMappingURL=live.js.map

package/dist/mail/offline/live.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mail/offline/live.ts"],
+  "sourcesContent": ["/**\n * The offline mailbox's connection to the real API (the session's `arbi.mail`), and the runners\n * that the app-wide runtime (`useOfflineMailRuntime`) and the mailbox call: flush the Outbox, apply\n * the changes made offline, upload offline drafts, sync.\n *\n * Each runner holds a Web Lock, so with several tabs open exactly one does the work at a time (the\n * send endpoints are idempotent anyway; the lock just avoids duplicate traffic).\n */\n\nimport { sendMailFile } from '../filing'\nimport { primeOnArbi } from '../../queued-writes'\nimport { onlineManager, 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 { accountPath, mailJson } from '../client'\nimport { mailQueryKeys } from '../hooks'\nimport type { MailAccount, MailCompose, MailFolder, MailMessage, MailPolicy } from '../types'\nimport { syncLocalDrafts } from './drafts'\nimport { applyMailChangesOnce, type MailChangeSender } from './changes'\nimport { flushOutboxOnce, listOutbox, purgeSentOutbox, type OutboxSender } from './outbox'\nimport { getOfflineMailSettings, notifyOfflineMailChange } from './settings'\nimport { requestPersistentStorage } from '../../documents/offline-documents'\nimport { syncMailbox, type MailTransport } from './sync'\n\n/** What a runner works with: the signed-in session's `Arbi` and the query cache it refreshes. */\nexport interface OfflineMailContext {\n  arbi: Arbi\n  queryClient: QueryClient\n  /** Show the Outbox (\"Open Outbox\" on a notice that a message could not be sent). */\n  openOutbox?: () => void\n}\n\n/** The folder role of the device Outbox. */\nexport const OUTBOX_FOLDER = 'outbox'\n\n/**\n * The user the session is signed in as (the offline settings are theirs): the loaded profile's,\n * as `useOfflineMailSettings` reads it. Until it is loaded (a restored tab) there is none, so the\n * defaults apply and nothing is cached yet.\n */\nexport function sessionUser(arbi: Arbi): string | null {\n  return arbi.session?.getState().user?.external_id ?? null\n}\n\n/** The session holds a server session key: the keys a background mail request needs. */\nfunction hasLiveSession(arbi: Arbi): boolean {\n  return !!arbi.session?.getState().serverSessionKey\n}\n\n/** Whether this tab has what a background mail request needs: a connection and an unlocked session. */\nfunction canReachMail(arbi: Arbi): boolean {\n  return onlineManager.isOnline() && hasLiveSession(arbi)\n}\n\nconst unlocked = { nativeUnlocked: true }\n\nfunction mailCall<T>(arbi: Arbi, path: string, init: RequestInit = {}): Promise<T> {\n  return mailJson<T>((p, i) => arbi.mail.fetch(p, i, unlocked), path, init)\n}\n\nfunction liveTransport(arbi: Arbi): MailTransport {\n  const unlock = async (account: MailAccount) => {\n    if (!hasLiveSession(arbi))\n      throw Object.assign(new Error('Sign in to unlock your mailbox'), { status: 401 })\n    await arbi.mail.unlockAccount(account)\n  }\n  return {\n    policy: () => mailCall<MailPolicy>(arbi, '/policy'),\n    accounts: () => mailCall<MailAccount[]>(arbi, '/accounts'),\n    unlock,\n    folders: (account) => mailCall<MailFolder[]>(arbi, `${accountPath(account.id)}/folders`),\n    messages: (account, folderId, cursor) =>\n      mailCall(\n        arbi,\n        `${accountPath(account.id)}/messages?${new URLSearchParams({\n          folder_id: folderId,\n          q: '',\n          limit: '100',\n          ...(cursor ? { cursor } : {}),\n        })}`\n      ),\n    message: async (account, messageId) => {\n      const path = `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}`\n      try {\n        return await mailCall<MailMessage>(arbi, path)\n      } catch (error) {\n        // Mail that arrived after this pass unlocked the inbox has a key the session doesn't hold yet.\n        if ((error as { status?: number }).status !== 401 || account.provider !== 'native')\n          throw error\n        if (hasLiveSession(arbi)) await arbi.mail.unlockNative()\n        return mailCall<MailMessage>(arbi, path)\n      }\n    },\n    attachment: async (account, messageId, attachmentId) => {\n      const response = await arbi.mail.fetch(\n        `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`,\n        {},\n        unlocked\n      )\n      return new Uint8Array(await response.arrayBuffer())\n    },\n  }\n}\n\nfunction liveSender(arbi: Arbi): OutboxSender {\n  const transport = liveTransport(arbi)\n  return {\n    prepareSecure: async (item) => {\n      if (item.account.provider !== 'native')\n        throw new Error('Choose your native inbox to send securely')\n      return arbi.secureMail.prepare(item.compose, item.account, item.requestId)\n    },\n    unlock: async (account) => {\n      // The native send path needs no session keys; connected accounts need this session's tokens.\n      if (account.provider !== 'native') await transport.unlock(account)\n    },\n    send: (item) =>\n      item.secure\n        ? mailJson<{ id?: string }>((p, i) => arbi.mail.fetch(p, i), '/secure/send', {\n            method: 'POST',\n            body: JSON.stringify(item.securePayload),\n          })\n        : mailJson<{ id?: string }>(\n            (p, i) => arbi.mail.fetch(p, i),\n            `${accountPath(item.account.id)}/send`,\n            {\n              method: 'POST',\n              body: JSON.stringify({ ...item.compose, request_id: item.requestId }),\n            }\n          ),\n  }\n}\n\nfunction liveChangeSender(arbi: Arbi): MailChangeSender {\n  return {\n    unlock: (account) => liveTransport(arbi).unlock(account),\n    apply: async ({ account, messageId, change }) => {\n      if (change.kind === 'file') {\n        const { kind: _, ...request } = change\n        await sendMailFile(\n          (p, i) => arbi.mail.fetch(p, i),\n          primeOnArbi(arbi),\n          account,\n          messageId,\n          request\n        )\n        return\n      }\n      await mailJson(\n        (p, i) => arbi.mail.fetch(p, i),\n        `${accountPath(account.id)}/messages/${encodeURIComponent(messageId)}`,\n        change.kind === 'delete'\n          ? { method: 'DELETE' }\n          : { method: 'PATCH', body: JSON.stringify(change.update) }\n      )\n    },\n  }\n}\n\nconst localLocks = new Set<string>()\n\n/** Run `fn` unless another tab (or this one) already is; returns whether it ran. */\nasync function exclusive(name: string, fn: () => Promise<void>): Promise<boolean> {\n  if (typeof navigator !== 'undefined' && navigator.locks?.request) {\n    return navigator.locks.request(name, { ifAvailable: true }, async (lock) => {\n      if (!lock) return false\n      await fn()\n      return true\n    })\n  }\n  if (localLocks.has(name)) return false\n  localLocks.add(name)\n  try {\n    await fn()\n    return true\n  } finally {\n    localLocks.delete(name)\n  }\n}\n\nlet retryTimer: ReturnType<typeof setTimeout> | null = null\n\n/** One Outbox pass: send what waits, in order, and tell the user how it went. */\nasync function sendOutbox({ arbi, queryClient, openOutbox }: OfflineMailContext): Promise<void> {\n  const result = await flushOutboxOnce(liveSender(arbi), () => onlineManager.isOnline())\n  if (result.sent > 0) void queryClient.invalidateQueries({ queryKey: mailQueryKeys.all() })\n  const remaining = (await listOutbox()).filter((i) => i.status !== 'sent')\n  if (result.failed > 0) {\n    notify.error(\n      result.failed === 1\n        ? \"A message in your Outbox couldn't be sent\"\n        : `${result.failed} messages in your Outbox couldn't be sent`,\n      {\n        description: 'Open the Outbox to see why, then retry, edit or delete it.',\n        ...(openOutbox && { action: { label: 'Open Outbox', onClick: openOutbox } }),\n      }\n    )\n  } else if (result.sent > 0 && remaining.length === 0) {\n    notify.success(\n      result.sent === 1 ? 'Your Outbox message was sent' : `${result.sent} Outbox messages sent`\n    )\n  }\n  // Sent rows stay visible briefly as \"Sent\", then leave the Outbox.\n  setTimeout(() => void purgeSentOutbox(30_000), 31_000)\n}\n\n/** One pass over the changes made offline: apply them, and say which could not be applied. */\nasync function applyChanges({ arbi, queryClient }: OfflineMailContext): Promise<void> {\n  const result = await applyMailChangesOnce(liveChangeSender(arbi), () => onlineManager.isOnline())\n  if (result.applied + result.gone + result.refused.length > 0)\n    void queryClient.invalidateQueries({ queryKey: mailQueryKeys.all() })\n  if (result.gone > 0)\n    notify.info(\n      result.gone === 1\n        ? 'A message you changed offline was already gone from the server'\n        : `${result.gone} messages you changed offline were already gone from the server`\n    )\n  if (result.refused.length > 0)\n    notify.error(\n      result.refused.length === 1\n        ? \"A change you made offline couldn't be applied\"\n        : `${result.refused.length} changes you made offline couldn't be applied`,\n      { description: result.refused[0].error }\n    )\n}\n\n/**\n * Send what waits on this device: the Outbox first, then the changes made offline (read, moved,\n * trashed, deleted), under one lock so neither overtakes the other, and nothing goes out twice\n * from two tabs. When another tab holds the lock, try again shortly: it may have missed something\n * queued here just now.\n */\nexport async function flushOutbox(context: OfflineMailContext): Promise<void> {\n  if (!canReachMail(context.arbi)) return\n  const ran = await exclusive('arbi-mail-outbox', async () => {\n    await sendOutbox(context)\n    await applyChanges(context)\n  })\n  if (!ran) {\n    if (retryTimer) clearTimeout(retryTimer)\n    retryTimer = setTimeout(() => void flushOutbox(context), 3_000)\n  }\n}\n\n/** Upload the drafts written offline to the account's server Drafts. */\nexport async function uploadOfflineDrafts({\n  arbi,\n  queryClient,\n}: OfflineMailContext): Promise<void> {\n  if (!canReachMail(arbi)) return\n  await exclusive('arbi-mail-drafts', async () => {\n    const uploaded = await syncLocalDrafts(({ accountId, compose }) =>\n      mailJson<{ id: string }>(\n        (p, i) => arbi.mail.fetch(p, i),\n        `${accountPath(accountId)}/drafts`,\n        {\n          method: 'POST',\n          body: JSON.stringify(compose satisfies MailCompose),\n        }\n      )\n    )\n    if (uploaded > 0) {\n      void queryClient.invalidateQueries({ queryKey: mailQueryKeys.allMessages() })\n      notify.success(\n        uploaded === 1\n          ? 'Your offline draft was saved to Drafts'\n          : `${uploaded} offline drafts were saved to Drafts`\n      )\n    }\n  })\n}\n\nlet syncing = false\nexport function isMailSyncRunning(): boolean {\n  return syncing\n}\n\n/** One sync pass of the offline mailbox, when the user turned it on for this device. */\nexport async function syncOfflineMailbox(\n  { arbi }: Pick<OfflineMailContext, 'arbi'>,\n  options: { full?: boolean } = {}\n): Promise<void> {\n  const latest = () => getOfflineMailSettings(sessionUser(arbi))\n  const settings = latest()\n  if (!settings.enabled || !canReachMail(arbi)) return\n  // Keeping mail (the default too, not only when it is switched on): ask the browser not to evict it.\n  void requestPersistentStorage()\n  await exclusive('arbi-mail-sync', async () => {\n    syncing = true\n    notifyOfflineMailChange('status')\n    try {\n      await syncMailbox(liveTransport(arbi), latest(), { ...options, latest })\n    } catch (error) {\n      logger.error('[offline-mail] sync failed', error)\n    } finally {\n      syncing = false\n      notifyOfflineMailChange('status')\n    }\n  })\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mail/offline/mailbox.js

@@ -0,0 +1,191 @@
+import { blind, openBytes, openJson, sealBytes, sealJson } from "./crypto.js";
+import {
+  deleteRecords,
+  getRecord,
+  hasRecord,
+  putRecord,
+  recordsInBucket,
+  touchRecord
+} from "./store.js";
+const keyOf = {
+  accounts: () => blind("accounts"),
+  policy: () => blind("policy"),
+  folders: (accountId) => blind("folders", accountId),
+  header: (accountId, folderId, messageId) => blind("header", accountId, folderId, messageId),
+  body: (accountId, messageId) => blind("body", accountId, messageId),
+  attachment: (accountId, messageId, attachmentId) => blind("attachment", accountId, messageId, attachmentId)
+};
+const bucketOf = {
+  global: () => blind("bucket", "global"),
+  folder: (accountId, folderId) => blind("bucket", "folder", accountId, folderId),
+  account: (accountId) => blind("bucket", "account", accountId)
+};
+async function put(kind, key, bucket, data, sortAt = Date.now()) {
+  const now = Date.now();
+  await putRecord({ key, kind, bucket, sortAt, size: data.byteLength, lastAccess: now, data });
+}
+async function readJson(record) {
+  if (!record) return void 0;
+  try {
+    return await openJson(record.data);
+  } catch {
+    return void 0;
+  }
+}
+const receivedAt = (m) => m.received_at ? Date.parse(m.received_at) || 0 : 0;
+async function saveAccounts(accounts) {
+  await put("accounts", await keyOf.accounts(), await bucketOf.global(), await sealJson(accounts));
+}
+async function loadAccounts() {
+  return readJson(await getRecord(await keyOf.accounts()));
+}
+async function savePolicy(policy) {
+  await put("policy", await keyOf.policy(), await bucketOf.global(), await sealJson(policy));
+}
+async function loadPolicy() {
+  return readJson(await getRecord(await keyOf.policy()));
+}
+async function saveFolders(accountId, folders) {
+  await put(
+    "folders",
+    await keyOf.folders(accountId),
+    await bucketOf.account(accountId),
+    await sealJson(folders)
+  );
+}
+async function loadFolders(accountId) {
+  return readJson(await getRecord(await keyOf.folders(accountId)));
+}
+function toHeader(message) {
+  return {
+    ...message,
+    text: "",
+    html: void 0,
+    delivery: void 0,
+    attachments: message.attachments.map((a) => ({ ...a, content_base64: null }))
+  };
+}
+async function saveHeader(accountId, folderId, message) {
+  await put(
+    "header",
+    await keyOf.header(accountId, folderId, message.id),
+    await bucketOf.folder(accountId, folderId),
+    await sealJson(toHeader(message)),
+    receivedAt(message)
+  );
+}
+async function loadHeaders(accountId, folderId) {
+  const records = await recordsInBucket(await bucketOf.folder(accountId, folderId));
+  const out = [];
+  for (const record of records) {
+    if (record.kind !== "header") continue;
+    const message = await readJson(record);
+    if (message) out.push({ key: record.key, sortAt: record.sortAt, message });
+  }
+  return out.sort((a, b) => b.sortAt - a.sortAt);
+}
+async function hasFolder(accountId) {
+  return hasRecord(await keyOf.folders(accountId));
+}
+async function saveBody(accountId, message) {
+  const stripped = {
+    ...message,
+    attachments: message.attachments.map((a) => ({ ...a, content_base64: null }))
+  };
+  await put(
+    "body",
+    await keyOf.body(accountId, message.id),
+    await bucketOf.account(accountId),
+    await sealJson(stripped),
+    receivedAt(message)
+  );
+}
+async function hasBody(accountId, messageId) {
+  return hasRecord(await keyOf.body(accountId, messageId));
+}
+async function loadBody(accountId, messageId) {
+  return readJson(await getRecord(await keyOf.body(accountId, messageId)));
+}
+async function saveAttachment(accountId, messageId, attachmentId, bytes, sortAt) {
+  await put(
+    "attachment",
+    await keyOf.attachment(accountId, messageId, attachmentId),
+    await bucketOf.account(accountId),
+    await sealBytes(bytes),
+    sortAt || void 0
+  );
+}
+async function hasAttachment(accountId, messageId, attachmentId) {
+  return hasRecord(await keyOf.attachment(accountId, messageId, attachmentId));
+}
+async function loadAttachment(accountId, messageId, attachmentId) {
+  const key = await keyOf.attachment(accountId, messageId, attachmentId);
+  const record = await getRecord(key);
+  if (!record) return void 0;
+  try {
+    const bytes = await openBytes(record.data);
+    void touchRecord(key);
+    return bytes;
+  } catch {
+    return void 0;
+  }
+}
+async function removeKeys(keys) {
+  await deleteRecords(keys);
+}
+function bodyText(body) {
+  const html = body.text ? "" : (body.html ?? "").replace(/<[^>]*>/g, " ");
+  return `${body.text} ${html} ${body.attachments.map((a) => a.name).join(" ")}`;
+}
+const folded = (value) => value.toLocaleLowerCase().normalize("NFKD");
+async function searchFolder(accountId, folderId, query) {
+  const words = folded(query).split(/\s+/).filter(Boolean);
+  const headers = await loadHeaders(accountId, folderId);
+  if (words.length === 0) return headers.map((h) => h.message);
+  const out = [];
+  for (const { message } of headers) {
+    const people = [...message.sender, ...message.to, ...message.cc].map((p) => `${p.name ?? ""} ${p.email}`).join(" ");
+    let haystack = folded(`${message.subject} ${people} ${message.preview}`);
+    if (!words.every((w) => haystack.includes(w))) {
+      const body = await loadBody(accountId, message.id);
+      if (body) haystack += " " + folded(bodyText(body));
+    }
+    if (words.every((w) => haystack.includes(w))) out.push(message);
+  }
+  return out;
+}
+const isVirtualFolder = (folder) => folder?.role === "flagged";
+async function loadAccountMessages(accountId, include, query = "") {
+  const seen = /* @__PURE__ */ new Map();
+  for (const folder of await loadFolders(accountId) ?? []) {
+    if (isVirtualFolder(folder) || !include(folder)) continue;
+    for (const message of await searchFolder(accountId, folder.id, query))
+      if (!seen.has(message.id)) seen.set(message.id, message);
+  }
+  return [...seen.values()].sort((a, b) => receivedAt(b) - receivedAt(a));
+}
+export {
+  bucketOf,
+  hasAttachment,
+  hasBody,
+  hasFolder,
+  isVirtualFolder,
+  keyOf,
+  loadAccountMessages,
+  loadAccounts,
+  loadAttachment,
+  loadBody,
+  loadFolders,
+  loadHeaders,
+  loadPolicy,
+  removeKeys,
+  saveAccounts,
+  saveAttachment,
+  saveBody,
+  saveFolders,
+  saveHeader,
+  savePolicy,
+  searchFolder,
+  toHeader
+};
+//# sourceMappingURL=mailbox.js.map