oino-ui 1.0.0

Wire types and ratatui-mirroring builder for the Oino extension UI protocol v2 (serde-only, wasm32-wasip2-safe)
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

//! `Tree` node (§4.5.2).

use serde::{Deserialize, Serialize};

use crate::extras::icon::Icon;
use crate::node::{ActionId, Common, IntoNode, Key, Node};
use crate::text::Line;

/// One tree row.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TreeNode {
    /// Node identity.
    pub key: Key,
    /// Row label.
    pub label: Line,
    /// Leading icon.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub icon: Option<Icon>,
    /// Right-aligned badge.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub badge: Option<Line>,
    /// Child rows.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub children: Vec<TreeNode>,
    /// Start expanded.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub expanded: Option<bool>,
    /// GUI extra: children load on first expand (extension replies with a patch).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub lazy: Option<bool>,
}

impl TreeNode {
    /// A leaf row.
    #[must_use]
    pub fn new(key: impl Into<Key>, label: impl Into<Line>) -> Self {
        Self {
            key: key.into(),
            label: label.into(),
            icon: None,
            badge: None,
            children: Vec::new(),
            expanded: None,
            lazy: None,
        }
    }

    /// Sets the leading icon.
    #[must_use]
    pub fn icon(mut self, icon: Icon) -> Self {
        self.icon = Some(icon);
        self
    }

    /// Sets the right-aligned badge.
    #[must_use]
    pub fn badge(mut self, badge: impl Into<Line>) -> Self {
        self.badge = Some(badge.into());
        self
    }

    /// Attaches child rows.
    #[must_use]
    pub fn children(mut self, children: impl IntoIterator<Item = TreeNode>) -> Self {
        self.children = children.into_iter().collect();
        self
    }

    /// Starts expanded.
    #[must_use]
    pub fn expanded(mut self, expanded: bool) -> Self {
        self.expanded = Some(expanded);
        self
    }

    /// Loads children lazily on first expand.
    #[must_use]
    pub fn lazy(mut self, lazy: bool) -> Self {
        self.lazy = Some(lazy);
        self
    }
}

/// Tree selection state.
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TreeState {
    /// Selected node key.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub selected: Option<Key>,
}

impl TreeState {
    /// State with one selected key.
    #[must_use]
    pub fn with_selected(key: impl Into<Key>) -> Self {
        Self {
            selected: Some(key.into()),
        }
    }
}

/// A tree with expand / collapse and optional lazy children (§4.5.2).
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Tree {
    /// Common node props (`key`, `style`, `block`, `fallback`).
    #[serde(flatten)]
    pub common: Common,
    /// Root rows (≤ 5 000 counting descendants, §4.8).
    pub nodes: Vec<TreeNode>,
    /// Selection state (wins when it changes, §4.6).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub state: Option<TreeState>,
    /// Action on selection change (node key).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub on_select: Option<ActionId>,
    /// Action on Enter (node key).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub on_activate: Option<ActionId>,
    /// Action on expand / collapse (`{key, expanded}`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub on_toggle: Option<ActionId>,
}

impl Tree {
    /// A tree from root rows.
    #[must_use]
    pub fn new(nodes: impl IntoIterator<Item = TreeNode>) -> Self {
        Self {
            nodes: nodes.into_iter().collect(),
            ..Self::default()
        }
    }

    /// Sets the selection state.
    #[must_use]
    pub fn state(mut self, state: TreeState) -> Self {
        self.state = Some(state);
        self
    }

    /// Sets the selection action.
    #[must_use]
    pub fn on_select(mut self, action: impl Into<ActionId>) -> Self {
        self.on_select = Some(action.into());
        self
    }

    /// Sets the activate action.
    #[must_use]
    pub fn on_activate(mut self, action: impl Into<ActionId>) -> Self {
        self.on_activate = Some(action.into());
        self
    }

    /// Sets the toggle action.
    #[must_use]
    pub fn on_toggle(mut self, action: impl Into<ActionId>) -> Self {
        self.on_toggle = Some(action.into());
        self
    }
}

impl IntoNode for Tree {}
impl From<Tree> for Node {
    fn from(t: Tree) -> Self {
        Node::Tree(t)
    }
}