ink-prompt 0.1.7 → 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/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.7",
+  "version": "0.1.8",
   "description": "A React Ink component for prompts",
   "type": "module",
   "main": "./dist/index.js",