mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-17 13:01:24 +00:00
- Add dialogActionScopeId to distinguish SftpView and SftpSidePanel dialog actions, preventing cross-instance interference - Refine selectionScope to clear tree selections per-pane instead of using clearAllExcept, avoiding side effects on other SFTP surfaces - Remove selection clearing from tab switch/move/add handlers; clearing now only happens on focus side change and file interaction - Reset keyboard selection and lastSelectedIndex when selections are externally cleared Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
605 lines
23 KiB
TypeScript
605 lines
23 KiB
TypeScript
/**
|
|
* useSftpKeyboardShortcuts
|
|
*
|
|
* Hook that handles keyboard shortcuts for SFTP operations.
|
|
* Supports copy, cut, paste, select all, rename, delete, refresh, and new folder.
|
|
*/
|
|
|
|
import { useCallback, useEffect } from "react";
|
|
import type { MutableRefObject } from "react";
|
|
import { KeyBinding, matchesKeyBinding } from "../../../domain/models";
|
|
import { getParentPath, joinPath } from "../../../application/state/sftp/utils";
|
|
import { sftpClipboardStore, SftpClipboardFile } from "./useSftpClipboard";
|
|
import { sftpFocusStore } from "./useSftpFocusedPane";
|
|
import { sftpDialogActionStore } from "./useSftpDialogAction";
|
|
import { sftpTreeSelectionStore } from "./useSftpTreeSelectionStore";
|
|
import { sftpListOrderStore } from "./useSftpListOrderStore";
|
|
import { keepOnlyPaneSelections } from "./selectionScope";
|
|
import type { SftpStateApi } from "../../../application/state/useSftpState";
|
|
import { filterHiddenFiles, isNavigableDirectory } from "../index";
|
|
import type { SftpFileEntry } from "../../../types";
|
|
import { toast } from "../../ui/toast";
|
|
|
|
// SFTP action names that we handle
|
|
const SFTP_ACTIONS = new Set([
|
|
"sftpCopy",
|
|
"sftpCut",
|
|
"sftpPaste",
|
|
"sftpSelectAll",
|
|
"sftpRename",
|
|
"sftpDelete",
|
|
"sftpRefresh",
|
|
"sftpNewFolder",
|
|
"sftpOpen",
|
|
"sftpGoParent",
|
|
"sftpNavigateTo",
|
|
]);
|
|
|
|
// ── Tree Enter key action store ──────────────────────────────────────
|
|
// Allows the keyboard shortcut hook to signal tree views to handle Enter.
|
|
|
|
type TreeEnterListener = () => void;
|
|
|
|
interface TreeEnterAction {
|
|
paneId: string;
|
|
entryPath: string;
|
|
isDirectory: boolean;
|
|
timestamp: number;
|
|
}
|
|
|
|
let _treeEnterAction: TreeEnterAction | null = null;
|
|
const _treeEnterListeners = new Set<TreeEnterListener>();
|
|
const notifyTreeEnterListeners = () => _treeEnterListeners.forEach((l) => l());
|
|
|
|
export const sftpTreeEnterStore = {
|
|
trigger: (paneId: string, entryPath: string, isDirectory: boolean) => {
|
|
_treeEnterAction = { paneId, entryPath, isDirectory, timestamp: Date.now() };
|
|
notifyTreeEnterListeners();
|
|
},
|
|
get: () => _treeEnterAction,
|
|
clear: () => {
|
|
_treeEnterAction = null;
|
|
notifyTreeEnterListeners();
|
|
},
|
|
subscribe: (listener: TreeEnterListener) => {
|
|
_treeEnterListeners.add(listener);
|
|
return () => { _treeEnterListeners.delete(listener); };
|
|
},
|
|
getSnapshot: () => _treeEnterAction,
|
|
};
|
|
|
|
// ── Keyboard selection anchor/focus tracking ────────────────────────
|
|
// Tracks the anchor (where Shift-selection started) and focus (cursor)
|
|
// indices per pane so Shift+Arrow extends correctly.
|
|
const _kbSelectionState = new Map<string, { anchor: number; focus: number }>();
|
|
|
|
export const sftpKeyboardSelectionStore = {
|
|
get: (paneId: string) => _kbSelectionState.get(paneId) ?? { anchor: 0, focus: 0 },
|
|
set: (paneId: string, anchor: number, focus: number) => {
|
|
_kbSelectionState.set(paneId, { anchor, focus });
|
|
},
|
|
clear: (paneId: string) => {
|
|
_kbSelectionState.delete(paneId);
|
|
},
|
|
};
|
|
|
|
// Basic navigation keys that work even when custom hotkeys are disabled.
|
|
const BASIC_NAV_KEYS: Record<string, string> = {
|
|
'Enter': 'sftpOpen',
|
|
'Backspace': 'sftpGoParent',
|
|
};
|
|
|
|
interface UseSftpKeyboardShortcutsParams {
|
|
keyBindings: KeyBinding[];
|
|
hotkeyScheme: "disabled" | "mac" | "pc";
|
|
sftpRef: MutableRefObject<SftpStateApi>;
|
|
dialogActionScopeId: string;
|
|
isActive: boolean;
|
|
}
|
|
|
|
/**
|
|
* Check if a keyboard event matches any SFTP action
|
|
*/
|
|
const matchSftpAction = (
|
|
e: KeyboardEvent,
|
|
keyBindings: KeyBinding[],
|
|
isMac: boolean
|
|
): { action: string; binding: KeyBinding } | null => {
|
|
for (const binding of keyBindings) {
|
|
if (binding.category !== "sftp") continue;
|
|
const keyStr = isMac ? binding.mac : binding.pc;
|
|
if (matchesKeyBinding(e, keyStr, isMac)) {
|
|
return { action: binding.action, binding };
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
export const useSftpKeyboardShortcuts = ({
|
|
keyBindings,
|
|
hotkeyScheme,
|
|
sftpRef,
|
|
dialogActionScopeId,
|
|
isActive,
|
|
}: UseSftpKeyboardShortcutsParams) => {
|
|
const handleKeyDown = useCallback(
|
|
async (e: KeyboardEvent) => {
|
|
// Basic SFTP keyboard navigation should work whenever the SFTP tab is active,
|
|
// even if the user has disabled global/custom hotkeys.
|
|
if (!isActive) return;
|
|
|
|
// Skip if focus is on an input element
|
|
const target = e.target as HTMLElement;
|
|
const isEditableTarget =
|
|
target.tagName === "INPUT" ||
|
|
target.tagName === "TEXTAREA" ||
|
|
target.isContentEditable ||
|
|
!!target.closest?.(".monaco-editor, .monaco-diff-editor, .monaco-inputbox");
|
|
if (isEditableTarget) {
|
|
return;
|
|
}
|
|
|
|
// Skip when a dialog or overlay is open to prevent SFTP shortcuts from
|
|
// firing while interacting with unrelated dialogs (e.g. settings, confirm).
|
|
if (document.querySelector('[role="dialog"][data-state="open"]')) {
|
|
return;
|
|
}
|
|
|
|
// ── Arrow Up/Down: move selection ────────────────────────────────
|
|
if ((e.key === 'ArrowUp' || e.key === 'ArrowDown') && !e.ctrlKey && !e.metaKey && !e.altKey) {
|
|
const sftp = sftpRef.current;
|
|
const focusedSide = sftpFocusStore.getFocusedSide();
|
|
const pane = focusedSide === "left"
|
|
? sftp.leftTabs.tabs.find(p => p.id === sftp.leftTabs.activeTabId)
|
|
: sftp.rightTabs.tabs.find(p => p.id === sftp.rightTabs.activeTabId);
|
|
if (!pane || !pane.connection) return;
|
|
|
|
const delta = e.key === 'ArrowDown' ? 1 : -1;
|
|
|
|
// List view: navigate sorted display files.
|
|
// Prefer the list store when it exists so stale tree selection state
|
|
// cannot swallow keyboard navigation after switching views.
|
|
const listItems = sftpListOrderStore.getItems(pane.id);
|
|
if (listItems.length > 0) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
|
|
// Resolve current focus position from tracked state, falling back
|
|
// to the actual selection when out of sync (e.g. after mouse click).
|
|
let { anchor: anchorIdx, focus: focusIdx } = sftpKeyboardSelectionStore.get(pane.id);
|
|
const currentSelected = Array.from(pane.selectedFiles) as string[];
|
|
if (currentSelected.length === 0) {
|
|
// No selection: start from before the list so the first arrow press lands on item 0.
|
|
// For Shift+Arrow, anchor at 0 so range selection starts from the first item.
|
|
anchorIdx = e.shiftKey ? 0 : -1;
|
|
focusIdx = -1;
|
|
} else if (!currentSelected.includes(listItems[focusIdx])) {
|
|
// Tracked focus doesn't match actual selection, re-sync
|
|
focusIdx = listItems.indexOf(currentSelected[currentSelected.length - 1]);
|
|
if (focusIdx < 0) focusIdx = 0;
|
|
anchorIdx = focusIdx;
|
|
sftpKeyboardSelectionStore.set(pane.id, anchorIdx, focusIdx);
|
|
}
|
|
|
|
let nextIdx = focusIdx + delta;
|
|
if (nextIdx < 0) nextIdx = 0;
|
|
if (nextIdx >= listItems.length) nextIdx = listItems.length - 1;
|
|
|
|
keepOnlyPaneSelections(sftp, { side: focusedSide, tabId: pane.id });
|
|
if (e.shiftKey) {
|
|
// Shift+Arrow: extend range from anchor to new focus
|
|
const start = Math.min(anchorIdx, nextIdx);
|
|
const end = Math.max(anchorIdx, nextIdx);
|
|
sftp.rangeSelect(focusedSide, listItems.slice(start, end + 1));
|
|
sftpKeyboardSelectionStore.set(pane.id, anchorIdx, nextIdx);
|
|
} else {
|
|
sftp.rangeSelect(focusedSide, [listItems[nextIdx]]);
|
|
sftpKeyboardSelectionStore.set(pane.id, nextIdx, nextIdx);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Tree view: navigate visible items
|
|
const treeState = sftpTreeSelectionStore.getPaneState(pane.id);
|
|
if (treeState.visibleItems.length > 0) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
const items = treeState.visibleItems;
|
|
const currentSelected = [...treeState.selectedPaths];
|
|
|
|
// Use tracked state, re-sync if needed
|
|
let { anchor: anchorIdx, focus: focusIdx } = sftpKeyboardSelectionStore.get(pane.id);
|
|
if (currentSelected.length === 0) {
|
|
// No selection: start from before the list so the first arrow press lands on item 0.
|
|
// For Shift+Arrow, anchor at 0 so range selection starts from the first item.
|
|
anchorIdx = e.shiftKey ? 0 : -1;
|
|
focusIdx = -1;
|
|
} else {
|
|
const focusPath = items[focusIdx]?.path;
|
|
if (!focusPath || !treeState.selectedPaths.has(focusPath)) {
|
|
focusIdx = treeState.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;
|
|
|
|
keepOnlyPaneSelections(sftp, { side: focusedSide, tabId: pane.id });
|
|
if (e.shiftKey) {
|
|
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);
|
|
}
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Basic navigation actions (Enter, Backspace) must work even when
|
|
// custom hotkeys are disabled — they are essential SFTP navigation.
|
|
// When hotkeys are enabled, defer to matchSftpAction so user
|
|
// customizations are respected.
|
|
const basicNavAction = hotkeyScheme === "disabled" && !e.ctrlKey && !e.metaKey && !e.altKey && !e.shiftKey
|
|
? BASIC_NAV_KEYS[e.key]
|
|
: undefined;
|
|
|
|
if (hotkeyScheme === "disabled" && !basicNavAction) return;
|
|
|
|
const isMac = hotkeyScheme === "mac";
|
|
const matched = basicNavAction ? null : matchSftpAction(e, keyBindings, isMac);
|
|
if (!matched && !basicNavAction) return;
|
|
|
|
const action = basicNavAction ?? matched?.action;
|
|
if (!action || !SFTP_ACTIONS.has(action)) return;
|
|
|
|
// Prevent default behavior
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
|
|
const sftp = sftpRef.current;
|
|
const focusedSide = sftpFocusStore.getFocusedSide();
|
|
|
|
// Get the active pane for the focused side
|
|
const pane = focusedSide === "left"
|
|
? sftp.leftTabs.tabs.find(p => p.id === sftp.leftTabs.activeTabId)
|
|
: sftp.rightTabs.tabs.find(p => p.id === sftp.rightTabs.activeTabId);
|
|
|
|
if (!pane || !pane.connection) return;
|
|
const treeSelectionState = sftpTreeSelectionStore.getPaneState(pane.id);
|
|
const treeSelection = sftpTreeSelectionStore.getSelectedItems(pane.id);
|
|
const treeActionSelection = treeSelection.filter((entry) => entry.name !== '..');
|
|
|
|
switch (action) {
|
|
case "sftpCopy": {
|
|
if (treeActionSelection.length > 0) {
|
|
const parentPaths = new Set(treeActionSelection.map((entry) => getParentPath(entry.path)));
|
|
if (parentPaths.size !== 1) {
|
|
toast.info("Tree selection across multiple folders can't be copied with shortcuts yet.", "SFTP");
|
|
return;
|
|
}
|
|
|
|
const clipboardFiles: SftpClipboardFile[] = treeActionSelection.map((entry) => ({
|
|
name: entry.name,
|
|
isDirectory: entry.isDirectory,
|
|
}));
|
|
|
|
sftpClipboardStore.copy(
|
|
clipboardFiles,
|
|
Array.from(parentPaths)[0],
|
|
pane.connection.id,
|
|
focusedSide,
|
|
);
|
|
break;
|
|
}
|
|
|
|
// Copy selected files to clipboard
|
|
const selectedFiles = Array.from(pane.selectedFiles) as string[];
|
|
if (selectedFiles.length === 0) return;
|
|
|
|
{
|
|
const filesByName = new Map((pane.files as SftpFileEntry[]).map(f => [f.name, f]));
|
|
const clipboardFiles: SftpClipboardFile[] = selectedFiles.map((name: string) => {
|
|
const file = filesByName.get(name);
|
|
return {
|
|
name,
|
|
isDirectory: file ? isNavigableDirectory(file) : false,
|
|
};
|
|
});
|
|
|
|
sftpClipboardStore.copy(
|
|
clipboardFiles,
|
|
pane.connection.currentPath,
|
|
pane.connection.id,
|
|
focusedSide
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case "sftpCut": {
|
|
if (treeActionSelection.length > 0) {
|
|
const parentPaths = new Set(treeActionSelection.map((entry) => getParentPath(entry.path)));
|
|
if (parentPaths.size !== 1) {
|
|
toast.info("Tree selection across multiple folders can't be cut with shortcuts yet.", "SFTP");
|
|
return;
|
|
}
|
|
|
|
const clipboardFiles: SftpClipboardFile[] = treeActionSelection.map((entry) => ({
|
|
name: entry.name,
|
|
isDirectory: entry.isDirectory,
|
|
}));
|
|
|
|
sftpClipboardStore.cut(
|
|
clipboardFiles,
|
|
Array.from(parentPaths)[0],
|
|
pane.connection.id,
|
|
focusedSide,
|
|
);
|
|
break;
|
|
}
|
|
|
|
// Cut selected files to clipboard
|
|
const selectedFiles = Array.from(pane.selectedFiles) as string[];
|
|
if (selectedFiles.length === 0) return;
|
|
|
|
{
|
|
const filesByName = new Map((pane.files as SftpFileEntry[]).map(f => [f.name, f]));
|
|
const clipboardFiles: SftpClipboardFile[] = selectedFiles.map((name: string) => {
|
|
const file = filesByName.get(name);
|
|
return {
|
|
name,
|
|
isDirectory: file ? isNavigableDirectory(file) : false,
|
|
};
|
|
});
|
|
|
|
sftpClipboardStore.cut(
|
|
clipboardFiles,
|
|
pane.connection.currentPath,
|
|
pane.connection.id,
|
|
focusedSide
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case "sftpPaste": {
|
|
// Paste files from clipboard
|
|
const clipboard = sftpClipboardStore.get();
|
|
if (!clipboard || clipboard.files.length === 0) return;
|
|
|
|
// Use startTransfer to paste files from source to current pane
|
|
// Allow paste when source and target are different connections, even on the same side
|
|
const isSameConnection = clipboard.sourceSide === focusedSide
|
|
&& clipboard.sourceConnectionId === pane.connection.id;
|
|
if (!isSameConnection) {
|
|
const sourceTabs = clipboard.sourceSide === "left" ? sftp.leftTabs.tabs : sftp.rightTabs.tabs;
|
|
const sourcePane = sourceTabs.find((tab) => tab.connection?.id === clipboard.sourceConnectionId);
|
|
|
|
if (!sourcePane?.connection) {
|
|
toast.info("Paste source is no longer available.", "SFTP");
|
|
return;
|
|
}
|
|
|
|
// Cross-pane paste - use startTransfer
|
|
try {
|
|
const isCut = clipboard.operation === "cut";
|
|
const pendingNames = new Set(clipboard.files.map((file) => file.name));
|
|
const completedNames = new Set<string>();
|
|
const failedNames = new Set<string>();
|
|
|
|
const updateClipboardAfterCompletion = (showToast: boolean) => {
|
|
if (!isCut) return;
|
|
const current = sftpClipboardStore.get();
|
|
if (
|
|
!current ||
|
|
current.operation !== "cut" ||
|
|
current.sourceConnectionId !== clipboard.sourceConnectionId ||
|
|
current.sourcePath !== clipboard.sourcePath ||
|
|
current.sourceSide !== clipboard.sourceSide
|
|
) {
|
|
return;
|
|
}
|
|
|
|
const remainingFiles = current.files.filter((file) => !completedNames.has(file.name));
|
|
if (remainingFiles.length === 0) {
|
|
sftpClipboardStore.clear();
|
|
} else {
|
|
sftpClipboardStore.updateFiles(remainingFiles);
|
|
}
|
|
|
|
if (showToast && failedNames.size > 0) {
|
|
toast.info("Some items could not be transferred and were kept in the clipboard.", "SFTP");
|
|
}
|
|
};
|
|
|
|
const handleTransferComplete = async (result: {
|
|
fileName: string;
|
|
originalFileName?: string;
|
|
status: string;
|
|
}) => {
|
|
if (!isCut) return;
|
|
const sourceFileName = result.originalFileName ?? result.fileName;
|
|
if (!pendingNames.has(sourceFileName)) return;
|
|
pendingNames.delete(sourceFileName);
|
|
|
|
if (result.status === "completed") {
|
|
try {
|
|
await sftp.deleteFilesAtPath(
|
|
clipboard.sourceSide,
|
|
clipboard.sourceConnectionId,
|
|
clipboard.sourcePath,
|
|
[sourceFileName],
|
|
);
|
|
completedNames.add(sourceFileName);
|
|
} catch {
|
|
failedNames.add(sourceFileName);
|
|
}
|
|
} else {
|
|
failedNames.add(sourceFileName);
|
|
}
|
|
|
|
updateClipboardAfterCompletion(pendingNames.size === 0);
|
|
};
|
|
|
|
await sftp.startTransfer(clipboard.files, clipboard.sourceSide, focusedSide, {
|
|
sourcePane,
|
|
sourcePath: clipboard.sourcePath,
|
|
sourceConnectionId: clipboard.sourceConnectionId,
|
|
onTransferComplete: handleTransferComplete,
|
|
});
|
|
} catch {
|
|
toast.error("Paste failed. Please try again.", "SFTP");
|
|
}
|
|
} else {
|
|
// Same-pane paste is not supported - show info toast
|
|
toast.info("Paste within the same pane is not supported. Use copy to other pane instead.", "SFTP");
|
|
}
|
|
break;
|
|
}
|
|
|
|
case "sftpSelectAll": {
|
|
if (treeSelectionState.visibleItems.length > 0) {
|
|
keepOnlyPaneSelections(sftp, { side: focusedSide, tabId: pane.id });
|
|
sftpTreeSelectionStore.selectAllVisible(pane.id);
|
|
break;
|
|
}
|
|
|
|
// Select all files in the current pane
|
|
// TODO: Reference already-computed filtered files from useSftpPaneFiles
|
|
// instead of re-implementing the hidden file + filter logic here.
|
|
// This requires either lifting the computed files into pane state or
|
|
// passing them via a shared store, which needs a larger refactor.
|
|
const term = pane.filter.trim().toLowerCase();
|
|
let visibleFiles = filterHiddenFiles(pane.files, pane.showHiddenFiles);
|
|
if (term) {
|
|
visibleFiles = visibleFiles.filter(
|
|
(f) => f.name === ".." || f.name.toLowerCase().includes(term),
|
|
);
|
|
}
|
|
const allFileNames = visibleFiles
|
|
.filter((f) => f.name !== "..")
|
|
.map((f) => f.name);
|
|
keepOnlyPaneSelections(sftp, { side: focusedSide, tabId: pane.id });
|
|
sftp.rangeSelect(focusedSide, allFileNames);
|
|
break;
|
|
}
|
|
|
|
case "sftpRename": {
|
|
if (treeActionSelection.length === 1) {
|
|
sftpDialogActionStore.trigger("rename", dialogActionScopeId, [treeActionSelection[0].path]);
|
|
break;
|
|
}
|
|
|
|
// Trigger rename for the first selected file
|
|
const selectedFiles = Array.from(pane.selectedFiles) as string[];
|
|
if (selectedFiles.length !== 1) return;
|
|
sftpDialogActionStore.trigger("rename", dialogActionScopeId, selectedFiles);
|
|
break;
|
|
}
|
|
|
|
case "sftpDelete": {
|
|
if (treeActionSelection.length > 0) {
|
|
sftpDialogActionStore.trigger(
|
|
"delete",
|
|
dialogActionScopeId,
|
|
treeActionSelection.map((entry) => entry.path),
|
|
);
|
|
break;
|
|
}
|
|
|
|
// Delete selected files
|
|
const selectedFiles = Array.from(pane.selectedFiles) as string[];
|
|
if (selectedFiles.length === 0) return;
|
|
sftpDialogActionStore.trigger("delete", dialogActionScopeId, selectedFiles);
|
|
break;
|
|
}
|
|
|
|
case "sftpRefresh": {
|
|
// Refresh the current pane
|
|
sftp.refresh(focusedSide);
|
|
break;
|
|
}
|
|
|
|
case "sftpNewFolder": {
|
|
// Create new folder
|
|
sftpDialogActionStore.trigger("newFolder", dialogActionScopeId);
|
|
break;
|
|
}
|
|
|
|
case "sftpOpen": {
|
|
// Prefer list selection when the list store is active
|
|
const listItems = sftpListOrderStore.getItems(pane.id);
|
|
const selectedFiles = Array.from(pane.selectedFiles) as string[];
|
|
if (listItems.length > 0 && selectedFiles.length === 1) {
|
|
const fileName = selectedFiles[0];
|
|
const entry = (pane.files as SftpFileEntry[]).find(f => f.name === fileName);
|
|
if (entry) {
|
|
if (isNavigableDirectory(entry)) {
|
|
_kbSelectionState.delete(pane.id);
|
|
sftp.navigateTo(focusedSide, joinPath(pane.connection.currentPath, entry.name));
|
|
} else {
|
|
sftp.openEntry(focusedSide, entry);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Only fall through to tree view if list store is empty (tree view mode)
|
|
if (listItems.length > 0) break;
|
|
const treeOpenSelection = sftpTreeSelectionStore.getSelectedItems(pane.id);
|
|
if (treeOpenSelection.length === 1) {
|
|
const item = treeOpenSelection[0];
|
|
if (item.isDirectory) _kbSelectionState.delete(pane.id);
|
|
sftpTreeEnterStore.trigger(pane.id, item.path, item.isDirectory);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case "sftpGoParent": {
|
|
const parentPath = getParentPath(pane.connection.currentPath);
|
|
if (parentPath !== pane.connection.currentPath) {
|
|
_kbSelectionState.delete(pane.id);
|
|
sftp.navigateTo(focusedSide, parentPath);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case "sftpNavigateTo": {
|
|
// Navigate to the selected directory (useful in tree view)
|
|
// Filter out ".." entry for consistency with other handlers
|
|
if (treeActionSelection.length === 1 && treeActionSelection[0].isDirectory) {
|
|
_kbSelectionState.delete(pane.id);
|
|
sftp.navigateTo(focusedSide, treeActionSelection[0].path);
|
|
break;
|
|
}
|
|
// In list view, navigate to selected directory
|
|
const selectedFiles = Array.from(pane.selectedFiles) as string[];
|
|
if (selectedFiles.length === 1) {
|
|
const entry = (pane.files as SftpFileEntry[]).find(f => f.name === selectedFiles[0]);
|
|
if (entry && isNavigableDirectory(entry)) {
|
|
_kbSelectionState.delete(pane.id);
|
|
sftp.navigateTo(focusedSide, joinPath(pane.connection.currentPath, entry.name));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
[dialogActionScopeId, hotkeyScheme, isActive, keyBindings, sftpRef]
|
|
);
|
|
|
|
useEffect(() => {
|
|
// Use capture phase to intercept before other handlers
|
|
window.addEventListener("keydown", handleKeyDown, true);
|
|
return () => window.removeEventListener("keydown", handleKeyDown, true);
|
|
}, [handleKeyDown]);
|
|
};
|