zeyn 0.0.8

Rust web framework for data heavy applications, written by AI agents and reviewed by people
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Tree view (ARIA tree) whose children load from an action when a branch first opens.

use super::{ActionSource, DataSource, layout::into_node};
use crate::action::{Action, Result};
use crate::i18n::Text;
use crate::render::{Render, attr};
use crate::screen::{Component, Node};
use serde::{Deserialize, Serialize};
use serde_json::{Value as Json, json};

into_node!(Tree);

/// Most children one branch may show.
pub const MAX_TREE_CHILDREN: usize = 1000;

/// What a tree action receives: the branch to list, or `None` for the top level.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct TreeQuery {
    #[serde(default)]
    pub parent: Option<String>,
}

/// One branch or leaf of a tree.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TreeItem {
    pub id: String,
    pub label: String,
    /// Whether the item can open. Children load the first time it opens.
    pub has_children: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub hint: Option<String>,
}

impl TreeItem {
    pub fn branch(id: impl Into<String>, label: impl Into<String>) -> Self {
        Self {
            id: id.into(),
            label: label.into(),
            has_children: true,
            hint: None,
        }
    }

    pub fn leaf(id: impl Into<String>, label: impl Into<String>) -> Self {
        Self {
            id: id.into(),
            label: label.into(),
            has_children: false,
            hint: None,
        }
    }

    pub fn hint(mut self, hint: impl Into<String>) -> Self {
        self.hint = Some(hint.into());
        self
    }
}

/// A tree. Keyboard (ARIA tree pattern): Up and Down move, Right opens or goes to the first
/// child, Left closes or goes to the parent, Home and End, Enter or Space selects, letters jump.
///
/// ```ignore
/// Tree::of(category_children).label("Categories")
/// ```
pub struct Tree {
    label: Text,
    source: Box<dyn DataSource>,
    action: crate::action::ActionMeta,
}

impl Tree {
    pub fn of<A>(_action: A) -> Self
    where
        A: Action<Input = TreeQuery, Output = Result<Vec<TreeItem>>>,
    {
        Self {
            label: Text::from(""),
            source: Box::new(ActionSource::<A>::new()),
            action: A::META,
        }
    }

    /// The tree's accessible name.
    pub fn label(mut self, label: impl Into<Text>) -> Self {
        self.label = label.into();
        self
    }
}

impl Component for Tree {
    fn render(&self, out: &mut String, r: &Render) {
        let texts = json!({
            "loading": r.i18n.text(r.locale, &Text::key("zeyn.ui.loading")),
            "empty": r.i18n.text(r.locale, &Text::key("zeyn.ui.tree.empty")),
            "failed": r.i18n.text(r.locale, &Text::key("zeyn.ui.load_failed")),
        });
        out.push_str(&format!(
            r#"<div class="z-tree" data-zeyn-tree data-texts="{}" data-max="{MAX_TREE_CHILDREN}"><ul role="tree" aria-label="{}" data-testid="{}.tree" aria-busy="true"><li class="z-tree-note">{}</li></ul></div>"#,
            attr(&texts),
            r.text(&self.label),
            r.scope,
            r.text(&Text::key("zeyn.ui.loading"))
        ));
    }

    fn schema(&self) -> Json {
        json!({ "type": "tree", "label": self.label, "action": self.action })
    }

    fn source(&self, key: &str) -> Option<&dyn DataSource> {
        key.is_empty()
            .then_some(self.source.as_ref())
    }
}