@devries-cameron20 / t3code-1 / commits / 8866e8fdcf
Fork 0

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

fix(web): align composer chip cleanup with undo history (#18466)

Co-authored-by: Julius Marminge <julius0216@outlook.com>

Guillermo Casanova committed Oct 20, 2026 at 03:05 UTC 8866e8fdcf834e3f79e81a1560fc2f0c2a7d3874
5 files changed +245 -72
apps/web/src/components/ComposerPromptEditorTiptap.input.browser.test.tsx
+176 -2
@@ -1,8 +1,18 @@
1 +import type { ComposerFileAttachment } from "../composerDraftStore";
2 +import { formatInlineContextReference } from "../lib/composerContextReferences";
3 +import { fileContextReference } from "../lib/composerContextRecords";
4 +import {
5 + reconcileAttachmentContextReferences,
6 + type RetainedContextPayloads,
7 + useRetainedContextPayloads,
8 +} from "./chat/composerContextUndo";
9 +
10 +import { userEvent } from "vite-plus/test/browser";
11 import type { ServerProviderSkill } from "@t3tools/contracts";
12 import type { Editor } from "@tiptap/core";
3 -import { act, createRef, useState } from "react";
13 +import { act, createElement, createRef, useEffect, useState } from "react";
14 import { createRoot, type Root } from "react-dom/client";
5 -import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test";
15 +import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
16
17 import { detectComposerTrigger } from "~/composer-logic";
18 import { serializeEditorDoc } from "~/composer-rich-text-doc";
@@ -353,3 +363,167 @@ it("reconciles provider skills and metadata without losing formatting, caret, or
363 expect(document.body.textContent).toContain("No description is available for this skill.");
364 expect(document.body.textContent).not.toContain("Previous provider description");
365 });
366 +
367 +const file = {
368 + type: "file",
369 + id: "file-1",
370 + name: "notes.txt",
371 + mimeType: "text/plain",
372 + sizeBytes: 5,
373 + file: new File(["notes"], "notes.txt", { type: "text/plain" }),
374 +} satisfies ComposerFileAttachment;
375 +
376 +describe("composer context undo lifetime", () => {
377 + async function mountComposer(destinationValue = "") {
378 + const initialValue = `Draft A ${formatInlineContextReference(fileContextReference(file))}`;
379 + const editorRef = createRef<ComposerPromptEditorHandle>();
380 + let current: { value: string; files: ComposerFileAttachment[] };
381 + let retained: RetainedContextPayloads;
382 +
383 + function Composer({ targetKey }: { targetKey: string }) {
384 + const [drafts, setDrafts] = useState<
385 + Record<string, { value: string; files: ComposerFileAttachment[] }>
386 + >({
387 + a: { value: initialValue, files: [file] },
388 + b: { value: destinationValue, files: [] },
389 + });
390 + const payloads = useRetainedContextPayloads(targetKey);
391 + const draft = drafts[targetKey]!;
392 + useEffect(() => {
393 + current = draft;
394 + retained = payloads;
395 + });
396 + const editorProps = {
397 + draftKey: targetKey,
398 + editorRef,
399 + value: draft.value,
400 + cursor: 0,
401 + contextRecords: new Map(
402 + draft.files.map((entry) => [
403 + fileContextReference(entry).contextId,
404 + { kind: "file" as const, record: entry },
405 + ]),
406 + ),
407 + skills: [],
408 + disabled: false,
409 + placeholder: "",
410 + onChange: (value, _cursor, _expandedCursor, _adjacent, contextIds) => {
411 + const changes = reconcileAttachmentContextReferences({
412 + referencedContextIds: new Set(contextIds),
413 + files: draft.files,
414 + images: [],
415 + previewAnnotations: [],
416 + retained: payloads,
417 + });
418 + setDrafts({
419 + ...drafts,
420 + [targetKey]: {
421 + value,
422 + files: [
423 + ...draft.files.filter((entry) => !changes.filesToRemove.includes(entry.id)),
424 + ...changes.filesToRestore,
425 + ],
426 + },
427 + });
428 + },
429 + onPaste: () => {},
430 + } satisfies ComposerPromptEditorProps;
431 + return createElement(ComposerPromptEditor, editorProps);
432 + }
433 +
434 + const render = async (targetKey: string) => {
435 + await act(async () => root.render(createElement(Composer, { targetKey })));
436 + };
437 + const editor = () => {
438 + const element = container.querySelector<HTMLElement & { editor: Editor }>(".tiptap");
439 + if (!element) throw new Error("Composer did not mount");
440 + return element.editor;
441 + };
442 + await render("a");
443 + return {
444 + initialValue,
445 + render,
446 + editor,
447 + draft: () => current,
448 + retained: () => retained,
449 + deleteDraft: async () => {
450 + await act(async () => {
451 + const currentEditor = editor();
452 + currentEditor.view.dispatch(
453 + currentEditor.state.tr.delete(1, currentEditor.state.doc.content.size - 1),
454 + );
455 + });
456 + },
457 + undo: async () => {
458 + await act(async () => {
459 + editor().commands.undo();
460 + });
461 + },
462 + };
463 + }
464 +
465 + it("preserves typing focus across draft switches without taking focus from another control", async () => {
466 + const composer = await mountComposer("Draft B");
467 + const previousEditor = composer.editor();
468 + await act(async () => {
469 + previousEditor.commands.setTextSelection(previousEditor.state.doc.content.size - 1);
470 + previousEditor.view.focus();
471 + });
472 + expect(document.activeElement).toBe(previousEditor.view.dom);
473 +
474 + await composer.render("b");
475 + const nextEditor = composer.editor();
476 + expect(nextEditor).not.toBe(previousEditor);
477 + expect(document.activeElement).toBe(nextEditor.view.dom);
478 + await act(async () => userEvent.keyboard("x"));
479 + expect(composer.draft().value).toBe("xDraft B");
480 +
481 + const button = document.createElement("button");
482 + container.append(button);
483 + button.focus();
484 + await composer.render("a");
485 + expect(document.activeElement).toBe(button);
486 + expect(composer.draft().value).toBe(composer.initialValue);
487 + });
488 +
489 + it("restores a deleted chip and its file bytes on same-draft undo, then releases them on unmount", async () => {
490 + const composer = await mountComposer();
491 + await composer.deleteDraft();
492 + expect(composer.draft()).toEqual({ value: "", files: [] });
493 + const retained = composer.retained();
494 + expect(retained.files.get(fileContextReference(file).contextId)?.file).toBe(file.file);
495 +
496 + await composer.render("a");
497 + await composer.undo();
498 + expect(serializeEditorDoc(composer.editor().state.doc).value).toBe(composer.initialValue);
499 + expect(composer.draft()).toEqual({ value: composer.initialValue, files: [file] });
500 + expect(composer.draft().files[0]?.file).toBe(file.file);
501 +
502 + await composer.deleteDraft();
503 + await act(async () => root.unmount());
504 + expect(retained.files.size).toBe(0);
505 + root = createRoot(container);
506 + });
507 +
508 + it.each(["", "Draft B"])(
509 + "releases deleted payloads and prevents undo into the previous draft when switching to %j",
510 + async (destinationValue) => {
511 + const composer = await mountComposer(destinationValue);
512 + await composer.deleteDraft();
513 + expect(composer.draft()).toEqual({ value: "", files: [] });
514 + const retained = composer.retained();
515 + expect(retained.files.get(fileContextReference(file).contextId)?.file).toBe(file.file);
516 +
517 + await composer.render("b");
518 + expect(retained.files.size).toBe(0);
519 + await composer.undo();
520 + expect(serializeEditorDoc(composer.editor().state.doc).value).toBe(destinationValue);
521 + expect(composer.draft()).toEqual({ value: destinationValue, files: [] });
522 +
523 + await composer.render("a");
524 + await composer.undo();
525 + expect(serializeEditorDoc(composer.editor().state.doc).value).toBe("");
526 + expect(composer.draft()).toEqual({ value: "", files: [] });
527 + },
528 + );
529 +});
apps/web/src/components/ComposerPromptEditorTiptap.tsx
+23 -2
@@ -45,6 +45,7 @@ import {
45 useRef,
46 useState,
47 type KeyboardEvent as ReactKeyboardEvent,
48 + type RefObject,
49 } from "react";
50 import { EditorContent, useEditor } from "@tiptap/react";
51
@@ -138,6 +139,7 @@ export interface ComposerPromptEditorHandle {
139 }
140
141 export interface ComposerPromptEditorProps {
142 + draftKey?: string;
143 value: string;
144 cursor: number;
145 richTextEnabled?: boolean;
@@ -775,6 +777,7 @@ function replaceSkillChips(
777 }
778
779 export function ComposerPromptEditorTiptap(props: ComposerPromptEditorProps) {
780 + const restoreFocusRef = useRef(false);
781 const { onChange: onPromptChange } = props;
782 const [selection, setSelection] = useState<{
783 value: string;
@@ -794,8 +797,9 @@ export function ComposerPromptEditorTiptap(props: ComposerPromptEditorProps) {
797 // a caret inside unknown `$name` text, so retain the exact Markdown offset here.
798 return (
799 <ComposerPromptEditorTiptapInner
797 - key={props.literalText ? "literal" : props.richTextEnabled ? "rich" : "plain"}
800 + key={`${props.draftKey ?? ""}:${props.literalText ? "literal" : props.richTextEnabled ? "rich" : "plain"}`}
801 {...props}
802 + restoreFocusRef={restoreFocusRef}
803 initialExpandedCursor={
804 selection?.value === props.value && selection.cursor === props.cursor
805 ? selection.expandedCursor
@@ -935,7 +939,10 @@ const RICH_TEXT_EXTENSIONS = createComposerExtensions(true);
939 const PLAIN_TEXT_EXTENSIONS = createComposerExtensions(false);
940
941 function ComposerPromptEditorTiptapInner(
938 - props: ComposerPromptEditorProps & { initialExpandedCursor: number },
942 + props: ComposerPromptEditorProps & {
943 + initialExpandedCursor: number;
944 + restoreFocusRef: RefObject<boolean>;
945 + },
946 ) {
947 const {
948 value,
@@ -965,6 +972,7 @@ function ComposerPromptEditorTiptapInner(
972 onCitationDraftSave,
973 onPaste,
974 editorRef,
975 + restoreFocusRef,
976 } = props;
977 const richText = !literalText && (richTextEnabled ?? false);
978 const clampEditorCursor = (text: string, position: number) =>
@@ -1644,6 +1652,19 @@ function ComposerPromptEditorTiptapInner(
1652 if (replacements.length > 0) replaceSkillChips(editor, replacements);
1653 }, [editor, literalText, skills]);
1654
1655 + useLayoutEffect(() => {
1656 + if (!editor) return;
1657 + if (restoreFocusRef.current) {
1658 + restoreFocusRef.current = false;
1659 + editor.view.focus();
1660 + scrollTiptapCaretIntoView(editor);
1661 + }
1662 + return () => {
1663 + // Capture focus before the keyed editor's DOM is removed.
1664 + restoreFocusRef.current = editor.view.hasFocus();
1665 + };
1666 + }, [editor, restoreFocusRef]);
1667 +
1668 const focusAt = (nextCursor: number, exactExpandedCursor?: number) => {
1669 if (!editor) return;
1670 // view.focus() writes the state selection to the DOM as it focuses. A
apps/web/src/components/chat/ChatComposer.tsx
+5 -17
@@ -153,7 +153,7 @@ import {
153 import { ComposerActivityRow } from "./ComposerActivityStatus";
154 import {
155 reconcileAttachmentContextReferences,
156 - type RetainedAttachmentContextPayloads,
156 + useRetainedContextPayloads,
157 } from "./composerContextUndo";
158 import type { ThreadSyncPhase } from "../../threadSync";
159 import { ComposerBanner } from "./ComposerBanner";
@@ -3556,20 +3556,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
3556 };
3557 const expandComposerForEditorChangeStable = useStableCallback(expandComposerForEditorChange);
3558
3559 - /**
3560 - * Payloads for chips the prompt no longer references. History undo restores the
3561 - * reference text but knows nothing about the draft records behind it, so a delete keeps its
3562 - * payload here and an undo puts it back rather than leaving a dangling chip.
3563 - */
3564 - const removedContextPayloadsRef = useRef<{
3565 - terminals: Map<string, TerminalContextDraft>;
3566 - reviewComments: Map<string, ReviewCommentContext>;
3567 - threads: Map<string, ThreadContextRecord>;
3568 - }>({ terminals: new Map(), reviewComments: new Map(), threads: new Map() });
3569 - const removedAttachmentContextPayloadsRef = useRef<RetainedAttachmentContextPayloads>({
3570 - files: new Map(),
3571 - previewAnnotations: new Map(),
3572 - });
3559 + const retainedContextPayloads = useRetainedContextPayloads(composerDraftTargetKey);
3560
3561 const onPromptChange = (
3562 nextPrompt: string,
@@ -3604,7 +3591,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
3591 promptHistoryPositionRef.current = null;
3592 }
3593 const referenced = new Set(contextIds);
3607 - const retained = removedContextPayloadsRef.current;
3594 + const retained = retainedContextPayloads;
3595
3596 const liveTerminalIds = new Set<string>(
3597 composerTerminalContexts.map((context) => terminalContextReference(context).contextId),
@@ -3668,7 +3655,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
3655 files: composerFiles,
3656 images: composerImages,
3657 previewAnnotations: composerPreviewAnnotations,
3671 - retained: removedAttachmentContextPayloadsRef.current,
3658 + retained: retainedContextPayloads,
3659 });
3660 for (const annotationId of attachmentChanges.annotationIdsToRemove) {
3661 removeComposerDraftPreviewAnnotation(composerDraftTarget, annotationId);
@@ -7125,6 +7112,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
7112 ) : null}
7113 <ComposerContextActionsContext value={composerContextActions}>
7114 <ComposerPromptEditor
7115 + draftKey={composerDraftTargetKey}
7116 ariaLabel="Message"
7117 suggestionListId={composerSuggestionListId}
7118 activeSuggestionId={
apps/web/src/components/chat/composerContextUndo.test.ts
+2 -50
@@ -1,26 +1,14 @@
1 import type { PreviewAnnotationPayload } from "@t3tools/contracts";
2 import { describe, expect, it } from "vite-plus/test";
3
4 -import type { ComposerFileAttachment, ComposerImageAttachment } from "../../composerDraftStore";
5 -import {
6 - buildMessageContext,
7 - fileContextReference,
8 - previewAnnotationContextId,
9 -} from "../../lib/composerContextRecords";
4 +import type { ComposerImageAttachment } from "../../composerDraftStore";
5 +import { buildMessageContext, previewAnnotationContextId } from "../../lib/composerContextRecords";
6 import {
7 reconcileAttachmentContextReferences,
8 type RetainedAttachmentContextPayloads,
9 } from "./composerContextUndo";
10
11 const binary = new File(["binary"], "context.png", { type: "image/png" });
16 -const file = {
17 - type: "file",
18 - id: "file-1",
19 - name: "notes.txt",
20 - mimeType: "text/plain",
21 - sizeBytes: 5,
22 - file: new File(["notes"], "notes.txt", { type: "text/plain" }),
23 -} satisfies ComposerFileAttachment;
12 const image = {
13 type: "image",
14 id: "annotation-1",
@@ -53,42 +41,6 @@ function retention(): RetainedAttachmentContextPayloads {
41 }
42
43 describe("reconcileAttachmentContextReferences", () => {
56 - it("restores file bytes after deleting and undoing its chip", () => {
57 - const retained = retention();
58 - const removed = reconcileAttachmentContextReferences({
59 - referencedContextIds: new Set(),
60 - files: [file],
61 - images: [],
62 - previewAnnotations: [],
63 - retained,
64 - });
65 - expect(removed.filesToRemove).toEqual(["file-1"]);
66 -
67 - const restored = reconcileAttachmentContextReferences({
68 - referencedContextIds: new Set([fileContextReference(file).contextId]),
69 - files: [],
70 - images: [],
71 - previewAnnotations: [],
72 - retained,
73 - });
74 - expect(restored.filesToRestore).toEqual([file]);
75 - expect(restored.filesToRestore[0]?.file).toBe(file.file);
76 - expect(
77 - buildMessageContext({
78 - terminalContexts: [],
79 - reviewComments: [],
80 - previewAnnotations: [],
81 - attachments: [{ attachment: restored.filesToRestore[0]!, attachmentId: "uploaded-file" }],
82 - })?.records,
83 - ).toEqual([
84 - expect.objectContaining({
85 - kind: "file",
86 - contextId: "file_file-1",
87 - attachmentId: "uploaded-file",
88 - }),
89 - ]);
90 - });
91 -
44 it("restores an annotation and its screenshot attachment after undo", () => {
45 const retained = retention();
46 const removed = reconcileAttachmentContextReferences({
apps/web/src/components/chat/composerContextUndo.ts
+39 -1
@@ -1,7 +1,10 @@
1 -import type { PreviewAnnotationPayload } from "@t3tools/contracts";
1 +import type { PreviewAnnotationPayload, ThreadContextRecord } from "@t3tools/contracts";
2 +import { useEffect, useState } from "react";
3
4 import type { ComposerFileAttachment, ComposerImageAttachment } from "../../composerDraftStore";
5 import { fileContextReference, previewAnnotationContextId } from "../../lib/composerContextRecords";
6 +import type { TerminalContextDraft } from "../../lib/terminalContext";
7 +import type { ReviewCommentContext } from "../../reviewCommentContext";
8
9 interface RetainedPreviewAnnotation {
10 annotation: PreviewAnnotationPayload;
@@ -13,6 +16,41 @@ export interface RetainedAttachmentContextPayloads {
16 previewAnnotations: Map<string, RetainedPreviewAnnotation>;
17 }
18
19 +export interface RetainedContextPayloads extends RetainedAttachmentContextPayloads {
20 + terminals: Map<string, TerminalContextDraft>;
21 + reviewComments: Map<string, ReviewCommentContext>;
22 + threads: Map<string, ThreadContextRecord>;
23 +}
24 +
25 +function createRetainedContextPayloads(): RetainedContextPayloads {
26 + return {
27 + terminals: new Map(),
28 + reviewComments: new Map(),
29 + threads: new Map(),
30 + files: new Map(),
31 + previewAnnotations: new Map(),
32 + };
33 +}
34 +
35 +// Deleted chips keep their payloads until their draft's undo history ends.
36 +export function useRetainedContextPayloads(draftTargetKey: string): RetainedContextPayloads {
37 + const [draft, setDraft] = useState(() => ({
38 + targetKey: draftTargetKey,
39 + payloads: createRetainedContextPayloads(),
40 + }));
41 + if (draft.targetKey !== draftTargetKey) {
42 + setDraft({ targetKey: draftTargetKey, payloads: createRetainedContextPayloads() });
43 + }
44 + const retained = draft.payloads;
45 + useEffect(
46 + () => () => {
47 + for (const payloads of Object.values(retained)) payloads.clear();
48 + },
49 + [retained],
50 + );
51 + return retained;
52 +}
53 +
54 export function reconcileAttachmentContextReferences(input: {
55 referencedContextIds: ReadonlySet<string>;
56 files: ReadonlyArray<ComposerFileAttachment>;