@remit/ui 0.0.92 → 0.0.93

package/package.json

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

package/src/components/app-shell-types.ts

@@ -104,6 +104,21 @@ export interface MessageListKeyboard {
 	ref: (element: HTMLElement | null) => void;
 }
 
+/**
+ * Whether a layer answers the cursor keys, and so walks the rows itself. A list
+ * under one stands its own roving-focus group down: both own the arrows, and
+ * the group stops the press before the layer above hears it.
+ */
+export function keyboardWalksRows(
+	keyboard: MessageListKeyboard | undefined,
+): keyboard is MessageListKeyboard {
+	if (keyboard === undefined) return false;
+	return (
+		keyboard.handlers.focusNext !== undefined &&
+		keyboard.handlers.focusPrevious !== undefined
+	);
+}
+
 /**
  * Measures an element's OWN width via ResizeObserver — a container query, not a
  * viewport one. The shell reflows by the space it actually occupies (so it works

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

@@ -5,9 +5,13 @@
 import assert from "node:assert/strict";
 import { after, afterEach, before, beforeEach, describe, it } from "node:test";
 import type { JSDOM } from "jsdom";
-import { act, createElement } from "react";
+import { act, createElement, useMemo } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { LIST_ROW_SELECTOR } from "../lib/roving-focus.js";
+import {
+	type ListKeyboard,
+	useListKeyboard,
+} from "../lib/use-list-keyboard.js";
 import type { ThreadSection } from "./app-shell-types.js";
 import { BriefSections } from "./brief-sections.js";
 import { ComfortableRow } from "./message-row.js";
@@ -99,9 +103,9 @@ afterEach(() => {
 	});
 });
 
-function pressKey(target: Element, key: string) {
+function pressKey(target: Element, key: string, shiftKey = false) {
 	target.dispatchEvent(
-		new dom.window.KeyboardEvent("keydown", { key, bubbles: true }),
+		new dom.window.KeyboardEvent("keydown", { key, bubbles: true, shiftKey }),
 	);
 }
 
@@ -173,3 +177,87 @@ describe("BriefSections arrow-key traversal", () => {
 		assert.equal(dom.window.document.activeElement, items[2]);
 	});
 });
+
+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",
+	});
+	list = keyboard;
+	return createElement(
+		"div",
+		{ ref: keyboard.keyboard.ref, tabIndex: -1 },
+		createElement(BriefSections, {
+			sections,
+			Row: ComfortableRow,
+			keyboard: keyboard.keyboard,
+			onSelectThread: () => undefined,
+			onSelectBriefCategory: () => undefined,
+		}),
+	);
+}
+
+function mountUnderLayer() {
+	act(() => {
+		root.render(createElement(BriefUnderLayer));
+	});
+}
+
+function selectedIds(): string[] {
+	return Array.from(list?.selection.selectedIds ?? []).sort();
+}
+
+describe("BriefSections under a keyboard layer", () => {
+	it("Shift+ArrowDown extends the selection down the rows", () => {
+		mountUnderLayer();
+		const items = rows();
+
+		act(() => items[0]?.focus());
+		act(() => pressKey(items[0] as Element, "ArrowDown", true));
+		act(() => pressKey(items[0] as Element, "ArrowDown", true));
+
+		assert.deepEqual(selectedIds(), ["t2", "t3"]);
+	});
+
+	it("Shift+ArrowUp extends the selection back up the rows", () => {
+		mountUnderLayer();
+		const items = rows();
+
+		act(() => items[0]?.focus());
+		act(() => pressKey(items[0] as Element, "ArrowDown"));
+		act(() => pressKey(items[0] as Element, "ArrowDown"));
+		act(() => pressKey(items[0] as Element, "ArrowUp", true));
+		act(() => pressKey(items[0] as Element, "ArrowUp", true));
+
+		assert.deepEqual(selectedIds(), ["t1", "t2"]);
+	});
+
+	it("Shift+ArrowDown selects the rows Shift+J does", () => {
+		mountUnderLayer();
+		const items = rows();
+
+		act(() => items[0]?.focus());
+		act(() => pressKey(items[0] as Element, "j", true));
+		act(() => pressKey(items[0] as Element, "j", true));
+
+		assert.deepEqual(selectedIds(), ["t2", "t3"]);
+	});
+
+	it("hands the bare arrows to the layer instead of walking the rows itself", () => {
+		mountUnderLayer();
+		const items = rows();
+
+		act(() => items[0]?.focus());
+		act(() => pressKey(items[0] as Element, "ArrowDown"));
+
+		assert.equal(list?.cursor.focusedMessageId, "t2");
+	});
+});

package/src/components/brief-sections.tsx

@@ -2,10 +2,15 @@ import { useRef, useState } from "react";
 import { LIST_ROW_SELECTOR, useRovingFocus } from "../lib/roving-focus.js";
 import type {
 	BriefCategoryFilter,
+	MessageListKeyboard,
 	ThreadRowData,
 	ThreadSection,
 } from "./app-shell-types.js";
-import { briefCategories, categoryTone } from "./app-shell-types.js";
+import {
+	briefCategories,
+	categoryTone,
+	keyboardWalksRows,
+} from "./app-shell-types.js";
 import { BriefSection } from "./brief-section.js";
 import {
 	FilterSheet,
@@ -135,6 +140,13 @@ interface BriefSectionsBaseProps
 	sections: ThreadSection[];
 	selectedThreadId?: string;
 	Row: BriefRowComponent;
+	/**
+	 * The keyboard layer walking the rows, when the caller mounts one. The rows
+	 * hand it the cursor keys rather than traversing with a roving group of their
+	 * own, so the ring and the cursor name one row and a Shift+arrow range
+	 * reaches the layer that extends it.
+	 */
+	keyboard?: MessageListKeyboard;
 	onSelectThread?: (id: string) => void;
 	/**
 	 * Drop the filter row and its panel, keeping the rows where they are. See
@@ -160,6 +172,7 @@ export function BriefSections({
 	briefCategory = "all",
 	selectedThreadId,
 	Row,
+	keyboard,
 	onSelectThread,
 	onSelectBriefCategory,
 	sources,
@@ -179,6 +192,7 @@ export function BriefSections({
 	useRovingFocus({
 		containerRef: listRef,
 		itemSelector: LIST_ROW_SELECTOR,
+		enabled: !keyboardWalksRows(keyboard),
 	});
 
 	const active = activeFilters ?? ownFilters;

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

@@ -4,11 +4,12 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { defaultKeyboardHints, keyboardHintsFor } from "../lib/keymap.js";
 import { LIST_ROW_SELECTOR, useRovingFocus } from "../lib/roving-focus.js";
 import { deriveIsMultiSelectMode, modifiersOf } from "../lib/use-selection.js";
-import type {
-	AppShellProps,
-	MessageListKeyboard,
-	MessageListSelection,
-	TouchSeed,
+import {
+	type AppShellProps,
+	keyboardWalksRows,
+	type MessageListKeyboard,
+	type MessageListSelection,
+	type TouchSeed,
 } from "./app-shell-types.js";
 import { type BriefFilterSurface, BriefSections } from "./brief-sections.js";
 import { Button } from "./button.js";
@@ -149,10 +150,7 @@ export function MessageListPane({
 	// The layer answers the arrows only if it registered them. Anything else it
 	// hands over — a layer with no cursor keys, or no layer at all — leaves the
 	// rows their own traversal and their own single tab stop.
-	const walksRows =
-		keyboard !== undefined &&
-		keyboard.handlers.focusNext !== undefined &&
-		keyboard.handlers.focusPrevious !== undefined;
+	const walksRows = keyboardWalksRows(keyboard);
 	useRovingFocus({
 		containerRef: flatListRef,
 		itemSelector: LIST_ROW_SELECTOR,
@@ -327,6 +325,7 @@ export function MessageListPane({
 					sections={sections}
 					selectedThreadId={selectedThreadId}
 					Row={BriefRow}
+					keyboard={keyboard}
 					onSelectThread={onSelectThread}
 				/>
 			) : listBody != null ? (

package/src/lib/roving-focus.test.ts

@@ -93,9 +93,9 @@ afterEach(() => {
 	});
 });
 
-function pressKey(target: Element, key: string) {
+function pressKey(target: Element, key: string, shiftKey = false) {
 	target.dispatchEvent(
-		new dom.window.KeyboardEvent("keydown", { key, bubbles: true }),
+		new dom.window.KeyboardEvent("keydown", { key, bubbles: true, shiftKey }),
 	);
 }
 
@@ -222,6 +222,23 @@ describe("useRovingFocus", () => {
 		assert.equal(dom.window.document.activeElement, rows()[0]);
 	});
 
+	it("leaves Shift+Arrow to the layer above instead of moving the cursor", () => {
+		mount({ count: 3 });
+		let seen = 0;
+		const spy = () => {
+			seen += 1;
+		};
+		dom.window.addEventListener("keydown", spy);
+		const items = rows();
+		act(() => items[0]?.focus());
+		act(() => pressKey(items[0] as Element, "ArrowDown", true));
+		act(() => pressKey(items[0] as Element, "ArrowUp", true));
+		dom.window.removeEventListener("keydown", spy);
+
+		assert.equal(dom.window.document.activeElement, items[0]);
+		assert.equal(seen, 2);
+	});
+
 	it("keeps a handled key from reaching a window-level listener", () => {
 		mount({ count: 3 });
 		let seen = 0;

package/src/lib/roving-focus.ts

@@ -69,7 +69,8 @@ function rovingItems(
  * consumer-supplied row component, so neither has a flat array to index into.
  *
  * A handled key stops propagating, so a window-level keyboard layer above the
- * group does not act on the same press.
+ * group does not act on the same press. Only the bare keys are handled — a
+ * modified arrow is a different binding, and it belongs to that layer.
  */
 export function useRovingFocus({
 	containerRef,
@@ -95,6 +96,11 @@ export function useRovingFocus({
 		};
 
 		const onKeyDown = (event: KeyboardEvent) => {
+			// Shift+Arrow extends a selection; the group traverses on the bare key
+			// and leaves every modified stroke to the layer that binds it.
+			if (event.shiftKey || event.metaKey || event.ctrlKey || event.altKey) {
+				return;
+			}
 			const items = rovingItems(container, itemSelector);
 			const currentIndex = items.indexOf(document.activeElement as HTMLElement);
 			const nextIndex = rovingNextIndex(