Struct FileTree 

pub struct FileTree { /* private fields */ }

File tree with lazy loading support

The tree starts with just the root node. Directories are only read when explicitly expanded via expand_node(). This makes the tree efficient even for very large directory structures.

Implementations

impl FileTree

pub async fn new(root_path: PathBuf, fs_manager: Arc<FsManager>) -> Result<Self>

Create a new file tree rooted at the given path

Errors

Returns an error if the root path doesn’t exist or isn’t a directory.

pub fn root_id(&self) -> NodeId

Get the root node ID

pub fn root_path(&self) -> &Path

Get the root path

pub fn get_node(&self, id: NodeId) -> Option<&TreeNode>

Get a node by ID

pub fn get_node_by_path(&self, path: &Path) -> Option<&TreeNode>

Get a node by path

pub fn all_nodes(&self) -> impl Iterator<Item = &TreeNode>

Get all nodes

pub async fn expand_node(&mut self, id: NodeId) -> Result<()>

Expand a directory node (load its children)

This is an async operation that reads the directory contents and creates child nodes. If the directory is already expanded, this does nothing.

Errors

Returns an error if the directory cannot be read.

pub fn collapse_node(&mut self, id: NodeId)

Collapse a directory node

This removes all child nodes from memory to save space. They will be reloaded if the directory is expanded again.

pub async fn toggle_node(&mut self, id: NodeId) -> Result<()>

Toggle node expansion (expand if collapsed, collapse if expanded)

pub async fn refresh_node(&mut self, id: NodeId) -> Result<()>

Refresh a node (re-read directory contents)

This is useful when filesystem contents have changed.

pub fn get_visible_nodes(&self) -> Vec<NodeId>

Get all visible nodes in tree order

Returns a flat list of nodes that should be visible, respecting the expansion state of parent directories.

pub fn get_ancestors(&self, id: NodeId) -> Vec<NodeId>

Get the parent chain for a node (from root to node)

pub fn get_depth(&self, id: NodeId) -> usize

Get the depth of a node (root is 0)

pub fn find_by_relative_path(&self, relative_path: &Path) -> Option<NodeId>

Find node by relative path from root

pub fn node_count(&self) -> usize

Get number of nodes currently in memory

pub async fn expand_to_path(&mut self, path: &Path) -> Option<NodeId>

Expand all directories along a path and return the final node ID

This is useful for revealing a specific file in the tree, even if its parent directories are collapsed. All parent directories will be expanded as needed.

Arguments

• path - The full path to the target file or directory

Returns

Returns the NodeId of the target if found, or None if:

• The path is not under the root directory
• The path doesn’t exist
• There was an error expanding intermediate directories

Example

// Expand to src/components/App.js
if let Some(node_id) = tree.expand_to_path(&project_root.join("src/components/App.js")).await {
    // All parent directories (src, src/components) are now expanded
    // node_id points to App.js
}

Trait Implementations

impl Debug for FileTree

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.