@tecet/ollm 0.1.3

package/dist/ui/components/file-explorer/FileTreeView.js

@@ -0,0 +1,686 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * FileTreeView - Terminal UI component for file tree rendering
+ *
+ * Renders the file tree with virtual scrolling, Nerd Font icons, git status
+ * colors, and focus indicators. Supports keyboard navigation and file focusing.
+ *
+ * Requirements: 2.1, 2.6, 2.7, 3.1, 3.4
+ */
+import { readFile } from 'fs/promises';
+import React, { useEffect, useRef, useCallback, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { ConfirmationDialog } from './ConfirmationDialog.js';
+import { useFileFocus } from './FileFocusContext.js';
+import { FileSearchDialog } from './FileSearchDialog.js';
+import { useFileTree } from './FileTreeContext.js';
+import { HelpPanel } from './HelpPanel.js';
+import { LoadingIndicator } from './LoadingIndicator.js';
+import { QuickActionsMenu } from './QuickActionsMenu.js';
+import { QuickOpenDialog } from './QuickOpenDialog.js';
+import { useFocusManager } from '../../../features/context/FocusContext.js';
+import { useKeybinds } from '../../../features/context/KeybindsContext.js';
+import { useUI } from '../../../features/context/UIContext.js';
+import { isKey } from '../../utils/keyUtils.js';
+/**
+ * Nerd Font icons for file types
+ */
+const ICONS = {
+    // Directory icons
+    directoryExpanded: '📂',
+    directoryCollapsed: '📁',
+    // File type icons
+    file: '📄',
+    typescript: '📘',
+    javascript: '📜',
+    json: '⚙️',
+    markdown: '📝',
+    yaml: '🛠️',
+    image: '🖼️',
+    text: '📄',
+    code: '💻',
+    // Status icons
+    focusIndicator: '📌', // Pin emoji for focused files
+};
+/**
+ * Get icon for a file node based on its type and name
+ */
+function getNodeIcon(node) {
+    if (node.type === 'directory') {
+        return node.expanded ? ICONS.directoryExpanded : ICONS.directoryCollapsed;
+    }
+    // File type detection based on extension
+    const ext = node.name.split('.').pop()?.toLowerCase();
+    switch (ext) {
+        case 'ts':
+        case 'tsx':
+            return ICONS.typescript;
+        case 'js':
+        case 'jsx':
+            return ICONS.javascript;
+        case 'json':
+            return ICONS.json;
+        case 'md':
+        case 'markdown':
+            return ICONS.markdown;
+        case 'yml':
+        case 'yaml':
+            return ICONS.yaml;
+        case 'png':
+        case 'jpg':
+        case 'jpeg':
+        case 'gif':
+        case 'webp':
+        case 'svg':
+            return ICONS.image;
+        case 'txt':
+        case 'log':
+            return ICONS.text;
+        case 'py':
+        case 'java':
+        case 'cpp':
+        case 'c':
+        case 'go':
+        case 'rs':
+        case 'rb':
+        case 'php':
+            return ICONS.code;
+        default:
+            return ICONS.file;
+    }
+}
+/**
+ * Get color for git status
+ */
+function getGitStatusColor(status) {
+    switch (status) {
+        case 'untracked':
+            return 'green';
+        case 'modified':
+            return 'yellow';
+        case 'ignored':
+            return 'gray';
+        case 'clean':
+        default:
+            return undefined; // Use default color
+    }
+}
+/**
+ * Calculate indentation level for a node
+ */
+function calculateIndentation(node, rootPath) {
+    if (!rootPath || !node.path)
+        return 0;
+    const relativePath = node.path.replace(rootPath, '');
+    // Split by forward or backward slash to handle both Unix and Windows paths
+    const depth = relativePath.split(/[/\\]/).filter((p) => p.length > 0).length;
+    return Math.max(0, depth - 1); // Root is at depth 0
+}
+/**
+ * FileTreeView component
+ *
+ * Renders the file tree with virtual scrolling, showing only the visible
+ * window of nodes. Displays icons, git status colors, and focus indicators.
+ * Supports keyboard navigation with debouncing and file focusing.
+ */
+export function FileTreeView({ fileTreeService, focusSystem, editorIntegration, fileOperations, followModeService, toolRegistry, rootPath = process.cwd(), excludePatterns = [], hasFocus = true, }) {
+    const { state: treeState, setVisibleWindow, setCursorPosition, setScrollOffset: _setScrollOffset, expandDirectory, collapseDirectory, getSelectedNode, toggleFollowMode, expandToPath, } = useFileTree();
+    const { isFocused, addFocusedFile, removeFocusedFile } = useFileFocus();
+    const { activeKeybinds } = useKeybinds();
+    const focusManager = useFocusManager();
+    const { openFileViewer, closeFileViewer } = useUI();
+    // Status message state for user feedback
+    const [statusMessage, setStatusMessage] = useState('');
+    const statusTimerRef = useRef(null);
+    // Help panel state
+    const [helpPanelOpen, setHelpPanelOpen] = useState(false);
+    // Loading state for long operations
+    const [isLoading, setIsLoading] = useState(false);
+    const [loadingMessage, setLoadingMessage] = useState('Loading...');
+    // Quick actions menu state
+    const [menuOpen, setMenuOpen] = useState(false);
+    // Quick Open dialog state
+    const [quickOpenState, setQuickOpenState] = useState(false);
+    const [quickOpenHistory, setQuickOpenHistory] = useState([]);
+    // Search dialog state
+    const [searchDialogOpen, setSearchDialogOpen] = useState(false);
+    // Confirmation dialog state
+    const [confirmationState, setConfirmationState] = useState(null);
+    // Debouncing state
+    const debounceTimerRef = useRef(null);
+    const DEBOUNCE_DELAY = 50; // 50ms debounce delay
+    // Timestamp when this component last gained focus — used to suppress
+    // the activating Enter that may be delivered twice (nav-bar -> file-tree).
+    const lastFocusTimeRef = useRef(0);
+    /**
+     * Show a temporary status message
+     */
+    const showStatus = useCallback((message) => {
+        setStatusMessage(message);
+        // Clear existing timer
+        if (statusTimerRef.current) {
+            clearTimeout(statusTimerRef.current);
+        }
+        // Set new timer to clear message after 2 seconds
+        statusTimerRef.current = setTimeout(() => {
+            setStatusMessage('');
+            statusTimerRef.current = null;
+        }, 2000);
+    }, []);
+    useEffect(() => {
+        if (hasFocus) {
+            lastFocusTimeRef.current = Date.now();
+        }
+    }, [hasFocus]);
+    /**
+     * Handle Quick Open file selection
+     */
+    const handleQuickOpenSelect = useCallback(async (node) => {
+        if (!treeState.root) {
+            return;
+        }
+        showStatus(`Selected: ${node.name}`);
+        setQuickOpenState(false);
+    }, [treeState.root, showStatus]);
+    /**
+     * Handle search result selection
+     */
+    const handleSearchSelect = useCallback(async (result) => {
+        try {
+            // Expand to the file path
+            await expandToPath(result.path);
+            // Open the file in viewer (left panel)
+            const content = await readFile(result.path, 'utf-8');
+            openFileViewer(result.path, content);
+            showStatus(`Opened: ${result.path}:${result.line}`);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            showStatus(`Error opening file: ${errorMsg}`);
+        }
+    }, [expandToPath, showStatus, openFileViewer]);
+    /**
+     * Update Quick Open history
+     */
+    const updateQuickOpenHistory = useCallback((filePath) => {
+        setQuickOpenHistory((prev) => {
+            const filtered = prev.filter((p) => p !== filePath);
+            const updated = [filePath, ...filtered];
+            return updated.slice(0, 20);
+        });
+    }, []);
+    /**
+     * Toggle focus on the selected file
+     */
+    const toggleFocus = useCallback(async () => {
+        const selectedNode = getSelectedNode();
+        if (!selectedNode) {
+            showStatus('No file selected');
+            return;
+        }
+        if (selectedNode.type === 'directory') {
+            showStatus('Cannot focus directories');
+            return;
+        }
+        const filePath = selectedNode.path;
+        try {
+            if (isFocused(filePath)) {
+                focusSystem.unfocusFile(filePath);
+                removeFocusedFile(filePath);
+                showStatus(`Unfocused: ${selectedNode.name}`);
+            }
+            else {
+                const focusedFile = await focusSystem.focusFile(filePath);
+                addFocusedFile(focusedFile);
+                const truncatedMsg = focusedFile.truncated ? ' (truncated)' : '';
+                showStatus(`Focused: ${selectedNode.name}${truncatedMsg}`);
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            showStatus(`Error: ${errorMsg}`);
+        }
+    }, [getSelectedNode, isFocused, focusSystem, addFocusedFile, removeFocusedFile, showStatus]);
+    /**
+     * Open the selected file in the syntax viewer
+     */
+    const openViewer = useCallback(async () => {
+        const selectedNode = getSelectedNode();
+        if (!selectedNode) {
+            showStatus('No file selected');
+            return;
+        }
+        if (selectedNode.type === 'directory') {
+            showStatus('Cannot view directories');
+            return;
+        }
+        const filePath = selectedNode.path;
+        try {
+            setIsLoading(true);
+            setLoadingMessage('Loading file...');
+            const content = await readFile(filePath, 'utf-8');
+            // Open in left panel via UI context
+            openFileViewer(filePath, content);
+            setStatusMessage('');
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            showStatus(`Error reading file: ${errorMsg}`);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [getSelectedNode, showStatus, setIsLoading, openFileViewer]);
+    /**
+     * Close the syntax viewer modal
+     */
+    const _closeViewer = useCallback(() => {
+        closeFileViewer();
+    }, [closeFileViewer]);
+    /**
+     * Open file in external editor
+     */
+    const openInEditor = useCallback(async () => {
+        const selectedNode = getSelectedNode();
+        if (!selectedNode) {
+            showStatus('No file selected');
+            return;
+        }
+        if (selectedNode.type === 'directory') {
+            showStatus('Cannot edit directories');
+            return;
+        }
+        const filePath = selectedNode.path;
+        const editorCommand = editorIntegration.getEditorCommand();
+        try {
+            setIsLoading(true);
+            setLoadingMessage(`Opening in ${editorCommand}...`);
+            const result = await editorIntegration.openInEditor(filePath);
+            if (result.success) {
+                showStatus(`Editor closed successfully`);
+            }
+            else {
+                showStatus(`Editor exited with code ${result.exitCode}: ${result.error || 'Unknown error'}`);
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            showStatus(`Error opening editor: ${errorMsg}`);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [getSelectedNode, editorIntegration, showStatus, setIsLoading]);
+    /**
+     * Handle quick actions menu action selection
+     */
+    const handleQuickAction = useCallback(async (action) => {
+        switch (action) {
+            case 'open': {
+                await openViewer();
+                break;
+            }
+            case 'focus': {
+                await toggleFocus();
+                break;
+            }
+            case 'edit': {
+                await openInEditor();
+                break;
+            }
+            case 'rename': {
+                showStatus('Rename functionality not yet implemented');
+                break;
+            }
+            case 'delete': {
+                const selectedNode = getSelectedNode();
+                if (!selectedNode) {
+                    showStatus('No file or folder selected');
+                    return;
+                }
+                const isDirectory = selectedNode.type === 'directory';
+                const message = isDirectory
+                    ? `Are you sure you want to delete the folder "${selectedNode.name}" and all its contents?`
+                    : `Are you sure you want to delete "${selectedNode.name}"?`;
+                setConfirmationState({
+                    isOpen: true,
+                    message,
+                    onConfirm: async () => {
+                        try {
+                            setIsLoading(true);
+                            setLoadingMessage(`Deleting ${selectedNode.name}...`);
+                            const alwaysConfirm = async () => true;
+                            let result;
+                            if (isDirectory) {
+                                result = await fileOperations.deleteFolder(selectedNode.path, alwaysConfirm, true // recursive
+                                );
+                            }
+                            else {
+                                result = await fileOperations.deleteFile(selectedNode.path, alwaysConfirm);
+                            }
+                            if (result.success) {
+                                showStatus(`Successfully deleted ${selectedNode.name}`);
+                            }
+                            else {
+                                showStatus(`Failed to delete: ${result.error}`);
+                            }
+                        }
+                        catch (error) {
+                            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+                            showStatus(`Error deleting: ${errorMsg}`);
+                        }
+                        finally {
+                            setIsLoading(false);
+                            setConfirmationState(null);
+                        }
+                    },
+                });
+                break;
+            }
+            case 'copyPath': {
+                const node = getSelectedNode();
+                if (node) {
+                    try {
+                        const absolutePath = await fileOperations.copyPath(node.path);
+                        showStatus(`Copied to clipboard: ${absolutePath}`);
+                    }
+                    catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+                        showStatus(`Error copying path: ${errorMsg}`);
+                    }
+                }
+                break;
+            }
+        }
+    }, [
+        openViewer,
+        toggleFocus,
+        openInEditor,
+        getSelectedNode,
+        fileOperations,
+        showStatus,
+        setIsLoading,
+    ]);
+    /**
+     * Debounced action executor
+     */
+    const debouncedAction = useCallback((action) => {
+        if (debounceTimerRef.current) {
+            clearTimeout(debounceTimerRef.current);
+        }
+        debounceTimerRef.current = setTimeout(() => {
+            action();
+            debounceTimerRef.current = null;
+        }, DEBOUNCE_DELAY);
+    }, []);
+    const moveDown = useCallback(() => {
+        const windowLength = treeState.visibleWindow.length;
+        if (windowLength === 0)
+            return;
+        if (treeState.cursorPosition < windowLength - 1) {
+            setCursorPosition(treeState.cursorPosition + 1);
+        }
+    }, [treeState, setCursorPosition]);
+    const moveUp = useCallback(() => {
+        if (treeState.visibleWindow.length === 0)
+            return;
+        if (treeState.cursorPosition > 0) {
+            setCursorPosition(treeState.cursorPosition - 1);
+        }
+    }, [treeState, setCursorPosition]);
+    /**
+     * Handle LLM message for Follow Mode
+     */
+    const _handleLLMMessage = useCallback(async (message) => {
+        if (!treeState.followModeEnabled || !followModeService || !treeState.root) {
+            return;
+        }
+        const rootPath = treeState.root.path;
+        const detectedPaths = followModeService.extractFromLLMResponse(message, {
+            rootPath,
+            filterByRoot: true,
+        });
+        for (const filePath of detectedPaths) {
+            if (followModeService.shouldExpandToPath(filePath, rootPath)) {
+                await expandToPath(filePath);
+                showStatus(`Follow Mode: Expanded to ${filePath}`);
+            }
+        }
+    }, [treeState.followModeEnabled, treeState.root, followModeService, expandToPath, showStatus]);
+    /**
+     * Handle keyboard input
+     */
+    /**
+     * Handle keyboard input
+     */
+    const handleInput = useCallback((input, key) => {
+        if (helpPanelOpen) {
+            if (isKey(input, key, activeKeybinds.chat.cancel) || input === '?') {
+                setHelpPanelOpen(false);
+                focusManager.closeModal();
+            }
+            return;
+        }
+        if (quickOpenState) {
+            // Quick open dialog handles its own input
+            return;
+        }
+        if (searchDialogOpen) {
+            // Search dialog handles its own input
+            return;
+        }
+        if (menuOpen) {
+            if (isKey(input, key, activeKeybinds.chat.cancel)) {
+                setMenuOpen(false);
+                focusManager.closeModal();
+            }
+            return;
+        }
+        if (input === '?') {
+            setHelpPanelOpen(true);
+            focusManager.openModal('help-panel');
+            return;
+        }
+        if (isKey(input, key, activeKeybinds.fileExplorer.quickOpen)) {
+            setQuickOpenState(true);
+            focusManager.openModal('quick-open-dialog');
+            return;
+        }
+        // Ctrl+F to open search dialog
+        if (input === 'f' && key.ctrl) {
+            setSearchDialogOpen(true);
+            focusManager.openModal('search-dialog');
+            return;
+        }
+        // Arrow key navigation (direct support)
+        if (key.downArrow) {
+            moveDown();
+            return;
+        }
+        else if (key.upArrow) {
+            moveUp();
+            return;
+        }
+        else if (key.leftArrow) {
+            const selectedNode = getSelectedNode();
+            if (selectedNode && selectedNode.type === 'directory' && selectedNode.expanded) {
+                debouncedAction(() => {
+                    collapseDirectory(selectedNode.path);
+                    fileTreeService.collapseDirectory(selectedNode);
+                });
+            }
+            return;
+        }
+        else if (key.rightArrow) {
+            const selectedNode = getSelectedNode();
+            if (selectedNode && selectedNode.type === 'directory' && !selectedNode.expanded) {
+                (async () => {
+                    try {
+                        // First load the children
+                        await fileTreeService.expandDirectory(selectedNode, excludePatterns);
+                        // Then mark as expanded in context
+                        expandDirectory(selectedNode.path);
+                    }
+                    catch (_err) {
+                        showStatus('Error expanding directory');
+                    }
+                })();
+            }
+            return;
+        }
+        // Keybind-based navigation (fallback)
+        if (isKey(input, key, activeKeybinds.fileExplorer.moveDown)) {
+            moveDown();
+        }
+        else if (isKey(input, key, activeKeybinds.fileExplorer.moveUp)) {
+            moveUp();
+        }
+        else if (isKey(input, key, activeKeybinds.fileExplorer.collapse)) {
+            const selectedNode = getSelectedNode();
+            if (selectedNode && selectedNode.type === 'directory' && selectedNode.expanded) {
+                debouncedAction(() => {
+                    collapseDirectory(selectedNode.path);
+                    fileTreeService.collapseDirectory(selectedNode);
+                });
+            }
+        }
+        else if (isKey(input, key, activeKeybinds.fileExplorer.expand)) {
+            const selectedNode = getSelectedNode();
+            if (selectedNode && selectedNode.type === 'directory' && !selectedNode.expanded) {
+                (async () => {
+                    try {
+                        // First load the children
+                        await fileTreeService.expandDirectory(selectedNode, excludePatterns);
+                        // Then mark as expanded in context
+                        expandDirectory(selectedNode.path);
+                    }
+                    catch (_err) {
+                        showStatus('Error expanding directory');
+                    }
+                })();
+            }
+        }
+        else if (isKey(input, key, activeKeybinds.fileExplorer.select)) {
+            // Suppress immediate select when focus was just given to avoid the
+            // Enter key press that activated the Files tab from also toggling
+            // the directory open/closed state.
+            if (Date.now() - lastFocusTimeRef.current < 200) {
+                return;
+            }
+            const selectedNode = getSelectedNode();
+            if (!selectedNode)
+                return;
+            if (selectedNode.type === 'directory') {
+                if (selectedNode.expanded) {
+                    collapseDirectory(selectedNode.path);
+                    fileTreeService.collapseDirectory(selectedNode);
+                }
+                else {
+                    // Expand directory asynchronously
+                    (async () => {
+                        try {
+                            // First load the children
+                            await fileTreeService.expandDirectory(selectedNode, excludePatterns);
+                            // Then mark as expanded in context
+                            expandDirectory(selectedNode.path);
+                        }
+                        catch (_err) {
+                            showStatus('Error expanding directory');
+                        }
+                    })();
+                }
+            }
+            else {
+                openViewer();
+            }
+        }
+        else if (isKey(input, key, activeKeybinds.fileExplorer.focus)) {
+            toggleFocus();
+        }
+        else if (isKey(input, key, activeKeybinds.fileExplorer.open)) {
+            openViewer();
+        }
+        else if (isKey(input, key, activeKeybinds.fileExplorer.edit)) {
+            openInEditor();
+        }
+        else if (isKey(input, key, activeKeybinds.fileExplorer.actions)) {
+            setMenuOpen(true);
+            focusManager.openModal('quick-actions-menu');
+        }
+        else if (isKey(input, key, activeKeybinds.fileExplorer.toggleFollow)) {
+            toggleFollowMode();
+            const newState = !treeState.followModeEnabled;
+            showStatus(`Follow Mode: ${newState ? 'Enabled' : 'Disabled'}`);
+        }
+    }, [
+        helpPanelOpen,
+        quickOpenState,
+        searchDialogOpen,
+        menuOpen,
+        debouncedAction,
+        moveDown,
+        moveUp,
+        getSelectedNode,
+        collapseDirectory,
+        fileTreeService,
+        expandDirectory,
+        excludePatterns,
+        toggleFocus,
+        openViewer,
+        openInEditor,
+        toggleFollowMode,
+        treeState.followModeEnabled,
+        showStatus,
+        activeKeybinds,
+        focusManager,
+    ]);
+    useInput(handleInput, {
+        isActive: hasFocus ||
+            focusManager.isFocused('syntax-viewer') ||
+            focusManager.isFocused('help-panel') ||
+            focusManager.isFocused('search-dialog') ||
+            focusManager.isFocused('quick-open-dialog') ||
+            focusManager.isFocused('quick-actions-menu'),
+    });
+    useEffect(() => {
+        return () => {
+            if (debounceTimerRef.current) {
+                clearTimeout(debounceTimerRef.current);
+            }
+            if (statusTimerRef.current) {
+                clearTimeout(statusTimerRef.current);
+            }
+        };
+    }, []);
+    // Performance optimization: Memoize visible window calculation
+    // This prevents unnecessary recalculations when unrelated state changes
+    const visibleNodes = React.useMemo(() => {
+        if (!treeState.root) {
+            return [];
+        }
+        // Get all visible nodes without windowing - just flatten the tree
+        return fileTreeService.getFlattenedTree(treeState.root);
+    }, [treeState.root, fileTreeService]);
+    // Update visible window in state when it changes
+    useEffect(() => {
+        setVisibleWindow(visibleNodes);
+    }, [visibleNodes, setVisibleWindow]);
+    if (!treeState.root) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { dimColor: true, children: "No directory loaded" }) }));
+    }
+    const treeRootPath = treeState.root.path;
+    return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [helpPanelOpen && (_jsx(HelpPanel, { isOpen: helpPanelOpen, onClose: () => setHelpPanelOpen(false) })), quickOpenState && (_jsx(QuickOpenDialog, { isOpen: quickOpenState, allFiles: treeState.root
+                    ? fileTreeService.flattenTree(treeState.root).filter((n) => n.type === 'file')
+                    : [], onSelect: handleQuickOpenSelect, onClose: () => setQuickOpenState(false), history: quickOpenHistory, onHistoryUpdate: updateQuickOpenHistory })), searchDialogOpen && (_jsx(FileSearchDialog, { visible: searchDialogOpen, onClose: () => setSearchDialogOpen(false), onSelect: handleSearchSelect, toolRegistry: toolRegistry, rootPath: treeState.root?.path || rootPath })), confirmationState?.isOpen && (_jsx(ConfirmationDialog, { isOpen: confirmationState.isOpen, message: confirmationState.message, title: "Confirm Delete", level: "danger", onConfirm: confirmationState.onConfirm, onCancel: () => setConfirmationState(null) })), menuOpen && (_jsx(QuickActionsMenu, { selectedNode: getSelectedNode(), isOpen: menuOpen, onAction: handleQuickAction, onClose: () => setMenuOpen(false) })), !helpPanelOpen && (_jsxs(_Fragment, { children: [_jsx(LoadingIndicator, { isLoading: isLoading, message: loadingMessage }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [Array.isArray(treeState.visibleWindow) &&
+                                treeState.visibleWindow.map((node, index) => {
+                                    if (!node || !node.path || !node.name)
+                                        return null;
+                                    const isSelected = index === treeState.cursorPosition;
+                                    const isFocusedFile = isFocused(node.path);
+                                    const indentation = calculateIndentation(node, treeRootPath);
+                                    const icon = getNodeIcon(node);
+                                    const gitColor = getGitStatusColor(node.gitStatus);
+                                    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: ' '.repeat(indentation * 2) }), _jsx(Text, { bold: isSelected, color: isSelected ? 'cyan' : undefined, children: isSelected ? '> ' : '  ' }), _jsxs(Text, { children: [" ", icon, " "] }), _jsx(Text, { bold: isSelected, color: gitColor || (isSelected ? 'cyan' : undefined), children: node.name }), isFocusedFile && _jsxs(Text, { children: [" ", ICONS.focusIndicator] })] }, node.path));
+                                }), treeState.visibleWindow.length === 0 && _jsx(Text, { dimColor: true, children: "No items found" })] }), (statusMessage || treeState.followModeEnabled) && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [statusMessage && (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: statusMessage }) })), treeState.followModeEnabled && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "Follow Mode: ON" }), _jsx(Text, { dimColor: true, children: " (Press F to toggle)" })] }))] }))] }))] }));
+}
+//# sourceMappingURL=FileTreeView.js.map