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 {