[Init] Initial commit - NetMesh terminal manager

components/sftp/hooks/useSftpPanePath.ts

@@ -0,0 +1,164 @@
+import React, { useCallback, useMemo, useRef, useState } from "react";
+import type { SftpFileEntry } from "../../../types";
+import type { SftpPane } from "../../../application/state/sftp/types";
+import {
+  isWindowsPath,
+  normalizeSftpNavigationPath,
+} from "../../../application/state/sftp/utils";
+import { filterHiddenFiles, isNavigableDirectory } from "../utils";
+
+interface UseSftpPanePathParams {
+  connection: SftpPane["connection"] | null;
+  files: SftpFileEntry[];
+  showHiddenFiles: boolean;
+  onNavigateTo: (path: string) => void;
+}
+
+interface UseSftpPanePathResult {
+  isEditingPath: boolean;
+  editingPathValue: string;
+  showPathSuggestions: boolean;
+  pathSuggestionIndex: number;
+  pathInputRef: React.RefObject<HTMLInputElement>;
+  pathDropdownRef: React.RefObject<HTMLDivElement>;
+  pathSuggestions: { path: string; type: "folder" | "history" }[];
+  setEditingPathValue: (value: string) => void;
+  setShowPathSuggestions: (value: boolean) => void;
+  setPathSuggestionIndex: (value: number) => void;
+  handlePathBlur: () => void;
+  handlePathKeyDown: (e: React.KeyboardEvent) => void;
+  handlePathDoubleClick: () => void;
+  handlePathSubmit: (pathOverride?: string) => void;
+}
+
+export const useSftpPanePath = ({
+  connection,
+  files,
+  showHiddenFiles,
+  onNavigateTo,
+}: UseSftpPanePathParams): UseSftpPanePathResult => {
+  const [isEditingPath, setIsEditingPath] = useState(false);
+  const [editingPathValue, setEditingPathValue] = useState("");
+  const [showPathSuggestions, setShowPathSuggestions] = useState(false);
+  const [pathSuggestionIndex, setPathSuggestionIndex] = useState(-1);
+  const pathInputRef = useRef<HTMLInputElement>(null);
+  const pathDropdownRef = useRef<HTMLDivElement>(null);
+
+  const pathSuggestions = useMemo(() => {
+    if (!isEditingPath || !connection) return [];
+    const currentValue = editingPathValue.trim().toLowerCase();
+    const suggestions: { path: string; type: "folder" | "history" }[] = [];
+
+    const folders = filterHiddenFiles(files, showHiddenFiles).filter(
+      (f) => isNavigableDirectory(f) && f.name !== "..",
+    );
+    folders.forEach((f) => {
+      const fullPath =
+        connection.currentPath === "/"
+          ? `/${f.name}`
+          : `${connection.currentPath}/${f.name}`;
+      if (
+        !currentValue ||
+        fullPath.toLowerCase().includes(currentValue) ||
+        f.name.toLowerCase().includes(currentValue)
+      ) {
+        suggestions.push({ path: fullPath, type: "folder" });
+      }
+    });
+
+    const quickPaths = ["/home", "/var", "/etc", "/tmp", "/usr", "/opt", "/root"];
+    quickPaths.forEach((qp) => {
+      if (!currentValue || qp.toLowerCase().includes(currentValue)) {
+        if (!suggestions.some((s) => s.path === qp)) {
+          suggestions.push({ path: qp, type: "history" });
+        }
+      }
+    });
+
+    return suggestions.slice(0, 8);
+  }, [connection, editingPathValue, files, isEditingPath, showHiddenFiles]);
+
+  const handlePathDoubleClick = () => {
+    if (!connection) return;
+    setEditingPathValue(connection.currentPath);
+    setIsEditingPath(true);
+    setShowPathSuggestions(true);
+    setPathSuggestionIndex(-1);
+    setTimeout(() => pathInputRef.current?.select(), 0);
+  };
+
+  const handlePathSubmit = useCallback((pathOverride?: string) => {
+    // Only treat //host/share as UNC when this pane is already on a Windows-style path.
+    const acceptForwardSlashUnc = !!(
+      connection && isWindowsPath(connection.currentPath)
+    );
+    const newPath = normalizeSftpNavigationPath(
+      pathOverride ?? editingPathValue,
+      { acceptForwardSlashUnc },
+    );
+    setIsEditingPath(false);
+    setShowPathSuggestions(false);
+    setPathSuggestionIndex(-1);
+    if (connection && newPath !== connection.currentPath) {
+      onNavigateTo(newPath);
+    }
+  }, [connection, editingPathValue, onNavigateTo]);
+
+  const handlePathKeyDown = (e: React.KeyboardEvent) => {
+    if (showPathSuggestions && pathSuggestions.length > 0) {
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        setPathSuggestionIndex((prev) =>
+          prev < pathSuggestions.length - 1 ? prev + 1 : 0,
+        );
+        return;
+      } else if (e.key === "ArrowUp") {
+        e.preventDefault();
+        setPathSuggestionIndex((prev) =>
+          prev > 0 ? prev - 1 : pathSuggestions.length - 1,
+        );
+        return;
+      } else if (e.key === "Tab" && pathSuggestionIndex >= 0) {
+        e.preventDefault();
+        setEditingPathValue(pathSuggestions[pathSuggestionIndex].path);
+        return;
+      }
+    }
+    if (e.key === "Enter") {
+      if (pathSuggestionIndex >= 0 && pathSuggestions[pathSuggestionIndex]) {
+        handlePathSubmit(pathSuggestions[pathSuggestionIndex].path);
+      } else {
+        handlePathSubmit();
+      }
+    } else if (e.key === "Escape") {
+      setIsEditingPath(false);
+      setShowPathSuggestions(false);
+      setPathSuggestionIndex(-1);
+    }
+  };
+
+  const handlePathBlur = useCallback(() => {
+    setTimeout(() => {
+      if (!pathDropdownRef.current?.contains(document.activeElement)) {
+        handlePathSubmit();
+      }
+    }, 150);
+  }, [handlePathSubmit]);
+
+  return {
+    isEditingPath,
+    editingPathValue,
+    showPathSuggestions,
+    pathSuggestionIndex,
+    pathInputRef,
+    pathDropdownRef,
+    pathSuggestions,
+    setEditingPathValue,
+    setShowPathSuggestions,
+    setPathSuggestionIndex,
+    handlePathBlur,
+    handlePathKeyDown,
+    handlePathDoubleClick,
+    handlePathSubmit,
+  };
+};