@devries-cameron20 / t3code Mirror · read-only / commits / facd190640
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 23:30 UTC

fix(web): opening the terminal with Cmd+J no longer re-renders the whole sidebar (#33129)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Nov 10, 2026 at 19:16 UTC facd190640235da44be84c86037694f1442ae63e
8 files changed +401 -120
apps/web/src/components/Sidebar.browser.test.tsx
+107 -3
@@ -1,18 +1,43 @@
1 -import { DEFAULT_CLIENT_SETTINGS, EnvironmentId, ProjectId } from "@t3tools/contracts";
1 +import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
2 +import {
3 + DEFAULT_CLIENT_SETTINGS,
4 + EnvironmentId,
5 + ProjectId,
6 + ThreadId,
7 + type ScopedThreadRef,
8 +} from "@t3tools/contracts";
9 +import { isMacPlatform } from "@t3tools/shared/keybindings";
10 import { describe, expect, it, vi } from "vite-plus/test";
11 import { userEvent } from "vite-plus/test/browser";
12
5 -import { render } from "../../test/render";
13 +import { act, fakeTimers, render } from "../../test/render";
14 import { openCommandPalette } from "../commandPaletteBus";
15 +import { makeThreadFixture } from "../test-fixtures";
16 import { useHandleNewThread } from "../hooks/useHandleNewThread";
17 import { __setClientSettingsForTests, getClientSettings } from "../hooks/useSettings";
9 -import { useProjects } from "../state/entities";
18 +import { useThreadRouteTarget } from "../hooks/useThreadRouteTarget";
19 +import { useProjects, useQuietThreadShells } from "../state/entities";
20 +import { useTerminalUiStateStore } from "../terminalUiStateStore";
21 import type { Project } from "../types";
22 import Sidebar from "./Sidebar";
23 +import { THREAD_JUMP_HINT_SHOW_DELAY_MS } from "./Sidebar.logic";
24 +import { SortableThreadRow } from "./sidebar/SidebarThreadRow";
25 import { SidebarProvider } from "./ui/sidebar";
26
27 vi.mock("../state/entities", { spy: true });
28 vi.mock("../hooks/useHandleNewThread", { spy: true });
29 +vi.mock("../hooks/useThreadRouteTarget", { spy: true });
30 +vi.mock("./sidebar/SidebarThreadRow", { spy: true });
31 +vi.mock(import("../state/server"), async (original) => {
32 + const { Atom } = await import("effect/reactivity");
33 + const { compileResolvedKeybindingsConfig } = await import("@t3tools/shared/keybindings");
34 + // The desktop defaults: holding Mod alone already matches a thread jump.
35 + const keybindings = compileResolvedKeybindingsConfig([
36 + { key: "mod+1", command: "thread.jump.1" },
37 + { key: "mod+2", command: "thread.jump.2" },
38 + ]);
39 + return { ...(await original()), primaryServerKeybindingsAtom: Atom.make(keybindings) };
40 +});
41 vi.mock("../commandPaletteBus", () => ({
42 openCommandPalette: vi.fn(),
43 isCommandPaletteOpen: () => false,
@@ -86,3 +111,82 @@ describe("sidebar header new thread", () => {
111 }
112 });
113 });
114 +
115 +function threadShell(projectId: ProjectId, index: number): EnvironmentThreadShell {
116 + return makeThreadFixture({
117 + environmentId: EnvironmentId.make("local"),
118 + id: ThreadId.make(`thread-${index}`),
119 + projectId,
120 + title: `Thread ${index}`,
121 + });
122 +}
123 +
124 +describe("sidebar render isolation", () => {
125 + // regression: #33100 Cmd+J re-rendered every sidebar row, which took hundreds of ms with many threads
126 + it("does not re-render thread rows when a quick Mod shortcut opens and focuses the terminal", async () => {
127 + using stack = new DisposableStack();
128 + const activeProject = project("active");
129 + const threads = Array.from({ length: 5 }, (_, index) => threadShell(activeProject.id, index));
130 + const routeThreadRef: ScopedThreadRef = {
131 + environmentId: activeProject.environmentId,
132 + threadId: threads[0]!.id,
133 + };
134 + vi.mocked(useProjects).mockReturnValue([activeProject]);
135 + vi.mocked(useQuietThreadShells).mockReturnValue(threads);
136 + vi.mocked(useThreadRouteTarget).mockReturnValue({ kind: "server", threadRef: routeThreadRef });
137 + vi.mocked(useHandleNewThread).mockReturnValue({
138 + activeDraftThread: null,
139 + activeThread: null,
140 + defaultProjectRef: {
141 + environmentId: activeProject.environmentId,
142 + projectId: activeProject.id,
143 + },
144 + defaultProjectFallbackReady: true,
145 + handleNewThread: vi.fn().mockResolvedValue(null),
146 + routeDraftId: null,
147 + routeThreadRef,
148 + });
149 + const terminal = document.createElement("div");
150 + terminal.dataset.terminalOwner = "drawer";
151 + const terminalInput = document.createElement("textarea");
152 + terminal.append(terminalInput);
153 + document.body.append(terminal);
154 + stack.defer(() => terminal.remove());
155 + stack.defer(() => useTerminalUiStateStore.getState().setTerminalOpen(routeThreadRef, false));
156 + await using screen = await render(
157 + <SidebarProvider>
158 + <Sidebar routeReveal={{ observedKey: null, pendingKey: null }} />
159 + </SidebarProvider>,
160 + );
161 + await expect.element(screen.getByText("Thread 4").first()).toBeInTheDocument();
162 + const rowRenders = () => vi.mocked(SortableThreadRow).mock.calls.length;
163 +
164 + using _timers = fakeTimers();
165 + const modifier = isMacPlatform(navigator.platform) ? "Meta" : "Control";
166 + const beforeShortcut = rowRenders();
167 + await userEvent.keyboard(`{${modifier}>}`);
168 + await act(() => useTerminalUiStateStore.getState().setTerminalOpen(routeThreadRef, true));
169 + await act(() => terminalInput.focus());
170 + await userEvent.keyboard(`{/${modifier}}`);
171 + await act(() => terminalInput.blur());
172 + expect(
173 + rowRenders() - beforeShortcut,
174 + "thread rows re-rendered while opening the terminal with a quick Mod shortcut",
175 + ).toBe(0);
176 +
177 + const jumpLabelsSince = (start: number) =>
178 + vi
179 + .mocked(SortableThreadRow)
180 + .mock.calls.slice(start)
181 + .map(([props]) => props.jumpLabel)
182 + .filter((label) => label !== null);
183 + const beforeHold = rowRenders();
184 + await userEvent.keyboard(`{${modifier}>}`);
185 + await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS));
186 + expect(jumpLabelsSince(beforeHold), "holding Mod showed no jump hints").toHaveLength(2);
187 + const beforeRelease = rowRenders();
188 + await userEvent.keyboard(`{/${modifier}}`);
189 + expect(rowRenders()).toBeGreaterThan(beforeRelease);
190 + expect(jumpLabelsSince(beforeRelease)).toEqual([]);
191 + });
192 +});
apps/web/src/components/Sidebar.logic.browser.test.tsx
+111 -15
@@ -1,7 +1,16 @@
1 +import { EnvironmentId, ThreadId, type ResolvedKeybindingsConfig } from "@t3tools/contracts";
2 +import { compileResolvedKeybindingsConfig, isMacPlatform } from "@t3tools/shared/keybindings";
3 import { describe, expect, it, vi } from "vite-plus/test";
4 +import { userEvent } from "vite-plus/test/browser";
5
6 import { act, fakeTimers, render } from "../../test/render";
4 -import { useSnoozeWakeClock, useThreadJumpHintsVisible } from "./Sidebar.logic";
7 +import { registerModelPickerContent } from "../modelPickerVisibility";
8 +import { useTerminalUiStateStore } from "../terminalUiStateStore";
9 +import {
10 + THREAD_JUMP_HINT_SHOW_DELAY_MS,
11 + useSnoozeWakeClock,
12 + useThreadJumpHintsVisible,
13 +} from "./Sidebar.logic";
14
15 const MOUNTED_AT_MS = Date.parse("2026-10-24T08:00:00.000Z");
16
@@ -32,28 +41,115 @@ describe("useSnoozeWakeClock", () => {
41 });
42 });
43
35 -function JumpHints(props: { readonly held: boolean }) {
36 - return <output>{useThreadJumpHintsVisible(props.held) ? "shown" : "hidden"}</output>;
44 +const ROUTE_THREAD_REF = {
45 + environmentId: EnvironmentId.make("local"),
46 + threadId: ThreadId.make("thread-1"),
47 +};
48 +
49 +function JumpHints(props: { readonly keybindings: ResolvedKeybindingsConfig }) {
50 + const shown = useThreadJumpHintsVisible(props.keybindings, ROUTE_THREAD_REF);
51 + return <output>{shown ? "shown" : "hidden"}</output>;
52 }
53
54 describe("useThreadJumpHintsVisible", () => {
55 it("waits for the delay again on a second hold", async () => {
41 - // The first render reads the clock.
42 - using _timers = fakeTimers({ now: 0 });
43 - await using screen = await render(<JumpHints held />, {
56 + const keybindings = compileResolvedKeybindingsConfig([
57 + { key: "mod+1", command: "thread.jump.1" },
58 + ]);
59 + const modifier = isMacPlatform(navigator.platform) ? "Meta" : "Control";
60 + await using screen = await render(<JumpHints keybindings={keybindings} />, {
61 // A bare hook host; nothing here links or navigates.
62 router: false,
63 });
47 - await act(() => vi.advanceTimersByTime(1_000));
48 - await expect.element(screen.getByRole("status")).toHaveTextContent("shown");
64 + using _timers = fakeTimers();
65 + const output = screen.getByRole("status");
66 +
67 + await userEvent.keyboard(`{${modifier}>}`);
68 + await expect.element(output).toHaveTextContent("hidden");
69 + await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS));
70 + await expect.element(output).toHaveTextContent("shown");
71 +
72 + await userEvent.keyboard(`{/${modifier}}`);
73 + await expect.element(output).toHaveTextContent("hidden");
74 + await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS));
75 +
76 + await userEvent.keyboard(`{${modifier}>}`);
77 + await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS - 1));
78 + await expect.element(output).toHaveTextContent("hidden");
79 + await act(() => vi.advanceTimersByTime(1));
80 + await expect.element(output).toHaveTextContent("shown");
81 + await userEvent.keyboard(`{/${modifier}}`);
82 + });
83 +
84 + it("follows terminal focus and the route thread's terminal while the modifier is held", async () => {
85 + using stack = new DisposableStack();
86 + const terminal = document.createElement("div");
87 + terminal.dataset.terminalOwner = "drawer";
88 + const terminalInput = document.createElement("textarea");
89 + terminal.append(terminalInput);
90 + document.body.append(terminal);
91 + stack.defer(() => terminal.remove());
92 + stack.defer(() => useTerminalUiStateStore.getState().setTerminalOpen(ROUTE_THREAD_REF, false));
93 + const keybindings = compileResolvedKeybindingsConfig([
94 + { key: "mod+1", command: "thread.jump.1", when: "terminalOpen" },
95 + ]);
96 + const modifier = isMacPlatform(navigator.platform) ? "Meta" : "Control";
97 + await using screen = await render(<JumpHints keybindings={keybindings} />, {
98 + // A bare hook host; nothing here links or navigates.
99 + router: false,
100 + });
101 + using _timers = fakeTimers();
102 + const output = screen.getByRole("status");
103 +
104 + await userEvent.keyboard(`{${modifier}>}`);
105 + await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS));
106 + await expect.element(output).toHaveTextContent("hidden");
107 + await act(() => useTerminalUiStateStore.getState().setTerminalOpen(ROUTE_THREAD_REF, true));
108 + await expect.element(output).toHaveTextContent("shown");
109 + await act(() => terminalInput.focus());
110 + await expect.element(output).toHaveTextContent("hidden");
111 + await act(() => terminalInput.blur());
112 + await expect.element(output).toHaveTextContent("shown");
113 + await userEvent.keyboard(`{/${modifier}}`);
114 + await expect.element(output).toHaveTextContent("hidden");
115 + });
116
50 - await screen.rerender(<JumpHints held={false} />);
51 - await expect.element(screen.getByRole("status")).toHaveTextContent("hidden");
52 - await act(() => vi.advanceTimersByTime(1_000));
117 + it("returns when the model picker closes while the modifier is still held", async () => {
118 + const keybindings = compileResolvedKeybindingsConfig([
119 + { key: "mod+1", command: "thread.jump.1", when: "!modelPickerOpen" },
120 + ]);
121 + const modifier = isMacPlatform(navigator.platform) ? "Meta" : "Control";
122 + await using screen = await render(<JumpHints keybindings={keybindings} />, {
123 + // A bare hook host; nothing here links or navigates.
124 + router: false,
125 + });
126 + using _timers = fakeTimers();
127 + const output = screen.getByRole("status");
128 +
129 + await userEvent.keyboard(`{${modifier}>}`);
130 + await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS));
131 + await expect.element(output).toHaveTextContent("shown");
132 + let unregisterModelPicker = () => {};
133 + await act(() => {
134 + unregisterModelPicker = registerModelPickerContent();
135 + });
136 + await expect.element(output).toHaveTextContent("hidden");
137 + await act(() => unregisterModelPicker());
138 + await expect.element(output).toHaveTextContent("shown");
139 + await userEvent.keyboard(`{/${modifier}}`);
140 + });
141 +
142 + it("shows after the delay for a jump binding without a modifier", async () => {
143 + const keybindings = compileResolvedKeybindingsConfig([{ key: "f1", command: "thread.jump.1" }]);
144 + // Mounting starts the hold delay.
145 + using _timers = fakeTimers();
146 + await using screen = await render(<JumpHints keybindings={keybindings} />, {
147 + // A bare hook host; nothing here links or navigates.
148 + router: false,
149 + });
150 + const output = screen.getByRole("status");
151
54 - await screen.rerender(<JumpHints held />);
55 - await expect.element(screen.getByRole("status")).toHaveTextContent("hidden");
56 - await act(() => vi.advanceTimersByTime(1_000));
57 - await expect.element(screen.getByRole("status")).toHaveTextContent("shown");
152 + await act(() => vi.advanceTimersByTime(THREAD_JUMP_HINT_SHOW_DELAY_MS));
153 + await expect.element(output).toHaveTextContent("shown");
154 });
155 });
apps/web/src/components/Sidebar.logic.ts
+104 -11
@@ -20,6 +20,8 @@ import {
20 isListedThreadLineage,
21 type ContextMenuItem,
22 type EnvironmentId,
23 + type ResolvedKeybindingsConfig,
24 + type ScopedThreadRef,
25 type ThreadId,
26 } from "@t3tools/contracts";
27 import type { SidebarProjectSortOrder, SidebarThreadSortOrder } from "@t3tools/contracts/settings";
@@ -39,9 +41,17 @@ import type { SidebarThreadSummary, Thread } from "../types";
41 import { normalizeSearchText } from "../lib/utils";
42 import { isLatestRunSettled } from "../session-logic";
43 import { observeIntersection } from "../lib/observeIntersection";
42 -import { deadlineAfter, deadlineStore } from "@t3tools/client-runtime/clock";
44 +import { deadlineAfter, deadlineStore, type ClockStore } from "@t3tools/client-runtime/clock";
45 import { useDeadlinePassed } from "../hooks/useDeadline";
46 import { legacyProjectCwdPreferenceKey } from "../uiStateStore";
47 +import { isElectron } from "../env";
48 +import { shouldShowThreadJumpHintsForModifiers } from "../keybindings";
49 +import { isTerminalFocused, subscribeToTerminalFocusChanges } from "../lib/terminalFocus";
50 +import { isPreviewFocused } from "../lib/previewFocus";
51 +import { isModelPickerOpen, subscribeToModelPickerVisibility } from "../modelPickerVisibility";
52 +import { shortcutModifierStore } from "../shortcutModifierState";
53 +import { selectThreadTerminalUiState, useTerminalUiStateStore } from "../terminalUiStateStore";
54 +import { selectActiveRightPanel, useRightPanelStore } from "../rightPanelStore";
55
56 export function shouldNavigateAfterThreadPark(input: {
57 readonly threadKey: string;
@@ -59,7 +69,7 @@ export function shouldNavigateAfterThreadPark(input: {
69 );
70 }
71
62 -const THREAD_JUMP_HINT_SHOW_DELAY_MS = 200;
72 +export const THREAD_JUMP_HINT_SHOW_DELAY_MS = 200;
73
74 export function resolveSidebarRowAccessibility(input: {
75 readonly title: string;
@@ -670,19 +680,102 @@ type ThreadStatusInput = Pick<
680 blockedOnThreadWait?: boolean | undefined;
681 };
682
683 +// Read at event time: subscribing Sidebar to terminal or modifier state re-renders every row.
684 +export function threadShortcutContext(routeThreadRef: ScopedThreadRef | null) {
685 + return {
686 + terminalFocus: isTerminalFocused(),
687 + terminalOpen:
688 + routeThreadRef !== null &&
689 + selectThreadTerminalUiState(
690 + useTerminalUiStateStore.getState().terminalUiStateByThreadKey,
691 + routeThreadRef,
692 + ).terminalOpen,
693 + previewFocus: isPreviewFocused(),
694 + previewOpen:
695 + selectActiveRightPanel(useRightPanelStore.getState().byThreadKey, routeThreadRef) ===
696 + "preview",
697 + modelPickerOpen: isModelPickerOpen(),
698 + isWeb: !isElectron,
699 + isDesktop: isElectron,
700 + };
701 +}
702 +
703 +/** Whether the current modifier combination, including none, has been held unchanged for `delayMs`. */
704 +function createModifierHoldStore(delayMs: number): ClockStore<boolean> {
705 + const listeners = new Set<() => void>();
706 + let held = false;
707 + let stopDeadline = () => {};
708 + let stopModifiers: (() => void) | null = null;
709 +
710 + const setHeld = (next: boolean) => {
711 + if (held === next) return;
712 + held = next;
713 + for (const listener of listeners) listener();
714 + };
715 + const onModifiersChange = () => {
716 + stopDeadline();
717 + const deadline = deadlineStore(deadlineAfter(delayMs));
718 + stopDeadline = deadline.subscribe(() => setHeld(true));
719 + // A deadline another subscriber already passed never notifies a late joiner.
720 + setHeld(deadline.getSnapshot());
721 + };
722 +
723 + return {
724 + subscribe: (listener) => {
725 + listeners.add(listener);
726 + if (stopModifiers === null) {
727 + stopModifiers = shortcutModifierStore.subscribe(onModifiersChange);
728 + onModifiersChange();
729 + }
730 + return () => {
731 + listeners.delete(listener);
732 + if (listeners.size > 0) return;
733 + stopModifiers?.();
734 + stopModifiers = null;
735 + stopDeadline();
736 + stopDeadline = () => {};
737 + held = false;
738 + };
739 + },
740 + getSnapshot: () => held,
741 + };
742 +}
743 +
744 +const threadJumpModifierHold = createModifierHoldStore(THREAD_JUMP_HINT_SHOW_DELAY_MS);
745 +
746 +function subscribeToThreadJumpHintInputs(listener: () => void): () => void {
747 + const unsubscribeHold = threadJumpModifierHold.subscribe(listener);
748 + const unsubscribeFocus = subscribeToTerminalFocusChanges(listener);
749 + const unsubscribeTerminals = useTerminalUiStateStore.subscribe(listener);
750 + const unsubscribeRightPanels = useRightPanelStore.subscribe(listener);
751 + const unsubscribeModelPicker = subscribeToModelPickerVisibility(listener);
752 + return () => {
753 + unsubscribeHold();
754 + unsubscribeFocus();
755 + unsubscribeTerminals();
756 + unsubscribeRightPanels();
757 + unsubscribeModelPicker();
758 + };
759 +}
760 +
761 /**
762 * Thread jump hints appear once the jump modifier has been held for a moment,
763 * so a quick shortcut never flashes them, and hide as soon as it is released.
764 + * The snapshot is the visibility itself, so a quick shortcut never re-renders the caller.
765 */
677 -export function useThreadJumpHintsVisible(shouldShow: boolean): boolean {
678 - const [showAt, setShowAt] = React.useState<number | null>(null);
679 - // The clock is read inside the updater: the compiler caches a bare clock read
680 - // in render once per instance, so a second hold would reuse the first deadline.
681 - // React discards this render and re-runs with the update.
682 - if (shouldShow !== (showAt !== null)) {
683 - setShowAt(shouldShow ? () => deadlineAfter(THREAD_JUMP_HINT_SHOW_DELAY_MS) : null);
684 - }
685 - return useDeadlinePassed(showAt);
766 +export function useThreadJumpHintsVisible(
767 + keybindings: ResolvedKeybindingsConfig,
768 + routeThreadRef: ScopedThreadRef | null,
769 +): boolean {
770 + return React.useSyncExternalStore(
771 + subscribeToThreadJumpHintInputs,
772 + () =>
773 + threadJumpModifierHold.getSnapshot() &&
774 + shouldShowThreadJumpHintsForModifiers(shortcutModifierStore.getSnapshot(), keybindings, {
775 + platform: navigator.platform,
776 + context: threadShortcutContext(routeThreadRef),
777 + }),
778 + );
779 }
780
781 export function resolveThreadLastVisitedAt(
apps/web/src/components/Sidebar.tsx
+4 -45
@@ -91,17 +91,11 @@ import { isElectron } from "../env";
91 import {
92 resolveShortcutCommand,
93 shortcutLabelForCommand,
94 - shouldShowThreadJumpHintsForModifiers,
94 threadJumpCommandForIndex,
95 threadJumpIndexFromCommand,
96 threadTraversalDirectionFromCommand,
97 } from "../keybindings";
99 -import { useShortcutModifierState } from "../shortcutModifierState";
100 -import { isTerminalFocused } from "../lib/terminalFocus";
101 -import { isPreviewFocused } from "../lib/previewFocus";
98 import { isModelPickerOpen } from "../modelPickerVisibility";
103 -import { selectThreadTerminalUiState, useTerminalUiStateStore } from "../terminalUiStateStore";
104 -import { selectActiveRightPanel, useRightPanelStore } from "../rightPanelStore";
99 import { isMacPlatform } from "~/lib/utils";
100 import { readLocalApi } from "../localApi";
101 import { configuredHostedAppUrl } from "../hostedPairing";
@@ -130,7 +124,6 @@ import { useHandleNewThread } from "../hooks/useHandleNewThread";
124 import { useOrderWhileOpen } from "../hooks/useOrderWhileOpen";
125 import { useProjectPin } from "../hooks/useProjectGroupUpdate";
126 import { useSidebarProjectGroups } from "../hooks/useSidebarProjectGroups";
133 -import { useTerminalFocus } from "../hooks/useTerminalFocus";
127 import { isCommandPaletteOpen, openCommandPalette } from "../commandPaletteBus";
128 import { registerSettleAndAdvance } from "../settleAndAdvance";
129 import { startNewThreadFromContext } from "../lib/chatThreadActions";
@@ -209,6 +202,7 @@ import {
202 sortThreadsForSidebar,
203 sortWorkingThreadsBySend,
204 useSnoozeWakeClock,
205 + threadShortcutContext,
206 useThreadJumpHintsVisible,
207 type SidebarListItem,
208 type SidebarSection,
@@ -1063,8 +1057,6 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
1057 } | null>(null);
1058 const snoozingThreadKeysRef = useRef(new Set<string>());
1059 const removeFromSelection = useThreadSelectionStore((s) => s.removeFromSelection);
1066 - const shortcutModifiers = useShortcutModifierState();
1067 - const terminalFocused = useTerminalFocus();
1060 const openAddProjectCommandPalette = () => openCommandPalette({ open: "add-project" });
1061 const routeThreadRef = resolveActiveThreadRouteRef(routeTarget, routeDraftThread);
1062 const routeThreadKey = routeThreadRef ? scopedThreadKey(routeThreadRef) : null;
@@ -2879,14 +2871,6 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
2871 },
2872 );
2873
2882 - const routeTerminalOpen = useTerminalUiStateStore((state) =>
2883 - routeThreadRef
2884 - ? selectThreadTerminalUiState(state.terminalUiStateByThreadKey, routeThreadRef).terminalOpen
2885 - : false,
2886 - );
2887 - const routePreviewOpen = useRightPanelStore(
2888 - (state) => selectActiveRightPanel(state.byThreadKey, routeThreadRef) === "preview",
2889 - );
2874 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- subscribes to window keydown for thread navigation shortcuts using the current thread list
2875 useEffect(() => {
2876 const onWindowKeyDown = (event: KeyboardEvent) => {
@@ -2895,15 +2879,7 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
2879 }
2880 const command = resolveShortcutCommand(event, keybindings, {
2881 platform: navigator.platform,
2898 - context: {
2899 - terminalFocus: isTerminalFocused(),
2900 - terminalOpen: routeTerminalOpen,
2901 - previewFocus: isPreviewFocused(),
2902 - previewOpen: routePreviewOpen,
2903 - modelPickerOpen: isModelPickerOpen(),
2904 - isWeb: !isElectron,
2905 - isDesktop: isElectron,
2906 - },
2882 + context: threadShortcutContext(routeThreadRef),
2883 });
2884 const navigateToThreadKey = (targetThreadKey: string | null) => {
2885 if (!targetThreadKey) return false;
@@ -2935,29 +2911,12 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
2911 keybindings,
2912 navigateToThread,
2913 orderedThreadKeys,
2938 - routePreviewOpen,
2914 routeRowThreadKey,
2940 - routeTerminalOpen,
2915 + routeThreadRef,
2916 threadByKey,
2917 ]);
2918
2944 - const shouldShowJumpHintsNow = shouldShowThreadJumpHintsForModifiers(
2945 - shortcutModifiers,
2946 - keybindings,
2947 - {
2948 - platform: navigator.platform,
2949 - context: {
2950 - terminalFocus: terminalFocused,
2951 - terminalOpen: routeTerminalOpen,
2952 - previewFocus: isPreviewFocused(),
2953 - previewOpen: routePreviewOpen,
2954 - modelPickerOpen: isModelPickerOpen(),
2955 - isWeb: !isElectron,
2956 - isDesktop: isElectron,
2957 - },
2958 - },
2959 - );
2960 - const showJumpHints = useThreadJumpHintsVisible(shouldShowJumpHintsNow);
2919 + const showJumpHints = useThreadJumpHintsVisible(keybindings, routeThreadRef);
2920
2921 const handleNewThreadClick = (event?: ReactMouseEvent) => {
2922 if (
apps/web/src/hooks/useTerminalFocus.ts deleted
-16
@@ -1,16 +0,0 @@
1 -import { useSyncExternalStore } from "react";
2 -
3 -import { isTerminalFocused } from "../lib/terminalFocus";
4 -
5 -function subscribeToTerminalFocusChanges(listener: () => void): () => void {
6 - window.addEventListener("focusin", listener, true);
7 - window.addEventListener("focusout", listener, true);
8 - return () => {
9 - window.removeEventListener("focusin", listener, true);
10 - window.removeEventListener("focusout", listener, true);
11 - };
12 -}
13 -
14 -export function useTerminalFocus(): boolean {
15 - return useSyncExternalStore(subscribeToTerminalFocusChanges, isTerminalFocused, () => false);
16 -}
apps/web/src/lib/terminalFocus.ts
+9
@@ -19,6 +19,15 @@ export function isTerminalFocused(): boolean {
19 return getTerminalFocusOwner() !== null;
20 }
21
22 +export function subscribeToTerminalFocusChanges(listener: () => void): () => void {
23 + window.addEventListener("focusin", listener, true);
24 + window.addEventListener("focusout", listener, true);
25 + return () => {
26 + window.removeEventListener("focusin", listener, true);
27 + window.removeEventListener("focusout", listener, true);
28 + };
29 +}
30 +
31 interface TerminalFocusTarget {
32 readonly threadRef: ScopedThreadRef;
33 readonly terminalId: string;
apps/web/src/modelPickerVisibility.ts
+17 -2
@@ -1,13 +1,28 @@
1 // Keydown handlers read this on every key, so a mount count replaces a document query.
2 let mountedModelPickers = 0;
3 +const listeners = new Set<() => void>();
4 +
5 +function setMountedModelPickers(next: number) {
6 + const wasOpen = mountedModelPickers > 0;
7 + mountedModelPickers = next;
8 + if (wasOpen === mountedModelPickers > 0) return;
9 + for (const listener of listeners) listener();
10 +}
11
12 export function registerModelPickerContent(): () => void {
5 - mountedModelPickers += 1;
13 + setMountedModelPickers(mountedModelPickers + 1);
14 return () => {
7 - mountedModelPickers -= 1;
15 + setMountedModelPickers(mountedModelPickers - 1);
16 };
17 }
18
19 export function isModelPickerOpen(): boolean {
20 return mountedModelPickers > 0;
21 }
22 +
23 +export function subscribeToModelPickerVisibility(listener: () => void): () => void {
24 + listeners.add(listener);
25 + return () => {
26 + listeners.delete(listener);
27 + };
28 +}
apps/web/src/shortcutModifierState.ts
+49 -28
@@ -1,4 +1,4 @@
1 -import { useEffect, useRef, useState } from "react";
1 +import { useSyncExternalStore } from "react";
2 import { isEditableFocused } from "./lib/editableFocus";
3
4 export interface ShortcutModifierState {
@@ -27,32 +27,31 @@ function areShortcutModifierStatesEqual(
27 );
28 }
29
30 -export function useShortcutModifierState(ignoreEditable = false): ShortcutModifierState {
31 - const [state, setState] = useState(EMPTY_SHORTCUT_MODIFIER_STATE);
32 - const stateRef = useRef(EMPTY_SHORTCUT_MODIFIER_STATE);
33 -
34 - // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- window key, focus, paste and blur listeners that track held shortcut modifiers
35 - useEffect(() => {
36 - const updateState = (next: ShortcutModifierState) => {
37 - if (areShortcutModifierStatesEqual(stateRef.current, next)) return;
38 - stateRef.current = next;
39 - setState(next);
40 - };
41 - const onKeyboardEvent = (event: KeyboardEvent) => {
42 - updateState(
43 - ignoreEditable && isEditableFocused(event.target)
44 - ? EMPTY_SHORTCUT_MODIFIER_STATE
45 - : shortcutModifierStateAfterKeyboardEvent(stateRef.current, event),
46 - );
47 - };
48 - // Dictation tools can omit Meta keyup after synthetic paste, leaving jump hints stuck.
49 - const onResetEvent = () => {
50 - updateState(EMPTY_SHORTCUT_MODIFIER_STATE);
51 - };
30 +function createShortcutModifierStore(ignoreEditable: boolean) {
31 + let state = EMPTY_SHORTCUT_MODIFIER_STATE;
32 + const listeners = new Set<() => void>();
33 + let stopTracking: (() => void) | null = null;
34
53 - const onFocus = (event: FocusEvent) => {
54 - if (ignoreEditable && isEditableFocused(event.target)) onResetEvent();
55 - };
35 + const updateState = (next: ShortcutModifierState) => {
36 + if (areShortcutModifierStatesEqual(state, next)) return;
37 + state = next;
38 + for (const listener of listeners) listener();
39 + };
40 + const onKeyboardEvent = (event: KeyboardEvent) => {
41 + updateState(
42 + ignoreEditable && isEditableFocused(event.target)
43 + ? EMPTY_SHORTCUT_MODIFIER_STATE
44 + : shortcutModifierStateAfterKeyboardEvent(state, event),
45 + );
46 + };
47 + // Dictation tools can omit Meta keyup after synthetic paste, leaving jump hints stuck.
48 + const onResetEvent = () => {
49 + updateState(EMPTY_SHORTCUT_MODIFIER_STATE);
50 + };
51 + const onFocus = (event: FocusEvent) => {
52 + if (ignoreEditable && isEditableFocused(event.target)) onResetEvent();
53 + };
54 + const startTracking = () => {
55 window.addEventListener("focusin", onFocus);
56 window.addEventListener("keydown", onKeyboardEvent, true);
57 window.addEventListener("keyup", onKeyboardEvent, true);
@@ -64,10 +63,32 @@ export function useShortcutModifierState(ignoreEditable = false): ShortcutModifi
63 window.removeEventListener("keyup", onKeyboardEvent, true);
64 window.removeEventListener("paste", onResetEvent, true);
65 window.removeEventListener("blur", onResetEvent);
66 + state = EMPTY_SHORTCUT_MODIFIER_STATE;
67 };
68 - }, [ignoreEditable]);
68 + };
69 +
70 + return {
71 + subscribe: (listener: () => void) => {
72 + listeners.add(listener);
73 + stopTracking ??= startTracking();
74 + return () => {
75 + listeners.delete(listener);
76 + if (listeners.size > 0) return;
77 + stopTracking?.();
78 + stopTracking = null;
79 + };
80 + },
81 + getSnapshot: () => state,
82 + };
83 +}
84
70 - return state;
85 +/** Shared by every subscriber; read it from a snapshot to re-render only when a derived value changes. */
86 +export const shortcutModifierStore = createShortcutModifierStore(false);
87 +const editableIgnoringShortcutModifierStore = createShortcutModifierStore(true);
88 +
89 +export function useShortcutModifierState(ignoreEditable = false): ShortcutModifierState {
90 + const store = ignoreEditable ? editableIgnoringShortcutModifierStore : shortcutModifierStore;
91 + return useSyncExternalStore(store.subscribe, store.getSnapshot);
92 }
93
94 function normalizeModifierKey(key: string): keyof ShortcutModifierState | null {