neonctl 2.37.1 → 2.38.1

package/dist/psql/io/lineEditor/keymap.js

@@ -1,745 +0,0 @@
-/**
- * Emacs keymap dispatch.
- *
- * Pure function: take a `KeyEvent` plus the current editor state, mutate
- * the state, and return an `Action` describing what the renderer / outer
- * loop should do (redraw, submit, signal cancel, request completion, …).
- *
- * The state lives in `EditorState`, which wraps a `LineBuffer` plus a
- * little extra context (history navigation, last-tab timestamp, search
- * mode). Keeping dispatch separate from rendering means we can write
- * deterministic key-by-key tests without touching a TTY.
- */
-import { LineBuffer } from "./buffer.js";
-export const makeState = (history = [], mode = "emacs") => ({
-    buffer: new LineBuffer(),
-    history: [...history],
-    historyIndex: -1,
-    liveSnapshot: null,
-    lastYank: null,
-    pasting: false,
-    mode,
-    viPending: null,
-    exBuffer: "",
-});
-/**
- * Apply one key event. Returns the resulting action for the outer loop.
- * All mutation happens in `state.buffer` (or the navigation fields).
- */
-export const dispatch = (state, ev) => {
-    if (state.pasting) {
-        // Inside a bracketed-paste block we treat every event as a literal char,
-        // except the closing marker.
-        if (ev.key === "paste-end") {
-            state.pasting = false;
-            return { kind: "paste-end" };
-        }
-        if (ev.key === "char" &&
-            ev.char !== undefined &&
-            !ev.ctrl &&
-            !ev.meta) {
-            state.buffer.insert(ev.char);
-            return { kind: "redraw" };
-        }
-        if (ev.key === "enter") {
-            state.buffer.insert("\n");
-            return { kind: "redraw" };
-        }
-        if (ev.key === "tab") {
-            state.buffer.insert("\t");
-            return { kind: "redraw" };
-        }
-        return { kind: "noop" };
-    }
-    // ^C always cancels regardless of mode.
-    if (ev.key === "char" && ev.ctrl && ev.char === "c") {
-        state.viPending = null;
-        return { kind: "cancel" };
-    }
-    // Route to vi dispatch when in vi modes.
-    if (state.mode === "ex") {
-        return dispatchViEx(state, ev);
-    }
-    if (state.mode === "normal") {
-        return dispatchViNormal(state, ev);
-    }
-    if (state.mode === "insert") {
-        return dispatchViInsert(state, ev);
-    }
-    switch (ev.key) {
-        case "paste-start":
-            state.pasting = true;
-            return { kind: "paste-start" };
-        case "paste-end":
-            state.pasting = false;
-            return { kind: "paste-end" };
-        case "enter":
-            return { kind: "submit" };
-        case "tab":
-            return { kind: "complete" };
-        case "backspace":
-            if (ev.meta) {
-                state.buffer.killWordLeft();
-            }
-            else {
-                state.buffer.deleteLeft();
-            }
-            return { kind: "redraw" };
-        case "delete":
-            state.buffer.deleteRight();
-            return { kind: "redraw" };
-        case "left":
-            if (ev.meta)
-                state.buffer.moveWordLeft();
-            else
-                state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "right":
-            if (ev.meta)
-                state.buffer.moveWordRight();
-            else
-                state.buffer.moveRight();
-            return { kind: "redraw" };
-        case "up":
-            return navigateHistory(state, -1);
-        case "down":
-            return navigateHistory(state, +1);
-        case "home":
-            state.buffer.moveHome();
-            return { kind: "redraw" };
-        case "end":
-            state.buffer.moveEnd();
-            return { kind: "redraw" };
-        case "escape":
-            // Bare Escape: ignore (Alt prefixes are decoded into meta:true).
-            return { kind: "noop" };
-        case "char":
-            return handleChar(state, ev);
-        case "pageup":
-        case "pagedown":
-        case "unknown":
-            return { kind: "bell" };
-    }
-};
-const handleChar = (state, ev) => {
-    const ch = ev.char ?? "";
-    if (ch.length === 0)
-        return { kind: "noop" };
-    if (ev.ctrl) {
-        switch (ch) {
-            case "a":
-                state.buffer.moveHome();
-                return { kind: "redraw" };
-            case "e":
-                state.buffer.moveEnd();
-                return { kind: "redraw" };
-            case "b":
-                state.buffer.moveLeft();
-                return { kind: "redraw" };
-            case "f":
-                state.buffer.moveRight();
-                return { kind: "redraw" };
-            case "p":
-                return navigateHistory(state, -1);
-            case "n":
-                return navigateHistory(state, +1);
-            case "k":
-                state.buffer.killToEnd();
-                return { kind: "redraw" };
-            case "u":
-                state.buffer.killToStart();
-                return { kind: "redraw" };
-            case "w":
-                state.buffer.killWordLeft();
-                return { kind: "redraw" };
-            case "y": {
-                const yanked = state.buffer.yank();
-                state.lastYank = yanked ?? null;
-                return yanked === undefined
-                    ? { kind: "bell" }
-                    : { kind: "redraw" };
-            }
-            case "c":
-                return { kind: "cancel" };
-            case "d":
-                if (state.buffer.length === 0)
-                    return { kind: "eof" };
-                state.buffer.deleteRight();
-                return { kind: "redraw" };
-            case "l":
-                return { kind: "clear-screen" };
-            case "h":
-                state.buffer.deleteLeft();
-                return { kind: "redraw" };
-            case "r":
-                return { kind: "search-start" };
-            case "t": {
-                // Transpose two chars before cursor. Edge cases per readline:
-                //  - at end-of-line, transpose the two chars before cursor
-                //  - at the very start with <2 chars, bell
-                transpose(state.buffer);
-                return { kind: "redraw" };
-            }
-            case "_":
-            case "/": // some terminals send ^/ as 0x1f
-                return state.buffer.undo()
-                    ? { kind: "redraw" }
-                    : { kind: "bell" };
-            case "g":
-                // ^G outside of search is a no-op bell.
-                return { kind: "bell" };
-            default:
-                return { kind: "bell" };
-        }
-    }
-    if (ev.meta) {
-        switch (ch) {
-            case "b":
-            case "B":
-                state.buffer.moveWordLeft();
-                return { kind: "redraw" };
-            case "f":
-            case "F":
-                state.buffer.moveWordRight();
-                return { kind: "redraw" };
-            case "d":
-            case "D":
-                state.buffer.killWordRight();
-                return { kind: "redraw" };
-            case "y":
-            case "Y":
-                if (state.lastYank === null)
-                    return { kind: "bell" };
-                {
-                    const next = state.buffer.yankPop(state.lastYank);
-                    if (next === undefined)
-                        return { kind: "bell" };
-                    state.lastYank = next;
-                }
-                return { kind: "redraw" };
-            default:
-                return { kind: "bell" };
-        }
-    }
-    // Plain printable.
-    state.buffer.insert(ch);
-    return { kind: "redraw" };
-};
-/**
- * Move history index by delta and load the corresponding entry. Saves
- * the live line on the first upward step so the user can return to it.
- */
-const navigateHistory = (state, delta) => {
-    if (state.history.length === 0)
-        return { kind: "bell" };
-    if (state.historyIndex === -1) {
-        if (delta < 0) {
-            state.liveSnapshot = state.buffer.text;
-            state.historyIndex = state.history.length - 1;
-            state.buffer.setText(state.history[state.historyIndex]);
-            return { kind: "redraw" };
-        }
-        return { kind: "bell" };
-    }
-    const next = state.historyIndex + delta;
-    if (next < 0)
-        return { kind: "bell" };
-    if (next >= state.history.length) {
-        // Stepped past newest: restore the live snapshot.
-        state.historyIndex = -1;
-        state.buffer.setText(state.liveSnapshot ?? "");
-        state.liveSnapshot = null;
-        return { kind: "redraw" };
-    }
-    state.historyIndex = next;
-    state.buffer.setText(state.history[next]);
-    return { kind: "redraw" };
-};
-// ---------------------------------------------------------------------------
-// vi mode
-// ---------------------------------------------------------------------------
-/**
- * Vi insert-mode dispatch. Behaves mostly like emacs for editing primitives —
- * printable keys insert, backspace/delete/arrows work the same way — but Esc
- * switches into normal mode. Ctrl keys are intentionally NOT vi commands here
- * (^C is handled at the top of `dispatch`).
- */
-const dispatchViInsert = (state, ev) => {
-    switch (ev.key) {
-        case "paste-start":
-            state.pasting = true;
-            return { kind: "paste-start" };
-        case "paste-end":
-            state.pasting = false;
-            return { kind: "paste-end" };
-        case "enter":
-            return { kind: "submit" };
-        case "tab":
-            return { kind: "complete" };
-        case "escape":
-            // Leave insert mode; vi convention: cursor steps left so it sits on the
-            // last inserted char (unless we were already at column 0).
-            state.mode = "normal";
-            state.viPending = null;
-            if (state.buffer.cursor > 0)
-                state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "backspace":
-            state.buffer.deleteLeft();
-            return { kind: "redraw" };
-        case "delete":
-            state.buffer.deleteRight();
-            return { kind: "redraw" };
-        case "left":
-            state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "right":
-            state.buffer.moveRight();
-            return { kind: "redraw" };
-        case "up":
-            return navigateHistory(state, -1);
-        case "down":
-            return navigateHistory(state, +1);
-        case "home":
-            state.buffer.moveHome();
-            return { kind: "redraw" };
-        case "end":
-            state.buffer.moveEnd();
-            return { kind: "redraw" };
-        case "char": {
-            const ch = ev.char ?? "";
-            if (ch.length === 0)
-                return { kind: "noop" };
-            // ^D on empty buffer still acts as EOF in either vi mode.
-            if (ev.ctrl && ch === "d" && state.buffer.length === 0) {
-                return { kind: "eof" };
-            }
-            // Ignore other control combos in vi insert; just insert plain printables.
-            if (ev.ctrl || ev.meta)
-                return { kind: "noop" };
-            state.buffer.insert(ch);
-            return { kind: "redraw" };
-        }
-        case "pageup":
-        case "pagedown":
-        case "unknown":
-            return { kind: "bell" };
-    }
-};
-/**
- * Vi normal-mode dispatch. Implements the core motion + edit subset documented
- * in the WP-24 plan: hjkl/0$^/bwe movement, x/X/dd/D/cc/cw/r/~ edits, i/a/I/A
- * to switch back to insert. Multi-key sequences (dd, cw, r<char>) are tracked
- * via `state.viPending`.
- */
-const dispatchViNormal = (state, ev) => {
-    // Pending operator awaiting its next char.
-    if (state.viPending !== null) {
-        return continueViPending(state, ev);
-    }
-    switch (ev.key) {
-        case "enter":
-            return { kind: "submit" };
-        case "tab":
-            // No completion in normal mode (matches vim/readline-vi).
-            return { kind: "bell" };
-        case "escape":
-            // Already normal; clear any half-formed operator.
-            state.viPending = null;
-            return { kind: "noop" };
-        case "backspace":
-            // In normal mode bare backspace is "move left" per readline-vi.
-            state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "delete":
-            state.buffer.deleteRight();
-            return { kind: "redraw" };
-        case "left":
-            state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "right":
-            state.buffer.moveRight();
-            return { kind: "redraw" };
-        case "up":
-            return navigateHistory(state, -1);
-        case "down":
-            return navigateHistory(state, +1);
-        case "home":
-            state.buffer.moveHome();
-            return { kind: "redraw" };
-        case "end":
-            state.buffer.moveEnd();
-            return { kind: "redraw" };
-        case "char":
-            return handleViNormalChar(state, ev);
-        case "paste-start":
-            state.pasting = true;
-            return { kind: "paste-start" };
-        case "paste-end":
-            state.pasting = false;
-            return { kind: "paste-end" };
-        case "pageup":
-        case "pagedown":
-        case "unknown":
-            return { kind: "bell" };
-    }
-};
-const handleViNormalChar = (state, ev) => {
-    const ch = ev.char ?? "";
-    if (ch.length === 0)
-        return { kind: "noop" };
-    // ^D on empty buffer is EOF in vi normal mode too.
-    if (ev.ctrl && ch === "d" && state.buffer.length === 0) {
-        return { kind: "eof" };
-    }
-    // Other ctrl/meta sequences: not bound in normal mode → bell.
-    if (ev.ctrl || ev.meta)
-        return { kind: "bell" };
-    switch (ch) {
-        // Movement
-        case "h":
-            state.buffer.moveLeft();
-            return { kind: "redraw" };
-        case "l":
-            state.buffer.moveRight();
-            return { kind: "redraw" };
-        case "b":
-            state.buffer.moveWordLeft();
-            return { kind: "redraw" };
-        case "w":
-            state.buffer.moveWordRight();
-            return { kind: "redraw" };
-        case "e":
-            viMoveEndOfWord(state.buffer);
-            return { kind: "redraw" };
-        case "0":
-            state.buffer.moveHome();
-            return { kind: "redraw" };
-        case "$":
-            state.buffer.moveEnd();
-            return { kind: "redraw" };
-        case "^":
-            viMoveFirstNonBlank(state.buffer);
-            return { kind: "redraw" };
-        // History (vi-style j/k).
-        case "j":
-            return navigateHistory(state, +1);
-        case "k":
-            return navigateHistory(state, -1);
-        // Mode switches.
-        case "i":
-            state.mode = "insert";
-            return { kind: "redraw" };
-        case "a":
-            if (state.buffer.cursor < state.buffer.length)
-                state.buffer.moveRight();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        case "I":
-            state.buffer.moveHome();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        case "A":
-            state.buffer.moveEnd();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        // Edits.
-        case "x":
-            state.buffer.deleteRight();
-            return { kind: "redraw" };
-        case "X":
-            state.buffer.deleteLeft();
-            return { kind: "redraw" };
-        case "D":
-            state.buffer.killToEnd();
-            return { kind: "redraw" };
-        case "~":
-            viToggleCaseAtCursor(state.buffer);
-            return { kind: "redraw" };
-        // Multi-key operators: wait for next char.
-        case "r":
-            state.viPending = "r";
-            return { kind: "noop" };
-        case "d":
-            state.viPending = "d";
-            return { kind: "noop" };
-        case "c":
-            state.viPending = "c";
-            return { kind: "noop" };
-        case "g":
-            // Stub: only 'gg' (go to first history) might be desirable; for now,
-            // just consume the prefix and bell on the follow-up.
-            state.viPending = "g";
-            return { kind: "noop" };
-        case ":":
-            // Enter ex-prompt mode. The renderer draws a `:` line; printable keys
-            // accumulate in `exBuffer`; Enter executes; Esc returns to normal.
-            state.mode = "ex";
-            state.exBuffer = "";
-            return { kind: "ex-update" };
-        default:
-            return { kind: "bell" };
-    }
-};
-/**
- * Vi ex-prompt dispatch (`:`-line). Mirrors a tiny slice of vim's ex grammar:
- *
- *   - `q`, `quit`, `q!` — abort the current readLine (same as ^C).
- *   - `w` (no arg)     — bell + ignore (we don't have a file to write to).
- *   - Esc              — abort ex; return to normal mode.
- *   - Enter            — execute the accumulated command.
- *
- * Printable characters extend `state.exBuffer`; Backspace shrinks it. Anything
- * else bells. The renderer is responsible for drawing `: ` + exBuffer on its
- * own row; we expose `ex-update` actions so it knows when to redraw.
- */
-const dispatchViEx = (state, ev) => {
-    switch (ev.key) {
-        case "escape":
-            // Abort ex; back to normal without executing anything.
-            state.mode = "normal";
-            state.exBuffer = "";
-            return { kind: "redraw" };
-        case "enter":
-            return executeExCommand(state);
-        case "backspace":
-            if (state.exBuffer.length === 0) {
-                // Backspace through the implicit `:` returns to normal mode (matches
-                // vim's "backspace at column 1 of ex line").
-                state.mode = "normal";
-                return { kind: "redraw" };
-            }
-            state.exBuffer = state.exBuffer.slice(0, -1);
-            return { kind: "ex-update" };
-        case "char": {
-            const ch = ev.char ?? "";
-            // Ctrl/Meta combos aren't bound in ex.
-            if (ch.length === 0 || ev.ctrl || ev.meta)
-                return { kind: "bell" };
-            state.exBuffer += ch;
-            return { kind: "ex-update" };
-        }
-        case "paste-start":
-        case "paste-end":
-        case "tab":
-        case "delete":
-        case "left":
-        case "right":
-        case "up":
-        case "down":
-        case "home":
-        case "end":
-        case "pageup":
-        case "pagedown":
-        case "unknown":
-            return { kind: "bell" };
-    }
-};
-/**
- * Interpret the accumulated ex buffer. Returns the action the driver should
- * apply (cancel = abort current readLine; bell = unknown command; redraw =
- * fall back to normal mode without side effects).
- */
-const executeExCommand = (state) => {
-    const cmd = state.exBuffer.trim();
-    // Always leave ex mode after Enter, even on unknown commands.
-    state.exBuffer = "";
-    state.mode = "normal";
-    switch (cmd) {
-        case "q":
-        case "q!":
-        case "quit":
-            // Abort the readLine. Same outcome as ^C — driver throws SignalError.
-            return { kind: "cancel" };
-        case "w":
-            // We don't have a file to write to; bell and return to normal.
-            return { kind: "bell" };
-        case "":
-            // Bare `:` then Enter — just return to normal silently.
-            return { kind: "redraw" };
-        default:
-            return { kind: "bell" };
-    }
-};
-/**
- * Resolve a pending vi operator using the next key event. `r<char>` replaces
- * one char; `dd` / `cc` operate on the whole line; `dw` / `cw` operate on a
- * word; anything else bells.
- */
-const continueViPending = (state, ev) => {
-    const pending = state.viPending;
-    state.viPending = null;
-    // Escape cancels a pending operator without bell (matches vi convention).
-    if (ev.key === "escape")
-        return { kind: "noop" };
-    if (pending === "r") {
-        // r<char> replaces one char at cursor with <char>.
-        if (ev.key !== "char" || ev.char === undefined || ev.ctrl || ev.meta) {
-            return { kind: "bell" };
-        }
-        if (state.buffer.cursor >= state.buffer.length)
-            return { kind: "bell" };
-        viReplaceCharAtCursor(state.buffer, ev.char);
-        return { kind: "redraw" };
-    }
-    if (pending === "g") {
-        // Only 'gg' is recognised; we don't actually implement first-history yet.
-        return { kind: "bell" };
-    }
-    // dd / cc / dw / cw all key off ev.char.
-    if (ev.key !== "char" || ev.char === undefined || ev.ctrl || ev.meta) {
-        return { kind: "bell" };
-    }
-    const c = ev.char;
-    if (pending === "d") {
-        if (c === "d") {
-            // dd: kill whole line.
-            state.buffer.moveHome();
-            state.buffer.killToEnd();
-            return { kind: "redraw" };
-        }
-        if (c === "w") {
-            state.buffer.killWordRight();
-            return { kind: "redraw" };
-        }
-        if (c === "b") {
-            state.buffer.killWordLeft();
-            return { kind: "redraw" };
-        }
-        if (c === "$") {
-            state.buffer.killToEnd();
-            return { kind: "redraw" };
-        }
-        if (c === "0") {
-            state.buffer.killToStart();
-            return { kind: "redraw" };
-        }
-        return { kind: "bell" };
-    }
-    if (pending === "c") {
-        if (c === "c") {
-            // cc: kill whole line, enter insert.
-            state.buffer.moveHome();
-            state.buffer.killToEnd();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        }
-        if (c === "w") {
-            state.buffer.killWordRight();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        }
-        if (c === "b") {
-            state.buffer.killWordLeft();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        }
-        if (c === "$") {
-            state.buffer.killToEnd();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        }
-        if (c === "0") {
-            state.buffer.killToStart();
-            state.mode = "insert";
-            return { kind: "redraw" };
-        }
-        return { kind: "bell" };
-    }
-    return { kind: "bell" };
-};
-/** `e` motion: jump to the end of the current word (or the next word). */
-const viMoveEndOfWord = (buf) => {
-    const text = buf.text;
-    const cps = Array.from(text);
-    let i = buf.cursor;
-    // If we're between/inside a word, move to the last char of the word that
-    // ends at or after cursor.
-    // Step 1: if cursor is at a non-word, skip to the next word's first char.
-    while (i < cps.length && !isWordChar(cps[i]))
-        i++;
-    // Step 2: if we landed inside a word, advance to its last char (one before
-    // the next non-word boundary).
-    while (i < cps.length - 1 && isWordChar(cps[i + 1]))
-        i++;
-    // Vi's `e` leaves the cursor ON the last char, not past it. Our buffer uses
-    // cursor "between code points", so put it after that last char.
-    if (i < cps.length)
-        i++;
-    buf.setText(text, i);
-};
-/** `^` motion: first non-blank char on the line. */
-const viMoveFirstNonBlank = (buf) => {
-    const text = buf.text;
-    const cps = Array.from(text);
-    let i = 0;
-    while (i < cps.length && (cps[i] === " " || cps[i] === "\t"))
-        i++;
-    buf.setText(text, i);
-};
-/** `~` toggles the case of the character at the cursor; advances cursor. */
-const viToggleCaseAtCursor = (buf) => {
-    const text = buf.text;
-    const cps = Array.from(text);
-    const i = buf.cursor;
-    if (i >= cps.length)
-        return;
-    const ch = cps[i];
-    const flipped = ch === ch.toLowerCase() ? ch.toUpperCase() : ch.toLowerCase();
-    if (flipped === ch) {
-        // Non-alpha: just advance.
-        buf.setText(text, Math.min(i + 1, cps.length));
-        return;
-    }
-    buf.pushUndo();
-    cps[i] = flipped;
-    buf.setText(cps.join(""), Math.min(i + 1, cps.length));
-};
-/** `r<char>` replaces the character at cursor and leaves cursor in place. */
-const viReplaceCharAtCursor = (buf, ch) => {
-    const text = buf.text;
-    const cps = Array.from(text);
-    const i = buf.cursor;
-    if (i >= cps.length)
-        return;
-    buf.pushUndo();
-    cps[i] = ch;
-    buf.setText(cps.join(""), i);
-};
-// Re-export for vi helpers that need word classification (matches buffer.ts).
-const isWordChar = (ch) => {
-    if (ch.length === 0)
-        return false;
-    const cp = ch.codePointAt(0) ?? 0;
-    if (cp >= 0x30 && cp <= 0x39)
-        return true; // 0-9
-    if (cp >= 0x41 && cp <= 0x5a)
-        return true; // A-Z
-    if (cp >= 0x61 && cp <= 0x7a)
-        return true; // a-z
-    if (cp === 0x5f)
-        return true; // _
-    if (cp > 0x7f)
-        return cp >= 0xa0;
-    return false;
-};
-/** ^T: swap the character before the cursor with the one before it. */
-const transpose = (buf) => {
-    const len = buf.length;
-    if (len < 2)
-        return;
-    const text = buf.text;
-    const cps = Array.from(text);
-    let i = buf.cursor;
-    if (i === 0)
-        return;
-    if (i === len)
-        i--; // at EOL: act on the last two chars
-    if (i < 1)
-        return;
-    buf.pushUndo();
-    const tmp = cps[i - 1];
-    cps[i - 1] = cps[i];
-    cps[i] = tmp;
-    buf.setText(cps.join(""), Math.min(i + 1, len));
-};