@remit/ui 0.0.91 → 0.0.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/ui",
-  "version": "0.0.91",
+  "version": "0.0.92",
   "type": "module",
   "files": [
     "src"

package/src/components/auto-moved-badge.stories.tsx

@@ -36,6 +36,19 @@ export const FilterMoveWithManageLink: Story = {
 	},
 };
 
+/**
+ * A user-reported spam message (issue #648). Independent of the classifier/
+ * filter-move shapes above: the badge follows the message wherever it now
+ * lives, including a report that never moved the message at all (it was
+ * already in Junk).
+ */
+export const ReportedAsSpam: Story = {
+	args: {
+		label: "Reported as spam",
+		onUndo: () => alert("Undo"),
+	},
+};
+
 export const SideBySide: Story = {
 	render: () => (
 		<div className="flex flex-col items-start gap-3">

package/src/components/intelligence-panel.stories.tsx

@@ -198,31 +198,70 @@ export const WithSimilarMessages: Story = {
 };
 
 /**
- * The spam quick actions are symmetric and mutually exclusive, decided by the
- * mailbox the message is in. A message sitting in Junk is offered the way out.
+ * The spam quick actions are a contextual pair, decided by whether the message
+ * carries a spam report — never by the mailbox it happens to sit in, since a
+ * report on a message already in Junk (the provider's own filter put it there)
+ * is a real, no-op-move case (issue #648). A reportable message offers
+ * "Report spam".
  */
-export const InJunk: Story = {
+export const Reportable: Story = {
 	args: {
 		data: base,
-		actions: { onNotSpam: () => {} },
+		actions: { onReportSpam: () => {} },
 	},
 };
 
-/** The inverse, for a message anywhere else. */
-export const OutsideJunk: Story = {
+/**
+ * Already reported: "Not spam" (the undo) is offered instead of "Report
+ * spam", and the panel names the message as reported. Driven by
+ * `actions.onNotSpam` being present, not by `flags.blocked` — a sender can be
+ * blocked manually, with no report on this particular message, and that must
+ * not read as "you reported this" (issue #648 review).
+ */
+export const Reported: Story = {
 	args: {
 		data: base,
-		actions: { onMarkSpam: () => {} },
+		actions: { onNotSpam: () => {} },
 	},
 };
 
 /**
- * The move has been made. Neither action is offered: pressing the one that just
- * ran would ask the mail server to move the message to where it already is.
+ * Neither action is offered. The panel hides the pair rather than disabling
+ * it — unlike VIP/Mute/Unsubscribe, which always render and go visibly
+ * unavailable with no handler (issue #51). The host's own wiring never
+ * actually reaches this: `resolveSpamAction` always returns one of the two,
+ * since every message either carries a spam report or doesn't. Kept as a
+ * defensive state for a host that doesn't wire the pair at all.
  */
-export const SpamActionSpent: Story = {
+export const SpamActionUnavailable: Story = {
 	args: {
 		data: base,
 		actions: {},
 	},
 };
+
+/**
+ * A "Report spam" press in flight. There's no optimistic update for this
+ * action (a report against a message already in Junk is a real no-op-move,
+ * issue #648), so without a pending label the button gives no visible
+ * response at all until the request lands — the dead-button failure the
+ * coding standards call the worst outcome. The button stays clickable
+ * throughout, same as the undo direction's `isUndoing`: the operation is
+ * idempotent, so a second press is safe, never a queued duplicate.
+ */
+export const ReportSpamPending: Story = {
+	args: {
+		data: base,
+		actions: { onReportSpam: () => {} },
+		reportSpamPending: true,
+	},
+};
+
+/** The undo direction's equivalent — "Undoing…" while `notSpam` is in flight. */
+export const NotSpamPending: Story = {
+	args: {
+		data: base,
+		actions: { onNotSpam: () => {} },
+		notSpamPending: true,
+	},
+};

package/src/components/intelligence-panel.tsx

@@ -1,5 +1,4 @@
 import {
-	Ban,
 	BellOff,
 	MailCheck,
 	MailX,
@@ -112,6 +111,16 @@ export type SimilarMessageLinkComponent = (
 export interface SenderFlagsIntel {
 	vip?: boolean;
 	muted?: boolean;
+	/**
+	 * True once the sender is blocked — via a spam report on some message from
+	 * them, or a manual block in Settings → Senders, which is the only durable
+	 * manage-and-undo surface for it now that this panel has no `Block` action
+	 * of its own. Not used to decide the quick-actions pair below: it's a
+	 * sender-wide flag, and a manual block with no report on THIS message would
+	 * make "You reported this sender" false (issue #648 review). The pair and
+	 * that line key off `actions.onNotSpam`/`onReportSpam` instead, which the
+	 * host derives from this specific message's `Message.spamReport`.
+	 */
 	blocked?: boolean;
 	unsubscribed?: boolean;
 }
@@ -127,20 +136,21 @@ export interface IntelligenceData {
 export interface IntelligenceQuickActions {
 	onToggleVip?: () => void;
 	onToggleMute?: () => void;
-	/** Block navigates through a confirm dialog — the callback fires post-confirm. */
-	onToggleBlock?: () => void;
 	onToggleUnsubscribe?: () => void;
 	onReclassify?: () => void;
 	/**
-	 * "Not spam": move the message out of Junk and promote the sender to
-	 * Wellknown (issue #594). Wired only when the message is currently in Junk.
+	 * "Not spam": undo a spam report — clears the sender block and moves the
+	 * message back where it came from (issue #648). Wired only when the
+	 * message currently carries a spam report.
 	 */
 	onNotSpam?: () => void;
 	/**
-	 * "Mark spam": move the message into Junk and strip the sender's trust
-	 * (the inverse of "Not spam"). Wired only when the message is not in Junk.
+	 * "Report spam": move the message into Junk and block the sender (the
+	 * inverse of "Not spam", issue #648). Wired only when the message has not
+	 * been reported yet. Replaces the former separate `Block` and `Mark spam`
+	 * actions with one contextual control.
 	 */
-	onMarkSpam?: () => void;
+	onReportSpam?: () => void;
 }
 
 /**
@@ -173,6 +183,19 @@ export interface IntelligencePanelProps {
 	 * Drawer header), so there is exactly one way back (#874).
 	 */
 	hideCloseButton?: boolean;
+	/**
+	 * True while a "Report spam" press is in flight. There is no optimistic
+	 * update for this action (issue #648: the client can't predict whether a
+	 * report against a message already in Junk is a no-op), so without this
+	 * the button gives no visible response at all until the request lands — a
+	 * dead button is the worst outcome. Swaps the label to "Reporting…"; the
+	 * handler stays wired throughout (same as `AutoMovedBadge`'s `isUndoing`)
+	 * because the operation is idempotent, so a second press mid-flight is
+	 * safe rather than a queued duplicate.
+	 */
+	reportSpamPending?: boolean;
+	/** True while a "Not spam" (undo) press is in flight. Same treatment as `reportSpamPending`. */
+	notSpamPending?: boolean;
 }
 
 const trustLabel: Record<
@@ -362,6 +385,8 @@ export function IntelligencePanel({
 	similarLinkComponent,
 	className,
 	hideCloseButton = false,
+	reportSpamPending = false,
+	notSpamPending = false,
 }: IntelligencePanelProps) {
 	const { sender, authenticity, category, flags = {}, similar } = data;
 	const suspicious = authenticity.verdict === "mismatch";
@@ -434,35 +459,34 @@ export function IntelligencePanel({
 						active={flags.muted}
 						onClick={actions?.onToggleMute}
 					/>
-					<QuickAction
-						icon={<Ban className="size-3.5" />}
-						label="Block"
-						active={flags.blocked}
-						danger
-						onClick={actions?.onToggleBlock}
-					/>
-					<QuickAction
-						icon={<MailX className="size-3.5" />}
-						label="Unsubscribe"
-						active={flags.unsubscribed}
-						onClick={actions?.onToggleUnsubscribe}
-					/>
 					{actions?.onNotSpam && (
 						<QuickAction
 							icon={<MailCheck className="size-3.5" />}
-							label="Not spam"
+							label={notSpamPending ? "Undoing…" : "Not spam"}
+							active
 							onClick={actions.onNotSpam}
 						/>
 					)}
-					{actions?.onMarkSpam && (
+					{actions?.onReportSpam && (
 						<QuickAction
 							icon={<ShieldX className="size-3.5" />}
-							label="Mark spam"
+							label={reportSpamPending ? "Reporting…" : "Report spam"}
 							danger
-							onClick={actions.onMarkSpam}
+							onClick={actions.onReportSpam}
 						/>
 					)}
+					<QuickAction
+						icon={<MailX className="size-3.5" />}
+						label="Unsubscribe"
+						active={flags.unsubscribed}
+						onClick={actions?.onToggleUnsubscribe}
+					/>
 				</div>
+				{actions?.onNotSpam && (
+					<p className="mt-1.5 text-2xs text-fg-subtle">
+						You reported this message as spam
+					</p>
+				)}
 			</Section>
 
 			{(similarState !== "ready" || similar.length > 0) && (