indusagi 0.12.13 → 0.12.16

package/dist/tui/components/editor.js

@@ -1,6 +1,8 @@
 import { getEditorKeybindings } from "../keybindings.js";
-import { matchesKey } from "../keys.js";
+import { decodeKittyPrintable, matchesKey } from "../keys.js";
+import { KillRing } from "../kill-ring.js";
 import { ComponentBase, CURSOR_MARKER } from "../tui.js";
+import { UndoStack } from "../undo-stack.js";
 import { getSegmenter, isPunctuationChar, isWhitespaceChar, visibleWidth } from "../utils.js";
 import { SelectList } from "./select-list.js";
 const segmenter = getSegmenter();
@@ -66,81 +68,60 @@ export function wordWrapLine(line, maxWidth) {
     chunks.push({ text: line.slice(chunkStart), startIndex: chunkStart, endIndex: line.length });
     return chunks;
 }
-// Kitty CSI-u sequences for printable keys, including optional shifted/base codepoints.
-const KITTY_CSI_U_REGEX = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+))?(?::(\d+))?u$/;
-const KITTY_MOD_SHIFT = 1;
-const KITTY_MOD_ALT = 2;
-const KITTY_MOD_CTRL = 4;
-// Decode a printable CSI-u sequence, preferring the shifted key when present.
-function decodeKittyPrintable(data) {
-    const match = data.match(KITTY_CSI_U_REGEX);
-    if (!match)
-        return undefined;
-    // CSI-u groups: <codepoint>[:<shifted>[:<base>]];<mod>u
-    const codepoint = Number.parseInt(match[1] ?? "", 10);
-    if (!Number.isFinite(codepoint))
-        return undefined;
-    const shiftedKey = match[2] && match[2].length > 0 ? Number.parseInt(match[2], 10) : undefined;
-    const modValue = match[4] ? Number.parseInt(match[4], 10) : 1;
-    // Modifiers are 1-indexed in CSI-u; normalize to our bitmask.
-    const modifier = Number.isFinite(modValue) ? modValue - 1 : 0;
-    // Ignore CSI-u sequences used for Alt/Ctrl shortcuts.
-    if (modifier & (KITTY_MOD_ALT | KITTY_MOD_CTRL))
-        return undefined;
-    // Prefer the shifted keycode when Shift is held.
-    let effectiveCodepoint = codepoint;
-    if (modifier & KITTY_MOD_SHIFT && typeof shiftedKey === "number") {
-        effectiveCodepoint = shiftedKey;
-    }
-    // Drop control characters or invalid codepoints.
-    if (!Number.isFinite(effectiveCodepoint) || effectiveCodepoint < 32)
-        return undefined;
-    try {
-        return String.fromCodePoint(effectiveCodepoint);
-    }
-    catch {
-        return undefined;
-    }
-}
 export class Editor extends ComponentBase {
+    state = {
+        lines: [""],
+        cursorLine: 0,
+        cursorCol: 0,
+    };
+    /** Focusable interface - set by TUI when focus changes */
+    focused = false;
+    tui;
+    theme;
+    paddingX = 0;
+    // Store last render width for cursor navigation
+    lastWidth = 80;
+    // Vertical scrolling support
+    scrollOffset = 0;
+    // Border color (can be changed dynamically)
+    borderColor;
+    // Autocomplete support
+    autocompleteProvider;
+    autocompleteList;
+    isAutocompleting = false;
+    autocompletePrefix = "";
+    autocompleteMaxVisible = 5;
+    // Paste tracking for large pastes
+    pastes = new Map();
+    pasteCounter = 0;
+    // Bracketed paste mode buffering
+    pasteBuffer = "";
+    isInPaste = false;
+    pendingShiftEnter = false;
+    // Prompt history for up/down navigation
+    history = [];
+    historyIndex = -1; // -1 = not browsing, 0 = most recent, 1 = older, etc.
+    // Kill ring for Emacs-style kill/yank operations
+    // Also tracks undo coalescing: "type-word" means we're mid-word (coalescing)
+    killRing = new KillRing();
+    lastAction = null;
+    // Undo support
+    undoStack = new UndoStack();
+    // Sticky column navigation for wrapped lines
+    // Maintains cursor column when moving up/down through lines of different lengths
+    preferredVisualCol = null;
+    onSubmit;
+    onChange;
+    disableSubmit = false;
     constructor(tui, theme, options = {}) {
         super();
-        this.state = {
-            lines: [""],
-            cursorLine: 0,
-            cursorCol: 0,
-        };
-        /** Focusable interface - set by TUI when focus changes */
-        this.focused = false;
-        this.paddingX = 0;
-        // Store last render width for cursor navigation
-        this.lastWidth = 80;
-        // Vertical scrolling support
-        this.scrollOffset = 0;
-        this.isAutocompleting = false;
-        this.autocompletePrefix = "";
-        // Paste tracking for large pastes
-        this.pastes = new Map();
-        this.pasteCounter = 0;
-        // Bracketed paste mode buffering
-        this.pasteBuffer = "";
-        this.isInPaste = false;
-        this.pendingShiftEnter = false;
-        // Prompt history for up/down navigation
-        this.history = [];
-        this.historyIndex = -1; // -1 = not browsing, 0 = most recent, 1 = older, etc.
-        // Kill ring for Emacs-style kill/yank operations
-        // Also tracks undo coalescing: "type-word" means we're mid-word (coalescing)
-        this.killRing = [];
-        this.lastAction = null;
-        // Undo support
-        this.undoStack = [];
-        this.disableSubmit = false;
         this.tui = tui;
         this.theme = theme;
         this.borderColor = theme.borderColor;
         const paddingX = options.paddingX ?? 0;
         this.paddingX = Number.isFinite(paddingX) ? Math.max(0, Math.floor(paddingX)) : 0;
+        const maxVisible = options.autocompleteMaxVisible ?? 5;
+        this.autocompleteMaxVisible = Number.isFinite(maxVisible) ? Math.max(3, Math.min(20, Math.floor(maxVisible))) : 5;
     }
     getPaddingX() {
         return this.paddingX;
@@ -152,6 +133,16 @@ export class Editor extends ComponentBase {
             this.tui.requestRender();
         }
     }
+    getAutocompleteMaxVisible() {
+        return this.autocompleteMaxVisible;
+    }
+    setAutocompleteMaxVisible(maxVisible) {
+        const newMaxVisible = Number.isFinite(maxVisible) ? Math.max(3, Math.min(20, Math.floor(maxVisible))) : 5;
+        if (this.autocompleteMaxVisible !== newMaxVisible) {
+            this.autocompleteMaxVisible = newMaxVisible;
+            this.tui.requestRender();
+        }
+    }
     setAutocompleteProvider(provider) {
         this.autocompleteProvider = provider;
         this.invalidate();
@@ -502,7 +493,7 @@ export class Editor extends ComponentBase {
             this.pasteCounter = 0;
             this.historyIndex = -1;
             this.scrollOffset = 0;
-            this.undoStack.length = 0;
+            this.undoStack.clear();
             this.lastAction = null;
             if (this.onChange)
                 this.onChange("");
@@ -899,14 +890,93 @@ export class Editor extends ComponentBase {
             }
         }
     }
+    /**
+     * Set cursor column and clear sticky column preference.
+     * Call this for any direct column positioning or horizontal movement.
+     */
+    setCursorCol(col) {
+        this.state.cursorCol = col;
+        this.preferredVisualCol = null;
+    }
+    /**
+     * Move cursor to a target visual line, applying sticky column logic.
+     * Preserves the cursor column when moving between wrapped lines of different widths.
+     */
+    moveToVisualLine(visualLines, currentVisualLine, targetVisualLine) {
+        const currentVL = visualLines[currentVisualLine];
+        const targetVL = visualLines[targetVisualLine];
+        if (currentVL && targetVL) {
+            const currentVisualCol = this.state.cursorCol - currentVL.startCol;
+            // For non-last segments, clamp to length-1 to stay within the segment
+            const isLastSourceSegment = currentVisualLine === visualLines.length - 1 ||
+                visualLines[currentVisualLine + 1]?.logicalLine !== currentVL.logicalLine;
+            const sourceMaxVisualCol = isLastSourceSegment ? currentVL.length : Math.max(0, currentVL.length - 1);
+            const isLastTargetSegment = targetVisualLine === visualLines.length - 1 ||
+                visualLines[targetVisualLine + 1]?.logicalLine !== targetVL.logicalLine;
+            const targetMaxVisualCol = isLastTargetSegment ? targetVL.length : Math.max(0, targetVL.length - 1);
+            const moveToVisualCol = this.computeVerticalMoveColumn(currentVisualCol, sourceMaxVisualCol, targetMaxVisualCol);
+            // Set cursor position
+            this.state.cursorLine = targetVL.logicalLine;
+            const targetCol = targetVL.startCol + moveToVisualCol;
+            const logicalLine = this.state.lines[targetVL.logicalLine] || "";
+            this.state.cursorCol = Math.min(targetCol, logicalLine.length);
+        }
+    }
+    /**
+     * Compute the target visual column for vertical cursor movement.
+     * Implements sticky column logic: maintains the cursor column when moving between
+     * wrapped lines of different lengths.
+     *
+     * Decision table:
+     * | P | S | T | U | Scenario                                             | Set Preferred | Move To     |
+     * |---|---|---|---| ---------------------------------------------------- |---------------|-------------|
+     * | 0 | * | 0 | - | Start nav, target fits                               | null          | current     |
+     * | 0 | * | 1 | - | Start nav, target shorter                            | current       | target end  |
+     * | 1 | 0 | 0 | 0 | Clamped, target fits preferred                       | null          | preferred   |
+     * | 1 | 0 | 0 | 1 | Clamped, target longer but still can't fit preferred | keep          | target end  |
+     * | 1 | 0 | 1 | - | Clamped, target even shorter                         | keep          | target end  |
+     * | 1 | 1 | 0 | - | Rewrapped, target fits current                       | null          | current     |
+     * | 1 | 1 | 1 | - | Rewrapped, target shorter than current               | current       | target end  |
+     *
+     * Where:
+     * - P = preferred col is set
+     * - S = cursor in middle of source line (not clamped to end)
+     * - T = target line shorter than current visual col
+     * - U = target line shorter than preferred col
+     */
+    computeVerticalMoveColumn(currentVisualCol, sourceMaxVisualCol, targetMaxVisualCol) {
+        const hasPreferred = this.preferredVisualCol !== null; // P
+        const cursorInMiddle = currentVisualCol < sourceMaxVisualCol; // S
+        const targetTooShort = targetMaxVisualCol < currentVisualCol; // T
+        if (!hasPreferred || cursorInMiddle) {
+            if (targetTooShort) {
+                // Cases 2 and 7: Start of navigation with target shorter than current
+                // Save current column as preferred for later restoration
+                this.preferredVisualCol = currentVisualCol;
+                return targetMaxVisualCol;
+            }
+            // Cases 1 and 6: Target fits current column
+            this.preferredVisualCol = null;
+            return currentVisualCol;
+        }
+        const targetCantFitPreferred = targetMaxVisualCol < this.preferredVisualCol; // U
+        if (targetTooShort || targetCantFitPreferred) {
+            // Cases 4 and 5: Target can't fit preferred, clamp to target end
+            return targetMaxVisualCol;
+        }
+        // Case 3: Target can fit preferred, restore it and clear preference
+        const result = this.preferredVisualCol;
+        this.preferredVisualCol = null;
+        return result;
+    }
     moveToLineStart() {
         this.lastAction = null;
-        this.state.cursorCol = 0;
+        this.setCursorCol(0);
     }
     moveToLineEnd() {
         this.lastAction = null;
         const currentLine = this.state.lines[this.state.cursorLine] || "";
-        this.state.cursorCol = currentLine.length;
+        this.setCursorCol(currentLine.length);
     }
     deleteToStartOfLine() {
         this.historyIndex = -1; // Exit history browsing mode
@@ -1138,20 +1208,10 @@ export class Editor extends ComponentBase {
             // Build visual line map for navigation
             const visualLines = this.buildVisualLineMap(width);
             const currentVisualLine = this.findCurrentVisualLine(visualLines);
-            // Calculate column position within current visual line
-            const currentVL = visualLines[currentVisualLine];
-            const visualCol = currentVL ? this.state.cursorCol - currentVL.startCol : 0;
-            // Move to target visual line
+            // Move to target visual line with sticky column logic
             const targetVisualLine = currentVisualLine + deltaLine;
             if (targetVisualLine >= 0 && targetVisualLine < visualLines.length) {
-                const targetVL = visualLines[targetVisualLine];
-                if (targetVL) {
-                    this.state.cursorLine = targetVL.logicalLine;
-                    // Try to maintain visual column position, clamped to line length
-                    const targetCol = targetVL.startCol + Math.min(visualCol, targetVL.length);
-                    const logicalLine = this.state.lines[targetVL.logicalLine] || "";
-                    this.state.cursorCol = Math.min(targetCol, logicalLine.length);
-                }
+                this.moveToVisualLine(visualLines, currentVisualLine, targetVisualLine);
             }
         }
         if (deltaCol !== 0) {
@@ -1162,12 +1222,12 @@ export class Editor extends ComponentBase {
                     const afterCursor = currentLine.slice(this.state.cursorCol);
                     const graphemes = [...segmenter.segment(afterCursor)];
                     const firstGrapheme = graphemes[0];
-                    this.state.cursorCol += firstGrapheme ? firstGrapheme.segment.length : 1;
+                    this.setCursorCol(this.state.cursorCol + (firstGrapheme ? firstGrapheme.segment.length : 1));
                 }
                 else if (this.state.cursorLine < this.state.lines.length - 1) {
                     // Wrap to start of next logical line
                     this.state.cursorLine++;
-                    this.state.cursorCol = 0;
+                    this.setCursorCol(0);
                 }
             }
             else {
@@ -1176,13 +1236,13 @@ export class Editor extends ComponentBase {
                     const beforeCursor = currentLine.slice(0, this.state.cursorCol);
                     const graphemes = [...segmenter.segment(beforeCursor)];
                     const lastGrapheme = graphemes[graphemes.length - 1];
-                    this.state.cursorCol -= lastGrapheme ? lastGrapheme.segment.length : 1;
+                    this.setCursorCol(this.state.cursorCol - (lastGrapheme ? lastGrapheme.segment.length : 1));
                 }
                 else if (this.state.cursorLine > 0) {
                     // Wrap to end of previous logical line
                     this.state.cursorLine--;
                     const prevLine = this.state.lines[this.state.cursorLine] || "";
-                    this.state.cursorCol = prevLine.length;
+                    this.setCursorCol(prevLine.length);
                 }
             }
         }
@@ -1201,17 +1261,8 @@ export class Editor extends ComponentBase {
         const currentVisualLine = this.findCurrentVisualLine(visualLines);
         // Calculate target visual line
         const targetVisualLine = Math.max(0, Math.min(visualLines.length - 1, currentVisualLine + direction * pageSize));
-        // Move cursor to target visual line
-        const targetVL = visualLines[targetVisualLine];
-        if (targetVL) {
-            // Preserve column position within the line
-            const currentVL = visualLines[currentVisualLine];
-            const visualCol = currentVL ? this.state.cursorCol - currentVL.startCol : 0;
-            this.state.cursorLine = targetVL.logicalLine;
-            const targetCol = targetVL.startCol + Math.min(visualCol, targetVL.length);
-            const logicalLine = this.state.lines[targetVL.logicalLine] || "";
-            this.state.cursorCol = Math.min(targetCol, logicalLine.length);
-        }
+        // Move cursor to target visual line with sticky column logic
+        this.moveToVisualLine(visualLines, currentVisualLine, targetVisualLine);
     }
     moveWordBackwards() {
         this.lastAction = null;
@@ -1258,7 +1309,7 @@ export class Editor extends ComponentBase {
         if (this.killRing.length === 0)
             return;
         this.pushUndoSnapshot();
-        const text = this.killRing[this.killRing.length - 1] || "";
+        const text = this.killRing.peek();
         this.insertYankedText(text);
         this.lastAction = "yank";
     }
@@ -1274,10 +1325,9 @@ export class Editor extends ComponentBase {
         // Delete the previously yanked text (still at end of ring before rotation)
         this.deleteYankedText();
         // Rotate the ring: move end to front
-        const lastEntry = this.killRing.pop();
-        this.killRing.unshift(lastEntry);
+        this.killRing.rotate();
         // Insert the new most recent entry (now at end after rotation)
-        const text = this.killRing[this.killRing.length - 1];
+        const text = this.killRing.peek();
         this.insertYankedText(text);
         this.lastAction = "yank";
     }
@@ -1319,10 +1369,10 @@ export class Editor extends ComponentBase {
     }
     /**
      * Delete the previously yanked text (used by yank-pop).
-     * The yanked text is derived from killRing[end] since it hasn't been rotated yet.
+     * The yanked text is derived from killRing.peek() since it hasn't been rotated yet.
      */
     deleteYankedText() {
-        const yankedText = this.killRing[this.killRing.length - 1] || "";
+        const yankedText = this.killRing.peek();
         if (!yankedText)
             return;
         const yankLines = yankedText.split("\n");
@@ -1360,38 +1410,17 @@ export class Editor extends ComponentBase {
      * @param prepend - If accumulating, prepend (true) or append (false) to existing entry
      */
     addToKillRing(text, prepend) {
-        if (!text)
-            return;
-        if (this.lastAction === "kill" && this.killRing.length > 0) {
-            // Accumulate with the most recent entry (at end of array)
-            const lastEntry = this.killRing.pop();
-            if (prepend) {
-                this.killRing.push(text + lastEntry);
-            }
-            else {
-                this.killRing.push(lastEntry + text);
-            }
-        }
-        else {
-            // Add new entry to end of ring
-            this.killRing.push(text);
-        }
-    }
-    captureUndoSnapshot() {
-        return structuredClone(this.state);
-    }
-    restoreUndoSnapshot(snapshot) {
-        Object.assign(this.state, structuredClone(snapshot));
+        this.killRing.push(text, { prepend, accumulate: this.lastAction === "kill" });
     }
     pushUndoSnapshot() {
-        this.undoStack.push(this.captureUndoSnapshot());
+        this.undoStack.push(this.state);
     }
     undo() {
         this.historyIndex = -1; // Exit history browsing mode
-        if (this.undoStack.length === 0)
-            return;
         const snapshot = this.undoStack.pop();
-        this.restoreUndoSnapshot(snapshot);
+        if (!snapshot)
+            return;
+        Object.assign(this.state, snapshot);
         this.lastAction = null;
         if (this.onChange) {
             this.onChange(this.getText());
@@ -1472,7 +1501,7 @@ export class Editor extends ComponentBase {
         const suggestions = this.autocompleteProvider.getSuggestions(this.state.lines, this.state.cursorLine, this.state.cursorCol);
         if (suggestions && suggestions.items.length > 0) {
             this.autocompletePrefix = suggestions.prefix;
-            this.autocompleteList = new SelectList(suggestions.items, 5, this.theme.selectList);
+            this.autocompleteList = new SelectList(suggestions.items, this.autocompleteMaxVisible, this.theme.selectList);
             this.isAutocompleting = true;
         }
         else {
@@ -1512,7 +1541,7 @@ https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19536643416/job/
         const suggestions = provider.getForceFileSuggestions(this.state.lines, this.state.cursorLine, this.state.cursorCol);
         if (suggestions && suggestions.items.length > 0) {
             this.autocompletePrefix = suggestions.prefix;
-            this.autocompleteList = new SelectList(suggestions.items, 5, this.theme.selectList);
+            this.autocompleteList = new SelectList(suggestions.items, this.autocompleteMaxVisible, this.theme.selectList);
             this.isAutocompleting = true;
         }
         else {
@@ -1534,7 +1563,7 @@ https://github.com/EsotericSoftware/spine-runtimes/actions/runs/19536643416/job/
         if (suggestions && suggestions.items.length > 0) {
             this.autocompletePrefix = suggestions.prefix;
             // Always create new SelectList to ensure update
-            this.autocompleteList = new SelectList(suggestions.items, 5, this.theme.selectList);
+            this.autocompleteList = new SelectList(suggestions.items, this.autocompleteMaxVisible, this.theme.selectList);
         }
         else {
             this.cancelAutocomplete();