ink-prompt 0.1.6 → 0.1.8

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

@@ -169,4 +169,141 @@ describe('useTextInput', () => {
             expect(result.current.cursor).toEqual({ line: 0, column: 5 });
         });
     });
+    describe('history limit', () => {
+        it('should use default history limit of 100', () => {
+            const { result } = renderHook(() => useTextInput());
+            // Insert 5 characters separately
+            for (let i = 0; i < 5; i++) {
+                act(() => {
+                    result.current.insert('a');
+                });
+            }
+            expect(result.current.value).toBe('aaaaa');
+            // Undo 5 times
+            for (let i = 0; i < 5; i++) {
+                act(() => {
+                    result.current.undo();
+                });
+            }
+            // Should be back to empty
+            expect(result.current.value).toBe('');
+            // Try to undo again - should have no effect
+            const valueBefore = result.current.value;
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe(valueBefore);
+        });
+        it('should respect custom history limit', () => {
+            const { result } = renderHook(() => useTextInput({ historyLimit: 3 }));
+            // Insert 5 characters
+            for (let i = 0; i < 5; i++) {
+                act(() => {
+                    result.current.insert('a');
+                });
+            }
+            expect(result.current.value).toBe('aaaaa');
+            // Undo 4 times - only 3 should work due to limit
+            for (let i = 0; i < 4; i++) {
+                act(() => {
+                    result.current.undo();
+                });
+            }
+            // Should be back to 2 characters (5 - 3 undos, since only 3 history entries)
+            expect(result.current.value).toBe('aa');
+            // Try to undo again - should have no effect
+            const valueBefore = result.current.value;
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe(valueBefore);
+        });
+        it('should trim oldest history when limit exceeded', () => {
+            const { result } = renderHook(() => useTextInput({ historyLimit: 3 }));
+            // Insert 5 characters
+            for (let i = 0; i < 5; i++) {
+                act(() => {
+                    result.current.insert('a');
+                });
+            }
+            expect(result.current.value).toBe('aaaaa');
+            // Can undo 3 times (limited by history)
+            for (let i = 0; i < 3; i++) {
+                act(() => {
+                    result.current.undo();
+                });
+            }
+            // Should be at 2 characters
+            expect(result.current.value).toBe('aa');
+            // Try to undo one more time - should have no effect (no more history)
+            const valueBefore = result.current.value;
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe(valueBefore);
+        });
+        it('should clear redo stack when new edit happens', () => {
+            const { result } = renderHook(() => useTextInput({ historyLimit: 5 }));
+            act(() => {
+                result.current.insert('a');
+            });
+            act(() => {
+                result.current.insert('b');
+            });
+            act(() => {
+                result.current.insert('c');
+            });
+            expect(result.current.value).toBe('abc');
+            // Undo once
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe('ab');
+            // Redo should work
+            act(() => {
+                result.current.redo();
+            });
+            expect(result.current.value).toBe('abc');
+            // Undo again
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe('ab');
+            // Insert new character - redo stack should be cleared
+            act(() => {
+                result.current.insert('d');
+            });
+            expect(result.current.value).toBe('abd');
+            // Redo should not work now (redo stack was cleared on insert)
+            const valueBefore = result.current.value;
+            act(() => {
+                result.current.redo();
+            });
+            expect(result.current.value).toBe(valueBefore);
+        });
+        it('should prevent excessive memory use with bounded history', () => {
+            const { result } = renderHook(() => useTextInput({ historyLimit: 10 }));
+            // Insert 30 characters
+            for (let i = 0; i < 30; i++) {
+                act(() => {
+                    result.current.insert('x');
+                });
+            }
+            expect(result.current.value).toBe('x'.repeat(30));
+            // We should only be able to undo 10 times due to history limit
+            for (let i = 0; i < 10; i++) {
+                act(() => {
+                    result.current.undo();
+                });
+            }
+            // Should be back to 20 characters (30 - 10 undos)
+            expect(result.current.value).toBe('x'.repeat(20));
+            // No more undos available
+            const valueBefore = result.current.value;
+            act(() => {
+                result.current.undo();
+            });
+            expect(result.current.value).toBe(valueBefore);
+        });
+    });
 });

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

@@ -1,37 +1,110 @@
 import React from 'react';
 export interface MultilineInputProps {
-    /** Controlled text value */
+    /**
+     * Controlled text value. When provided, the component becomes controlled
+     * and the value is managed externally.
+     */
     value?: string;
-    /** Called when text changes */
+    /**
+     * Called when the text content changes due to user input. Receives the
+     * new text value as a parameter.
+     */
     onChange?: (value: string) => void;
-    /** Called when user submits (Enter without backslash) */
+    /**
+     * Called when the user submits the input (typically by pressing Enter
+     * without a backslash at the end). Receives the final text value.
+     */
     onSubmit?: (value: string) => void;
-    /** Placeholder text when empty */
+    /**
+     * Placeholder text displayed when the input is empty and the cursor
+     * is not shown.
+     */
     placeholder?: string;
-    /** Whether to show the cursor (defaults to true) */
+    /**
+     * Whether to display the cursor. Defaults to true.
+     */
     showCursor?: boolean;
-    /** Terminal width for word wrapping */
+    /**
+     * Terminal width for word wrapping. If not provided, uses the terminal's
+     * current width with resize support.
+     */
     width?: number;
-    /** Whether input is active/focused (defaults to true) */
+    /**
+     * Whether the input is active and focused, allowing keyboard input.
+     * Defaults to true.
+     */
     isActive?: boolean;
-    /** Called whenever the cursor offset changes (flat index) */
+    /**
+     * Called whenever the cursor position changes. Receives the flat
+     * character offset as a parameter.
+     */
     onCursorChange?: (offset: number) => void;
-    /** Optional external cursor override (flat index) */
+    /**
+     * Optional external cursor position override. When set, forces the
+     * cursor to the specified flat character offset.
+     */
     cursorOverride?: number;
+    /**
+     * Called when an arrow key is pressed but cursor is at a boundary.
+     * - 'up': cursor is on the first/topmost line
+     * - 'down': cursor is on the last/bottommost line
+     * - 'left': cursor is at position 0 (start of text)
+     * - 'right': cursor is at end of text (after last character)
+     */
+    onBoundaryArrow?: (direction: 'up' | 'down' | 'left' | 'right') => void;
 }
 /**
  * Props for the core component (without Ink-specific hooks)
  * This allows testing the rendering logic separately.
  */
 export interface MultilineInputCoreProps {
+    /**
+     * Controlled text value. When provided, the component becomes controlled
+     * and the text is managed externally.
+     */
     value?: string;
+    /**
+     * Called when the text content changes. Receives the new text value
+     * as a parameter.
+     */
     onChange?: (value: string) => void;
+    /**
+     * Called when the user submits the input (typically by pressing Enter
+     * without a backslash at the end).
+     */
     onSubmit?: (value: string) => void;
+    /**
+     * Placeholder text displayed when the input is empty and the cursor
+     * is not shown.
+     */
     placeholder?: string;
+    /**
+     * Whether to display the cursor. Defaults to true.
+     */
     showCursor?: boolean;
+    /**
+     * Terminal width for word wrapping. If not provided, uses the terminal's
+     * current width.
+     */
     width?: number;
+    /**
+     * Called whenever the cursor position changes. Receives the flat
+     * character offset as a parameter.
+     */
     onCursorChange?: (offset: number) => void;
+    /**
+     * Optional external cursor position override. When set, forces the
+     * cursor to the specified flat character offset.
+     */
     cursorOverride?: number;
+    /**
+     * Called when an arrow key is pressed but cursor is at a boundary.
+     * - 'up': cursor is on the first/topmost line
+     * - 'down': cursor is on the last/bottommost line
+     * - 'left': cursor is at position 0 (start of text)
+     * - 'right': cursor is at end of text (after last character)
+     */
+    onBoundaryArrow?: (direction: 'up' | 'down' | 'left' | 'right') => void;
 }
 /**
  * Core rendering component that can be tested without Ink runtime.

package/dist/components/MultilineInput/index.js

@@ -66,7 +66,7 @@ export const MultilineInputCore = ({ value, onChange, placeholder, 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, onCursorChange, cursorOverride, }) => {
+export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCursor = true, width, isActive = true, onCursorChange, cursorOverride, onBoundaryArrow, }) => {
     // Get terminal width from Ink (with resize support) if not provided
     const terminalWidth = useTerminalWidth(width);
     // Track raw input for detecting Home/End keys
@@ -140,11 +140,12 @@ export const MultilineInput = ({ value, onChange, onSubmit, placeholder, showCur
         redo: textInput.redo,
         setText: textInput.setText,
         submit: handleSubmit,
+        onBoundaryArrow,
     };
     // Handle keyboard input
     useInput((input, key) => {
         log(`[USEINPUT] input="${input.replace(/[\x00-\x1F\x7F-\uFFFF]/g, c => `\\x${c.charCodeAt(0).toString(16)}`)}" key=${JSON.stringify(key)} rawLen=${lastRawInput.current?.length || 0}`);
-        handleKey(key, input, buffer, actions, textInput.cursor, lastRawInput.current);
+        handleKey(key, input, buffer, actions, textInput.cursor, lastRawInput.current, terminalWidth);
     }, { isActive });
     // Show placeholder if empty and no cursor shown
     const isEmpty = textInput.value === '';

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

@@ -3,6 +3,8 @@ export interface UseTextInputProps {
     initialValue?: string;
     /** Terminal width for visual-aware cursor navigation (up/down arrows respect line wrapping) */
     width?: number;
+    /** Maximum number of history entries to keep (default: 100) */
+    historyLimit?: number;
 }
 export interface UseTextInputResult {
     value: string;
@@ -19,4 +21,4 @@ export interface UseTextInputResult {
     cursorOffset: number;
     setCursorOffset: (offset: number) => void;
 }
-export declare function useTextInput({ initialValue, width }?: UseTextInputProps): UseTextInputResult;
+export declare function useTextInput({ initialValue, width, historyLimit }?: UseTextInputProps): UseTextInputResult;

package/dist/components/MultilineInput/useTextInput.js

@@ -1,7 +1,7 @@
 import { useState, useCallback } from 'react';
 import { createBuffer, insertText as bufferInsertText, deleteChar as bufferDeleteChar, deleteCharForward as bufferDeleteCharForward, insertNewLine as bufferInsertNewLine, moveCursor as bufferMoveCursor, getTextContent, getOffset, getCursor, } from './TextBuffer.js';
 import { log } from '../../utils/logger.js';
-export function useTextInput({ initialValue = '', width } = {}) {
+export function useTextInput({ initialValue = '', width, historyLimit = 100 } = {}) {
     const [buffer, setBuffer] = useState(() => createBuffer(initialValue));
     const [cursor, setCursor] = useState(() => {
         const lines = initialValue.split('\n');
@@ -13,9 +13,16 @@ export function useTextInput({ initialValue = '', width } = {}) {
     const [undoStack, setUndoStack] = useState([]);
     const [redoStack, setRedoStack] = useState([]);
     const pushToHistory = useCallback((currentBuffer, currentCursor) => {
-        setUndoStack((prev) => [...prev, { buffer: currentBuffer, cursor: currentCursor }]);
+        setUndoStack((prev) => {
+            const newStack = [...prev, { buffer: currentBuffer, cursor: currentCursor }];
+            // Trim stack if it exceeds history limit
+            if (newStack.length > historyLimit) {
+                return newStack.slice(-historyLimit);
+            }
+            return newStack;
+        });
         setRedoStack([]);
-    }, []);
+    }, [historyLimit]);
     const insert = useCallback((char) => {
         log(`[INSERT] char="${char.replace(/[\x00-\x1F\x7F-\uFFFF]/g, c => `\\x${c.charCodeAt(0).toString(16)}`)}" len=${char.length} cursor={line:${cursor.line},col:${cursor.column}} linesBefore=${buffer.lines.length}`);
         // Normalize line endings: \r\n → \n, \r → \n (handles Windows, Unix, and old Mac)

package/dist/hooks/__tests__/useTerminalWidth.test.js

@@ -30,7 +30,8 @@ describe('useTerminalWidth', () => {
         const { result } = renderHook(() => useTerminalWidth(100));
         expect(result.current).toBe(100);
     });
-    it('updates width on resize', () => {
+    it('updates width on resize', async () => {
+        vi.useFakeTimers();
         const { result } = renderHook(() => useTerminalWidth());
         expect(result.current).toBe(80);
         // Simulate resize
@@ -38,7 +39,12 @@ describe('useTerminalWidth', () => {
         act(() => {
             mockStdout.emit('resize');
         });
+        // Wait for debounce to complete
+        await act(async () => {
+            vi.advanceTimersByTime(100);
+        });
         expect(result.current).toBe(120);
+        vi.useRealTimers();
     });
     it('does not update when prop width is provided', () => {
         const { result } = renderHook(() => useTerminalWidth(50));
@@ -57,4 +63,66 @@ describe('useTerminalWidth', () => {
         unmount();
         expect(mockStdout.listenerCount('resize')).toBe(0);
     });
+    it('debounces multiple rapid resize events', async () => {
+        vi.useFakeTimers();
+        const { result } = renderHook(() => useTerminalWidth());
+        expect(result.current).toBe(80);
+        // Simulate rapid resize events
+        mockStdout.columns = 100;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        mockStdout.columns = 120;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        mockStdout.columns = 140;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        // Still at initial width because debounce hasn't fired yet
+        expect(result.current).toBe(80);
+        // Wait for debounce to complete
+        await act(async () => {
+            vi.advanceTimersByTime(100);
+        });
+        // Now updated to the last value
+        expect(result.current).toBe(140);
+        vi.useRealTimers();
+    });
+    it('accepts custom debounce delay', async () => {
+        vi.useFakeTimers();
+        const { result } = renderHook(() => useTerminalWidth(undefined, 50));
+        expect(result.current).toBe(80);
+        // Simulate resize
+        mockStdout.columns = 100;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        expect(result.current).toBe(80);
+        // Wait for custom debounce to complete
+        await act(async () => {
+            vi.advanceTimersByTime(50);
+        });
+        expect(result.current).toBe(100);
+        vi.useRealTimers();
+    });
+    it('cancels pending debounce on unmount', async () => {
+        vi.useFakeTimers();
+        const { unmount } = renderHook(() => useTerminalWidth());
+        // Simulate resize
+        mockStdout.columns = 100;
+        act(() => {
+            mockStdout.emit('resize');
+        });
+        // Unmount before debounce fires
+        unmount();
+        // Advance time past debounce delay
+        await act(async () => {
+            vi.advanceTimersByTime(200);
+        });
+        // No errors should occur
+        expect(true).toBe(true);
+        vi.useRealTimers();
+    });
 });

package/dist/hooks/useTerminalWidth.d.ts

@@ -2,6 +2,7 @@
  * Hook to get the current terminal width and listen for resize events.
  *
  * @param propWidth - Optional explicit width to use instead of terminal width
+ * @param debounceMs - Optional debounce delay in milliseconds (default: 100)
  * @returns The effective width (propWidth if provided, otherwise terminal width)
  */
-export declare function useTerminalWidth(propWidth?: number): number;
+export declare function useTerminalWidth(propWidth?: number, debounceMs?: number): number;

package/dist/hooks/useTerminalWidth.js

@@ -1,24 +1,39 @@
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import { useStdout } from 'ink';
 /**
  * Hook to get the current terminal width and listen for resize events.
  *
  * @param propWidth - Optional explicit width to use instead of terminal width
+ * @param debounceMs - Optional debounce delay in milliseconds (default: 100)
  * @returns The effective width (propWidth if provided, otherwise terminal width)
  */
-export function useTerminalWidth(propWidth) {
+export function useTerminalWidth(propWidth, debounceMs = 100) {
     const { stdout } = useStdout();
     const [terminalWidth, setTerminalWidth] = useState(stdout?.columns ?? 80);
+    const debounceTimer = useRef(null);
     useEffect(() => {
         if (!stdout)
             return;
         const onResize = () => {
-            setTerminalWidth(stdout.columns);
+            // Cancel any pending debounce timer
+            if (debounceTimer.current) {
+                clearTimeout(debounceTimer.current);
+            }
+            // Set a new debounce timer
+            debounceTimer.current = setTimeout(() => {
+                setTerminalWidth(stdout.columns);
+                debounceTimer.current = null;
+            }, debounceMs);
         };
         stdout.on('resize', onResize);
         return () => {
             stdout.off('resize', onResize);
+            // Clean up any pending timer on unmount
+            if (debounceTimer.current) {
+                clearTimeout(debounceTimer.current);
+                debounceTimer.current = null;
+            }
         };
-    }, [stdout]);
+    }, [stdout, debounceMs]);
     return propWidth ?? terminalWidth;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ink-prompt",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "A React Ink component for prompts",
   "type": "module",
   "main": "./dist/index.js",