Fix incorrect IME input window positioning when "multiline input + specific conditions" occur (#45)

* Code review fixes.

More IME fixes

Checkpoint.

Cursor simplifications
Remove enableImeCursor and move the cursor to the appropriate
location without making the cursor be visible.

Gemini CLI will continue to render its own cursor so there is no need
to show the cursor as that introduces visual artifacts. Gemini CLI does
however need the cursor position to be at the correct location so IME
input works as expected.

Fixes for incremental updates in non-alternate buffer mode and tests.

* fix: improve cursor position calculation in wrapped text with dropped spaces

- Rename currentLineStartOffset to previousLineEndOffset for clearer semantics
- Add early exit to avoid unnecessary iteration
- Keep cursor at end of previous line instead of jumping to next line in gap area
- Add comments for code clarity

* fix: handle cursor position when first line is empty

* merge: master - 3aef965

---------

Co-authored-by: jacob314 <jacob314@gmail.com>

Author: iblea

src/render-node-to-output.ts

@@ -491,33 +491,54 @@ const calculateWrappedCursorPosition = (
 
 	let cursorLineIndex = lines.length - 1;
 	let relativeCursorPosition = targetOffset;
-	let currentLineStartOffset = 0;
+	// -1 represents "before document start" so first character (offset 0) is handled correctly
+	let previousLineEndOffset = -1;
 
 	for (const [i, line] of lines.entries()) {
 		if (line.length > 0) {
 			const firstChar = line.find(char => styledCharToOffset.has(char));
+			const lastChar = line.findLast(char => styledCharToOffset.has(char));
 
-			if (firstChar) {
-				const firstCharOffset = styledCharToOffset.get(firstChar)!;
-
-				if (targetOffset >= currentLineStartOffset) {
+			if (!firstChar || !lastChar) {
+				// Padding-only line (originally empty), treat as empty line
+				if (targetOffset > previousLineEndOffset) {
 					cursorLineIndex = i;
-					relativeCursorPosition = Math.max(0, targetOffset - firstCharOffset);
+					relativeCursorPosition = targetOffset - previousLineEndOffset - 1;
+					previousLineEndOffset++;
 				}
 
-				const lastChar = line.findLast(char => styledCharToOffset.has(char));
+				continue;
+			}
+
+			const lineStartOffset = styledCharToOffset.get(firstChar)!;
+			const lineEndOffset =
+				styledCharToOffset.get(lastChar)! + lastChar.value.length;
 
-				if (lastChar) {
-					currentLineStartOffset =
-						styledCharToOffset.get(lastChar)! + lastChar.value.length;
-				}
+			// Set as candidate if targetOffset is at or after line start
+			if (targetOffset >= lineStartOffset) {
+				cursorLineIndex = i;
+				relativeCursorPosition = Math.max(0, targetOffset - lineStartOffset);
 			}
-		} else if (i > 0 && targetOffset >= currentLineStartOffset) {
+
+			// Finalize and exit if targetOffset is within or before this line's range.
+			// If targetOffset is in a gap (between previousLineEndOffset and lineStartOffset),
+			// the cursor stays at the previous line's end (already set in previous iteration).
+			if (targetOffset <= lineEndOffset) {
+				break;
+			}
+
+			previousLineEndOffset = lineEndOffset;
+		} else if (i === 0 && targetOffset === 0) {
+			// Edge case: First line is empty and cursor is at position 0
+			cursorLineIndex = 0;
+			relativeCursorPosition = 0;
+			break;
+		} else if (i > 0 && targetOffset > previousLineEndOffset) {
 			// Handle empty lines (usually caused by \n)
 			cursorLineIndex = i;
-			relativeCursorPosition = targetOffset - currentLineStartOffset;
-			// Advance currentLineStartOffset past the \n
-			currentLineStartOffset++;
+			relativeCursorPosition = targetOffset - previousLineEndOffset - 1;
+			// Advance past the \n character
+			previousLineEndOffset++;
 		}
 	}
 

test/terminal-cursor.tsx

@@ -370,16 +370,13 @@ test('renderer returns correct cursorPosition for wrapped Text with dropped spac
 	root.yogaNode?.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
 
 	const result = renderer(root, false);
-	// Currently, if it's in the "gap" created by dropping spaces, it will fall through
-	// and default to the last line's beginning if not caught.
+	// When cursor is in the "gap" created by dropping spaces during wrapping,
+	// it should stay at the end of the previous line rather than jumping to next line.
 	// In "Hello   World" with width 5, lines are ["Hello", "World"].
-	// TargetOffset = 6.
-	// Line 0: offset 0, len 5. 6 >= 0 but 6 < 5 is false.
-	// Synchronization: next line starts with "W" which is at original index 8.
-	// CurrentOriginalOffset becomes 8.
-	// Line 1: offset 8, len 5. 6 >= 8 is false.
-	// Not found. Defaults to last line (1), relative pos 0.
-	t.deepEqual(result.cursorPosition, {row: 1, col: 0});
+	// TargetOffset = 6 (in dropped spaces area).
+	// Line 0: [0, 4], Line 1: [8, 12]
+	// Since 6 > 4 (line 0 end) but 6 < 8 (line 1 start), cursor stays at line 0 end.
+	t.deepEqual(result.cursorPosition, {row: 0, col: 5});
 });
 
 test('renderer returns correct cursorPosition for wrapped Text with dropped spaces - after gap', t => {
@@ -406,6 +403,83 @@ test('renderer returns correct cursorPosition for wrapped Text with dropped spac
 	t.deepEqual(result.cursorPosition, {row: 1, col: 1});
 });
 
+test('renderer returns correct cursorPosition when first line is empty', t => {
+	const root = dom.createNode('ink-root');
+	root.yogaNode?.setWidth(100);
+
+	const textNode = dom.createNode('ink-text');
+	textNode.internal_terminalCursorFocus = true;
+	textNode.internal_terminalCursorPosition = 0; // Cursor at the very beginning
+
+	// First line is empty (text starts with \n)
+	const text = dom.createTextNode('\n한글\n문제가');
+	dom.appendChildNode(textNode, text as unknown as dom.DOMElement);
+	dom.appendChildNode(root, textNode);
+
+	root.yogaNode?.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
+
+	const result = renderer(root, false);
+	// Cursor should be on the first (empty) line, not the last line
+	t.deepEqual(result.cursorPosition, {row: 0, col: 0});
+});
+
+test('renderer returns correct cursorPosition when first line is empty - cursor on second line', t => {
+	const root = dom.createNode('ink-root');
+	root.yogaNode?.setWidth(100);
+
+	const textNode = dom.createNode('ink-text');
+	textNode.internal_terminalCursorFocus = true;
+	textNode.internal_terminalCursorPosition = 1; // After the first \n, start of "한글"
+
+	const text = dom.createTextNode('\n한글\n문제가');
+	dom.appendChildNode(textNode, text as unknown as dom.DOMElement);
+	dom.appendChildNode(root, textNode);
+
+	root.yogaNode?.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
+
+	const result = renderer(root, false);
+	// Cursor should be at the start of the second line
+	t.deepEqual(result.cursorPosition, {row: 1, col: 0});
+});
+
+test('renderer handles multiple leading newlines', t => {
+	const root = dom.createNode('ink-root');
+	root.yogaNode?.setWidth(100);
+
+	const textNode = dom.createNode('ink-text');
+	textNode.internal_terminalCursorFocus = true;
+	textNode.internal_terminalCursorPosition = 0;
+
+	// Multiple empty lines at start
+	const text = dom.createTextNode('\n\n한글');
+	dom.appendChildNode(textNode, text as unknown as dom.DOMElement);
+	dom.appendChildNode(root, textNode);
+
+	root.yogaNode?.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
+
+	const result = renderer(root, false);
+	t.deepEqual(result.cursorPosition, {row: 0, col: 0});
+});
+
+test('renderer handles cursor in middle of second line after empty first', t => {
+	const root = dom.createNode('ink-root');
+	root.yogaNode?.setWidth(100);
+
+	const textNode = dom.createNode('ink-text');
+	textNode.internal_terminalCursorFocus = true;
+	textNode.internal_terminalCursorPosition = 2; // After '\n' and '한'
+
+	const text = dom.createTextNode('\n한글');
+	dom.appendChildNode(textNode, text as unknown as dom.DOMElement);
+	dom.appendChildNode(root, textNode);
+
+	root.yogaNode?.calculateLayout(undefined, undefined, Yoga.DIRECTION_LTR);
+
+	const result = renderer(root, false);
+	// '한' is a wide character (width 2), so cursor after '한' is at col 2
+	t.deepEqual(result.cursorPosition, {row: 1, col: 2});
+});
+
 // =============================================================================
 // Integration tests with Text component
 // =============================================================================