@remit/web-client 0.0.325 → 0.0.326

package/dist/src/hooks/useDeleteFolder.js

@@ -0,0 +1,280 @@
+import { configOperationsGetConfigQueryKey, mailboxOperationsListMailboxesQueryKey, syncOperationsGetSyncStatusOptions, } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { mailboxDetailOperationsDeleteMailbox, mailboxOperationsListMailboxes, messageBulkOperationsMoveMessages, syncOperationsTriggerSync, threadOperationsListThreads, } from "@remit/api-http-client/sdk.gen.ts";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useRef, useState } from "react";
+import { advanceMove, beginMove, failMove, MOVE_BATCH_SIZE, } from "../lib/delete-folder";
+import { awaitFreshMailboxCount, mailboxSyncStamp, } from "../lib/fresh-mailbox-count";
+const PAGE_CAP = 50;
+const errorText = (error) => error instanceof Error ? error.message : "Something went wrong.";
+/**
+ * Run a network call to a branchable result instead of a thrown exception, so
+ * the caller can surface a failed batch to the UI without a block catch (the
+ * fail-fast lint rule reserves those for rethrows).
+ */
+const attempt = (work) => work.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error: errorText(error) }));
+/**
+ * Collect up to `limit` message ids still living in the mailbox, skipping ones
+ * already moved this run and anything flagged deleted. Reads fresh from the
+ * server every call so a resumed or interrupted move enumerates what is
+ * actually left, never a stale snapshot.
+ */
+const collectMovableIds = async (mailboxId, alreadyMoved, limit, signal) => {
+    const ids = [];
+    let continuationToken;
+    for (let page = 0; page < PAGE_CAP; page += 1) {
+        if (signal.aborted)
+            return ids;
+        const { data } = await threadOperationsListThreads({
+            path: { mailboxId },
+            query: { order: "desc", continuationToken },
+            throwOnError: true,
+        });
+        for (const item of data.items) {
+            if (item.isDeleted)
+                continue;
+            if (alreadyMoved.has(item.messageId))
+                continue;
+            if (ids.includes(item.messageId))
+                continue;
+            ids.push(item.messageId);
+            if (ids.length >= limit)
+                return ids;
+        }
+        if (!data.continuationToken)
+            break;
+        continuationToken = data.continuationToken;
+    }
+    return ids;
+};
+/**
+ * Count live messages still listed in the mailbox with no `moved`-set filtering,
+ * an independent read the move loop cannot fool. The delete gates on this: if any
+ * message still shows here — including one that lags in the source listing after a
+ * move — the folder is not emptied yet and must not be deleted.
+ */
+const liveMessageCount = async (mailboxId, signal) => {
+    let count = 0;
+    let continuationToken;
+    for (let page = 0; page < PAGE_CAP; page += 1) {
+        if (signal.aborted)
+            return count;
+        const { data } = await threadOperationsListThreads({
+            path: { mailboxId },
+            query: { order: "desc", continuationToken },
+            throwOnError: true,
+        });
+        for (const item of data.items) {
+            if (item.isDeleted)
+                continue;
+            count += 1;
+        }
+        if (!data.continuationToken)
+            break;
+        continuationToken = data.continuationToken;
+    }
+    return count;
+};
+export function useDeleteFolder({ accountId, mailboxId, onDeleted, }) {
+    const queryClient = useQueryClient();
+    const [phase, setPhase] = useState("idle");
+    const [progress, setProgress] = useState(null);
+    const [errorMessage, setErrorMessage] = useState();
+    const [checkStartedAt, setCheckStartedAt] = useState();
+    const abortRef = useRef(null);
+    /** The folder's sync stamp before the round was asked for; set while a check
+     * is running or paused, so resuming it re-uses the same baseline. */
+    const sinceRef = useRef(undefined);
+    const invalidate = useCallback(() => {
+        queryClient.invalidateQueries({
+            queryKey: mailboxOperationsListMailboxesQueryKey({ path: { accountId } }),
+        });
+        queryClient.invalidateQueries({
+            queryKey: configOperationsGetConfigQueryKey(),
+        });
+    }, [queryClient, accountId]);
+    const deleteMailbox = useCallback(async () => {
+        setPhase("deleting");
+        const outcome = await attempt(mailboxDetailOperationsDeleteMailbox({
+            path: { accountId, mailboxId },
+            throwOnError: true,
+        }));
+        if (!outcome.ok) {
+            setErrorMessage(outcome.error);
+            setPhase("error");
+            return;
+        }
+        invalidate();
+        setPhase("done");
+        onDeleted();
+    }, [accountId, mailboxId, invalidate, onDeleted]);
+    const remainingCount = useCallback(() => mailboxOperationsListMailboxes({
+        path: { accountId },
+        throwOnError: true,
+    }).then(({ data }) => data.items.find((box) => box.mailboxId === mailboxId)?.messageCount ??
+        0), [accountId, mailboxId]);
+    const readMailboxSyncStatus = useCallback(() => queryClient
+        .fetchQuery({
+        ...syncOperationsGetSyncStatusOptions({ path: { accountId } }),
+        staleTime: 0,
+    })
+        .then((data) => data.mailboxes ?? []), [queryClient, accountId]);
+    /**
+     * Delete a folder the user was told is empty. Every count the client holds is
+     * the last sync round's, so this waits (R2 of the IMAP mutation rules) for a
+     * round asked for here to report on the folder, and deletes only on the count
+     * that round read. A read failure or a folder gone from the account refuses
+     * the delete: not knowing what a folder holds is never permission.
+     *
+     * The round can take minutes — it fans the whole account out behind INBOX —
+     * so the wait runs in segments. A segment that ends unreported returns
+     * `pending` and the user decides; calling again resumes the same wait against
+     * the same baseline, and never asks for a second round.
+     */
+    const deleteIfEmpty = useCallback(async () => {
+        const controller = new AbortController();
+        abortRef.current = controller;
+        const { signal } = controller;
+        setPhase("checking");
+        setErrorMessage(undefined);
+        const resuming = sinceRef.current !== undefined;
+        const counted = await attempt((async () => {
+            if (!resuming) {
+                signal.throwIfAborted();
+                sinceRef.current = mailboxSyncStamp(await readMailboxSyncStatus(), mailboxId);
+                signal.throwIfAborted();
+                setCheckStartedAt(Date.now());
+                await syncOperationsTriggerSync({
+                    path: { accountId },
+                    throwOnError: true,
+                });
+            }
+            return awaitFreshMailboxCount({
+                readMailboxes: readMailboxSyncStatus,
+                mailboxId,
+                since: sinceRef.current ?? 0,
+                signal,
+            });
+        })());
+        if (signal.aborted) {
+            // The dialog is closing or the user cancelled; leave nothing running
+            // and no phase for a later caller to inherit.
+            setPhase("idle");
+            sinceRef.current = undefined;
+            return { status: "failed" };
+        }
+        if (!counted.ok) {
+            sinceRef.current = undefined;
+            setErrorMessage(counted.error);
+            setPhase("error");
+            return { status: "failed" };
+        }
+        if (counted.value.status === "pending") {
+            setPhase("check-stalled");
+            return { status: "pending" };
+        }
+        sinceRef.current = undefined;
+        if (counted.value.messageCount > 0) {
+            setPhase("idle");
+            invalidate();
+            return { status: "blocked", messageCount: counted.value.messageCount };
+        }
+        await deleteMailbox();
+        return { status: "deleted" };
+    }, [accountId, mailboxId, readMailboxSyncStatus, deleteMailbox, invalidate]);
+    const cancel = useCallback(() => {
+        abortRef.current?.abort();
+    }, []);
+    const moveThenDelete = useCallback(async (destinationMailboxId) => {
+        const controller = new AbortController();
+        abortRef.current = controller;
+        const { signal } = controller;
+        setPhase("moving");
+        setErrorMessage(undefined);
+        const counted = await attempt(remainingCount());
+        if (signal.aborted)
+            return;
+        if (!counted.ok) {
+            setErrorMessage(counted.error);
+            setPhase("error");
+            return;
+        }
+        let current = beginMove(counted.value);
+        setProgress(current);
+        const moved = new Set();
+        while (true) {
+            if (signal.aborted)
+                return;
+            const collected = await attempt(collectMovableIds(mailboxId, moved, MOVE_BATCH_SIZE, signal));
+            if (signal.aborted)
+                return;
+            if (!collected.ok) {
+                current = failMove(current, collected.error);
+                setProgress(current);
+                setErrorMessage(collected.error);
+                setPhase("error");
+                return;
+            }
+            const batch = collected.value;
+            if (batch.length === 0)
+                break;
+            const movedBatch = await attempt(messageBulkOperationsMoveMessages({
+                body: { messageIds: batch, destinationMailboxId },
+                throwOnError: true,
+            }));
+            if (signal.aborted)
+                return;
+            if (!movedBatch.ok) {
+                current = failMove(current, movedBatch.error);
+                setProgress(current);
+                setErrorMessage(movedBatch.error);
+                setPhase("error");
+                return;
+            }
+            for (const id of batch)
+                moved.add(id);
+            current = advanceMove(current, batch.length);
+            setProgress(current);
+        }
+        const remaining = await attempt(liveMessageCount(mailboxId, signal));
+        if (signal.aborted)
+            return;
+        if (!remaining.ok) {
+            current = failMove(current, remaining.error);
+            setProgress(current);
+            setErrorMessage(remaining.error);
+            setPhase("error");
+            return;
+        }
+        if (remaining.value > 0) {
+            const message = `${remaining.value} ${remaining.value === 1 ? "email is" : "emails are"} still syncing. Re-open delete to finish removing this folder.`;
+            current = failMove(current, message);
+            setProgress(current);
+            setErrorMessage(message);
+            setPhase("error");
+            invalidate();
+            return;
+        }
+        await deleteMailbox();
+    }, [mailboxId, remainingCount, deleteMailbox, invalidate]);
+    const reset = useCallback(() => {
+        abortRef.current?.abort();
+        abortRef.current = null;
+        sinceRef.current = undefined;
+        setPhase("idle");
+        setProgress(null);
+        setErrorMessage(undefined);
+        setCheckStartedAt(undefined);
+    }, []);
+    return {
+        phase,
+        progress,
+        errorMessage,
+        /** When the running check asked for its round; the surface shows the wait. */
+        checkStartedAt,
+        deleteMailbox,
+        deleteIfEmpty,
+        moveThenDelete,
+        cancel,
+        reset,
+    };
+}

package/dist/src/hooks/useDeleteMessages.d.ts

@@ -0,0 +1,41 @@
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+interface UseDeleteMessagesOptions {
+    mailboxId: string;
+    threadId?: string;
+    accountId?: string;
+    /**
+     * The threads the ids may come from, when the caller has them. A selection in
+     * the brief or Flagged spans mailboxes and accounts, so the listings to patch
+     * are the ones each message actually lives in — `mailboxId` alone would leave
+     * every other mailbox's cached list holding a deleted row.
+     */
+    messages?: RemitImapThreadMessageResponse[];
+    /**
+     * Called once the optimistic removal has been applied. Use this to
+     * navigate away from a now-empty thread (e.g. clear `selectedMessageId`)
+     * before the server response arrives.
+     */
+    onAfterOptimisticRemove?: (messageIds: string[]) => void;
+}
+/**
+ * Pure helper: drop the messages in `messageIds` from a single page's items.
+ *
+ * Exported so the optimistic-removal math can be exercised without rendering
+ * React. Other identity is preserved — only items whose `messageId` is in
+ * the set are removed.
+ */
+export declare const removeMessagesFromItems: (items: RemitImapThreadMessageResponse[], messageIds: Set<string>) => RemitImapThreadMessageResponse[];
+/**
+ * Pure helper: drop soft-deleted rows from a flattened thread list.
+ *
+ * Belt-and-braces guard against #212. The backend already excludes
+ * `isDeleted: true` rows from the inbox listing, but if a regression slips
+ * back in (or an eventual-consistency window briefly returns a soft-deleted
+ * row) the UI must not show it.
+ */
+export declare const dropDeletedThreads: (items: RemitImapThreadMessageResponse[]) => RemitImapThreadMessageResponse[];
+export declare const useDeleteMessages: ({ mailboxId, threadId, accountId, messages, onAfterOptimisticRemove, }: UseDeleteMessagesOptions) => {
+    deleteMessages: (messageIds: string[]) => void;
+    isPending: boolean;
+};
+export {};

package/dist/src/hooks/useDeleteMessages.js

@@ -0,0 +1,171 @@
+import { mailboxOperationsListMailboxesQueryKey, messageBulkOperationsDeleteMessagesMutation, threadDetailOperationsListThreadMessagesQueryKey, } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useRef } from "react";
+import { useRoleAppointmentPrompt } from "../components/mail/RoleAppointmentPromptProvider";
+import { useErrorBanners } from "../components/ui/ErrorBannerProvider";
+import { formatErrorDetail } from "../components/ui/error-banners";
+import { isFolderRoleRefusal } from "../components/ui/folder-role-refusal";
+import { isPlacementRefusal, placementRefusalBanner, } from "../components/ui/placement-refusal";
+import { runChunkedMutation } from "../lib/bulk-actions";
+import { softErrorStatuses } from "../lib/error-classifier";
+import { cancelThreadListQueries, invalidateThreadListQueries, patchThreadListQueries, restoreThreadListQueries, snapshotThreadListQueries, threadListCacheKeys, } from "../lib/thread-list-cache";
+import { resolveMailboxesForMessages } from "./useMarkAsRead";
+/**
+ * Pure helper: drop the messages in `messageIds` from a single page's items.
+ *
+ * Exported so the optimistic-removal math can be exercised without rendering
+ * React. Other identity is preserved — only items whose `messageId` is in
+ * the set are removed.
+ */
+export const removeMessagesFromItems = (items, messageIds) => items.filter((item) => !messageIds.has(item.messageId));
+/**
+ * Pure helper: drop soft-deleted rows from a flattened thread list.
+ *
+ * Belt-and-braces guard against #212. The backend already excludes
+ * `isDeleted: true` rows from the inbox listing, but if a regression slips
+ * back in (or an eventual-consistency window briefly returns a soft-deleted
+ * row) the UI must not show it.
+ */
+export const dropDeletedThreads = (items) => items.filter((item) => item.isDeleted !== true);
+export const useDeleteMessages = ({ mailboxId, threadId, accountId, messages, onAfterOptimisticRemove, }) => {
+    const queryClient = useQueryClient();
+    const { pushError } = useErrorBanners();
+    const { requestAppointment } = useRoleAppointmentPrompt();
+    // The refused chunk is not what the user asked for. The whole selection is
+    // held here so the appointment's confirm replays all of it (#887).
+    const selectionRef = useRef([]);
+    const runRef = useRef(async () => { });
+    const { mutateAsync, isPending } = useMutation({
+        ...messageBulkOperationsDeleteMessagesMutation(),
+        // A coded 409 is answered here — the prompt, or a banner — so it must not
+        // also take the whole screen. Only 409: a 401, 403 or 5xx on a delete is
+        // still the fatal page's (#1059).
+        meta: softErrorStatuses(409),
+        onMutate: async (variables) => {
+            const messageIds = new Set(variables.body.messageIds ?? []);
+            const threadMessagesPrefix = threadId
+                ? threadDetailOperationsListThreadMessagesQueryKey({
+                    path: { threadId },
+                })
+                : [];
+            // Every mailbox the deleted messages live in, plus the unified
+            // cross-account listing that backs the daily brief — deleting from the
+            // brief has to remove the row there too, not only from the per-mailbox
+            // lists (#140, part of #149).
+            const listPrefixes = threadListCacheKeys(resolveMailboxesForMessages(messageIds, messages ?? [], mailboxId));
+            await Promise.all([
+                queryClient.cancelQueries({ queryKey: threadMessagesPrefix }),
+                cancelThreadListQueries(queryClient, listPrefixes),
+            ]);
+            const previousThreadMessages = threadId
+                ? queryClient
+                    .getQueriesData({
+                    queryKey: threadMessagesPrefix,
+                })
+                    .filter((entry) => entry[1] !== undefined)
+                    .map(([queryKey, data]) => ({ queryKey, data }))
+                : [];
+            const previousThreadsList = snapshotThreadListQueries(queryClient, listPrefixes);
+            if (threadId) {
+                queryClient.setQueriesData({ queryKey: threadMessagesPrefix }, (old) => {
+                    if (!old)
+                        return old;
+                    return {
+                        ...old,
+                        items: removeMessagesFromItems(old.items, messageIds),
+                    };
+                });
+            }
+            patchThreadListQueries(queryClient, listPrefixes, (items) => removeMessagesFromItems(items, messageIds));
+            onAfterOptimisticRemove?.(Array.from(messageIds));
+            return {
+                threadMessagesPrefix,
+                listPrefixes,
+                previousThreadMessages,
+                previousThreadsList,
+            };
+        },
+        // A batch that partly applied answers 200 with a non-zero `failureCount`:
+        // the rows whose placement changed under it were never claimed
+        // (imap-mutations R3). `onSettled` invalidates, so those rows come back on
+        // their own — this is what stops them coming back unexplained, which is
+        // the dead-button failure wearing a different face (#1229).
+        onSuccess: (data, vars) => {
+            const refused = data?.failureCount ?? 0;
+            if (refused === 0)
+                return;
+            const asked = vars.body.messageIds?.length ?? 0;
+            pushError({
+                severity: "warning",
+                title: refused > 1
+                    ? `Couldn't delete ${refused} of ${asked} messages yet`
+                    : "Couldn't delete this message yet",
+                detail: "Something else moved it while the delete was being prepared. It is back where it now sits — try again.",
+            });
+        },
+        onError: (err, vars, context) => {
+            if (context) {
+                for (const entry of context.previousThreadMessages) {
+                    queryClient.setQueryData(entry.queryKey, entry.data);
+                }
+                restoreThreadListQueries(queryClient, context.previousThreadsList);
+            }
+            // A provenance refusal is answered by the prompt, not by a banner: the
+            // generic banner is suppressed for this one error, and every other
+            // failure keeps today's.
+            const refusal = isFolderRoleRefusal(err);
+            if (refusal) {
+                const replay = selectionRef.current;
+                requestAppointment({
+                    accountId: refusal.accountId,
+                    role: refusal.role,
+                    reason: refusal.reason,
+                    action: { kind: "delete", count: replay.length },
+                    onAppointed: () => runRef.current(replay),
+                });
+                return;
+            }
+            const count = vars.body.messageIds?.length ?? 0;
+            const placement = isPlacementRefusal(err);
+            if (placement) {
+                pushError(placementRefusalBanner(placement, count, "delete"));
+                return;
+            }
+            pushError({
+                title: count > 1
+                    ? `Couldn't delete ${count} messages`
+                    : "Couldn't delete this message",
+                detail: formatErrorDetail(err),
+                error: err,
+            });
+        },
+        onSettled: (_data, _err, _vars, context) => {
+            if (!context)
+                return;
+            if (threadId) {
+                queryClient.invalidateQueries({
+                    queryKey: context.threadMessagesPrefix,
+                });
+            }
+            invalidateThreadListQueries(queryClient, context.listPrefixes);
+            if (accountId) {
+                queryClient.invalidateQueries({
+                    queryKey: mailboxOperationsListMailboxesQueryKey({
+                        path: { accountId },
+                    }),
+                });
+            }
+        },
+    });
+    const runSelection = useCallback((messageIds) => runChunkedMutation(messageIds, (chunk) => mutateAsync({ body: { messageIds: chunk } })), [mutateAsync]);
+    useEffect(() => {
+        runRef.current = runSelection;
+    }, [runSelection]);
+    const deleteMessages = useCallback((messageIds) => {
+        if (messageIds.length === 0)
+            return;
+        selectionRef.current = messageIds;
+        void runSelection(messageIds);
+    }, [runSelection]);
+    return { deleteMessages, isPending };
+};

package/dist/src/hooks/useDeleteOutcome.d.ts

@@ -0,0 +1,14 @@
+import { type DeleteOutcome, type DeleteTarget } from "../lib/format";
+export interface DeleteOutcomeResult {
+    outcome: DeleteOutcome;
+    /** The folder the user appointed, when it is gone from the mail server. */
+    staleFolderLabel?: string;
+    /**
+     * `unconfirmed`: the folder reader matched by name, which the rows are
+     * already inside. The prompt opens with it chosen, so confirming the guess is
+     * one tap.
+     */
+    guessedMailboxId?: string;
+}
+/** The outcome of deleting `targets`. */
+export declare const useDeleteOutcome: (targets: readonly DeleteTarget[]) => DeleteOutcomeResult;

package/dist/src/hooks/useDeleteOutcome.js

@@ -0,0 +1,46 @@
+/**
+ * What a delete is about to do to a specific set of rows — the one derivation
+ * every delete confirmation words itself from (#845, #855).
+ *
+ * `MessageMoveService.deleteMessages` moves a message to its account's Trash
+ * unless it is already there, in which case the same keypress is an IMAP
+ * expunge and nothing survives it; and it refuses the call outright when the
+ * account appoints no Trash. That branch is per message and per account, not
+ * per view, so the mailbox list, the brief and Flagged all have to ask it of
+ * the rows they are actually about to delete — the brief and Flagged hold rows
+ * from several mailboxes and several accounts at once.
+ *
+ * The decision itself is `deleteOutcomeFor`, kept pure in `lib/format`; this is
+ * only the read that feeds it. The two facts beside it are the folders the
+ * refusal has to name: the one a stale appointment lost, and the one reader
+ * guessed and is asking the user to confirm.
+ */
+import { useMemo } from "react";
+import { deleteOutcomeFor, } from "../lib/format";
+import { useTrashByAccount } from "./useArchiveMailbox";
+/** The outcome of deleting `targets`. */
+export const useDeleteOutcome = (targets) => {
+    const { trashByAccount, hasAppointments, isError } = useTrashByAccount();
+    return useMemo(() => {
+        const outcome = deleteOutcomeFor({
+            targets,
+            trashByAccount,
+            hasAppointments,
+            isError,
+        });
+        const trashFor = (target) => target.accountId ? trashByAccount.get(target.accountId) : undefined;
+        return {
+            outcome,
+            // The account `deleteOutcomeFor` refused on, found the way it found it.
+            staleFolderLabel: targets
+                .map(trashFor)
+                .find((trash) => trash?.source === "Stale")?.staleFolderPath,
+            // The folder that produced `unconfirmed`: a row's own mailbox, which is
+            // also its account's guessed Trash. Only that row says which folder is
+            // being asked about — a row filed elsewhere is moving, not expunging.
+            guessedMailboxId: outcome === "unconfirmed"
+                ? targets.find((target) => trashFor(target)?.mailboxId === target.mailboxId)?.mailboxId
+                : undefined,
+        };
+    }, [targets, trashByAccount, hasAppointments, isError]);
+};

package/dist/src/hooks/useEmptyTrash.d.ts

@@ -0,0 +1,16 @@
+import { type FolderRoleRefusal } from "../components/ui/folder-role-refusal";
+interface UseEmptyTrashOptions {
+    accountId: string | undefined;
+    /** The open mailbox the strip is mounted over. */
+    mailboxId: string;
+}
+export interface EmptyTrashState {
+    emptyTrash: () => void;
+    isEmptying: boolean;
+    /** What the last finished run reported, straight from the service. */
+    deletedCount: number | undefined;
+    refusal: FolderRoleRefusal | undefined;
+    repair: () => void;
+}
+export declare const useEmptyTrash: ({ accountId, mailboxId, }: UseEmptyTrashOptions) => EmptyTrashState;
+export {};