indusagi 0.12.16 → 0.12.18

package/dist/tui/components/editor.js

@@ -1,8 +1,6 @@
 import { getEditorKeybindings } from "../keybindings.js";
-import { decodeKittyPrintable, matchesKey } from "../keys.js";
-import { KillRing } from "../kill-ring.js";
+import { matchesKey } from "../keys.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();
@@ -68,60 +66,81 @@ 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;
@@ -133,16 +152,6 @@ 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();
@@ -493,7 +502,7 @@ export class Editor extends ComponentBase {
             this.pasteCounter = 0;
             this.historyIndex = -1;
             this.scrollOffset = 0;
-            this.undoStack.clear();
+            this.undoStack.length = 0;
             this.lastAction = null;
             if (this.onChange)
                 this.onChange("");
@@ -890,93 +899,14 @@ 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.setCursorCol(0);
+        this.state.cursorCol = 0;
     }
     moveToLineEnd() {
         this.lastAction = null;
         const currentLine = this.state.lines[this.state.cursorLine] || "";
-        this.setCursorCol(currentLine.length);
+        this.state.cursorCol = currentLine.length;
     }
     deleteToStartOfLine() {
         this.historyIndex = -1; // Exit history browsing mode
@@ -1208,10 +1138,20 @@ export class Editor extends ComponentBase {
             // Build visual line map for navigation
             const visualLines = this.buildVisualLineMap(width);
             const currentVisualLine = this.findCurrentVisualLine(visualLines);
-            // Move to target visual line with sticky column logic
+            // 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
             const targetVisualLine = currentVisualLine + deltaLine;
             if (targetVisualLine >= 0 && targetVisualLine < visualLines.length) {
-                this.moveToVisualLine(visualLines, currentVisualLine, targetVisualLine);
+                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);
+                }
             }
         }
         if (deltaCol !== 0) {
@@ -1222,12 +1162,12 @@ export class Editor extends ComponentBase {
                     const afterCursor = currentLine.slice(this.state.cursorCol);
                     const graphemes = [...segmenter.segment(afterCursor)];
                     const firstGrapheme = graphemes[0];
-                    this.setCursorCol(this.state.cursorCol + (firstGrapheme ? firstGrapheme.segment.length : 1));
+                    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.setCursorCol(0);
+                    this.state.cursorCol = 0;
                 }
             }
             else {
@@ -1236,13 +1176,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.setCursorCol(this.state.cursorCol - (lastGrapheme ? lastGrapheme.segment.length : 1));
+                    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.setCursorCol(prevLine.length);
+                    this.state.cursorCol = prevLine.length;
                 }
             }
         }
@@ -1261,8 +1201,17 @@ 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 with sticky column logic
-        this.moveToVisualLine(visualLines, currentVisualLine, targetVisualLine);
+        // 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);
+        }
     }
     moveWordBackwards() {
         this.lastAction = null;
@@ -1309,7 +1258,7 @@ export class Editor extends ComponentBase {
         if (this.killRing.length === 0)
             return;
         this.pushUndoSnapshot();
-        const text = this.killRing.peek();
+        const text = this.killRing[this.killRing.length - 1] || "";
         this.insertYankedText(text);
         this.lastAction = "yank";
     }
@@ -1325,9 +1274,10 @@ 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
-        this.killRing.rotate();
+        const lastEntry = this.killRing.pop();
+        this.killRing.unshift(lastEntry);
         // Insert the new most recent entry (now at end after rotation)
-        const text = this.killRing.peek();
+        const text = this.killRing[this.killRing.length - 1];
         this.insertYankedText(text);
         this.lastAction = "yank";
     }
@@ -1369,10 +1319,10 @@ export class Editor extends ComponentBase {
     }
     /**
      * Delete the previously yanked text (used by yank-pop).
-     * The yanked text is derived from killRing.peek() since it hasn't been rotated yet.
+     * The yanked text is derived from killRing[end] since it hasn't been rotated yet.
      */
     deleteYankedText() {
-        const yankedText = this.killRing.peek();
+        const yankedText = this.killRing[this.killRing.length - 1] || "";
         if (!yankedText)
             return;
         const yankLines = yankedText.split("\n");
@@ -1410,17 +1360,38 @@ export class Editor extends ComponentBase {
      * @param prepend - If accumulating, prepend (true) or append (false) to existing entry
      */
     addToKillRing(text, prepend) {
-        this.killRing.push(text, { prepend, accumulate: this.lastAction === "kill" });
+        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));
     }
     pushUndoSnapshot() {
-        this.undoStack.push(this.state);
+        this.undoStack.push(this.captureUndoSnapshot());
     }
     undo() {
         this.historyIndex = -1; // Exit history browsing mode
-        const snapshot = this.undoStack.pop();
-        if (!snapshot)
+        if (this.undoStack.length === 0)
             return;
-        Object.assign(this.state, snapshot);
+        const snapshot = this.undoStack.pop();
+        this.restoreUndoSnapshot(snapshot);
         this.lastAction = null;
         if (this.onChange) {
             this.onChange(this.getText());
@@ -1501,7 +1472,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, this.autocompleteMaxVisible, this.theme.selectList);
+            this.autocompleteList = new SelectList(suggestions.items, 5, this.theme.selectList);
             this.isAutocompleting = true;
         }
         else {
@@ -1541,7 +1512,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, this.autocompleteMaxVisible, this.theme.selectList);
+            this.autocompleteList = new SelectList(suggestions.items, 5, this.theme.selectList);
             this.isAutocompleting = true;
         }
         else {
@@ -1563,7 +1534,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, this.autocompleteMaxVisible, this.theme.selectList);
+            this.autocompleteList = new SelectList(suggestions.items, 5, this.theme.selectList);
         }
         else {
             this.cancelAutocomplete();