@rapidmx/web-client 0.21.0 → 0.23.0

package/dist/apps/shared/mail/decryptedMessages.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What this device has recovered of encrypted messages by decrypting them: the real subject (the server only ever holds RFC 9788's `[...]`
+ * placeholder) and a short preview. Shared by every view that draws a message - the message list, the conversation list and the reading pane -
+ * so a message decrypted in one shows its subject in all of them. Held in memory only, keyed by message uid, and dropped for a mailbox the moment
+ * its keys are locked, exactly like the decrypted content it came from.
+ */
+export interface DecryptedMessage {
+    mailboxUid: string;
+    subject?: string;
+    preview?: string;
+}
+/** Plain text of decrypted HTML for a one-line preview. Only ever feeds text display, never markup. */
+export declare function previewOf(html: string): string;
+/** Remembers what was recovered of one message. Ignored when there is nothing new to show. */
+export declare function rememberDecrypted(uid: string, mailboxUid: string, found: {
+    subject?: string;
+    preview?: string;
+}): void;
+/** Every message decrypted so far, by uid; a new object whenever any changes. */
+export declare function useDecryptedMessages(): Record<string, DecryptedMessage>;
+/** A number that changes whenever a mailbox is unlocked - a dependency for effects that decrypt what they can. */
+export declare function useUnlockEpoch(): number;
+/**
+ * Decrypts one message to recover its subject and preview, when its mailbox's keys are unlocked and it isn't already known. Best effort: a
+ * message that can't be fetched or opened is simply left as it was. Never prompts.
+ */
+export declare function decryptForDisplay(uid: string, mailboxUid: string): Promise<void>;

package/dist/apps/shared/mail/decryptedMessages.js

@@ -0,0 +1,97 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { useSyncExternalStore } from "react";
+import { getUnlockedKeys, subscribeKeySession } from "../../../lib/crypto/keySession.js";
+import { getMessageRawContent } from "../../../lib/mail/mailApi.js";
+const PREVIEW_MAX_LENGTH = 160;
+let entries = {};
+/** Bumped whenever a mailbox's keys are unlocked, so a view can retry decrypting what it couldn't before. */
+let unlockEpoch = 0;
+const listeners = new Set();
+const inFlight = new Set();
+function emit() {
+    for (const listener of [...listeners]) {
+        listener();
+    }
+}
+subscribeKeySession(({ mailboxUid, state }) => {
+    if (state === "locked") {
+        const kept = Object.fromEntries(Object.entries(entries).filter(([, entry]) => entry.mailboxUid !== mailboxUid));
+        if (Object.keys(kept).length !== Object.keys(entries).length) {
+            entries = kept;
+        }
+    }
+    else {
+        unlockEpoch++;
+    }
+    emit();
+});
+function subscribe(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+/** Plain text of decrypted HTML for a one-line preview. Only ever feeds text display, never markup. */
+export function previewOf(html) {
+    return html
+        .replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, " ")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/gi, " ")
+        .replace(/&amp;/gi, "&")
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">")
+        .replace(/&quot;/gi, '"')
+        .replace(/&#0*39;/gi, "'")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, PREVIEW_MAX_LENGTH);
+}
+/** Remembers what was recovered of one message. Ignored when there is nothing new to show. */
+export function rememberDecrypted(uid, mailboxUid, found) {
+    if (!found.subject && !found.preview) {
+        return;
+    }
+    const current = entries[uid];
+    if (current && current.subject === found.subject && current.preview === found.preview) {
+        return;
+    }
+    entries = { ...entries, [uid]: { mailboxUid, subject: found.subject, preview: found.preview } };
+    emit();
+}
+/** Every message decrypted so far, by uid; a new object whenever any changes. */
+export function useDecryptedMessages() {
+    return useSyncExternalStore(subscribe, () => entries);
+}
+/** A number that changes whenever a mailbox is unlocked - a dependency for effects that decrypt what they can. */
+export function useUnlockEpoch() {
+    return useSyncExternalStore(subscribe, () => unlockEpoch);
+}
+/**
+ * Decrypts one message to recover its subject and preview, when its mailbox's keys are unlocked and it isn't already known. Best effort: a
+ * message that can't be fetched or opened is simply left as it was. Never prompts.
+ */
+export async function decryptForDisplay(uid, mailboxUid) {
+    const unlocked = getUnlockedKeys(mailboxUid);
+    if (!unlocked || entries[uid] || inFlight.has(uid)) {
+        return;
+    }
+    inFlight.add(uid);
+    try {
+        const rawMime = await getMessageRawContent(uid);
+        const { evaluateMessageSecurity } = await import("../../../lib/crypto/messageSecurity.js");
+        const security = await evaluateMessageSecurity(rawMime, unlocked);
+        // A lock while this ran: the result must not go back on screen.
+        if (getUnlockedKeys(mailboxUid) === unlocked) {
+            rememberDecrypted(uid, mailboxUid, { subject: security.subject, preview: security.html ? previewOf(security.html) : security.text?.slice(0, PREVIEW_MAX_LENGTH) });
+        }
+    }
+    catch {
+        // Left as the placeholder.
+    }
+    finally {
+        inFlight.delete(uid);
+    }
+}

package/dist/apps/shared/mail/findWellKnownFolderUid.d.ts

@@ -1,5 +1,7 @@
-import { FolderType } from "@rapidmx/react-shared/mail/mailApi.js";
+import { FolderType } from "../../../lib/mail/mailApi.js";
+import { ApiClient } from "../../../lib/util/api.js";
 /** The uid of a mailbox's well-known folder of `type` (e.g. its Contacts or Tasks folder), for creating an
  * item in a mailbox other than the one an app currently has loaded. Resolves `undefined` if the mailbox has
- * no such folder; rejects if the folder list can't be fetched. */
-export declare function findWellKnownFolderUid(mailboxUid: string, type: FolderType): Promise<string | undefined>;
+ * no such folder; rejects if the folder list can't be fetched. `client`, when given, is threaded through to
+ * `listFolders()` (see `useApiClient()`'s own doc comment) - omitted, this behaves exactly as before. */
+export declare function findWellKnownFolderUid(mailboxUid: string, type: FolderType, client?: ApiClient): Promise<string | undefined>;

package/dist/apps/shared/mail/findWellKnownFolderUid.js

@@ -2,11 +2,12 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { listFolders } from "@rapidmx/react-shared/mail/mailApi.js";
+import { listFolders } from "../../../lib/mail/mailApi.js";
 /** The uid of a mailbox's well-known folder of `type` (e.g. its Contacts or Tasks folder), for creating an
  * item in a mailbox other than the one an app currently has loaded. Resolves `undefined` if the mailbox has
- * no such folder; rejects if the folder list can't be fetched. */
-export async function findWellKnownFolderUid(mailboxUid, type) {
-    const folders = await listFolders(mailboxUid);
+ * no such folder; rejects if the folder list can't be fetched. `client`, when given, is threaded through to
+ * `listFolders()` (see `useApiClient()`'s own doc comment) - omitted, this behaves exactly as before. */
+export async function findWellKnownFolderUid(mailboxUid, type, client) {
+    const folders = await listFolders(mailboxUid, client);
     return folders.find((folder) => folder.type === type)?.uid;
 }

package/dist/apps/shared/mail/folderCounts.d.ts

@@ -1,4 +1,4 @@
-import { Folder, FolderType, Mailbox, Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Folder, FolderType, Mailbox, Message } from "../../../lib/mail/mailApi.js";
 /**
  * The folder badges' numbers, kept right without a reload.
  *

package/dist/apps/shared/mail/folderCounts.js

@@ -3,7 +3,8 @@
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
 import { useCallback, useEffect, useRef, useState } from "react";
-import { listFolders } from "@rapidmx/react-shared/mail/mailApi.js";
+import { listFolders } from "../../../lib/mail/mailApi.js";
+import { useApiClient } from "../../../lib/util/apiClientContext.js";
 /** What one message change - a new message (`previous` absent), a deletion (`next` absent), a read/unread flip, a move - does to the folders' counts. */
 export function countDeltas(previous, next) {
     const byFolder = new Map();
@@ -75,9 +76,10 @@ const SEEN_LIMIT = 500;
  * each was loaded with); `mailboxes` is whose folders to read back. The overlay starts again whenever `mailboxes` does.
  */
 export function useFolderCounts(mailboxes, folders, onFoldersListed) {
+    const client = useApiClient();
     const [counts, setCounts] = useState({});
-    const latestRef = useRef({ mailboxes, folders, onFoldersListed });
-    latestRef.current = { mailboxes, folders, onFoldersListed };
+    const latestRef = useRef({ mailboxes, folders, onFoldersListed, client });
+    latestRef.current = { mailboxes, folders, onFoldersListed, client };
     // Bumped by every change of the overlay this page makes, so a read that started before one can tell it is out of date.
     const changesRef = useRef(0);
     const inFlightRef = useRef(0);
@@ -124,7 +126,7 @@ export function useFolderCounts(mailboxes, folders, onFoldersListed) {
         timerRef.current = undefined;
         const run = ++runRef.current;
         const startedAt = changesRef.current;
-        const results = await Promise.all(latestRef.current.mailboxes.map((mailbox) => listFolders(mailbox.uid).catch(() => undefined)));
+        const results = await Promise.all(latestRef.current.mailboxes.map((mailbox) => listFolders(mailbox.uid, latestRef.current.client).catch(() => undefined)));
         if (stoppedRef.current || run !== runRef.current) {
             return;
         }

package/dist/apps/shared/mail/folderOfType.d.ts

@@ -1,4 +1,5 @@
-import { Folder } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Folder } from "../../../lib/mail/mailApi.js";
+import type { ApiClient } from "../../../lib/util/api.js";
 /** Forgets every remembered folder - for the tests. */
 export declare function clearResolvedFolders(): void;
 /**
@@ -10,4 +11,4 @@ export declare function clearResolvedFolders(): void;
  * lacks is asked for - the tree may only be out of date - and used, never created twice; only a server that really has none is asked to
  * make it. `onFound` is told about a folder the tree did not have, so the sidebar picks it up.
  */
-export declare function resolveFolderOfType(mailboxUid: string, type: Folder["type"], name: string, known?: Folder[], onFound?: (folder: Folder) => void): Promise<string>;
+export declare function resolveFolderOfType(mailboxUid: string, type: Folder["type"], name: string, known?: Folder[], onFound?: (folder: Folder) => void, client?: ApiClient): Promise<string>;

package/dist/apps/shared/mail/folderOfType.js

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { createFolder, listFolders } from "@rapidmx/react-shared/mail/mailApi.js";
+import { createFolder, listFolders } from "../../../lib/mail/mailApi.js";
 /** The folders this page load has had to look up or make for a mailbox, so a second Report junk does not ask again. */
 const resolved = new Map();
 /** Forgets every remembered folder - for the tests. */
@@ -18,7 +18,7 @@ export function clearResolvedFolders() {
  * lacks is asked for - the tree may only be out of date - and used, never created twice; only a server that really has none is asked to
  * make it. `onFound` is told about a folder the tree did not have, so the sidebar picks it up.
  */
-export async function resolveFolderOfType(mailboxUid, type, name, known = [], onFound) {
+export async function resolveFolderOfType(mailboxUid, type, name, known = [], onFound, client) {
     const inTree = known.find((folder) => folder.mailboxUid === mailboxUid && folder.type === type);
     if (inTree) {
         return inTree.uid;
@@ -28,13 +28,13 @@ export async function resolveFolderOfType(mailboxUid, type, name, known = [], on
     if (remembered) {
         return remembered;
     }
-    const listed = (await listFolders(mailboxUid)).find((folder) => folder.type === type);
+    const listed = (await listFolders(mailboxUid, client)).find((folder) => folder.type === type);
     if (listed) {
         onFound?.(listed);
         resolved.set(key, listed.uid);
         return listed.uid;
     }
-    const created = await createFolder({ mailboxUid, name, type });
+    const created = await createFolder({ mailboxUid, name, type }, client);
     resolved.set(key, created.uid);
     return created.uid;
 }

package/dist/apps/shared/mail/folderTree.d.ts

@@ -1,4 +1,4 @@
-import type { Folder } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Folder } from "../../../lib/mail/mailApi.js";
 import type { MailboxFolders } from "../components/mail/layout/MailShell.js";
 /**
  * The sidebar's order of a mailbox's well-known folders; anything else (`user`) follows, alphabetically. Also the order push channels are asked

package/dist/apps/shared/mail/listSnapshots.d.ts

@@ -1,5 +1,5 @@
-import type { ConversationSummary } from "@rapidmx/react-shared/mail/conversationsApi.js";
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { ConversationSummary } from "../../../lib/mail/conversationsApi.js";
+import type { Message } from "../../../lib/mail/mailApi.js";
 /**
  * A short-lived, in-memory copy of a folder's listing, so that switching to a folder that was shown a moment ago (or coming back
  * to Mail from another app) shows its rows on the very frame of the click and revalidates behind them (stale-while-revalidate),

package/dist/apps/shared/mail/messageReadState.d.ts

@@ -1,4 +1,5 @@
-import { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import { Message } from "../../../lib/mail/mailApi.js";
+import type { ApiClient } from "../../../lib/util/api.js";
 import type { CountTracker } from "./folderCounts.js";
 /**
  * The one way a message's read state changes in the webmail, so that every place that shows it moves together: the row in
@@ -23,10 +24,10 @@ export interface ReadStateSink {
  * doing (it already was that way) or the server refused - in which case everything has already been put back as it was.
  * Never rejects: like the old mark-as-read, a failure must not get in the way of reading the message.
  */
-export declare function setReadState(message: Message, read: boolean, sink: ReadStateSink): Promise<Message | undefined>;
+export declare function setReadState(message: Message, read: boolean, sink: ReadStateSink, client?: ApiClient): Promise<Message | undefined>;
 /**
  * The same for a whole selection, in one request. Resolves the updated messages, in request order. Unlike `setReadState()`
  * it rejects when the server refuses (after putting everything back), because a bulk update is not atomic - some of it may
  * have landed - and the caller's own handling reloads the list and says so (see `bulkUpdateMessages()`).
  */
-export declare function setReadStateMany(messages: Message[], read: boolean, sink: ReadStateSink): Promise<Message[]>;
+export declare function setReadStateMany(messages: Message[], read: boolean, sink: ReadStateSink, client?: ApiClient): Promise<Message[]>;

package/dist/apps/shared/mail/messageReadState.js

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { setMessageRead, setMessagesRead } from "@rapidmx/react-shared/mail/mailApi.js";
+import { setMessageRead, setMessagesRead } from "../../../lib/mail/mailApi.js";
 function withRead(message, read) {
     return { ...message, flags: { ...message.flags, read } };
 }
@@ -15,7 +15,7 @@ function needsChange(message, read) {
  * doing (it already was that way) or the server refused - in which case everything has already been put back as it was.
  * Never rejects: like the old mark-as-read, a failure must not get in the way of reading the message.
  */
-export async function setReadState(message, read, sink) {
+export async function setReadState(message, read, sink, client) {
     if (!needsChange(message, read)) {
         return undefined;
     }
@@ -23,7 +23,7 @@ export async function setReadState(message, read, sink) {
     sink.patch(optimistic, message);
     const tracker = sink.track(message, optimistic);
     try {
-        const updated = await setMessageRead(message, read);
+        const updated = await setMessageRead(message, read, client);
         sink.patch(updated);
         tracker.settle();
         return updated;
@@ -39,14 +39,14 @@ export async function setReadState(message, read, sink) {
  * it rejects when the server refuses (after putting everything back), because a bulk update is not atomic - some of it may
  * have landed - and the caller's own handling reloads the list and says so (see `bulkUpdateMessages()`).
  */
-export async function setReadStateMany(messages, read, sink) {
+export async function setReadStateMany(messages, read, sink, client) {
     const changes = messages.filter((message) => needsChange(message, read)).map((message) => ({ message, optimistic: withRead(message, read) }));
     const trackers = changes.map(({ message, optimistic }) => {
         sink.patch(optimistic, message);
         return sink.track(message, optimistic);
     });
     try {
-        const updated = await setMessagesRead(messages, read);
+        const updated = await setMessagesRead(messages, read, client);
         for (const message of updated) {
             sink.patch(message);
         }

package/dist/apps/shared/mail/newMailNotifications.d.ts

@@ -1,4 +1,4 @@
-import type { Folder, Mailbox, Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Folder, Mailbox, Message } from "../../../lib/mail/mailApi.js";
 /**
  * What decides whether a new message is announced, what the announcement says, and the setting behind it (per browser, in
  * `localStorage`): what the user told the "turn on desktop notifications" offer. Whether pop-ups are on at all is the

package/dist/apps/shared/mail/newMailNotifications.js

@@ -1,4 +1,4 @@
-import { formatMailAddress, splitMailAddress } from "@rapidmx/react-shared/mail/mailAddress.js";
+import { formatMailAddress, splitMailAddress } from "../../../lib/mail/mailAddress.js";
 /**
  * What decides whether a new message is announced, what the announcement says, and the setting behind it (per browser, in
  * `localStorage`): what the user told the "turn on desktop notifications" offer. Whether pop-ups are on at all is the

package/dist/apps/shared/mail/outbox/composeBridge.d.ts

@@ -1,5 +1,5 @@
-import type { Attachment, Message } from "@rapidmx/react-shared/mail/mailApi.js";
-import type { PublicKey } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import type { Attachment, Message } from "../../../../lib/mail/mailApi.js";
+import type { PublicKey } from "../../../../lib/crypto/keyvaultApi.js";
 /**
  * A compose window to re-open around a message that was already composed: a failed send's "Open draft". The message keeps its uid - the
  * server draft it was assembled into - and everything the sender had typed comes back exactly as it was, including what could not have

package/dist/apps/shared/mail/outbox/outboxState.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
+import type { Message } from "../../../../lib/mail/mailApi.js";
 /**
  * What a message in Outbox is doing, read from the fields the server keeps on it (`scheduledSend*`):
  *

package/dist/apps/shared/mail/outbox/outgoingReplies.d.ts

@@ -1,5 +1,5 @@
-import type { Message } from "@rapidmx/react-shared/mail/mailApi.js";
-import type { MailAddressLike } from "@rapidmx/react-shared/mail/mailAddress.js";
+import type { Message } from "../../../../lib/mail/mailApi.js";
+import type { MailAddressLike } from "../../../../lib/mail/mailAddress.js";
 import type { NotificationAction } from "../../notifications/store.js";
 import type { SendRequest } from "./sendJob.js";
 /**

package/dist/apps/shared/mail/outbox/sendDecision.d.ts

@@ -1,5 +1,5 @@
-import { RecipientEncryptionStatus } from "@rapidmx/react-shared/crypto/composeSecurity.js";
-import type { EncryptionPolicy } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import { RecipientEncryptionStatus } from "../../../../lib/crypto/composeSecurity.js";
+import type { EncryptionPolicy } from "../../../../lib/crypto/keyvaultApi.js";
 /** Signed/encrypted bodies are built client-side from the editor's HTML verbatim, so an inline image (an uploaded attachment previewed via
  * its content URL, or a `cid:` reference) would never be carried - only `assembleDraft()`'s server-side plaintext path rewrites those into
  * real MIME parts. */

package/dist/apps/shared/mail/outbox/sendDecision.js

@@ -2,7 +2,7 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-import { decideMessageEncryption } from "@rapidmx/react-shared/crypto/composeSecurity.js";
+import { decideMessageEncryption } from "../../../../lib/crypto/composeSecurity.js";
 import { evaluateEncryptionRequirement } from "../../components/mail/compose/encryptionRequirement.js";
 /** Signed/encrypted bodies are built client-side from the editor's HTML verbatim, so an inline image (an uploaded attachment previewed via
  * its content URL, or a `cid:` reference) would never be carried - only `assembleDraft()`'s server-side plaintext path rewrites those into

package/dist/apps/shared/mail/outbox/sendJob.d.ts

@@ -1,6 +1,7 @@
-import { Attachment, ComposeRecipientInput, DraftThreading, Mailbox, Message } from "@rapidmx/react-shared/mail/mailApi.js";
-import { RecipientEncryptionStatus } from "@rapidmx/react-shared/crypto/composeSecurity.js";
-import { EncryptionPolicy } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import { type ApiClient } from "../../../../lib/util/api.js";
+import { Attachment, ComposeRecipientInput, DraftThreading, Mailbox, Message } from "../../../../lib/mail/mailApi.js";
+import { RecipientEncryptionStatus } from "../../../../lib/crypto/composeSecurity.js";
+import { EncryptionPolicy } from "../../../../lib/crypto/keyvaultApi.js";
 import { SendDecisionInput } from "./sendDecision.js";
 import { OutboxCountTracker } from "./sendState.js";
 /** Everything the background send needs, captured when Send is clicked: the window it came from is gone by the time it runs. */
@@ -47,7 +48,7 @@ export declare function retainedRequest(draftUid: string): SendRequest | undefin
 export declare function forgetRetainedRequest(draftUid: string): void;
 /** The sender's signing/encryption key state right now, read from the tab's key session (they can lock mid-send). */
 export declare function readSendKeys(mailboxUid: string, signEnabled: boolean, mailbox: Mailbox | undefined): {
-    unlocked: import("@rapidmx/react-shared/crypto/keySession.js").UnlockedKeys | undefined;
+    unlocked: import("../../../../lib/crypto/keySession.js").UnlockedKeys | undefined;
     canSign: boolean;
     canEncryptSelf: boolean;
 };
@@ -66,7 +67,10 @@ export declare function notifySent(message?: string): void;
  * under way here. The outcome is shown as pop-ups and the Outbox indicator, never as a window that waits: a failure at any stage (assembling,
  * encrypting, the request) is a sticky "This message wasn't sent" with the reason, and Retry / Open draft; the server's own later outcome
  * (`send-succeeded`, `send-failed`, `send-retrying`) is `handleSendEvent()`'s.
+ *
+ * `client` is the explicit `ApiClient` (from `useApiClient()`) the compose window that built `request` was rendered under - `undefined` (the
+ * default) for every existing caller, which keeps using the default global cookie-based session exactly as before.
  */
-export declare function startSend(request: SendRequest): boolean;
+export declare function startSend(request: SendRequest, client?: ApiClient): boolean;
 /** Tries a failed send again - unless the server already has the message (an earlier request that seemed to fail did land), which it must not send twice. */
-export declare function retrySend(request: SendRequest): Promise<void>;
+export declare function retrySend(request: SendRequest, client?: ApiClient): Promise<void>;