Skip to main content

ftui_widgets/
tree.rs

1//! Tree widget for hierarchical display.
2//!
3//! Renders a tree of labeled nodes with configurable guide characters
4//! and styles, suitable for file trees or structured views.
5//!
6//! # Example
7//!
8//! ```
9//! use ftui_widgets::tree::{Tree, TreeNode, TreeGuides};
10//!
11//! let tree = Tree::new(TreeNode::new("root")
12//!     .child(TreeNode::new("src")
13//!         .child(TreeNode::new("main.rs"))
14//!         .child(TreeNode::new("lib.rs")))
15//!     .child(TreeNode::new("Cargo.toml")));
16//!
17//! assert_eq!(tree.root().label(), "root");
18//! assert_eq!(tree.root().children().len(), 2);
19//! ```
20
21use crate::mouse::MouseResult;
22use crate::stateful::Stateful;
23use crate::undo_support::{TreeUndoExt, UndoSupport, UndoWidgetId};
24use crate::{Widget, clear_text_area, draw_text_span};
25use ftui_core::event::{KeyCode, KeyEvent, KeyEventKind, MouseButton, MouseEvent, MouseEventKind};
26use ftui_core::geometry::Rect;
27use ftui_render::frame::{Frame, HitId, HitRegion};
28use ftui_style::Style;
29use std::any::Any;
30use std::collections::HashSet;
31#[cfg(feature = "tracing")]
32use web_time::Instant;
33
34/// Guide character styles for tree rendering.
35#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
36pub enum TreeGuides {
37    /// ASCII guides: `|`, `+--`, `` `-- ``.
38    Ascii,
39    /// Unicode box-drawing characters (default).
40    #[default]
41    Unicode,
42    /// Bold Unicode box-drawing characters.
43    Bold,
44    /// Double-line Unicode characters.
45    Double,
46    /// Rounded Unicode characters.
47    Rounded,
48}
49
50impl TreeGuides {
51    /// Vertical continuation (item has siblings below).
52    #[must_use]
53    pub const fn vertical(&self) -> &str {
54        match self {
55            Self::Ascii => "|   ",
56            Self::Unicode | Self::Rounded => "\u{2502}   ",
57            Self::Bold => "\u{2503}   ",
58            Self::Double => "\u{2551}   ",
59        }
60    }
61
62    /// Branch guide (item has siblings below).
63    #[must_use]
64    pub const fn branch(&self) -> &str {
65        match self {
66            Self::Ascii => "+-- ",
67            Self::Unicode => "\u{251C}\u{2500}\u{2500} ",
68            Self::Bold => "\u{2523}\u{2501}\u{2501} ",
69            Self::Double => "\u{2560}\u{2550}\u{2550} ",
70            Self::Rounded => "\u{251C}\u{2500}\u{2500} ",
71        }
72    }
73
74    /// Last-item guide (no siblings below).
75    #[must_use]
76    pub const fn last(&self) -> &str {
77        match self {
78            Self::Ascii => "`-- ",
79            Self::Unicode => "\u{2514}\u{2500}\u{2500} ",
80            Self::Bold => "\u{2517}\u{2501}\u{2501} ",
81            Self::Double => "\u{255A}\u{2550}\u{2550} ",
82            Self::Rounded => "\u{2570}\u{2500}\u{2500} ",
83        }
84    }
85
86    /// Empty indentation (no guide needed).
87    #[must_use]
88    pub const fn space(&self) -> &str {
89        "    "
90    }
91
92    /// Width in columns of each guide segment.
93    #[inline]
94    #[must_use]
95    pub fn width(&self) -> usize {
96        4
97    }
98}
99
100/// A node in the tree hierarchy.
101#[derive(Debug, Clone)]
102pub struct TreeNode {
103    label: String,
104    icon: Option<String>,
105    /// Child nodes (crate-visible for undo support).
106    pub(crate) children: Vec<TreeNode>,
107    /// Lazily materialized children.
108    lazy_children: Option<Vec<TreeNode>>,
109    /// Whether this node is expanded (crate-visible for undo support).
110    pub(crate) expanded: bool,
111}
112
113impl TreeNode {
114    /// Create a new tree node with the given label.
115    #[must_use]
116    pub fn new(label: impl Into<String>) -> Self {
117        Self {
118            label: label.into(),
119            icon: None,
120            children: Vec::new(),
121            lazy_children: None,
122            expanded: true,
123        }
124    }
125
126    /// Add a child node.
127    #[must_use]
128    pub fn child(mut self, node: TreeNode) -> Self {
129        self.children.push(node);
130        self
131    }
132
133    /// Set children from a vec.
134    #[must_use]
135    pub fn with_children(mut self, nodes: Vec<TreeNode>) -> Self {
136        self.children = nodes;
137        self
138    }
139
140    /// Set an icon prefix rendered before the label.
141    #[must_use]
142    pub fn with_icon(mut self, icon: impl Into<String>) -> Self {
143        self.icon = Some(icon.into());
144        self
145    }
146
147    /// Configure lazily materialized children.
148    ///
149    /// The node starts collapsed and children are attached when first expanded.
150    #[must_use]
151    pub fn with_lazy_children(mut self, nodes: Vec<TreeNode>) -> Self {
152        self.lazy_children = Some(nodes);
153        self.expanded = false;
154        self
155    }
156
157    /// Set whether this node is expanded.
158    #[must_use]
159    pub fn with_expanded(mut self, expanded: bool) -> Self {
160        if expanded {
161            self.materialize_lazy_children();
162        }
163        self.expanded = expanded;
164        self
165    }
166
167    /// Get the label.
168    #[must_use]
169    pub fn label(&self) -> &str {
170        &self.label
171    }
172
173    /// Get the children.
174    #[must_use]
175    pub fn children(&self) -> &[TreeNode] {
176        &self.children
177    }
178
179    /// Optional icon rendered before label.
180    #[must_use]
181    pub fn icon(&self) -> Option<&str> {
182        self.icon.as_deref()
183    }
184
185    /// Whether this node has loaded or lazy children.
186    #[must_use]
187    pub fn has_children(&self) -> bool {
188        !self.children.is_empty()
189            || self
190                .lazy_children
191                .as_ref()
192                .is_some_and(|children| !children.is_empty())
193    }
194
195    /// Whether this node is expanded.
196    #[must_use]
197    pub fn is_expanded(&self) -> bool {
198        self.expanded
199    }
200
201    /// Toggle the expanded state.
202    pub fn toggle_expanded(&mut self) {
203        if !self.expanded {
204            self.materialize_lazy_children();
205        }
206        self.expanded = !self.expanded;
207    }
208
209    fn materialize_lazy_children(&mut self) {
210        if let Some(mut lazy) = self.lazy_children.take() {
211            self.children.append(&mut lazy);
212        }
213    }
214
215    fn materialize_all_lazy_children(&mut self) {
216        self.materialize_lazy_children();
217        for child in &mut self.children {
218            child.materialize_all_lazy_children();
219        }
220    }
221
222    #[cfg(feature = "tracing")]
223    fn total_count(&self) -> usize {
224        let mut count = 1usize;
225        for child in &self.children {
226            count = count.saturating_add(child.total_count());
227        }
228        if let Some(lazy) = &self.lazy_children {
229            for child in lazy {
230                count = count.saturating_add(child.total_count());
231            }
232        }
233        count
234    }
235
236    #[cfg(feature = "tracing")]
237    fn expanded_count(&self) -> usize {
238        let mut count = usize::from(self.expanded && self.has_children());
239        for child in &self.children {
240            count = count.saturating_add(child.expanded_count());
241        }
242        if let Some(lazy) = &self.lazy_children {
243            for child in lazy {
244                count = count.saturating_add(child.expanded_count());
245            }
246        }
247        count
248    }
249
250    /// Count all visible (expanded) nodes, including this one.
251    #[must_use]
252    pub fn visible_count(&self) -> usize {
253        let mut count = 1;
254        if self.expanded {
255            for child in &self.children {
256                count += child.visible_count();
257            }
258        }
259        count
260    }
261
262    /// Collect all expanded node paths into a set.
263    #[allow(dead_code)]
264    pub(crate) fn collect_expanded(&self, prefix: &str, out: &mut HashSet<String>) {
265        let path = if prefix.is_empty() {
266            self.label.clone()
267        } else {
268            format!("{}/{}", prefix, self.label)
269        };
270
271        if self.expanded && self.has_children() {
272            out.insert(path.clone());
273        }
274
275        for child in &self.children {
276            child.collect_expanded(&path, out);
277        }
278    }
279
280    /// Apply expanded state from a set of paths.
281    #[allow(dead_code)]
282    pub(crate) fn apply_expanded(&mut self, prefix: &str, expanded_paths: &HashSet<String>) {
283        let path = if prefix.is_empty() {
284            self.label.clone()
285        } else {
286            format!("{}/{}", prefix, self.label)
287        };
288
289        if self.has_children() {
290            self.expanded = expanded_paths.contains(&path);
291            if self.expanded {
292                self.materialize_lazy_children();
293            }
294        }
295
296        for child in &mut self.children {
297            child.apply_expanded(&path, expanded_paths);
298        }
299    }
300}
301
302/// Tree widget for rendering hierarchical data.
303#[derive(Debug, Clone)]
304pub struct Tree {
305    /// Unique ID for undo tracking.
306    undo_id: UndoWidgetId,
307    root: TreeNode,
308    /// Whether to show the root node.
309    show_root: bool,
310    /// Guide character style.
311    guides: TreeGuides,
312    /// Style for guide characters.
313    guide_style: Style,
314    /// Style for node labels.
315    label_style: Style,
316    /// Style for the root node label.
317    root_style: Style,
318    /// Optional persistence ID for state saving/restoration.
319    persistence_id: Option<String>,
320    /// Optional hit ID for mouse interaction.
321    hit_id: Option<HitId>,
322    /// Optional explicit accessibility root node ID.
323    accessibility_id: Option<u64>,
324    /// Optional currently selected visible row index.
325    selected_visible_index: Option<usize>,
326    /// Whether this tree currently owns keyboard focus.
327    focused: bool,
328    /// Optional case-insensitive search query.
329    search_query: Option<String>,
330}
331
332impl Tree {
333    /// Create a tree widget with the given root node.
334    #[must_use]
335    pub fn new(root: TreeNode) -> Self {
336        Self {
337            undo_id: UndoWidgetId::new(),
338            root,
339            show_root: true,
340            guides: TreeGuides::default(),
341            guide_style: Style::default(),
342            label_style: Style::default(),
343            root_style: Style::default(),
344            persistence_id: None,
345            hit_id: None,
346            accessibility_id: None,
347            selected_visible_index: None,
348            focused: false,
349            search_query: None,
350        }
351    }
352
353    /// Set whether to show the root node.
354    #[must_use]
355    pub fn with_show_root(mut self, show: bool) -> Self {
356        self.show_root = show;
357        self
358    }
359
360    /// Set the guide character style.
361    #[must_use]
362    pub fn with_guides(mut self, guides: TreeGuides) -> Self {
363        self.guides = guides;
364        self
365    }
366
367    /// Set the style for guide characters.
368    #[must_use]
369    pub fn with_guide_style(mut self, style: Style) -> Self {
370        self.guide_style = style;
371        self
372    }
373
374    /// Set the style for node labels.
375    #[must_use]
376    pub fn with_label_style(mut self, style: Style) -> Self {
377        self.label_style = style;
378        self
379    }
380
381    /// Set the style for the root label.
382    #[must_use]
383    pub fn with_root_style(mut self, style: Style) -> Self {
384        self.root_style = style;
385        self
386    }
387
388    /// Set a persistence ID for state saving. Without one the tree has no
389    /// [`StateKey`](crate::stateful::StateKey) and its state is not persisted.
390    #[must_use]
391    pub fn with_persistence_id(mut self, id: impl Into<String>) -> Self {
392        self.persistence_id = Some(id.into());
393        self
394    }
395
396    /// Get the persistence ID, if set.
397    #[must_use]
398    pub fn persistence_id(&self) -> Option<&str> {
399        self.persistence_id.as_deref()
400    }
401
402    /// Set a hit ID for mouse interaction.
403    #[must_use]
404    pub fn hit_id(mut self, id: HitId) -> Self {
405        self.hit_id = Some(id);
406        self
407    }
408
409    /// Set an explicit accessibility root node ID that stays stable across
410    /// layout moves and resizes.
411    #[must_use]
412    pub fn with_accessibility_id(mut self, id: u64) -> Self {
413        self.accessibility_id = Some(id);
414        self
415    }
416
417    /// Set the currently selected visible row index for accessibility state.
418    #[must_use]
419    pub fn with_selected_visible_index(mut self, index: Option<usize>) -> Self {
420        self.selected_visible_index = index;
421        self
422    }
423
424    /// Set whether this tree currently owns keyboard focus.
425    #[must_use]
426    pub fn with_focused(mut self, focused: bool) -> Self {
427        self.focused = focused;
428        self
429    }
430
431    /// Apply a case-insensitive search query filter.
432    #[must_use]
433    pub fn with_search_query(mut self, query: impl Into<String>) -> Self {
434        let query = query.into();
435        self.search_query = if query.trim().is_empty() {
436            None
437        } else {
438            Some(query)
439        };
440        self
441    }
442
443    /// Clear search filtering.
444    #[must_use]
445    pub fn without_search_query(mut self) -> Self {
446        self.search_query = None;
447        self
448    }
449
450    fn accessibility_root_id(&self, area: Rect) -> u64 {
451        if let Some(id) = self.accessibility_id {
452            return id;
453        }
454        if let Some(hit) = self.hit_id {
455            use std::hash::{Hash, Hasher};
456            let mut hasher = std::collections::hash_map::DefaultHasher::new();
457            ("ftui.tree.hit", hit.id()).hash(&mut hasher);
458            return hasher.finish();
459        }
460        if let Some(ref pid) = self.persistence_id {
461            use std::hash::{Hash, Hasher};
462            let mut hasher = std::collections::hash_map::DefaultHasher::new();
463            ("ftui.tree.persist", pid.as_str()).hash(&mut hasher);
464            return hasher.finish();
465        }
466        crate::a11y_node_id(area)
467    }
468
469    /// Compute the stable accessibility node ID for a tree node at `path`
470    /// (canonical child indices from root; `&[]` for the root node itself).
471    #[must_use]
472    pub fn accessibility_item_id(root_id: u64, path: &[usize]) -> u64 {
473        use std::hash::{Hash, Hasher};
474        let mut hasher = std::collections::hash_map::DefaultHasher::new();
475        ("ftui.tree.node", root_id, path).hash(&mut hasher);
476        hasher.finish()
477    }
478
479    #[cfg(feature = "tracing")]
480    fn total_nodes(&self) -> usize {
481        if self.show_root {
482            self.root.total_count()
483        } else if self.root.expanded {
484            self.root
485                .children
486                .iter()
487                .fold(0usize, |acc, child| acc.saturating_add(child.total_count()))
488        } else {
489            0
490        }
491    }
492
493    #[cfg(feature = "tracing")]
494    fn visible_nodes(&self) -> usize {
495        if self.show_root {
496            self.root.visible_count()
497        } else if self.root.expanded {
498            self.root.children.iter().fold(0usize, |acc, child| {
499                acc.saturating_add(child.visible_count())
500            })
501        } else {
502            0
503        }
504    }
505
506    #[cfg(feature = "tracing")]
507    fn expanded_nodes(&self) -> usize {
508        if self.show_root {
509            self.root.expanded_count()
510        } else if self.root.expanded {
511            self.root.children.iter().fold(0usize, |acc, child| {
512                acc.saturating_add(child.expanded_count())
513            })
514        } else {
515            0
516        }
517    }
518
519    /// Get a reference to the root node.
520    #[must_use]
521    pub fn root(&self) -> &TreeNode {
522        &self.root
523    }
524
525    /// Get a mutable reference to the root node.
526    pub fn root_mut(&mut self) -> &mut TreeNode {
527        &mut self.root
528    }
529
530    fn build_a11y_item_node(
531        &self,
532        node: &TreeNode,
533        depth: usize,
534        row_idx: usize,
535        row_bounds: Rect,
536        root_id: u64,
537        path: &[usize],
538    ) -> ftui_a11y::node::A11yNodeInfo {
539        let item_id = Self::accessibility_item_id(root_id, path);
540        let mut item = ftui_a11y::node::A11yNodeInfo::new(
541            item_id,
542            ftui_a11y::node::A11yRole::ListItem,
543            row_bounds,
544        );
545        if !node.label.is_empty() {
546            item.name = Some(node.label.clone());
547        }
548        item.description = Some(match node.icon() {
549            Some(icon) if !icon.is_empty() => format!("level {}, icon {}", depth + 1, icon),
550            _ => format!("level {}", depth + 1),
551        });
552        let has_children = self
553            .get_node_at_path(path)
554            .map_or_else(|| node.has_children(), TreeNode::has_children);
555        if has_children {
556            item.state.expanded = Some(node.is_expanded());
557        }
558        item.state.selected = self.selected_visible_index == Some(row_idx);
559        item.state.focused = self.focused && self.selected_visible_index == Some(row_idx);
560        item
561    }
562
563    #[allow(clippy::too_many_arguments)]
564    fn render_node(
565        &self,
566        node: &TreeNode,
567        depth: usize,
568        is_last: &mut Vec<bool>,
569        area: Rect,
570        frame: &mut Frame,
571        current_row: &mut usize,
572        deg: ftui_render::budget::DegradationLevel,
573        a11y_root_id: u64,
574    ) {
575        if *current_row >= area.height as usize {
576            return;
577        }
578
579        let row_idx = *current_row;
580        let y = area.y.saturating_add(row_idx as u16);
581        let mut x = area.x;
582        let max_x = area.right();
583
584        // Draw guide characters for each depth level
585        if depth > 0 && deg.apply_styling() {
586            for d in 0..depth {
587                let is_last_at_depth = is_last.get(d).copied().unwrap_or(false);
588                let guide = if d == depth - 1 {
589                    // This is the immediate parent level
590                    if is_last_at_depth {
591                        self.guides.last()
592                    } else {
593                        self.guides.branch()
594                    }
595                } else {
596                    // Ancestor level: show vertical line or blank
597                    if is_last_at_depth {
598                        self.guides.space()
599                    } else {
600                        self.guides.vertical()
601                    }
602                };
603
604                x = draw_text_span(frame, x, y, guide, self.guide_style, max_x);
605            }
606        } else if depth > 0 {
607            // Minimal rendering: indent with spaces
608            // Avoid allocation by drawing chunks iteratively
609            for _ in 0..depth {
610                x = draw_text_span(frame, x, y, "    ", Style::default(), max_x);
611                if x >= max_x {
612                    break;
613                }
614            }
615        }
616
617        // Draw label
618        let style = if depth == 0 && self.show_root {
619            self.root_style
620        } else {
621            self.label_style
622        };
623        if let Some(icon) = node.icon() {
624            let icon_style = if deg.apply_styling() {
625                style
626            } else {
627                Style::default()
628            };
629            x = draw_text_span(frame, x, y, icon, icon_style, max_x);
630            if x < max_x {
631                x = draw_text_span(frame, x, y, " ", icon_style, max_x);
632            }
633        }
634
635        if deg.apply_styling() {
636            draw_text_span(frame, x, y, &node.label, style, max_x);
637        } else {
638            draw_text_span(frame, x, y, &node.label, Style::default(), max_x);
639        }
640
641        let row_area = Rect::new(area.x, y, area.width, 1);
642
643        // Register hit region for the row
644        if let Some(id) = self.hit_id {
645            frame.register_hit(row_area, id, HitRegion::Content, row_idx as u64);
646        }
647
648        let a11y_item = if frame.a11y_enabled() {
649            let row_bounds = row_area.intersection(&frame.buffer.current_scissor());
650            if row_bounds.is_empty() {
651                None
652            } else {
653                let path = self
654                    .find_path_indices_at_visible_index(row_idx)
655                    .unwrap_or_default();
656                Some(self.build_a11y_item_node(
657                    node,
658                    depth,
659                    row_idx,
660                    row_bounds,
661                    a11y_root_id,
662                    &path,
663                ))
664            }
665        } else {
666            None
667        };
668
669        *current_row += 1;
670
671        if !node.expanded || node.children.is_empty() || *current_row >= area.height as usize {
672            if let Some(item_node) = a11y_item {
673                frame.push_a11y(item_node);
674            }
675            return;
676        }
677
678        let mut render_children = |frame: &mut Frame| {
679            let child_count = node.children.len();
680            for (i, child) in node.children.iter().enumerate() {
681                if *current_row >= area.height as usize {
682                    break;
683                }
684                is_last.push(i == child_count - 1);
685                self.render_node(
686                    child,
687                    depth + 1,
688                    is_last,
689                    area,
690                    frame,
691                    current_row,
692                    deg,
693                    a11y_root_id,
694                );
695                is_last.pop();
696            }
697        };
698
699        if let Some(item_node) = a11y_item {
700            frame.with_a11y_scope(item_node, render_children);
701        } else {
702            render_children(frame);
703        }
704    }
705}
706
707fn filter_node(node: &TreeNode, query_lower: &str) -> Option<TreeNode> {
708    let label_matches = crate::contains_ignore_case(&node.label, query_lower)
709        || node
710            .icon
711            .as_deref()
712            .is_some_and(|icon| crate::contains_ignore_case(icon, query_lower));
713
714    let mut filtered_children = Vec::new();
715    for child in &node.children {
716        if let Some(filtered) = filter_node(child, query_lower) {
717            filtered_children.push(filtered);
718        }
719    }
720
721    let mut filtered_lazy = Vec::new();
722    if let Some(lazy) = &node.lazy_children {
723        for child in lazy {
724            if let Some(filtered) = filter_node(child, query_lower) {
725                filtered_lazy.push(filtered);
726            }
727        }
728    }
729
730    if !label_matches && filtered_children.is_empty() && filtered_lazy.is_empty() {
731        return None;
732    }
733
734    let mut filtered = node.clone();
735    if label_matches {
736        // Search-mode render walks `children`, not `lazy_children`. When a node
737        // itself matches, render the same full subtree that path bookkeeping already
738        // exposes by eagerly materializing lazy descendants in the filtered clone.
739        filtered.materialize_all_lazy_children();
740        filtered.expanded = true;
741    } else {
742        // Materialize filtered lazy matches into `children` so render/flatten traversal,
743        // which walks `children`, includes lazy descendants that matched the query.
744        filtered.children = filtered_children;
745        filtered.children.extend(filtered_lazy);
746        filtered.lazy_children = None;
747        filtered.expanded = true;
748    }
749    Some(filtered)
750}
751
752struct FilteredPathNode {
753    expanded: bool,
754    children: Vec<(usize, FilteredPathNode)>,
755}
756
757fn create_unfiltered_path_node(node: &TreeNode) -> FilteredPathNode {
758    let mut children = Vec::new();
759    for (idx, child) in node.children.iter().enumerate() {
760        children.push((idx, create_unfiltered_path_node(child)));
761    }
762    let lazy_offset = node.children.len();
763    if let Some(lazy) = &node.lazy_children {
764        for (idx, child) in lazy.iter().enumerate() {
765            children.push((lazy_offset + idx, create_unfiltered_path_node(child)));
766        }
767    }
768    FilteredPathNode {
769        expanded: node.expanded,
770        children,
771    }
772}
773
774fn filter_node_paths(
775    node: &TreeNode,
776    query_lower: &str,
777) -> Option<(bool, Vec<(usize, FilteredPathNode)>)> {
778    let label_matches = crate::contains_ignore_case(&node.label, query_lower)
779        || node
780            .icon
781            .as_deref()
782            .is_some_and(|icon| crate::contains_ignore_case(icon, query_lower));
783
784    if label_matches {
785        let mut children = Vec::new();
786        for (idx, child) in node.children.iter().enumerate() {
787            children.push((idx, create_unfiltered_path_node(child)));
788        }
789        let lazy_offset = node.children.len();
790        if let Some(lazy) = &node.lazy_children {
791            for (idx, child) in lazy.iter().enumerate() {
792                children.push((lazy_offset + idx, create_unfiltered_path_node(child)));
793            }
794        }
795        return Some((true, children));
796    }
797
798    let mut filtered_children = Vec::new();
799    for (idx, child) in node.children.iter().enumerate() {
800        if let Some(filtered) = filter_node_paths(child, query_lower) {
801            filtered_children.push((
802                idx,
803                FilteredPathNode {
804                    expanded: filtered.0,
805                    children: filtered.1,
806                },
807            ));
808        }
809    }
810
811    let mut filtered_lazy = Vec::new();
812    let lazy_offset = node.children.len();
813    if let Some(lazy) = &node.lazy_children {
814        for (idx, child) in lazy.iter().enumerate() {
815            if let Some(filtered) = filter_node_paths(child, query_lower) {
816                filtered_lazy.push((
817                    lazy_offset + idx,
818                    FilteredPathNode {
819                        expanded: filtered.0,
820                        children: filtered.1,
821                    },
822                ));
823            }
824        }
825    }
826
827    if filtered_children.is_empty() && filtered_lazy.is_empty() {
828        return None;
829    }
830
831    filtered_children.extend(filtered_lazy);
832    Some((true, filtered_children))
833}
834
835impl Widget for Tree {
836    fn render(&self, area: Rect, frame: &mut Frame) {
837        if area.width == 0 || area.height == 0 {
838            return;
839        }
840
841        #[cfg(feature = "tracing")]
842        let render_start = Instant::now();
843        #[cfg(feature = "tracing")]
844        let total_nodes = self.total_nodes();
845        #[cfg(feature = "tracing")]
846        let visible_nodes = self.visible_nodes();
847        #[cfg(feature = "tracing")]
848        let expanded_count = self.expanded_nodes();
849        #[cfg(feature = "tracing")]
850        let render_span = tracing::debug_span!(
851            "tree.render",
852            total_nodes,
853            visible_nodes,
854            expanded_count,
855            render_duration_us = tracing::field::Empty,
856        );
857        #[cfg(feature = "tracing")]
858        let _render_guard = render_span.enter();
859
860        let deg = frame.buffer.degradation;
861        let base_style = if deg.apply_styling() {
862            self.label_style
863        } else {
864            Style::default()
865        };
866        clear_text_area(frame, area, base_style);
867        let mut current_row = 0;
868        let mut is_last = Vec::with_capacity(8);
869
870        let search_query = self
871            .search_query
872            .as_deref()
873            .filter(|q| !q.trim().is_empty());
874        let is_searching = search_query.is_some();
875        let filtered_root = if let Some(q) = search_query {
876            let query_lower = q.trim().to_lowercase();
877            filter_node(&self.root, &query_lower)
878        } else {
879            Some(self.root.clone())
880        };
881
882        let a11y_root_id = self.accessibility_root_id(area);
883        let a11y_bounds = area.intersection(&frame.buffer.current_scissor());
884        let tree_title = if self.root.label().trim().is_empty() {
885            "Tree"
886        } else {
887            self.root.label()
888        };
889
890        if is_searching && filtered_root.is_none() {
891            if frame.a11y_enabled() && !a11y_bounds.is_empty() {
892                let root_node = ftui_a11y::node::A11yNodeInfo::new(
893                    a11y_root_id,
894                    ftui_a11y::node::A11yRole::List,
895                    a11y_bounds,
896                )
897                .with_name(tree_title)
898                .with_description("0 matching items");
899                frame.push_a11y(root_node);
900            }
901            #[cfg(feature = "tracing")]
902            {
903                let elapsed = render_start.elapsed();
904                let elapsed_us = elapsed.as_micros() as u64;
905                render_span.record("render_duration_us", elapsed_us);
906                tracing::debug!(
907                    render_duration_us = elapsed_us,
908                    "Tree render complete (empty search)"
909                );
910            }
911            return;
912        }
913
914        let root_fallback = self.root.clone();
915        let root = filtered_root.as_ref().unwrap_or(&root_fallback);
916
917        let visible_item_count = if self.show_root {
918            root.visible_count()
919        } else if root.expanded {
920            root.children.iter().fold(0usize, |acc, child| {
921                acc.saturating_add(child.visible_count())
922            })
923        } else {
924            0
925        };
926
927        let mut render_tree_rows = |frame: &mut Frame| {
928            if self.show_root {
929                self.render_node(
930                    root,
931                    0,
932                    &mut is_last,
933                    area,
934                    frame,
935                    &mut current_row,
936                    deg,
937                    a11y_root_id,
938                );
939            } else if root.expanded {
940                // If root is hidden but expanded, render children as top-level nodes.
941                // We do NOT push to is_last for the root level, effectively shifting
942                // the hierarchy up by one level.
943                let child_count = root.children.len();
944                for (i, child) in root.children.iter().enumerate() {
945                    is_last.push(i == child_count - 1);
946                    self.render_node(
947                        child,
948                        0, // Children become depth 0
949                        &mut is_last,
950                        area,
951                        frame,
952                        &mut current_row,
953                        deg,
954                        a11y_root_id,
955                    );
956                    is_last.pop();
957                }
958            }
959        };
960
961        if frame.a11y_enabled() && !a11y_bounds.is_empty() {
962            let desc = if is_searching {
963                format!("{visible_item_count} matching items")
964            } else {
965                format!("{visible_item_count} visible items")
966            };
967            let root_node = ftui_a11y::node::A11yNodeInfo::new(
968                a11y_root_id,
969                ftui_a11y::node::A11yRole::List,
970                a11y_bounds,
971            )
972            .with_name(tree_title)
973            .with_description(desc);
974            frame.with_a11y_scope(root_node, render_tree_rows);
975        } else {
976            render_tree_rows(frame);
977        }
978
979        #[cfg(feature = "tracing")]
980        {
981            let elapsed = render_start.elapsed();
982            let elapsed_us = elapsed.as_micros() as u64;
983            render_span.record("render_duration_us", elapsed_us);
984            tracing::debug!(
985                message = "tree.metrics",
986                tree_render_duration_us = elapsed_us,
987                total_nodes,
988                visible_nodes,
989                expanded_count
990            );
991        }
992    }
993
994    fn is_essential(&self) -> bool {
995        false
996    }
997}
998
999impl ftui_a11y::Accessible for Tree {
1000    fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
1001        if area.is_empty() {
1002            return Vec::new();
1003        }
1004        let mut pool = ftui_render::grapheme_pool::GraphemePool::new();
1005        let mut builder = ftui_a11y::tree::A11yTreeBuilder::new();
1006        let width = area.right().max(1);
1007        let height = area.bottom().max(1);
1008        let order = {
1009            let mut frame = Frame::new(width, height, &mut pool);
1010            frame.set_a11y(&mut builder);
1011            Widget::render(self, area, &mut frame);
1012            frame.finish_a11y();
1013            frame.take_a11y_order()
1014        };
1015        let tree = builder.build();
1016        order
1017            .into_iter()
1018            .filter_map(|id| tree.node(id).cloned())
1019            .collect()
1020    }
1021}
1022
1023// ============================================================================
1024// Stateful Persistence Implementation
1025// ============================================================================
1026
1027/// Persistable state for a [`Tree`] widget.
1028///
1029/// Stores the set of expanded node paths to restore tree expansion state.
1030#[derive(Clone, Debug, Default, PartialEq)]
1031#[cfg_attr(
1032    feature = "state-persistence",
1033    derive(serde::Serialize, serde::Deserialize)
1034)]
1035pub struct TreePersistState {
1036    /// Set of expanded node paths (e.g., "root/src/main.rs").
1037    pub expanded_paths: HashSet<String>,
1038}
1039
1040impl crate::stateful::Stateful for Tree {
1041    type State = TreePersistState;
1042
1043    fn state_key(&self) -> Option<crate::stateful::StateKey> {
1044        // No persistence_id, no identity: two unnamed trees must not share one.
1045        self.persistence_id
1046            .as_deref()
1047            .map(|id| crate::stateful::StateKey::new("Tree", id))
1048    }
1049
1050    fn save_state(&self) -> TreePersistState {
1051        let mut expanded_paths = HashSet::new();
1052        self.root.collect_expanded("", &mut expanded_paths);
1053        TreePersistState { expanded_paths }
1054    }
1055
1056    fn restore_state(&mut self, state: TreePersistState) {
1057        self.root.apply_expanded("", &state.expanded_paths);
1058    }
1059}
1060
1061// ============================================================================
1062// Undo Support Implementation
1063// ============================================================================
1064
1065impl UndoSupport for Tree {
1066    fn undo_widget_id(&self) -> UndoWidgetId {
1067        self.undo_id
1068    }
1069
1070    fn create_snapshot(&self) -> Box<dyn Any + Send> {
1071        Box::new(self.save_state())
1072    }
1073
1074    fn restore_snapshot(&mut self, snapshot: &dyn Any) -> bool {
1075        if let Some(snap) = snapshot.downcast_ref::<TreePersistState>() {
1076            self.restore_state(snap.clone());
1077            true
1078        } else {
1079            false
1080        }
1081    }
1082}
1083
1084impl TreeUndoExt for Tree {
1085    fn is_node_expanded(&self, path: &[usize]) -> bool {
1086        self.get_node_at_path(path)
1087            .map(|node| node.is_expanded())
1088            .unwrap_or(false)
1089    }
1090
1091    fn expand_node(&mut self, path: &[usize]) {
1092        if let Some(node) = self.get_node_at_path_mut(path) {
1093            node.materialize_lazy_children();
1094            node.expanded = true;
1095        }
1096    }
1097
1098    fn collapse_node(&mut self, path: &[usize]) {
1099        if let Some(node) = self.get_node_at_path_mut(path) {
1100            node.expanded = false;
1101        }
1102    }
1103}
1104
1105impl Tree {
1106    /// Get the undo widget ID for this tree.
1107    #[must_use]
1108    pub fn undo_id(&self) -> UndoWidgetId {
1109        self.undo_id
1110    }
1111
1112    /// Get a reference to a node at the given path (indices from root).
1113    fn get_node_at_path(&self, path: &[usize]) -> Option<&TreeNode> {
1114        let mut current = &self.root;
1115        for &idx in path {
1116            current = current.children.get(idx)?;
1117        }
1118        Some(current)
1119    }
1120
1121    /// Get a mutable reference to a node at the given path (indices from root).
1122    fn get_node_at_path_mut(&mut self, path: &[usize]) -> Option<&mut TreeNode> {
1123        let mut current = &mut self.root;
1124        for &idx in path {
1125            current = current.children.get_mut(idx)?;
1126        }
1127        Some(current)
1128    }
1129
1130    #[cfg(feature = "tracing")]
1131    fn log_expand_collapse(action: &str, source: &str, index: usize, label: &str) {
1132        tracing::debug!(
1133            message = "tree.toggle",
1134            action,
1135            source,
1136            visible_index = index,
1137            label
1138        );
1139    }
1140
1141    fn toggle_node_at_visible_index(&mut self, index: usize, source: &str) -> bool {
1142        #[cfg(not(feature = "tracing"))]
1143        let _ = source;
1144        let Some(node) = self.node_at_visible_index_mut(index) else {
1145            return false;
1146        };
1147        if !node.has_children() {
1148            return false;
1149        }
1150        #[cfg(feature = "tracing")]
1151        let action = if node.is_expanded() {
1152            "collapse"
1153        } else {
1154            "expand"
1155        };
1156        #[cfg(feature = "tracing")]
1157        let label = node.label().to_owned();
1158        node.toggle_expanded();
1159        #[cfg(feature = "tracing")]
1160        Self::log_expand_collapse(action, source, index, &label);
1161        true
1162    }
1163
1164    /// Handle keyboard navigation at the currently selected visible row.
1165    ///
1166    /// Supported keys:
1167    /// - **Enter / Space**: Toggle expand/collapse on the selected node.
1168    /// - **Right**: Expand the selected node (if collapsed and has children).
1169    /// - **Left**: Collapse the selected node (if expanded).
1170    ///
1171    /// Returns `true` when an expand/collapse action was applied.
1172    ///
1173    /// Acts on press and repeat, never release. Terminals with the kitty
1174    /// keyboard protocol's event types, and the web backend, report a release
1175    /// for every key, so Enter toggled a node open and straight back shut.
1176    pub fn handle_key(&mut self, key: &KeyEvent, selected_visible_index: usize) -> bool {
1177        if key.kind == KeyEventKind::Release {
1178            return false;
1179        }
1180        match key.code {
1181            KeyCode::Enter | KeyCode::Char(' ') => {
1182                self.toggle_node_at_visible_index(selected_visible_index, "keyboard")
1183            }
1184            KeyCode::Right => {
1185                // Expand if collapsed and has children.
1186                if let Some(node) = self.node_at_visible_index_mut(selected_visible_index)
1187                    && !node.is_expanded()
1188                    && node.has_children()
1189                {
1190                    #[cfg(feature = "tracing")]
1191                    let label = node.label().to_owned();
1192                    node.toggle_expanded();
1193                    #[cfg(feature = "tracing")]
1194                    Self::log_expand_collapse("expand", "keyboard", selected_visible_index, &label);
1195                    return true;
1196                }
1197                false
1198            }
1199            KeyCode::Left => {
1200                // Collapse if expanded.
1201                if let Some(node) = self.node_at_visible_index_mut(selected_visible_index)
1202                    && node.is_expanded()
1203                    && node.has_children()
1204                {
1205                    #[cfg(feature = "tracing")]
1206                    let label = node.label().to_owned();
1207                    node.toggle_expanded();
1208                    #[cfg(feature = "tracing")]
1209                    Self::log_expand_collapse(
1210                        "collapse",
1211                        "keyboard",
1212                        selected_visible_index,
1213                        &label,
1214                    );
1215                    return true;
1216                }
1217                false
1218            }
1219            _ => false,
1220        }
1221    }
1222
1223    /// Handle a mouse event for this tree.
1224    ///
1225    /// # Hit data convention
1226    ///
1227    /// The hit data (`u64`) encodes the flattened visible row index. When the
1228    /// tree renders with a `hit_id`, each visible row registers
1229    /// `HitRegion::Content` with `data = visible_row_index as u64`.
1230    ///
1231    /// Clicking a parent node (one with children) toggles its expanded state
1232    /// and returns `Activated`. Clicking a leaf returns `Selected`.
1233    ///
1234    /// # Arguments
1235    ///
1236    /// * `event` — the mouse event from the terminal
1237    /// * `hit` — result of `frame.hit_test(event.x, event.y)`, if available
1238    /// * `expected_id` — the `HitId` this tree was rendered with
1239    pub fn handle_mouse(
1240        &mut self,
1241        event: &MouseEvent,
1242        hit: Option<(HitId, HitRegion, u64)>,
1243        expected_id: HitId,
1244    ) -> MouseResult {
1245        match event.kind {
1246            MouseEventKind::Down(MouseButton::Left) => {
1247                if let Some((id, HitRegion::Content, data)) = hit
1248                    && id == expected_id
1249                {
1250                    let index = data as usize;
1251                    if let Some(node) = self.node_at_visible_index_mut(index)
1252                        && !node.has_children()
1253                    {
1254                        return MouseResult::Selected(index);
1255                    }
1256                    if self.toggle_node_at_visible_index(index, "mouse") {
1257                        return MouseResult::Activated(index);
1258                    }
1259                }
1260                MouseResult::Ignored
1261            }
1262            _ => MouseResult::Ignored,
1263        }
1264    }
1265
1266    /// Get a mutable reference to the node at the given visible (flattened) index.
1267    ///
1268    /// The traversal order matches `render_node()`: if `show_root` is true the
1269    /// root is row 0; otherwise children of the root are the top-level rows.
1270    /// Only expanded nodes' children are visited.
1271    pub fn node_at_visible_index_mut(&mut self, target: usize) -> Option<&mut TreeNode> {
1272        let path = self.find_path_indices_at_visible_index(target)?;
1273
1274        let mut current = &mut self.root;
1275        for &idx in &path {
1276            current.materialize_lazy_children();
1277            current = current.children.get_mut(idx)?;
1278        }
1279        Some(current)
1280    }
1281
1282    fn find_path_indices_at_visible_index(&self, target: usize) -> Option<Vec<usize>> {
1283        let query = self
1284            .search_query
1285            .as_deref()
1286            .map(str::trim)
1287            .filter(|q| !q.is_empty());
1288        let mut counter = 0usize;
1289        let mut path = Vec::new();
1290
1291        if let Some(q) = query {
1292            let query_lower = q.to_lowercase();
1293            let (expanded, children) = filter_node_paths(&self.root, &query_lower)?;
1294            let root_node = FilteredPathNode { expanded, children };
1295
1296            if self.show_root {
1297                Self::walk_filtered_path(&root_node, target, &mut counter, &mut path)
1298            } else if root_node.expanded {
1299                for &(idx, ref child) in &root_node.children {
1300                    path.push(idx);
1301                    if let Some(p) =
1302                        Self::walk_filtered_path(child, target, &mut counter, &mut path)
1303                    {
1304                        return Some(p);
1305                    }
1306                    path.pop();
1307                }
1308                None
1309            } else {
1310                None
1311            }
1312        } else {
1313            if self.show_root {
1314                Self::walk_visible_index_path(&self.root, target, &mut counter, &mut path)
1315            } else if self.root.expanded {
1316                for (idx, child) in self.root.children.iter().enumerate() {
1317                    path.push(idx);
1318                    if let Some(p) =
1319                        Self::walk_visible_index_path(child, target, &mut counter, &mut path)
1320                    {
1321                        return Some(p);
1322                    }
1323                    path.pop();
1324                }
1325                None
1326            } else {
1327                None
1328            }
1329        }
1330    }
1331
1332    fn walk_filtered_path(
1333        node: &FilteredPathNode,
1334        target: usize,
1335        counter: &mut usize,
1336        current_path: &mut Vec<usize>,
1337    ) -> Option<Vec<usize>> {
1338        if *counter == target {
1339            return Some(current_path.clone());
1340        }
1341        *counter += 1;
1342        if node.expanded {
1343            for &(idx, ref child) in &node.children {
1344                current_path.push(idx);
1345                if let Some(found) = Self::walk_filtered_path(child, target, counter, current_path)
1346                {
1347                    return Some(found);
1348                }
1349                current_path.pop();
1350            }
1351        }
1352        None
1353    }
1354
1355    fn walk_visible_index_path(
1356        node: &TreeNode,
1357        target: usize,
1358        counter: &mut usize,
1359        current_path: &mut Vec<usize>,
1360    ) -> Option<Vec<usize>> {
1361        if *counter == target {
1362            return Some(current_path.clone());
1363        }
1364        *counter += 1;
1365        if node.expanded {
1366            for (idx, child) in node.children.iter().enumerate() {
1367                current_path.push(idx);
1368                if let Some(found) =
1369                    Self::walk_visible_index_path(child, target, counter, current_path)
1370                {
1371                    return Some(found);
1372                }
1373                current_path.pop();
1374            }
1375        }
1376        None
1377    }
1378}
1379
1380// ---------------------------------------------------------------------------
1381// Test-only flatten helpers
1382// ---------------------------------------------------------------------------
1383
1384#[cfg(test)]
1385#[derive(Debug, Clone, PartialEq, Eq)]
1386struct FlatNode {
1387    label: String,
1388    depth: usize,
1389}
1390
1391#[cfg(test)]
1392fn flatten_visible(node: &TreeNode, depth: usize, out: &mut Vec<FlatNode>) {
1393    out.push(FlatNode {
1394        label: node.label.clone(),
1395        depth,
1396    });
1397    if node.expanded {
1398        for child in &node.children {
1399            flatten_visible(child, depth + 1, out);
1400        }
1401    }
1402}
1403
1404#[cfg(test)]
1405impl Tree {
1406    fn flatten(&self) -> Vec<FlatNode> {
1407        let mut out = Vec::new();
1408        let search_query = self
1409            .search_query
1410            .as_deref()
1411            .filter(|q| !q.trim().is_empty());
1412        let is_searching = search_query.is_some();
1413        let filtered_root = if let Some(q) = search_query {
1414            let query_lower = q.trim().to_lowercase();
1415            filter_node(&self.root, &query_lower)
1416        } else {
1417            Some(self.root.clone())
1418        };
1419
1420        if is_searching && filtered_root.is_none() {
1421            return out;
1422        }
1423
1424        let root_fallback = self.root.clone();
1425        let root = filtered_root.as_ref().unwrap_or(&root_fallback);
1426        if self.show_root {
1427            flatten_visible(root, 0, &mut out);
1428        } else if root.expanded {
1429            for child in &root.children {
1430                flatten_visible(child, 0, &mut out);
1431            }
1432        }
1433        out
1434    }
1435}
1436
1437#[cfg(test)]
1438mod tests {
1439    use super::*;
1440    use ftui_render::frame::Frame;
1441    use ftui_render::grapheme_pool::GraphemePool;
1442    #[cfg(feature = "tracing")]
1443    use std::sync::{Arc, Mutex};
1444    #[cfg(feature = "tracing")]
1445    use tracing::Subscriber;
1446    #[cfg(feature = "tracing")]
1447    use tracing_subscriber::Layer;
1448    #[cfg(feature = "tracing")]
1449    use tracing_subscriber::layer::{Context, SubscriberExt};
1450
1451    fn line_text(frame: &Frame, y: u16, width: u16) -> String {
1452        (0..width)
1453            .map(|x| {
1454                frame
1455                    .buffer
1456                    .get(x, y)
1457                    .and_then(|cell| cell.content.as_char())
1458                    .unwrap_or(' ')
1459            })
1460            .collect()
1461    }
1462
1463    fn simple_tree() -> TreeNode {
1464        TreeNode::new("root")
1465            .child(
1466                TreeNode::new("a")
1467                    .child(TreeNode::new("a1"))
1468                    .child(TreeNode::new("a2")),
1469            )
1470            .child(TreeNode::new("b"))
1471    }
1472
1473    #[cfg(feature = "tracing")]
1474    #[derive(Debug, Default)]
1475    struct TreeTraceState {
1476        tree_render_seen: bool,
1477        has_total_nodes_field: bool,
1478        has_visible_nodes_field: bool,
1479        has_expanded_count_field: bool,
1480        render_duration_recorded: bool,
1481        toggle_events: usize,
1482    }
1483
1484    #[cfg(feature = "tracing")]
1485    struct TreeTraceCapture {
1486        state: Arc<Mutex<TreeTraceState>>,
1487    }
1488
1489    #[cfg(feature = "tracing")]
1490    impl<S> Layer<S> for TreeTraceCapture
1491    where
1492        S: Subscriber + for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>,
1493    {
1494        fn on_new_span(
1495            &self,
1496            attrs: &tracing::span::Attributes<'_>,
1497            _id: &tracing::Id,
1498            _ctx: Context<'_, S>,
1499        ) {
1500            if attrs.metadata().name() != "tree.render" {
1501                return;
1502            }
1503            let fields = attrs.metadata().fields();
1504            let mut state = self.state.lock().expect("tree trace state lock");
1505            state.tree_render_seen = true;
1506            state.has_total_nodes_field |= fields.field("total_nodes").is_some();
1507            state.has_visible_nodes_field |= fields.field("visible_nodes").is_some();
1508            state.has_expanded_count_field |= fields.field("expanded_count").is_some();
1509        }
1510
1511        fn on_record(
1512            &self,
1513            id: &tracing::Id,
1514            values: &tracing::span::Record<'_>,
1515            ctx: Context<'_, S>,
1516        ) {
1517            let Some(span) = ctx.span(id) else {
1518                return;
1519            };
1520            if span.metadata().name() != "tree.render" {
1521                return;
1522            }
1523
1524            struct DurationVisitor {
1525                saw_duration: bool,
1526            }
1527            impl tracing::field::Visit for DurationVisitor {
1528                fn record_u64(&mut self, field: &tracing::field::Field, _value: u64) {
1529                    if field.name() == "render_duration_us" {
1530                        self.saw_duration = true;
1531                    }
1532                }
1533
1534                fn record_debug(
1535                    &mut self,
1536                    field: &tracing::field::Field,
1537                    _value: &dyn std::fmt::Debug,
1538                ) {
1539                    if field.name() == "render_duration_us" {
1540                        self.saw_duration = true;
1541                    }
1542                }
1543            }
1544
1545            let mut visitor = DurationVisitor {
1546                saw_duration: false,
1547            };
1548            values.record(&mut visitor);
1549            if visitor.saw_duration {
1550                self.state
1551                    .lock()
1552                    .expect("tree trace state lock")
1553                    .render_duration_recorded = true;
1554            }
1555        }
1556
1557        fn on_event(&self, event: &tracing::Event<'_>, _ctx: Context<'_, S>) {
1558            struct MessageVisitor {
1559                message: Option<String>,
1560            }
1561            impl tracing::field::Visit for MessageVisitor {
1562                fn record_str(&mut self, field: &tracing::field::Field, value: &str) {
1563                    if field.name() == "message" {
1564                        self.message = Some(value.to_owned());
1565                    }
1566                }
1567
1568                fn record_debug(
1569                    &mut self,
1570                    field: &tracing::field::Field,
1571                    value: &dyn std::fmt::Debug,
1572                ) {
1573                    if field.name() == "message" {
1574                        self.message = Some(format!("{value:?}").trim_matches('"').to_owned());
1575                    }
1576                }
1577            }
1578
1579            let mut visitor = MessageVisitor { message: None };
1580            event.record(&mut visitor);
1581            if visitor.message.as_deref() == Some("tree.toggle") {
1582                let mut state = self.state.lock().expect("tree trace state lock");
1583                state.toggle_events = state.toggle_events.saturating_add(1);
1584            }
1585        }
1586    }
1587
1588    #[test]
1589    fn tree_node_basics() {
1590        let node = TreeNode::new("hello");
1591        assert_eq!(node.label(), "hello");
1592        assert!(node.children().is_empty());
1593        assert!(node.is_expanded());
1594    }
1595
1596    #[test]
1597    fn tree_node_children() {
1598        let root = simple_tree();
1599        assert_eq!(root.children().len(), 2);
1600        assert_eq!(root.children()[0].label(), "a");
1601        assert_eq!(root.children()[0].children().len(), 2);
1602    }
1603
1604    #[test]
1605    fn tree_node_visible_count() {
1606        let root = simple_tree();
1607        // root + a + a1 + a2 + b = 5
1608        assert_eq!(root.visible_count(), 5);
1609    }
1610
1611    #[test]
1612    fn tree_node_collapsed() {
1613        let root = TreeNode::new("root")
1614            .child(
1615                TreeNode::new("a")
1616                    .with_expanded(false)
1617                    .child(TreeNode::new("a1"))
1618                    .child(TreeNode::new("a2")),
1619            )
1620            .child(TreeNode::new("b"));
1621        // root + a (collapsed, so no a1/a2) + b = 3
1622        assert_eq!(root.visible_count(), 3);
1623    }
1624
1625    #[test]
1626    fn tree_node_toggle() {
1627        let mut node = TreeNode::new("x");
1628        assert!(node.is_expanded());
1629        node.toggle_expanded();
1630        assert!(!node.is_expanded());
1631        node.toggle_expanded();
1632        assert!(node.is_expanded());
1633    }
1634
1635    #[test]
1636    fn tree_node_lazy_children_materialize_on_expand() {
1637        let mut node = TreeNode::new("root")
1638            .with_lazy_children(vec![TreeNode::new("child"), TreeNode::new("child2")]);
1639        assert!(!node.is_expanded());
1640        assert_eq!(node.children().len(), 0);
1641        assert!(node.has_children());
1642
1643        node.toggle_expanded();
1644        assert!(node.is_expanded());
1645        assert_eq!(node.children().len(), 2);
1646    }
1647
1648    #[test]
1649    fn tree_guides_unicode() {
1650        let g = TreeGuides::Unicode;
1651        assert!(g.branch().contains('├'));
1652        assert!(g.last().contains('└'));
1653        assert!(g.vertical().contains('│'));
1654    }
1655
1656    #[test]
1657    fn tree_guides_ascii() {
1658        let g = TreeGuides::Ascii;
1659        assert!(g.branch().contains('+'));
1660        assert!(g.vertical().contains('|'));
1661    }
1662
1663    #[test]
1664    fn tree_guides_width() {
1665        for g in [
1666            TreeGuides::Ascii,
1667            TreeGuides::Unicode,
1668            TreeGuides::Bold,
1669            TreeGuides::Double,
1670            TreeGuides::Rounded,
1671        ] {
1672            assert_eq!(g.width(), 4);
1673        }
1674    }
1675
1676    #[test]
1677    fn tree_render_basic() {
1678        let tree = Tree::new(simple_tree());
1679
1680        let mut pool = GraphemePool::new();
1681        let mut frame = Frame::new(40, 10, &mut pool);
1682        let area = Rect::new(0, 0, 40, 10);
1683        tree.render(area, &mut frame);
1684
1685        // Root label at (0, 0)
1686        let cell = frame.buffer.get(0, 0).unwrap();
1687        assert_eq!(cell.content.as_char(), Some('r'));
1688    }
1689
1690    #[test]
1691    fn tree_render_guides_present() {
1692        let tree = Tree::new(simple_tree()).with_guides(TreeGuides::Ascii);
1693
1694        let mut pool = GraphemePool::new();
1695        let mut frame = Frame::new(40, 10, &mut pool);
1696        let area = Rect::new(0, 0, 40, 10);
1697        tree.render(area, &mut frame);
1698
1699        // Row 1 should be child "a" with branch guide "+-- "
1700        // First char of guide at (0, 1)
1701        let cell = frame.buffer.get(0, 1).unwrap();
1702        assert_eq!(cell.content.as_char(), Some('+'));
1703    }
1704
1705    #[test]
1706    fn tree_render_last_guide() {
1707        let tree = Tree::new(
1708            TreeNode::new("root")
1709                .child(TreeNode::new("a"))
1710                .child(TreeNode::new("b")),
1711        )
1712        .with_guides(TreeGuides::Ascii);
1713
1714        let mut pool = GraphemePool::new();
1715        let mut frame = Frame::new(40, 10, &mut pool);
1716        let area = Rect::new(0, 0, 40, 10);
1717        tree.render(area, &mut frame);
1718
1719        // Row 1: "+-- a" (not last)
1720        let cell = frame.buffer.get(0, 1).unwrap();
1721        assert_eq!(cell.content.as_char(), Some('+'));
1722
1723        // Row 2: "`-- b" (last child)
1724        let cell = frame.buffer.get(0, 2).unwrap();
1725        assert_eq!(cell.content.as_char(), Some('`'));
1726    }
1727
1728    #[test]
1729    fn tree_render_icon_before_label() {
1730        let tree = Tree::new(TreeNode::new("root").with_icon(">"));
1731        let mut pool = GraphemePool::new();
1732        let mut frame = Frame::new(12, 2, &mut pool);
1733        tree.render(Rect::new(0, 0, 12, 2), &mut frame);
1734
1735        assert_eq!(
1736            frame.buffer.get(0, 0).and_then(|c| c.content.as_char()),
1737            Some('>')
1738        );
1739        assert_eq!(
1740            frame.buffer.get(2, 0).and_then(|c| c.content.as_char()),
1741            Some('r')
1742        );
1743    }
1744
1745    #[test]
1746    fn tree_search_query_filters_to_matching_branches() {
1747        let tree = Tree::new(
1748            TreeNode::new("root")
1749                .child(TreeNode::new("alpha").child(TreeNode::new("target-file")))
1750                .child(TreeNode::new("beta")),
1751        )
1752        .with_search_query("target");
1753
1754        let flat = tree.flatten();
1755        assert_eq!(flat.len(), 3);
1756        assert_eq!(flat[0].label, "root");
1757        assert_eq!(flat[1].label, "alpha");
1758        assert_eq!(flat[2].label, "target-file");
1759    }
1760
1761    #[test]
1762    fn tree_search_query_includes_lazy_matching_descendants() {
1763        let tree =
1764            Tree::new(TreeNode::new("root").child(
1765                TreeNode::new("alpha").with_lazy_children(vec![TreeNode::new("target-file")]),
1766            ))
1767            .with_search_query("target");
1768
1769        let flat = tree.flatten();
1770        assert_eq!(flat.len(), 3);
1771        assert_eq!(flat[0].label, "root");
1772        assert_eq!(flat[1].label, "alpha");
1773        assert_eq!(flat[2].label, "target-file");
1774    }
1775
1776    #[test]
1777    fn tree_search_query_on_matching_parent_includes_immediate_lazy_children() {
1778        let tree = Tree::new(TreeNode::new("root").child(
1779            TreeNode::new("alpha").with_lazy_children(vec![
1780                TreeNode::new("lazy-child")
1781                    .with_lazy_children(vec![TreeNode::new("deep-grandchild")]),
1782            ]),
1783        ))
1784        .with_search_query("alpha");
1785
1786        let flat = tree.flatten();
1787        assert_eq!(flat.len(), 3);
1788        assert_eq!(flat[0].label, "root");
1789        assert_eq!(flat[1].label, "alpha");
1790        assert_eq!(flat[2].label, "lazy-child");
1791    }
1792
1793    #[test]
1794    fn tree_render_zero_area() {
1795        let tree = Tree::new(simple_tree());
1796        let mut pool = GraphemePool::new();
1797        let mut frame = Frame::new(40, 10, &mut pool);
1798        tree.render(Rect::new(0, 0, 0, 0), &mut frame); // No panic
1799    }
1800
1801    #[test]
1802    fn tree_render_shorter_label_clears_stale_suffix() {
1803        let mut pool = GraphemePool::new();
1804        let mut frame = Frame::new(20, 3, &mut pool);
1805        let area = Rect::new(0, 0, 20, 3);
1806
1807        Tree::new(TreeNode::new("root-with-long-tail")).render(area, &mut frame);
1808        Tree::new(TreeNode::new("r")).render(area, &mut frame);
1809
1810        assert_eq!(line_text(&frame, 0, 20), "r                   ");
1811        assert_eq!(line_text(&frame, 1, 20), "                    ");
1812        assert_eq!(line_text(&frame, 2, 20), "                    ");
1813    }
1814
1815    #[test]
1816    fn tree_render_truncated_height() {
1817        let tree = Tree::new(simple_tree());
1818        let mut pool = GraphemePool::new();
1819        let mut frame = Frame::new(40, 2, &mut pool);
1820        let area = Rect::new(0, 0, 40, 2);
1821        tree.render(area, &mut frame); // Only first 2 rows render, no panic
1822    }
1823
1824    #[test]
1825    fn is_not_essential() {
1826        let tree = Tree::new(TreeNode::new("x"));
1827        assert!(!tree.is_essential());
1828    }
1829
1830    #[test]
1831    fn tree_root_access() {
1832        let mut tree = Tree::new(TreeNode::new("root"));
1833        assert_eq!(tree.root().label(), "root");
1834        tree.root_mut().toggle_expanded();
1835        assert!(!tree.root().is_expanded());
1836    }
1837
1838    #[test]
1839    fn tree_guides_default() {
1840        let g = TreeGuides::default();
1841        assert_eq!(g, TreeGuides::Unicode);
1842    }
1843
1844    #[test]
1845    fn tree_guides_rounded() {
1846        let g = TreeGuides::Rounded;
1847        assert!(g.last().contains('╰'));
1848    }
1849
1850    #[test]
1851    fn tree_deep_nesting() {
1852        let node = TreeNode::new("d3");
1853        let node = TreeNode::new("d2").child(node);
1854        let node = TreeNode::new("d1").child(node);
1855        let root = TreeNode::new("root").child(node);
1856
1857        let tree = Tree::new(root);
1858        let flat = tree.flatten();
1859        assert_eq!(flat.len(), 4);
1860        assert_eq!(flat[3].depth, 3);
1861    }
1862
1863    #[test]
1864    fn tree_node_with_children_vec() {
1865        let root = TreeNode::new("root").with_children(vec![
1866            TreeNode::new("a"),
1867            TreeNode::new("b"),
1868            TreeNode::new("c"),
1869        ]);
1870        assert_eq!(root.children().len(), 3);
1871    }
1872
1873    // --- Stateful Persistence tests ---
1874
1875    use crate::stateful::Stateful;
1876
1877    #[test]
1878    fn tree_with_persistence_id() {
1879        let tree = Tree::new(TreeNode::new("root")).with_persistence_id("file-tree");
1880        assert_eq!(tree.persistence_id(), Some("file-tree"));
1881    }
1882
1883    #[test]
1884    fn tree_default_no_persistence_id() {
1885        let tree = Tree::new(TreeNode::new("root"));
1886        assert_eq!(tree.persistence_id(), None);
1887    }
1888
1889    #[test]
1890    fn tree_save_restore_round_trip() {
1891        // Create tree with some nodes expanded, some collapsed
1892        let mut tree = Tree::new(
1893            TreeNode::new("root")
1894                .child(
1895                    TreeNode::new("src")
1896                        .child(TreeNode::new("main.rs"))
1897                        .child(TreeNode::new("lib.rs")),
1898                )
1899                .child(TreeNode::new("tests").with_expanded(false)),
1900        )
1901        .with_persistence_id("test");
1902
1903        // Verify initial state: root and src expanded, tests collapsed
1904        assert!(tree.root().is_expanded());
1905        assert!(tree.root().children()[0].is_expanded()); // src
1906        assert!(!tree.root().children()[1].is_expanded()); // tests
1907
1908        let saved = tree.save_state();
1909
1910        // Verify saved state captures expanded nodes
1911        assert!(saved.expanded_paths.contains("root"));
1912        assert!(saved.expanded_paths.contains("root/src"));
1913        assert!(!saved.expanded_paths.contains("root/tests"));
1914
1915        // Modify tree state (collapse src)
1916        tree.root_mut().children[0].toggle_expanded();
1917        assert!(!tree.root().children()[0].is_expanded());
1918
1919        // Restore
1920        tree.restore_state(saved);
1921
1922        // Verify restored state
1923        assert!(tree.root().is_expanded());
1924        assert!(tree.root().children()[0].is_expanded()); // src restored
1925        assert!(!tree.root().children()[1].is_expanded()); // tests still collapsed
1926    }
1927
1928    #[test]
1929    fn tree_state_key_uses_persistence_id() {
1930        let tree = Tree::new(TreeNode::new("root")).with_persistence_id("project-explorer");
1931        let key = tree.state_key().expect("named tree has a key");
1932        assert_eq!(key.widget_type, "Tree");
1933        assert_eq!(key.instance_id, "project-explorer");
1934    }
1935
1936    #[test]
1937    fn tree_without_id_is_not_persisted() {
1938        assert!(Tree::new(TreeNode::new("root")).state_key().is_none());
1939    }
1940
1941    #[test]
1942    fn tree_persist_state_default() {
1943        let persist = TreePersistState::default();
1944        assert!(persist.expanded_paths.is_empty());
1945    }
1946
1947    #[test]
1948    fn tree_collect_expanded_only_includes_nodes_with_children() {
1949        let tree = Tree::new(
1950            TreeNode::new("root").child(TreeNode::new("leaf")), // leaf has no children
1951        );
1952
1953        let saved = tree.save_state();
1954
1955        // Only root is expanded (and has children)
1956        assert!(saved.expanded_paths.contains("root"));
1957        // leaf has no children, so it's not tracked
1958        assert!(!saved.expanded_paths.contains("root/leaf"));
1959    }
1960
1961    // ============================================================================
1962    // Undo Support Tests
1963    // ============================================================================
1964
1965    #[test]
1966    fn tree_undo_widget_id_unique() {
1967        let tree1 = Tree::new(TreeNode::new("root1"));
1968        let tree2 = Tree::new(TreeNode::new("root2"));
1969        assert_ne!(tree1.undo_id(), tree2.undo_id());
1970    }
1971
1972    #[test]
1973    fn tree_undo_snapshot_and_restore() {
1974        // Nodes must have children for their expanded state to be tracked
1975        let mut tree = Tree::new(
1976            TreeNode::new("root")
1977                .child(
1978                    TreeNode::new("a")
1979                        .with_expanded(true)
1980                        .child(TreeNode::new("a_child")),
1981                )
1982                .child(
1983                    TreeNode::new("b")
1984                        .with_expanded(false)
1985                        .child(TreeNode::new("b_child")),
1986                ),
1987        );
1988
1989        // Create snapshot
1990        let snapshot = tree.create_snapshot();
1991
1992        // Verify initial state
1993        assert!(tree.is_node_expanded(&[0])); // a
1994        assert!(!tree.is_node_expanded(&[1])); // b
1995
1996        // Modify state
1997        tree.collapse_node(&[0]); // collapse a
1998        tree.expand_node(&[1]); // expand b
1999        assert!(!tree.is_node_expanded(&[0]));
2000        assert!(tree.is_node_expanded(&[1]));
2001
2002        // Restore snapshot
2003        assert!(tree.restore_snapshot(&*snapshot));
2004
2005        // Verify restored state
2006        assert!(tree.is_node_expanded(&[0])); // a back to expanded
2007        assert!(!tree.is_node_expanded(&[1])); // b back to collapsed
2008    }
2009
2010    #[test]
2011    fn tree_expand_collapse_node() {
2012        let mut tree =
2013            Tree::new(TreeNode::new("root").child(TreeNode::new("child").with_expanded(true)));
2014
2015        // Initial state
2016        assert!(tree.is_node_expanded(&[0]));
2017
2018        // Collapse
2019        tree.collapse_node(&[0]);
2020        assert!(!tree.is_node_expanded(&[0]));
2021
2022        // Expand again
2023        tree.expand_node(&[0]);
2024        assert!(tree.is_node_expanded(&[0]));
2025    }
2026
2027    #[test]
2028    fn tree_node_path_navigation() {
2029        let tree = Tree::new(
2030            TreeNode::new("root")
2031                .child(
2032                    TreeNode::new("a")
2033                        .child(TreeNode::new("a1"))
2034                        .child(TreeNode::new("a2")),
2035                )
2036                .child(TreeNode::new("b")),
2037        );
2038
2039        // Test path navigation
2040        assert_eq!(tree.get_node_at_path(&[]).map(|n| n.label()), Some("root"));
2041        assert_eq!(tree.get_node_at_path(&[0]).map(|n| n.label()), Some("a"));
2042        assert_eq!(tree.get_node_at_path(&[1]).map(|n| n.label()), Some("b"));
2043        assert_eq!(
2044            tree.get_node_at_path(&[0, 0]).map(|n| n.label()),
2045            Some("a1")
2046        );
2047        assert_eq!(
2048            tree.get_node_at_path(&[0, 1]).map(|n| n.label()),
2049            Some("a2")
2050        );
2051        assert!(tree.get_node_at_path(&[5]).is_none()); // Invalid path
2052    }
2053
2054    #[test]
2055    fn tree_restore_wrong_snapshot_type_fails() {
2056        use std::any::Any;
2057        let mut tree = Tree::new(TreeNode::new("root"));
2058        let wrong_snapshot: Box<dyn Any + Send> = Box::new(42i32);
2059        assert!(!tree.restore_snapshot(&*wrong_snapshot));
2060    }
2061
2062    // --- Mouse handling tests ---
2063
2064    use crate::mouse::MouseResult;
2065    use ftui_core::event::{KeyCode, KeyEvent, MouseButton, MouseEvent, MouseEventKind};
2066
2067    #[test]
2068    fn tree_click_expands_parent() {
2069        let mut tree = Tree::new(
2070            TreeNode::new("root")
2071                .child(
2072                    TreeNode::new("a")
2073                        .child(TreeNode::new("a1"))
2074                        .child(TreeNode::new("a2")),
2075                )
2076                .child(TreeNode::new("b")),
2077        );
2078        assert!(tree.root().children()[0].is_expanded());
2079
2080        // Click on row 1 which is node "a" (a parent node)
2081        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 1);
2082        let hit = Some((HitId::new(1), HitRegion::Content, 1u64));
2083        let result = tree.handle_mouse(&event, hit, HitId::new(1));
2084        assert_eq!(result, MouseResult::Activated(1));
2085        assert!(!tree.root().children()[0].is_expanded()); // toggled to collapsed
2086    }
2087
2088    #[test]
2089    fn tree_click_selects_leaf() {
2090        let mut tree = Tree::new(
2091            TreeNode::new("root")
2092                .child(
2093                    TreeNode::new("a")
2094                        .child(TreeNode::new("a1"))
2095                        .child(TreeNode::new("a2")),
2096                )
2097                .child(TreeNode::new("b")),
2098        );
2099
2100        // Row 4 is "b" (a leaf): root=0, a=1, a1=2, a2=3, b=4
2101        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 4);
2102        let hit = Some((HitId::new(1), HitRegion::Content, 4u64));
2103        let result = tree.handle_mouse(&event, hit, HitId::new(1));
2104        assert_eq!(result, MouseResult::Selected(4));
2105    }
2106
2107    #[test]
2108    fn tree_click_wrong_id_ignored() {
2109        let mut tree = Tree::new(TreeNode::new("root").child(TreeNode::new("a")));
2110        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
2111        let hit = Some((HitId::new(99), HitRegion::Content, 0u64));
2112        let result = tree.handle_mouse(&event, hit, HitId::new(1));
2113        assert_eq!(result, MouseResult::Ignored);
2114    }
2115
2116    #[test]
2117    fn tree_click_no_hit_ignored() {
2118        let mut tree = Tree::new(TreeNode::new("root"));
2119        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
2120        let result = tree.handle_mouse(&event, None, HitId::new(1));
2121        assert_eq!(result, MouseResult::Ignored);
2122    }
2123
2124    #[test]
2125    fn tree_right_click_ignored() {
2126        let mut tree = Tree::new(TreeNode::new("root").child(TreeNode::new("a")));
2127        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Right), 0, 0);
2128        let hit = Some((HitId::new(1), HitRegion::Content, 0u64));
2129        let result = tree.handle_mouse(&event, hit, HitId::new(1));
2130        assert_eq!(result, MouseResult::Ignored);
2131    }
2132
2133    #[test]
2134    fn tree_node_at_visible_index_with_show_root() {
2135        let mut tree = Tree::new(
2136            TreeNode::new("root")
2137                .child(
2138                    TreeNode::new("a")
2139                        .child(TreeNode::new("a1"))
2140                        .child(TreeNode::new("a2")),
2141                )
2142                .child(TreeNode::new("b")),
2143        );
2144
2145        // Visible order: root=0, a=1, a1=2, a2=3, b=4
2146        assert_eq!(
2147            tree.node_at_visible_index_mut(0)
2148                .map(|n| n.label().to_string()),
2149            Some("root".to_string())
2150        );
2151        assert_eq!(
2152            tree.node_at_visible_index_mut(1)
2153                .map(|n| n.label().to_string()),
2154            Some("a".to_string())
2155        );
2156        assert_eq!(
2157            tree.node_at_visible_index_mut(2)
2158                .map(|n| n.label().to_string()),
2159            Some("a1".to_string())
2160        );
2161        assert_eq!(
2162            tree.node_at_visible_index_mut(3)
2163                .map(|n| n.label().to_string()),
2164            Some("a2".to_string())
2165        );
2166        assert_eq!(
2167            tree.node_at_visible_index_mut(4)
2168                .map(|n| n.label().to_string()),
2169            Some("b".to_string())
2170        );
2171        assert!(tree.node_at_visible_index_mut(5).is_none());
2172    }
2173
2174    #[test]
2175    fn tree_node_at_visible_index_hidden_root() {
2176        let mut tree = Tree::new(
2177            TreeNode::new("root")
2178                .child(TreeNode::new("a").child(TreeNode::new("a1")))
2179                .child(TreeNode::new("b")),
2180        )
2181        .with_show_root(false);
2182
2183        // Root hidden: a=0, a1=1, b=2
2184        assert_eq!(
2185            tree.node_at_visible_index_mut(0)
2186                .map(|n| n.label().to_string()),
2187            Some("a".to_string())
2188        );
2189        assert_eq!(
2190            tree.node_at_visible_index_mut(1)
2191                .map(|n| n.label().to_string()),
2192            Some("a1".to_string())
2193        );
2194        assert_eq!(
2195            tree.node_at_visible_index_mut(2)
2196                .map(|n| n.label().to_string()),
2197            Some("b".to_string())
2198        );
2199        assert!(tree.node_at_visible_index_mut(3).is_none());
2200    }
2201
2202    #[test]
2203    fn tree_node_at_visible_index_collapsed() {
2204        let mut tree = Tree::new(
2205            TreeNode::new("root")
2206                .child(
2207                    TreeNode::new("a")
2208                        .with_expanded(false)
2209                        .child(TreeNode::new("a1"))
2210                        .child(TreeNode::new("a2")),
2211                )
2212                .child(TreeNode::new("b")),
2213        );
2214
2215        // root=0, a=1 (collapsed, so a1/a2 hidden), b=2
2216        assert_eq!(
2217            tree.node_at_visible_index_mut(0)
2218                .map(|n| n.label().to_string()),
2219            Some("root".to_string())
2220        );
2221        assert_eq!(
2222            tree.node_at_visible_index_mut(1)
2223                .map(|n| n.label().to_string()),
2224            Some("a".to_string())
2225        );
2226        assert_eq!(
2227            tree.node_at_visible_index_mut(2)
2228                .map(|n| n.label().to_string()),
2229            Some("b".to_string())
2230        );
2231        assert!(tree.node_at_visible_index_mut(3).is_none());
2232    }
2233
2234    #[test]
2235    fn tree_click_toggles_collapsed_node() {
2236        let mut tree = Tree::new(
2237            TreeNode::new("root")
2238                .child(
2239                    TreeNode::new("a")
2240                        .with_expanded(false)
2241                        .child(TreeNode::new("a1")),
2242                )
2243                .child(TreeNode::new("b")),
2244        );
2245        assert!(!tree.root().children()[0].is_expanded());
2246
2247        // Click on "a" (row 1) to expand it
2248        let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 1);
2249        let hit = Some((HitId::new(1), HitRegion::Content, 1u64));
2250        let result = tree.handle_mouse(&event, hit, HitId::new(1));
2251        assert_eq!(result, MouseResult::Activated(1));
2252        assert!(tree.root().children()[0].is_expanded()); // now expanded
2253    }
2254
2255    #[test]
2256    fn tree_handle_key_enter_toggles_parent() {
2257        let mut tree = Tree::new(
2258            TreeNode::new("root")
2259                .child(TreeNode::new("a").child(TreeNode::new("a1")))
2260                .child(TreeNode::new("b")),
2261        );
2262
2263        // root=0, a=1, a1=2, b=3
2264        assert!(tree.root().children()[0].is_expanded());
2265        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Enter), 1));
2266        assert!(!tree.root().children()[0].is_expanded());
2267        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Char(' ')), 1));
2268        assert!(tree.root().children()[0].is_expanded());
2269    }
2270
2271    #[test]
2272    fn tree_handle_key_ignores_key_release() {
2273        // With release events reported, Enter collapsed the node on press
2274        // and expanded it again on release.
2275        let mut tree = Tree::new(
2276            TreeNode::new("root")
2277                .child(TreeNode::new("a").child(TreeNode::new("a1")))
2278                .child(TreeNode::new("b")),
2279        );
2280        let enter = KeyEvent::new(KeyCode::Enter);
2281        assert!(tree.handle_key(&enter, 1));
2282        assert!(!tree.handle_key(&enter.with_kind(KeyEventKind::Release), 1));
2283        assert!(!tree.root().children()[0].is_expanded());
2284    }
2285
2286    // =========================================================================
2287    // Keyboard navigation tests (bd-1lg.26)
2288    // =========================================================================
2289
2290    #[test]
2291    fn tree_handle_key_right_expands_collapsed_node() {
2292        let mut tree = Tree::new(
2293            TreeNode::new("root")
2294                .child(
2295                    TreeNode::new("a")
2296                        .with_expanded(false)
2297                        .child(TreeNode::new("a1")),
2298                )
2299                .child(TreeNode::new("b")),
2300        );
2301        assert!(!tree.root().children()[0].is_expanded());
2302
2303        // Right arrow on collapsed parent should expand it.
2304        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Right), 1));
2305        assert!(tree.root().children()[0].is_expanded());
2306    }
2307
2308    #[test]
2309    fn tree_handle_key_right_on_expanded_node_is_noop() {
2310        let mut tree = Tree::new(
2311            TreeNode::new("root")
2312                .child(TreeNode::new("a").child(TreeNode::new("a1")))
2313                .child(TreeNode::new("b")),
2314        );
2315        assert!(tree.root().children()[0].is_expanded());
2316
2317        // Right arrow on already-expanded node should be no-op.
2318        assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Right), 1));
2319        assert!(tree.root().children()[0].is_expanded());
2320    }
2321
2322    #[test]
2323    fn tree_handle_key_right_on_leaf_is_noop() {
2324        let mut tree = Tree::new(
2325            TreeNode::new("root")
2326                .child(TreeNode::new("a").child(TreeNode::new("a1")))
2327                .child(TreeNode::new("b")),
2328        );
2329
2330        // Right arrow on leaf node "b" (index 3) should be no-op.
2331        assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Right), 3));
2332    }
2333
2334    #[test]
2335    fn tree_handle_key_left_collapses_expanded_node() {
2336        let mut tree = Tree::new(
2337            TreeNode::new("root")
2338                .child(TreeNode::new("a").child(TreeNode::new("a1")))
2339                .child(TreeNode::new("b")),
2340        );
2341        assert!(tree.root().children()[0].is_expanded());
2342
2343        // Left arrow on expanded parent should collapse it.
2344        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2345        assert!(!tree.root().children()[0].is_expanded());
2346    }
2347
2348    #[test]
2349    fn tree_handle_key_left_on_collapsed_node_is_noop() {
2350        let mut tree = Tree::new(
2351            TreeNode::new("root")
2352                .child(
2353                    TreeNode::new("a")
2354                        .with_expanded(false)
2355                        .child(TreeNode::new("a1")),
2356                )
2357                .child(TreeNode::new("b")),
2358        );
2359        assert!(!tree.root().children()[0].is_expanded());
2360
2361        // Left arrow on already-collapsed node should be no-op.
2362        assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2363        assert!(!tree.root().children()[0].is_expanded());
2364    }
2365
2366    #[test]
2367    fn tree_handle_key_left_on_leaf_is_noop() {
2368        let mut tree = Tree::new(
2369            TreeNode::new("root")
2370                .child(TreeNode::new("a").child(TreeNode::new("a1")))
2371                .child(TreeNode::new("b")),
2372        );
2373
2374        // Left arrow on leaf node "b" (index 3) should be no-op.
2375        assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Left), 3));
2376    }
2377
2378    #[test]
2379    fn tree_handle_key_left_right_round_trip() {
2380        let mut tree = Tree::new(
2381            TreeNode::new("root")
2382                .child(TreeNode::new("a").child(TreeNode::new("a1")))
2383                .child(TreeNode::new("b")),
2384        );
2385
2386        // Collapse with Left.
2387        assert!(tree.root().children()[0].is_expanded());
2388        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2389        assert!(!tree.root().children()[0].is_expanded());
2390
2391        // Expand with Right.
2392        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Right), 1));
2393        assert!(tree.root().children()[0].is_expanded());
2394    }
2395
2396    #[test]
2397    fn tree_handle_key_unhandled_keys_return_false() {
2398        let mut tree = Tree::new(
2399            TreeNode::new("root")
2400                .child(TreeNode::new("a").child(TreeNode::new("a1")))
2401                .child(TreeNode::new("b")),
2402        );
2403
2404        // Up/Down are not handled by the tree widget (caller manages selection).
2405        assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Up), 1));
2406        assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Down), 1));
2407        assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Tab), 1));
2408        assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Escape), 1));
2409    }
2410
2411    #[test]
2412    fn tree_visible_index_navigation_after_collapse() {
2413        let mut tree = Tree::new(
2414            TreeNode::new("root")
2415                .child(
2416                    TreeNode::new("a")
2417                        .child(TreeNode::new("a1"))
2418                        .child(TreeNode::new("a2")),
2419                )
2420                .child(TreeNode::new("b")),
2421        );
2422
2423        // Before collapse: root=0, a=1, a1=2, a2=3, b=4
2424        assert_eq!(
2425            tree.node_at_visible_index_mut(4)
2426                .map(|n| n.label().to_string()),
2427            Some("b".to_string())
2428        );
2429
2430        // Collapse "a" with Left key
2431        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2432
2433        // After collapse: root=0, a=1, b=2
2434        assert_eq!(
2435            tree.node_at_visible_index_mut(2)
2436                .map(|n| n.label().to_string()),
2437            Some("b".to_string())
2438        );
2439        assert!(tree.node_at_visible_index_mut(3).is_none());
2440    }
2441
2442    // =========================================================================
2443    // Lazy loading tests (bd-1lg.26)
2444    // =========================================================================
2445
2446    #[test]
2447    fn tree_lazy_children_materialized_visible_count() {
2448        let mut node = TreeNode::new("root").with_lazy_children(vec![
2449            TreeNode::new("child1").child(TreeNode::new("grandchild")),
2450            TreeNode::new("child2"),
2451        ]);
2452
2453        // Before expand: only root visible.
2454        assert_eq!(node.visible_count(), 1);
2455
2456        // Expand → lazy children materialize.
2457        node.toggle_expanded();
2458        // root + child1 (expanded) + grandchild + child2 = 4
2459        assert_eq!(node.visible_count(), 4);
2460    }
2461
2462    #[test]
2463    fn tree_lazy_children_second_toggle_collapses() {
2464        let mut node = TreeNode::new("root")
2465            .with_lazy_children(vec![TreeNode::new("child1"), TreeNode::new("child2")]);
2466
2467        // Expand.
2468        node.toggle_expanded();
2469        assert!(node.is_expanded());
2470        assert_eq!(node.children().len(), 2);
2471
2472        // Collapse. Children stay materialized but hidden.
2473        node.toggle_expanded();
2474        assert!(!node.is_expanded());
2475        assert_eq!(node.children().len(), 2); // still there
2476        assert_eq!(node.visible_count(), 1); // only root visible
2477    }
2478
2479    #[test]
2480    fn tree_lazy_children_with_right_key() {
2481        let mut tree = Tree::new(TreeNode::new("root").child(
2482            TreeNode::new("lazy-parent").with_lazy_children(vec![TreeNode::new("lazy-child")]),
2483        ));
2484
2485        // root=0, lazy-parent=1 (collapsed, has lazy children)
2486        assert!(!tree.root().children()[0].is_expanded());
2487        assert!(tree.root().children()[0].has_children());
2488
2489        // Right key should expand and materialize lazy children.
2490        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Right), 1));
2491        assert!(tree.root().children()[0].is_expanded());
2492        assert_eq!(tree.root().children()[0].children().len(), 1);
2493        assert_eq!(
2494            tree.root().children()[0].children()[0].label(),
2495            "lazy-child"
2496        );
2497    }
2498
2499    // =========================================================================
2500    // Search filter tests (bd-1lg.26)
2501    // =========================================================================
2502
2503    #[test]
2504    fn tree_search_case_insensitive() {
2505        let tree = Tree::new(
2506            TreeNode::new("root")
2507                .child(TreeNode::new("Alpha"))
2508                .child(TreeNode::new("Beta")),
2509        )
2510        .with_search_query("alpha");
2511
2512        let flat = tree.flatten();
2513        assert_eq!(flat.len(), 2); // root + Alpha
2514        assert_eq!(flat[1].label, "Alpha");
2515    }
2516
2517    #[test]
2518    fn tree_search_no_match_returns_empty() {
2519        let tree = Tree::new(
2520            TreeNode::new("root")
2521                .child(TreeNode::new("Alpha"))
2522                .child(TreeNode::new("Beta")),
2523        )
2524        .with_search_query("zzz-no-match");
2525
2526        let flat = tree.flatten();
2527        // When nothing matches (including root), filter_node returns None,
2528        // so flatten should return an empty tree.
2529        assert_eq!(flat.len(), 0);
2530    }
2531
2532    #[test]
2533    fn tree_search_no_match_clears_stale_rows() {
2534        let base_tree = Tree::new(
2535            TreeNode::new("root")
2536                .child(TreeNode::new("Alpha"))
2537                .child(TreeNode::new("Beta")),
2538        );
2539        let filtered_tree = Tree::new(
2540            TreeNode::new("root")
2541                .child(TreeNode::new("Alpha"))
2542                .child(TreeNode::new("Beta")),
2543        )
2544        .with_search_query("zzz-no-match");
2545
2546        let mut pool = GraphemePool::new();
2547        let mut frame = Frame::new(20, 4, &mut pool);
2548        let area = Rect::new(0, 0, 20, 4);
2549
2550        base_tree.render(area, &mut frame);
2551        filtered_tree.render(area, &mut frame);
2552
2553        assert_eq!(line_text(&frame, 0, 20), "                    ");
2554        assert_eq!(line_text(&frame, 1, 20), "                    ");
2555        assert_eq!(line_text(&frame, 2, 20), "                    ");
2556        assert_eq!(line_text(&frame, 3, 20), "                    ");
2557    }
2558
2559    #[test]
2560    fn tree_search_cleared() {
2561        let tree = Tree::new(
2562            TreeNode::new("root")
2563                .child(TreeNode::new("Alpha"))
2564                .child(TreeNode::new("Beta")),
2565        )
2566        .with_search_query("alpha")
2567        .without_search_query();
2568
2569        let flat = tree.flatten();
2570        assert_eq!(flat.len(), 3); // root + Alpha + Beta
2571    }
2572
2573    // =========================================================================
2574    // Expansion state correctness (bd-1lg.26)
2575    // =========================================================================
2576
2577    #[test]
2578    fn tree_expand_deep_nesting() {
2579        let mut tree = Tree::new(
2580            TreeNode::new("root").child(
2581                TreeNode::new("d1").with_expanded(false).child(
2582                    TreeNode::new("d2")
2583                        .with_expanded(false)
2584                        .child(TreeNode::new("d3")),
2585                ),
2586            ),
2587        );
2588
2589        // Initially: root + d1 (collapsed) = 2 visible
2590        assert_eq!(tree.root().visible_count(), 2);
2591
2592        // Expand d1
2593        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Right), 1));
2594        // root + d1 + d2 (collapsed) = 3 visible
2595        assert_eq!(tree.root().visible_count(), 3);
2596
2597        // Expand d2 (now at index 2)
2598        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Right), 2));
2599        // root + d1 + d2 + d3 = 4 visible
2600        assert_eq!(tree.root().visible_count(), 4);
2601    }
2602
2603    #[test]
2604    fn tree_collapse_parent_hides_all_descendants() {
2605        let mut tree = Tree::new(
2606            TreeNode::new("root")
2607                .child(
2608                    TreeNode::new("a")
2609                        .child(TreeNode::new("a1").child(TreeNode::new("a1x")))
2610                        .child(TreeNode::new("a2")),
2611                )
2612                .child(TreeNode::new("b")),
2613        );
2614
2615        // All expanded: root + a + a1 + a1x + a2 + b = 6
2616        assert_eq!(tree.root().visible_count(), 6);
2617
2618        // Collapse "a" → hides a1, a1x, a2
2619        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2620        // root + a (collapsed) + b = 3
2621        assert_eq!(tree.root().visible_count(), 3);
2622    }
2623
2624    #[cfg(feature = "tracing")]
2625    #[test]
2626    fn tree_tracing_span_and_toggle_events_are_emitted() {
2627        let trace_state = Arc::new(Mutex::new(TreeTraceState::default()));
2628        let _trace_test_guard = crate::tracing_test_support::acquire();
2629        let subscriber = tracing_subscriber::registry().with(TreeTraceCapture {
2630            state: Arc::clone(&trace_state),
2631        });
2632        let _guard = tracing::subscriber::set_default(subscriber);
2633        tracing::callsite::rebuild_interest_cache();
2634
2635        let mut tree = Tree::new(
2636            TreeNode::new("root")
2637                .child(TreeNode::new("a").child(TreeNode::new("a1")))
2638                .child(TreeNode::new("b")),
2639        );
2640        let mut pool = GraphemePool::new();
2641        let mut frame = Frame::new(20, 6, &mut pool);
2642        tracing::callsite::rebuild_interest_cache();
2643        tree.render(Rect::new(0, 0, 20, 6), &mut frame);
2644        tracing::callsite::rebuild_interest_cache();
2645        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Enter), 1));
2646
2647        tracing::callsite::rebuild_interest_cache();
2648        let snapshot = trace_state.lock().expect("tree trace state lock");
2649        assert!(snapshot.tree_render_seen, "expected tree.render span");
2650        assert!(
2651            snapshot.has_total_nodes_field,
2652            "tree.render missing total_nodes"
2653        );
2654        assert!(
2655            snapshot.has_visible_nodes_field,
2656            "tree.render missing visible_nodes"
2657        );
2658        assert!(
2659            snapshot.has_expanded_count_field,
2660            "tree.render missing expanded_count"
2661        );
2662        assert!(
2663            snapshot.render_duration_recorded,
2664            "tree.render did not record render_duration_us"
2665        );
2666        assert!(
2667            snapshot.toggle_events >= 1,
2668            "expected tree.toggle debug event"
2669        );
2670    }
2671
2672    #[test]
2673    fn tree_accessibility_emits_nested_hierarchy_and_states() {
2674        use ftui_a11y::node::A11yRole;
2675        use ftui_a11y::tree::A11yTreeBuilder;
2676
2677        let root_id = 0x72EE_0000_0000_0001;
2678        let root_node = TreeNode::new("workspace")
2679            .child(
2680                TreeNode::new("src").child(TreeNode::new("main.rs")).child(
2681                    TreeNode::new("nested_collapsed")
2682                        .with_expanded(false)
2683                        .child(TreeNode::new("hidden.rs")),
2684                ),
2685            )
2686            .child(TreeNode::new("README.md"));
2687
2688        let tree_widget = Tree::new(root_node)
2689            .with_accessibility_id(root_id)
2690            .with_selected_visible_index(Some(2))
2691            .with_focused(true);
2692
2693        let mut pool = GraphemePool::new();
2694        let mut builder = A11yTreeBuilder::new();
2695        let area = Rect::new(0, 0, 40, 10);
2696        {
2697            let mut frame = Frame::new(40, 10, &mut pool);
2698            frame.set_a11y(&mut builder);
2699            tree_widget.render(area, &mut frame);
2700            frame.finish_a11y();
2701        }
2702        let a11y_tree = builder.build();
2703
2704        // Container List + 5 visible items (workspace, src, main.rs, nested_collapsed, README.md)
2705        assert_eq!(a11y_tree.node_count(), 6);
2706
2707        let list_container = a11y_tree.node(root_id).expect("tree container node");
2708        assert_eq!(list_container.role, A11yRole::List);
2709        assert_eq!(list_container.name.as_deref(), Some("workspace"));
2710        assert_eq!(
2711            list_container.description.as_deref(),
2712            Some("5 visible items")
2713        );
2714
2715        let ws_id = Tree::accessibility_item_id(root_id, &[]);
2716        let src_id = Tree::accessibility_item_id(root_id, &[0]);
2717        let main_id = Tree::accessibility_item_id(root_id, &[0, 0]);
2718        let collapsed_id = Tree::accessibility_item_id(root_id, &[0, 1]);
2719        let readme_id = Tree::accessibility_item_id(root_id, &[1]);
2720
2721        let ws_node = a11y_tree.node(ws_id).expect("workspace item");
2722        assert_eq!(ws_node.parent, Some(root_id));
2723        assert_eq!(ws_node.state.expanded, Some(true));
2724        assert_eq!(ws_node.children, vec![src_id, readme_id]);
2725
2726        let src_node = a11y_tree.node(src_id).expect("src item");
2727        assert_eq!(src_node.parent, Some(ws_id));
2728        assert_eq!(src_node.state.expanded, Some(true));
2729        assert_eq!(src_node.children, vec![main_id, collapsed_id]);
2730
2731        let main_node = a11y_tree.node(main_id).expect("main.rs item");
2732        assert_eq!(main_node.parent, Some(src_id));
2733        assert_eq!(main_node.state.expanded, None);
2734        assert!(main_node.state.selected);
2735        assert!(main_node.state.focused);
2736        assert_eq!(a11y_tree.focused().map(|n| n.id), Some(main_id));
2737
2738        let collapsed_node = a11y_tree.node(collapsed_id).expect("collapsed dir item");
2739        assert_eq!(collapsed_node.parent, Some(src_id));
2740        assert_eq!(collapsed_node.state.expanded, Some(false));
2741        assert!(collapsed_node.children.is_empty());
2742
2743        let readme_node = a11y_tree.node(readme_id).expect("README.md item");
2744        assert_eq!(readme_node.parent, Some(ws_id));
2745        assert_eq!(readme_node.state.expanded, None);
2746    }
2747
2748    #[test]
2749    fn tree_accessibility_canonical_path_ids_survive_sibling_collapse_and_search() {
2750        use ftui_a11y::tree::A11yTreeBuilder;
2751
2752        let root_id = 0x72EE_0000_0000_0002;
2753        let make_root = || {
2754            TreeNode::new("root")
2755                .child(
2756                    TreeNode::new("alpha")
2757                        .child(TreeNode::new("alpha_one"))
2758                        .child(TreeNode::new("alpha_two")),
2759                )
2760                .child(TreeNode::new("beta").child(TreeNode::new("beta_target")))
2761        };
2762
2763        let render_a11y = |tree: &Tree| {
2764            let mut pool = GraphemePool::new();
2765            let mut builder = A11yTreeBuilder::new();
2766            let mut frame = Frame::new(40, 10, &mut pool);
2767            frame.set_a11y(&mut builder);
2768            tree.render(Rect::new(0, 0, 40, 10), &mut frame);
2769            frame.finish_a11y();
2770            builder.build()
2771        };
2772
2773        let mut tree = Tree::new(make_root()).with_accessibility_id(root_id);
2774        let expanded_a11y = render_a11y(&tree);
2775        let beta_id = Tree::accessibility_item_id(root_id, &[1]);
2776        let beta_target_id = Tree::accessibility_item_id(root_id, &[1, 0]);
2777        assert!(expanded_a11y.node(beta_id).is_some());
2778        assert!(expanded_a11y.node(beta_target_id).is_some());
2779
2780        // Collapse "alpha" at visible index 1; "beta" shifts from visible row 4 to row 2,
2781        // but its canonical path &[1] and item ID remain identical.
2782        assert!(tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2783        let collapsed_a11y = render_a11y(&tree);
2784        let beta_after_collapse = collapsed_a11y
2785            .node(beta_id)
2786            .expect("beta retains canonical ID after sibling collapse");
2787        assert_eq!(beta_after_collapse.name.as_deref(), Some("beta"));
2788        assert!(collapsed_a11y.node(beta_target_id).is_some());
2789
2790        // Search filter for "beta_target" prunes "alpha" completely, yet "beta" (&[1]) and
2791        // "beta_target" (&[1, 0]) still use their canonical tree path IDs.
2792        let filtered_tree = Tree::new(make_root())
2793            .with_accessibility_id(root_id)
2794            .with_search_query("beta_target");
2795        let filtered_a11y = render_a11y(&filtered_tree);
2796        assert!(filtered_a11y.node(beta_id).is_some());
2797        let target_node = filtered_a11y
2798            .node(beta_target_id)
2799            .expect("filtered target keeps canonical path ID");
2800        assert_eq!(target_node.parent, Some(beta_id));
2801    }
2802
2803    #[test]
2804    fn tree_accessibility_focus_sync_delegates_to_selected_descendant() {
2805        use crate::focus::{FocusManager, FocusNode};
2806        use ftui_a11y::tree::A11yTreeBuilder;
2807
2808        let root_id = 0x72EE_0000_0000_0003;
2809        let tree_widget = Tree::new(simple_tree())
2810            .with_accessibility_id(root_id)
2811            .with_selected_visible_index(Some(3)) // "a2" at path &[0, 1]
2812            .with_focused(false); // Even if widget flag wasn't set, FocusManager sync delegates
2813
2814        let mut fm = FocusManager::new();
2815        fm.graph_mut()
2816            .insert(FocusNode::new(root_id, Rect::new(0, 0, 40, 10)).with_tab_index(0));
2817        let _ = fm.focus(root_id);
2818        assert_eq!(fm.current(), Some(root_id));
2819
2820        let mut pool = GraphemePool::new();
2821        let mut builder = A11yTreeBuilder::new();
2822        {
2823            let mut frame = Frame::new(40, 10, &mut pool);
2824            frame.set_a11y(&mut builder);
2825            fm.sync_to_frame(&mut frame);
2826            tree_widget.render(Rect::new(0, 0, 40, 10), &mut frame);
2827            frame.finish_a11y();
2828        }
2829        let a11y_tree = builder.build();
2830        let expected_item_id = Tree::accessibility_item_id(root_id, &[0, 1]);
2831        assert_eq!(a11y_tree.focused().map(|n| n.id), Some(expected_item_id));
2832        assert!(
2833            a11y_tree
2834                .node(expected_item_id)
2835                .expect("a2 node")
2836                .state
2837                .focused
2838        );
2839    }
2840
2841    #[test]
2842    fn tree_accessible_trait_matches_rendered_nodes() {
2843        use ftui_a11y::Accessible;
2844
2845        let tree_widget = Tree::new(simple_tree())
2846            .with_accessibility_id(0x72EE_0000_0000_0004)
2847            .with_selected_visible_index(Some(1))
2848            .with_focused(true);
2849        let nodes = tree_widget.accessibility_nodes(Rect::new(0, 0, 40, 10));
2850        // Container List + 5 items (root, a, a1, a2, b)
2851        assert_eq!(nodes.len(), 6);
2852        assert_eq!(nodes[0].name.as_deref(), Some("root"));
2853        assert_eq!(nodes[2].name.as_deref(), Some("a"));
2854        assert!(nodes[2].state.selected);
2855        assert!(nodes[2].state.focused);
2856    }
2857}