fix(Tree): filtering (properly matching items, but still not allowing…

… navigating matches)
lautarodragan · Feb 11, 2025 · bf9611a · bf9611a
1 parent 0e67a80
commit bf9611a
Show file tree

Hide file tree

Showing 2 changed files with 21 additions and 30 deletions.
diff --git a/src/components/tree/component.rs b/src/components/tree/component.rs
@@ -197,42 +197,30 @@ where
     }
 
     pub fn filter_mut(&self, cb: impl FnOnce(&mut String)) {
-        let nodes = self.items.borrow_mut();
-
-        if nodes.len() < 2 {
+        if self.items.borrow().len() < 2 {
             return;
         }
 
         let mut filter = self.filter.borrow_mut();
 
         cb(&mut filter);
 
-        // for item in nodes.iter_mut() {
-        //     if filter.is_empty() {
-        //         item.is_match = false;
-        //     } else {
-        //         item.is_match = item
-        //             .inner
-        //             .to_string()
-        //             .to_lowercase()
-        //             .contains(filter.to_lowercase().as_str());
-        //     }
-        // }
-
-        // let selected_item_index = self.selected_item_index.get();
-        // if !items[selected_item_index].is_match {
-        //     if let Some(i) = items.iter().skip(selected_item_index).position(|item| item.is_match) {
-        //         let i = i + selected_item_index;
-        //         self.selected_item_index.set(i);
-        //     } else if let Some(i) = items.iter().position(|item| item.is_match) {
-        //         self.selected_item_index.set(i);
-        //     }
-        // }
-    }
+        let mut nodes = self.items.borrow_mut();
+        for node in nodes.iter_mut() {
+            node.is_match = !filter.is_empty() && node.inner.to_string().to_lowercase().contains(filter.to_lowercase().as_str());
 
-    // pub fn selected_index(&self) -> Vec<usize> {
-    //     self.selected_item_index.borrow()
-    // }
+            if node.is_open {
+                for node in node.children.iter_mut() {
+                    node.is_match = !filter.is_empty() && node.inner.to_string().to_lowercase().contains(filter.to_lowercase().as_str());
+                }
+
+                // TODO: how can I implement node.iter_mut????
+                // for node in node.iter() {
+                //     // log::debug!("filtering child: {}", node.inner)
+                // }
+            }
+        }
+    }
 
     #[allow(unused)]
     pub fn set_selected_path(&self, new_i: TreeNodePath) {

diff --git a/src/components/tree/tree_node.rs b/src/components/tree/tree_node.rs
@@ -8,6 +8,7 @@ use super::TreeNodePath;
 pub struct TreeNode<T> {
     pub inner: T,
     pub is_visible: bool,
+    #[serde(skip)]
     pub is_match: bool,
     pub is_open: bool,
     pub children: Vec<Self>,
@@ -127,8 +128,9 @@ impl<T> TreeNode<T> {
     }
 
     pub fn iter(&self) -> TreeNodeIterator<T> {
+        // TODO: iter_mut???
         let iter = TreeNodeIterator {
-            root: &self,
+            root: self,
             current_node: None,
             current_path: TreeNodePath::empty(),
         };
@@ -137,7 +139,7 @@ impl<T> TreeNode<T> {
     }
 }
 
-struct TreeNodeIterator<'a, T> {
+pub struct TreeNodeIterator<'a, T> {
     root: &'a TreeNode<T>,
     current_node: Option<&'a TreeNode<T>>,
     current_path: TreeNodePath,
@@ -149,6 +151,7 @@ impl<'a, T> Iterator for TreeNodeIterator<'a, T> {
 
     fn next(&mut self) -> Option<Self::Item> {
         // TODO: avoid calling .get_child(). store branch: Vec<&'a TreeNode<T>> (or VecDeque?)
+        // TODO: skip closed nodes? can that be achieved with .filter (is filter lazy and ordered and deterministic?)
 
         if let Some(current_node) = self.current_node {
             let current_node_first_child = current_node.children().first();