ink-prompt 0.2.3 → 0.2.5

package/dist/examples/src/components/MultilineInput/KeyHandler.js

@@ -1,97 +0,0 @@
-/**
- * Handles keyboard input and maps it to text input actions.
- *
- * @param key - The Ink key object
- * @param input - The input string (if any)
- * @param buffer - The current text buffer
- * @param actions - The actions available to modify the state
- * @param cursor - The current cursor position (optional, but required for some logic like backslash check)
- */
-export function handleKey(key, input, buffer, actions, cursor) {
-    // Navigation
-    if (key.upArrow) {
-        actions.moveCursor('up');
-        return;
-    }
-    if (key.downArrow) {
-        actions.moveCursor('down');
-        return;
-    }
-    if (key.leftArrow) {
-        actions.moveCursor('left');
-        return;
-    }
-    if (key.rightArrow) {
-        actions.moveCursor('right');
-        return;
-    }
-    // Home/End (Ink might not provide these directly in all environments, but if it does)
-    // We check for 'home' and 'end' properties if they exist on the key object,
-    // or specific sequences if we were parsing raw input, but here we assume Ink's Key object.
-    // Note: Ink's Key interface might not have home/end in all versions, but we'll assume it does or we extend it.
-    // If not, we might need to check specific input sequences, but for now let's trust the test/types.
-    if (key.home) {
-        actions.moveCursor('lineStart');
-        return;
-    }
-    if (key.end) {
-        actions.moveCursor('lineEnd');
-        return;
-    }
-    // History
-    if (key.ctrl) {
-        if (input === 'z') {
-            actions.undo();
-            return;
-        }
-        if (input === 'y') {
-            actions.redo();
-            return;
-        }
-        if (input === 'j') {
-            actions.newLine();
-            return;
-        }
-    }
-    // Editing
-    if (key.backspace) {
-        actions.delete();
-        return;
-    }
-    if (key.delete) {
-        // Currently mapped to delete (backspace behavior) as per requirements/tests,
-        // but usually delete is forward.
-        // The plan said "Delete (delete at cursor)", which usually means forward.
-        // But our useTextInput only has `delete` (which is backspace).
-        // For now, we map it to `delete` as per the test "handles Delete".
-        actions.delete();
-        return;
-    }
-    // Submission / New Line
-    if (key.return) {
-        if (cursor) {
-            const currentLine = buffer.lines[cursor.line];
-            // Check if line ends with backslash AND cursor is at the end (or we just check the line content?)
-            // Requirement: "Line ending with \ + Enter continues to next line"
-            // Usually this implies the user typed '\' then Enter.
-            // We should probably check if the character *before* the cursor is '\' if we want to be precise,
-            // or just if the line ends with '\'.
-            // Let's assume "line ends with \" means the last char of the line is '\'.
-            if (currentLine.endsWith('\\')) {
-                actions.delete(); // Remove the backslash
-                actions.newLine(); // Insert newline
-                return;
-            }
-        }
-        actions.submit();
-        return;
-    }
-    // Text Insertion
-    // Ignore control keys if they don't have a specific handler above
-    if (key.ctrl || key.meta) {
-        return;
-    }
-    if (input) {
-        actions.insert(input);
-    }
-}

package/dist/examples/src/components/MultilineInput/TextBuffer.d.ts

@@ -1,34 +0,0 @@
-import type { Buffer, Cursor, Direction } from './types';
-/**
- * Create a new buffer from optional initial text
- */
-export declare function createBuffer(text?: string): Buffer;
-/**
- * Insert a character at the cursor position
- */
-export declare function insertChar(buffer: Buffer, cursor: Cursor, char: string): {
-    buffer: Buffer;
-    cursor: Cursor;
-};
-/**
- * Delete character before cursor (backspace)
- */
-export declare function deleteChar(buffer: Buffer, cursor: Cursor): {
-    buffer: Buffer;
-    cursor: Cursor;
-};
-/**
- * Insert a new line at cursor position (splits current line)
- */
-export declare function insertNewLine(buffer: Buffer, cursor: Cursor): {
-    buffer: Buffer;
-    cursor: Cursor;
-};
-/**
- * Move cursor in specified direction with bounds checking
- */
-export declare function moveCursor(buffer: Buffer, cursor: Cursor, direction: Direction): Cursor;
-/**
- * Get the full text content from buffer (lines joined with newlines)
- */
-export declare function getTextContent(buffer: Buffer): string;

package/dist/examples/src/components/MultilineInput/TextBuffer.js

@@ -1,127 +0,0 @@
-/**
- * Create a new buffer from optional initial text
- */
-export function createBuffer(text) {
-    if (!text) {
-        return { lines: [''] };
-    }
-    return { lines: text.split('\n') };
-}
-/**
- * Insert a character at the cursor position
- */
-export function insertChar(buffer, cursor, char) {
-    const { line, column } = cursor;
-    const currentLine = buffer.lines[line];
-    const newLine = currentLine.slice(0, column) + char + currentLine.slice(column);
-    const newLines = [...buffer.lines];
-    newLines[line] = newLine;
-    return {
-        buffer: { lines: newLines },
-        cursor: { line, column: column + 1 },
-    };
-}
-/**
- * Delete character before cursor (backspace)
- */
-export function deleteChar(buffer, cursor) {
-    const { line, column } = cursor;
-    // At the very start of the buffer - nothing to delete
-    if (line === 0 && column === 0) {
-        return { buffer, cursor };
-    }
-    // At the start of a line - merge with previous line
-    if (column === 0) {
-        const previousLine = buffer.lines[line - 1];
-        const currentLine = buffer.lines[line];
-        const mergedLine = previousLine + currentLine;
-        const newLines = [...buffer.lines];
-        newLines[line - 1] = mergedLine;
-        newLines.splice(line, 1);
-        return {
-            buffer: { lines: newLines },
-            cursor: { line: line - 1, column: previousLine.length },
-        };
-    }
-    // Delete character within the line
-    const currentLine = buffer.lines[line];
-    const newLine = currentLine.slice(0, column - 1) + currentLine.slice(column);
-    const newLines = [...buffer.lines];
-    newLines[line] = newLine;
-    return {
-        buffer: { lines: newLines },
-        cursor: { line, column: column - 1 },
-    };
-}
-/**
- * Insert a new line at cursor position (splits current line)
- */
-export function insertNewLine(buffer, cursor) {
-    const { line, column } = cursor;
-    const currentLine = buffer.lines[line];
-    const beforeCursor = currentLine.slice(0, column);
-    const afterCursor = currentLine.slice(column);
-    const newLines = [...buffer.lines];
-    newLines[line] = beforeCursor;
-    newLines.splice(line + 1, 0, afterCursor);
-    return {
-        buffer: { lines: newLines },
-        cursor: { line: line + 1, column: 0 },
-    };
-}
-/**
- * Move cursor in specified direction with bounds checking
- */
-export function moveCursor(buffer, cursor, direction) {
-    const { line, column } = cursor;
-    const currentLine = buffer.lines[line];
-    const lineCount = buffer.lines.length;
-    switch (direction) {
-        case 'left':
-            if (column > 0) {
-                return { line, column: column - 1 };
-            }
-            // Wrap to end of previous line
-            if (line > 0) {
-                return { line: line - 1, column: buffer.lines[line - 1].length };
-            }
-            return cursor;
-        case 'right':
-            if (column < currentLine.length) {
-                return { line, column: column + 1 };
-            }
-            // Wrap to start of next line
-            if (line < lineCount - 1) {
-                return { line: line + 1, column: 0 };
-            }
-            return cursor;
-        case 'up':
-            if (line > 0) {
-                const targetLine = buffer.lines[line - 1];
-                return { line: line - 1, column: Math.min(column, targetLine.length) };
-            }
-            return cursor;
-        case 'down':
-            if (line < lineCount - 1) {
-                const targetLine = buffer.lines[line + 1];
-                return { line: line + 1, column: Math.min(column, targetLine.length) };
-            }
-            return cursor;
-        case 'lineStart':
-            return { line, column: 0 };
-        case 'lineEnd':
-            return { line, column: currentLine.length };
-        default:
-            return cursor;
-    }
-}
-/**
- * Get the full text content from buffer (lines joined with newlines)
- */
-export function getTextContent(buffer) {
-    // Single empty line is considered empty buffer
-    if (buffer.lines.length === 1 && buffer.lines[0] === '') {
-        return '';
-    }
-    return buffer.lines.join('\n');
-}

package/dist/examples/src/components/MultilineInput/TextRenderer.d.ts

@@ -1,24 +0,0 @@
-import React from 'react';
-import type { Buffer, Cursor, WrapResult } from './types';
-/**
- * Props for the TextRenderer component
- */
-export interface TextRendererProps {
-    /** Text buffer to render */
-    buffer: Buffer;
-    /** Current cursor position */
-    cursor: Cursor;
-    /** Terminal width for word wrapping (defaults to 80) */
-    width?: number;
-    /** Whether to show the cursor (defaults to true) */
-    showCursor?: boolean;
-}
-/**
- * Wrap buffer lines to fit within a given width.
- * Returns visual lines and maps cursor position to visual coordinates.
- */
-export declare function wrapLines(buffer: Buffer, cursor: Cursor, width: number): WrapResult;
-/**
- * TextRenderer component for displaying buffer content with cursor
- */
-export declare function TextRenderer({ buffer, cursor, width, showCursor, }: TextRendererProps): React.ReactElement;

package/dist/examples/src/components/MultilineInput/TextRenderer.js

@@ -1,72 +0,0 @@
-import React from 'react';
-/**
- * Wrap buffer lines to fit within a given width.
- * Returns visual lines and maps cursor position to visual coordinates.
- */
-export function wrapLines(buffer, cursor, width) {
-    const visualLines = [];
-    let cursorVisualRow = 0;
-    let cursorVisualCol = 0;
-    let visualRowIndex = 0;
-    for (let lineIndex = 0; lineIndex < buffer.lines.length; lineIndex++) {
-        const line = buffer.lines[lineIndex];
-        const isCursorLine = lineIndex === cursor.line;
-        if (line.length <= width) {
-            // Line fits, no wrapping needed
-            visualLines.push(line);
-            if (isCursorLine) {
-                cursorVisualRow = visualRowIndex;
-                cursorVisualCol = cursor.column;
-            }
-            visualRowIndex++;
-        }
-        else {
-            // Line needs to be wrapped
-            let offset = 0;
-            while (offset < line.length) {
-                const chunk = line.slice(offset, offset + width);
-                visualLines.push(chunk);
-                if (isCursorLine) {
-                    // Check if cursor falls within this chunk
-                    if (cursor.column >= offset && cursor.column < offset + width) {
-                        cursorVisualRow = visualRowIndex;
-                        cursorVisualCol = cursor.column - offset;
-                    }
-                    else if (cursor.column === line.length && offset + chunk.length === line.length) {
-                        // Cursor at end of line
-                        cursorVisualRow = visualRowIndex;
-                        cursorVisualCol = chunk.length;
-                    }
-                }
-                offset += width;
-                visualRowIndex++;
-            }
-        }
-    }
-    return { visualLines, cursorVisualRow, cursorVisualCol };
-}
-/**
- * Render a line with cursor inserted at the specified position
- */
-function renderLineWithCursor(line, cursorCol, showCursor) {
-    if (!showCursor) {
-        return line;
-    }
-    const cursorChar = '█';
-    const before = line.slice(0, cursorCol);
-    const after = line.slice(cursorCol);
-    return before + cursorChar + after;
-}
-/**
- * TextRenderer component for displaying buffer content with cursor
- */
-export function TextRenderer({ buffer, cursor, width = 80, showCursor = true, }) {
-    const { visualLines, cursorVisualRow, cursorVisualCol } = wrapLines(buffer, cursor, width);
-    return (React.createElement("div", null, visualLines.map((line, index) => {
-        const isCursorRow = index === cursorVisualRow;
-        const displayLine = isCursorRow
-            ? renderLineWithCursor(line, cursorVisualCol, showCursor)
-            : line;
-        return (React.createElement("div", { key: index }, displayLine));
-    })));
-}

package/dist/examples/src/components/MultilineInput/__tests__/KeyHandler.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/examples/src/components/MultilineInput/__tests__/KeyHandler.test.js

@@ -1,115 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleKey } from '../KeyHandler';
-describe('KeyHandler', () => {
-    let actions;
-    let buffer;
-    beforeEach(() => {
-        actions = {
-            insert: vi.fn(),
-            delete: vi.fn(),
-            newLine: vi.fn(),
-            moveCursor: vi.fn(),
-            undo: vi.fn(),
-            redo: vi.fn(),
-            setText: vi.fn(),
-            submit: vi.fn(),
-        };
-        buffer = { lines: [''] };
-    });
-    describe('Navigation', () => {
-        it('handles ArrowUp', () => {
-            handleKey({ upArrow: true }, 'up', buffer, actions);
-            expect(actions.moveCursor).toHaveBeenCalledWith('up');
-        });
-        it('handles ArrowDown', () => {
-            handleKey({ downArrow: true }, 'down', buffer, actions);
-            expect(actions.moveCursor).toHaveBeenCalledWith('down');
-        });
-        it('handles ArrowLeft', () => {
-            handleKey({ leftArrow: true }, 'left', buffer, actions);
-            expect(actions.moveCursor).toHaveBeenCalledWith('left');
-        });
-        it('handles ArrowRight', () => {
-            handleKey({ rightArrow: true }, 'right', buffer, actions);
-            expect(actions.moveCursor).toHaveBeenCalledWith('right');
-        });
-        it('handles Home', () => {
-            // Ink doesn't have a specific 'home' property usually, but we check for special keys
-            // Often represented as key.home if using a specific library or just checking input
-            // For Ink's useInput, we might receive specific sequences.
-            // Assuming we handle it via checking `key` object properties if available, or input string if it maps.
-            // However, standard Ink `Key` interface has `home` and `end`?
-            // Let's assume standard Ink Key interface.
-            handleKey({ home: true }, '', buffer, actions);
-            expect(actions.moveCursor).toHaveBeenCalledWith('lineStart');
-        });
-        it('handles End', () => {
-            handleKey({ end: true }, '', buffer, actions);
-            expect(actions.moveCursor).toHaveBeenCalledWith('lineEnd');
-        });
-    });
-    describe('Editing', () => {
-        it('handles Backspace', () => {
-            handleKey({ backspace: true }, 'backspace', buffer, actions);
-            expect(actions.delete).toHaveBeenCalled();
-        });
-        it('handles Delete', () => {
-            handleKey({ delete: true }, 'delete', buffer, actions);
-            expect(actions.delete).toHaveBeenCalled(); // Our current simple delete handles backspace, we might need forward delete later
-        });
-        it('handles Ctrl+J (NewLine)', () => {
-            handleKey({ ctrl: true }, 'j', buffer, actions);
-            expect(actions.newLine).toHaveBeenCalled();
-        });
-        it('handles regular text insertion', () => {
-            handleKey({}, 'a', buffer, actions);
-            expect(actions.insert).toHaveBeenCalledWith('a');
-        });
-        it('ignores control keys without text', () => {
-            handleKey({ ctrl: true }, '', buffer, actions);
-            expect(actions.insert).not.toHaveBeenCalled();
-        });
-    });
-    describe('History', () => {
-        it('handles Ctrl+Z (Undo)', () => {
-            handleKey({ ctrl: true }, 'z', buffer, actions);
-            expect(actions.undo).toHaveBeenCalled();
-        });
-        it('handles Ctrl+Y (Redo)', () => {
-            handleKey({ ctrl: true }, 'y', buffer, actions);
-            expect(actions.redo).toHaveBeenCalled();
-        });
-    });
-    describe('Submission', () => {
-        it('handles Enter as submit by default', () => {
-            buffer = { lines: ['hello'] };
-            handleKey({ return: true }, 'return', buffer, actions);
-            expect(actions.submit).toHaveBeenCalled();
-            expect(actions.newLine).not.toHaveBeenCalled();
-        });
-        it('handles Enter as newline if line ends with backslash', () => {
-            buffer = { lines: ['hello\\'] };
-            const cursor = { line: 0, column: 6 };
-            handleKey({ return: true }, 'return', buffer, actions, cursor);
-            // It should probably remove the backslash first.
-            // Since we are mocking actions, we can't easily verify the state change between calls unless we implement a fake.
-            // But we can check call order.
-            expect(actions.delete).toHaveBeenCalled();
-            expect(actions.newLine).toHaveBeenCalled();
-            expect(actions.submit).not.toHaveBeenCalled();
-        });
-        it('handles Enter as newline if line ends with backslash (multiple lines)', () => {
-            // Cursor is implicitly at the end for this logic usually, or we need to pass cursor to handleKey?
-            // The plan says `handleKey` takes `buffer`. It probably needs `cursor` too to know which line we are on?
-            // Ah, `TextBuffer` logic usually needs cursor.
-            // If `handleKey` decides based on "current line", it needs to know the current line.
-            // So `handleKey` signature should probably include `cursor`.
-            const cursor = { line: 1, column: 6 };
-            buffer = { lines: ['first', 'second\\'] };
-            handleKey({ return: true }, 'return', buffer, actions, cursor);
-            expect(actions.delete).toHaveBeenCalled();
-            expect(actions.newLine).toHaveBeenCalled();
-            expect(actions.submit).not.toHaveBeenCalled();
-        });
-    });
-});

package/dist/examples/src/components/MultilineInput/__tests__/TextBuffer.test.d.ts

@@ -1 +0,0 @@
-export {};