wave-code 0.8.0 → 0.8.2

package/dist/hooks/useInputManager.js

@@ -1,223 +1,249 @@
-import { useEffect, useRef, useState, useCallback } from "react";
-import { InputManager, } from "../managers/InputManager.js";
-import { logger } from "../utils/logger.js";
+import { useEffect, useReducer, useCallback, useRef } from "react";
+import { inputReducer, initialState, } from "../managers/inputReducer.js";
+import { searchFiles as searchFilesUtil } from "wave-agent-sdk";
+import * as handlers from "../managers/inputHandlers.js";
 export const useInputManager = (callbacks = {}) => {
-    const managerRef = useRef(null);
-    const [isManagerReady, setIsManagerReady] = useState(false);
-    // React state that mirrors InputManager state
-    const [inputText, setInputText] = useState("");
-    const [cursorPosition, setCursorPosition] = useState(0);
-    const [fileSelectorState, setFileSelectorState] = useState({
-        show: false,
-        files: [],
-        query: "",
-        position: -1,
-    });
-    const [commandSelectorState, setCommandSelectorState] = useState({
-        show: false,
-        query: "",
-        position: -1,
-    });
-    const [historySearchState, setHistorySearchState] = useState({
-        show: false,
-        query: "",
-    });
-    const [showBackgroundTaskManager, setShowBackgroundTaskManager] = useState(false);
-    const [showMcpManager, setShowMcpManager] = useState(false);
-    const [showRewindManager, setShowRewindManager] = useState(false);
-    const [showHelp, setShowHelp] = useState(false);
-    const [showStatusCommand, setShowStatusCommand] = useState(false);
-    const [permissionMode, setPermissionModeState] = useState("default");
-    const [attachedImages, setAttachedImages] = useState([]);
-    // Create InputManager on mount and update callbacks when they change
+    const [state, dispatch] = useReducer(inputReducer, initialState);
+    const callbacksRef = useRef(callbacks);
+    const stateRef = useRef(state);
+    // Update refs when they change
     useEffect(() => {
-        if (!managerRef.current) {
-            // Create InputManager on first mount
-            const manager = new InputManager({
-                logger,
-                onInputTextChange: setInputText,
-                onCursorPositionChange: setCursorPosition,
-                onFileSelectorStateChange: (show, files, query, position) => {
-                    setFileSelectorState({ show, files, query, position });
-                },
-                onCommandSelectorStateChange: (show, query, position) => {
-                    setCommandSelectorState({ show, query, position });
-                },
-                onHistorySearchStateChange: (show, query) => {
-                    setHistorySearchState({ show, query });
-                },
-                onBackgroundTaskManagerStateChange: (show) => {
-                    setShowBackgroundTaskManager(show);
-                },
-                onMcpManagerStateChange: (show) => {
-                    setShowMcpManager(show);
-                },
-                onRewindManagerStateChange: (show) => {
-                    setShowRewindManager(show);
-                },
-                onHelpStateChange: (show) => {
-                    setShowHelp(show);
-                },
-                onStatusCommandStateChange: (show) => {
-                    setShowStatusCommand(show);
-                },
-                onPermissionModeChange: (mode) => {
-                    setPermissionModeState(mode);
-                    callbacks.onPermissionModeChange?.(mode);
-                },
-                onImagesStateChange: setAttachedImages,
-                ...callbacks,
-            });
-            managerRef.current = manager;
-            setIsManagerReady(true);
+        callbacksRef.current = callbacks;
+    }, [callbacks]);
+    useEffect(() => {
+        stateRef.current = state;
+    }, [state]);
+    // Handle selectorJustUsed reset
+    useEffect(() => {
+        if (state.selectorJustUsed) {
+            const timer = setTimeout(() => {
+                dispatch({ type: "SET_SELECTOR_JUST_USED", payload: false });
+            }, 0);
+            return () => clearTimeout(timer);
         }
-        else {
-            // Update callbacks on existing manager
-            managerRef.current.updateCallbacks({
-                logger,
-                onInputTextChange: setInputText,
-                onCursorPositionChange: setCursorPosition,
-                onFileSelectorStateChange: (show, files, query, position) => {
-                    setFileSelectorState({ show, files, query, position });
-                },
-                onCommandSelectorStateChange: (show, query, position) => {
-                    setCommandSelectorState({ show, query, position });
-                },
-                onHistorySearchStateChange: (show, query) => {
-                    setHistorySearchState({ show, query });
-                },
-                onBackgroundTaskManagerStateChange: (show) => {
-                    setShowBackgroundTaskManager(show);
-                },
-                onMcpManagerStateChange: (show) => {
-                    setShowMcpManager(show);
-                },
-                onRewindManagerStateChange: (show) => {
-                    setShowRewindManager(show);
-                },
-                onHelpStateChange: (show) => {
-                    setShowHelp(show);
-                },
-                onStatusCommandStateChange: (show) => {
-                    setShowStatusCommand(show);
-                },
-                onPermissionModeChange: (mode) => {
-                    setPermissionModeState(mode);
-                    callbacks.onPermissionModeChange?.(mode);
-                },
-                onImagesStateChange: setAttachedImages,
-                ...callbacks,
-            });
+    }, [state.selectorJustUsed]);
+    // Handle debounced file search
+    useEffect(() => {
+        if (state.showFileSelector) {
+            const debounceDelay = parseInt(process.env.FILE_SELECTOR_DEBOUNCE_MS || "300", 10);
+            const timer = setTimeout(async () => {
+                try {
+                    const fileItems = await searchFilesUtil(state.fileSearchQuery);
+                    dispatch({ type: "SET_FILTERED_FILES", payload: fileItems });
+                }
+                catch (error) {
+                    console.error("File search error:", error);
+                    dispatch({ type: "SET_FILTERED_FILES", payload: [] });
+                }
+            }, debounceDelay);
+            return () => clearTimeout(timer);
         }
-    }, [callbacks]);
-    // Cleanup on unmount
+    }, [state.showFileSelector, state.fileSearchQuery]);
+    // Handle paste debouncing
     useEffect(() => {
-        return () => {
-            if (managerRef.current) {
-                managerRef.current.destroy();
-            }
-        };
-    }, []);
-    // Expose manager methods
-    const insertTextAtCursor = useCallback((text, callback) => {
-        managerRef.current?.insertTextAtCursor(text, callback);
+        if (state.isPasting) {
+            const pasteDebounceDelay = parseInt(process.env.PASTE_DEBOUNCE_MS || "30", 10);
+            const timer = setTimeout(() => {
+                const processedInput = stateRef.current.pasteBuffer.replace(/\r/g, "\n");
+                dispatch({ type: "COMPRESS_AND_INSERT_TEXT", payload: processedInput });
+                dispatch({ type: "END_PASTE" });
+                callbacksRef.current.onResetHistoryNavigation?.();
+            }, pasteDebounceDelay);
+            return () => clearTimeout(timer);
+        }
+    }, [state.isPasting, state.pasteBuffer]);
+    // Sync state changes with callbacks
+    useEffect(() => {
+        callbacksRef.current.onInputTextChange?.(state.inputText);
+    }, [state.inputText]);
+    useEffect(() => {
+        callbacksRef.current.onCursorPositionChange?.(state.cursorPosition);
+    }, [state.cursorPosition]);
+    useEffect(() => {
+        callbacksRef.current.onFileSelectorStateChange?.(state.showFileSelector, state.filteredFiles, state.fileSearchQuery, state.atPosition);
+    }, [
+        state.showFileSelector,
+        state.filteredFiles,
+        state.fileSearchQuery,
+        state.atPosition,
+    ]);
+    useEffect(() => {
+        callbacksRef.current.onCommandSelectorStateChange?.(state.showCommandSelector, state.commandSearchQuery, state.slashPosition);
+    }, [
+        state.showCommandSelector,
+        state.commandSearchQuery,
+        state.slashPosition,
+    ]);
+    useEffect(() => {
+        callbacksRef.current.onHistorySearchStateChange?.(state.showHistorySearch, state.historySearchQuery);
+    }, [state.showHistorySearch, state.historySearchQuery]);
+    useEffect(() => {
+        callbacksRef.current.onBackgroundTaskManagerStateChange?.(state.showBackgroundTaskManager);
+    }, [state.showBackgroundTaskManager]);
+    useEffect(() => {
+        callbacksRef.current.onMcpManagerStateChange?.(state.showMcpManager);
+    }, [state.showMcpManager]);
+    useEffect(() => {
+        callbacksRef.current.onRewindManagerStateChange?.(state.showRewindManager);
+    }, [state.showRewindManager]);
+    useEffect(() => {
+        callbacksRef.current.onHelpStateChange?.(state.showHelp);
+    }, [state.showHelp]);
+    useEffect(() => {
+        callbacksRef.current.onStatusCommandStateChange?.(state.showStatusCommand);
+    }, [state.showStatusCommand]);
+    useEffect(() => {
+        callbacksRef.current.onImagesStateChange?.(state.attachedImages);
+    }, [state.attachedImages]);
+    // Methods
+    const insertTextAtCursor = useCallback((text) => {
+        dispatch({ type: "INSERT_TEXT", payload: text });
     }, []);
-    const deleteCharAtCursor = useCallback((callback) => {
-        managerRef.current?.deleteCharAtCursor(callback);
+    const deleteCharAtCursor = useCallback(() => {
+        dispatch({ type: "DELETE_CHAR" });
     }, []);
     const clearInput = useCallback(() => {
-        managerRef.current?.clearInput();
+        dispatch({ type: "CLEAR_INPUT" });
     }, []);
     const moveCursorLeft = useCallback(() => {
-        managerRef.current?.moveCursorLeft();
+        dispatch({ type: "MOVE_CURSOR", payload: -1 });
     }, []);
     const moveCursorRight = useCallback(() => {
-        managerRef.current?.moveCursorRight();
+        dispatch({ type: "MOVE_CURSOR", payload: 1 });
     }, []);
-    // File selector methods
     const activateFileSelector = useCallback((position) => {
-        managerRef.current?.activateFileSelector(position);
+        dispatch({ type: "ACTIVATE_FILE_SELECTOR", payload: position });
     }, []);
     const handleFileSelect = useCallback((filePath) => {
-        return (managerRef.current?.handleFileSelect(filePath) || {
-            newInput: inputText,
-            newCursorPosition: cursorPosition,
-        });
-    }, [inputText, cursorPosition]);
+        return handlers.handleFileSelect(stateRef.current, dispatch, callbacksRef.current, filePath);
+    }, []);
     const handleCancelFileSelect = useCallback(() => {
-        managerRef.current?.handleCancelFileSelect();
+        dispatch({ type: "CANCEL_FILE_SELECTOR" });
     }, []);
     const updateFileSearchQuery = useCallback((query) => {
-        managerRef.current?.updateFileSearchQuery(query);
+        dispatch({ type: "SET_FILE_SEARCH_QUERY", payload: query });
     }, []);
     const checkForAtDeletion = useCallback((cursorPos) => {
-        return managerRef.current?.checkForAtDeletion(cursorPos) || false;
+        return handlers.checkForAtDeletion(stateRef.current, dispatch, cursorPos);
     }, []);
-    // Command selector methods
     const activateCommandSelector = useCallback((position) => {
-        managerRef.current?.activateCommandSelector(position);
+        dispatch({ type: "ACTIVATE_COMMAND_SELECTOR", payload: position });
     }, []);
     const handleCommandSelect = useCallback((command) => {
-        return (managerRef.current?.handleCommandSelect(command) || {
-            newInput: inputText,
-            newCursorPosition: cursorPosition,
-        });
-    }, [inputText, cursorPosition]);
+        return handlers.handleCommandSelect(stateRef.current, dispatch, callbacksRef.current, command);
+    }, []);
     const handleCommandInsert = useCallback((command) => {
-        return (managerRef.current?.handleCommandInsert(command) || {
-            newInput: inputText,
-            newCursorPosition: cursorPosition,
-        });
-    }, [inputText, cursorPosition]);
+        const currentState = stateRef.current;
+        if (currentState.slashPosition >= 0) {
+            const beforeSlash = currentState.inputText.substring(0, currentState.slashPosition);
+            const afterQuery = currentState.inputText.substring(currentState.cursorPosition);
+            const newInput = beforeSlash + `/${command} ` + afterQuery;
+            const newCursorPosition = beforeSlash.length + command.length + 2;
+            dispatch({ type: "SET_INPUT_TEXT", payload: newInput });
+            dispatch({ type: "SET_CURSOR_POSITION", payload: newCursorPosition });
+            dispatch({ type: "CANCEL_COMMAND_SELECTOR" });
+            callbacksRef.current.onInputTextChange?.(newInput);
+            callbacksRef.current.onCursorPositionChange?.(newCursorPosition);
+            return { newInput, newCursorPosition };
+        }
+        return {
+            newInput: currentState.inputText,
+            newCursorPosition: currentState.cursorPosition,
+        };
+    }, []);
     const handleCancelCommandSelect = useCallback(() => {
-        managerRef.current?.handleCancelCommandSelect();
+        dispatch({ type: "CANCEL_COMMAND_SELECTOR" });
     }, []);
     const updateCommandSearchQuery = useCallback((query) => {
-        managerRef.current?.updateCommandSearchQuery(query);
+        dispatch({ type: "SET_COMMAND_SEARCH_QUERY", payload: query });
     }, []);
     const checkForSlashDeletion = useCallback((cursorPos) => {
-        return managerRef.current?.checkForSlashDeletion(cursorPos) || false;
+        return handlers.checkForSlashDeletion(stateRef.current, dispatch, cursorPos);
     }, []);
-    // History search methods
     const handleHistorySearchSelect = useCallback((prompt) => {
-        managerRef.current?.handleHistorySearchSelect(prompt);
+        dispatch({ type: "SET_INPUT_TEXT", payload: prompt });
+        dispatch({ type: "SET_CURSOR_POSITION", payload: prompt.length });
+        dispatch({ type: "CANCEL_HISTORY_SEARCH" });
     }, []);
     const handleCancelHistorySearch = useCallback(() => {
-        managerRef.current?.handleCancelHistorySearch();
+        dispatch({ type: "CANCEL_HISTORY_SEARCH" });
     }, []);
-    // Special character handling
     const handleSpecialCharInput = useCallback((char) => {
-        managerRef.current?.handleSpecialCharInput(char);
+        handlers.handleSpecialCharInput(stateRef.current, dispatch, char, stateRef.current.cursorPosition, stateRef.current.inputText);
+    }, []);
+    const setInputText = useCallback((text) => {
+        dispatch({ type: "SET_INPUT_TEXT", payload: text });
+    }, []);
+    const setCursorPosition = useCallback((position) => {
+        dispatch({ type: "SET_CURSOR_POSITION", payload: position });
+    }, []);
+    const setShowBackgroundTaskManager = useCallback((show) => {
+        dispatch({ type: "SET_SHOW_BACKGROUND_TASK_MANAGER", payload: show });
+    }, []);
+    const setShowMcpManager = useCallback((show) => {
+        dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: show });
+    }, []);
+    const setShowRewindManager = useCallback((show) => {
+        dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: show });
+    }, []);
+    const setShowHelp = useCallback((show) => {
+        dispatch({ type: "SET_SHOW_HELP", payload: show });
+    }, []);
+    const setShowStatusCommand = useCallback((show) => {
+        dispatch({ type: "SET_SHOW_STATUS_COMMAND", payload: show });
+    }, []);
+    const setPermissionMode = useCallback((mode) => {
+        dispatch({ type: "SET_PERMISSION_MODE", payload: mode });
+        callbacksRef.current.onPermissionModeChange?.(mode);
+    }, []);
+    const addImage = useCallback((imagePath, mimeType) => {
+        dispatch({ type: "ADD_IMAGE", payload: { path: imagePath, mimeType } });
+    }, []);
+    const removeImage = useCallback((imageId) => {
+        dispatch({ type: "REMOVE_IMAGE", payload: imageId });
+    }, []);
+    const clearImages = useCallback(() => {
+        dispatch({ type: "CLEAR_IMAGES" });
+    }, []);
+    const handlePasteImage = useCallback(async () => {
+        return await handlers.handlePasteImage(dispatch);
+    }, []);
+    const handlePasteInput = useCallback((input) => {
+        handlers.handlePasteInput(stateRef.current, dispatch, callbacksRef.current, input);
+    }, []);
+    const handleSubmit = useCallback(async (attachedImages, isLoading = false, isCommandRunning = false) => {
+        await handlers.handleSubmit(stateRef.current, dispatch, callbacksRef.current, isLoading, isCommandRunning, attachedImages);
+    }, []);
+    const expandLongTextPlaceholders = useCallback((text) => {
+        return handlers.expandLongTextPlaceholders(text, stateRef.current.longTextMap);
     }, []);
-    // Direct state access methods (for compatibility with existing code)
-    const setInputTextDirect = useCallback((text) => {
-        managerRef.current?.setInputText(text);
+    const clearLongTextMap = useCallback(() => {
+        dispatch({ type: "CLEAR_LONG_TEXT_MAP" });
     }, []);
-    const setCursorPositionDirect = useCallback((position) => {
-        managerRef.current?.setCursorPosition(position);
+    const handleInput = useCallback(async (input, key, attachedImages, isLoading = false, isCommandRunning = false, clearImages) => {
+        return await handlers.handleInput(stateRef.current, dispatch, callbacksRef.current, input, key, isLoading, isCommandRunning, clearImages);
     }, []);
-    // Complex handlers that combine multiple operations
     return {
         // State
-        inputText,
-        cursorPosition,
-        showFileSelector: fileSelectorState.show,
-        filteredFiles: fileSelectorState.files,
-        fileSearchQuery: fileSelectorState.query,
-        atPosition: fileSelectorState.position,
-        showCommandSelector: commandSelectorState.show,
-        commandSearchQuery: commandSelectorState.query,
-        slashPosition: commandSelectorState.position,
-        showHistorySearch: historySearchState.show,
-        historySearchQuery: historySearchState.query,
-        showBackgroundTaskManager,
-        showMcpManager,
-        showRewindManager,
-        showHelp,
-        showStatusCommand,
-        permissionMode,
-        attachedImages,
-        isManagerReady,
+        inputText: state.inputText,
+        cursorPosition: state.cursorPosition,
+        showFileSelector: state.showFileSelector,
+        filteredFiles: state.filteredFiles,
+        fileSearchQuery: state.fileSearchQuery,
+        atPosition: state.atPosition,
+        showCommandSelector: state.showCommandSelector,
+        commandSearchQuery: state.commandSearchQuery,
+        slashPosition: state.slashPosition,
+        showHistorySearch: state.showHistorySearch,
+        historySearchQuery: state.historySearchQuery,
+        showBackgroundTaskManager: state.showBackgroundTaskManager,
+        showMcpManager: state.showMcpManager,
+        showRewindManager: state.showRewindManager,
+        showHelp: state.showHelp,
+        showStatusCommand: state.showStatusCommand,
+        permissionMode: state.permissionMode,
+        attachedImages: state.attachedImages,
+        isManagerReady: true,
         // Methods
         insertTextAtCursor,
         deleteCharAtCursor,
@@ -243,62 +269,28 @@ export const useInputManager = (callbacks = {}) => {
         // Special handling
         handleSpecialCharInput,
         // Bash/MCP Manager
-        setShowBackgroundTaskManager: useCallback((show) => {
-            managerRef.current?.setShowBackgroundTaskManager(show);
-        }, []),
-        setShowMcpManager: useCallback((show) => {
-            managerRef.current?.setShowMcpManager(show);
-        }, []),
-        setShowRewindManager: useCallback((show) => {
-            managerRef.current?.setShowRewindManager(show);
-            setShowRewindManager(show);
-        }, []),
-        setShowHelp: useCallback((show) => {
-            managerRef.current?.setShowHelp(show);
-            setShowHelp(show);
-        }, []),
-        setShowStatusCommand: useCallback((show) => {
-            managerRef.current?.setShowStatusCommand(show);
-            setShowStatusCommand(show);
-        }, []),
-        setPermissionMode: useCallback((mode) => {
-            setPermissionModeState(mode);
-            managerRef.current?.setPermissionMode(mode);
-        }, []),
+        setShowBackgroundTaskManager,
+        setShowMcpManager,
+        setShowRewindManager,
+        setShowHelp,
+        setShowStatusCommand,
+        setPermissionMode,
         // Image management
-        addImage: useCallback((imagePath, mimeType) => {
-            return managerRef.current?.addImage(imagePath, mimeType);
-        }, []),
-        removeImage: useCallback((imageId) => {
-            managerRef.current?.removeImage(imageId);
-        }, []),
-        clearImages: useCallback(() => {
-            managerRef.current?.clearImages();
-        }, []),
-        handlePasteImage: useCallback(async () => {
-            return (await managerRef.current?.handlePasteImage()) || false;
-        }, []),
+        addImage,
+        removeImage,
+        clearImages,
+        handlePasteImage,
         // Paste and text handling
-        handlePasteInput: useCallback((input) => {
-            managerRef.current?.handlePasteInput(input);
-        }, []),
-        handleSubmit: useCallback(async (attachedImages, isLoading = false, isCommandRunning = false) => {
-            await managerRef.current?.handleSubmit(attachedImages, isLoading, isCommandRunning);
-        }, []),
-        expandLongTextPlaceholders: useCallback((text) => {
-            return managerRef.current?.expandLongTextPlaceholders(text) || text;
-        }, []),
-        clearLongTextMap: useCallback(() => {
-            managerRef.current?.clearLongTextMap();
-        }, []),
+        handlePasteInput,
+        handleSubmit,
+        expandLongTextPlaceholders,
+        clearLongTextMap,
         // Main input handler
-        handleInput: useCallback(async (input, key, attachedImages, isLoading = false, isCommandRunning = false, clearImages) => {
-            return ((await managerRef.current?.handleInput(input, key, attachedImages, isLoading, isCommandRunning, clearImages)) || false);
-        }, []),
-        // Direct state setters (for React compatibility)
-        setInputText: setInputTextDirect,
-        setCursorPosition: setCursorPositionDirect,
-        // Manager reference for advanced usage
-        manager: managerRef.current,
+        handleInput,
+        // Direct state setters
+        setInputText,
+        setCursorPosition,
+        // Manager reference (for compatibility, though it's null now)
+        manager: null,
     };
 };

package/dist/managers/inputHandlers.d.ts

@@ -0,0 +1,28 @@
+import { Key } from "ink";
+import { PermissionMode } from "wave-agent-sdk";
+import { InputState, InputAction, InputManagerCallbacks } from "./inputReducer.js";
+export declare const expandLongTextPlaceholders: (text: string, longTextMap: Record<string, string>) => string;
+export declare const handleSubmit: (state: InputState, dispatch: React.Dispatch<InputAction>, callbacks: Partial<InputManagerCallbacks>, isLoading?: boolean, isCommandRunning?: boolean, attachedImagesOverride?: Array<{
+    id: number;
+    path: string;
+    mimeType: string;
+}>) => Promise<void>;
+export declare const handlePasteImage: (dispatch: React.Dispatch<InputAction>) => Promise<boolean>;
+export declare const cyclePermissionMode: (currentMode: PermissionMode, dispatch: React.Dispatch<InputAction>, callbacks: Partial<InputManagerCallbacks>) => void;
+export declare const updateSearchQueriesForActiveSelectors: (state: InputState, dispatch: React.Dispatch<InputAction>, inputText: string, cursorPosition: number) => void;
+export declare const handleSpecialCharInput: (state: InputState, dispatch: React.Dispatch<InputAction>, char: string, cursorPosition: number, inputText: string) => void;
+export declare const handlePasteInput: (state: InputState, dispatch: React.Dispatch<InputAction>, callbacks: Partial<InputManagerCallbacks>, input: string) => void;
+export declare const handleCommandSelect: (state: InputState, dispatch: React.Dispatch<InputAction>, callbacks: Partial<InputManagerCallbacks>, command: string) => {
+    newInput: string;
+    newCursorPosition: number;
+};
+export declare const handleFileSelect: (state: InputState, dispatch: React.Dispatch<InputAction>, callbacks: Partial<InputManagerCallbacks>, filePath: string) => {
+    newInput: string;
+    newCursorPosition: number;
+};
+export declare const checkForAtDeletion: (state: InputState, dispatch: React.Dispatch<InputAction>, cursorPosition: number) => boolean;
+export declare const checkForSlashDeletion: (state: InputState, dispatch: React.Dispatch<InputAction>, cursorPosition: number) => boolean;
+export declare const handleSelectorInput: (state: InputState, dispatch: React.Dispatch<InputAction>, callbacks: Partial<InputManagerCallbacks>, input: string, key: Key) => boolean;
+export declare const handleNormalInput: (state: InputState, dispatch: React.Dispatch<InputAction>, callbacks: Partial<InputManagerCallbacks>, input: string, key: Key, isLoading?: boolean, isCommandRunning?: boolean, clearImages?: () => void) => Promise<boolean>;
+export declare const handleInput: (state: InputState, dispatch: React.Dispatch<InputAction>, callbacks: Partial<InputManagerCallbacks>, input: string, key: Key, isLoading?: boolean, isCommandRunning?: boolean, clearImages?: () => void) => Promise<boolean>;
+//# sourceMappingURL=inputHandlers.d.ts.map

package/dist/managers/inputHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputHandlers.d.ts","sourceRoot":"","sources":["../../src/managers/inputHandlers.ts"],"names":[],"mappings":"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"}