@remit/ui 0.0.94 → 0.0.96

package/package.json

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

package/src/components/brief-sections.keyboard.test.ts

@@ -5,7 +5,7 @@
 import assert from "node:assert/strict";
 import { after, afterEach, before, beforeEach, describe, it } from "node:test";
 import type { JSDOM } from "jsdom";
-import { act, createElement, useMemo } from "react";
+import { act, createElement } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { LIST_ROW_SELECTOR } from "../lib/roving-focus.js";
 import {
@@ -76,6 +76,7 @@ before(async () => {
 	globalThis.HTMLElement = dom.window.HTMLElement;
 	globalThis.Element = dom.window.Element;
 	globalThis.KeyboardEvent = dom.window.KeyboardEvent;
+	globalThis.MutationObserver = dom.window.MutationObserver;
 	Object.defineProperty(globalThis, "navigator", {
 		value: dom.window.navigator,
 		configurable: true,
@@ -178,16 +179,10 @@ describe("BriefSections arrow-key traversal", () => {
 	});
 });
 
-const orderedIds = sections.flatMap((section) =>
-	section.threads.map((thread) => thread.id),
-);
-
 let list: ListKeyboard | undefined;
 
 function BriefUnderLayer() {
-	const ids = useMemo(() => orderedIds, []);
 	const keyboard = useListKeyboard({
-		orderedIds: ids,
 		isDesktop: true,
 		initialFocusedId: "t1",
 	});

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

@@ -245,9 +245,11 @@ export const SpamActionUnavailable: Story = {
  * 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.
+ * coding standards call the worst outcome. The button is disabled for the
+ * duration: the server dedupes message ids only within a single request, so
+ * a second press mid-flight would fire a second, concurrent request rather
+ * than join the first (issue #648 review). Still visibly a button, never
+ * dead — the "Reporting…" label carries that.
  */
 export const ReportSpamPending: Story = {
 	args: {

package/src/components/intelligence-panel.tsx

@@ -188,10 +188,12 @@ export interface IntelligencePanelProps {
 	 * 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.
+	 * dead button is the worst outcome. Swaps the label to "Reporting…" AND
+	 * disables the button: the server dedupes message ids only within a
+	 * single request, so a second press mid-flight fires a second, concurrent
+	 * request rather than joining the first (issue #648 review — for "Not
+	 * spam" this races the restore move and can surface a spurious
+	 * "try again in a moment" for an undo that already succeeded).
 	 */
 	reportSpamPending?: boolean;
 	/** True while a "Not spam" (undo) press is in flight. Same treatment as `reportSpamPending`. */
@@ -336,17 +338,21 @@ function QuickAction({
 	active,
 	danger,
 	onClick,
+	pending,
 }: {
 	icon: ReactNode;
 	label: string;
 	active?: boolean;
 	danger?: boolean;
 	onClick?: () => void;
+	/** Disable the button without hiding it — a request for this action is already in flight. */
+	pending?: boolean;
 }) {
 	// No handler means the action cannot be serviced yet (the sender's address
 	// record has not resolved). Render it visibly unavailable rather than as a
-	// live button that swallows the click.
-	const disabled = onClick === undefined;
+	// live button that swallows the click. `pending` disables it for the same
+	// reason once a press is in flight.
+	const disabled = onClick === undefined || pending === true;
 	return (
 		<button
 			type="button"
@@ -465,6 +471,7 @@ export function IntelligencePanel({
 							label={notSpamPending ? "Undoing…" : "Not spam"}
 							active
 							onClick={actions.onNotSpam}
+							pending={notSpamPending}
 						/>
 					)}
 					{actions?.onReportSpam && (
@@ -473,6 +480,7 @@ export function IntelligencePanel({
 							label={reportSpamPending ? "Reporting…" : "Report spam"}
 							danger
 							onClick={actions.onReportSpam}
+							pending={reportSpamPending}
 						/>
 					)}
 					<QuickAction

package/src/components/message-list-pane.stories.tsx

@@ -101,8 +101,7 @@ const noKeyboard: MessageListKeyboard = {
  * footer offers what is wired.
  */
 function LiveList({ briefFilters = false }: { briefFilters?: boolean }) {
-	const orderedIds = sections.flatMap((s) => s.threads).map((t) => t.id);
-	const list = useListKeyboard({ orderedIds, isDesktop: true });
+	const list = useListKeyboard({ isDesktop: true });
 	return (
 		<MessageListPane
 			listTitle="Inbox"
@@ -258,9 +257,9 @@ function SelectableList({ isDesktop }: { isDesktop: boolean }) {
 				readIds.has(thread.id) ? { ...thread, isRead: true } : thread,
 			),
 	}));
-	const orderedIds = visible.flatMap((s) => s.threads).map((t) => t.id);
-	const list = useListKeyboard({ orderedIds, isDesktop });
+	const list = useListKeyboard({ isDesktop });
 	const { selection } = list.cursor;
+	const { orderedIds } = list;
 	const allSelected =
 		orderedIds.length > 0 &&
 		orderedIds.every((id) => selection.selectedIds.has(id));

package/src/components/swipeable-row.tsx

@@ -325,6 +325,7 @@ export function SwipeableRow({
 				role={selectionMode ? "checkbox" : undefined}
 				aria-checked={selectionMode ? checked : undefined}
 				data-message-row
+				data-message-id={thread.id}
 				{...gestureProps}
 				className={interactiveClassName}
 				style={interactiveStyle}

package/src/index.ts

@@ -748,6 +748,10 @@ export {
 	type UseLongPressResult,
 	useLongPress,
 } from "./lib/use-long-press.js";
+export {
+	MESSAGE_ROW_SELECTOR,
+	useRenderedRowIds,
+} from "./lib/use-rendered-row-ids.js";
 export {
 	computeRange,
 	deriveIsMultiSelectMode,

package/src/lib/use-list-keyboard.test.ts

@@ -1,8 +1,8 @@
 /**
  * The list's keyboard layer as a host mounts it: the keys reach the cursor from
  * inside the element the layer was given and from nowhere else, the row-click
- * path reads its modifiers the same way, the selection follows the rows it is
- * handed, and the footer offers only the actions the layer registered.
+ * path reads its modifiers the same way, the selection follows the rows on
+ * screen, and the footer offers only the actions the layer registered.
  */
 import assert from "node:assert/strict";
 import { after, afterEach, before, beforeEach, describe, it } from "node:test";
@@ -18,14 +18,32 @@ let container: HTMLElement;
 let root: Root;
 let list: ListKeyboard;
 
-function Harness({ orderedIds }: { orderedIds: string[] }) {
-	list = useListKeyboard({ orderedIds, isDesktop: true });
-	return createElement("section", { id: "pane", ref: list.keyboard.ref });
+function Harness({ rowIds }: { rowIds: string[] }) {
+	list = useListKeyboard({ isDesktop: true });
+	return createElement(
+		"section",
+		{ id: "pane", ref: list.keyboard.ref },
+		...rowIds.map((id) =>
+			createElement("button", {
+				key: id,
+				type: "button",
+				"data-message-id": id,
+			}),
+		),
+	);
 }
 
-const mount = (orderedIds: string[] = ALL_IDS) => {
+const mount = (rowIds: string[] = ALL_IDS) => {
 	act(() => {
-		root.render(createElement(Harness, { orderedIds }));
+		root.render(createElement(Harness, { rowIds }));
+	});
+};
+
+// The layer reads the rendered rows through a MutationObserver, whose callback
+// lands on the microtask queue — an async act flushes both.
+const rerender = async (rowIds: string[]) => {
+	await act(async () => {
+		root.render(createElement(Harness, { rowIds }));
 	});
 };
 
@@ -82,6 +100,7 @@ before(async () => {
 	globalThis.HTMLElement = dom.window.HTMLElement;
 	globalThis.Element = dom.window.Element;
 	globalThis.SVGElement = dom.window.SVGElement;
+	globalThis.MutationObserver = dom.window.MutationObserver;
 	(
 		globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
 	).IS_REACT_ACT_ENVIRONMENT = true;
@@ -159,14 +178,35 @@ describe("useListKeyboard", () => {
 		assert.deepEqual(selected(), []);
 	});
 
-	it("drops the ticked rows that leave the list, and keeps the rest", () => {
+	it("drops the ticked rows that leave the screen, and keeps the rest", async () => {
 		press("a", { metaKey: true });
 		assert.deepEqual(selected(), ALL_IDS);
-		mount(["m1", "m3"]);
+		await rerender(["m1", "m3"]);
 		assert.deepEqual(
 			selected(),
 			["m1", "m3"],
 			"a verb acts on the rows that are still on screen",
 		);
 	});
+
+	it("walks and takes only the rows the pane is rendering", async () => {
+		await rerender(["m1", "m2"]);
+
+		press("a", { metaKey: true });
+		assert.deepEqual(
+			selected(),
+			["m1", "m2"],
+			"⌘A stops at the rows on screen",
+		);
+
+		press("Escape");
+		press("j");
+		press("j");
+		press("j");
+		assert.equal(
+			list.keyboard.focusedId,
+			"m2",
+			"the cursor stops at the last rendered row",
+		);
+	});
 });

package/src/lib/use-list-keyboard.ts

@@ -10,7 +10,10 @@
  *
  * The layer binds its keys to the pane element rather than the window, so a
  * page carrying several lists gives each of them only the keys pressed inside
- * it.
+ * it. It takes the rows it walks from that same element rather than from the
+ * caller's data: a section behind "Show N more", a collapsed header and a
+ * category scope all take rows off the screen without touching the data, and a
+ * cursor or a count built from the data reaches them anyway.
  */
 import { useEffect, useMemo, useState } from "react";
 import type {
@@ -19,11 +22,12 @@ import type {
 } from "../components/app-shell-types.js";
 import type { TriageHandlers } from "./keymap.js";
 import { type ListCursor, useListCursor } from "./use-list-cursor.js";
+import { useRenderedRowIds } from "./use-rendered-row-ids.js";
 import { useTriageKeyboard } from "./use-triage-keyboard.js";
 
+const NO_ROWS: string[] = [];
+
 export interface UseListKeyboardOptions {
-	/** Row ids in display order. */
-	orderedIds: string[];
 	isDesktop: boolean;
 	/** Seeds the cursor — normally the open thread. */
 	initialFocusedId?: string;
@@ -35,6 +39,11 @@ export interface UseListKeyboardOptions {
 
 export interface ListKeyboard {
 	cursor: ListCursor;
+	/**
+	 * The rows the pane is rendering, in display order — what the keys walk,
+	 * what ⌘A takes, and what a select-all checkbox above the list counts.
+	 */
+	orderedIds: string[];
 	/** The pane's `selection` prop. */
 	selection: MessageListSelection;
 	/** The pane's `keyboard` prop. */
@@ -42,13 +51,14 @@ export interface ListKeyboard {
 }
 
 export const useListKeyboard = ({
-	orderedIds,
 	isDesktop,
 	initialFocusedId,
 	initialSelectedIds,
 	enabled = true,
 }: UseListKeyboardOptions): ListKeyboard => {
 	const [pane, setPane] = useState<HTMLElement | null>(null);
+	const renderedIds = useRenderedRowIds(pane);
+	const orderedIds = renderedIds ?? NO_ROWS;
 
 	const cursor = useListCursor({
 		orderedIds,
@@ -70,13 +80,16 @@ export const useListKeyboard = ({
 	};
 	useTriageKeyboard({ handlers, enabled, target: pane });
 
-	// A row that leaves the list — a filter, an account pill, a completed verb —
-	// cannot stay selected, or the count and the verbs act on rows nobody can
-	// see. The same rule the app runs in `ThreadListInteraction`.
+	// A row that leaves the screen — a filter, an account pill, a collapsed
+	// section, a completed verb — cannot stay selected, or the count and the
+	// verbs act on rows nobody can see. The same rule the app runs in
+	// `ThreadListInteraction`. Rows that have not been read yet are not rows that
+	// left, so the seeded selection survives the first render.
 	const { intersectWith } = cursor.selection;
 	useEffect(() => {
-		intersectWith(orderedIds);
-	}, [intersectWith, orderedIds]);
+		if (renderedIds === undefined) return;
+		intersectWith(renderedIds);
+	}, [intersectWith, renderedIds]);
 
 	const { selectedIds, toggle } = cursor.selection;
 	const { handleRowSelect } = cursor;
@@ -91,6 +104,7 @@ export const useListKeyboard = ({
 
 	return {
 		cursor,
+		orderedIds,
 		selection,
 		keyboard: {
 			focusedId: cursor.focusedMessageId,

package/src/lib/use-rendered-row-ids.ts

@@ -0,0 +1,56 @@
+/**
+ * The rows a message list is actually showing, read from the DOM.
+ *
+ * A list narrows itself in ways its data never records: a section caps itself
+ * behind "Show N more", collapses from its own header, or falls out of a
+ * category scope. The ids a consumer hands down are therefore not the ids on
+ * screen, and a cursor or a selection built from them reaches rows nobody can
+ * see. Reading the rendered rows is the one answer that holds for every kind of
+ * narrowing, wherever it happens.
+ */
+import { useCallback, useEffect, useState } from "react";
+
+/** The marker a row carries the id the cursor and the selection know it by. */
+export const MESSAGE_ROW_SELECTOR = "[data-message-id]";
+
+const readRowIds = (container: HTMLElement): string[] =>
+	Array.from(container.querySelectorAll<HTMLElement>(MESSAGE_ROW_SELECTOR))
+		.map((row) => row.dataset.messageId)
+		.filter((id): id is string => id !== undefined);
+
+const sameIds = (a: string[], b: string[]): boolean =>
+	a.length === b.length && a.every((id, index) => id === b[index]);
+
+/**
+ * The ids of the rows inside `container`, in document order, kept in step with
+ * what it renders. `undefined` until a container has been read — a list whose
+ * rows have not been counted yet is a different answer from a list with no
+ * rows, and only the second one may empty a selection.
+ *
+ */
+export function useRenderedRowIds(
+	container: HTMLElement | null,
+): string[] | undefined {
+	const [rowIds, setRowIds] = useState<string[] | undefined>(undefined);
+
+	const sync = useCallback(() => {
+		if (!container) return;
+		const next = readRowIds(container);
+		setRowIds((prev) => (prev && sameIds(prev, next) ? prev : next));
+	}, [container]);
+
+	// Rows this render moved — a chip, an account pill, a completed verb — are in
+	// the DOM by the time the commit's effects run.
+	useEffect(sync);
+
+	// Rows a section moves on its own — "Show N more", a collapsing header — never
+	// reach this render at all, so nothing but the DOM reports them.
+	useEffect(() => {
+		if (!container) return;
+		const observer = new MutationObserver(sync);
+		observer.observe(container, { childList: true, subtree: true });
+		return () => observer.disconnect();
+	}, [container, sync]);
+
+	return rowIds;
+}