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});