@remit/web-client 0.0.61 → 0.0.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.61",
+  "version": "0.0.62",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

package/src/components/mail/AutoMovedIndicator.tsx

@@ -8,7 +8,7 @@ interface AutoMovedIndicatorProps {
 	threadId: string;
 	mailboxId: string;
 	autoMoved: RemitImapAutoMovedInfo | undefined;
-	/** `md` (reading view) adds the inline Undo action; `sm` (list row) is icon + label only. */
+	/** `md` (reading view) adds the inline actions (Undo, and the Manage-filter link for a filter move); `sm` (list row) shows the icon + label. */
 	size?: "sm" | "md";
 }
 
@@ -43,6 +43,7 @@ export function AutoMovedIndicator({
 			size={size}
 			onUndo={badge.onUndo}
 			undoLabel={badge.isUndoing ? "Undoing…" : "Undo"}
+			filtersHref={size === "md" ? badge.filtersHref : undefined}
 		/>
 	);
 }

package/src/hooks/useAutoMovedBadge.ts

@@ -1,10 +1,13 @@
+import { mailboxOperationsListMailboxesOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
 import type { RemitImapAutoMovedInfo } from "@remit/api-http-client/types.gen.ts";
+import { useQuery } from "@tanstack/react-query";
 import { useCallback } from "react";
 import {
 	autoMovedLabel,
 	isAutoMoveInEffect,
 	resolveUndoTargetMailboxId,
 } from "@/lib/auto-moved";
+import { getMailboxDisplayName } from "@/lib/folder-roles";
 import { useInboxMailbox, useJunkMailbox } from "./useArchiveMailbox";
 import { useMoveMessages } from "./useMoveMessages";
 
@@ -24,14 +27,26 @@ export interface AutoMovedBadgeState {
 	/** Present only when the undo target mailbox resolved. */
 	onUndo?: () => void;
 	isUndoing: boolean;
+	/**
+	 * Settings › Filters link, present only for a standing-filter move — undo
+	 * returns the message but never disables the filter, so the badge points to
+	 * where the filter can be managed.
+	 */
+	filtersHref?: string;
 }
 
 /**
- * Composes the account's Inbox/Junk mailboxes with the message's `autoMoved`
- * projection into everything the `AutoMovedBadge` kit component needs: the
- * derived "still in effect" gate, the plain-language label, and a one-click
- * undo bound to the existing `moveMessages` mutation (no new endpoint — moves
- * back through the same bulk move operation, the other direction).
+ * Composes the account's mailboxes with the message's `autoMoved` projection
+ * into everything the `AutoMovedBadge` kit component needs: the derived "still
+ * in effect" gate, the plain-language label, and a one-click undo bound to the
+ * existing `moveMessages` mutation (no new endpoint — moves back through the
+ * same bulk move operation, the other direction).
+ *
+ * Both auto-move shapes are handled. A classifier move resolves its
+ * Inbox/Junk role mailboxes; a standing-filter move names an arbitrary source
+ * folder, whose display name is resolved from the account's mailbox list, and
+ * carries a Settings › Filters link so the filter that keeps moving mail is one
+ * tap away — undo does not disable it.
  *
  * `show` re-derives on every render from `mailboxId` — no local dismissed
  * flag. Once `moveMessages` settles, its query invalidation refetches the
@@ -53,11 +68,20 @@ export const useAutoMovedBadge = ({
 		accountId,
 	});
 
+	const { data: mailboxes } = useQuery({
+		...mailboxOperationsListMailboxesOptions({
+			path: { accountId: accountId ?? "" },
+		}),
+		staleTime: Infinity,
+		enabled: !!accountId && autoMoved?.fromMailboxId !== undefined,
+	});
+
 	const roleMailboxes = { inboxMailboxId, junkMailboxId };
 	const show = isAutoMoveInEffect(autoMoved, mailboxId, roleMailboxes);
-	const undoTargetMailboxId = autoMoved
-		? resolveUndoTargetMailboxId(autoMoved.fromPlacement, roleMailboxes)
-		: undefined;
+	const undoTargetMailboxId = resolveUndoTargetMailboxId(
+		autoMoved,
+		roleMailboxes,
+	);
 
 	const handleUndo = useCallback(() => {
 		if (!undoTargetMailboxId) return;
@@ -68,10 +92,17 @@ export const useAutoMovedBadge = ({
 		return { show: false, label: "", isUndoing: false };
 	}
 
+	const sourceFolderName = autoMoved.fromMailboxId
+		? mailboxes?.items
+				.filter((mailbox) => mailbox.mailboxId === autoMoved.fromMailboxId)
+				.map((mailbox) => getMailboxDisplayName(mailbox.fullPath))[0]
+		: undefined;
+
 	return {
 		show: true,
-		label: autoMovedLabel(autoMoved.fromPlacement),
+		label: autoMovedLabel(autoMoved, sourceFolderName),
 		onUndo: undoTargetMailboxId ? handleUndo : undefined,
 		isUndoing: isPending,
+		...(autoMoved.filterId ? { filtersHref: "/settings/filters" } : {}),
 	};
 };

package/src/lib/auto-moved.test.ts

@@ -14,23 +14,65 @@ const ROLE_MAILBOXES: AutoMovedRoleMailboxes = {
 	junkMailboxId: "mb-junk",
 };
 
+const classifierMove = (
+	action: RemitImapAutoMovedInfo["action"],
+	fromPlacement: string,
+): RemitImapAutoMovedInfo => ({ action, fromPlacement });
+
+const filterMove = (
+	fromMailboxId: string,
+	destinationMailboxId: string,
+): RemitImapAutoMovedInfo => ({
+	fromMailboxId,
+	destinationMailboxId,
+	filterId: "flt-1",
+});
+
 describe("autoMovedLabel", () => {
-	test("reads 'Moved from Junk by Remit'", () => {
-		assert.equal(autoMovedLabel("junk"), "Moved from Junk by Remit");
+	test("classifier move reads 'Moved from Junk by Remit'", () => {
+		assert.equal(
+			autoMovedLabel(classifierMove(PlacementAction.MoveToInbox, "junk")),
+			"Moved from Junk by Remit",
+		);
 	});
 
-	test("reads 'Moved from Inbox by Remit'", () => {
-		assert.equal(autoMovedLabel("inbox"), "Moved from Inbox by Remit");
+	test("classifier move reads 'Moved from Inbox by Remit'", () => {
+		assert.equal(
+			autoMovedLabel(classifierMove(PlacementAction.MoveToJunk, "inbox")),
+			"Moved from Inbox by Remit",
+		);
 	});
 
-	test("falls back to plain language for an unrecognized placement", () => {
-		assert.equal(autoMovedLabel("other"), "Moved from another folder by Remit");
+	test("classifier move falls back to plain language for an unrecognized placement", () => {
+		assert.equal(
+			autoMovedLabel(classifierMove(PlacementAction.MoveToInbox, "other")),
+			"Moved from another folder by Remit",
+		);
+	});
+
+	test("filter move names the resolved source folder", () => {
+		assert.equal(
+			autoMovedLabel(filterMove("mb-inbox", "mb-travel"), "Travel"),
+			"Moved from Travel by Remit",
+		);
+	});
+
+	test("filter move falls back to 'another folder' before the name resolves", () => {
+		assert.equal(
+			autoMovedLabel(filterMove("mb-inbox", "mb-travel")),
+			"Moved from another folder by Remit",
+		);
 	});
 
 	test("never leaks verdict jargon", () => {
-		for (const placement of ["inbox", "junk", "other"]) {
+		const cases = [
+			classifierMove(PlacementAction.MoveToInbox, "junk"),
+			classifierMove(PlacementAction.MoveToJunk, "inbox"),
+			filterMove("mb-inbox", "mb-travel"),
+		];
+		for (const autoMoved of cases) {
 			assert.doesNotMatch(
-				autoMovedLabel(placement),
+				autoMovedLabel(autoMoved),
 				/confiden|dry.?run|verdict/i,
 			);
 		}
@@ -46,94 +88,138 @@ describe("isAutoMoveInEffect", () => {
 	});
 
 	test("false when currentMailboxId is absent", () => {
-		const autoMoved: RemitImapAutoMovedInfo = {
-			action: PlacementAction.MoveToInbox,
-			fromPlacement: "junk",
-		};
 		assert.equal(
-			isAutoMoveInEffect(autoMoved, undefined, ROLE_MAILBOXES),
+			isAutoMoveInEffect(
+				classifierMove(PlacementAction.MoveToInbox, "junk"),
+				undefined,
+				ROLE_MAILBOXES,
+			),
 			false,
 		);
 	});
 
-	test("true when a MoveToInbox message currently sits in the Inbox mailbox", () => {
-		const autoMoved: RemitImapAutoMovedInfo = {
-			action: PlacementAction.MoveToInbox,
-			fromPlacement: "junk",
-		};
+	test("classifier: true when a MoveToInbox message sits in the Inbox mailbox", () => {
 		assert.equal(
-			isAutoMoveInEffect(autoMoved, "mb-inbox", ROLE_MAILBOXES),
+			isAutoMoveInEffect(
+				classifierMove(PlacementAction.MoveToInbox, "junk"),
+				"mb-inbox",
+				ROLE_MAILBOXES,
+			),
 			true,
 		);
 	});
 
-	test("true when a MoveToJunk message currently sits in the Junk mailbox", () => {
-		const autoMoved: RemitImapAutoMovedInfo = {
-			action: PlacementAction.MoveToJunk,
-			fromPlacement: "inbox",
-		};
+	test("classifier: true when a MoveToJunk message sits in the Junk mailbox", () => {
 		assert.equal(
-			isAutoMoveInEffect(autoMoved, "mb-junk", ROLE_MAILBOXES),
+			isAutoMoveInEffect(
+				classifierMove(PlacementAction.MoveToJunk, "inbox"),
+				"mb-junk",
+				ROLE_MAILBOXES,
+			),
 			true,
 		);
 	});
 
-	test("false once the message has moved elsewhere (self-hide on reconcile)", () => {
-		const autoMoved: RemitImapAutoMovedInfo = {
-			action: PlacementAction.MoveToInbox,
-			fromPlacement: "junk",
-		};
+	test("classifier: false once the message has moved elsewhere", () => {
+		const autoMoved = classifierMove(PlacementAction.MoveToInbox, "junk");
 		assert.equal(
 			isAutoMoveInEffect(autoMoved, "mb-archive", ROLE_MAILBOXES),
 			false,
 		);
-		// Undone back to Junk — no longer in the implied destination.
 		assert.equal(
 			isAutoMoveInEffect(autoMoved, "mb-junk", ROLE_MAILBOXES),
 			false,
 		);
 	});
 
-	test("false when the implied destination mailbox hasn't resolved yet", () => {
-		const autoMoved: RemitImapAutoMovedInfo = {
-			action: PlacementAction.MoveToInbox,
-			fromPlacement: "junk",
-		};
+	test("filter: true while the message sits in the filter's destination", () => {
+		assert.equal(
+			isAutoMoveInEffect(
+				filterMove("mb-inbox", "mb-travel"),
+				"mb-travel",
+				ROLE_MAILBOXES,
+			),
+			true,
+		);
+	});
+
+	test("filter: false once undone back to the source folder", () => {
+		assert.equal(
+			isAutoMoveInEffect(
+				filterMove("mb-inbox", "mb-travel"),
+				"mb-inbox",
+				ROLE_MAILBOXES,
+			),
+			false,
+		);
+	});
+
+	test("filter: in-effect does not depend on the Inbox/Junk role mailboxes", () => {
 		assert.equal(
-			isAutoMoveInEffect(autoMoved, "mb-inbox", {
+			isAutoMoveInEffect(filterMove("mb-inbox", "mb-travel"), "mb-travel", {
 				inboxMailboxId: undefined,
-				junkMailboxId: "mb-junk",
+				junkMailboxId: undefined,
 			}),
+			true,
+		);
+	});
+
+	test("classifier: false when the implied destination mailbox hasn't resolved yet", () => {
+		assert.equal(
+			isAutoMoveInEffect(
+				classifierMove(PlacementAction.MoveToInbox, "junk"),
+				"mb-inbox",
+				{ inboxMailboxId: undefined, junkMailboxId: "mb-junk" },
+			),
 			false,
 		);
 	});
 });
 
 describe("resolveUndoTargetMailboxId", () => {
-	test("resolves the Junk mailbox for fromPlacement='junk'", () => {
-		assert.equal(resolveUndoTargetMailboxId("junk", ROLE_MAILBOXES), "mb-junk");
+	test("classifier: resolves the Junk mailbox for fromPlacement='junk'", () => {
+		assert.equal(
+			resolveUndoTargetMailboxId(
+				classifierMove(PlacementAction.MoveToInbox, "junk"),
+				ROLE_MAILBOXES,
+			),
+			"mb-junk",
+		);
 	});
 
-	test("resolves the Inbox mailbox for fromPlacement='inbox'", () => {
+	test("classifier: resolves the Inbox mailbox for fromPlacement='inbox'", () => {
 		assert.equal(
-			resolveUndoTargetMailboxId("inbox", ROLE_MAILBOXES),
+			resolveUndoTargetMailboxId(
+				classifierMove(PlacementAction.MoveToJunk, "inbox"),
+				ROLE_MAILBOXES,
+			),
 			"mb-inbox",
 		);
 	});
 
-	test("undefined for an unresolvable placement", () => {
+	test("classifier: undefined when the role mailbox hasn't resolved yet", () => {
 		assert.equal(
-			resolveUndoTargetMailboxId("other", ROLE_MAILBOXES),
+			resolveUndoTargetMailboxId(
+				classifierMove(PlacementAction.MoveToInbox, "junk"),
+				{ inboxMailboxId: "mb-inbox", junkMailboxId: undefined },
+			),
 			undefined,
 		);
 	});
 
-	test("undefined when the role mailbox hasn't resolved yet", () => {
+	test("filter: undo targets the recorded source mailbox verbatim", () => {
 		assert.equal(
-			resolveUndoTargetMailboxId("junk", {
-				inboxMailboxId: "mb-inbox",
-				junkMailboxId: undefined,
-			}),
+			resolveUndoTargetMailboxId(
+				filterMove("mb-work", "mb-travel"),
+				ROLE_MAILBOXES,
+			),
+			"mb-work",
+		);
+	});
+
+	test("undefined when autoMoved is absent", () => {
+		assert.equal(
+			resolveUndoTargetMailboxId(undefined, ROLE_MAILBOXES),
 			undefined,
 		);
 	});

package/src/lib/auto-moved.ts

@@ -12,17 +12,35 @@ const FROM_PLACEMENT_LABEL: Record<string, string> = {
 	junk: "Junk",
 };
 
+/** A standing-filter move names an arbitrary destination via `destinationMailboxId`; a classifier move names a direction via `action`. */
+const isFilterMove = (autoMoved: RemitImapAutoMovedInfo): boolean =>
+	autoMoved.destinationMailboxId !== undefined;
+
 /**
  * Plain-language badge text, e.g. "Moved from Junk by Remit". No jargon
  * (verdict/confidence/dryRun never surface) — mirrors the no-jargon precedent
  * in `rescue-candidates.ts`.
+ *
+ * A classifier move reads its source from the `fromPlacement` role. A
+ * standing-filter move moved from an arbitrary folder, so the caller resolves
+ * that folder's display name and passes it as `sourceFolderName`; absent (name
+ * not resolved yet) falls back to "another folder".
  */
-export const autoMovedLabel = (fromPlacement: string | undefined): string =>
-	`Moved from ${FROM_PLACEMENT_LABEL[fromPlacement ?? ""] ?? "another folder"} by Remit`;
+export const autoMovedLabel = (
+	autoMoved: RemitImapAutoMovedInfo,
+	sourceFolderName?: string,
+): string => {
+	if (isFilterMove(autoMoved)) {
+		return `Moved from ${sourceFolderName ?? "another folder"} by Remit`;
+	}
+	const from = autoMoved.fromPlacement ?? "";
+	return `Moved from ${FROM_PLACEMENT_LABEL[from] ?? "another folder"} by Remit`;
+};
 
 /**
- * The mailbox the verdict's `action` implies as the destination — where the
- * message should currently sit for the move to still be "in effect".
+ * The mailbox the verdict's `action` implies as the destination — where a
+ * classifier-moved message should currently sit for the move to still be "in
+ * effect".
  */
 const impliedDestinationMailboxId = (
 	action: string | undefined,
@@ -34,12 +52,13 @@ const impliedDestinationMailboxId = (
 };
 
 /**
- * True only while the auto-move is still in effect: the message currently
- * sits in the mailbox the verdict's `action` implied. Once the message moves
- * elsewhere (an undo, or any other move), this returns false — the badge has
- * no local "dismissed" flag; it re-derives from current placement every
- * render, per the data-flow rule that a projection never forks from its
- * source (doc/rules/data-flow.md).
+ * True only while the auto-move is still in effect: the message currently sits
+ * in the mailbox the move targeted. A standing-filter move targets the
+ * `destinationMailboxId` it recorded; a classifier move targets the mailbox its
+ * `action` implies. Once the message moves elsewhere (an undo, or any other
+ * move), this returns false — the badge has no local "dismissed" flag; it
+ * re-derives from current placement every render, per the data-flow rule that a
+ * projection never forks from its source (doc/rules/data-flow.md).
  */
 export const isAutoMoveInEffect = (
 	autoMoved: RemitImapAutoMovedInfo | undefined,
@@ -47,22 +66,29 @@ export const isAutoMoveInEffect = (
 	mailboxes: AutoMovedRoleMailboxes,
 ): boolean => {
 	if (!autoMoved || !currentMailboxId) return false;
-	const destination = impliedDestinationMailboxId(autoMoved.action, mailboxes);
+	const destination = isFilterMove(autoMoved)
+		? autoMoved.destinationMailboxId
+		: impliedDestinationMailboxId(autoMoved.action, mailboxes);
 	return destination !== undefined && destination === currentMailboxId;
 };
 
 /**
- * Resolve the undo destination: the mailbox filling the role the message was
- * moved from. `fromPlacement` is always `inbox` or `junk` for an actionable
- * verdict (the Tier 0 classifier only fires move-to-inbox from junk and
- * move-to-junk from inbox — see `classifyPlacement.ts`); `undefined` when the
- * account has no mailbox appointed to that role.
+ * Resolve the undo destination: where the message was before the move. A
+ * standing-filter move recorded the exact source mailbox (`fromMailboxId`),
+ * used verbatim. A classifier move recorded only a role (`fromPlacement`,
+ * always `inbox` or `junk` for an actionable verdict — the Tier 0 classifier
+ * only fires move-to-inbox from junk and move-to-junk from inbox, see
+ * `classifyPlacement.ts`), resolved to the account's mailbox for that role.
+ * `undefined` when the account has no mailbox for that role, or the source
+ * cannot be resolved.
  */
 export const resolveUndoTargetMailboxId = (
-	fromPlacement: string | undefined,
+	autoMoved: RemitImapAutoMovedInfo | undefined,
 	mailboxes: AutoMovedRoleMailboxes,
 ): string | undefined => {
-	if (fromPlacement === "inbox") return mailboxes.inboxMailboxId;
-	if (fromPlacement === "junk") return mailboxes.junkMailboxId;
+	if (!autoMoved) return undefined;
+	if (isFilterMove(autoMoved)) return autoMoved.fromMailboxId;
+	if (autoMoved.fromPlacement === "inbox") return mailboxes.inboxMailboxId;
+	if (autoMoved.fromPlacement === "junk") return mailboxes.junkMailboxId;
 	return undefined;
 };