ftreeview 0.1.1 → 0.1.3

package/src/hooks/useTree.js

@@ -57,6 +57,7 @@ function createFileNode(absPath, rootPath, depth, isDir, isSymlink = false) {
         absPath,
         isDir,
         children: null,
+        childrenLoaded: false,
         expanded: false,
         depth,
         size: 0,
@@ -77,6 +78,7 @@ function createFileNode(absPath, rootPath, depth, isDir, isSymlink = false) {
     absPath,
     isDir,
     children: isDir ? [] : null,
+    childrenLoaded: isDir ? false : undefined,
     expanded: false,
     depth,
     size: stats.size,
@@ -116,9 +118,10 @@ function compareNodes(a, b) {
  * @param {number} [currentDepth=0] - Current traversal depth (internal)
  * @param {object} [ignoreFilter] - Ignore filter instance (internal)
  * @param {string|null} [baseRootPath] - Absolute root path used for node.path (internal)
+ * @param {Set<string>|null} [expandedPaths] - Directory paths to pre-load (internal)
  * @returns {FileNode} The root FileNode of the tree
  */
-export function buildTree(rootPath, options = {}, currentDepth = 0, ignoreFilter = null, baseRootPath = null) {
+export function buildTree(rootPath, options = {}, currentDepth = 0, ignoreFilter = null, baseRootPath = null, expandedPaths = null) {
   const { depth = DEFAULT_CONFIG.maxDepth, showHidden = false } = options;
   const finalBaseRootPath = baseRootPath || rootPath;
 
@@ -136,6 +139,9 @@ export function buildTree(rootPath, options = {}, currentDepth = 0, ignoreFilter
     return rootNode;
   }
 
+  // Root directory children are always loaded (we're scanning it now).
+  rootNode.childrenLoaded = true;
+
   try {
     // Load .gitignore patterns for this directory
     if (ignoreFilter.loadPatternsForDirectory) {
@@ -207,17 +213,26 @@ export function buildTree(rootPath, options = {}, currentDepth = 0, ignoreFilter
         }
       }
 
-      // Recursively build subtree for directories (but not for symlinks to directories)
+      // Lazy-load subtrees:
+      // - Always load the current directory's children
+      // - Only recurse into subdirectories that are already expanded (from a preserved state rebuild)
       if (isDir && !isSymlink) {
-        const childOptions = { ...options, showHidden };
-        const subtree = buildTree(
-          entryAbsPath,
-          childOptions,
-          currentDepth + 1,
-          ignoreFilter,
-          finalBaseRootPath,
-        );
-        childNode.children = subtree.children;
+        const shouldRecurse = expandedPaths && expandedPaths.has(childNode.path);
+        if (shouldRecurse) {
+          const childOptions = { ...options, showHidden };
+          const subtree = buildTree(
+            entryAbsPath,
+            childOptions,
+            currentDepth + 1,
+            ignoreFilter,
+            finalBaseRootPath,
+            expandedPaths,
+          );
+          childNode.children = subtree.children;
+          childNode.childrenLoaded = true;
+        } else {
+          childNode.childrenLoaded = false;
+        }
       }
 
       rootNode.children.push(childNode);
@@ -287,39 +302,13 @@ export function applyGitStatus(root, statusMap) {
    * @param {FileNode} node - Current node being processed
    */
   function walk(node) {
-    if (!node.isDir) {
-      // File: lookup in statusMap, default to empty string (clean)
-      node.gitStatus = statusMap.get(node.path) || '';
-    } else {
-      // Directory: aggregate from children
-      let aggregatedStatus = '';
+    // Status maps can contain both file and directory paths (pre-aggregated).
+    node.gitStatus = statusMap.get(node.path) || '';
 
-      // First walk all children to populate their gitStatus
+    if (node.children && node.children.length > 0) {
       for (const child of node.children) {
         walk(child);
-
-        // Aggregate child status with priority ordering
-        const childStatus = child.gitStatus;
-
-        if (childStatus === 'D') {
-          // Deleted has highest priority
-          aggregatedStatus = 'D';
-        } else if (childStatus === 'M' && aggregatedStatus !== 'D') {
-          // Modified has second priority
-          aggregatedStatus = 'M';
-        } else if (childStatus === 'A' && aggregatedStatus !== 'D' && aggregatedStatus !== 'M') {
-          // Added has third priority
-          aggregatedStatus = 'A';
-        } else if (childStatus === 'U' && !aggregatedStatus) {
-          // Untracked (no status yet)
-          aggregatedStatus = 'U';
-        } else if (childStatus === 'R' && !aggregatedStatus) {
-          // Renamed (no status yet)
-          aggregatedStatus = 'R';
-        }
       }
-
-      node.gitStatus = aggregatedStatus;
     }
   }
 
@@ -346,32 +335,24 @@ export function applyChangeIndicators(root, gitStatusMap = new Map(), watcherSta
    * @returns {''|'A'|'M'} Node indicator status
    */
   function walk(node) {
-    if (!node.isDir) {
-      const gitChangeStatus = mapGitStatusToChangeStatus(
-        gitStatusMap.get(node.path) || node.gitStatus || ''
-      );
-      const watcherChangeStatus = normalizeChangeStatus(
-        watcherStatusMap.get(node.path) || ''
-      );
-      const fileChangeStatus = mergeChangeStatus(gitChangeStatus, watcherChangeStatus);
-      node.changeStatus = fileChangeStatus;
-      return fileChangeStatus;
-    }
+    const gitChangeStatus = mapGitStatusToChangeStatus(
+      gitStatusMap.get(node.path) || node.gitStatus || ''
+    );
+    const watcherChangeStatus = normalizeChangeStatus(
+      watcherStatusMap.get(node.path) || ''
+    );
+    const merged = mergeChangeStatus(gitChangeStatus, watcherChangeStatus);
 
-    // Allow direct watcher events on directories (e.g., addDir)
-    let aggregatedStatus = normalizeChangeStatus(watcherStatusMap.get(node.path) || '');
+    // Never show the indicator on the root "parent" folder (depth 0).
+    node.changeStatus = node.depth === 0 ? '' : merged;
 
     if (node.children && node.children.length > 0) {
       for (const child of node.children) {
-        const childStatus = walk(child);
-        aggregatedStatus = mergeChangeStatus(aggregatedStatus, childStatus);
+        walk(child);
       }
     }
 
-    // Never show the indicator on the root "parent" folder (depth 0).
-    const finalStatus = node.depth === 0 ? '' : aggregatedStatus;
-    node.changeStatus = finalStatus;
-    return finalStatus;
+    return node.changeStatus;
   }
 
   walk(root);
@@ -431,9 +412,13 @@ export function mergeExpandState(oldTree, newTree) {
  */
 export function useTree(rootPath, options = {}) {
   const absPath = resolve(rootPath);
+  const ignoreFilterRef = useRef(null);
+  if (!ignoreFilterRef.current) {
+    ignoreFilterRef.current = createIgnoreFilter(absPath, options);
+  }
 
   // Initial tree build
-  const [tree, setTree] = useState(() => buildTree(absPath, options));
+  const [tree, setTree] = useState(() => buildTree(absPath, options, 0, ignoreFilterRef.current));
 
   // Keep ref to current tree to avoid closure staleness
   const treeRef = useRef(tree);
@@ -467,8 +452,25 @@ export function useTree(rootPath, options = {}) {
     // Get current tree from ref (always fresh)
     const oldTree = treeRef.current;
 
+    // Collect expanded directory paths so rebuilds only load expanded subtrees.
+    let expandedPaths = null;
+    if (preserveState && oldTree) {
+      expandedPaths = new Set();
+      (function collectExpanded(node) {
+        if (!node) return;
+        if (node.isDir && node.expanded) {
+          expandedPaths.add(node.path);
+        }
+        if (node.children) {
+          for (const child of node.children) {
+            collectExpanded(child);
+          }
+        }
+      })(oldTree);
+    }
+
     // Rebuild tree
-    const newTree = buildTree(absPath, options);
+    const newTree = buildTree(absPath, options, 0, ignoreFilterRef.current, null, expandedPaths);
 
     // Merge expanded state if requested and old tree exists
     const mergedTree = preserveState && oldTree
@@ -492,6 +494,120 @@ export function useTree(rootPath, options = {}) {
     }
   }, [absPath, options]);
 
+  /**
+   * Ensure a directory node has its immediate children loaded.
+   * This enables fast startup (root-only scan) while still allowing on-demand expansion.
+   *
+   * @param {FileNode} node - Directory node to load
+   * @returns {boolean} True if a load occurred
+   */
+  const ensureChildrenLoaded = useCallback((node) => {
+    if (!node || !node.isDir || node.childrenLoaded) {
+      return false;
+    }
+
+    const { depth = DEFAULT_CONFIG.maxDepth, showHidden = false } = options;
+    if (node.depth >= depth) {
+      node.childrenLoaded = true;
+      node.children = [];
+      setTree(prev => ({ ...prev }));
+      return false;
+    }
+
+    const ignoreFilter = ignoreFilterRef.current || createIgnoreFilter(absPath, options);
+    ignoreFilterRef.current = ignoreFilter;
+
+    try {
+      if (ignoreFilter.loadPatternsForDirectory) {
+        ignoreFilter.loadPatternsForDirectory(node.absPath);
+      }
+
+      const entries = readdirSync(node.absPath, { withFileTypes: true });
+      const children = [];
+
+      for (const entry of entries) {
+        const entryName = entry.name;
+        const entryAbsPath = resolve(node.absPath, entryName);
+
+        if (entryName === '.git') {
+          continue;
+        }
+        if (!showHidden && entryName.startsWith('.')) {
+          continue;
+        }
+
+        const isDir = entry.isDirectory();
+        const isSymlink = entry.isSymbolicLink();
+        const entryRelativePath = relative(absPath, entryAbsPath);
+
+        if (ignoreFilter.shouldIgnore(entryRelativePath)) {
+          continue;
+        }
+
+        let childNode;
+        try {
+          childNode = createFileNode(
+            entryAbsPath,
+            absPath,
+            node.depth + 1,
+            isDir,
+            isSymlink,
+          );
+        } catch (e) {
+          if (e.code === 'EACCES' || e.code === 'EPERM') {
+            childNode = {
+              name: entryName,
+              path: relative(absPath, entryAbsPath).split(sep).join('/'),
+              absPath: entryAbsPath,
+              isDir,
+              children: null,
+              childrenLoaded: false,
+              expanded: false,
+              depth: node.depth + 1,
+              size: 0,
+              mode: 0,
+              gitStatus: '',
+              changeStatus: '',
+              hasError: true,
+              error: 'Permission denied',
+              isSymlink,
+              targetPath: null,
+            };
+          } else {
+            continue;
+          }
+        }
+
+        if (isDir && !isSymlink) {
+          childNode.children = [];
+          childNode.childrenLoaded = false;
+        }
+
+        children.push(childNode);
+      }
+
+      children.sort(compareNodes);
+      node.children = children;
+      node.childrenLoaded = true;
+      node.hasError = false;
+      node.error = null;
+    } catch (error) {
+      if (error.code === 'EACCES' || error.code === 'EPERM') {
+        node.hasError = true;
+        node.error = 'Permission denied';
+      } else {
+        node.hasError = true;
+        node.error = 'Cannot read directory';
+      }
+      node.children = [];
+      node.childrenLoaded = true;
+    }
+
+    // Change the root object reference so App's memoized decorators re-run.
+    setTree(prev => ({ ...prev }));
+    return true;
+  }, [absPath, options]);
+
   /**
    * Get the current tree state
    * Useful for external code to read the tree before rebuild
@@ -504,5 +620,6 @@ export function useTree(rootPath, options = {}) {
     refreshFlatList,
     rebuildTree,
     getTree,
+    ensureChildrenLoaded,
   };
 }

package/src/hooks/useWatcher.js

@@ -37,6 +37,7 @@ export function useWatcher(rootPath, onTreeChange, options = {}) {
   const debounceTimerRef = useRef(null);
   const pendingChangesRef = useRef(new Map()); // path -> event
   const sawAnyEventRef = useRef(false);
+  const ignoredPathRef = useRef((watchPath) => /(^|[\/\\])\.\./.test(watchPath) || /(^|[\/\\])\.git([\/\\]|$)/.test(watchPath));
 
   // Keep callback ref in sync
   useEffect(() => {
@@ -56,7 +57,7 @@ export function useWatcher(rootPath, onTreeChange, options = {}) {
 
     const usePolling = shouldUsePolling(rootPath);
     const watcher = chokidar.watch(rootPath, {
-      ignored: /(^|[\/\\])\.\./,
+      ignored: ignoredPathRef.current,
       persistent: true,
       ignoreInitial: true,
       followSymlinks: false,
@@ -78,12 +79,20 @@ export function useWatcher(rootPath, onTreeChange, options = {}) {
     };
 
     watcher.on('all', (event, path) => {
+      if (ignoredPathRef.current(path)) {
+        return;
+      }
       sawAnyEventRef.current = true;
 
       // Keep a best-effort batch of "change indicator relevant" events.
-      // Prefer add/addDir over change for the same path within the debounce window.
+      // Prefer add/addDir over unlink/unlinkDir over change for the same path within the debounce window.
       if (event === 'add' || event === 'addDir') {
         pendingChangesRef.current.set(path, event);
+      } else if (event === 'unlink' || event === 'unlinkDir') {
+        const existing = pendingChangesRef.current.get(path);
+        if (existing !== 'add' && existing !== 'addDir') {
+          pendingChangesRef.current.set(path, event);
+        }
       } else if (event === 'change') {
         if (!pendingChangesRef.current.has(path)) {
           pendingChangesRef.current.set(path, event);