@google/gemini-cli 0.12.0-nightly.20251023.c4c0c0d1 → 0.12.0-preview.0

package/dist/src/ui/hooks/useSelectionList.test.js

@@ -1,10 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
+import { act } from 'react';
+import { render } from 'ink-testing-library';
 import { useSelectionList, } from './useSelectionList.js';
 import { useKeypress } from './useKeypress.js';
 vi.mock('./useKeypress.js');
@@ -49,29 +51,52 @@ describe('useSelectionList', () => {
             }
         });
     };
+    const renderSelectionListHook = (initialProps) => {
+        let hookResult;
+        function TestComponent(props) {
+            hookResult = useSelectionList(props);
+            return null;
+        }
+        const { rerender, unmount } = render(_jsx(TestComponent, { ...initialProps }));
+        return {
+            result: {
+                get current() {
+                    return hookResult;
+                },
+            },
+            rerender: (newProps) => rerender(_jsx(TestComponent, { ...initialProps, ...newProps })),
+            unmount,
+        };
+    };
     describe('Initialization', () => {
         it('should initialize with the default index (0) if enabled', () => {
-            const { result } = renderHook(() => useSelectionList({ items, onSelect: mockOnSelect }));
+            const { result } = renderSelectionListHook({
+                items,
+                onSelect: mockOnSelect,
+            });
             expect(result.current.activeIndex).toBe(0);
         });
         it('should initialize with the provided initialIndex if enabled', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items,
                 initialIndex: 2,
                 onSelect: mockOnSelect,
-            }));
+            });
             expect(result.current.activeIndex).toBe(2);
         });
         it('should handle an empty list gracefully', () => {
-            const { result } = renderHook(() => useSelectionList({ items: [], onSelect: mockOnSelect }));
+            const { result } = renderSelectionListHook({
+                items: [],
+                onSelect: mockOnSelect,
+            });
             expect(result.current.activeIndex).toBe(0);
         });
         it('should find the next enabled item (downwards) if initialIndex is disabled', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items,
                 initialIndex: 1,
                 onSelect: mockOnSelect,
-            }));
+            });
             expect(result.current.activeIndex).toBe(2);
         });
         it('should wrap around to find the next enabled item if initialIndex is disabled', () => {
@@ -80,25 +105,25 @@ describe('useSelectionList', () => {
                 { value: 'B', disabled: true, key: 'B' },
                 { value: 'C', disabled: true, key: 'C' },
             ];
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: wrappingItems,
                 initialIndex: 2,
                 onSelect: mockOnSelect,
-            }));
+            });
             expect(result.current.activeIndex).toBe(0);
         });
         it('should default to 0 if initialIndex is out of bounds', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items,
                 initialIndex: 10,
                 onSelect: mockOnSelect,
-            }));
+            });
             expect(result.current.activeIndex).toBe(0);
-            const { result: resultNeg } = renderHook(() => useSelectionList({
+            const { result: resultNeg } = renderSelectionListHook({
                 items,
                 initialIndex: -1,
                 onSelect: mockOnSelect,
-            }));
+            });
             expect(resultNeg.current.activeIndex).toBe(0);
         });
         it('should stick to the initial index if all items are disabled', () => {
@@ -106,17 +131,20 @@ describe('useSelectionList', () => {
                 { value: 'A', disabled: true, key: 'A' },
                 { value: 'B', disabled: true, key: 'B' },
             ];
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: allDisabled,
                 initialIndex: 1,
                 onSelect: mockOnSelect,
-            }));
+            });
             expect(result.current.activeIndex).toBe(1);
         });
     });
     describe('Keyboard Navigation (Up/Down/J/K)', () => {
         it('should move down with "j" and "down" keys, skipping disabled items', () => {
-            const { result } = renderHook(() => useSelectionList({ items, onSelect: mockOnSelect }));
+            const { result } = renderSelectionListHook({
+                items,
+                onSelect: mockOnSelect,
+            });
             expect(result.current.activeIndex).toBe(0);
             pressKey('j');
             expect(result.current.activeIndex).toBe(2);
@@ -124,7 +152,11 @@ describe('useSelectionList', () => {
             expect(result.current.activeIndex).toBe(3);
         });
         it('should move up with "k" and "up" keys, skipping disabled items', () => {
-            const { result } = renderHook(() => useSelectionList({ items, initialIndex: 3, onSelect: mockOnSelect }));
+            const { result } = renderSelectionListHook({
+                items,
+                initialIndex: 3,
+                onSelect: mockOnSelect,
+            });
             expect(result.current.activeIndex).toBe(3);
             pressKey('k');
             expect(result.current.activeIndex).toBe(2);
@@ -132,11 +164,11 @@ describe('useSelectionList', () => {
             expect(result.current.activeIndex).toBe(0);
         });
         it('should wrap navigation correctly', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items,
                 initialIndex: items.length - 1,
                 onSelect: mockOnSelect,
-            }));
+            });
             expect(result.current.activeIndex).toBe(3);
             pressKey('down');
             expect(result.current.activeIndex).toBe(0);
@@ -144,22 +176,22 @@ describe('useSelectionList', () => {
             expect(result.current.activeIndex).toBe(3);
         });
         it('should call onHighlight when index changes', () => {
-            renderHook(() => useSelectionList({
+            renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
-            }));
+            });
             pressKey('down');
             expect(mockOnHighlight).toHaveBeenCalledTimes(1);
             expect(mockOnHighlight).toHaveBeenCalledWith('C');
         });
         it('should not move or call onHighlight if navigation results in the same index (e.g., single item)', () => {
             const singleItem = [{ value: 'A', key: 'A' }];
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: singleItem,
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
-            }));
+            });
             pressKey('down');
             expect(result.current.activeIndex).toBe(0);
             expect(mockOnHighlight).not.toHaveBeenCalled();
@@ -169,11 +201,11 @@ describe('useSelectionList', () => {
                 { value: 'A', disabled: true, key: 'A' },
                 { value: 'B', disabled: true, key: 'B' },
             ];
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: allDisabled,
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
-            }));
+            });
             const initialIndex = result.current.activeIndex;
             pressKey('down');
             expect(result.current.activeIndex).toBe(initialIndex);
@@ -182,20 +214,20 @@ describe('useSelectionList', () => {
     });
     describe('Selection (Enter)', () => {
         it('should call onSelect when "return" is pressed on enabled item', () => {
-            renderHook(() => useSelectionList({
+            renderSelectionListHook({
                 items,
                 initialIndex: 2,
                 onSelect: mockOnSelect,
-            }));
+            });
             pressKey('return');
             expect(mockOnSelect).toHaveBeenCalledTimes(1);
             expect(mockOnSelect).toHaveBeenCalledWith('C');
         });
         it('should not call onSelect if the active item is disabled', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
-            }));
+            });
             act(() => result.current.setActiveIndex(1));
             pressKey('return');
             expect(mockOnSelect).not.toHaveBeenCalled();
@@ -203,11 +235,11 @@ describe('useSelectionList', () => {
     });
     describe('Keyboard Navigation Robustness (Rapid Input)', () => {
         it('should handle rapid navigation and selection robustly (avoiding stale state)', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items, // A, B(disabled), C, D. Initial index 0 (A).
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
-            }));
+            });
             // Simulate rapid inputs with separate act blocks to allow effects to run
             if (!activeKeypressHandler)
                 throw new Error('Handler not active');
@@ -244,11 +276,11 @@ describe('useSelectionList', () => {
             expect(mockOnSelect).not.toHaveBeenCalledWith('A');
         });
         it('should handle ultra-rapid input (multiple presses in single act) without stale state', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items, // A, B(disabled), C, D. Initial index 0 (A).
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
-            }));
+            });
             // Simulate ultra-rapid inputs where all keypresses happen faster than React can re-render
             act(() => {
                 if (!activeKeypressHandler)
@@ -278,27 +310,38 @@ describe('useSelectionList', () => {
     });
     describe('Focus Management (isFocused)', () => {
         it('should activate the keypress handler when focused (default) and items exist', () => {
-            const { result } = renderHook(() => useSelectionList({ items, onSelect: mockOnSelect }));
+            const { result } = renderSelectionListHook({
+                items,
+                onSelect: mockOnSelect,
+            });
             expect(activeKeypressHandler).not.toBeNull();
             pressKey('down');
             expect(result.current.activeIndex).toBe(2);
         });
         it('should not activate the keypress handler when isFocused is false', () => {
-            renderHook(() => useSelectionList({ items, onSelect: mockOnSelect, isFocused: false }));
+            renderSelectionListHook({
+                items,
+                onSelect: mockOnSelect,
+                isFocused: false,
+            });
             expect(activeKeypressHandler).toBeNull();
             expect(() => pressKey('down')).toThrow(/keypress handler is not active/);
         });
         it('should not activate the keypress handler when items list is empty', () => {
-            renderHook(() => useSelectionList({
+            renderSelectionListHook({
                 items: [],
                 onSelect: mockOnSelect,
                 isFocused: true,
-            }));
+            });
             expect(activeKeypressHandler).toBeNull();
             expect(() => pressKey('down')).toThrow(/keypress handler is not active/);
         });
         it('should activate/deactivate when isFocused prop changes', () => {
-            const { result, rerender } = renderHook((props) => useSelectionList({ items, onSelect: mockOnSelect, ...props }), { initialProps: { isFocused: false } });
+            const { result, rerender } = renderSelectionListHook({
+                items,
+                onSelect: mockOnSelect,
+                isFocused: false,
+            });
             expect(activeKeypressHandler).toBeNull();
             rerender({ isFocused: true });
             expect(activeKeypressHandler).not.toBeNull();
@@ -320,18 +363,21 @@ describe('useSelectionList', () => {
         const longList = Array.from({ length: 15 }, (_, i) => ({ value: `Item ${i + 1}`, key: `Item ${i + 1}` }));
         const pressNumber = (num) => pressKey(num, num);
         it('should not respond to numbers if showNumbers is false (default)', () => {
-            const { result } = renderHook(() => useSelectionList({ items: shortList, onSelect: mockOnSelect }));
+            const { result } = renderSelectionListHook({
+                items: shortList,
+                onSelect: mockOnSelect,
+            });
             pressNumber('1');
             expect(result.current.activeIndex).toBe(0);
             expect(mockOnSelect).not.toHaveBeenCalled();
         });
         it('should select item immediately if the number cannot be extended (unambiguous)', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: shortList,
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
                 showNumbers: true,
-            }));
+            });
             pressNumber('3');
             expect(result.current.activeIndex).toBe(2);
             expect(mockOnHighlight).toHaveBeenCalledWith('C');
@@ -340,13 +386,13 @@ describe('useSelectionList', () => {
             expect(vi.getTimerCount()).toBe(0);
         });
         it('should highlight and wait for timeout if the number can be extended (ambiguous)', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: longList,
                 initialIndex: 1, // Start at index 1 so pressing "1" (index 0) causes a change
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
                 showNumbers: true,
-            }));
+            });
             pressNumber('1');
             expect(result.current.activeIndex).toBe(0);
             expect(mockOnHighlight).toHaveBeenCalledWith('Item 1');
@@ -359,11 +405,11 @@ describe('useSelectionList', () => {
             expect(mockOnSelect).toHaveBeenCalledWith('Item 1');
         });
         it('should handle multi-digit input correctly', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
-            }));
+            });
             pressNumber('1');
             expect(mockOnSelect).not.toHaveBeenCalled();
             pressNumber('2');
@@ -372,11 +418,11 @@ describe('useSelectionList', () => {
             expect(mockOnSelect).toHaveBeenCalledWith('Item 12');
         });
         it('should reset buffer if input becomes invalid (out of bounds)', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: shortList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
-            }));
+            });
             pressNumber('5');
             expect(result.current.activeIndex).toBe(0);
             expect(mockOnSelect).not.toHaveBeenCalled();
@@ -385,11 +431,11 @@ describe('useSelectionList', () => {
             expect(mockOnSelect).toHaveBeenCalledWith('C');
         });
         it('should allow "0" as subsequent digit, but ignore as first digit', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
-            }));
+            });
             pressNumber('0');
             expect(result.current.activeIndex).toBe(0);
             expect(mockOnSelect).not.toHaveBeenCalled();
@@ -402,11 +448,11 @@ describe('useSelectionList', () => {
             expect(mockOnSelect).toHaveBeenCalledWith('Item 10');
         });
         it('should clear the initial "0" input after timeout', () => {
-            renderHook(() => useSelectionList({
+            renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
-            }));
+            });
             pressNumber('0');
             act(() => vi.advanceTimersByTime(1000)); // Timeout the '0' input
             pressNumber('1');
@@ -415,12 +461,12 @@ describe('useSelectionList', () => {
             expect(mockOnSelect).toHaveBeenCalledWith('Item 1');
         });
         it('should highlight but not select a disabled item (immediate selection case)', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: shortList, // B (index 1, number 2) is disabled
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
                 showNumbers: true,
-            }));
+            });
             pressNumber('2');
             expect(result.current.activeIndex).toBe(1);
             expect(mockOnHighlight).toHaveBeenCalledWith('B');
@@ -433,11 +479,11 @@ describe('useSelectionList', () => {
                 { value: 'Item 1 Disabled', disabled: true, key: 'Item 1 Disabled' },
                 ...longList.slice(1),
             ];
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: disabledAmbiguousList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
-            }));
+            });
             pressNumber('1');
             expect(result.current.activeIndex).toBe(0);
             expect(vi.getTimerCount()).toBe(1);
@@ -448,11 +494,11 @@ describe('useSelectionList', () => {
             expect(mockOnSelect).not.toHaveBeenCalled();
         });
         it('should clear the number buffer if a non-numeric key (e.g., navigation) is pressed', () => {
-            const { result } = renderHook(() => useSelectionList({
+            const { result } = renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
-            }));
+            });
             pressNumber('1');
             expect(vi.getTimerCount()).toBe(1);
             pressKey('down');
@@ -463,11 +509,11 @@ describe('useSelectionList', () => {
             expect(result.current.activeIndex).toBe(2);
         });
         it('should clear the number buffer if "return" is pressed', () => {
-            renderHook(() => useSelectionList({
+            renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
-            }));
+            });
             pressNumber('1');
             pressKey('return');
             expect(mockOnSelect).toHaveBeenCalledTimes(1);
@@ -479,44 +525,50 @@ describe('useSelectionList', () => {
         });
     });
     describe('Reactivity (Dynamic Updates)', () => {
-        it('should update activeIndex when initialIndex prop changes', () => {
-            const { result, rerender } = renderHook(({ initialIndex }) => useSelectionList({
+        it('should update activeIndex when initialIndex prop changes', async () => {
+            const { result, rerender } = renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
-                initialIndex,
-            }), { initialProps: { initialIndex: 0 } });
+                initialIndex: 0,
+            });
             rerender({ initialIndex: 2 });
-            expect(result.current.activeIndex).toBe(2);
+            await vi.waitFor(() => {
+                expect(result.current.activeIndex).toBe(2);
+            });
         });
-        it('should respect a new initialIndex even after user interaction', () => {
-            const { result, rerender } = renderHook(({ initialIndex }) => useSelectionList({
+        it('should respect a new initialIndex even after user interaction', async () => {
+            const { result, rerender } = renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
-                initialIndex,
-            }), { initialProps: { initialIndex: 0 } });
+                initialIndex: 0,
+            });
             // User navigates, changing the active index
             pressKey('down');
             expect(result.current.activeIndex).toBe(2);
             // The component re-renders with a new initial index
             rerender({ initialIndex: 3 });
             // The hook should now respect the new initial index
-            expect(result.current.activeIndex).toBe(3);
+            await vi.waitFor(() => {
+                expect(result.current.activeIndex).toBe(3);
+            });
         });
-        it('should validate index when initialIndex prop changes to a disabled item', () => {
-            const { result, rerender } = renderHook(({ initialIndex }) => useSelectionList({
+        it('should validate index when initialIndex prop changes to a disabled item', async () => {
+            const { result, rerender } = renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
-                initialIndex,
-            }), { initialProps: { initialIndex: 0 } });
+                initialIndex: 0,
+            });
             rerender({ initialIndex: 1 });
-            expect(result.current.activeIndex).toBe(2);
+            await vi.waitFor(() => {
+                expect(result.current.activeIndex).toBe(2);
+            });
         });
-        it('should adjust activeIndex if items change and the initialIndex is now out of bounds', () => {
-            const { result, rerender } = renderHook(({ items: testItems }) => useSelectionList({
+        it('should adjust activeIndex if items change and the initialIndex is now out of bounds', async () => {
+            const { result, rerender } = renderSelectionListHook({
                 onSelect: mockOnSelect,
                 initialIndex: 3,
-                items: testItems,
-            }), { initialProps: { items } });
+                items,
+            });
             expect(result.current.activeIndex).toBe(3);
             const shorterItems = [
                 { value: 'X', key: 'X' },
@@ -524,19 +576,21 @@ describe('useSelectionList', () => {
             ];
             rerender({ items: shorterItems }); // Length 2
             // The useEffect syncs based on the initialIndex (3) which is now out of bounds. It defaults to 0.
-            expect(result.current.activeIndex).toBe(0);
+            await vi.waitFor(() => {
+                expect(result.current.activeIndex).toBe(0);
+            });
         });
-        it('should adjust activeIndex if items change and the initialIndex becomes disabled', () => {
+        it('should adjust activeIndex if items change and the initialIndex becomes disabled', async () => {
             const initialItems = [
                 { value: 'A', key: 'A' },
                 { value: 'B', key: 'B' },
                 { value: 'C', key: 'C' },
             ];
-            const { result, rerender } = renderHook(({ items: testItems }) => useSelectionList({
+            const { result, rerender } = renderSelectionListHook({
                 onSelect: mockOnSelect,
                 initialIndex: 1,
-                items: testItems,
-            }), { initialProps: { items: initialItems } });
+                items: initialItems,
+            });
             expect(result.current.activeIndex).toBe(1);
             const newItems = [
                 { value: 'A', key: 'A' },
@@ -544,30 +598,34 @@ describe('useSelectionList', () => {
                 { value: 'C', key: 'C' },
             ];
             rerender({ items: newItems });
-            expect(result.current.activeIndex).toBe(2);
+            await vi.waitFor(() => {
+                expect(result.current.activeIndex).toBe(2);
+            });
         });
-        it('should reset to 0 if items change to an empty list', () => {
-            const { result, rerender } = renderHook(({ items: testItems }) => useSelectionList({
+        it('should reset to 0 if items change to an empty list', async () => {
+            const { result, rerender } = renderSelectionListHook({
                 onSelect: mockOnSelect,
                 initialIndex: 2,
-                items: testItems,
-            }), { initialProps: { items } });
+                items,
+            });
             rerender({ items: [] });
-            expect(result.current.activeIndex).toBe(0);
+            await vi.waitFor(() => {
+                expect(result.current.activeIndex).toBe(0);
+            });
         });
-        it('should not reset activeIndex when items are deeply equal', () => {
+        it('should not reset activeIndex when items are deeply equal', async () => {
             const initialItems = [
                 { value: 'A', key: 'A' },
                 { value: 'B', disabled: true, key: 'B' },
                 { value: 'C', key: 'C' },
                 { value: 'D', key: 'D' },
             ];
-            const { result, rerender } = renderHook(({ items: testItems }) => useSelectionList({
+            const { result, rerender } = renderSelectionListHook({
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
                 initialIndex: 2,
-                items: testItems,
-            }), { initialProps: { items: initialItems } });
+                items: initialItems,
+            });
             expect(result.current.activeIndex).toBe(2);
             act(() => {
                 result.current.setActiveIndex(3);
@@ -583,23 +641,25 @@ describe('useSelectionList', () => {
             ];
             rerender({ items: newItems });
             // Active index should remain the same since items are deeply equal
-            expect(result.current.activeIndex).toBe(3);
+            await vi.waitFor(() => {
+                expect(result.current.activeIndex).toBe(3);
+            });
             // onHighlight should NOT be called since the index didn't change
             expect(mockOnHighlight).not.toHaveBeenCalled();
         });
-        it('should update activeIndex when items change structurally', () => {
+        it('should update activeIndex when items change structurally', async () => {
             const initialItems = [
                 { value: 'A', key: 'A' },
                 { value: 'B', disabled: true, key: 'B' },
                 { value: 'C', key: 'C' },
                 { value: 'D', key: 'D' },
             ];
-            const { result, rerender } = renderHook(({ items: testItems }) => useSelectionList({
+            const { result, rerender } = renderSelectionListHook({
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
                 initialIndex: 3,
-                items: testItems,
-            }), { initialProps: { items: initialItems } });
+                items: initialItems,
+            });
             expect(result.current.activeIndex).toBe(3);
             mockOnHighlight.mockClear();
             // Change item values (not deeply equal)
@@ -610,19 +670,21 @@ describe('useSelectionList', () => {
             ];
             rerender({ items: newItems });
             // Active index should update based on initialIndex and new items
-            expect(result.current.activeIndex).toBe(0);
+            await vi.waitFor(() => {
+                expect(result.current.activeIndex).toBe(0);
+            });
         });
-        it('should handle partial changes in items array', () => {
+        it('should handle partial changes in items array', async () => {
             const initialItems = [
                 { value: 'A', key: 'A' },
                 { value: 'B', key: 'B' },
                 { value: 'C', key: 'C' },
             ];
-            const { result, rerender } = renderHook(({ items: testItems }) => useSelectionList({
+            const { result, rerender } = renderSelectionListHook({
                 onSelect: mockOnSelect,
                 initialIndex: 1,
-                items: testItems,
-            }), { initialProps: { items: initialItems } });
+                items: initialItems,
+            });
             expect(result.current.activeIndex).toBe(1);
             // Change only one item's disabled status
             const newItems = [
@@ -632,18 +694,20 @@ describe('useSelectionList', () => {
             ];
             rerender({ items: newItems });
             // Should find next valid index since current became disabled
-            expect(result.current.activeIndex).toBe(2);
+            await vi.waitFor(() => {
+                expect(result.current.activeIndex).toBe(2);
+            });
         });
-        it('should update selection when a new item is added to the start of the list', () => {
+        it('should update selection when a new item is added to the start of the list', async () => {
             const initialItems = [
                 { value: 'A', key: 'A' },
                 { value: 'B', key: 'B' },
                 { value: 'C', key: 'C' },
             ];
-            const { result, rerender } = renderHook(({ items: testItems }) => useSelectionList({
+            const { result, rerender } = renderSelectionListHook({
                 onSelect: mockOnSelect,
-                items: testItems,
-            }), { initialProps: { items: initialItems } });
+                items: initialItems,
+            });
             pressKey('down');
             expect(result.current.activeIndex).toBe(1);
             const newItems = [
@@ -653,7 +717,9 @@ describe('useSelectionList', () => {
                 { value: 'C', key: 'C' },
             ];
             rerender({ items: newItems });
-            expect(result.current.activeIndex).toBe(2);
+            await vi.waitFor(() => {
+                expect(result.current.activeIndex).toBe(2);
+            });
         });
         it('should not re-initialize when items have identical keys but are different objects', () => {
             const initialItems = [
@@ -661,14 +727,22 @@ describe('useSelectionList', () => {
                 { value: 'B', key: 'B' },
             ];
             let renderCount = 0;
-            const { rerender } = renderHook(({ items: testItems }) => {
-                renderCount++;
-                return useSelectionList({
-                    onSelect: mockOnSelect,
-                    onHighlight: mockOnHighlight,
-                    items: testItems,
-                });
-            }, { initialProps: { items: initialItems } });
+            const renderHookWithCount = (initialProps) => {
+                function TestComponent(props) {
+                    renderCount++;
+                    useSelectionList({
+                        onSelect: mockOnSelect,
+                        onHighlight: mockOnHighlight,
+                        items: props.items,
+                    });
+                    return null;
+                }
+                const { rerender } = render(_jsx(TestComponent, { ...initialProps }));
+                return {
+                    rerender: (newProps) => rerender(_jsx(TestComponent, { ...initialProps, ...newProps })),
+                };
+            };
+            const { rerender } = renderHookWithCount({ items: initialItems });
             // Initial render
             expect(renderCount).toBe(1);
             // Create new items with the same keys but different object references
@@ -680,19 +754,6 @@ describe('useSelectionList', () => {
             expect(renderCount).toBe(2);
         });
     });
-    describe('Manual Control', () => {
-        it('should allow manual setting of active index via setActiveIndex', () => {
-            const { result } = renderHook(() => useSelectionList({ items, onSelect: mockOnSelect }));
-            act(() => {
-                result.current.setActiveIndex(3);
-            });
-            expect(result.current.activeIndex).toBe(3);
-            act(() => {
-                result.current.setActiveIndex(1);
-            });
-            expect(result.current.activeIndex).toBe(1);
-        });
-    });
     describe('Cleanup', () => {
         beforeEach(() => {
             vi.useFakeTimers();
@@ -702,11 +763,11 @@ describe('useSelectionList', () => {
         });
         it('should clear timeout on unmount when timer is active', () => {
             const longList = Array.from({ length: 15 }, (_, i) => ({ value: `Item ${i + 1}`, key: `Item ${i + 1}` }));
-            const { unmount } = renderHook(() => useSelectionList({
+            const { unmount } = renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
-            }));
+            });
             pressKey('1', '1');
             expect(vi.getTimerCount()).toBe(1);
             act(() => {