@rapidmx/web-client 0.4.0 → 0.6.0

package/dist/apps/shared/components/mail/compose/ComposeContext.d.ts

@@ -0,0 +1,58 @@
+import React, { PropsWithChildren } from "react";
+export interface ComposeSession {
+    id: string;
+    /** The initial sending mailbox - absent means "the caller's own mailbox" (see `ComposeWindow`). */
+    mailboxUid?: string;
+    initialTo?: string;
+    initialCc?: string;
+    initialSubject?: string;
+    /** Pre-built HTML (already includes its own quote-attribution wrapper — see `composeQuoting.ts`)
+     * inserted below the resolved default signature. Absent for a fresh, non-reply/forward compose. */
+    initialQuotedHtml?: string;
+    /** Which of a signature's two "default" flags to resolve against — `"new"` (the default) uses
+     * `isDefaultForNewMessages`, `"reply_forward"` uses `isDefaultForReplyForward`. */
+    signatureContext: "new" | "reply_forward";
+    /** See `OpenComposeInput.suppressSigning`'s own doc comment. */
+    suppressSigning?: boolean;
+    minimized: boolean;
+}
+export interface OpenComposeInput {
+    /** The sending mailbox to start with. Omit for a fresh message (defaults to the caller's own mailbox);
+     * a reply/forward passes the original message's mailbox so a shared mailbox's mail replies from it.
+     * Either way the user can change it via the compose window's From field. */
+    mailboxUid?: string;
+    /** Prefills the To field — e.g. Contacts' "Email" toolbar action, or Reply/Reply All/Forward. */
+    to?: string;
+    /** Prefills the Cc field and reveals the Cc/Bcc row — Reply All only. */
+    cc?: string;
+    /** Prefills the Subject field — Reply/Reply All/Forward. */
+    subject?: string;
+    /** See `ComposeSession.initialQuotedHtml`'s own doc comment. */
+    quotedHtml?: string;
+    /** See `ComposeSession.signatureContext`'s own doc comment. Defaults to `"new"` — every existing
+     * caller (Contacts' "Email" action, the folder-sidebar "Compose" button) is a fresh compose. */
+    signatureContext?: "new" | "reply_forward";
+    /** `true` when the caller (`MessageDetailPane.tsx`'s Reply/Reply All) has already determined, via
+     * `composeSecurity.ts`'s `isLikelyMailingList()`, that the message being replied to came from a
+     * mailing list — a list that appends a footer after signing invalidates the signature (spec's own
+     * "Mailing lists" note), so the new compose window defaults its Sign toggle off rather than on.
+     * The user can still turn it back on manually; this only changes the *default*. */
+    suppressSigning?: boolean;
+}
+export interface ComposeContextValue {
+    /** Opens a new compose window, stacked alongside any already open (Gmail allows several at once). */
+    openCompose: (input: OpenComposeInput) => void;
+}
+/** Opens the floating Compose window from anywhere inside `AppShell` (any of the four webmail apps). */
+export declare function useCompose(): ComposeContextValue;
+/**
+ * Owns every currently-open Compose window and renders them stacked bottom-right, Gmail-style — see
+ * `ComposeWindow`'s own doc comment for why this replaced the old dedicated `/compose` page. Mounted
+ * once in `AppShell`, so every webmail app (Mail/Calendar/Contacts/Tasks) shares the same instance:
+ * opening Compose from Contacts' "Email" action, for instance, overlays the window on top of whatever
+ * app is currently showing, exactly like opening it from Mail's own sidebar button.
+ */
+export default function ComposeProvider({ children, userUid, trusted }: PropsWithChildren<{
+    userUid?: string;
+    trusted?: boolean;
+}>): React.JSX.Element;

package/dist/apps/shared/components/mail/compose/ComposeContext.js

@@ -18,7 +18,7 @@ export function useCompose() {
  * opening Compose from Contacts' "Email" action, for instance, overlays the window on top of whatever
  * app is currently showing, exactly like opening it from Mail's own sidebar button.
  */
-export default function ComposeProvider({ children, userUid }) {
+export default function ComposeProvider({ children, userUid, trusted }) {
     const [sessions, setSessions] = useState([]);
     const isMobile = useIsMobile();
     function openCompose({ mailboxUid, to, cc, subject, quotedHtml, signatureContext = "new", suppressSigning }) {
@@ -46,11 +46,14 @@ export default function ComposeProvider({ children, userUid }) {
     const value = useMemo(() => ({ openCompose }), []);
     // On mobile, a non-minimized `ComposeWindow` renders full-screen (see that component's own doc
     // comment) — Gmail-style stacking of several full-screen overlays at once makes no sense there, so
-    // at most one non-minimized session is ever rendered: the most recently opened one. Minimized
-    // sessions are small chips regardless of device, so every one of those still renders — an earlier
+    // at most one non-minimized session is ever shown: the most recently opened one. Minimized
+    // sessions are small chips regardless of device, so every one of those still shows — an earlier
     // session becomes visible again (as its own chip, or full-screen if it's the new most-recent
-    // non-minimized one) once whatever's currently "on top" is closed or minimized.
+    // non-minimized one) once whatever's currently "on top" is closed or minimized. The others stay
+    // mounted, just hidden: unmounting them would throw away everything typed into them.
     const lastNonMinimizedId = isMobile ? [...sessions].reverse().find((s) => !s.minimized)?.id : undefined;
-    const visibleSessions = isMobile ? sessions.filter((s) => s.minimized || s.id === lastNonMinimizedId) : sessions;
-    return (_jsxs(ComposeContext.Provider, { value: value, children: [children, visibleSessions.length > 0 && (_jsx("div", { className: "fixed bottom-0 right-6 flex items-end gap-3 z-50", children: visibleSessions.map((session) => (_jsx(ComposeWindow, { session: session, userUid: userUid, onClose: () => closeCompose(session.id), onToggleMinimize: () => toggleMinimize(session.id) }, session.id))) }))] }));
+    return (_jsxs(ComposeContext.Provider, { value: value, children: [children, sessions.length > 0 && (_jsx("div", { className: "fixed bottom-0 right-6 flex items-end gap-3 z-50", children: sessions.map((session) => {
+                    const hidden = isMobile && !session.minimized && session.id !== lastNonMinimizedId;
+                    return (_jsx("div", { hidden: hidden, className: hidden ? "hidden" : "contents", children: _jsx(ComposeWindow, { session: session, userUid: userUid, trusted: trusted, onClose: () => closeCompose(session.id), onToggleMinimize: () => toggleMinimize(session.id) }) }, session.id));
+                }) }))] }));
 }

package/dist/apps/shared/components/mail/compose/ComposeToolbar.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import type { Editor } from "@tiptap/react";
+export interface ComposeToolbarProps {
+    /** `null` before the editor has mounted client-side (see `RichTextEditor`'s `immediatelyRender: false`
+     * doc comment) — every button is disabled in that state rather than the toolbar rendering nothing, so
+     * its layout doesn't shift the instant the editor becomes ready. */
+    editor: Editor | null;
+    /** Uploads `file` as an attachment on the current draft and resolves to a URL the browser can
+     * preview it at while composing — see `BaseMailComposeRoute.rewriteInlineImageSources()`'s doc
+     * comment for why that's not the final URL the message actually ships with. Resolves to `null`
+     * (rather than rejecting) on failure — `ComposeWindow`'s own implementation is responsible for
+     * surfacing the error itself, so a failed upload here just quietly doesn't insert an image. */
+    onUploadImage: (file: File) => Promise<string | null>;
+}
+export default function ComposeToolbar({ editor, onUploadImage }: ComposeToolbarProps): React.JSX.Element;

package/dist/apps/shared/components/mail/compose/ComposeWindow.d.ts

@@ -0,0 +1,37 @@
+import React from "react";
+import type { ComposeSession } from "./ComposeContext.js";
+export interface ComposeWindowProps {
+    session: ComposeSession;
+    onClose: () => void;
+    onToggleMinimize: () => void;
+    /** The signed-in user - identifies their own ("primary") mailbox, the default From when the session
+     * doesn't name a mailbox. */
+    userUid?: string;
+    /** The caller holds a trusted (admin) role - every mailbox is writable, so no per-mailbox access checks. */
+    trusted?: boolean;
+    /** How long (ms) after the last edit the draft is autosaved. Defaults to `DEFAULT_AUTOSAVE_DELAY_MS`;
+     * only overridden by tests. */
+    autosaveDelayMs?: number;
+    /** Backoff (ms) between automatic retries of a failed mailbox/encryption-policy load, one entry per retry.
+     * Defaults to `DEFAULT_CRYPTO_RETRY_DELAYS_MS`; only overridden by tests. */
+    cryptoRetryDelaysMs?: number[];
+}
+/** Debounce between the last edit and the draft autosave. */
+export declare const DEFAULT_AUTOSAVE_DELAY_MS = 2000;
+/** Automatic retries of a failed mailbox/encryption-policy load; after the last one only "Retry" tries again. */
+export declare const DEFAULT_CRYPTO_RETRY_DELAYS_MS: number[];
+/**
+ * A floating, Gmail-style compose window — overlays whatever app is currently showing instead of
+ * navigating to a dedicated page (see `ComposeContext.tsx`'s doc comment for why: a full-page compose
+ * form meant losing your place in the inbox/calendar/contacts view behind it, and every navigation to
+ * `/compose` re-ran this whole app's full mailbox/folder resolution waterfall from scratch). Owns its
+ * own draft lifecycle end to end (unlike the old page, which read the Drafts folder from `MailShell`'s
+ * context — this window can be opened from apps that never mount `MailShell` at all, e.g. Contacts'
+ * "Email" action, so it resolves its own Drafts folder from just a `mailboxUid`).
+ *
+ * Below the `md` breakpoint, a non-minimized session instead renders as a full-screen sheet (there's no
+ * room for a floating window, and the click-drag resize handles below become meaningless full-screen) —
+ * see `ComposeContext.tsx`'s own doc comment for how that interacts with several sessions being open at
+ * once.
+ */
+export default function ComposeWindow({ session, onClose, onToggleMinimize, userUid, trusted, autosaveDelayMs, cryptoRetryDelaysMs, }: ComposeWindowProps): React.JSX.Element;