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 22, 19:30 UTC
refactor(web): composer key handling lives in useComposerCommandKey (#23060)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Oct 21, 2026 at 13:23 UTC
e78f58046876271109bf6985e8f46769d8e7505d
4 files changed
+328
-158
apps/web/src/components/chat/ChatComposer.tsx
+39
-158
@@ -64,16 +64,15 @@ import {
64
type ComposerSubmissionIntent,
65
collapseExpandedComposerCursor,
66
composerRequiresModifier,
67
- composerSubmissionIntentForKey,
67
composerStateAtPromptEnd,
68
detectComposerTrigger,
69
expandCollapsedComposerCursor,
70
formatAssistantCitationForComposer,
71
isPathSuggestionCurrent,
72
+ extendReplacementRangeForTrailingSpace,
73
replaceTextRange,
74
} from "../../composer-logic";
75
import { DISCONNECTED_COMPOSER_PLACEHOLDER } from "../../composerPlaceholder";
76
-import { listContinuationForEnter, listIndentForTab } from "../../composer-list-continuation";
76
import {
77
deriveComposerSendState,
78
getAntigravitySendBlockReason,
@@ -259,11 +258,7 @@ import {
258
type Thread,
259
type ThreadShell,
260
} from "../../types";
262
-import {
263
- buildComposerPromptHistoryEntries,
264
- stepComposerPromptHistory,
265
- type ComposerPromptHistoryPosition,
266
-} from "./composerPromptHistory";
261
+import { type ComposerPromptHistoryPosition } from "./composerPromptHistory";
262
import type { PendingUserInputDraftAnswer } from "../../pendingUserInput";
263
import type {
264
LatestProposedPlanState,
@@ -296,6 +291,7 @@ import { useComposerStash } from "./useComposerStash";
291
import { useComposerContextImport } from "./useComposerContextImport";
292
import { useComposerAttachmentIntake } from "./useComposerAttachmentIntake";
293
import { ComposerControlsBar } from "./ComposerControlsBar";
294
+import { useComposerCommandKey } from "./useComposerCommandKey";
295
296
/** Reads and disarms a paste-as-text deadline: the shortcut applies to one paste only. */
297
function consumePasteAsTextShortcut(deadline: { current: number }): boolean {
@@ -304,17 +300,6 @@ function consumePasteAsTextShortcut(deadline: { current: number }): boolean {
300
return armed;
301
}
302
307
-const extendReplacementRangeForTrailingSpace = (
308
- text: string,
309
- rangeEnd: number,
310
- replacement: string,
311
-): number => {
312
- if (!replacement.endsWith(" ")) {
313
- return rangeEnd;
314
- }
315
- return text[rangeEnd] === " " ? rangeEnd + 1 : rangeEnd;
316
-};
317
-
303
const runtimeModeOptions = runtimeModes.map((mode) => ({ mode, ...runtimeModeConfig[mode] }));
304
305
export interface ChatComposerHandle {
@@ -2258,148 +2243,44 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
2243
};
2244
const expandMobileComposerStable = useStableCallback(expandMobileComposer);
2245
2261
- // Entries are built on the keypress, not per render: the timeline changes
2262
- // on every streamed delta and ArrowUp is rare.
2263
- const promptHistoryMessagesRef = useRef(promptHistoryMessages);
2264
- useLayoutEffect(() => {
2265
- promptHistoryMessagesRef.current = promptHistoryMessages;
2246
+ const { onComposerCommandKey } = useComposerCommandKey({
2247
+ keybindings,
2248
+ sendShortcut: settings.sendShortcut,
2249
+ routeKind,
2250
+ phase,
2251
+ isCompacting,
2252
+ followUpBehavior,
2253
+ isSoftwareKeyboardOpen,
2254
+ planModeUiEnabled,
2255
+ isLiteralPendingAnswer,
2256
+ pendingUserInputs,
2257
+ promptHistoryMessages,
2258
+ promptHistoryPositionRef,
2259
+ composerDraftTarget,
2260
+ promptRef,
2261
+ composerImagesRef,
2262
+ composerFilesRef,
2263
+ composerTerminalContextsRef,
2264
+ composerPreviewAnnotations,
2265
+ composerReviewComments,
2266
+ composerEditorRef,
2267
+ composerMenuOpenRef,
2268
+ composerMenuItemsRef,
2269
+ activeComposerMenuItemRef,
2270
+ setComposerDraftPrompt,
2271
+ setComposerCursor,
2272
+ setComposerTrigger,
2273
+ setComposerHighlightedItemId,
2274
+ dismissComposerTrigger,
2275
+ toggleInteractionMode,
2276
+ nudgeComposerMenuHighlight,
2277
+ onSelectComposerItem,
2278
+ resolveActiveComposerTrigger,
2279
+ readComposerSnapshot,
2280
+ applyPromptReplacement,
2281
+ submitComposer,
2282
});
2283
2268
- // The composer persists across threads. A recall from thread A must not
2269
- // be treated as active in thread B, where the text-match fallback could
2270
- // otherwise turn B's own draft into a browsing position.
2271
- const promptHistoryTargetKey = composerTargetKey(composerDraftTarget);
2272
-
2273
- const replacePromptFromHistory = (nextPrompt: string) => {
2274
- promptRef.current = nextPrompt;
2275
- setComposerDraftPrompt(composerDraftTarget, nextPrompt);
2276
- setComposerCursor(collapseExpandedComposerCursor(nextPrompt, nextPrompt.length));
2277
- setComposerTrigger(null);
2278
- setComposerHighlightedItemId(null);
2279
- };
2280
-
2281
- const navigatePromptHistory = (
2282
- direction: "backward" | "forward",
2283
- event: KeyboardEvent,
2284
- ): boolean => {
2285
- if (event.shiftKey || event.altKey || event.metaKey || event.ctrlKey || event.isComposing) {
2286
- return false;
2287
- }
2288
- if (pendingUserInputs.length > 0) return false;
2289
- if (
2290
- composerImagesRef.current.length > 0 ||
2291
- composerFilesRef.current.length > 0 ||
2292
- composerTerminalContextsRef.current.length > 0 ||
2293
- composerPreviewAnnotations.length > 0 ||
2294
- composerReviewComments.length > 0
2295
- ) {
2296
- return false;
2297
- }
2298
- const recalled = promptHistoryPositionRef.current;
2299
- const position = recalled?.targetKey === promptHistoryTargetKey ? recalled.position : null;
2300
- if (position === null && promptRef.current.length > 0) {
2301
- return false;
2302
- }
2303
- const editor = composerEditorRef.current;
2304
- if (!editor?.isCaretOnVisualEdge(direction === "backward" ? "start" : "end")) {
2305
- return false;
2306
- }
2307
- const step = stepComposerPromptHistory({
2308
- direction,
2309
- entries: buildComposerPromptHistoryEntries(promptHistoryMessagesRef.current),
2310
- position,
2311
- currentPrompt: promptRef.current,
2312
- });
2313
- if (!step) return false;
2314
- promptHistoryPositionRef.current = step.position
2315
- ? { targetKey: promptHistoryTargetKey, position: step.position }
2316
- : null;
2317
- replacePromptFromHistory(step.prompt);
2318
- return true;
2319
- };
2320
-
2321
- const onComposerCommandKey = (key: string, event: KeyboardEvent, isTaskItem = false) => {
2322
- const submissionIntent = composerSubmissionIntentForKey({
2323
- event,
2324
- keybindings,
2325
- isSoftwareKeyboardOpen,
2326
- isDraftThread: routeKind === "draft",
2327
- isRunning: phase === "running",
2328
- sendShortcut: settings.sendShortcut,
2329
- prompt: promptRef.current,
2330
- });
2331
- if (key === "Tab" && event.shiftKey && submissionIntent === null) {
2332
- if (!planModeUiEnabled) return false;
2333
- toggleInteractionMode();
2334
- return true;
2335
- }
2336
- const { trigger } = resolveActiveComposerTrigger();
2337
- const menuIsActive =
2338
- !isLiteralPendingAnswer && (composerMenuOpenRef.current || trigger !== null);
2339
- if (key === "Escape") {
2340
- if (!menuIsActive || event.isComposing || event.keyCode === 229) return false;
2341
- dismissComposerTrigger(trigger);
2342
- composerMenuOpenRef.current = false;
2343
- return true;
2344
- }
2345
- if (menuIsActive && (submissionIntent === null || submissionIntent === "foreground")) {
2346
- const currentItems = composerMenuItemsRef.current;
2347
- const selectedItem = activeComposerMenuItemRef.current ?? currentItems[0];
2348
- if (key === "ArrowDown" && currentItems.length > 0) {
2349
- nudgeComposerMenuHighlight("ArrowDown");
2350
- return true;
2351
- }
2352
- if (key === "ArrowUp" && currentItems.length > 0) {
2353
- nudgeComposerMenuHighlight("ArrowUp");
2354
- return true;
2355
- }
2356
- if ((key === "Enter" || key === "Tab") && selectedItem) {
2357
- onSelectComposerItem(selectedItem);
2358
- return true;
2359
- }
2360
- }
2361
- if ((key === "ArrowUp" || key === "ArrowDown") && submissionIntent === null) {
2362
- return navigatePromptHistory(key === "ArrowUp" ? "backward" : "forward", event);
2363
- }
2364
- if (submissionIntent) {
2365
- submitComposer(
2366
- undefined,
2367
- resolveComposerDispatchMode({
2368
- running: phase === "running",
2369
- alternateModifier: submissionIntent === "alternate",
2370
- activeTurnDefault: followUpBehavior,
2371
- canSteer: !isCompacting,
2372
- }),
2373
- submissionIntent,
2374
- );
2375
- return true;
2376
- }
2377
- if (key === "Enter" && isTaskItem) return false;
2378
- if (
2379
- !isLiteralPendingAnswer &&
2380
- !event.isComposing &&
2381
- (key === "Enter" || (key === "Tab" && !event.shiftKey))
2382
- ) {
2383
- const selection = composerEditorRef.current?.readSelectionRange();
2384
- const snapshot = readComposerSnapshot();
2385
- if (selection && selection.start === selection.end && snapshot.value === promptRef.current) {
2386
- const edit =
2387
- key === "Enter"
2388
- ? listContinuationForEnter(snapshot.value, selection.start)
2389
- : listIndentForTab(snapshot.value, selection.start, selection.end);
2390
- if (
2391
- edit &&
2392
- applyPromptReplacement(edit.start, edit.end, edit.replacement, {
2393
- expandedCursorAfterReplace: edit.cursorAfter,
2394
- })
2395
- ) {
2396
- return true;
2397
- }
2398
- }
2399
- }
2400
- return false;
2401
- };
2402
-
2284
const {
2285
stashQueue,
2286
isStashMenuOpen,
apps/web/src/components/chat/useComposerCommandKey.ts
new
+264
@@ -0,0 +1,264 @@
1
+import type { ChatComposerProps } from "./ChatComposer";
2
+import { type ComposerCommandItem } from "./ComposerCommandMenu";
3
+import {
4
+ type ComposerDispatchMode,
5
+ resolveComposerDispatchMode,
6
+} from "@t3tools/client-runtime/state/composer-dispatch";
7
+import { type ComposerPromptEditorHandle } from "../ComposerPromptEditor";
8
+import {
9
+ type ComposerPromptHistoryPosition,
10
+ buildComposerPromptHistoryEntries,
11
+ stepComposerPromptHistory,
12
+} from "./composerPromptHistory";
13
+import {
14
+ type ComposerSubmissionIntent,
15
+ type ComposerTrigger,
16
+ collapseExpandedComposerCursor,
17
+ composerSubmissionIntentForKey,
18
+} from "../../composer-logic";
19
+import { type PendingUserInput } from "../../session-logic";
20
+import { type PreviewAnnotationPayload } from "@t3tools/contracts";
21
+import { type ReviewCommentContext } from "../../reviewCommentContext";
22
+import { composerTargetKey } from "../../composerDraftStore";
23
+import { listContinuationForEnter, listIndentForTab } from "../../composer-list-continuation";
24
+import { type Dispatch, type RefObject, type SetStateAction, useLayoutEffect, useRef } from "react";
25
+
26
+/**
27
+ * The composer's key handling inside the editor: send shortcuts, the slash/mention menu,
28
+ * prompt history on ArrowUp/ArrowDown, plan-mode toggle, and list continuation.
29
+ */
30
+export function useComposerCommandKey(input: {
31
+ readonly keybindings: ChatComposerProps["keybindings"];
32
+ readonly sendShortcut: ChatComposerProps["settings"]["sendShortcut"];
33
+ readonly routeKind: ChatComposerProps["routeKind"];
34
+ readonly phase: ChatComposerProps["phase"];
35
+ readonly isCompacting: boolean;
36
+ readonly followUpBehavior: ChatComposerProps["settings"]["followUpBehavior"];
37
+ readonly isSoftwareKeyboardOpen: boolean;
38
+ readonly planModeUiEnabled: boolean;
39
+ readonly isLiteralPendingAnswer: boolean;
40
+ readonly pendingUserInputs: ReadonlyArray<PendingUserInput>;
41
+ readonly promptHistoryMessages: ChatComposerProps["promptHistoryMessages"];
42
+ readonly promptHistoryPositionRef: RefObject<{
43
+ targetKey: string;
44
+ position: ComposerPromptHistoryPosition;
45
+ } | null>;
46
+ readonly composerDraftTarget: ChatComposerProps["composerDraftTarget"];
47
+ readonly promptRef: ChatComposerProps["promptRef"];
48
+ readonly composerImagesRef: ChatComposerProps["composerImagesRef"];
49
+ readonly composerFilesRef: ChatComposerProps["composerFilesRef"];
50
+ readonly composerTerminalContextsRef: ChatComposerProps["composerTerminalContextsRef"];
51
+ readonly composerPreviewAnnotations: ReadonlyArray<PreviewAnnotationPayload>;
52
+ readonly composerReviewComments: ReadonlyArray<ReviewCommentContext>;
53
+ readonly composerEditorRef: RefObject<ComposerPromptEditorHandle | null>;
54
+ readonly composerMenuOpenRef: RefObject<boolean>;
55
+ readonly composerMenuItemsRef: RefObject<ComposerCommandItem[]>;
56
+ readonly activeComposerMenuItemRef: RefObject<ComposerCommandItem | null>;
57
+ readonly setComposerDraftPrompt: (
58
+ target: ChatComposerProps["composerDraftTarget"],
59
+ prompt: string,
60
+ ) => void;
61
+ readonly setComposerCursor: Dispatch<SetStateAction<number>>;
62
+ readonly setComposerTrigger: (trigger: ComposerTrigger | null) => void;
63
+ readonly setComposerHighlightedItemId: Dispatch<SetStateAction<string | null>>;
64
+ readonly dismissComposerTrigger: (trigger: ComposerTrigger | null) => void;
65
+ readonly toggleInteractionMode: () => void;
66
+ readonly nudgeComposerMenuHighlight: (key: "ArrowDown" | "ArrowUp") => void;
67
+ readonly onSelectComposerItem: (item: ComposerCommandItem) => void;
68
+ readonly resolveActiveComposerTrigger: () => { trigger: ComposerTrigger | null };
69
+ readonly readComposerSnapshot: () => { value: string };
70
+ readonly applyPromptReplacement: (
71
+ rangeStart: number,
72
+ rangeEnd: number,
73
+ replacement: string,
74
+ options?: { expandedCursorAfterReplace?: number },
75
+ ) => boolean;
76
+ readonly submitComposer: (
77
+ event: undefined,
78
+ dispatchMode: ComposerDispatchMode,
79
+ submissionIntent: ComposerSubmissionIntent,
80
+ ) => void;
81
+}) {
82
+ const {
83
+ keybindings,
84
+ sendShortcut,
85
+ routeKind,
86
+ phase,
87
+ isCompacting,
88
+ followUpBehavior,
89
+ isSoftwareKeyboardOpen,
90
+ planModeUiEnabled,
91
+ isLiteralPendingAnswer,
92
+ pendingUserInputs,
93
+ promptHistoryMessages,
94
+ promptHistoryPositionRef,
95
+ composerDraftTarget,
96
+ promptRef,
97
+ composerImagesRef,
98
+ composerFilesRef,
99
+ composerTerminalContextsRef,
100
+ composerPreviewAnnotations,
101
+ composerReviewComments,
102
+ composerEditorRef,
103
+ composerMenuOpenRef,
104
+ composerMenuItemsRef,
105
+ activeComposerMenuItemRef,
106
+ setComposerDraftPrompt,
107
+ setComposerCursor,
108
+ setComposerTrigger,
109
+ setComposerHighlightedItemId,
110
+ dismissComposerTrigger,
111
+ toggleInteractionMode,
112
+ nudgeComposerMenuHighlight,
113
+ onSelectComposerItem,
114
+ resolveActiveComposerTrigger,
115
+ readComposerSnapshot,
116
+ applyPromptReplacement,
117
+ submitComposer,
118
+ } = input;
119
+ // Entries are built on the keypress, not per render: the timeline changes
120
+ // on every streamed delta and ArrowUp is rare.
121
+ const promptHistoryMessagesRef = useRef(promptHistoryMessages);
122
+ useLayoutEffect(() => {
123
+ promptHistoryMessagesRef.current = promptHistoryMessages;
124
+ });
125
+
126
+ // The composer persists across threads. A recall from thread A must not
127
+ // be treated as active in thread B, where the text-match fallback could
128
+ // otherwise turn B's own draft into a browsing position.
129
+ const promptHistoryTargetKey = composerTargetKey(composerDraftTarget);
130
+
131
+ const replacePromptFromHistory = (nextPrompt: string) => {
132
+ promptRef.current = nextPrompt;
133
+ setComposerDraftPrompt(composerDraftTarget, nextPrompt);
134
+ setComposerCursor(collapseExpandedComposerCursor(nextPrompt, nextPrompt.length));
135
+ setComposerTrigger(null);
136
+ setComposerHighlightedItemId(null);
137
+ };
138
+
139
+ const navigatePromptHistory = (
140
+ direction: "backward" | "forward",
141
+ event: KeyboardEvent,
142
+ ): boolean => {
143
+ if (event.shiftKey || event.altKey || event.metaKey || event.ctrlKey || event.isComposing) {
144
+ return false;
145
+ }
146
+ if (pendingUserInputs.length > 0) return false;
147
+ if (
148
+ composerImagesRef.current.length > 0 ||
149
+ composerFilesRef.current.length > 0 ||
150
+ composerTerminalContextsRef.current.length > 0 ||
151
+ composerPreviewAnnotations.length > 0 ||
152
+ composerReviewComments.length > 0
153
+ ) {
154
+ return false;
155
+ }
156
+ const recalled = promptHistoryPositionRef.current;
157
+ const position = recalled?.targetKey === promptHistoryTargetKey ? recalled.position : null;
158
+ if (position === null && promptRef.current.length > 0) {
159
+ return false;
160
+ }
161
+ const editor = composerEditorRef.current;
162
+ if (!editor?.isCaretOnVisualEdge(direction === "backward" ? "start" : "end")) {
163
+ return false;
164
+ }
165
+ const step = stepComposerPromptHistory({
166
+ direction,
167
+ entries: buildComposerPromptHistoryEntries(promptHistoryMessagesRef.current),
168
+ position,
169
+ currentPrompt: promptRef.current,
170
+ });
171
+ if (!step) return false;
172
+ promptHistoryPositionRef.current = step.position
173
+ ? { targetKey: promptHistoryTargetKey, position: step.position }
174
+ : null;
175
+ replacePromptFromHistory(step.prompt);
176
+ return true;
177
+ };
178
+
179
+ const onComposerCommandKey = (key: string, event: KeyboardEvent, isTaskItem = false) => {
180
+ const submissionIntent = composerSubmissionIntentForKey({
181
+ event,
182
+ keybindings,
183
+ isSoftwareKeyboardOpen,
184
+ isDraftThread: routeKind === "draft",
185
+ isRunning: phase === "running",
186
+ sendShortcut,
187
+ prompt: promptRef.current,
188
+ });
189
+ if (key === "Tab" && event.shiftKey && submissionIntent === null) {
190
+ if (!planModeUiEnabled) return false;
191
+ toggleInteractionMode();
192
+ return true;
193
+ }
194
+ const { trigger } = resolveActiveComposerTrigger();
195
+ const menuIsActive =
196
+ !isLiteralPendingAnswer && (composerMenuOpenRef.current || trigger !== null);
197
+ if (key === "Escape") {
198
+ if (!menuIsActive || event.isComposing || event.keyCode === 229) return false;
199
+ dismissComposerTrigger(trigger);
200
+ composerMenuOpenRef.current = false;
201
+ return true;
202
+ }
203
+ if (menuIsActive && (submissionIntent === null || submissionIntent === "foreground")) {
204
+ const currentItems = composerMenuItemsRef.current;
205
+ const selectedItem = activeComposerMenuItemRef.current ?? currentItems[0];
206
+ if (key === "ArrowDown" && currentItems.length > 0) {
207
+ nudgeComposerMenuHighlight("ArrowDown");
208
+ return true;
209
+ }
210
+ if (key === "ArrowUp" && currentItems.length > 0) {
211
+ nudgeComposerMenuHighlight("ArrowUp");
212
+ return true;
213
+ }
214
+ if ((key === "Enter" || key === "Tab") && selectedItem) {
215
+ onSelectComposerItem(selectedItem);
216
+ return true;
217
+ }
218
+ }
219
+ if ((key === "ArrowUp" || key === "ArrowDown") && submissionIntent === null) {
220
+ return navigatePromptHistory(key === "ArrowUp" ? "backward" : "forward", event);
221
+ }
222
+ if (submissionIntent) {
223
+ submitComposer(
224
+ undefined,
225
+ resolveComposerDispatchMode({
226
+ running: phase === "running",
227
+ alternateModifier: submissionIntent === "alternate",
228
+ activeTurnDefault: followUpBehavior,
229
+ canSteer: !isCompacting,
230
+ }),
231
+ submissionIntent,
232
+ );
233
+ return true;
234
+ }
235
+ if (key === "Enter" && isTaskItem) return false;
236
+ if (
237
+ !isLiteralPendingAnswer &&
238
+ !event.isComposing &&
239
+ (key === "Enter" || (key === "Tab" && !event.shiftKey))
240
+ ) {
241
+ const selection = composerEditorRef.current?.readSelectionRange();
242
+ const snapshot = readComposerSnapshot();
243
+ if (selection && selection.start === selection.end && snapshot.value === promptRef.current) {
244
+ const edit =
245
+ key === "Enter"
246
+ ? listContinuationForEnter(snapshot.value, selection.start)
247
+ : listIndentForTab(snapshot.value, selection.start, selection.end);
248
+ if (
249
+ edit &&
250
+ applyPromptReplacement(edit.start, edit.end, edit.replacement, {
251
+ expandedCursorAfterReplace: edit.cursorAfter,
252
+ })
253
+ ) {
254
+ return true;
255
+ }
256
+ }
257
+ }
258
+ return false;
259
+ };
260
+
261
+ return {
262
+ onComposerCommandKey,
263
+ };
264
+}
apps/web/src/composer-logic.test.ts
+10
@@ -19,6 +19,7 @@ import {
19
composerStateAtPromptEnd,
20
detectComposerTrigger,
21
expandCollapsedComposerCursor,
22
+ extendReplacementRangeForTrailingSpace,
23
formatAssistantCitationForComposer,
24
isCollapsedCursorAdjacentToInlineToken,
25
isPathSuggestionCurrent,
@@ -551,3 +552,12 @@ describe("literal editor answer cursor state", () => {
552
expect(composerStateAtPromptEnd("Use $my").trigger?.kind).toBe("skill");
553
});
554
});
555
+
556
+describe("extendReplacementRangeForTrailingSpace", () => {
557
+ it("swallows one existing space after the range when the replacement ends with one", () => {
558
+ expect(extendReplacementRangeForTrailingSpace("@fi rest", 3, "@file ")).toBe(4);
559
+ expect(extendReplacementRangeForTrailingSpace("@firest", 3, "@file ")).toBe(3);
560
+ expect(extendReplacementRangeForTrailingSpace("@fi rest", 3, "@file")).toBe(3);
561
+ expect(extendReplacementRangeForTrailingSpace("@fi", 3, "@file ")).toBe(3);
562
+ });
563
+});
apps/web/src/composer-logic.ts
+15
@@ -359,6 +359,21 @@ export function parseStandaloneComposerSlashCommand(
359
return "default";
360
}
361
362
+/**
363
+ * A replacement ending in a space swallows one space already after the range, so inserting
364
+ * `@file ` before existing text does not leave a double space.
365
+ */
366
+export function extendReplacementRangeForTrailingSpace(
367
+ text: string,
368
+ rangeEnd: number,
369
+ replacement: string,
370
+): number {
371
+ if (!replacement.endsWith(" ")) {
372
+ return rangeEnd;
373
+ }
374
+ return text[rangeEnd] === " " ? rangeEnd + 1 : rangeEnd;
375
+}
376
+
377
export function replaceTextRange(
378
text: string,
379
rangeStart: number,