@remit/web-client 0.0.324 → 0.0.326

package/dist/src/components/mail/bulk-run-state.js

@@ -0,0 +1,64 @@
+const NOTHING_STARTED = {
+    matched: 0,
+    applied: 0,
+    failed: 0,
+    failedIds: [],
+};
+/**
+ * What the run screen says a bulk run did.
+ *
+ * Stopping is read before counting, because a stop is not a failure however
+ * little it reached (#113). Pressing Stop during the first batch — the only
+ * batch a selection of 100 or fewer has — leaves `done` at zero while the
+ * server has most likely applied all of them, and answering that with
+ * "Couldn't start deleting / Nothing has changed" is both alarming and wrong.
+ * Only a run that errored before anything landed has nothing to report but the
+ * failure.
+ */
+export const bulkRunReport = ({ matched, outcome, failureReason, progressDone, }) => {
+    // Nothing was sent, and nothing about sending it again resolves what was
+    // missing — so the screen carries why rather than the generic ending (#522).
+    if (failureReason !== undefined) {
+        return { ...NOTHING_STARTED, state: "commitFailed", failureReason };
+    }
+    if (!outcome) {
+        // A predicate matches more by the time the run re-pages it than the count
+        // saw, so what it has covered can overtake what it was offered against.
+        // The bar never reads more done than out of, and neither does this.
+        return {
+            state: "backApplyRunning",
+            matched: Math.max(matched, progressDone),
+            applied: progressDone,
+            failed: 0,
+            failedIds: [],
+        };
+    }
+    if (!outcome.cancelled && outcome.error === undefined) {
+        return {
+            state: "backApplyComplete",
+            matched: Math.max(matched, outcome.done),
+            applied: outcome.done,
+            failed: 0,
+            failedIds: [],
+        };
+    }
+    if (!outcome.cancelled && outcome.done === 0) {
+        return { ...NOTHING_STARTED, state: "commitFailed" };
+    }
+    // The run stopped part-way. Nothing here was rejected: a returned bulk call
+    // accepts every id in it, so the only failure this layer sees is a call that
+    // threw or was aborted, and everything after it was never sent. A bounded run
+    // hands back exactly those ids; a predicate run re-resolves its match on every
+    // pass and has no remainder to hand back, so what is left is the difference
+    // between the count and what the run covered.
+    const unreached = outcome.failedIds.length > 0
+        ? outcome.failedIds.length
+        : Math.max(matched - outcome.done, 1);
+    return {
+        state: "runStopped",
+        matched: Math.max(matched, outcome.done),
+        applied: outcome.done,
+        failed: unreached,
+        failedIds: outcome.failedIds,
+    };
+};

package/dist/src/components/mail/intelligence-story-calendar.d.ts

@@ -0,0 +1,7 @@
+import type { IntelligenceCalendarSurface } from "@remit/ui";
+/**
+ * The calendar half the shipping pane always carries, for a message that says
+ * nothing about time. Stories of the Sender half mount it too, so the tab strip
+ * they draw is the one the app draws.
+ */
+export declare const quietCalendar: IntelligenceCalendarSurface;

package/dist/src/components/mail/intelligence-story-calendar.js

@@ -0,0 +1,17 @@
+/**
+ * The calendar half the shipping pane always carries, for a message that says
+ * nothing about time. Stories of the Sender half mount it too, so the tab strip
+ * they draw is the one the app draws.
+ */
+export const quietCalendar = {
+    data: { suggestions: [], day: [], dayLabel: "" },
+    actions: {
+        onAddInvite: () => undefined,
+        onDeclineInvite: () => undefined,
+        onOfferOtherTimes: () => undefined,
+        onToggleSlot: () => undefined,
+        onAddSuggestion: () => undefined,
+        onDismissSuggestion: () => undefined,
+        onSelectEvent: () => undefined,
+    },
+};

package/dist/src/components/mail/message-body-error-banner-content.d.ts

@@ -0,0 +1,31 @@
+import { type BodyFetchReason } from "../../hooks/useMessageBodyContent";
+export interface BannerContent {
+    title: string;
+    detail: string;
+}
+/**
+ * Pure helpers for `MessageBodyErrorBanner`. Extracted so they can be
+ * unit-tested with the Node test runner without importing React /
+ * @aws-amplify/ui-react / lucide-react. The banner component composes these
+ * with the React surface.
+ *
+ * The variant copy lives here so a glance at one file shows every banner
+ * variant the SPA can render — issue #401 / postmortem #394.
+ */
+/**
+ * Map a `BodyFetchReason` to user-facing banner copy.
+ *
+ * - `auth` — Lambda@Edge denied the JWT (missing/invalid/expired) or the
+ *            tenant didn't match. The user needs to sign in again.
+ * - `body-missing` — CloudFront/S3 returned 403/404 without the edge reason
+ *            header. The OAC bucket policy only grants `s3:GetObject` so a
+ *            missing object surfaces as 403. Either an in-flight sync failure
+ *            left the message stuck, or the body part was never written.
+ * - `content-type-mismatch` / `spa-shell-leak` — defensive guards; the user
+ *            sees a safer "couldn't load" message and is asked to report it.
+ * - `generic` — anything else; surfaces the underlying error message so the
+ *            user has something to attach to a support ticket.
+ */
+export declare const contentForReason: (reason: BodyFetchReason, fallback: string) => BannerContent;
+export declare const extractReason: (error: unknown) => BodyFetchReason;
+export declare const extractFallbackDetail: (error: unknown) => string;

package/dist/src/components/mail/message-body-error-banner-content.js

@@ -0,0 +1,70 @@
+import { BodyFetchError, } from "../../hooks/useMessageBodyContent";
+/**
+ * Pure helpers for `MessageBodyErrorBanner`. Extracted so they can be
+ * unit-tested with the Node test runner without importing React /
+ * @aws-amplify/ui-react / lucide-react. The banner component composes these
+ * with the React surface.
+ *
+ * The variant copy lives here so a glance at one file shows every banner
+ * variant the SPA can render — issue #401 / postmortem #394.
+ */
+/**
+ * Map a `BodyFetchReason` to user-facing banner copy.
+ *
+ * - `auth` — Lambda@Edge denied the JWT (missing/invalid/expired) or the
+ *            tenant didn't match. The user needs to sign in again.
+ * - `body-missing` — CloudFront/S3 returned 403/404 without the edge reason
+ *            header. The OAC bucket policy only grants `s3:GetObject` so a
+ *            missing object surfaces as 403. Either an in-flight sync failure
+ *            left the message stuck, or the body part was never written.
+ * - `content-type-mismatch` / `spa-shell-leak` — defensive guards; the user
+ *            sees a safer "couldn't load" message and is asked to report it.
+ * - `generic` — anything else; surfaces the underlying error message so the
+ *            user has something to attach to a support ticket.
+ */
+export const contentForReason = (reason, fallback) => {
+    switch (reason) {
+        case "auth":
+            return {
+                title: "Your session expired",
+                detail: "Sign in again to reload the message body. Other parts of the app may also stop responding until you do.",
+            };
+        case "body-missing":
+            return {
+                title: "Message body is missing in storage",
+                detail: "A sync failure may have left this message without its body bytes. Contact support, or run the reconcile script to refetch from the upstream IMAP server.",
+            };
+        case "content-type-mismatch":
+            return {
+                title: "Couldn't load message body",
+                detail: "The server returned an unexpected content type for this part. The message body has not been rendered to keep you safe.",
+            };
+        case "spa-shell-leak":
+            return {
+                title: "Couldn't load message body",
+                detail: "The server returned the app shell instead of the message body. This is an infrastructure bug — please report it.",
+            };
+        case "not-ready":
+            return {
+                title: "Message body is still syncing",
+                detail: "This message's body hasn't finished downloading from the mail server yet. It should appear shortly — reopen the message to try again.",
+            };
+        default:
+            return {
+                title: "Couldn't load message body",
+                detail: fallback,
+            };
+    }
+};
+export const extractReason = (error) => {
+    if (error instanceof BodyFetchError)
+        return error.reason;
+    return "generic";
+};
+export const extractFallbackDetail = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    return "An unexpected error occurred while loading the message body.";
+};

package/dist/src/components/mail/organize-run-state.d.ts

@@ -0,0 +1,26 @@
+import type { RunState } from "@remit/ui";
+import type { OrganizeJobFailure } from "../../hooks/useOrganizeJob";
+/** What the run screen knows about a back-apply job it is reporting on. */
+export interface OrganizeJobReading {
+    failure: OrganizeJobFailure | undefined;
+    isStarting: boolean;
+    isRunning: boolean;
+    isDone: boolean;
+    failedCount: number;
+    /**
+     * The pass belongs to a rule that already saved, so a pass that never started
+     * leaves the rule standing rather than leaving nothing behind.
+     */
+    ruleSaved: boolean;
+}
+/**
+ * What the run screen says the job is doing. A status that could not be read is
+ * not a job that never started (#526), so what the job is doing is read before
+ * what failed: a dropped poll leaves a running pass running and a finished one
+ * finished, and only a create that never returned an id says nothing happened.
+ *
+ * A create that failed over a pass that already ran is that same distinction on
+ * the create path (#552): the counts of the pass that ran stand, and what failed
+ * is the retry.
+ */
+export declare const organizeRunState: ({ failure, isStarting, isRunning, isDone, failedCount, ruleSaved, }: OrganizeJobReading) => RunState;

package/dist/src/components/mail/organize-run-state.js

@@ -0,0 +1,24 @@
+/**
+ * What the run screen says the job is doing. A status that could not be read is
+ * not a job that never started (#526), so what the job is doing is read before
+ * what failed: a dropped poll leaves a running pass running and a finished one
+ * finished, and only a create that never returned an id says nothing happened.
+ *
+ * A create that failed over a pass that already ran is that same distinction on
+ * the create path (#552): the counts of the pass that ran stand, and what failed
+ * is the retry.
+ */
+export const organizeRunState = ({ failure, isStarting, isRunning, isDone, failedCount, ruleSaved, }) => {
+    if (failure?.kind === "restartFailed")
+        return "backApplyRestartFailed";
+    if (failure?.kind === "startFailed") {
+        return ruleSaved ? "backApplyStartFailed" : "commitFailed";
+    }
+    if (isDone)
+        return failedCount > 0 ? "backApplyFailed" : "backApplyComplete";
+    if (failure?.kind === "statusUnreadable")
+        return "statusUnknown";
+    if (isStarting || isRunning)
+        return "backApplyRunning";
+    return "saving";
+};

package/dist/src/components/mail/selection-wizard-run-controls.d.ts

@@ -0,0 +1,66 @@
+import type { RunState, StepId } from "@remit/ui";
+import type { BulkActionTarget, BulkRunOutcome } from "../../lib/bulk-actions";
+import type { OrganizeScope } from "../../lib/organize/organize-model";
+export interface RetryContext {
+    runState: RunState;
+    isEscalated: boolean;
+    committedScope: OrganizeScope | undefined;
+    createFilterFailed: boolean;
+    backApplyPending: boolean;
+    widenRunsAsJob: boolean;
+    failedIds: readonly string[];
+    sent: readonly BulkActionTarget[];
+}
+export type RetryIntent = {
+    kind: "refreshStatus";
+} | {
+    kind: "rerunEscalated";
+} | {
+    kind: "resetAndResend";
+} | {
+    kind: "resend";
+} | {
+    kind: "startBackApply";
+} | {
+    kind: "waitOnJob";
+} | {
+    kind: "rerunBulk";
+    targets: readonly BulkActionTarget[];
+};
+/**
+ * What pressing the run screen's retry asks for, given where the commit got to.
+ *
+ * A back-apply whose status could not be read is still running on the server
+ * (#526), so that one is decided before anything that could queue a second pass
+ * over the same mail.
+ */
+export declare const retryIntent: (context: RetryContext) => RetryIntent;
+/**
+ * What a commit has left paging. A commit that never started, one whose runner
+ * has handed back its outcome, and one that could not start at all all have
+ * nothing to end — so the run screen offers no control that would claim to end
+ * them (#521).
+ */
+export declare const runIsInFlight: (bulkRun: {
+    outcome?: BulkRunOutcome;
+    failureReason?: string;
+} | undefined) => boolean;
+/**
+ * Ends the run rather than leaving it. An escalated predicate is paged by the
+ * list's own runner and a bounded selection by the wizard's, so the stop has to
+ * follow whichever one is paging: a stop that reaches only one of them leaves
+ * the other's control on screen doing nothing.
+ */
+export declare const stopRunner: (escalated: {
+    stop: () => void;
+} | undefined, stopBulk: () => void) => void;
+/**
+ * Which of the two movements the wizard's exit is, on the step it is taken
+ * from. Everywhere but the run screen it rewinds the entries the wizard owns
+ * and leaves the selection where it was; on the run screen the action has
+ * already been sent, so leaving walks away from a run that keeps going.
+ */
+export declare const wizardExit: (step: StepId, movements: {
+    dismiss: () => void;
+    cancel: () => void;
+}) => (() => void);

package/dist/src/components/mail/selection-wizard-run-controls.js

@@ -0,0 +1,65 @@
+/**
+ * What pressing the run screen's retry asks for, given where the commit got to.
+ *
+ * A back-apply whose status could not be read is still running on the server
+ * (#526), so that one is decided before anything that could queue a second pass
+ * over the same mail.
+ */
+export const retryIntent = (context) => {
+    if (context.runState === "statusUnknown")
+        return { kind: "refreshStatus" };
+    // The predicate is re-resolved, not resumed: every verb it carries is
+    // idempotent, so the messages the first pass already reached are a no-op.
+    if (context.isEscalated)
+        return { kind: "rerunEscalated" };
+    if (context.committedScope === "standing" ||
+        context.committedScope === "temporary") {
+        if (context.createFilterFailed)
+            return { kind: "resetAndResend" };
+        return context.backApplyPending
+            ? { kind: "startBackApply" }
+            : { kind: "waitOnJob" };
+    }
+    if (context.committedScope === "all-like-these" && context.widenRunsAsJob) {
+        return { kind: "resend" };
+    }
+    // A run hands back ids, and each one's account came from the batch it was
+    // sent in — so a retry re-sends the targets the run was given, filtered to
+    // what it never reached.
+    const outstanding = new Set(context.failedIds);
+    return {
+        kind: "rerunBulk",
+        targets: outstanding.size > 0
+            ? context.sent.filter((target) => outstanding.has(target.id))
+            : context.sent,
+    };
+};
+/**
+ * What a commit has left paging. A commit that never started, one whose runner
+ * has handed back its outcome, and one that could not start at all all have
+ * nothing to end — so the run screen offers no control that would claim to end
+ * them (#521).
+ */
+export const runIsInFlight = (bulkRun) => bulkRun !== undefined &&
+    bulkRun.outcome === undefined &&
+    bulkRun.failureReason === undefined;
+/**
+ * Ends the run rather than leaving it. An escalated predicate is paged by the
+ * list's own runner and a bounded selection by the wizard's, so the stop has to
+ * follow whichever one is paging: a stop that reaches only one of them leaves
+ * the other's control on screen doing nothing.
+ */
+export const stopRunner = (escalated, stopBulk) => {
+    if (escalated) {
+        escalated.stop();
+        return;
+    }
+    stopBulk();
+};
+/**
+ * Which of the two movements the wizard's exit is, on the step it is taken
+ * from. Everywhere but the run screen it rewinds the entries the wizard owns
+ * and leaves the selection where it was; on the run screen the action has
+ * already been sent, so leaving walks away from a run that keeps going.
+ */
+export const wizardExit = (step, movements) => (step === "run" ? movements.dismiss : movements.cancel);

package/dist/src/components/mail/useModifierSelect.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Modifier-click selection for a message row, shared by every row shape.
+ *
+ * Selection on modifiers is not gated on the layout tier. `isDesktop` is a media
+ * query at 1024px: it says how the app is laid out, not what is driving it.
+ * While the modifiers were read only on the desktop tier, every narrower window
+ * — a half-screen browser, a tablet — fell through to the touch branch, which
+ * never looks at them, and shift, cmd and ctrl click all just opened the
+ * message. A modifier can only come from a real keyboard, so a row honours it at
+ * every width; a tap carries none and is unaffected.
+ *
+ * The press, not the click, is where a modified click is taken. A mailbox row is
+ * an `<a href>`, and a modified click on an anchor is a browser gesture: shift
+ * opens a new window, cmd a new tab, ctrl raises the context menu. WebKit
+ * commits to that gesture from the press, so a `click` handler calling
+ * `preventDefault` is already too late there. `claimClick` still handles the
+ * click for engines that deliver it that way.
+ */
+import { type SelectionModifiers } from "@remit/ui";
+import { type MouseEvent } from "react";
+export interface ModifierSelect {
+    /** Takes a modified press for selection before the browser acts on it. */
+    onMouseDown: (e: MouseEvent<HTMLElement>) => void;
+    /**
+     * Suppresses the context menu macOS raises from a ctrl-click the press
+     * already spent on selection. A plain right-click keeps its menu.
+     */
+    onContextMenu: (e: MouseEvent) => void;
+    /**
+     * True when the click belongs to a modified gesture selection has taken, in
+     * which case it is already consumed and the row must not open.
+     */
+    claimClick: (e: MouseEvent) => boolean;
+}
+export declare const useModifierSelect: (messageId: string, onRowSelect?: (messageId: string, modifiers: SelectionModifiers) => boolean) => ModifierSelect;

package/dist/src/components/mail/useModifierSelect.js

@@ -0,0 +1,75 @@
+/**
+ * Modifier-click selection for a message row, shared by every row shape.
+ *
+ * Selection on modifiers is not gated on the layout tier. `isDesktop` is a media
+ * query at 1024px: it says how the app is laid out, not what is driving it.
+ * While the modifiers were read only on the desktop tier, every narrower window
+ * — a half-screen browser, a tablet — fell through to the touch branch, which
+ * never looks at them, and shift, cmd and ctrl click all just opened the
+ * message. A modifier can only come from a real keyboard, so a row honours it at
+ * every width; a tap carries none and is unaffected.
+ *
+ * The press, not the click, is where a modified click is taken. A mailbox row is
+ * an `<a href>`, and a modified click on an anchor is a browser gesture: shift
+ * opens a new window, cmd a new tab, ctrl raises the context menu. WebKit
+ * commits to that gesture from the press, so a `click` handler calling
+ * `preventDefault` is already too late there. `claimClick` still handles the
+ * click for engines that deliver it that way.
+ */
+import { isModified, modifiersOf } from "@remit/ui";
+import { useCallback, useRef } from "react";
+const consume = (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+};
+export const useModifierSelect = (messageId, onRowSelect) => {
+    // Set while a modified press has already been handed to selection, so the
+    // click the same gesture still delivers cannot open the row on top of it.
+    const claimedRef = useRef(false);
+    const onMouseDown = useCallback((e) => {
+        claimedRef.current = false;
+        // Only the primary button; a right-click keeps its context menu.
+        if (e.button !== 0)
+            return;
+        const modifiers = modifiersOf(e);
+        if (!isModified(modifiers))
+            return;
+        // The browser's own default is only worth taking once selection has
+        // actually taken the press. On a row without selection, cmd-click still
+        // opens a new tab.
+        if (!onRowSelect?.(messageId, modifiers))
+            return;
+        consume(e);
+        claimedRef.current = true;
+        // Preventing the press also drops the focus it would have moved, so put
+        // it back: the roving cursor follows the row the user clicked, and it is
+        // the origin a later shift-click ranges from.
+        e.currentTarget.focus();
+        // Shift-click otherwise drags a native text selection across the rows it
+        // spans — the row highlight is the selection the user asked for.
+        if (modifiers.shiftKey)
+            window.getSelection()?.removeAllRanges();
+    }, [onRowSelect, messageId]);
+    const onContextMenu = useCallback((e) => {
+        if (!e.ctrlKey || !onRowSelect)
+            return;
+        e.preventDefault();
+    }, [onRowSelect]);
+    const claimClick = useCallback((e) => {
+        if (claimedRef.current) {
+            claimedRef.current = false;
+            consume(e);
+            return true;
+        }
+        const modifiers = modifiersOf(e);
+        if (!isModified(modifiers))
+            return false;
+        if (!onRowSelect?.(messageId, modifiers))
+            return false;
+        consume(e);
+        if (modifiers.shiftKey)
+            window.getSelection()?.removeAllRanges();
+        return true;
+    }, [onRowSelect, messageId]);
+    return { onMouseDown, onContextMenu, claimClick };
+};

package/dist/src/components/onboarding/OnboardingWizard.d.ts

@@ -0,0 +1,83 @@
+/**
+ * OnboardingWizard — full 7-step onboarding flow.
+ *
+ * Steps: Welcome → Connector → Address → Servers → Credentials → Test → Sync
+ *        Microsoft path: Connector → MicrosoftEmail → redirect → MicrosoftGranted
+ *
+ * Entry points:
+ *  - First-run (zero accounts): full-screen wizard via /onboarding route
+ *  - Settings "Add account": steps 2-7 embedded in the settings content area
+ *
+ * Backend deps status:
+ *  - POST /accounts — CREATE. Exists.
+ *  - POST /accounts/test-connection — Exists.
+ *  - GET /accounts/{accountId}/sync/status — Exists (#431 syncPhase).
+ *  - POST /accounts/oauth/microsoft/start — Exists (#473).
+ *  - GET /autodiscovery?email=… — NOT YET IMPLEMENTED (TypeSpec-first, future).
+ *    Client-side autodiscovery (provider table + Mozilla autoconfig) used instead.
+ */
+import type { RemitImapAccountResponse } from "@remit/api-http-client/types.gen.ts";
+import { type AccountService } from "@remit/ui";
+import { type ServerConfig } from "./credential-steps.js";
+/**
+ * First run. Importing a config file sits beside adding the first account, not
+ * under it: someone arriving from another Reader has already made every choice
+ * the wizard is about to ask for, and the file is the shorter road.
+ */
+export declare function StepWelcome({ onStart, onImportConfig, }: {
+    onStart: () => void;
+    onImportConfig?: () => void;
+}): import("react").JSX.Element;
+export interface StepMicrosoftEmailProps {
+    refusal?: MicrosoftRefusal;
+    onBack: () => void;
+    onConnected: (accountId: string) => void;
+}
+export declare function StepMicrosoftEmail({ refusal, onBack, onConnected, }: StepMicrosoftEmailProps): import("react").JSX.Element;
+export interface StepMicrosoftGrantedProps {
+    accountId: string;
+    onSignInAgain: () => void;
+    onContinue: (accountId: string) => void;
+}
+export declare function StepMicrosoftGranted({ accountId, onSignInAgain, onContinue, }: StepMicrosoftGrantedProps): import("react").JSX.Element;
+export interface AccountGrantedProps {
+    account: Pick<RemitImapAccountResponse, "accountId" | "email" | "syncedServices" | "grantedScopes">;
+    onContinue: (accountId: string) => void;
+}
+export declare function AccountGranted({ account, onContinue }: AccountGrantedProps): import("react").JSX.Element;
+export declare function StepServers({ email, imapConfig, smtpConfig, discovered, onContinue, onBack, onChange, }: {
+    email: string;
+    imapConfig: ServerConfig;
+    smtpConfig: ServerConfig;
+    discovered: boolean;
+    onContinue: () => void;
+    onBack: () => void;
+    onChange: (imap: ServerConfig, smtp: ServerConfig) => void;
+}): import("react").JSX.Element;
+export interface OnboardingWizardProps {
+    /** If false, show the Welcome step first */
+    skipWelcome?: boolean;
+    /** Called when the user clicks "Go to inbox" with the new accountId */
+    onComplete: (accountId: string) => void;
+    /** Called when the user cancels (Esc from connector picker) */
+    onCancel?: () => void;
+    /**
+     * Offered on the welcome step only, beside adding the first account. Absent
+     * where the wizard is embedded to add an account to an instance that already
+     * has one — importing a configuration is a first-run move, not an add.
+     */
+    onImportConfig?: () => void;
+    microsoftReturn?: MicrosoftReturn;
+}
+export interface MicrosoftRefusal {
+    kind: "refused";
+    message: string;
+    email?: string;
+    services?: AccountService[];
+    reconnect: boolean;
+}
+export type MicrosoftReturn = {
+    kind: "connected";
+    accountId: string;
+} | MicrosoftRefusal;
+export declare function OnboardingWizard({ skipWelcome, onComplete, onCancel, onImportConfig, microsoftReturn, }: OnboardingWizardProps): import("react").JSX.Element;