ink-prompt 0.2.3 → 0.2.4

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

@@ -1,176 +0,0 @@
-import React from 'react';
-import { describe, it, expect } from 'vitest';
-import { render } from '@testing-library/react';
-import { TextRenderer, wrapLines } from '../TextRenderer';
-describe('wrapLines', () => {
-    describe('no wrapping needed', () => {
-        it('returns single line unchanged when shorter than width', () => {
-            const buffer = { lines: ['hello'] };
-            const cursor = { line: 0, column: 5 };
-            const result = wrapLines(buffer, cursor, 80);
-            expect(result.visualLines).toEqual(['hello']);
-            expect(result.cursorVisualRow).toBe(0);
-            expect(result.cursorVisualCol).toBe(5);
-        });
-        it('returns multiple lines unchanged when all shorter than width', () => {
-            const buffer = { lines: ['hello', 'world'] };
-            const cursor = { line: 1, column: 3 };
-            const result = wrapLines(buffer, cursor, 80);
-            expect(result.visualLines).toEqual(['hello', 'world']);
-            expect(result.cursorVisualRow).toBe(1);
-            expect(result.cursorVisualCol).toBe(3);
-        });
-        it('handles empty buffer', () => {
-            const buffer = { lines: [''] };
-            const cursor = { line: 0, column: 0 };
-            const result = wrapLines(buffer, cursor, 80);
-            expect(result.visualLines).toEqual(['']);
-            expect(result.cursorVisualRow).toBe(0);
-            expect(result.cursorVisualCol).toBe(0);
-        });
-    });
-    describe('wrapping single line', () => {
-        it('wraps line exceeding width', () => {
-            const buffer = { lines: ['abcdefghij'] };
-            const cursor = { line: 0, column: 0 };
-            const result = wrapLines(buffer, cursor, 5);
-            expect(result.visualLines).toEqual(['abcde', 'fghij']);
-        });
-        it('wraps line into multiple visual lines', () => {
-            const buffer = { lines: ['abcdefghijklmno'] };
-            const cursor = { line: 0, column: 0 };
-            const result = wrapLines(buffer, cursor, 5);
-            expect(result.visualLines).toEqual(['abcde', 'fghij', 'klmno']);
-        });
-        it('handles exact width match (no extra empty line)', () => {
-            const buffer = { lines: ['abcde'] };
-            const cursor = { line: 0, column: 5 };
-            const result = wrapLines(buffer, cursor, 5);
-            expect(result.visualLines).toEqual(['abcde']);
-        });
-    });
-    describe('cursor position in wrapped lines', () => {
-        it('cursor on first visual row', () => {
-            const buffer = { lines: ['abcdefghij'] };
-            const cursor = { line: 0, column: 3 };
-            const result = wrapLines(buffer, cursor, 5);
-            expect(result.cursorVisualRow).toBe(0);
-            expect(result.cursorVisualCol).toBe(3);
-        });
-        it('cursor on second visual row', () => {
-            const buffer = { lines: ['abcdefghij'] };
-            const cursor = { line: 0, column: 7 };
-            const result = wrapLines(buffer, cursor, 5);
-            expect(result.cursorVisualRow).toBe(1);
-            expect(result.cursorVisualCol).toBe(2);
-        });
-        it('cursor at wrap boundary (end of first visual row)', () => {
-            const buffer = { lines: ['abcdefghij'] };
-            const cursor = { line: 0, column: 5 };
-            const result = wrapLines(buffer, cursor, 5);
-            expect(result.cursorVisualRow).toBe(1);
-            expect(result.cursorVisualCol).toBe(0);
-        });
-        it('cursor at end of wrapped line', () => {
-            const buffer = { lines: ['abcdefghij'] };
-            const cursor = { line: 0, column: 10 };
-            const result = wrapLines(buffer, cursor, 5);
-            expect(result.cursorVisualRow).toBe(1);
-            expect(result.cursorVisualCol).toBe(5);
-        });
-    });
-    describe('wrapping multiple lines', () => {
-        it('wraps only the line that exceeds width', () => {
-            const buffer = { lines: ['hi', 'abcdefghij'] };
-            const cursor = { line: 0, column: 0 };
-            const result = wrapLines(buffer, cursor, 5);
-            expect(result.visualLines).toEqual(['hi', 'abcde', 'fghij']);
-        });
-        it('cursor on second logical line that wraps', () => {
-            const buffer = { lines: ['hi', 'abcdefghij'] };
-            const cursor = { line: 1, column: 7 };
-            const result = wrapLines(buffer, cursor, 5);
-            expect(result.visualLines).toEqual(['hi', 'abcde', 'fghij']);
-            expect(result.cursorVisualRow).toBe(2);
-            expect(result.cursorVisualCol).toBe(2);
-        });
-        it('handles multiple wrapped lines', () => {
-            const buffer = { lines: ['abcdefg', 'hijklmn'] };
-            const cursor = { line: 1, column: 5 };
-            const result = wrapLines(buffer, cursor, 4);
-            expect(result.visualLines).toEqual(['abcd', 'efg', 'hijk', 'lmn']);
-            expect(result.cursorVisualRow).toBe(3);
-            expect(result.cursorVisualCol).toBe(1);
-        });
-    });
-});
-describe('TextRenderer', () => {
-    describe('basic rendering', () => {
-        it('renders single line', () => {
-            const buffer = { lines: ['hello'] };
-            const cursor = { line: 0, column: 0 };
-            const { container } = render(React.createElement(TextRenderer, { buffer: buffer, cursor: cursor }));
-            expect(container.textContent).toContain('hello');
-        });
-        it('renders multiple lines', () => {
-            const buffer = { lines: ['hello', 'world'] };
-            const cursor = { line: 0, column: 0 };
-            const { container } = render(React.createElement(TextRenderer, { buffer: buffer, cursor: cursor }));
-            expect(container.textContent).toContain('hello');
-            expect(container.textContent).toContain('world');
-        });
-        it('renders empty buffer', () => {
-            const buffer = { lines: [''] };
-            const cursor = { line: 0, column: 0 };
-            const { container } = render(React.createElement(TextRenderer, { buffer: buffer, cursor: cursor }));
-            // Should render cursor character in empty buffer
-            expect(container.textContent).toContain('█');
-        });
-    });
-    describe('cursor display', () => {
-        it('shows cursor at start of line', () => {
-            const buffer = { lines: ['hello'] };
-            const cursor = { line: 0, column: 0 };
-            const { container } = render(React.createElement(TextRenderer, { buffer: buffer, cursor: cursor, showCursor: true }));
-            // Cursor should be rendered before 'hello'
-            expect(container.textContent).toContain('█hello');
-        });
-        it('shows cursor at end of line', () => {
-            const buffer = { lines: ['hello'] };
-            const cursor = { line: 0, column: 5 };
-            const { container } = render(React.createElement(TextRenderer, { buffer: buffer, cursor: cursor, showCursor: true }));
-            expect(container.textContent).toContain('hello█');
-        });
-        it('shows cursor in middle of line', () => {
-            const buffer = { lines: ['hello'] };
-            const cursor = { line: 0, column: 2 };
-            const { container } = render(React.createElement(TextRenderer, { buffer: buffer, cursor: cursor, showCursor: true }));
-            expect(container.textContent).toContain('he█llo');
-        });
-        it('hides cursor when showCursor is false', () => {
-            const buffer = { lines: ['hello'] };
-            const cursor = { line: 0, column: 0 };
-            const { container } = render(React.createElement(TextRenderer, { buffer: buffer, cursor: cursor, showCursor: false }));
-            expect(container.textContent).not.toContain('█');
-            expect(container.textContent).toContain('hello');
-        });
-    });
-    describe('word wrapping in render', () => {
-        it('renders wrapped lines', () => {
-            const buffer = { lines: ['abcdefghij'] };
-            const cursor = { line: 0, column: 0 };
-            const { container } = render(React.createElement(TextRenderer, { buffer: buffer, cursor: cursor, width: 5 }));
-            // Both visual lines should be present
-            expect(container.textContent).toContain('abcde');
-            expect(container.textContent).toContain('fghij');
-        });
-        it('shows cursor correctly on wrapped line', () => {
-            const buffer = { lines: ['abcdefghij'] };
-            const cursor = { line: 0, column: 7 };
-            const { container } = render(React.createElement(TextRenderer, { buffer: buffer, cursor: cursor, width: 5, showCursor: true }));
-            // Cursor at position 7 wraps to second visual row, column 2
-            // So we should see 'fg█hij' on the second visual row
-            expect(container.textContent).toContain('fg█hij');
-        });
-    });
-});

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

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

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

@@ -1,71 +0,0 @@
-import React from 'react';
-import { describe, it, expect, vi } from 'vitest';
-import { render } from '@testing-library/react';
-import { MultilineInputCore } from '../index';
-/**
- * Integration tests for MultilineInputCore.
- *
- * These tests validate the component's rendering and props behavior.
- * We test MultilineInputCore instead of MultilineInput to avoid requiring
- * the Ink runtime (useInput, useStdout hooks).
- *
- * Keyboard handling is thoroughly tested via KeyHandler.test.ts.
- * State management is tested via useTextInput.test.ts.
- */
-describe('MultilineInputCore', () => {
-    describe('Rendering', () => {
-        it('renders empty input with cursor', () => {
-            const { container } = render(React.createElement(MultilineInputCore, null));
-            expect(container.textContent).toContain('█');
-        });
-        it('renders with initial value', () => {
-            const { container } = render(React.createElement(MultilineInputCore, { value: "hello" }));
-            expect(container.textContent).toContain('hello');
-        });
-        it('renders multiline value', () => {
-            const { container } = render(React.createElement(MultilineInputCore, { value: "line1\\nline2" }));
-            expect(container.textContent).toContain('line1');
-            expect(container.textContent).toContain('line2');
-        });
-        it('shows cursor at end of value', () => {
-            const { container } = render(React.createElement(MultilineInputCore, { value: "hi" }));
-            expect(container.textContent).toContain('hi█');
-        });
-        it('hides cursor when showCursor is false', () => {
-            const { container } = render(React.createElement(MultilineInputCore, { value: "hello", showCursor: false }));
-            expect(container.textContent).not.toContain('█');
-            expect(container.textContent).toContain('hello');
-        });
-    });
-    describe('Props', () => {
-        it('accepts width prop for word wrapping', () => {
-            const { container } = render(React.createElement(MultilineInputCore, { value: "abcdefghij", width: 5 }));
-            // Should wrap at width 5
-            expect(container.textContent).toContain('abcde');
-            expect(container.textContent).toContain('fghij');
-        });
-        it('calls onChange on initial render with value', () => {
-            const onChange = vi.fn();
-            render(React.createElement(MultilineInputCore, { value: "test", onChange: onChange }));
-            // onChange is called with the initial value
-            expect(onChange).toHaveBeenCalledWith('test');
-        });
-    });
-    describe('Placeholder', () => {
-        it('shows placeholder when empty and cursor hidden', () => {
-            const { container } = render(React.createElement(MultilineInputCore, { placeholder: "Type here...", showCursor: false }));
-            expect(container.textContent).toContain('Type here...');
-        });
-        it('does not show placeholder when showCursor is true', () => {
-            const { container } = render(React.createElement(MultilineInputCore, { placeholder: "Type here...", showCursor: true }));
-            // Shows cursor instead, not placeholder
-            expect(container.textContent).toContain('█');
-            expect(container.textContent).not.toContain('Type here...');
-        });
-        it('does not show placeholder when has value', () => {
-            const { container } = render(React.createElement(MultilineInputCore, { value: "hello", placeholder: "Type here...", showCursor: false }));
-            expect(container.textContent).toContain('hello');
-            expect(container.textContent).not.toContain('Type here...');
-        });
-    });
-});

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

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

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

@@ -1,65 +0,0 @@
-import { renderHook, act } from '@testing-library/react';
-import { describe, it, expect } from 'vitest';
-import { useTextInput } from '../useTextInput';
-describe('useTextInput', () => {
-    it('should initialize with empty buffer', () => {
-        const { result } = renderHook(() => useTextInput());
-        expect(result.current.value).toBe('');
-        expect(result.current.cursor).toEqual({ line: 0, column: 0 });
-    });
-    it('should initialize with initial value', () => {
-        const { result } = renderHook(() => useTextInput({ initialValue: 'Hello\nWorld' }));
-        expect(result.current.value).toBe('Hello\nWorld');
-        expect(result.current.cursor).toEqual({ line: 1, column: 5 }); // Cursor at end
-    });
-    it('should insert character', () => {
-        const { result } = renderHook(() => useTextInput());
-        act(() => {
-            result.current.insert('a');
-        });
-        expect(result.current.value).toBe('a');
-        expect(result.current.cursor).toEqual({ line: 0, column: 1 });
-    });
-    it('should delete character', () => {
-        const { result } = renderHook(() => useTextInput({ initialValue: 'abc' }));
-        act(() => {
-            result.current.delete();
-        });
-        expect(result.current.value).toBe('ab');
-        expect(result.current.cursor).toEqual({ line: 0, column: 2 });
-    });
-    it('should insert new line', () => {
-        const { result } = renderHook(() => useTextInput({ initialValue: 'abc' }));
-        // Move cursor to middle
-        act(() => {
-            result.current.moveCursor('left');
-        });
-        act(() => {
-            result.current.newLine();
-        });
-        expect(result.current.value).toBe('ab\nc');
-        expect(result.current.cursor).toEqual({ line: 1, column: 0 });
-    });
-    it('should move cursor', () => {
-        const { result } = renderHook(() => useTextInput({ initialValue: 'abc' }));
-        act(() => {
-            result.current.moveCursor('left');
-        });
-        expect(result.current.cursor).toEqual({ line: 0, column: 2 });
-    });
-    it('should support undo/redo', () => {
-        const { result } = renderHook(() => useTextInput());
-        act(() => {
-            result.current.insert('a');
-        });
-        expect(result.current.value).toBe('a');
-        act(() => {
-            result.current.undo();
-        });
-        expect(result.current.value).toBe('');
-        act(() => {
-            result.current.redo();
-        });
-        expect(result.current.value).toBe('a');
-    });
-});

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

@@ -1,39 +0,0 @@
-import React from 'react';
-export interface MultilineInputProps {
-    /** Controlled text value */
-    value?: string;
-    /** Called when text changes */
-    onChange?: (value: string) => void;
-    /** Called when user submits (Enter without backslash) */
-    onSubmit?: (value: string) => void;
-    /** Placeholder text when empty */
-    placeholder?: string;
-    /** Whether to show the cursor (defaults to true) */
-    showCursor?: boolean;
-    /** Terminal width for word wrapping */
-    width?: number;
-    /** Whether input is active/focused (defaults to true) */
-    isActive?: boolean;
-}
-/**
- * Props for the core component (without Ink-specific hooks)
- * This allows testing the rendering logic separately.
- */
-export interface MultilineInputCoreProps {
-    value?: string;
-    onChange?: (value: string) => void;
-    onSubmit?: (value: string) => void;
-    placeholder?: string;
-    showCursor?: boolean;
-    width?: number;
-}
-/**
- * Core rendering component that can be tested without Ink runtime.
- * Does not include useInput/useStdout hooks.
- */
-export declare const MultilineInputCore: React.FC<MultilineInputCoreProps>;
-/**
- * Full MultilineInput with Ink keyboard handling.
- * This component uses Ink-specific hooks and must be rendered in an Ink context.
- */
-export declare const MultilineInput: React.FC<MultilineInputProps>;

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

@@ -1,82 +0,0 @@
-import React, { useEffect, useCallback } from 'react';
-import { useTextInput } from './useTextInput';
-import { handleKey } from './KeyHandler';
-import { TextRenderer } from './TextRenderer';
-import { createBuffer } from './TextBuffer';
-/**
- * Core rendering component that can be tested without Ink runtime.
- * Does not include useInput/useStdout hooks.
- */
-export const MultilineInputCore = ({ value, onChange, placeholder, showCursor = true, width = 80, }) => {
-    const textInput = useTextInput({ initialValue: value ?? '' });
-    // Sync external value changes
-    useEffect(() => {
-        if (value !== undefined && value !== textInput.value) {
-            textInput.setText(value);
-        }
-    }, [value]);
-    // Notify parent of changes
-    useEffect(() => {
-        onChange?.(textInput.value);
-    }, [textInput.value, onChange]);
-    // Create buffer for TextRenderer
-    const buffer = createBuffer(textInput.value);
-    // Show placeholder if empty and no cursor shown
-    const isEmpty = textInput.value === '';
-    const showPlaceholder = isEmpty && placeholder && !showCursor;
-    if (showPlaceholder) {
-        return React.createElement("div", { style: { opacity: 0.5 } }, placeholder);
-    }
-    return (React.createElement(TextRenderer, { buffer: buffer, cursor: textInput.cursor, width: width, showCursor: showCursor }));
-};
-/**
- * Full MultilineInput with Ink keyboard handling.
- * This component uses Ink-specific hooks and must be rendered in an Ink context.
- */
-export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCursor = true, width, isActive = true, }) => {
-    // Import Ink hooks dynamically to avoid import-time errors in tests
-    const { useInput, useStdout, Box, Text } = require('ink');
-    // Get terminal width from Ink if not provided
-    const { stdout } = useStdout();
-    const terminalWidth = width ?? stdout?.columns ?? 80;
-    const textInput = useTextInput({ initialValue: value ?? '' });
-    // Sync external value changes
-    useEffect(() => {
-        if (value !== undefined && value !== textInput.value) {
-            textInput.setText(value);
-        }
-    }, [value]);
-    // Notify parent of changes
-    useEffect(() => {
-        onChange?.(textInput.value);
-    }, [textInput.value, onChange]);
-    // Create buffer for TextRenderer and KeyHandler
-    const buffer = createBuffer(textInput.value);
-    // Create submit handler
-    const handleSubmit = useCallback(() => {
-        onSubmit?.(textInput.value);
-    }, [onSubmit, textInput.value]);
-    // Create actions for KeyHandler
-    const actions = {
-        insert: textInput.insert,
-        delete: textInput.delete,
-        newLine: textInput.newLine,
-        moveCursor: textInput.moveCursor,
-        undo: textInput.undo,
-        redo: textInput.redo,
-        setText: textInput.setText,
-        submit: handleSubmit,
-    };
-    // Handle keyboard input
-    useInput((input, key) => {
-        handleKey(key, input, buffer, actions, textInput.cursor);
-    }, { isActive });
-    // Show placeholder if empty and no cursor shown
-    const isEmpty = textInput.value === '';
-    const showPlaceholder = isEmpty && placeholder && !showCursor;
-    if (showPlaceholder) {
-        return (React.createElement(Box, null,
-            React.createElement(Text, { dimColor: true }, placeholder)));
-    }
-    return (React.createElement(TextRenderer, { buffer: buffer, cursor: textInput.cursor, width: terminalWidth, showCursor: showCursor }));
-};

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

@@ -1,55 +0,0 @@
-/**
- * Cursor position in the text buffer
- */
-export interface Cursor {
-    /** 0-indexed line number */
-    line: number;
-    /** 0-indexed column position */
-    column: number;
-}
-/**
- * Text buffer containing multiple lines
- */
-export interface Buffer {
-    /** Array of text lines (without newline characters) */
-    lines: string[];
-}
-/**
- * Cursor movement directions
- */
-export type Direction = 'up' | 'down' | 'left' | 'right' | 'lineStart' | 'lineEnd';
-/**
- * Result of wrapping buffer lines for visual display
- */
-export interface WrapResult {
-    /** Visual lines after wrapping */
-    visualLines: string[];
-    /** Row in visual lines where cursor appears */
-    cursorVisualRow: number;
-    /** Column in that visual row where cursor appears */
-    cursorVisualCol: number;
-}
-/**
- * Keyboard key state (mirrors Ink's Key interface)
- * Defined locally to avoid ESM/CJS import issues with Ink
- */
-export interface Key {
-    upArrow?: boolean;
-    downArrow?: boolean;
-    leftArrow?: boolean;
-    rightArrow?: boolean;
-    pageDown?: boolean;
-    pageUp?: boolean;
-    return?: boolean;
-    escape?: boolean;
-    ctrl?: boolean;
-    shift?: boolean;
-    tab?: boolean;
-    backspace?: boolean;
-    delete?: boolean;
-    meta?: boolean;
-    /** Home key (may not be available in all terminals) */
-    home?: boolean;
-    /** End key (may not be available in all terminals) */
-    end?: boolean;
-}

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

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

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

@@ -1,16 +0,0 @@
-import type { Cursor, Direction } from './types';
-export interface UseTextInputProps {
-    initialValue?: string;
-}
-export interface UseTextInputResult {
-    value: string;
-    cursor: Cursor;
-    insert: (char: string) => void;
-    delete: () => void;
-    newLine: () => void;
-    moveCursor: (direction: Direction) => void;
-    undo: () => void;
-    redo: () => void;
-    setText: (text: string) => void;
-}
-export declare function useTextInput({ initialValue }?: UseTextInputProps): UseTextInputResult;

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

@@ -1,82 +0,0 @@
-import { useState, useCallback } from 'react';
-import { createBuffer, insertChar as bufferInsertChar, deleteChar as bufferDeleteChar, insertNewLine as bufferInsertNewLine, moveCursor as bufferMoveCursor, getTextContent, } from './TextBuffer';
-export function useTextInput({ initialValue = '' } = {}) {
-    const [buffer, setBuffer] = useState(() => createBuffer(initialValue));
-    const [cursor, setCursor] = useState(() => {
-        const lines = initialValue.split('\n');
-        return {
-            line: lines.length - 1,
-            column: lines[lines.length - 1].length,
-        };
-    });
-    const [undoStack, setUndoStack] = useState([]);
-    const [redoStack, setRedoStack] = useState([]);
-    const pushToHistory = useCallback((currentBuffer, currentCursor) => {
-        setUndoStack((prev) => [...prev, { buffer: currentBuffer, cursor: currentCursor }]);
-        setRedoStack([]);
-    }, []);
-    const insert = useCallback((char) => {
-        pushToHistory(buffer, cursor);
-        const result = bufferInsertChar(buffer, cursor, char);
-        setBuffer(result.buffer);
-        setCursor(result.cursor);
-    }, [buffer, cursor, pushToHistory]);
-    const deleteChar = useCallback(() => {
-        pushToHistory(buffer, cursor);
-        const result = bufferDeleteChar(buffer, cursor);
-        setBuffer(result.buffer);
-        setCursor(result.cursor);
-    }, [buffer, cursor, pushToHistory]);
-    const newLine = useCallback(() => {
-        pushToHistory(buffer, cursor);
-        const result = bufferInsertNewLine(buffer, cursor);
-        setBuffer(result.buffer);
-        setCursor(result.cursor);
-    }, [buffer, cursor, pushToHistory]);
-    const moveCursor = useCallback((direction) => {
-        const newCursor = bufferMoveCursor(buffer, cursor, direction);
-        setCursor(newCursor);
-    }, [buffer, cursor]);
-    const undo = useCallback(() => {
-        if (undoStack.length === 0)
-            return;
-        const previousState = undoStack[undoStack.length - 1];
-        const newUndoStack = undoStack.slice(0, -1);
-        setRedoStack((prev) => [...prev, { buffer, cursor }]);
-        setBuffer(previousState.buffer);
-        setCursor(previousState.cursor);
-        setUndoStack(newUndoStack);
-    }, [buffer, cursor, undoStack]);
-    const redo = useCallback(() => {
-        if (redoStack.length === 0)
-            return;
-        const nextState = redoStack[redoStack.length - 1];
-        const newRedoStack = redoStack.slice(0, -1);
-        setUndoStack((prev) => [...prev, { buffer, cursor }]);
-        setBuffer(nextState.buffer);
-        setCursor(nextState.cursor);
-        setRedoStack(newRedoStack);
-    }, [buffer, cursor, redoStack]);
-    const setText = useCallback((text) => {
-        pushToHistory(buffer, cursor);
-        const newBuffer = createBuffer(text);
-        setBuffer(newBuffer);
-        // Move cursor to end of new text
-        const lines = text.split('\n');
-        setCursor({
-            line: lines.length - 1,
-            column: lines[lines.length - 1].length,
-        });
-    }, [buffer, cursor, pushToHistory]);
-    return {
-        value: getTextContent(buffer),
-        cursor,
-        insert,
-        delete: deleteChar,
-        newLine,
-        moveCursor,
-        undo,
-        redo,
-        setText,
-    };
-}

package/dist/examples/src/hello.test.d.ts

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

package/dist/examples/src/hello.test.js

@@ -1,13 +0,0 @@
-import { describe, it, expect } from 'vitest';
-describe('Hello World Test', () => {
-    it('should pass a simple test', () => {
-        expect(true).toBe(true);
-    });
-    it('should perform basic arithmetic', () => {
-        expect(2 + 2).toBe(4);
-    });
-    it('should handle string concatenation', () => {
-        const greeting = 'Hello' + ' ' + 'World';
-        expect(greeting).toBe('Hello World');
-    });
-});

package/dist/examples/src/index.d.ts

@@ -1,2 +0,0 @@
-export { MultilineInput } from './components/MultilineInput';
-export type { MultilineInputProps } from './components/MultilineInput';

package/dist/examples/src/index.js

@@ -1,2 +0,0 @@
-// Re-export all components and utilities
-export { MultilineInput } from './components/MultilineInput/index.js';