@aexol/spectral 0.7.7 → 0.8.0

package/dist/pi/tui/components/image.js

@@ -1,88 +0,0 @@
-import { allocateImageId, getCapabilities, getCellDimensions, getImageDimensions, imageFallback, renderImage, } from "../terminal-image.js";
-export class Image {
-    base64Data;
-    mimeType;
-    dimensions;
-    theme;
-    options;
-    imageId;
-    cachedLines;
-    cachedWidth;
-    constructor(base64Data, mimeType, theme, options = {}, dimensions) {
-        this.base64Data = base64Data;
-        this.mimeType = mimeType;
-        this.theme = theme;
-        this.options = options;
-        this.dimensions = dimensions || getImageDimensions(base64Data, mimeType) || { widthPx: 800, heightPx: 600 };
-        this.imageId = options.imageId;
-    }
-    /** Get the Kitty image ID used by this image (if any). */
-    getImageId() {
-        return this.imageId;
-    }
-    invalidate() {
-        this.cachedLines = undefined;
-        this.cachedWidth = undefined;
-    }
-    render(width) {
-        if (this.cachedLines && this.cachedWidth === width) {
-            return this.cachedLines;
-        }
-        const maxWidth = Math.max(1, Math.min(width - 2, this.options.maxWidthCells ?? 60));
-        const cellDimensions = getCellDimensions();
-        const defaultMaxHeight = Math.max(1, Math.ceil((maxWidth * cellDimensions.widthPx) / cellDimensions.heightPx));
-        const maxHeight = this.options.maxHeightCells ?? defaultMaxHeight;
-        const caps = getCapabilities();
-        let lines;
-        if (caps.images) {
-            if (caps.images === "kitty" && this.imageId === undefined) {
-                this.imageId = allocateImageId();
-            }
-            const result = renderImage(this.base64Data, this.dimensions, {
-                maxWidthCells: maxWidth,
-                maxHeightCells: maxHeight,
-                imageId: this.imageId,
-                moveCursor: false,
-            });
-            if (result) {
-                // Store the image ID for later cleanup
-                if (result.imageId) {
-                    this.imageId = result.imageId;
-                }
-                if (caps.images === "kitty") {
-                    // For Kitty: C=1 prevents cursor movement.
-                    // Don't need the cursor movement.
-                    lines = [result.sequence];
-                    // Return `rows` lines so TUI accounts for image height.
-                    for (let i = 0; i < result.rows - 1; i++) {
-                        lines.push("");
-                    }
-                }
-                else {
-                    // Return `rows` lines so TUI accounts for image height.
-                    // First (rows-1) lines are empty and cleared before the image is drawn.
-                    // Last line: move cursor back up, draw the image, then move back down
-                    // so TUI cursor accounting stays inside the scroll area.
-                    lines = [];
-                    for (let i = 0; i < result.rows - 1; i++) {
-                        lines.push("");
-                    }
-                    const rowOffset = result.rows - 1;
-                    const moveUp = rowOffset > 0 ? `\x1b[${rowOffset}A` : "";
-                    lines.push(moveUp + result.sequence);
-                }
-            }
-            else {
-                const fallback = imageFallback(this.mimeType, this.dimensions, this.options.filename);
-                lines = [this.theme.fallbackColor(fallback)];
-            }
-        }
-        else {
-            const fallback = imageFallback(this.mimeType, this.dimensions, this.options.filename);
-            lines = [this.theme.fallbackColor(fallback)];
-        }
-        this.cachedLines = lines;
-        this.cachedWidth = width;
-        return lines;
-    }
-}

package/dist/pi/tui/components/input.js

@@ -1,425 +0,0 @@
-import { getKeybindings } from "../keybindings.js";
-import { decodeKittyPrintable } from "../keys.js";
-import { KillRing } from "../kill-ring.js";
-import { CURSOR_MARKER } from "../tui.js";
-import { UndoStack } from "../undo-stack.js";
-import { getSegmenter, isPunctuationChar, isWhitespaceChar, sliceByColumn, visibleWidth } from "../utils.js";
-const segmenter = getSegmenter();
-/**
- * Input component - single-line text input with horizontal scrolling
- */
-export class Input {
-    value = "";
-    cursor = 0; // Cursor position in the value
-    onSubmit;
-    onEscape;
-    /** Focusable interface - set by TUI when focus changes */
-    focused = false;
-    // Bracketed paste mode buffering
-    pasteBuffer = "";
-    isInPaste = false;
-    // Kill ring for Emacs-style kill/yank operations
-    killRing = new KillRing();
-    lastAction = null;
-    // Undo support
-    undoStack = new UndoStack();
-    getValue() {
-        return this.value;
-    }
-    setValue(value) {
-        this.value = value;
-        this.cursor = Math.min(this.cursor, value.length);
-    }
-    handleInput(data) {
-        // Handle bracketed paste mode
-        // Start of paste: \x1b[200~
-        // End of paste: \x1b[201~
-        // Check if we're starting a bracketed paste
-        if (data.includes("\x1b[200~")) {
-            this.isInPaste = true;
-            this.pasteBuffer = "";
-            data = data.replace("\x1b[200~", "");
-        }
-        // If we're in a paste, buffer the data
-        if (this.isInPaste) {
-            // Check if this chunk contains the end marker
-            this.pasteBuffer += data;
-            const endIndex = this.pasteBuffer.indexOf("\x1b[201~");
-            if (endIndex !== -1) {
-                // Extract the pasted content
-                const pasteContent = this.pasteBuffer.substring(0, endIndex);
-                // Process the complete paste
-                this.handlePaste(pasteContent);
-                // Reset paste state
-                this.isInPaste = false;
-                // Handle any remaining input after the paste marker
-                const remaining = this.pasteBuffer.substring(endIndex + 6); // 6 = length of \x1b[201~
-                this.pasteBuffer = "";
-                if (remaining) {
-                    this.handleInput(remaining);
-                }
-            }
-            return;
-        }
-        const kb = getKeybindings();
-        // Escape/Cancel
-        if (kb.matches(data, "tui.select.cancel")) {
-            if (this.onEscape)
-                this.onEscape();
-            return;
-        }
-        // Undo
-        if (kb.matches(data, "tui.editor.undo")) {
-            this.undo();
-            return;
-        }
-        // Submit
-        if (kb.matches(data, "tui.input.submit") || data === "\n") {
-            if (this.onSubmit)
-                this.onSubmit(this.value);
-            return;
-        }
-        // Deletion
-        if (kb.matches(data, "tui.editor.deleteCharBackward")) {
-            this.handleBackspace();
-            return;
-        }
-        if (kb.matches(data, "tui.editor.deleteCharForward")) {
-            this.handleForwardDelete();
-            return;
-        }
-        if (kb.matches(data, "tui.editor.deleteWordBackward")) {
-            this.deleteWordBackwards();
-            return;
-        }
-        if (kb.matches(data, "tui.editor.deleteWordForward")) {
-            this.deleteWordForward();
-            return;
-        }
-        if (kb.matches(data, "tui.editor.deleteToLineStart")) {
-            this.deleteToLineStart();
-            return;
-        }
-        if (kb.matches(data, "tui.editor.deleteToLineEnd")) {
-            this.deleteToLineEnd();
-            return;
-        }
-        // Kill ring actions
-        if (kb.matches(data, "tui.editor.yank")) {
-            this.yank();
-            return;
-        }
-        if (kb.matches(data, "tui.editor.yankPop")) {
-            this.yankPop();
-            return;
-        }
-        // Cursor movement
-        if (kb.matches(data, "tui.editor.cursorLeft")) {
-            this.lastAction = null;
-            if (this.cursor > 0) {
-                const beforeCursor = this.value.slice(0, this.cursor);
-                const graphemes = [...segmenter.segment(beforeCursor)];
-                const lastGrapheme = graphemes[graphemes.length - 1];
-                this.cursor -= lastGrapheme ? lastGrapheme.segment.length : 1;
-            }
-            return;
-        }
-        if (kb.matches(data, "tui.editor.cursorRight")) {
-            this.lastAction = null;
-            if (this.cursor < this.value.length) {
-                const afterCursor = this.value.slice(this.cursor);
-                const graphemes = [...segmenter.segment(afterCursor)];
-                const firstGrapheme = graphemes[0];
-                this.cursor += firstGrapheme ? firstGrapheme.segment.length : 1;
-            }
-            return;
-        }
-        if (kb.matches(data, "tui.editor.cursorLineStart")) {
-            this.lastAction = null;
-            this.cursor = 0;
-            return;
-        }
-        if (kb.matches(data, "tui.editor.cursorLineEnd")) {
-            this.lastAction = null;
-            this.cursor = this.value.length;
-            return;
-        }
-        if (kb.matches(data, "tui.editor.cursorWordLeft")) {
-            this.moveWordBackwards();
-            return;
-        }
-        if (kb.matches(data, "tui.editor.cursorWordRight")) {
-            this.moveWordForwards();
-            return;
-        }
-        // Kitty CSI-u printable character (e.g. \x1b[97u for 'a').
-        // Terminals with Kitty protocol flag 1 (disambiguate) send CSI-u for all keys,
-        // including plain printable characters. Decode before the control-char check
-        // since CSI-u sequences contain \x1b which would be rejected.
-        const kittyPrintable = decodeKittyPrintable(data);
-        if (kittyPrintable !== undefined) {
-            this.insertCharacter(kittyPrintable);
-            return;
-        }
-        // Regular character input - accept printable characters including Unicode,
-        // but reject control characters (C0: 0x00-0x1F, DEL: 0x7F, C1: 0x80-0x9F)
-        const hasControlChars = [...data].some((ch) => {
-            const code = ch.charCodeAt(0);
-            return code < 32 || code === 0x7f || (code >= 0x80 && code <= 0x9f);
-        });
-        if (!hasControlChars) {
-            this.insertCharacter(data);
-        }
-    }
-    insertCharacter(char) {
-        // Undo coalescing: consecutive word chars coalesce into one undo unit
-        if (isWhitespaceChar(char) || this.lastAction !== "type-word") {
-            this.pushUndo();
-        }
-        this.lastAction = "type-word";
-        this.value = this.value.slice(0, this.cursor) + char + this.value.slice(this.cursor);
-        this.cursor += char.length;
-    }
-    handleBackspace() {
-        this.lastAction = null;
-        if (this.cursor > 0) {
-            this.pushUndo();
-            const beforeCursor = this.value.slice(0, this.cursor);
-            const graphemes = [...segmenter.segment(beforeCursor)];
-            const lastGrapheme = graphemes[graphemes.length - 1];
-            const graphemeLength = lastGrapheme ? lastGrapheme.segment.length : 1;
-            this.value = this.value.slice(0, this.cursor - graphemeLength) + this.value.slice(this.cursor);
-            this.cursor -= graphemeLength;
-        }
-    }
-    handleForwardDelete() {
-        this.lastAction = null;
-        if (this.cursor < this.value.length) {
-            this.pushUndo();
-            const afterCursor = this.value.slice(this.cursor);
-            const graphemes = [...segmenter.segment(afterCursor)];
-            const firstGrapheme = graphemes[0];
-            const graphemeLength = firstGrapheme ? firstGrapheme.segment.length : 1;
-            this.value = this.value.slice(0, this.cursor) + this.value.slice(this.cursor + graphemeLength);
-        }
-    }
-    deleteToLineStart() {
-        if (this.cursor === 0)
-            return;
-        this.pushUndo();
-        const deletedText = this.value.slice(0, this.cursor);
-        this.killRing.push(deletedText, { prepend: true, accumulate: this.lastAction === "kill" });
-        this.lastAction = "kill";
-        this.value = this.value.slice(this.cursor);
-        this.cursor = 0;
-    }
-    deleteToLineEnd() {
-        if (this.cursor >= this.value.length)
-            return;
-        this.pushUndo();
-        const deletedText = this.value.slice(this.cursor);
-        this.killRing.push(deletedText, { prepend: false, accumulate: this.lastAction === "kill" });
-        this.lastAction = "kill";
-        this.value = this.value.slice(0, this.cursor);
-    }
-    deleteWordBackwards() {
-        if (this.cursor === 0)
-            return;
-        // Save lastAction before cursor movement (moveWordBackwards resets it)
-        const wasKill = this.lastAction === "kill";
-        this.pushUndo();
-        const oldCursor = this.cursor;
-        this.moveWordBackwards();
-        const deleteFrom = this.cursor;
-        this.cursor = oldCursor;
-        const deletedText = this.value.slice(deleteFrom, this.cursor);
-        this.killRing.push(deletedText, { prepend: true, accumulate: wasKill });
-        this.lastAction = "kill";
-        this.value = this.value.slice(0, deleteFrom) + this.value.slice(this.cursor);
-        this.cursor = deleteFrom;
-    }
-    deleteWordForward() {
-        if (this.cursor >= this.value.length)
-            return;
-        // Save lastAction before cursor movement (moveWordForwards resets it)
-        const wasKill = this.lastAction === "kill";
-        this.pushUndo();
-        const oldCursor = this.cursor;
-        this.moveWordForwards();
-        const deleteTo = this.cursor;
-        this.cursor = oldCursor;
-        const deletedText = this.value.slice(this.cursor, deleteTo);
-        this.killRing.push(deletedText, { prepend: false, accumulate: wasKill });
-        this.lastAction = "kill";
-        this.value = this.value.slice(0, this.cursor) + this.value.slice(deleteTo);
-    }
-    yank() {
-        const text = this.killRing.peek();
-        if (!text)
-            return;
-        this.pushUndo();
-        this.value = this.value.slice(0, this.cursor) + text + this.value.slice(this.cursor);
-        this.cursor += text.length;
-        this.lastAction = "yank";
-    }
-    yankPop() {
-        if (this.lastAction !== "yank" || this.killRing.length <= 1)
-            return;
-        this.pushUndo();
-        // Delete the previously yanked text (still at end of ring before rotation)
-        const prevText = this.killRing.peek() || "";
-        this.value = this.value.slice(0, this.cursor - prevText.length) + this.value.slice(this.cursor);
-        this.cursor -= prevText.length;
-        // Rotate and insert new entry
-        this.killRing.rotate();
-        const text = this.killRing.peek() || "";
-        this.value = this.value.slice(0, this.cursor) + text + this.value.slice(this.cursor);
-        this.cursor += text.length;
-        this.lastAction = "yank";
-    }
-    pushUndo() {
-        this.undoStack.push({ value: this.value, cursor: this.cursor });
-    }
-    undo() {
-        const snapshot = this.undoStack.pop();
-        if (!snapshot)
-            return;
-        this.value = snapshot.value;
-        this.cursor = snapshot.cursor;
-        this.lastAction = null;
-    }
-    moveWordBackwards() {
-        if (this.cursor === 0) {
-            return;
-        }
-        this.lastAction = null;
-        const textBeforeCursor = this.value.slice(0, this.cursor);
-        const graphemes = [...segmenter.segment(textBeforeCursor)];
-        // Skip trailing whitespace
-        while (graphemes.length > 0 && isWhitespaceChar(graphemes[graphemes.length - 1]?.segment || "")) {
-            this.cursor -= graphemes.pop()?.segment.length || 0;
-        }
-        if (graphemes.length > 0) {
-            const lastGrapheme = graphemes[graphemes.length - 1]?.segment || "";
-            if (isPunctuationChar(lastGrapheme)) {
-                // Skip punctuation run
-                while (graphemes.length > 0 && isPunctuationChar(graphemes[graphemes.length - 1]?.segment || "")) {
-                    this.cursor -= graphemes.pop()?.segment.length || 0;
-                }
-            }
-            else {
-                // Skip word run
-                while (graphemes.length > 0 &&
-                    !isWhitespaceChar(graphemes[graphemes.length - 1]?.segment || "") &&
-                    !isPunctuationChar(graphemes[graphemes.length - 1]?.segment || "")) {
-                    this.cursor -= graphemes.pop()?.segment.length || 0;
-                }
-            }
-        }
-    }
-    moveWordForwards() {
-        if (this.cursor >= this.value.length) {
-            return;
-        }
-        this.lastAction = null;
-        const textAfterCursor = this.value.slice(this.cursor);
-        const segments = segmenter.segment(textAfterCursor);
-        const iterator = segments[Symbol.iterator]();
-        let next = iterator.next();
-        // Skip leading whitespace
-        while (!next.done && isWhitespaceChar(next.value.segment)) {
-            this.cursor += next.value.segment.length;
-            next = iterator.next();
-        }
-        if (!next.done) {
-            const firstGrapheme = next.value.segment;
-            if (isPunctuationChar(firstGrapheme)) {
-                // Skip punctuation run
-                while (!next.done && isPunctuationChar(next.value.segment)) {
-                    this.cursor += next.value.segment.length;
-                    next = iterator.next();
-                }
-            }
-            else {
-                // Skip word run
-                while (!next.done && !isWhitespaceChar(next.value.segment) && !isPunctuationChar(next.value.segment)) {
-                    this.cursor += next.value.segment.length;
-                    next = iterator.next();
-                }
-            }
-        }
-    }
-    handlePaste(pastedText) {
-        this.lastAction = null;
-        this.pushUndo();
-        // Clean the pasted text - remove newlines and carriage returns
-        const cleanText = pastedText.replace(/\r\n/g, "").replace(/\r/g, "").replace(/\n/g, "").replace(/\t/g, "    ");
-        // Insert at cursor position
-        this.value = this.value.slice(0, this.cursor) + cleanText + this.value.slice(this.cursor);
-        this.cursor += cleanText.length;
-    }
-    invalidate() {
-        // No cached state to invalidate currently
-    }
-    render(width) {
-        // Calculate visible window
-        const prompt = "> ";
-        const availableWidth = width - prompt.length;
-        if (availableWidth <= 0) {
-            return [prompt];
-        }
-        let visibleText = "";
-        let cursorDisplay = this.cursor;
-        const totalWidth = visibleWidth(this.value);
-        if (totalWidth < availableWidth) {
-            // Everything fits (leave room for cursor at end)
-            visibleText = this.value;
-        }
-        else {
-            // Need horizontal scrolling
-            // Reserve one column for cursor if it's at the end
-            const scrollWidth = this.cursor === this.value.length ? availableWidth - 1 : availableWidth;
-            const cursorCol = visibleWidth(this.value.slice(0, this.cursor));
-            if (scrollWidth > 0) {
-                const halfWidth = Math.floor(scrollWidth / 2);
-                let startCol = 0;
-                if (cursorCol < halfWidth) {
-                    // Cursor near start
-                    startCol = 0;
-                }
-                else if (cursorCol > totalWidth - halfWidth) {
-                    // Cursor near end
-                    startCol = Math.max(0, totalWidth - scrollWidth);
-                }
-                else {
-                    // Cursor in middle
-                    startCol = Math.max(0, cursorCol - halfWidth);
-                }
-                visibleText = sliceByColumn(this.value, startCol, scrollWidth, true);
-                const beforeCursor = sliceByColumn(this.value, startCol, Math.max(0, cursorCol - startCol), true);
-                cursorDisplay = beforeCursor.length;
-            }
-            else {
-                visibleText = "";
-                cursorDisplay = 0;
-            }
-        }
-        // Build line with fake cursor
-        // Insert cursor character at cursor position
-        const graphemes = [...segmenter.segment(visibleText.slice(cursorDisplay))];
-        const cursorGrapheme = graphemes[0];
-        const beforeCursor = visibleText.slice(0, cursorDisplay);
-        const atCursor = cursorGrapheme?.segment ?? " "; // Character at cursor, or space if at end
-        const afterCursor = visibleText.slice(cursorDisplay + atCursor.length);
-        // Hardware cursor marker (zero-width, emitted before fake cursor for IME positioning)
-        const marker = this.focused ? CURSOR_MARKER : "";
-        // Use inverse video to show cursor
-        const cursorChar = `\x1b[7m${atCursor}\x1b[27m`; // ESC[7m = reverse video, ESC[27m = normal
-        const textWithCursor = beforeCursor + marker + cursorChar + afterCursor;
-        // Calculate visual width
-        const visualLength = visibleWidth(textWithCursor);
-        const padding = " ".repeat(Math.max(0, availableWidth - visualLength));
-        const line = prompt + textWithCursor + padding;
-        return [line];
-    }
-}

package/dist/pi/tui/components/loader.js

@@ -1,68 +0,0 @@
-import { Text } from "./text.js";
-const DEFAULT_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const DEFAULT_INTERVAL_MS = 80;
-/**
- * Loader component that updates with an optional spinning animation.
- */
-export class Loader extends Text {
-    frames = [...DEFAULT_FRAMES];
-    intervalMs = DEFAULT_INTERVAL_MS;
-    currentFrame = 0;
-    intervalId = null;
-    ui = null;
-    renderIndicatorVerbatim = false;
-    spinnerColorFn;
-    messageColorFn;
-    message = "Loading...";
-    constructor(ui, spinnerColorFn, messageColorFn, message = "Loading...", indicator) {
-        super("", 1, 0);
-        this.ui = ui;
-        this.spinnerColorFn = spinnerColorFn;
-        this.messageColorFn = messageColorFn;
-        this.message = message;
-        this.setIndicator(indicator);
-    }
-    render(width) {
-        return ["", ...super.render(width)];
-    }
-    start() {
-        this.updateDisplay();
-        this.restartAnimation();
-    }
-    stop() {
-        if (this.intervalId) {
-            clearInterval(this.intervalId);
-            this.intervalId = null;
-        }
-    }
-    setMessage(message) {
-        this.message = message;
-        this.updateDisplay();
-    }
-    setIndicator(indicator) {
-        this.renderIndicatorVerbatim = indicator !== undefined;
-        this.frames = indicator?.frames !== undefined ? [...indicator.frames] : [...DEFAULT_FRAMES];
-        this.intervalMs = indicator?.intervalMs && indicator.intervalMs > 0 ? indicator.intervalMs : DEFAULT_INTERVAL_MS;
-        this.currentFrame = 0;
-        this.start();
-    }
-    restartAnimation() {
-        this.stop();
-        if (this.frames.length <= 1) {
-            return;
-        }
-        this.intervalId = setInterval(() => {
-            this.currentFrame = (this.currentFrame + 1) % this.frames.length;
-            this.updateDisplay();
-        }, this.intervalMs);
-    }
-    updateDisplay() {
-        const frame = this.frames[this.currentFrame] ?? "";
-        const renderedFrame = this.renderIndicatorVerbatim ? frame : this.spinnerColorFn(frame);
-        const indicator = frame.length > 0 ? `${renderedFrame} ` : "";
-        this.setText(`${indicator}${this.messageColorFn(this.message)}`);
-        if (this.ui) {
-            this.ui.requestRender();
-        }
-    }
-}