forked from sanbuphy/learn-coding-agent
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathuseArrowKeyHistory.tsx
More file actions
229 lines (214 loc) · 33.3 KB
/
useArrowKeyHistory.tsx
File metadata and controls
229 lines (214 loc) · 33.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
import React, { useCallback, useRef, useState } from 'react';
import { getModeFromInput } from 'src/components/PromptInput/inputModes.js';
import { useNotifications } from 'src/context/notifications.js';
import { ConfigurableShortcutHint } from '../components/ConfigurableShortcutHint.js';
import { FOOTER_TEMPORARY_STATUS_TIMEOUT } from '../components/PromptInput/Notifications.js';
import { getHistory } from '../history.js';
import { Text } from '../ink.js';
import type { PromptInputMode } from '../types/textInputTypes.js';
import type { HistoryEntry, PastedContent } from '../utils/config.js';
export type HistoryMode = PromptInputMode;
// Load history entries in chunks to reduce disk reads on rapid keypresses
const HISTORY_CHUNK_SIZE = 10;
// Shared state for batching concurrent load requests into a single disk read
// Mode filter is included to ensure we don't mix filtered and unfiltered caches
let pendingLoad: Promise<HistoryEntry[]> | null = null;
let pendingLoadTarget = 0;
let pendingLoadModeFilter: HistoryMode | undefined = undefined;
async function loadHistoryEntries(minCount: number, modeFilter?: HistoryMode): Promise<HistoryEntry[]> {
// Round up to next chunk to avoid repeated small reads
const target = Math.ceil(minCount / HISTORY_CHUNK_SIZE) * HISTORY_CHUNK_SIZE;
// If a load is already pending with the same mode filter and will satisfy our needs, wait for it
if (pendingLoad && pendingLoadTarget >= target && pendingLoadModeFilter === modeFilter) {
return pendingLoad;
}
// If a load is pending but won't satisfy our needs or has different filter, we need to wait for it
// to complete first, then start a new one (can't interrupt an ongoing read)
if (pendingLoad) {
await pendingLoad;
}
// Start a new load
pendingLoadTarget = target;
pendingLoadModeFilter = modeFilter;
pendingLoad = (async () => {
const entries: HistoryEntry[] = [];
let loaded = 0;
for await (const entry of getHistory()) {
// If mode filter is specified, only include entries that match the mode
if (modeFilter) {
const entryMode = getModeFromInput(entry.display);
if (entryMode !== modeFilter) {
continue;
}
}
entries.push(entry);
loaded++;
if (loaded >= pendingLoadTarget) break;
}
return entries;
})();
try {
return await pendingLoad;
} finally {
pendingLoad = null;
pendingLoadTarget = 0;
pendingLoadModeFilter = undefined;
}
}
export function useArrowKeyHistory(onSetInput: (value: string, mode: HistoryMode, pastedContents: Record<number, PastedContent>) => void, currentInput: string, pastedContents: Record<number, PastedContent>, setCursorOffset?: (offset: number) => void, currentMode?: HistoryMode): {
historyIndex: number;
setHistoryIndex: (index: number) => void;
onHistoryUp: () => void;
onHistoryDown: () => boolean;
resetHistory: () => void;
dismissSearchHint: () => void;
} {
const [historyIndex, setHistoryIndex] = useState(0);
const [lastShownHistoryEntry, setLastShownHistoryEntry] = useState<(HistoryEntry & {
mode?: HistoryMode;
}) | undefined>(undefined);
const hasShownSearchHintRef = useRef(false);
const {
addNotification,
removeNotification
} = useNotifications();
// Cache loaded history entries
const historyCache = useRef<HistoryEntry[]>([]);
// Track which mode filter the cache was loaded with
const historyCacheModeFilter = useRef<HistoryMode | undefined>(undefined);
// Synchronous tracker for history index to avoid stale closure issues
// React state updates are async, so rapid keypresses can see stale values
const historyIndexRef = useRef(0);
// Track the mode filter that was active when history navigation started
// This is set on the first arrow press and stays fixed until reset
const initialModeFilterRef = useRef<HistoryMode | undefined>(undefined);
// Refs to track current input values for draft preservation
// These ensure we capture the draft with the latest values, not stale closure values
const currentInputRef = useRef(currentInput);
const pastedContentsRef = useRef(pastedContents);
const currentModeRef = useRef(currentMode);
// Keep refs in sync with props (synchronous update on each render)
currentInputRef.current = currentInput;
pastedContentsRef.current = pastedContents;
currentModeRef.current = currentMode;
const setInputWithCursor = useCallback((value: string, mode: HistoryMode, contents: Record<number, PastedContent>, cursorToStart = false): void => {
onSetInput(value, mode, contents);
setCursorOffset?.(cursorToStart ? 0 : value.length);
}, [onSetInput, setCursorOffset]);
const updateInput = useCallback((input: HistoryEntry | undefined, cursorToStart_0 = false): void => {
if (!input || !input.display) return;
const mode_0 = getModeFromInput(input.display);
const value_0 = mode_0 === 'bash' ? input.display.slice(1) : input.display;
setInputWithCursor(value_0, mode_0, input.pastedContents ?? {}, cursorToStart_0);
}, [setInputWithCursor]);
const showSearchHint = useCallback((): void => {
addNotification({
key: 'search-history-hint',
jsx: <Text dimColor>
<ConfigurableShortcutHint action="history:search" context="Global" fallback="ctrl+r" description="search history" />
</Text>,
priority: 'immediate',
timeoutMs: FOOTER_TEMPORARY_STATUS_TIMEOUT
});
}, [addNotification]);
const onHistoryUp = useCallback((): void => {
// Capture and increment synchronously to handle rapid keypresses
const targetIndex = historyIndexRef.current;
historyIndexRef.current++;
const inputAtPress = currentInputRef.current;
const pastedContentsAtPress = pastedContentsRef.current;
const modeAtPress = currentModeRef.current;
if (targetIndex === 0) {
initialModeFilterRef.current = modeAtPress === 'bash' ? modeAtPress : undefined;
// Save draft synchronously using refs for the latest values
// This ensures we capture the draft before any async operations or re-renders
const hasInput = inputAtPress.trim() !== '';
setLastShownHistoryEntry(hasInput ? {
display: inputAtPress,
pastedContents: pastedContentsAtPress,
mode: modeAtPress
} : undefined);
}
const modeFilter = initialModeFilterRef.current;
void (async () => {
const neededCount = targetIndex + 1; // How many entries we need
// If mode filter changed, invalidate cache
if (historyCacheModeFilter.current !== modeFilter) {
historyCache.current = [];
historyCacheModeFilter.current = modeFilter;
historyIndexRef.current = 0;
}
// Load more entries if needed
if (historyCache.current.length < neededCount) {
// Batches concurrent requests - rapid keypresses share a single disk read
const entries = await loadHistoryEntries(neededCount, modeFilter);
// Only update cache if we loaded more than currently cached
// (handles race condition where multiple loads complete out of order)
if (entries.length > historyCache.current.length) {
historyCache.current = entries;
}
}
// Check if we can navigate
if (targetIndex >= historyCache.current.length) {
// Rollback the ref since we can't navigate
historyIndexRef.current--;
// Keep the draft intact - user stays on their current input
return;
}
const newIndex = targetIndex + 1;
setHistoryIndex(newIndex);
updateInput(historyCache.current[targetIndex], true);
// Show hint once per session after navigating through 2 history entries
if (newIndex >= 2 && !hasShownSearchHintRef.current) {
hasShownSearchHintRef.current = true;
showSearchHint();
}
})();
}, [updateInput, showSearchHint]);
const onHistoryDown = useCallback((): boolean => {
// Use the ref for consistent reads
const currentIndex = historyIndexRef.current;
if (currentIndex > 1) {
historyIndexRef.current--;
setHistoryIndex(currentIndex - 1);
updateInput(historyCache.current[currentIndex - 2]);
} else if (currentIndex === 1) {
historyIndexRef.current = 0;
setHistoryIndex(0);
if (lastShownHistoryEntry) {
// Restore the draft with its saved mode if available
const savedMode = lastShownHistoryEntry.mode;
if (savedMode) {
setInputWithCursor(lastShownHistoryEntry.display, savedMode, lastShownHistoryEntry.pastedContents ?? {});
} else {
updateInput(lastShownHistoryEntry);
}
} else {
// When in filtered mode, stay in that mode when clearing input
setInputWithCursor('', initialModeFilterRef.current ?? 'prompt', {});
}
}
return currentIndex <= 0;
}, [lastShownHistoryEntry, updateInput, setInputWithCursor]);
const resetHistory = useCallback((): void => {
setLastShownHistoryEntry(undefined);
setHistoryIndex(0);
historyIndexRef.current = 0;
initialModeFilterRef.current = undefined;
removeNotification('search-history-hint');
historyCache.current = [];
historyCacheModeFilter.current = undefined;
}, [removeNotification]);
const dismissSearchHint = useCallback((): void => {
removeNotification('search-history-hint');
}, [removeNotification]);
return {
historyIndex,
setHistoryIndex,
onHistoryUp,
onHistoryDown,
resetHistory,
dismissSearchHint
};
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useRef","useState","getModeFromInput","useNotifications","ConfigurableShortcutHint","FOOTER_TEMPORARY_STATUS_TIMEOUT","getHistory","Text","PromptInputMode","HistoryEntry","PastedContent","HistoryMode","HISTORY_CHUNK_SIZE","pendingLoad","Promise","pendingLoadTarget","pendingLoadModeFilter","undefined","loadHistoryEntries","minCount","modeFilter","target","Math","ceil","entries","loaded","entry","entryMode","display","push","useArrowKeyHistory","onSetInput","value","mode","pastedContents","Record","currentInput","setCursorOffset","offset","currentMode","historyIndex","setHistoryIndex","index","onHistoryUp","onHistoryDown","resetHistory","dismissSearchHint","lastShownHistoryEntry","setLastShownHistoryEntry","hasShownSearchHintRef","addNotification","removeNotification","historyCache","historyCacheModeFilter","historyIndexRef","initialModeFilterRef","currentInputRef","pastedContentsRef","currentModeRef","current","setInputWithCursor","contents","cursorToStart","length","updateInput","input","slice","showSearchHint","key","jsx","priority","timeoutMs","targetIndex","inputAtPress","pastedContentsAtPress","modeAtPress","hasInput","trim","neededCount","newIndex","currentIndex","savedMode"],"sources":["useArrowKeyHistory.tsx"],"sourcesContent":["import React, { useCallback, useRef, useState } from 'react'\nimport { getModeFromInput } from 'src/components/PromptInput/inputModes.js'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { ConfigurableShortcutHint } from '../components/ConfigurableShortcutHint.js'\nimport { FOOTER_TEMPORARY_STATUS_TIMEOUT } from '../components/PromptInput/Notifications.js'\nimport { getHistory } from '../history.js'\nimport { Text } from '../ink.js'\nimport type { PromptInputMode } from '../types/textInputTypes.js'\nimport type { HistoryEntry, PastedContent } from '../utils/config.js'\n\nexport type HistoryMode = PromptInputMode\n\n// Load history entries in chunks to reduce disk reads on rapid keypresses\nconst HISTORY_CHUNK_SIZE = 10\n\n// Shared state for batching concurrent load requests into a single disk read\n// Mode filter is included to ensure we don't mix filtered and unfiltered caches\nlet pendingLoad: Promise<HistoryEntry[]> | null = null\nlet pendingLoadTarget = 0\nlet pendingLoadModeFilter: HistoryMode | undefined = undefined\n\nasync function loadHistoryEntries(\n  minCount: number,\n  modeFilter?: HistoryMode,\n): Promise<HistoryEntry[]> {\n  // Round up to next chunk to avoid repeated small reads\n  const target = Math.ceil(minCount / HISTORY_CHUNK_SIZE) * HISTORY_CHUNK_SIZE\n\n  // If a load is already pending with the same mode filter and will satisfy our needs, wait for it\n  if (\n    pendingLoad &&\n    pendingLoadTarget >= target &&\n    pendingLoadModeFilter === modeFilter\n  ) {\n    return pendingLoad\n  }\n\n  // If a load is pending but won't satisfy our needs or has different filter, we need to wait for it\n  // to complete first, then start a new one (can't interrupt an ongoing read)\n  if (pendingLoad) {\n    await pendingLoad\n  }\n\n  // Start a new load\n  pendingLoadTarget = target\n  pendingLoadModeFilter = modeFilter\n  pendingLoad = (async () => {\n    const entries: HistoryEntry[] = []\n    let loaded = 0\n    for await (const entry of getHistory()) {\n      // If mode filter is specified, only include entries that match the mode\n      if (modeFilter) {\n        const entryMode = getModeFromInput(entry.display)\n        if (entryMode !== modeFilter) {\n          continue\n        }\n      }\n      entries.push(entry)\n      loaded++\n      if (loaded >= pendingLoadTarget) break\n    }\n    return entries\n  })()\n\n  try {\n    return await pendingLoad\n  } finally {\n    pendingLoad = null\n    pendingLoadTarget = 0\n    pendingLoadModeFilter = undefined\n  }\n}\n\nexport function useArrowKeyHistory(\n  onSetInput: (\n    value: string,\n    mode: HistoryMode,\n    pastedContents: Record<number, PastedContent>,\n  ) => void,\n  currentInput: string,\n  pastedContents: Record<number, PastedContent>,\n  setCursorOffset?: (offset: number) => void,\n  currentMode?: HistoryMode,\n): {\n  historyIndex: number\n  setHistoryIndex: (index: number) => void\n  onHistoryUp: () => void\n  onHistoryDown: () => boolean\n  resetHistory: () => void\n  dismissSearchHint: () => void\n} {\n  const [historyIndex, setHistoryIndex] = useState(0)\n  const [lastShownHistoryEntry, setLastShownHistoryEntry] = useState<\n    (HistoryEntry & { mode?: HistoryMode }) | undefined\n  >(undefined)\n  const hasShownSearchHintRef = useRef(false)\n  const { addNotification, removeNotification } = useNotifications()\n\n  // Cache loaded history entries\n  const historyCache = useRef<HistoryEntry[]>([])\n  // Track which mode filter the cache was loaded with\n  const historyCacheModeFilter = useRef<HistoryMode | undefined>(undefined)\n\n  // Synchronous tracker for history index to avoid stale closure issues\n  // React state updates are async, so rapid keypresses can see stale values\n  const historyIndexRef = useRef(0)\n\n  // Track the mode filter that was active when history navigation started\n  // This is set on the first arrow press and stays fixed until reset\n  const initialModeFilterRef = useRef<HistoryMode | undefined>(undefined)\n\n  // Refs to track current input values for draft preservation\n  // These ensure we capture the draft with the latest values, not stale closure values\n  const currentInputRef = useRef(currentInput)\n  const pastedContentsRef = useRef(pastedContents)\n  const currentModeRef = useRef(currentMode)\n\n  // Keep refs in sync with props (synchronous update on each render)\n  currentInputRef.current = currentInput\n  pastedContentsRef.current = pastedContents\n  currentModeRef.current = currentMode\n\n  const setInputWithCursor = useCallback(\n    (\n      value: string,\n      mode: HistoryMode,\n      contents: Record<number, PastedContent>,\n      cursorToStart = false,\n    ): void => {\n      onSetInput(value, mode, contents)\n      setCursorOffset?.(cursorToStart ? 0 : value.length)\n    },\n    [onSetInput, setCursorOffset],\n  )\n\n  const updateInput = useCallback(\n    (input: HistoryEntry | undefined, cursorToStart = false): void => {\n      if (!input || !input.display) return\n\n      const mode = getModeFromInput(input.display)\n      const value = mode === 'bash' ? input.display.slice(1) : input.display\n\n      setInputWithCursor(value, mode, input.pastedContents ?? {}, cursorToStart)\n    },\n    [setInputWithCursor],\n  )\n\n  const showSearchHint = useCallback((): void => {\n    addNotification({\n      key: 'search-history-hint',\n      jsx: (\n        <Text dimColor>\n          <ConfigurableShortcutHint\n            action=\"history:search\"\n            context=\"Global\"\n            fallback=\"ctrl+r\"\n            description=\"search history\"\n          />\n        </Text>\n      ),\n      priority: 'immediate',\n      timeoutMs: FOOTER_TEMPORARY_STATUS_TIMEOUT,\n    })\n  }, [addNotification])\n\n  const onHistoryUp = useCallback((): void => {\n    // Capture and increment synchronously to handle rapid keypresses\n    const targetIndex = historyIndexRef.current\n    historyIndexRef.current++\n\n    const inputAtPress = currentInputRef.current\n    const pastedContentsAtPress = pastedContentsRef.current\n    const modeAtPress = currentModeRef.current\n\n    if (targetIndex === 0) {\n      initialModeFilterRef.current =\n        modeAtPress === 'bash' ? modeAtPress : undefined\n\n      // Save draft synchronously using refs for the latest values\n      // This ensures we capture the draft before any async operations or re-renders\n      const hasInput = inputAtPress.trim() !== ''\n      setLastShownHistoryEntry(\n        hasInput\n          ? {\n              display: inputAtPress,\n              pastedContents: pastedContentsAtPress,\n              mode: modeAtPress,\n            }\n          : undefined,\n      )\n    }\n\n    const modeFilter = initialModeFilterRef.current\n\n    void (async () => {\n      const neededCount = targetIndex + 1 // How many entries we need\n\n      // If mode filter changed, invalidate cache\n      if (historyCacheModeFilter.current !== modeFilter) {\n        historyCache.current = []\n        historyCacheModeFilter.current = modeFilter\n        historyIndexRef.current = 0\n      }\n\n      // Load more entries if needed\n      if (historyCache.current.length < neededCount) {\n        // Batches concurrent requests - rapid keypresses share a single disk read\n        const entries = await loadHistoryEntries(neededCount, modeFilter)\n        // Only update cache if we loaded more than currently cached\n        // (handles race condition where multiple loads complete out of order)\n        if (entries.length > historyCache.current.length) {\n          historyCache.current = entries\n        }\n      }\n\n      // Check if we can navigate\n      if (targetIndex >= historyCache.current.length) {\n        // Rollback the ref since we can't navigate\n        historyIndexRef.current--\n        // Keep the draft intact - user stays on their current input\n        return\n      }\n\n      const newIndex = targetIndex + 1\n      setHistoryIndex(newIndex)\n      updateInput(historyCache.current[targetIndex], true)\n\n      // Show hint once per session after navigating through 2 history entries\n      if (newIndex >= 2 && !hasShownSearchHintRef.current) {\n        hasShownSearchHintRef.current = true\n        showSearchHint()\n      }\n    })()\n  }, [updateInput, showSearchHint])\n\n  const onHistoryDown = useCallback((): boolean => {\n    // Use the ref for consistent reads\n    const currentIndex = historyIndexRef.current\n    if (currentIndex > 1) {\n      historyIndexRef.current--\n      setHistoryIndex(currentIndex - 1)\n      updateInput(historyCache.current[currentIndex - 2])\n    } else if (currentIndex === 1) {\n      historyIndexRef.current = 0\n      setHistoryIndex(0)\n      if (lastShownHistoryEntry) {\n        // Restore the draft with its saved mode if available\n        const savedMode = lastShownHistoryEntry.mode\n        if (savedMode) {\n          setInputWithCursor(\n            lastShownHistoryEntry.display,\n            savedMode,\n            lastShownHistoryEntry.pastedContents ?? {},\n          )\n        } else {\n          updateInput(lastShownHistoryEntry)\n        }\n      } else {\n        // When in filtered mode, stay in that mode when clearing input\n        setInputWithCursor('', initialModeFilterRef.current ?? 'prompt', {})\n      }\n    }\n    return currentIndex <= 0\n  }, [lastShownHistoryEntry, updateInput, setInputWithCursor])\n\n  const resetHistory = useCallback((): void => {\n    setLastShownHistoryEntry(undefined)\n    setHistoryIndex(0)\n    historyIndexRef.current = 0\n    initialModeFilterRef.current = undefined\n    removeNotification('search-history-hint')\n    historyCache.current = []\n    historyCacheModeFilter.current = undefined\n  }, [removeNotification])\n\n  const dismissSearchHint = useCallback((): void => {\n    removeNotification('search-history-hint')\n  }, [removeNotification])\n\n  return {\n    historyIndex,\n    setHistoryIndex,\n    onHistoryUp,\n    onHistoryDown,\n    resetHistory,\n    dismissSearchHint,\n  }\n}\n"],"mappings":"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","ignoreList":[]}