import React, { useCallback, useEffect, useLayoutEffect, useMemo, useReducer, useRef, useState } from 'react'; import { AlertCircle, ArrowRight, ArrowUp, ChevronRight, ClipboardCopy, CornerUpLeft, Copy, Download, Edit2, ExternalLink, FilePlus, Folder, FolderInput, FolderOpen, FolderPlus, Loader2, Pencil, RefreshCw, Shield, Trash2, Upload, } from 'lucide-react'; import { Button } from '../ui/button'; import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle, } from '../ui/dialog'; import { Input } from '../ui/input'; import { ContextMenu, ContextMenuContent, ContextMenuItem, ContextMenuSeparator, ContextMenuTrigger, } from '../ui/context-menu'; import { cn } from '../../lib/utils'; import type { SftpFileEntry } from '../../types'; import type { SftpPane } from '../../application/state/sftp/types'; import { getParentPath, joinPath } from '../../application/state/sftp/utils'; import { buildSftpColumnTemplate, filterHiddenFiles, formatBytes, formatDate, getFileIcon, isNavigableDirectory, sortSftpEntries, type ColumnWidths, type SortField, type SortOrder } from './utils'; import type { SftpTransferSource } from './SftpContext'; import { sftpTreeSelectionStore, useSftpTreeSelectionState } from './hooks/useSftpTreeSelectionStore'; import { sftpKeyboardSelectionStore, sftpTreeEnterStore } from './hooks/useSftpKeyboardShortcuts'; import { useI18n } from '../../application/i18n/I18nProvider'; import { isKnownBinaryFile } from '../../lib/sftpFileUtils'; import { getSftpTreeUploadFilesTargetPath, getSftpUploadFilesLabelKey, getSftpUploadFolderLabelKey, shouldShowSftpUploadFolderMenu, shouldShowSftpUploadFilesMenu, } from './sftpUploadMenu'; type NodeDescriptor = | { type: 'node'; entry: SftpFileEntry; entryPath: string; depth: number; isExpanded: boolean; isLoading: boolean } | { type: 'loading' | 'error'; key: string; depth: number }; interface SftpPaneTreeViewProps { pane: SftpPane; side: 'left' | 'right'; onPrepareSelection: () => void; onLoadChildren: (path: string) => Promise; onMoveEntriesToPath: (sourcePaths: string[], targetPath: string) => Promise; onNavigateUp: () => void; onNavigateTo: (path: string) => void; onRefresh: () => void; onOpenEntry: (entry: SftpFileEntry, fullPath?: string) => void; onDragStart: (files: SftpTransferSource[], side: 'left' | 'right') => void; onDragEnd: () => void; openRenameDialog: (entryPath: string) => void; openDeleteConfirm: (targets: string[]) => void; onCopyToOtherPane: (files: SftpTransferSource[]) => void; onReceiveFromOtherPane: (files: SftpTransferSource[]) => void; onOpenFileWith?: (entry: SftpFileEntry, fullPath?: string) => void; onEditFile?: (entry: SftpFileEntry, fullPath?: string) => void; onDownloadFile?: (entry: SftpFileEntry, fullPath?: string) => void; onEditPermissions?: (entry: SftpFileEntry, fullPath?: string) => void; draggedFiles: (SftpTransferSource & { side: 'left' | 'right' })[] | null; openNewFolderDialog: (targetPath: string) => void; openNewFileDialog: (targetPath: string) => void; onUploadExternalFiles?: (dataTransfer: DataTransfer, targetPath?: string) => Promise; onUploadExternalFileList?: (fileList: FileList, targetPath?: string) => Promise; onUploadExternalFolder?: (targetPath?: string) => Promise; columnWidths: ColumnWidths; handleSort: (field: SortField) => void; handleResizeStart: (field: keyof ColumnWidths, e: React.MouseEvent) => void; sortField: SortField; sortOrder: SortOrder; reloadRequest: { token: number; paths?: string[]; full?: boolean }; } // ── Simplified TreeNode (no per-node ContextMenu) ──────────────────── interface TreeNodeProps { entry: SftpFileEntry; entryPath: string; depth: number; columnTemplate: string; isSelected: boolean; isExpanded: boolean; isLoading: boolean; isDragOver: boolean; onToggleExpand: (entry: SftpFileEntry, entryPath: string) => void; onNodeClick: (entry: SftpFileEntry, entryPath: string, e: React.MouseEvent) => void; onOpenEntry: (entry: SftpFileEntry, entryPath: string) => void; onDragStart: (entry: SftpFileEntry, entryPath: string, isDir: boolean, e: React.DragEvent) => void; onDragEnd: () => void; onDragOverEntry: (entryPath: string, e: React.DragEvent) => void; onDropEntry: (entryPath: string, e: React.DragEvent) => void; onDragLeaveEntry: () => void; onContextMenu: (entry: SftpFileEntry, entryPath: string, e: React.MouseEvent) => void; } const TREE_ROW_HEIGHT = 28; const TreeNode = React.memo(({ entry, entryPath, depth, columnTemplate, isSelected, isExpanded, isLoading, isDragOver, onToggleExpand, onNodeClick, onOpenEntry, onDragStart, onDragEnd, onDragOverEntry, onDropEntry, onDragLeaveEntry, onContextMenu, }) => { const { t } = useI18n(); const isParentEntry = entry.name === '..'; const isDir = isNavigableDirectory(entry); const icon = isDir ? (isExpanded ? : ) : getFileIcon(entry); return (
onNodeClick(entry, entryPath, e)} onDoubleClick={() => { if (isParentEntry) { onOpenEntry(entry, entryPath); return; } if (isDir) void onToggleExpand(entry, entryPath); else onOpenEntry(entry, entryPath); }} onContextMenu={e => { if (!isParentEntry) { onContextMenu(entry, entryPath, e); } }} draggable={!isParentEntry} onDragStart={e => { if (!isParentEntry) onDragStart(entry, entryPath, isDir, e); }} onDragEnd={onDragEnd} onDragOver={e => onDragOverEntry(entryPath, e)} onDrop={e => onDropEntry(entryPath, e)} onDragLeave={onDragLeaveEntry} >
{isParentEntry ? ( ) : isDir ? ( isLoading ? ( ) : ( { e.stopPropagation(); void onToggleExpand(entry, entryPath); }} /> ) ) : null} {!isParentEntry && {icon}} {entry.name}
{isParentEntry ? '' : formatDate(entry.lastModified)} {isParentEntry ? '' : (isDir ? '--' : formatBytes(entry.size ?? 0))} {isParentEntry ? '' : (isDir ? t('sftp.kind.folder') : (entry.name.split('.').pop()?.toUpperCase() ?? '--'))}
); }); TreeNode.displayName = 'TreeNode'; // ── Tree paths reducer (unchanged) ────────────────────────────────── type TreePathsState = { expandedPaths: Set; loadingPaths: Set; errorPaths: Set; }; type TreePathsAction = | { type: 'START_LOADING'; path: string } | { type: 'FINISH_LOADING'; path: string } | { type: 'LOAD_ERROR'; path: string } | { type: 'EXPAND'; path: string } | { type: 'COLLAPSE'; path: string } | { type: 'RESET' }; const INITIAL_TREE_PATHS_STATE: TreePathsState = { expandedPaths: new Set(), loadingPaths: new Set(), errorPaths: new Set(), }; function treePathsReducer(state: TreePathsState, action: TreePathsAction): TreePathsState { switch (action.type) { case 'START_LOADING': { const loadingPaths = new Set(state.loadingPaths); loadingPaths.add(action.path); const errorPaths = new Set(state.errorPaths); errorPaths.delete(action.path); return { ...state, loadingPaths, errorPaths }; } case 'FINISH_LOADING': { const loadingPaths = new Set(state.loadingPaths); loadingPaths.delete(action.path); return { ...state, loadingPaths }; } case 'LOAD_ERROR': { const loadingPaths = new Set(state.loadingPaths); loadingPaths.delete(action.path); const errorPaths = new Set(state.errorPaths); errorPaths.add(action.path); return { ...state, loadingPaths, errorPaths }; } case 'EXPAND': { const expandedPaths = new Set(state.expandedPaths); expandedPaths.add(action.path); return { ...state, expandedPaths }; } case 'COLLAPSE': { const expandedPaths = new Set(state.expandedPaths); expandedPaths.delete(action.path); return { ...state, expandedPaths }; } case 'RESET': return INITIAL_TREE_PATHS_STATE; default: return state; } } // ── Context target type ───────────────────────────────────────────── interface ContextTarget { entry: SftpFileEntry; entryPath: string; } // ── Main tree view component ──────────────────────────────────────── export const SftpPaneTreeView = React.memo(({ pane, side, onPrepareSelection, onLoadChildren, onMoveEntriesToPath, onNavigateUp, onNavigateTo, onRefresh, onOpenEntry, onDragStart, onDragEnd, openRenameDialog, openDeleteConfirm, onCopyToOtherPane, onReceiveFromOtherPane, onOpenFileWith, onEditFile, onDownloadFile, onEditPermissions, draggedFiles, openNewFolderDialog, openNewFileDialog, onUploadExternalFiles, onUploadExternalFileList, onUploadExternalFolder, columnWidths, handleSort, handleResizeStart, sortField, sortOrder, reloadRequest, }) => { const { t } = useI18n(); const columnTemplate = buildSftpColumnTemplate(columnWidths); const tRef = useRef(t); tRef.current = t; // ── Drag-over state for external file drops on directories ────── const [dragOverNodePath, setDragOverNodePath] = useState(null); const onUploadExternalFilesRef = useRef(onUploadExternalFiles); onUploadExternalFilesRef.current = onUploadExternalFiles; const onUploadExternalFileListRef = useRef(onUploadExternalFileList); onUploadExternalFileListRef.current = onUploadExternalFileList; const uploadInputRef = useRef(null); const uploadTargetPathRef = useRef(undefined); const uploadEnabled = shouldShowSftpUploadFilesMenu({ isLocal: !!pane.connection?.isLocal, hasFileListUpload: !!onUploadExternalFileList, }); const folderUploadEnabled = shouldShowSftpUploadFolderMenu({ isLocal: !!pane.connection?.isLocal, hasFolderUpload: !!onUploadExternalFolder, }); const triggerUploadPicker = useCallback((targetPath?: string) => { if (!uploadEnabled) return; const input = uploadInputRef.current; if (!input) return; uploadTargetPathRef.current = targetPath; input.value = ''; input.click(); }, [uploadEnabled]); const handleUploadInputChange = useCallback((e: React.ChangeEvent) => { const files = e.target.files; if (!files || files.length === 0) { uploadTargetPathRef.current = undefined; return; } const targetPath = uploadTargetPathRef.current; uploadTargetPathRef.current = undefined; void onUploadExternalFileListRef.current?.(files, targetPath); }, []); // ── Virtual scrolling state ────────────────────────────────────── const scrollContainerRef = useRef(null); const [scrollTop, setScrollTop] = useState(0); const [viewportHeight, setViewportHeight] = useState(0); const scrollFrameRef = useRef(null); useLayoutEffect(() => { const container = scrollContainerRef.current; if (!container) return; const update = () => setViewportHeight(container.clientHeight); update(); const raf = window.requestAnimationFrame(update); const resizeObserver = new ResizeObserver(update); resizeObserver.observe(container); return () => { resizeObserver.disconnect(); window.cancelAnimationFrame(raf); }; }, []); useEffect(() => { return () => { if (scrollFrameRef.current !== null) { window.cancelAnimationFrame(scrollFrameRef.current); } }; }, []); const pendingScrollTopRef = useRef(0); const handleScroll = useCallback((e: React.UIEvent) => { pendingScrollTopRef.current = e.currentTarget.scrollTop; if (scrollFrameRef.current !== null) return; scrollFrameRef.current = window.requestAnimationFrame(() => { scrollFrameRef.current = null; setScrollTop(pendingScrollTopRef.current); }); }, []); // ── Shared context menu state ──────────────────────────────────── const [contextTarget, setContextTarget] = useState(null); // ── Move-to dialog state ──────────────────────────────────────── const [showMoveToDialog, setShowMoveToDialog] = useState(false); const [moveToPath, setMoveToPath] = useState(''); const [moveTargetPaths, setMoveTargetPaths] = useState([]); const [moveToError, setMoveToError] = useState(null); const [isMoving, setIsMoving] = useState(false); const [moveToSuggestions, setMoveToSuggestions] = useState([]); const [moveToSuggestionIndex, setMoveToSuggestionIndex] = useState(-1); const moveToInputRef = useRef(null); const moveToSuggestionsTimerRef = useRef | null>(null); // ── Tree data state ────────────────────────────────────────────── const childrenCacheRef = useRef>(new Map()); const sortedChildrenCacheRef = useRef>(new Map()); const [treePaths, dispatchTreePaths] = useReducer(treePathsReducer, INITIAL_TREE_PATHS_STATE); const { expandedPaths, loadingPaths, errorPaths } = treePaths; const treeSelectionState = useSftpTreeSelectionState(pane.id); const selectedPaths = treeSelectionState.selectedPaths; const lastClickedPathRef = useRef(null); const expandedPathsRef = useRef(expandedPaths); expandedPathsRef.current = expandedPaths; const loadingPathsRef = useRef(loadingPaths); loadingPathsRef.current = loadingPaths; const selectedPathsRef = useRef(selectedPaths); selectedPathsRef.current = selectedPaths; const treeSelectionStateRef = useRef(treeSelectionState); treeSelectionStateRef.current = treeSelectionState; const treeGenerationRef = useRef(0); const previousRootPathRef = useRef(pane.connection?.currentPath ?? ''); const previousConnectionIdRef = useRef(pane.connection?.id ?? null); const [rootEntries, setRootEntries] = useState(pane.files ?? []); const [resolvedRootPath, setResolvedRootPath] = useState(pane.connection?.currentPath ?? ''); useEffect(() => { if (selectedPaths.size === 0) { lastClickedPathRef.current = null; sftpKeyboardSelectionStore.clear(pane.id); } }, [pane.id, selectedPaths.size]); const onOpenEntryRef = useRef(onOpenEntry); onOpenEntryRef.current = onOpenEntry; const onNavigateUpRef = useRef(onNavigateUp); onNavigateUpRef.current = onNavigateUp; const onNavigateToRef = useRef(onNavigateTo); onNavigateToRef.current = onNavigateTo; const onPrepareSelectionRef = useRef(onPrepareSelection); onPrepareSelectionRef.current = onPrepareSelection; const onMoveEntriesToPathRef = useRef(onMoveEntriesToPath); onMoveEntriesToPathRef.current = onMoveEntriesToPath; const onDragStartRef = useRef(onDragStart); onDragStartRef.current = onDragStart; const onDragEndRef = useRef(onDragEnd); onDragEndRef.current = onDragEnd; const onCopyToOtherPaneRef = useRef(onCopyToOtherPane); onCopyToOtherPaneRef.current = onCopyToOtherPane; const onReceiveFromOtherPaneRef = useRef(onReceiveFromOtherPane); onReceiveFromOtherPaneRef.current = onReceiveFromOtherPane; const onOpenFileWithRef = useRef(onOpenFileWith); onOpenFileWithRef.current = onOpenFileWith; const onEditFileRef = useRef(onEditFile); onEditFileRef.current = onEditFile; const onDownloadFileRef = useRef(onDownloadFile); onDownloadFileRef.current = onDownloadFile; const onEditPermissionsRef = useRef(onEditPermissions); onEditPermissionsRef.current = onEditPermissions; const openRenameDialogRef = useRef(openRenameDialog); openRenameDialogRef.current = openRenameDialog; const openDeleteConfirmRef = useRef(openDeleteConfirm); openDeleteConfirmRef.current = openDeleteConfirm; const openNewFolderDialogRef = useRef(openNewFolderDialog); openNewFolderDialogRef.current = openNewFolderDialog; const openNewFileDialogRef = useRef(openNewFileDialog); openNewFileDialogRef.current = openNewFileDialog; const onLoadChildrenRef = useRef(onLoadChildren); onLoadChildrenRef.current = onLoadChildren; const onRefreshRef = useRef(onRefresh); onRefreshRef.current = onRefresh; const sideRef = useRef(side); sideRef.current = side; const draggedFilesRef = useRef(draggedFiles); draggedFilesRef.current = draggedFiles; const invalidateTreeCache = useCallback(() => { treeGenerationRef.current += 1; childrenCacheRef.current.clear(); sortedChildrenCacheRef.current.clear(); }, []); const invalidatePathCache = useCallback((targetPath: string) => { treeGenerationRef.current += 1; childrenCacheRef.current.delete(targetPath); sortedChildrenCacheRef.current.delete(targetPath); }, []); // Clear sorted cache when sort/filter settings change const prevSortKeyRef = useRef(`${sortField}:${sortOrder}:${pane.showHiddenFiles}`); const sortKey = `${sortField}:${sortOrder}:${pane.showHiddenFiles}`; if (prevSortKeyRef.current !== sortKey) { prevSortKeyRef.current = sortKey; sortedChildrenCacheRef.current.clear(); } // Atomically sync rootEntries and resolvedRootPath together so the tree // never renders new-path + old-files or vice versa. useEffect(() => { const currentPath = pane.connection?.currentPath ?? ''; if (!currentPath) { setResolvedRootPath(''); setRootEntries([]); return; } if (!pane.loading) { setResolvedRootPath(currentPath); setRootEntries(pane.files ?? []); sortedChildrenCacheRef.current.delete(currentPath); } }, [pane.connection?.currentPath, pane.loading, pane.files]); const loadChildrenForPath = useCallback(async (entryPath: string) => { const generation = treeGenerationRef.current; dispatchTreePaths({ type: 'START_LOADING', path: entryPath }); try { const children = await onLoadChildrenRef.current(entryPath); if (generation !== treeGenerationRef.current) { return false; } childrenCacheRef.current.set(entryPath, children); dispatchTreePaths({ type: 'FINISH_LOADING', path: entryPath }); return true; } catch { if (generation === treeGenerationRef.current) { dispatchTreePaths({ type: 'LOAD_ERROR', path: entryPath }); } return false; } }, []); const toggleExpand = useCallback(async (entry: SftpFileEntry, entryPath: string) => { if (!isNavigableDirectory(entry)) return; if (expandedPathsRef.current.has(entryPath)) { dispatchTreePaths({ type: 'COLLAPSE', path: entryPath }); return; } // Guard against concurrent loads for the same path if (loadingPathsRef.current.has(entryPath)) return; if (!childrenCacheRef.current.has(entryPath)) { const loaded = await loadChildrenForPath(entryPath); if (!loaded) return; } dispatchTreePaths({ type: 'EXPAND', path: entryPath }); }, [loadChildrenForPath]); const reloadExpandedPaths = useCallback(async (paths: string[]) => { await Promise.all(paths.map((path) => loadChildrenForPath(path))); }, [loadChildrenForPath]); const reloadRootPath = useCallback(async (rootPath: string) => { try { const children = await onLoadChildrenRef.current(rootPath); if ((pane.connection?.currentPath ?? '') !== rootPath) return; setResolvedRootPath(rootPath); setRootEntries(children); sortedChildrenCacheRef.current.delete(rootPath); } catch { // Keep the previous root listing if the reload fails. } }, [pane.connection?.currentPath]); useEffect(() => { const rootPath = pane.connection?.currentPath ?? ''; const connectionId = pane.connection?.id ?? null; const pathChanged = previousRootPathRef.current !== rootPath; const connectionChanged = previousConnectionIdRef.current !== connectionId; previousRootPathRef.current = rootPath; previousConnectionIdRef.current = connectionId; if (pathChanged || connectionChanged) { invalidateTreeCache(); dispatchTreePaths({ type: 'RESET' }); sftpTreeSelectionStore.clearSelection(pane.id); sftpKeyboardSelectionStore.clear(pane.id); lastClickedPathRef.current = null; } }, [pane.connection?.currentPath, pane.connection?.id, pane.id, invalidateTreeCache]); useEffect(() => { if (!reloadRequest.token) return; const rootPath = pane.connection?.currentPath; if (!rootPath) return; if (reloadRequest.full || !reloadRequest.paths || reloadRequest.paths.length === 0) { const expanded = Array.from(expandedPathsRef.current); invalidateTreeCache(); if (expanded.length > 0) { void reloadExpandedPaths(expanded); } return; } const targets = Array.from(new Set(reloadRequest.paths)); for (const targetPath of targets) { invalidatePathCache(targetPath); } const shouldReloadRoot = targets.includes(rootPath); if (shouldReloadRoot) { void reloadRootPath(rootPath); } const expandedTargets = targets.filter((targetPath) => targetPath !== rootPath && expandedPathsRef.current.has(targetPath), ); if (expandedTargets.length > 0) { void reloadExpandedPaths(expandedTargets); } }, [invalidatePathCache, invalidateTreeCache, pane.connection?.currentPath, reloadExpandedPaths, reloadRequest, reloadRootPath]); const focusTreeContainer = useCallback(() => { const container = scrollContainerRef.current; if (!container) return; if (document.activeElement !== container) { container.focus(); } }, []); const handleNodeClick = useCallback((entry: SftpFileEntry, entryPath: string, e: React.MouseEvent) => { focusTreeContainer(); const state = treeSelectionStateRef.current; const currentIdx = state.visibleIndexByPath.get(entryPath) ?? -1; const nextSelection: string[] = (() => { if (e.shiftKey && lastClickedPathRef.current) { const items = state.visibleItems; const lastIdx = state.visibleIndexByPath.get(lastClickedPathRef.current) ?? -1; if (lastIdx !== -1 && currentIdx !== -1) { const parentPath = getParentPath(entryPath); const start = Math.min(lastIdx, currentIdx); const end = Math.max(lastIdx, currentIdx); return items .slice(start, end + 1) .filter(item => getParentPath(item.path) === parentPath) .map(item => item.path); } } if (e.ctrlKey || e.metaKey) { const next = new Set(selectedPathsRef.current); if (next.has(entryPath)) next.delete(entryPath); else next.add(entryPath); return Array.from(next); } return [entryPath]; })(); onPrepareSelectionRef.current(); sftpTreeSelectionStore.setSelection(pane.id, nextSelection); if (currentIdx !== -1) { if (e.shiftKey && lastClickedPathRef.current) { const anchorIdx = state.visibleIndexByPath.get(lastClickedPathRef.current) ?? currentIdx; sftpKeyboardSelectionStore.set(pane.id, anchorIdx, currentIdx); } else { sftpKeyboardSelectionStore.set(pane.id, currentIdx, currentIdx); } } lastClickedPathRef.current = entryPath; }, [focusTreeContainer, pane.id]); const openTreeEntry = useCallback((entry: SftpFileEntry, entryPath: string) => { if (entry.name === '..') { onNavigateUpRef.current(); return; } onOpenEntryRef.current(entry, entryPath); }, []); const stableOnRefresh = useCallback(() => onRefreshRef.current(), []); const handleTreeContainerKeyDown = useCallback((e: React.KeyboardEvent) => { if (e.altKey || e.ctrlKey || e.metaKey) return; const state = treeSelectionStateRef.current; const items = state.visibleItems; if (items.length === 0) return; if (e.key === 'ArrowUp' || e.key === 'ArrowDown') { e.preventDefault(); e.stopPropagation(); const delta = e.key === 'ArrowDown' ? 1 : -1; const currentSelected = [...selectedPathsRef.current]; let { anchor: anchorIdx, focus: focusIdx } = sftpKeyboardSelectionStore.get(pane.id); if (currentSelected.length === 0) { anchorIdx = e.shiftKey ? 0 : -1; focusIdx = -1; } else { const focusPath = items[focusIdx]?.path; if (!focusPath || !state.selectedPaths.has(focusPath)) { focusIdx = state.visibleIndexByPath.get(currentSelected[currentSelected.length - 1]) ?? 0; anchorIdx = focusIdx; sftpKeyboardSelectionStore.set(pane.id, anchorIdx, focusIdx); } } let nextIdx = focusIdx + delta; if (nextIdx < 0) nextIdx = 0; if (nextIdx >= items.length) nextIdx = items.length - 1; onPrepareSelectionRef.current(); if (e.shiftKey && currentSelected.length > 0) { const start = Math.min(anchorIdx, nextIdx); const end = Math.max(anchorIdx, nextIdx); const paths = items.slice(start, end + 1).map((item) => item.path); sftpTreeSelectionStore.setSelection(pane.id, paths); sftpKeyboardSelectionStore.set(pane.id, anchorIdx, nextIdx); } else { sftpTreeSelectionStore.setSelection(pane.id, [items[nextIdx].path]); sftpKeyboardSelectionStore.set(pane.id, nextIdx, nextIdx); } lastClickedPathRef.current = items[nextIdx].path; return; } if (e.key === 'Enter' && !e.shiftKey) { const selected = sftpTreeSelectionStore.getSelectedItems(pane.id); if (selected.length !== 1) return; e.preventDefault(); e.stopPropagation(); const item = selected[0]; const entry = entryByPathRef.current.get(item.path); if (!entry) return; if (entry.name === '..') { openTreeEntry(entry, item.path); return; } if (item.isDirectory) { void toggleExpand(entry, item.path); return; } openTreeEntry(entry, item.path); } }, [openTreeEntry, pane.id, toggleExpand]); const { nodeDescriptors, flatVisibleNodes, entryByPath } = useMemo(() => { const flat: Array<{ entry: SftpFileEntry; entryPath: string }> = []; const descriptors: NodeDescriptor[] = []; const pathMap = new Map(); // Prepend ".." entry for parent navigation when not at root const currentPath = resolvedRootPath; const isRootPath = currentPath === '/' || /^[A-Za-z]:[\\/]?$/.test(currentPath); if (!isRootPath && currentPath) { const files = rootEntries; let parentEntry = files.find(f => f.name === '..'); if (!parentEntry) { parentEntry = { name: '..', type: 'directory', size: 0, sizeFormatted: '--', lastModified: 0, lastModifiedFormatted: '--', }; } const parentPath = getParentPath(currentPath); flat.push({ entry: parentEntry, entryPath: parentPath }); pathMap.set(parentPath, parentEntry); descriptors.push({ type: 'node', entry: parentEntry, entryPath: parentPath, depth: 0, isExpanded: false, isLoading: false, }); } const getSortedEntries = (entries: SftpFileEntry[], parentPath: string): SftpFileEntry[] => { const cached = sortedChildrenCacheRef.current.get(parentPath); if (cached) return cached; const sorted = sortSftpEntries(filterHiddenFiles(entries, pane.showHiddenFiles), sortField, sortOrder); sortedChildrenCacheRef.current.set(parentPath, sorted); return sorted; }; const buildTree = (entries: SftpFileEntry[], parentPath: string, depth: number) => { for (const entry of getSortedEntries(entries, parentPath)) { if (entry.name === '..') continue; // Skip ".." from file list; already handled above const entryPath = joinPath(parentPath, entry.name); flat.push({ entry, entryPath }); pathMap.set(entryPath, entry); descriptors.push({ type: 'node', entry, entryPath, depth, isExpanded: expandedPaths.has(entryPath), isLoading: loadingPaths.has(entryPath), }); if (isNavigableDirectory(entry) && expandedPaths.has(entryPath)) { if (loadingPaths.has(entryPath)) { descriptors.push({ type: 'loading', key: `${entryPath}-loading`, depth }); } else if (errorPaths.has(entryPath)) { descriptors.push({ type: 'error', key: `${entryPath}-error`, depth }); } else { buildTree(childrenCacheRef.current.get(entryPath) ?? [], entryPath, depth + 1); } } } }; buildTree(rootEntries, currentPath, 0); return { nodeDescriptors: descriptors, flatVisibleNodes: flat, entryByPath: pathMap }; }, [ rootEntries, resolvedRootPath, pane.showHiddenFiles, sortField, sortOrder, expandedPaths, loadingPaths, errorPaths, ]); const entryByPathRef = useRef(entryByPath); entryByPathRef.current = entryByPath; const prevVisiblePathsRef = useRef([]); useEffect(() => { const currentPaths = flatVisibleNodes .filter(({ entry }) => entry.name !== '..') .map(({ entryPath }) => entryPath); const prev = prevVisiblePathsRef.current; if ( currentPaths.length === prev.length && currentPaths.every((p, i) => p === prev[i]) ) { return; } prevVisiblePathsRef.current = currentPaths; sftpTreeSelectionStore.setVisibleItems( pane.id, flatVisibleNodes .filter(({ entry }) => entry.name !== '..') .map(({ entry, entryPath }) => ({ path: entryPath, name: entry.name, isDirectory: isNavigableDirectory(entry), sourcePath: getParentPath(entryPath), })), ); }, [flatVisibleNodes, pane.id]); useEffect(() => { return () => { sftpTreeSelectionStore.clearPane(pane.id); }; }, [pane.id]); // Subscribe to tree Enter key actions from the keyboard shortcut hook useEffect(() => { return sftpTreeEnterStore.subscribe(() => { const action = sftpTreeEnterStore.get(); if (!action || action.paneId !== pane.id) return; sftpTreeEnterStore.clear(); const entry = entryByPathRef.current.get(action.entryPath); if (!entry) return; if (entry.name === '..') { onNavigateUpRef.current(); } else if (action.isDirectory) { // Toggle expand for directories in tree view void toggleExpand(entry, action.entryPath); } else { // Open file onOpenEntryRef.current(entry, action.entryPath); } }); }, [pane.id, toggleExpand]); const getActionPaths = useCallback((entryPath: string) => { const selected = selectedPathsRef.current; return selected.has(entryPath) ? Array.from(selected) : [entryPath]; }, []); const toTransferSources = useCallback((paths: string[]): SftpTransferSource[] => { const sources: SftpTransferSource[] = []; for (const path of paths) { const entry = entryByPathRef.current.get(path); if (!entry || entry.name === '..') continue; sources.push({ name: entry.name, isDirectory: isNavigableDirectory(entry), sourceConnectionId: pane.connection?.id, sourcePath: getParentPath(path), }); } return sources; }, [pane.connection?.id]); const stableOnOpenEntry = useCallback((entry: SftpFileEntry, entryPath: string) => { openTreeEntry(entry, entryPath); }, [openTreeEntry]); const stableOnDragStart = useCallback((entry: SftpFileEntry, entryPath: string, isDir: boolean, e: React.DragEvent) => { const files = toTransferSources(getActionPaths(entryPath)); if (files.length === 0) { files.push({ name: entry.name, isDirectory: isDir, sourceConnectionId: pane.connection?.id, sourcePath: getParentPath(entryPath), }); } e.dataTransfer.effectAllowed = 'copyMove'; e.dataTransfer.setData('text/plain', files.map((f) => f.name).join('\n')); onDragStartRef.current(files, sideRef.current); }, [getActionPaths, pane.connection?.id, toTransferSources]); const stableOnDragEnd = useCallback(() => onDragEndRef.current(), []); const applyLocalMoveMutation = useCallback(( sourceParentPaths: string[], targetPath: string, movedEntries: SftpFileEntry[], ) => { if (movedEntries.length === 0) return; const currentPath = pane.connection?.currentPath ?? ''; const movedNameSet = new Set(movedEntries.map((entry) => entry.name)); const uniqueSourceParents = Array.from(new Set(sourceParentPaths)); if (currentPath) { if (uniqueSourceParents.includes(currentPath)) { setRootEntries((prev) => prev.filter((entry) => !movedNameSet.has(entry.name))); } else if (currentPath === targetPath) { setRootEntries((prev) => { const next = [...prev]; for (const entry of movedEntries) { if (!next.some((candidate) => candidate.name === entry.name)) { next.push(entry); } } return next; }); } } for (const sourceParent of uniqueSourceParents) { if (sourceParent === currentPath) continue; const cached = childrenCacheRef.current.get(sourceParent); if (!cached) continue; childrenCacheRef.current.set( sourceParent, cached.filter((entry) => !movedNameSet.has(entry.name)), ); sortedChildrenCacheRef.current.delete(sourceParent); } if (targetPath !== currentPath) { const targetCache = childrenCacheRef.current.get(targetPath); if (targetCache) { const next = [...targetCache]; for (const entry of movedEntries) { if (!next.some((candidate) => candidate.name === entry.name)) { next.push(entry); } } childrenCacheRef.current.set(targetPath, next); sortedChildrenCacheRef.current.delete(targetPath); } } }, [pane.connection?.currentPath]); const executeMoveAction = useCallback(async (sourcePaths: string[], targetPath: string) => { try { await onMoveEntriesToPathRef.current(sourcePaths, targetPath); const sourceParents = sourcePaths.map((p) => getParentPath(p)); const movedEntries = sourcePaths .map((p) => entryByPathRef.current.get(p)) .filter((e): e is SftpFileEntry => Boolean(e)); applyLocalMoveMutation(sourceParents, targetPath, movedEntries); const syncTargets = Array.from(new Set( [targetPath, ...sourceParents].filter((p) => p && expandedPathsRef.current.has(p)), )); if (syncTargets.length > 0) void reloadExpandedPaths(syncTargets); } catch { throw new Error('Move failed'); } }, [applyLocalMoveMutation, reloadExpandedPaths]); const fetchMoveToSuggestions = useCallback((inputPath: string) => { if (moveToSuggestionsTimerRef.current) clearTimeout(moveToSuggestionsTimerRef.current); if (!inputPath.trim()) { setMoveToSuggestions([]); return; } const parentDir = inputPath.endsWith('/') || inputPath.endsWith('\\') ? inputPath : getParentPath(inputPath); const prefix = inputPath.endsWith('/') || inputPath.endsWith('\\') ? '' : inputPath.split(/[/\\]/).pop()?.toLowerCase() ?? ''; moveToSuggestionsTimerRef.current = setTimeout(async () => { try { const entries = await onLoadChildrenRef.current(parentDir); const dirs = entries .filter((e) => isNavigableDirectory(e) && e.name !== '..') .map((e) => joinPath(parentDir, e.name)) .filter((p) => !prefix || p.split(/[/\\]/).pop()!.toLowerCase().startsWith(prefix)); setMoveToSuggestions(dirs.slice(0, 8)); } catch { setMoveToSuggestions([]); } }, 200); }, []); const handleMoveToSubmit = useCallback(async () => { const target = moveToPath.trim(); if (!target || isMoving) return; setIsMoving(true); setMoveToError(null); try { // Validate the target directory exists by listing it await onLoadChildrenRef.current(target); await executeMoveAction(moveTargetPaths, target); setShowMoveToDialog(false); } catch { setMoveToError(tRef.current('sftp.moveTo.pathNotFound')); } finally { setIsMoving(false); } }, [moveToPath, isMoving, executeMoveAction, moveTargetPaths]); const getSamePaneDragPaths = useCallback((): string[] | null => { const dragged = draggedFilesRef.current; if (!dragged || dragged.length === 0) return null; if (dragged[0]?.side !== sideRef.current) return null; const currentConnectionId = pane.connection?.id; const paths = dragged .filter((file) => file.sourceConnectionId === currentConnectionId && file.sourcePath) .map((file) => joinPath(file.sourcePath!, file.name)); return paths.length > 0 ? paths : null; }, [pane.connection?.id]); // ── External file drag-over/drop handlers for tree directory nodes ── const handleNodeDragOver = useCallback((entryPath: string, e: React.DragEvent) => { const entry = entryByPathRef.current.get(entryPath); if (!entry) return; const isDir = isNavigableDirectory(entry); const samePaneDragPaths = getSamePaneDragPaths(); if (samePaneDragPaths && isDir && entry.name !== '..') { e.preventDefault(); e.stopPropagation(); e.dataTransfer.dropEffect = 'move'; setDragOverNodePath(entryPath); return; } const isInternalDrag = draggedFilesRef.current && draggedFilesRef.current[0]?.side !== sideRef.current; if (isInternalDrag && isDir && entry.name !== '..') { e.preventDefault(); e.stopPropagation(); e.dataTransfer.dropEffect = 'copy'; setDragOverNodePath(entryPath); return; } const hasFiles = e.dataTransfer.types.includes('Files'); if (hasFiles && isDir && entry.name !== '..') { e.preventDefault(); e.stopPropagation(); e.dataTransfer.dropEffect = 'copy'; setDragOverNodePath(entryPath); } }, [getSamePaneDragPaths]); const handleNodeDrop = useCallback((entryPath: string, e: React.DragEvent) => { const entry = entryByPathRef.current.get(entryPath); if (!entry) return; const isDir = isNavigableDirectory(entry); const samePaneDragPaths = getSamePaneDragPaths(); if (samePaneDragPaths && isDir && entry.name !== '..') { e.preventDefault(); e.stopPropagation(); setDragOverNodePath(null); const movedEntries = samePaneDragPaths .map((path) => entryByPathRef.current.get(path)) .filter((value): value is SftpFileEntry => Boolean(value)); const sourceParents = samePaneDragPaths.map((path) => getParentPath(path)); void (async () => { try { await onMoveEntriesToPathRef.current(samePaneDragPaths, entryPath); applyLocalMoveMutation(sourceParents, entryPath, movedEntries); const syncTargets = Array.from( new Set( [entryPath, ...sourceParents].filter((path) => path && expandedPathsRef.current.has(path)), ), ); if (syncTargets.length > 0) { void reloadExpandedPaths(syncTargets); } } catch { // Leave the tree untouched when the move fails. } })(); return; } const hasFiles = e.dataTransfer.types.includes('Files'); const isInternalDrag = draggedFilesRef.current && draggedFilesRef.current[0]?.side !== sideRef.current; if (isInternalDrag && isDir && entry.name !== '..') { e.preventDefault(); e.stopPropagation(); setDragOverNodePath(null); onReceiveFromOtherPaneRef.current( draggedFilesRef.current.map((file) => ({ ...file, targetPath: entryPath })), ); return; } if (hasFiles && isDir && entry.name !== '..') { e.preventDefault(); e.stopPropagation(); setDragOverNodePath(null); if (onUploadExternalFilesRef.current) { void onUploadExternalFilesRef.current(e.dataTransfer, entryPath); } } }, [applyLocalMoveMutation, getSamePaneDragPaths, reloadExpandedPaths]); const handleNodeDragLeave = useCallback(() => { setDragOverNodePath(null); }, []); // ── Shared context menu handler (called by each TreeNode) ──────── const handleNodeContextMenu = useCallback((entry: SftpFileEntry, entryPath: string, _e: React.MouseEvent) => { // Store the right-clicked target; the native contextmenu event bubbles up // to the Radix ContextMenuTrigger wrapping the scroll area. setContextTarget({ entry, entryPath }); }, []); // ── Virtual scrolling computation ──────────────────────────────── const { totalHeight, visibleRange } = useMemo(() => { const totalCount = nodeDescriptors.length; const total = totalCount * TREE_ROW_HEIGHT; const shouldVirtualize = viewportHeight > 0 && totalCount > 50; if (!shouldVirtualize) { return { totalHeight: 0, visibleRange: { start: 0, end: totalCount - 1, virtualized: false } }; } const overscan = 6; const start = Math.max(0, Math.floor(scrollTop / TREE_ROW_HEIGHT) - overscan); const end = Math.min(totalCount - 1, Math.ceil((scrollTop + viewportHeight) / TREE_ROW_HEIGHT) + overscan); return { totalHeight: total, visibleRange: { start, end, virtualized: true } }; }, [nodeDescriptors.length, scrollTop, viewportHeight]); // ── Render visible rows ────────────────────────────────────────── const treeRows = useMemo(() => { const { start, end, virtualized } = visibleRange; const rows: React.ReactNode[] = []; for (let i = start; i <= end; i++) { const descriptor = nodeDescriptors[i]; if (!descriptor) continue; let content: React.ReactNode; if (descriptor.type === 'loading') { content = (
{tRef.current('sftp.tree.loading')}
); } else if (descriptor.type === 'error') { content = (
{tRef.current('sftp.tree.loadError')}
); } else { content = ( ); } const key = descriptor.type === 'node' ? descriptor.entryPath : descriptor.key; if (virtualized) { rows.push(
{content}
, ); } else { rows.push({content}); } } return rows; }, [ visibleRange, nodeDescriptors, columnTemplate, selectedPaths, dragOverNodePath, toggleExpand, handleNodeClick, stableOnOpenEntry, stableOnDragStart, stableOnDragEnd, handleNodeDragOver, handleNodeDrop, handleNodeDragLeave, handleNodeContextMenu, ]); // ── Shared context menu content (single instance) ──────────────── const contextMenuContent = useMemo(() => { const target = contextTarget; if (!target) return null; const { entry, entryPath } = target; const isDir = isNavigableDirectory(entry); const isLocal = pane.connection?.isLocal; const handleOpen = () => { if (isDir) void toggleExpand(entry, entryPath); else stableOnOpenEntry(entry, entryPath); }; const handleCopyToOtherPane = () => { const paths = getActionPaths(entryPath); const files = toTransferSources(paths); if (files.length === 0) { files.push({ name: entry.name, isDirectory: isDir, sourceConnectionId: pane.connection?.id, sourcePath: getParentPath(entryPath), }); } onCopyToOtherPaneRef.current(files); }; const handleDelete = () => { openDeleteConfirmRef.current(getActionPaths(entryPath)); }; return ( {isDir ? <>{tRef.current('sftp.context.open')} : <>{tRef.current('sftp.context.open')}} {isDir && ( onNavigateToRef.current(entryPath)}> {tRef.current('sftp.context.navigateTo')} )} {!isDir && onOpenFileWithRef.current && ( onOpenFileWithRef.current?.(entry, entryPath)}> {tRef.current('sftp.context.openWith')} )} {!isDir && !isKnownBinaryFile(entry.name) && onEditFileRef.current && ( onEditFileRef.current?.(entry, entryPath)}> {tRef.current('sftp.context.edit')} )} {onDownloadFileRef.current && (!isDir || !isLocal) && ( onDownloadFileRef.current?.(entry, entryPath)}> {tRef.current('sftp.context.download')} )} {tRef.current('sftp.context.copyToOtherPane')} navigator.clipboard.writeText(entryPath)}> {tRef.current('sftp.context.copyPath')} {(() => { const sourceParent = getParentPath(entryPath); const targetParent = getParentPath(sourceParent); if (sourceParent === targetParent) return null; return ( { const paths = getActionPaths(entryPath); void executeMoveAction(paths, targetParent); }}> {tRef.current('sftp.context.moveToParent')} ); })()} { setMoveTargetPaths(getActionPaths(entryPath)); setMoveToPath(''); setMoveToError(null); setMoveToSuggestions([]); setMoveToSuggestionIndex(-1); setIsMoving(false); setShowMoveToDialog(true); }}> {tRef.current('sftp.context.moveTo')} openRenameDialogRef.current(entryPath)}> {tRef.current('common.rename')} {onEditPermissionsRef.current && !isLocal && ( onEditPermissionsRef.current?.(entry, entryPath)}> {tRef.current('sftp.context.permissions')} )} {tRef.current('action.delete')} {tRef.current('common.refresh')} openNewFolderDialogRef.current(isDir ? entryPath : getParentPath(entryPath))}> {tRef.current('sftp.newFolder')} openNewFileDialogRef.current(isDir ? entryPath : getParentPath(entryPath))}> {tRef.current('sftp.newFile')} {uploadEnabled && ( { triggerUploadPicker(getSftpTreeUploadFilesTargetPath(entry, entryPath)); }} > {tRef.current(getSftpUploadFilesLabelKey(entry))} )} {folderUploadEnabled && ( { void onUploadExternalFolder?.(getSftpTreeUploadFilesTargetPath(entry, entryPath)); }} > {tRef.current(getSftpUploadFolderLabelKey(entry))} )} ); }, [ contextTarget, pane.connection?.isLocal, pane.connection?.id, toggleExpand, stableOnOpenEntry, stableOnRefresh, getActionPaths, toTransferSources, executeMoveAction, triggerUploadPicker, uploadEnabled, folderUploadEnabled, onUploadExternalFolder, ]); return (
handleSort('name')} > {t('sftp.columns.name')} {sortField === 'name' && ( {sortOrder === 'asc' ? '↑' : '↓'} )}
handleResizeStart('name', e)} />
handleSort('modified')} > {t('sftp.columns.modified')} {sortField === 'modified' && ( {sortOrder === 'asc' ? '↑' : '↓'} )}
handleResizeStart('modified', e)} />
handleSort('size')} > {sortField === 'size' && ( {sortOrder === 'asc' ? '↑' : '↓'} )} {t('sftp.columns.size')}
handleResizeStart('size', e)} />
handleSort('type')} > {sortField === 'type' && ( {sortOrder === 'asc' ? '↑' : '↓'} )} {t('sftp.columns.kind')}
{pane.error && !pane.reconnecting && pane.files.length === 0 ? (
{t(pane.error)}
) : (
{treeRows}
)}
{contextMenuContent}
{uploadEnabled && ( )} {pane.loading && !pane.reconnecting && (
{pane.connectionLogs.length > 0 && (
{pane.connectionLogs.map((log, i) => (
{log}
))}
)}
)} {pane.reconnecting && (
{t('sftp.reconnecting.title')}
{t('sftp.reconnecting.desc')}
)} { if (!open) { setShowMoveToDialog(false); setMoveToSuggestions([]); setMoveToSuggestionIndex(-1); } }}> {t('sftp.moveTo.title')}
{ const val = e.target.value; setMoveToPath(val); setMoveToError(null); setMoveToSuggestionIndex(-1); fetchMoveToSuggestions(val); }} onKeyDown={(e) => { if (e.key === 'ArrowDown' && moveToSuggestions.length > 0) { e.preventDefault(); setMoveToSuggestionIndex((i) => i < moveToSuggestions.length - 1 ? i + 1 : 0); } else if (e.key === 'ArrowUp' && moveToSuggestions.length > 0) { e.preventDefault(); setMoveToSuggestionIndex((i) => i > 0 ? i - 1 : moveToSuggestions.length - 1); } else if (e.key === 'Tab' && moveToSuggestionIndex >= 0) { e.preventDefault(); const selected = moveToSuggestions[moveToSuggestionIndex]; setMoveToPath(selected); setMoveToError(null); fetchMoveToSuggestions(selected); } else if (e.key === 'Enter') { e.preventDefault(); if (moveToSuggestionIndex >= 0 && moveToSuggestions[moveToSuggestionIndex]) { const selected = moveToSuggestions[moveToSuggestionIndex]; setMoveToPath(selected); setMoveToSuggestionIndex(-1); setMoveToSuggestions([]); setMoveToError(null); } else { void handleMoveToSubmit(); } } else if (e.key === 'Escape') { if (moveToSuggestions.length > 0) { e.preventDefault(); e.stopPropagation(); setMoveToSuggestions([]); setMoveToSuggestionIndex(-1); } // When no suggestions, let the Dialog handle ESC to close itself } }} placeholder={t('sftp.moveTo.placeholder')} autoFocus className={moveToError ? 'border-destructive' : undefined} /> {moveToSuggestions.length > 0 && (
{moveToSuggestions.map((suggestion, i) => (
{ e.preventDefault(); setMoveToPath(suggestion); setMoveToSuggestions([]); setMoveToSuggestionIndex(-1); setMoveToError(null); }} > {suggestion}
))}
)}
{moveToError && (

{moveToError}

)}
); }); SftpPaneTreeView.displayName = 'SftpPaneTreeView';