xonecas.io
70160
Ce

cel-tui / files

cel-tui / packages / core / src / text-input.test.ts

31.7 KB
1import { afterEach, describe, expect, test } from "bun:test";
2import { VStack } from "./primitives/stacks.js";
3import { Text } from "./primitives/text.js";
4import { TextInput } from "./primitives/text-input.js";
5import { MockTerminal } from "./terminal.js";
6import { testCel as cel, kittyEncode } from "./test-helpers.js";
7
8const ENTER = kittyEncode("enter");
9const BACKSPACE = kittyEncode("backspace");
10const CTRL_A = kittyEncode("ctrl+a");
11const CTRL_E = kittyEncode("ctrl+e");
12const CTRL_LEFT = kittyEncode("ctrl+left");
13const CTRL_RIGHT = kittyEncode("ctrl+right");
14const CTRL_S = kittyEncode("ctrl+s");
15const CTRL_W = kittyEncode("ctrl+w");
16const ALT_B = kittyEncode("alt+b");
17const ALT_D = kittyEncode("alt+d");
18const ALT_F = kittyEncode("alt+f");
19const UP = kittyEncode("up");
20const DOWN = kittyEncode("down");
21const LEFT = kittyEncode("left");
22const RIGHT = kittyEncode("right");
23const DELETE = kittyEncode("delete");
24const LEGACY_CTRL_R = "\x12";
25const LEGACY_ALT_X = "\x1bx";
26const BRACKETED_PASTE_START = "\x1b[200~";
27const BRACKETED_PASTE_END = "\x1b[201~";
28
29function bracketedPaste(text: string): string {
30  return `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
31}
32
33describe("TextInput integration", () => {
34  let term: MockTerminal;
35
36  afterEach(() => {
37    cel.stop();
38  });
39
40  function setup(columns = 20, rows = 5): MockTerminal {
41    term = new MockTerminal(columns, rows);
42    cel.init(term);
43    return term;
44  }
45
46  async function waitForRender(): Promise<void> {
47    await cel._flush();
48  }
49
50  function currentBuffer() {
51    const buf = cel._getBuffer();
52    expect(buf).not.toBeNull();
53    if (buf === null) {
54      throw new Error("Expected a rendered buffer");
55    }
56    return buf;
57  }
58
59  test("renders value text", async () => {
60    const term = setup(20, 3);
61    cel.viewport(() =>
62      VStack({}, [TextInput({ value: "hello", onChange: () => {} })]),
63    );
64    await waitForRender();
65    expect(term.output).toContain("hello");
66  });
67
68  test("renders placeholder when value is empty", async () => {
69    const term = setup(20, 3);
70    cel.viewport(() =>
71      VStack({}, [
72        TextInput({
73          value: "",
74          onChange: () => {},
75          placeholder: Text("type here...", { fgColor: "color08" }),
76        }),
77      ]),
78    );
79    await waitForRender();
80    expect(term.output).toContain("type here...");
81  });
82
83  test("typing fires onChange with new value", async () => {
84    const term = setup(20, 3);
85    let value = "hi";
86    cel.viewport(() =>
87      VStack({}, [
88        TextInput({
89          value,
90          focused: true,
91          onChange: (v) => {
92            value = v;
93          },
94        }),
95      ]),
96    );
97    await waitForRender();
98
99    // Type "!"
100    term.sendInput("!");
101    await waitForRender();
102
103    expect(value).toBe("hi!");
104  });
105
106  test("batched printable input inserts all characters in order", async () => {
107    const term = setup(20, 3);
108    let value = "hi";
109    cel.viewport(() =>
110      VStack({}, [
111        TextInput({
112          value,
113          focused: true,
114          onChange: (v) => {
115            value = v;
116          },
117        }),
118      ]),
119    );
120    await waitForRender();
121
122    term.sendInput("ab");
123    await waitForRender();
124
125    expect(value).toBe("hiab");
126  });
127
128  test("bracketed paste in focused TextInput inserts full payload literally and skips onKeyPress", async () => {
129    const term = setup(20, 3);
130    let value = "hi";
131    let onChangeCalls = 0;
132    const keys: string[] = [];
133
134    cel.viewport(() =>
135      VStack({}, [
136        TextInput({
137          value,
138          focused: true,
139          onChange: (v) => {
140            value = v;
141            onChangeCalls++;
142          },
143          onKeyPress: (key) => {
144            keys.push(key);
145          },
146        }),
147      ]),
148    );
149    await waitForRender();
150
151    term.sendInput(bracketedPaste("!\n\tok"));
152    await waitForRender();
153
154    expect(value).toBe("hi!\n\tok");
155    expect(onChangeCalls).toBe(1);
156    expect(keys).toEqual([]);
157  });
158
159  test("bracketed paste split across stdin chunks waits for end marker and fires one onChange", async () => {
160    const term = setup(20, 3);
161    let value = "";
162    let onChangeCalls = 0;
163
164    cel.viewport(() =>
165      VStack({}, [
166        TextInput({
167          value,
168          focused: true,
169          onChange: (v) => {
170            value = v;
171            onChangeCalls++;
172          },
173        }),
174      ]),
175    );
176    await waitForRender();
177
178    term.sendInput(`${BRACKETED_PASTE_START}hel`);
179    await waitForRender();
180    expect(value).toBe("");
181    expect(onChangeCalls).toBe(0);
182
183    term.sendInput("lo\nwo");
184    await waitForRender();
185    expect(value).toBe("");
186    expect(onChangeCalls).toBe(0);
187
188    term.sendInput(`rld${BRACKETED_PASTE_END}`);
189    await waitForRender();
190
191    expect(value).toBe("hello\nworld");
192    expect(onChangeCalls).toBe(1);
193  });
194
195  test("bracketed paste start marker can be split at every byte boundary", async () => {
196    for (let split = 1; split < BRACKETED_PASTE_START.length; split++) {
197      if (split > 1) {
198        cel.stop();
199      }
200
201      const term = setup(20, 3);
202      let value = "";
203      let onChangeCalls = 0;
204
205      cel.viewport(() =>
206        VStack({}, [
207          TextInput({
208            value,
209            focused: true,
210            onChange: (v) => {
211              value = v;
212              onChangeCalls++;
213            },
214          }),
215        ]),
216      );
217      await waitForRender();
218
219      term.sendInput(BRACKETED_PASTE_START.slice(0, split));
220      await waitForRender();
221      expect(value).toBe("");
222      expect(onChangeCalls).toBe(0);
223
224      term.sendInput(
225        `${BRACKETED_PASTE_START.slice(split)}hi${BRACKETED_PASTE_END}`,
226      );
227      await waitForRender();
228
229      expect(value).toBe("hi");
230      expect(onChangeCalls).toBe(1);
231    }
232  });
233
234  test("a standalone legacy Escape is dispatched after the ambiguous prefix timeout", async () => {
235    const term = setup(20, 3);
236    const keys: string[] = [];
237
238    cel.viewport(() =>
239      VStack(
240        {
241          onKeyPress: (key) => {
242            keys.push(key);
243          },
244        },
245        [Text("content")],
246      ),
247    );
248    await waitForRender();
249
250    term.sendInput("\x1b");
251    await new Promise((resolve) => setTimeout(resolve, 35));
252
253    expect(keys).toEqual(["escape"]);
254  });
255
256  test("bracketed paste with no focused TextInput is ignored and does not bubble as keys", async () => {
257    const term = setup(20, 3);
258    let value = "";
259    const receivedKeys: string[] = [];
260
261    cel.viewport(() =>
262      VStack(
263        {
264          onKeyPress: (key) => {
265            receivedKeys.push(key);
266          },
267        },
268        [
269          TextInput({
270            value,
271            focused: false,
272            onChange: (v) => {
273              value = v;
274            },
275          }),
276        ],
277      ),
278    );
279    await waitForRender();
280
281    term.sendInput(bracketedPaste("abc\n\tdef"));
282    await waitForRender();
283
284    expect(value).toBe("");
285    expect(receivedKeys).toEqual([]);
286  });
287
288  test("onKeyPress receives normalized keys while TextInput inserts original text", async () => {
289    const term = setup(20, 3);
290    let keyReceived = "";
291    let value = "";
292    cel.viewport(() =>
293      VStack({}, [
294        TextInput({
295          value,
296          focused: true,
297          onChange: (v) => {
298            value = v;
299          },
300          onKeyPress: (key) => {
301            keyReceived = key;
302          },
303        }),
304      ]),
305    );
306    await waitForRender();
307
308    term.sendInput("A");
309    await waitForRender();
310
311    expect(keyReceived).toBe("a");
312    expect(value).toBe("A");
313  });
314
315  test("backspace deletes character", async () => {
316    const term = setup(20, 3);
317    let value = "abc";
318    cel.viewport(() =>
319      VStack({}, [
320        TextInput({
321          value,
322          focused: true,
323          onChange: (v) => {
324            value = v;
325          },
326        }),
327      ]),
328    );
329    await waitForRender();
330
331    // Press backspace
332    term.sendInput(BACKSPACE);
333    await waitForRender();
334
335    expect(value).toBe("ab");
336  });
337
338  test("ctrl+a and ctrl+e move to the start and end of the value", async () => {
339    const term = setup(20, 3);
340    let value = "hello";
341    const onChange = (v: string) => {
342      value = v;
343    };
344    cel.viewport(() =>
345      VStack({}, [
346        TextInput({
347          value,
348          focused: true,
349          onChange,
350        }),
351      ]),
352    );
353    await waitForRender();
354
355    term.sendInput(CTRL_A);
356    await waitForRender();
357    term.sendInput("X");
358    await waitForRender();
359
360    expect(value).toBe("Xhello");
361
362    term.sendInput(CTRL_E);
363    await waitForRender();
364    term.sendInput("!");
365    await waitForRender();
366
367    expect(value).toBe("Xhello!");
368  });
369
370  test("alt+b and alt+f move by whitespace-delimited words", async () => {
371    const term = setup(20, 3);
372    let value = "hello brave world";
373    const onChange = (v: string) => {
374      value = v;
375    };
376    cel.viewport(() =>
377      VStack({}, [
378        TextInput({
379          value,
380          focused: true,
381          onChange,
382        }),
383      ]),
384    );
385    await waitForRender();
386
387    term.sendInput(ALT_B);
388    await waitForRender();
389    term.sendInput("!");
390    await waitForRender();
391
392    expect(value).toBe("hello brave !world");
393
394    term.sendInput(CTRL_A);
395    await waitForRender();
396    term.sendInput(ALT_F);
397    await waitForRender();
398    term.sendInput("?");
399    await waitForRender();
400
401    expect(value).toBe("hello? brave !world");
402  });
403
404  test("ctrl+left and ctrl+right move by whitespace-delimited words", async () => {
405    const term = setup(20, 3);
406    let value = "hello brave world";
407    const onChange = (v: string) => {
408      value = v;
409    };
410    cel.viewport(() =>
411      VStack({}, [
412        TextInput({
413          value,
414          focused: true,
415          onChange,
416        }),
417      ]),
418    );
419    await waitForRender();
420
421    term.sendInput(CTRL_LEFT);
422    await waitForRender();
423    term.sendInput("!");
424    await waitForRender();
425
426    expect(value).toBe("hello brave !world");
427
428    term.sendInput(CTRL_A);
429    await waitForRender();
430    term.sendInput(CTRL_RIGHT);
431    await waitForRender();
432    term.sendInput("?");
433    await waitForRender();
434
435    expect(value).toBe("hello? brave !world");
436  });
437
438  test("ctrl+w and alt+d delete by whitespace-delimited words", async () => {
439    const term = setup(20, 3);
440    let value = "hello brave world";
441    const onChange = (v: string) => {
442      value = v;
443    };
444    cel.viewport(() =>
445      VStack({}, [
446        TextInput({
447          value,
448          focused: true,
449          onChange,
450        }),
451      ]),
452    );
453    await waitForRender();
454
455    term.sendInput(CTRL_W);
456    await waitForRender();
457
458    expect(value).toBe("hello brave ");
459
460    term.sendInput(CTRL_A);
461    await waitForRender();
462    term.sendInput(ALT_D);
463    await waitForRender();
464
465    expect(value).toBe(" brave ");
466  });
467
468  test("up follows visual wrapped lines in TextInput", async () => {
469    const term = setup(20, 3);
470    let value = "foo bar baz";
471    const onChange = (v: string) => {
472      value = v;
473    };
474    cel.viewport(() =>
475      VStack({}, [
476        TextInput({
477          width: 6,
478          value,
479          focused: true,
480          onChange,
481        }),
482      ]),
483    );
484    await waitForRender();
485
486    term.sendInput(UP);
487    await waitForRender();
488    term.sendInput("!");
489    await waitForRender();
490
491    expect(value).toBe("foo bar! baz");
492  });
493
494  test("down follows visual wrapped lines in TextInput", async () => {
495    const term = setup(20, 3);
496    let value = "foo bar baz";
497    const onChange = (v: string) => {
498      value = v;
499    };
500    cel.viewport(() =>
501      VStack({}, [
502        TextInput({
503          width: 6,
504          value,
505          focused: true,
506          onChange,
507        }),
508      ]),
509    );
510    await waitForRender();
511
512    term.sendInput(CTRL_A);
513    await waitForRender();
514    term.sendInput(DOWN);
515    await waitForRender();
516    term.sendInput("?");
517    await waitForRender();
518
519    expect(value).toBe("foo ?bar baz");
520  });
521
522  test("TextInput consumes editing modifier shortcuts instead of bubbling them", async () => {
523    const term = setup(20, 3);
524    let parentKey = "";
525    let value = "hello brave world";
526    cel.viewport(() =>
527      VStack(
528        {
529          onKeyPress: (key) => {
530            parentKey = key;
531          },
532        },
533        [
534          TextInput({
535            value,
536            focused: true,
537            onChange: (v) => {
538              value = v;
539            },
540          }),
541        ],
542      ),
543    );
544    await waitForRender();
545
546    term.sendInput(CTRL_W);
547    await waitForRender();
548
549    expect(value).toBe("hello brave ");
550    expect(parentKey).toBe("");
551  });
552
553  test("TextInput consumes editing keys when they are boundary no-ops", async () => {
554    const term = setup(20, 3);
555    const parentKeys: string[] = [];
556
557    cel.viewport(() =>
558      VStack(
559        {
560          onKeyPress: (key) => {
561            parentKeys.push(key);
562          },
563        },
564        [
565          TextInput({
566            value: "",
567            focused: true,
568            onChange: () => {},
569          }),
570        ],
571      ),
572    );
573    await waitForRender();
574
575    term.sendInput(
576      BACKSPACE +
577        LEFT +
578        RIGHT +
579        DELETE +
580        CTRL_LEFT +
581        CTRL_RIGHT +
582        CTRL_W +
583        ALT_B +
584        ALT_D +
585        ALT_F,
586    );
587    await waitForRender();
588
589    expect(parentKeys).toEqual([]);
590  });
591
592  test("enter inserts newline by default", async () => {
593    const term = setup(20, 3);
594    let value = "ab";
595    cel.viewport(() =>
596      VStack({}, [
597        TextInput({
598          value,
599          focused: true,
600          onChange: (v) => {
601            value = v;
602          },
603        }),
604      ]),
605    );
606    await waitForRender();
607
608    // Press enter
609    term.sendInput(ENTER);
610    await waitForRender();
611
612    expect(value).toBe("ab\n");
613  });
614
615  test("onKeyPress returning false prevents default editing action", async () => {
616    const term = setup(20, 3);
617    let submitted = false;
618    let value = "hello";
619    cel.viewport(() =>
620      VStack({}, [
621        TextInput({
622          value,
623          focused: true,
624          onChange: (v) => {
625            value = v;
626          },
627          onKeyPress: (key) => {
628            if (key === "enter") {
629              submitted = true;
630              return false;
631            }
632          },
633        }),
634      ]),
635    );
636    await waitForRender();
637
638    term.sendInput(ENTER);
639    await waitForRender();
640
641    expect(submitted).toBe(true);
642    expect(value).toBe("hello"); // No newline inserted
643  });
644
645  test("onKeyPress not returning false allows default editing", async () => {
646    const term = setup(20, 3);
647    let keyReceived = "";
648    let value = "hi";
649    cel.viewport(() =>
650      VStack({}, [
651        TextInput({
652          value,
653          focused: true,
654          onChange: (v) => {
655            value = v;
656          },
657          onKeyPress: (key) => {
658            keyReceived = key;
659            // no return false — default editing proceeds
660          },
661        }),
662      ]),
663    );
664    await waitForRender();
665
666    term.sendInput(ENTER);
667    await waitForRender();
668
669    expect(keyReceived).toBe("enter");
670    expect(value).toBe("hi\n"); // Newline inserted
671  });
672
673  test("onKeyPress returning false prevents character insertion", async () => {
674    const term = setup(20, 3);
675    let value = "abc";
676    cel.viewport(() =>
677      VStack({}, [
678        TextInput({
679          value,
680          focused: true,
681          onChange: (v) => {
682            value = v;
683          },
684          onKeyPress: (key) => {
685            if (key === "x") return false;
686          },
687        }),
688      ]),
689    );
690    await waitForRender();
691
692    // "x" should be prevented
693    term.sendInput("x");
694    await waitForRender();
695    expect(value).toBe("abc");
696
697    // "y" should go through
698    term.sendInput("y");
699    await waitForRender();
700    expect(value).toBe("abcy");
701  });
702
703  test("onKeyPress returning false prevents backspace", async () => {
704    const term = setup(20, 3);
705    let value = "abc";
706    cel.viewport(() =>
707      VStack({}, [
708        TextInput({
709          value,
710          focused: true,
711          onChange: (v) => {
712            value = v;
713          },
714          onKeyPress: (key) => {
715            if (key === "backspace") return false;
716          },
717        }),
718      ]),
719    );
720    await waitForRender();
721
722    term.sendInput(BACKSPACE);
723    await waitForRender();
724
725    expect(value).toBe("abc"); // No deletion
726  });
727
728  test("onKeyPress on TextInput fires before ancestor onKeyPress", async () => {
729    const term = setup(20, 3);
730    let parentKey = "";
731    let inputKey = "";
732    let value = "hi";
733    cel.viewport(() =>
734      VStack(
735        {
736          onKeyPress: (key) => {
737            parentKey = key;
738          },
739        },
740        [
741          TextInput({
742            value,
743            focused: true,
744            onChange: (v) => {
745              value = v;
746            },
747            onKeyPress: (key) => {
748              if (key === "enter") {
749                inputKey = key;
750                return false; // prevent default, consume key
751              }
752            },
753          }),
754        ],
755      ),
756    );
757    await waitForRender();
758
759    term.sendInput(ENTER);
760    await waitForRender();
761
762    expect(inputKey).toBe("enter");
763    expect(parentKey).toBe(""); // Ancestor never sees it
764    expect(value).toBe("hi"); // No newline
765  });
766
767  test("non-editing key bubbles to ancestor when onKeyPress doesn't intercept", async () => {
768    const term = setup(20, 3);
769    let parentKey = "";
770    let value = "hi";
771    cel.viewport(() =>
772      VStack(
773        {
774          onKeyPress: (key) => {
775            parentKey = key;
776          },
777        },
778        [
779          TextInput({
780            value,
781            focused: true,
782            onChange: (v) => {
783              value = v;
784            },
785            onKeyPress: (key) => {
786              // only intercept enter
787              if (key === "enter") return false;
788            },
789          }),
790        ],
791      ),
792    );
793    await waitForRender();
794
795    // ctrl+s is not intercepted by onKeyPress, and not an editing key — bubbles up
796    term.sendInput(CTRL_S);
797    await waitForRender();
798
799    expect(parentKey).toBe("ctrl+s"); // Bubbled up
800    expect(value).toBe("hi"); // Unchanged
801  });
802
803  test("modifier keys bubble up (not consumed by TextInput)", async () => {
804    const term = setup(20, 3);
805    let receivedKey = "";
806    let value = "text";
807    cel.viewport(() =>
808      VStack(
809        {
810          onKeyPress: (key) => {
811            receivedKey = key;
812          },
813        },
814        [
815          TextInput({
816            value,
817            focused: true,
818            onChange: (v) => {
819              value = v;
820            },
821          }),
822        ],
823      ),
824    );
825    await waitForRender();
826
827    // Ctrl+S should bubble up
828    term.sendInput(CTRL_S);
829    await waitForRender();
830
831    expect(receivedKey).toBe("ctrl+s");
832    expect(value).toBe("text"); // Value unchanged
833  });
834
835  test("legacy ctrl+letter from tmux bubbles to ancestor without editing", async () => {
836    const term = setup(20, 3);
837    let parentKey = "";
838    let value = "text";
839    cel.viewport(() =>
840      VStack(
841        {
842          onKeyPress: (key) => {
843            parentKey = key;
844          },
845        },
846        [
847          TextInput({
848            value,
849            focused: true,
850            onChange: (v) => {
851              value = v;
852            },
853          }),
854        ],
855      ),
856    );
857    await waitForRender();
858
859    term.sendInput(LEGACY_CTRL_R);
860    await waitForRender();
861
862    expect(parentKey).toBe("ctrl+r");
863    expect(value).toBe("text");
864  });
865
866  test("ESC-prefixed Alt combos bubble to ancestor without editing", async () => {
867    const term = setup(20, 3);
868    let parentKey = "";
869    let value = "text";
870    cel.viewport(() =>
871      VStack(
872        {
873          onKeyPress: (key) => {
874            parentKey = key;
875          },
876        },
877        [
878          TextInput({
879            value,
880            focused: true,
881            onChange: (v) => {
882              value = v;
883            },
884          }),
885        ],
886      ),
887    );
888    await waitForRender();
889
890    term.sendInput(LEGACY_ALT_X);
891    await waitForRender();
892
893    expect(parentKey).toBe("alt+x");
894    expect(value).toBe("text");
895  });
896
897  test("cursor position persists across re-renders", async () => {
898    const term = setup(20, 3);
899    let value = "abcdef";
900    const onChange = (v: string) => {
901      value = v;
902      cel.render();
903    };
904
905    cel.viewport(() =>
906      VStack({}, [
907        TextInput({
908          value,
909          focused: true,
910          onChange,
911        }),
912      ]),
913    );
914    await waitForRender();
915
916    // Move cursor left 3 times (from end of "abcdef")
917    term.sendInput(LEFT); // left
918    await waitForRender();
919    term.sendInput(LEFT); // left
920    await waitForRender();
921    term.sendInput(LEFT); // left
922    await waitForRender();
923
924    // Now type "X" — should insert at position 3 (after "abc")
925    term.sendInput("X");
926    await waitForRender();
927
928    expect(value).toBe("abcXdef");
929  });
930
931  test("stateKey preserves cursor across inline callback recreation", async () => {
932    const term = setup(20, 3);
933    let value = "abcdef";
934    let showHeader = false;
935
936    cel.viewport(() =>
937      VStack({}, [
938        ...(showHeader ? [Text("header")] : []),
939        TextInput({
940          stateKey: "editor",
941          value,
942          focused: true,
943          onChange: (next) => {
944            value = next;
945          },
946        }),
947      ]),
948    );
949    await waitForRender();
950
951    term.sendInput(LEFT);
952    await waitForRender();
953    term.sendInput(LEFT);
954    await waitForRender();
955    term.sendInput(LEFT);
956    await waitForRender();
957    showHeader = true;
958    cel.render();
959    await waitForRender();
960    term.sendInput("X");
961    await waitForRender();
962
963    expect(value).toBe("abcXdef");
964  });
965
966  test("controlled cursor inserts at the requested offset and reports updates", async () => {
967    const term = setup(20, 3);
968    let value = "abc";
969    let cursor = 1;
970    const cursorUpdates: number[] = [];
971
972    cel.viewport(() =>
973      VStack({}, [
974        TextInput({
975          value,
976          cursor,
977          focused: true,
978          onChange: (next) => {
979            value = next;
980          },
981          onCursorChange: (next) => {
982            cursor = next;
983            cursorUpdates.push(next);
984          },
985        }),
986      ]),
987    );
988    await waitForRender();
989
990    term.sendInput("X");
991    await waitForRender();
992    term.sendInput(RIGHT);
993    await waitForRender();
994
995    expect(value).toBe("aXbc");
996    expect(cursor).toBe(3);
997    expect(cursorUpdates).toEqual([2, 3]);
998  });
999
1000  test("controlled cursor clamps backward to a grapheme boundary", async () => {
1001    const term = setup(20, 3);
1002    let value = "A👨‍👩‍👧B";
1003    let cursor = 2; // Inside the multi-codepoint family emoji.
1004
1005    cel.viewport(() =>
1006      VStack({}, [
1007        TextInput({
1008          value,
1009          cursor,
1010          focused: true,
1011          onChange: (next) => {
1012            value = next;
1013          },
1014          onCursorChange: (next) => {
1015            cursor = next;
1016          },
1017        }),
1018      ]),
1019    );
1020    await waitForRender();
1021
1022    term.sendInput("X");
1023    await waitForRender();
1024
1025    expect(value).toBe("AX👨‍👩‍👧B");
1026    expect(cursor).toBe(2);
1027  });
1028
1029  test("programmatic controlled cursor updates take effect on the next render", async () => {
1030    const term = setup(20, 3);
1031    let value = "abc";
1032    let cursor = 0;
1033
1034    cel.viewport(() =>
1035      VStack({}, [
1036        TextInput({
1037          value,
1038          cursor,
1039          focused: true,
1040          onChange: (next) => {
1041            value = next;
1042          },
1043          onCursorChange: (next) => {
1044            cursor = next;
1045          },
1046        }),
1047      ]),
1048    );
1049    await waitForRender();
1050
1051    cursor = 3;
1052    cel.render();
1053    await waitForRender();
1054    term.sendInput("X");
1055    await waitForRender();
1056
1057    expect(value).toBe("abcX");
1058    expect(cursor).toBe(4);
1059  });
1060
1061  test("unmounting a stateKey disposes its TextInput cursor state", async () => {
1062    const term = setup(20, 3);
1063    let value = "abc";
1064    let mounted = true;
1065
1066    cel.viewport(() =>
1067      VStack(
1068        {},
1069        mounted
1070          ? [
1071              TextInput({
1072                stateKey: "editor",
1073                value,
1074                focused: true,
1075                onChange: (next) => {
1076                  value = next;
1077                },
1078              }),
1079            ]
1080          : [Text("unmounted")],
1081      ),
1082    );
1083    await waitForRender();
1084
1085    term.sendInput(LEFT);
1086    await waitForRender();
1087    mounted = false;
1088    cel.render();
1089    await waitForRender();
1090    mounted = true;
1091    cel.render();
1092    await waitForRender();
1093    term.sendInput("X");
1094    await waitForRender();
1095
1096    expect(value).toBe("abcX");
1097  });
1098
1099  test("animated sibling updates do not emit cursor commands after synchronized output", async () => {
1100    const term = setup(20, 3);
1101    let tick = 0;
1102    const onChange = () => {};
1103
1104    cel.viewport(() =>
1105      VStack({ height: "100%" }, [
1106        Text(`tick:${tick}`),
1107        TextInput({
1108          value: "abc",
1109          focused: true,
1110          onChange,
1111        }),
1112      ]),
1113    );
1114    await waitForRender();
1115
1116    term.clearOutput();
1117    tick = 1;
1118    cel.render();
1119    await waitForRender();
1120
1121    expect(term.output.endsWith("\x1b[?2026l")).toBe(true);
1122    expect(term.output).not.toContain("\x1b[?25h");
1123    expect(term.output).toContain("\x1b7");
1124    expect(term.output).toContain("\x1b8");
1125  });
1126
1127  test("auto-scrolls to keep cursor visible when typing past viewport", async () => {
1128    const term = setup(20, 3); // 3 rows tall
1129    let value = "line1\nline2\nline3";
1130    const onChange = (v: string) => {
1131      value = v;
1132      cel.render();
1133    };
1134
1135    cel.viewport(() =>
1136      VStack({}, [
1137        TextInput({
1138          value,
1139          focused: true,
1140          height: 3,
1141          onChange,
1142        }),
1143      ]),
1144    );
1145    await waitForRender();
1146
1147    // Press enter to add line4 — cursor is now on line 4 (index 3)
1148    // which is below the 3-row viewport
1149    term.sendInput(ENTER);
1150    await waitForRender();
1151
1152    // The buffer should show the cursor line (line4 area)
1153    // not the top lines. Check that the scroll adjusted.
1154    const buf = currentBuffer();
1155    // The cursor should be visible somewhere in the viewport.
1156    // With 4 lines and 3-row viewport, scroll should be at least 1.
1157    // Row 2 (bottom of viewport) should show content from line3 or line4 area.
1158    // At minimum, the empty line4 cursor should be visible.
1159    // Let's verify line1 is NOT visible (scrolled past)
1160    let hasLine1 = false;
1161    for (let x = 0; x < 20; x++) {
1162      if (buf.get(x, 0).char === "l" && buf.get(x + 1, 0).char === "i") {
1163        const row = Array.from(
1164          { length: 5 },
1165          (_, i) => buf.get(x + i, 0).char,
1166        ).join("");
1167        if (row === "line1") hasLine1 = true;
1168      }
1169    }
1170    expect(hasLine1).toBe(false);
1171  });
1172
1173  test("native cursor follows a TextInput shifted by ancestor scroll", async () => {
1174    const term = setup(10, 1);
1175    const onChange = () => {};
1176
1177    cel.viewport(() =>
1178      VStack({ width: 10, height: 1, overflow: "scroll", scrollOffset: 1 }, [
1179        Text("above"),
1180        TextInput({ value: "x", height: 1, focused: true, onChange }),
1181      ]),
1182    );
1183    await waitForRender();
1184
1185    expect(currentBuffer().get(0, 0).char).toBe("x");
1186    expect(term.output).toContain("\x1b[1;2H\x1b[1 q\x1b[?25h");
1187    expect(term.output).not.toContain("\x1b[2;2H");
1188  });
1189
1190  test("native cursor shape follows TextInput cursorStyle", async () => {
1191    const term = setup(10, 1);
1192
1193    cel.viewport(() =>
1194      TextInput({
1195        value: "x",
1196        cursorStyle: "bar",
1197        focused: true,
1198        onChange: () => {},
1199      }),
1200    );
1201    await waitForRender();
1202
1203    expect(term.output).toContain("\x1b[1;2H\x1b[5 q\x1b[?25h");
1204  });
1205
1206  test("native cursor is hidden when ancestor clipping scrolls the input away", async () => {
1207    const term = setup(10, 1);
1208    const onChange = () => {};
1209
1210    cel.viewport(() =>
1211      VStack({ width: 10, height: 1, overflow: "scroll", scrollOffset: 1 }, [
1212        TextInput({ value: "x", height: 1, focused: true, onChange }),
1213        Text("below"),
1214      ]),
1215    );
1216    await waitForRender();
1217
1218    expect(currentBuffer().get(0, 0).char).toBe("b");
1219    expect(term.output).not.toContain("\x1b[?25h");
1220    expect(term.output).not.toContain("\x1b[1;2H");
1221  });
1222
1223  test("unfocused TextInput does not consume keys", async () => {
1224    const term = setup(20, 3);
1225    let receivedKey = "";
1226    let value = "text";
1227    cel.viewport(() =>
1228      VStack(
1229        {
1230          onKeyPress: (key) => {
1231            receivedKey = key;
1232          },
1233        },
1234        [
1235          TextInput({
1236            value,
1237            focused: false,
1238            onChange: (v) => {
1239              value = v;
1240            },
1241          }),
1242        ],
1243      ),
1244    );
1245    await waitForRender();
1246
1247    term.sendInput("a");
1248    await waitForRender();
1249
1250    expect(value).toBe("text"); // Not consumed
1251    expect(receivedKey).toBe("a"); // Bubbled up
1252  });
1253
1254  test("padding insets content area", async () => {
1255    setup(20, 5);
1256    let value = "hi";
1257
1258    cel.viewport(() =>
1259      VStack({ width: 20, height: 5 }, [
1260        TextInput({
1261          width: 10,
1262          height: 3,
1263          padding: { x: 2, y: 1 },
1264          value,
1265          onChange: (v) => {
1266            value = v;
1267          },
1268          focused: true,
1269        }),
1270      ]),
1271    );
1272    await waitForRender();
1273
1274    const buf = currentBuffer();
1275    // With padding x=2, content starts at col 2. With padding y=1, content at row 1.
1276    // Content should be at (2, 1) not (0, 0)
1277    expect(buf.get(0, 0).char).toBe(" "); // padding
1278    expect(buf.get(1, 0).char).toBe(" "); // padding
1279    expect(buf.get(2, 1).char).not.toBe(" "); // content area — "h" or cursor
1280  });
1281
1282  test("cursor resets when value is cleared externally", async () => {
1283    const term = setup(30, 3);
1284    let value = "hello";
1285    const onChange = (v: string) => {
1286      value = v;
1287      cel.render();
1288    };
1289
1290    cel.viewport(() =>
1291      VStack({}, [
1292        TextInput({
1293          value,
1294          focused: true,
1295          onChange,
1296        }),
1297      ]),
1298    );
1299    await waitForRender();
1300
1301    // Type a character to confirm cursor is at end
1302    term.sendInput("!");
1303    await waitForRender();
1304    expect(value).toBe("hello!");
1305
1306    // Simulate external clear (e.g. after send)
1307    value = "";
1308    cel.render();
1309    await waitForRender();
1310
1311    // Now type again — should appear at position 0, not at stale cursor
1312    term.sendInput("a");
1313    await waitForRender();
1314    expect(value).toBe("a");
1315
1316    // Verify the text is actually visible in the buffer
1317    const buf = currentBuffer();
1318    let found = false;
1319    for (let x = 0; x < 30; x++) {
1320      if (buf.get(x, 0).char === "a") {
1321        found = true;
1322        break;
1323      }
1324    }
1325    expect(found).toBe(true);
1326  });
1327
1328  test("programmatic insert at the cursor advances the cursor", async () => {
1329    const term = setup(30, 3);
1330    let value = "abcd";
1331    const onChange = (v: string) => {
1332      value = v;
1333      cel.render();
1334    };
1335
1336    cel.viewport(() =>
1337      VStack({}, [
1338        TextInput({
1339          value,
1340          focused: true,
1341          onChange,
1342        }),
1343      ]),
1344    );
1345    await waitForRender();
1346
1347    term.sendInput(LEFT);
1348    await waitForRender();
1349    term.sendInput(LEFT);
1350    await waitForRender();
1351
1352    value = "abXcd";
1353    cel.render();
1354    await waitForRender();
1355
1356    term.sendInput("!");
1357    await waitForRender();
1358
1359    expect(value).toBe("abX!cd");
1360  });
1361
1362  test("padding affects intrinsic height", async () => {
1363    setup(20, 10);
1364    let value = "line1";
1365
1366    cel.viewport(() =>
1367      VStack({ width: 20, height: 10 }, [
1368        TextInput({
1369          width: 10,
1370          padding: { y: 1 },
1371          value,
1372          onChange: (v) => {
1373            value = v;
1374          },
1375        }),
1376        Text("after"),
1377      ]),
1378    );
1379    await waitForRender();
1380
1381    const buf = currentBuffer();
1382    // TextInput should have height 3 (1 content + 2 padding)
1383    // "after" should start at row 3
1384    let afterRow = "";
1385    for (let x = 0; x < 5; x++) afterRow += buf.get(x, 3).char;
1386    expect(afterRow).toBe("after");
1387  });
1388});