ink-prompt 0.2.3 → 0.2.4

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.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 {};

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

@@ -1,254 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createBuffer, insertChar, deleteChar, insertNewLine, moveCursor, getTextContent, } from '../TextBuffer';
-describe('TextBuffer', () => {
-    describe('createBuffer', () => {
-        it('creates empty buffer with single empty line', () => {
-            const buffer = createBuffer();
-            expect(buffer).toEqual({ lines: [''] });
-        });
-        it('creates buffer from single line text', () => {
-            const buffer = createBuffer('hello');
-            expect(buffer).toEqual({ lines: ['hello'] });
-        });
-        it('creates buffer from multi-line text', () => {
-            const buffer = createBuffer('line1\nline2\nline3');
-            expect(buffer).toEqual({ lines: ['line1', 'line2', 'line3'] });
-        });
-        it('handles text ending with newline', () => {
-            const buffer = createBuffer('hello\n');
-            expect(buffer).toEqual({ lines: ['hello', ''] });
-        });
-    });
-    describe('insertChar', () => {
-        it('inserts character into empty buffer', () => {
-            const buffer = createBuffer();
-            const cursor = { line: 0, column: 0 };
-            const result = insertChar(buffer, cursor, 'a');
-            expect(result.buffer).toEqual({ lines: ['a'] });
-            expect(result.cursor).toEqual({ line: 0, column: 1 });
-        });
-        it('inserts character at end of line', () => {
-            const buffer = createBuffer('hello');
-            const cursor = { line: 0, column: 5 };
-            const result = insertChar(buffer, cursor, '!');
-            expect(result.buffer).toEqual({ lines: ['hello!'] });
-            expect(result.cursor).toEqual({ line: 0, column: 6 });
-        });
-        it('inserts character in middle of line', () => {
-            const buffer = createBuffer('hllo');
-            const cursor = { line: 0, column: 1 };
-            const result = insertChar(buffer, cursor, 'e');
-            expect(result.buffer).toEqual({ lines: ['hello'] });
-            expect(result.cursor).toEqual({ line: 0, column: 2 });
-        });
-        it('inserts character at line start', () => {
-            const buffer = createBuffer('ello');
-            const cursor = { line: 0, column: 0 };
-            const result = insertChar(buffer, cursor, 'h');
-            expect(result.buffer).toEqual({ lines: ['hello'] });
-            expect(result.cursor).toEqual({ line: 0, column: 1 });
-        });
-        it('inserts into specific line of multi-line buffer', () => {
-            const buffer = createBuffer('line1\nline2\nline3');
-            const cursor = { line: 1, column: 4 };
-            const result = insertChar(buffer, cursor, 'X');
-            expect(result.buffer).toEqual({ lines: ['line1', 'lineX2', 'line3'] });
-            expect(result.cursor).toEqual({ line: 1, column: 5 });
-        });
-    });
-    describe('deleteChar (backspace)', () => {
-        it('does nothing when cursor at buffer start', () => {
-            const buffer = createBuffer('hello');
-            const cursor = { line: 0, column: 0 };
-            const result = deleteChar(buffer, cursor);
-            expect(result.buffer).toEqual({ lines: ['hello'] });
-            expect(result.cursor).toEqual({ line: 0, column: 0 });
-        });
-        it('deletes character before cursor', () => {
-            const buffer = createBuffer('hello');
-            const cursor = { line: 0, column: 5 };
-            const result = deleteChar(buffer, cursor);
-            expect(result.buffer).toEqual({ lines: ['hell'] });
-            expect(result.cursor).toEqual({ line: 0, column: 4 });
-        });
-        it('deletes character in middle of line', () => {
-            const buffer = createBuffer('heello');
-            const cursor = { line: 0, column: 3 };
-            const result = deleteChar(buffer, cursor);
-            expect(result.buffer).toEqual({ lines: ['hello'] });
-            expect(result.cursor).toEqual({ line: 0, column: 2 });
-        });
-        it('merges with previous line when at line start', () => {
-            const buffer = createBuffer('hello\nworld');
-            const cursor = { line: 1, column: 0 };
-            const result = deleteChar(buffer, cursor);
-            expect(result.buffer).toEqual({ lines: ['helloworld'] });
-            expect(result.cursor).toEqual({ line: 0, column: 5 });
-        });
-        it('merges empty line with previous', () => {
-            const buffer = createBuffer('hello\n');
-            const cursor = { line: 1, column: 0 };
-            const result = deleteChar(buffer, cursor);
-            expect(result.buffer).toEqual({ lines: ['hello'] });
-            expect(result.cursor).toEqual({ line: 0, column: 5 });
-        });
-    });
-    describe('insertNewLine', () => {
-        it('splits line at cursor position', () => {
-            const buffer = createBuffer('helloworld');
-            const cursor = { line: 0, column: 5 };
-            const result = insertNewLine(buffer, cursor);
-            expect(result.buffer).toEqual({ lines: ['hello', 'world'] });
-            expect(result.cursor).toEqual({ line: 1, column: 0 });
-        });
-        it('creates new line at line start', () => {
-            const buffer = createBuffer('hello');
-            const cursor = { line: 0, column: 0 };
-            const result = insertNewLine(buffer, cursor);
-            expect(result.buffer).toEqual({ lines: ['', 'hello'] });
-            expect(result.cursor).toEqual({ line: 1, column: 0 });
-        });
-        it('creates new line at line end', () => {
-            const buffer = createBuffer('hello');
-            const cursor = { line: 0, column: 5 };
-            const result = insertNewLine(buffer, cursor);
-            expect(result.buffer).toEqual({ lines: ['hello', ''] });
-            expect(result.cursor).toEqual({ line: 1, column: 0 });
-        });
-        it('inserts new line in middle of multi-line buffer', () => {
-            const buffer = createBuffer('line1\nline2\nline3');
-            const cursor = { line: 1, column: 2 };
-            const result = insertNewLine(buffer, cursor);
-            expect(result.buffer).toEqual({ lines: ['line1', 'li', 'ne2', 'line3'] });
-            expect(result.cursor).toEqual({ line: 2, column: 0 });
-        });
-    });
-    describe('moveCursor', () => {
-        describe('left', () => {
-            it('moves left within line', () => {
-                const buffer = createBuffer('hello');
-                const cursor = { line: 0, column: 3 };
-                const result = moveCursor(buffer, cursor, 'left');
-                expect(result).toEqual({ line: 0, column: 2 });
-            });
-            it('wraps to end of previous line', () => {
-                const buffer = createBuffer('hello\nworld');
-                const cursor = { line: 1, column: 0 };
-                const result = moveCursor(buffer, cursor, 'left');
-                expect(result).toEqual({ line: 0, column: 5 });
-            });
-            it('stays at buffer start', () => {
-                const buffer = createBuffer('hello');
-                const cursor = { line: 0, column: 0 };
-                const result = moveCursor(buffer, cursor, 'left');
-                expect(result).toEqual({ line: 0, column: 0 });
-            });
-        });
-        describe('right', () => {
-            it('moves right within line', () => {
-                const buffer = createBuffer('hello');
-                const cursor = { line: 0, column: 2 };
-                const result = moveCursor(buffer, cursor, 'right');
-                expect(result).toEqual({ line: 0, column: 3 });
-            });
-            it('wraps to start of next line', () => {
-                const buffer = createBuffer('hello\nworld');
-                const cursor = { line: 0, column: 5 };
-                const result = moveCursor(buffer, cursor, 'right');
-                expect(result).toEqual({ line: 1, column: 0 });
-            });
-            it('stays at buffer end', () => {
-                const buffer = createBuffer('hello');
-                const cursor = { line: 0, column: 5 };
-                const result = moveCursor(buffer, cursor, 'right');
-                expect(result).toEqual({ line: 0, column: 5 });
-            });
-        });
-        describe('up', () => {
-            it('moves up maintaining column', () => {
-                const buffer = createBuffer('hello\nworld');
-                const cursor = { line: 1, column: 3 };
-                const result = moveCursor(buffer, cursor, 'up');
-                expect(result).toEqual({ line: 0, column: 3 });
-            });
-            it('clamps column to shorter line', () => {
-                const buffer = createBuffer('hi\nhello');
-                const cursor = { line: 1, column: 4 };
-                const result = moveCursor(buffer, cursor, 'up');
-                expect(result).toEqual({ line: 0, column: 2 });
-            });
-            it('stays on first line', () => {
-                const buffer = createBuffer('hello');
-                const cursor = { line: 0, column: 2 };
-                const result = moveCursor(buffer, cursor, 'up');
-                expect(result).toEqual({ line: 0, column: 2 });
-            });
-        });
-        describe('down', () => {
-            it('moves down maintaining column', () => {
-                const buffer = createBuffer('hello\nworld');
-                const cursor = { line: 0, column: 3 };
-                const result = moveCursor(buffer, cursor, 'down');
-                expect(result).toEqual({ line: 1, column: 3 });
-            });
-            it('clamps column to shorter line', () => {
-                const buffer = createBuffer('hello\nhi');
-                const cursor = { line: 0, column: 4 };
-                const result = moveCursor(buffer, cursor, 'down');
-                expect(result).toEqual({ line: 1, column: 2 });
-            });
-            it('stays on last line', () => {
-                const buffer = createBuffer('hello');
-                const cursor = { line: 0, column: 2 };
-                const result = moveCursor(buffer, cursor, 'down');
-                expect(result).toEqual({ line: 0, column: 2 });
-            });
-        });
-        describe('lineStart', () => {
-            it('moves to start of line', () => {
-                const buffer = createBuffer('hello');
-                const cursor = { line: 0, column: 3 };
-                const result = moveCursor(buffer, cursor, 'lineStart');
-                expect(result).toEqual({ line: 0, column: 0 });
-            });
-            it('stays at start if already there', () => {
-                const buffer = createBuffer('hello');
-                const cursor = { line: 0, column: 0 };
-                const result = moveCursor(buffer, cursor, 'lineStart');
-                expect(result).toEqual({ line: 0, column: 0 });
-            });
-        });
-        describe('lineEnd', () => {
-            it('moves to end of line', () => {
-                const buffer = createBuffer('hello');
-                const cursor = { line: 0, column: 2 };
-                const result = moveCursor(buffer, cursor, 'lineEnd');
-                expect(result).toEqual({ line: 0, column: 5 });
-            });
-            it('stays at end if already there', () => {
-                const buffer = createBuffer('hello');
-                const cursor = { line: 0, column: 5 };
-                const result = moveCursor(buffer, cursor, 'lineEnd');
-                expect(result).toEqual({ line: 0, column: 5 });
-            });
-        });
-    });
-    describe('getTextContent', () => {
-        it('returns empty string for empty buffer', () => {
-            const buffer = createBuffer();
-            expect(getTextContent(buffer)).toBe('');
-        });
-        it('returns single line content', () => {
-            const buffer = createBuffer('hello');
-            expect(getTextContent(buffer)).toBe('hello');
-        });
-        it('joins multiple lines with newlines', () => {
-            const buffer = createBuffer('line1\nline2\nline3');
-            expect(getTextContent(buffer)).toBe('line1\nline2\nline3');
-        });
-        it('preserves empty lines', () => {
-            const buffer = createBuffer('hello\n\nworld');
-            expect(getTextContent(buffer)).toBe('hello\n\nworld');
-        });
-    });
-});

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

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