Migrate file tree creation to Rust backend

apps/app/src-tauri/Cargo.toml

@@ -30,3 +30,4 @@ tauri-plugin-fs = "2"
 tauri-plugin-store = "2"
 tauri-plugin-dialog = "2"
 tauri-plugin-os = "2"
+urlencoding = "2"

apps/app/src-tauri/src/lib.rs

@@ -1,3 +1,155 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct FileNode {
+    pub name: String,
+    pub path: String,
+    pub is_directory: bool,
+    pub children: Vec<FileNode>,
+}
+
+fn sort_nodes(nodes: &mut Vec<FileNode>) {
+    nodes.sort_by(|a, b| {
+        if a.is_directory != b.is_directory {
+            return if a.is_directory {
+                std::cmp::Ordering::Less
+            } else {
+                std::cmp::Ordering::Greater
+            };
+        }
+        a.name.to_lowercase().cmp(&b.name.to_lowercase())
+    });
+
+    for node in nodes {
+        if !node.children.is_empty() {
+            sort_nodes(&mut node.children);
+        }
+    }
+}
+
+#[cfg(not(target_os = "android"))]
+fn build_tree_recursive_desktop(path_str: &str) -> std::io::Result<Vec<FileNode>> {
+    use std::fs;
+    let mut nodes = Vec::new();
+    let entries = fs::read_dir(path_str)?;
+
+    for entry in entries {
+        if let Ok(entry) = entry {
+            if let Ok(metadata) = entry.metadata() {
+                let file_name = entry.file_name().to_string_lossy().to_string();
+
+                let is_directory = metadata.is_dir();
+                let starts_with_dot = file_name.starts_with('.');
+                let ends_with_md = file_name.ends_with(".md");
+
+                if (is_directory && !starts_with_dot) || ends_with_md {
+                    let path = entry.path().to_string_lossy().to_string();
+                    let mut children = Vec::new();
+
+                    if is_directory {
+                        if let Ok(sub_children) = build_tree_recursive_desktop(&path) {
+                            children = sub_children;
+                        }
+                    }
+
+                    nodes.push(FileNode {
+                        name: file_name.trim_end_matches(".md").to_string(),
+                        path,
+                        is_directory,
+                        children,
+                    });
+                }
+            }
+        }
+    }
+    Ok(nodes)
+}
+
+#[cfg(target_os = "android")]
+fn build_tree_recursive_android(
+    app: tauri::AppHandle,
+    path: String,
+    document_top_tree_uri: Option<String>,
+) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Vec<FileNode>, String>> + Send>> {
+    Box::pin(async move {
+        use tauri_plugin_android_fs::AndroidFsExt;
+        use tauri_plugin_android_fs::FileUri;
+
+        let api = app.android_fs();
+
+        let json_obj = serde_json::json!({
+            "uri": path,
+            "documentTopTreeUri": document_top_tree_uri
+        });
+        let file_uri = FileUri::from_json_str(&json_obj.to_string())
+            .map_err(|e| format!("Failed to create FileUri: {}", e))?;
+
+        let entries = api.read_dir(&file_uri)
+            .map_err(|e| e.to_string())?;
+
+        let mut nodes = Vec::new();
+        for entry in entries {
+            let name = entry.name().to_string();
+            let is_directory = entry.is_dir();
+
+            let starts_with_dot = name.starts_with('.');
+            let ends_with_md = name.ends_with(".md");
+
+            if (is_directory && !starts_with_dot) || ends_with_md {
+                let path_uri = format!("{}%2F{}", path, urlencoding::encode(&name));
+
+                let mut children = Vec::new();
+                if is_directory {
+                     children = build_tree_recursive_android(
+                        app.clone(),
+                        path_uri.clone(),
+                        document_top_tree_uri.clone()
+                    ).await?;
+                }
+
+                nodes.push(FileNode {
+                    name: name.trim_end_matches(".md").to_string(),
+                    path: path_uri,
+                    is_directory,
+                    children,
+                });
+            }
+        }
+        Ok(nodes)
+    })
+}
+
+#[tauri::command]
+async fn build_file_tree(
+    _app: tauri::AppHandle,
+    path: String,
+    _document_top_tree_uri: Option<String>,
+) -> Result<Vec<FileNode>, String> {
+    let nodes;
+
+    #[cfg(target_os = "android")]
+    {
+        // On Android, we need the app handle and args.
+        // But we renamed arguments to start with _.
+        // We can use them directly.
+        let mut unsorted_nodes = build_tree_recursive_android(_app, path, _document_top_tree_uri).await?;
+        sort_nodes(&mut unsorted_nodes);
+        nodes = unsorted_nodes;
+    }
+
+    #[cfg(not(target_os = "android"))]
+    {
+        nodes = tauri::async_runtime::spawn_blocking(move || {
+            let mut n = build_tree_recursive_desktop(&path)?;
+            sort_nodes(&mut n);
+            Ok(n)
+        }).await.map_err(|e| e.to_string())?
+          .map_err(|e: std::io::Error| e.to_string())?;
+    }
+
+    Ok(nodes)
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
@@ -6,6 +158,7 @@ pub fn run() {
         .plugin(tauri_plugin_store::Builder::new().build())
         .plugin(tauri_plugin_fs::init())
         .plugin(tauri_plugin_android_fs::init())
+        .invoke_handler(tauri::generate_handler![build_file_tree])
         .setup(|app| {
             if cfg!(debug_assertions) {
                 app.handle().plugin(

apps/app/src/components/sidebar/file_manager/index.svelte

@@ -2,12 +2,13 @@
   import {
     build_file_tree_from_fs,
     move_node,
-    sort_file_tree,
+    sort_nodes,
   } from '@/lib/file_tree';
   import ItemsRender from './items_renderer.svelte';
   import { type FileNode, type GenericPath } from '@/types';
   import Toolbar from './toolbar.svelte';
   import { toast } from 'svelte-sonner';
+  import { untrack } from 'svelte';
   let {
     opened_filenode = $bindable(),
     root_path = $bindable(),
@@ -22,8 +23,10 @@
   let focused_subtree: FileNode[] | undefined = $derived(file_tree);
 
   $effect(() => {
-    if (file_tree) sort_file_tree(file_tree);
+    const subtree = untrack(() => focused_subtree);
+    if (file_tree && subtree) sort_nodes(subtree);
   });
+
   let collapsed_state: boolean = $state(true);
   $effect(() => {
     if (!root_path) return;

apps/app/src/lib/file_tree/builder.ts

@@ -1,85 +1,25 @@
-import { readDir, type DirEntry } from '@tauri-apps/plugin-fs';
 import { type FileNode, type GenericPath } from '@/types';
-import {
-  AndroidFs,
-  type AndroidEntryMetadataWithUri,
-} from 'tauri-plugin-android-fs-api';
-import { join } from '@tauri-apps/api/path';
-import { current_platform } from './utils';
+import { invoke } from '@tauri-apps/api/core';
+import { toast } from 'svelte-sonner';
 
 export async function build_file_tree_from_fs({
   path,
   document_top_tree_uri,
 }: GenericPath): Promise<FileNode[]> {
-  let entries: DirEntry[] | AndroidEntryMetadataWithUri[] | undefined;
-  let base_nodes: FileNode[] | undefined;
-
-  if (current_platform == 'android') {
-    if (!document_top_tree_uri)
-      throw new Error('Document top tree URI is not set');
-    entries = await AndroidFs.readDir({
-      uri: path,
-      documentTopTreeUri: document_top_tree_uri,
+  try {
+    return await invoke('build_file_tree', {
+      path,
+      documentTopTreeUri: document_top_tree_uri || null,
     });
-    base_nodes = await transform_android_entries_to_filenode(entries, path);
-  } else {
-    entries = await readDir(path);
-    base_nodes = await transform_entries_to_filenode(entries, path);
+  } catch (error) {
+    console.error('Failed to build file tree:', error);
+    const description =
+      error instanceof Error
+        ? error.message
+        : typeof error === 'string'
+          ? error
+          : JSON.stringify(error);
+    toast.error('Failed to build file tree', { description });
+    throw error;
   }
-
-  const nodes = await Promise.all(
-    base_nodes.map(async (n) => {
-      if (!n.is_directory) return n;
-      const children = await build_file_tree_from_fs({
-        path: n.path,
-        document_top_tree_uri,
-      });
-      return {
-        ...n,
-        children,
-      };
-    })
-  );
-
-  return nodes;
-}
-export async function transform_entries_to_filenode(
-  entries: DirEntry[],
-  base_dir_path: string
-): Promise<FileNode[]> {
-  const nodes = await Promise.all(
-    entries
-      .filter(
-        (entry) =>
-          (entry.isDirectory && !entry.name.startsWith('.')) ||
-          entry.name.endsWith('.md')
-      )
-      .map(async (entry) => ({
-        name: entry.name.replace(/\.md$/, ''),
-        path: await join(base_dir_path, entry.name),
-        is_directory: entry.isDirectory,
-        children: [],
-      }))
-  );
-  return nodes;
-}
-export async function transform_android_entries_to_filenode(
-  entries: AndroidEntryMetadataWithUri[],
-  base_dir_path: string
-): Promise<FileNode[]> {
-  const nodes = await Promise.all(
-    entries
-      .filter(
-        (entry) =>
-          (entry.type === 'Dir' && !entry.name.startsWith('.')) ||
-          entry.name.endsWith('.md')
-      )
-      .map(async (entry) => ({
-        name: entry.name.replace(/\.md$/, ''),
-        path: `${base_dir_path}%2F${encodeURIComponent(entry.name)}`,
-        is_directory: entry.type === 'Dir',
-        children: [],
-      }))
-  );
-  return nodes;
 }

apps/app/src/lib/file_tree/utils/file_tree_utils.ts

@@ -1,4 +1,5 @@
-import { type FileNode } from '@/types';
+import type { FileNode } from '@/types';
+
 export function find_unused_name(
   base_name: string,
   subtree: FileNode[],
@@ -11,7 +12,8 @@ export function find_unused_name(
     base_name = `Untitled ${++i}`;
   return base_name;
 }
-export function sort_file_tree(nodes: FileNode[]): FileNode[] {
+
+export function sort_nodes(nodes: FileNode[]) {
   // Sort array in-place
   nodes.sort((a, b) => {
     if (a.is_directory !== b.is_directory) return a.is_directory ? -1 : 1;
@@ -20,13 +22,4 @@ export function sort_file_tree(nodes: FileNode[]): FileNode[] {
       sensitivity: 'base',
     });
   });
-
-  // Recursively sort children in-place
-  for (const node of nodes) {
-    if (node.children?.length) {
-      sort_file_tree(node.children);
-    }
-  }
-
-  return nodes;
 }