@draht/tui 2026.3.6 → 2026.3.14

package/dist/components/editor.js

@@ -1,5 +1,5 @@
 import { getEditorKeybindings } from "../keybindings.js";
-import { matchesKey } from "../keys.js";
+import { decodeKittyPrintable, matchesKey } from "../keys.js";
 import { KillRing } from "../kill-ring.js";
 import { CURSOR_MARKER } from "../tui.js";
 import { UndoStack } from "../undo-stack.js";
@@ -39,14 +39,19 @@ export function wordWrapLine(line, maxWidth) {
         const isWs = isWhitespaceChar(grapheme);
         // Overflow check before advancing.
         if (currentWidth + gWidth > maxWidth) {
-            if (wrapOppIndex >= 0) {
-                // Backtrack to last wrap opportunity.
+            if (wrapOppIndex >= 0 && currentWidth - wrapOppWidth + gWidth <= maxWidth) {
+                // Backtrack to last wrap opportunity (the remaining content
+                // plus the current grapheme still fits within maxWidth).
                 chunks.push({ text: line.slice(chunkStart, wrapOppIndex), startIndex: chunkStart, endIndex: wrapOppIndex });
                 chunkStart = wrapOppIndex;
                 currentWidth -= wrapOppWidth;
             }
             else if (chunkStart < charIndex) {
-                // No wrap opportunity: force-break at current position.
+                // No viable wrap opportunity: force-break at current position.
+                // This also handles the case where backtracking to a word
+                // boundary wouldn't help because the remaining content plus
+                // the current grapheme (e.g. a wide character) still exceeds
+                // maxWidth.
                 chunks.push({ text: line.slice(chunkStart, charIndex), startIndex: chunkStart, endIndex: charIndex });
                 chunkStart = charIndex;
                 currentWidth = 0;
@@ -68,48 +73,6 @@ 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;
-const KITTY_LOCK_MASK = 64 + 128; // Caps Lock + Num Lock
-const KITTY_ALLOWED_MODIFIERS = KITTY_MOD_SHIFT | KITTY_LOCK_MASK;
-// 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;
-    // Only accept printable CSI-u input for plain or Shift-modified text keys.
-    // Reject unsupported modifier bits (e.g. Super/Meta) to avoid inserting
-    // characters from modifier-only terminal events.
-    if ((modifier & ~KITTY_ALLOWED_MODIFIERS) !== 0)
-        return undefined;
-    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 {
     state = {
         lines: [""],
@@ -238,7 +201,7 @@ export class Editor {
     }
     /** Internal setText that doesn't reset history state - used by navigateHistory */
     setTextInternal(text) {
-        const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+        const lines = text.split("\n");
         this.state.lines = lines.length === 0 ? [""] : lines;
         this.state.cursorLine = this.state.lines.length - 1;
         this.setCursorCol(this.state.lines[this.state.cursorLine]?.length || 0);
@@ -420,6 +383,7 @@ export class Editor {
             if (kb.matches(data, "tab")) {
                 const selected = this.autocompleteList.getSelectedItem();
                 if (selected && this.autocompleteProvider) {
+                    const shouldChainSlashArgumentAutocomplete = this.shouldChainSlashArgumentAutocompleteOnTabSelection();
                     this.pushUndoSnapshot();
                     this.lastAction = null;
                     const result = this.autocompleteProvider.applyCompletion(this.state.lines, this.state.cursorLine, this.state.cursorCol, selected, this.autocompletePrefix);
@@ -429,6 +393,9 @@ export class Editor {
                     this.cancelAutocomplete();
                     if (this.onChange)
                         this.onChange(this.getText());
+                    if (shouldChainSlashArgumentAutocomplete && this.isBareCompletedSlashCommandAtCursor()) {
+                        this.tryTriggerAutocomplete();
+                    }
                 }
                 return;
             }
@@ -718,11 +685,12 @@ export class Editor {
     setText(text) {
         this.lastAction = null;
         this.historyIndex = -1; // Exit history browsing mode
+        const normalized = this.normalizeText(text);
         // Push undo snapshot if content differs (makes programmatic changes undoable)
-        if (this.getText() !== text) {
+        if (this.getText() !== normalized) {
             this.pushUndoSnapshot();
         }
-        this.setTextInternal(text);
+        this.setTextInternal(normalized);
     }
     /**
      * Insert text at the current cursor position.
@@ -737,6 +705,14 @@ export class Editor {
         this.historyIndex = -1;
         this.insertTextAtCursorInternal(text);
     }
+    /**
+     * Normalize text for editor storage:
+     * - Normalize line endings (\r\n and \r -> \n)
+     * - Expand tabs to 4 spaces
+     */
+    normalizeText(text) {
+        return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\t/g, "    ");
+    }
     /**
      * Internal text insertion at cursor. Handles single and multi-line text.
      * Does not push undo snapshots or trigger autocomplete - caller is responsible.
@@ -745,8 +721,8 @@ export class Editor {
     insertTextAtCursorInternal(text) {
         if (!text)
             return;
-        // Normalize line endings
-        const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        // Normalize line endings and tabs
+        const normalized = this.normalizeText(text);
         const insertedLines = normalized.split("\n");
         const currentLine = this.state.lines[this.state.cursorLine] || "";
         const beforeCursor = currentLine.slice(0, this.state.cursorCol);
@@ -837,12 +813,10 @@ export class Editor {
         this.historyIndex = -1; // Exit history browsing mode
         this.lastAction = null;
         this.pushUndoSnapshot();
-        // Clean the pasted text
-        const cleanText = pastedText.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-        // Convert tabs to spaces (4 spaces per tab)
-        const tabExpandedText = cleanText.replace(/\t/g, "    ");
+        // Clean the pasted text: normalize line endings, expand tabs
+        const cleanText = this.normalizeText(pastedText);
         // Filter out non-printable characters except newlines
-        let filteredText = tabExpandedText
+        let filteredText = cleanText
             .split("")
             .filter((char) => char === "\n" || char.charCodeAt(0) >= 32)
             .join("");
@@ -1578,7 +1552,49 @@ export class Editor {
     isInSlashCommandContext(textBeforeCursor) {
         return this.isSlashMenuAllowed() && textBeforeCursor.trimStart().startsWith("/");
     }
+    shouldChainSlashArgumentAutocompleteOnTabSelection() {
+        if (this.autocompleteState !== "regular") {
+            return false;
+        }
+        const currentLine = this.state.lines[this.state.cursorLine] || "";
+        const textBeforeCursor = currentLine.slice(0, this.state.cursorCol);
+        return this.isInSlashCommandContext(textBeforeCursor) && !textBeforeCursor.trimStart().includes(" ");
+    }
+    isBareCompletedSlashCommandAtCursor() {
+        const currentLine = this.state.lines[this.state.cursorLine] || "";
+        if (this.state.cursorCol !== currentLine.length) {
+            return false;
+        }
+        const textBeforeCursor = currentLine.slice(0, this.state.cursorCol).trimStart();
+        return /^\/\S+ $/.test(textBeforeCursor);
+    }
     // Autocomplete methods
+    /**
+     * Find the best autocomplete item index for the given prefix.
+     * Returns -1 if no match is found.
+     *
+     * Match priority:
+     * 1. Exact match (prefix === item.value) -> always selected
+     * 2. Prefix match -> first item whose value starts with prefix
+     * 3. No match -> -1 (keep default highlight)
+     *
+     * Matching is case-sensitive and checks item.value only.
+     */
+    getBestAutocompleteMatchIndex(items, prefix) {
+        if (!prefix)
+            return -1;
+        let firstPrefixIndex = -1;
+        for (let i = 0; i < items.length; i++) {
+            const value = items[i].value;
+            if (value === prefix) {
+                return i; // Exact match always wins
+            }
+            if (firstPrefixIndex === -1 && value.startsWith(prefix)) {
+                firstPrefixIndex = i;
+            }
+        }
+        return firstPrefixIndex;
+    }
     tryTriggerAutocomplete(explicitTab = false) {
         if (!this.autocompleteProvider)
             return;
@@ -1595,6 +1611,11 @@ export class Editor {
         if (suggestions && suggestions.items.length > 0) {
             this.autocompletePrefix = suggestions.prefix;
             this.autocompleteList = new SelectList(suggestions.items, this.autocompleteMaxVisible, this.theme.selectList);
+            // If typed prefix exactly matches one of the suggestions, select that item
+            const bestMatchIndex = this.getBestAutocompleteMatchIndex(suggestions.items, suggestions.prefix);
+            if (bestMatchIndex >= 0) {
+                this.autocompleteList.setSelectedIndex(bestMatchIndex);
+            }
             this.autocompleteState = "regular";
         }
         else {
@@ -1648,6 +1669,11 @@ export class Editor {
             }
             this.autocompletePrefix = suggestions.prefix;
             this.autocompleteList = new SelectList(suggestions.items, this.autocompleteMaxVisible, this.theme.selectList);
+            // If typed prefix exactly matches one of the suggestions, select that item
+            const bestMatchIndex = this.getBestAutocompleteMatchIndex(suggestions.items, suggestions.prefix);
+            if (bestMatchIndex >= 0) {
+                this.autocompleteList.setSelectedIndex(bestMatchIndex);
+            }
             this.autocompleteState = "force";
         }
         else {
@@ -1674,6 +1700,11 @@ export class Editor {
             this.autocompletePrefix = suggestions.prefix;
             // Always create new SelectList to ensure update
             this.autocompleteList = new SelectList(suggestions.items, this.autocompleteMaxVisible, this.theme.selectList);
+            // If typed prefix exactly matches one of the suggestions, select that item
+            const bestMatchIndex = this.getBestAutocompleteMatchIndex(suggestions.items, suggestions.prefix);
+            if (bestMatchIndex >= 0) {
+                this.autocompleteList.setSelectedIndex(bestMatchIndex);
+            }
         }
         else {
             this.cancelAutocomplete();