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

//! ratatui `Tabs` (§4.5.1).

use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};

use crate::node::{ActionId, Common, IntoNode, Key, Node};
use crate::style::Style;
use crate::text::{Line, Span};

/// One tab title.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TabTitle {
    /// Tab identity (drives `selected` and the action value).
    pub key: Key,
    /// Tab title.
    pub title: Line,
    /// GUI extra: right-aligned badge.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub badge: Option<Line>,
}

impl TabTitle {
    /// A tab title.
    #[must_use]
    pub fn new(key: impl Into<Key>, title: impl Into<Line>) -> Self {
        Self {
            key: key.into(),
            title: title.into(),
            badge: None,
        }
    }

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

/// ratatui `Tabs` (§4.5.1). With `panes`, the selected pane renders below the bar
/// and switching is local (no round-trip) unless `onSelect` is set.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Tabs {
    /// Common node props (`key`, `style`, `block`, `fallback`).
    #[serde(flatten)]
    pub common: Common,
    /// Tab titles.
    pub titles: Vec<TabTitle>,
    /// Selected tab key.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub selected: Option<Key>,
    /// Divider between titles (ratatui default `"│"`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub divider: Option<Span>,
    /// Left / right padding lines around the bar.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub padding: Option<[Line; 2]>,
    /// Selected-title style.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub highlight_style: Option<Style>,
    /// Pane contents keyed by tab key.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub panes: Option<BTreeMap<Key, Node>>,
    /// Action on selection change (tab key).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub on_select: Option<ActionId>,
}

impl Tabs {
    /// Tabs from titles.
    #[must_use]
    pub fn new(titles: impl IntoIterator<Item = TabTitle>) -> Self {
        Self {
            titles: titles.into_iter().collect(),
            ..Self::default()
        }
    }

    /// Sets the selected tab key.
    #[must_use]
    pub fn selected(mut self, key: impl Into<Key>) -> Self {
        self.selected = Some(key.into());
        self
    }

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

    /// Sets the left / right padding lines.
    #[must_use]
    pub fn padding(mut self, padding: [Line; 2]) -> Self {
        self.padding = Some(padding);
        self
    }

    /// Sets the selected-title style.
    #[must_use]
    pub fn highlight_style(mut self, style: Style) -> Self {
        self.highlight_style = Some(style);
        self
    }

    /// Attaches pane contents keyed by tab key.
    #[must_use]
    pub fn panes(mut self, panes: impl IntoIterator<Item = (Key, impl IntoNode)>) -> Self {
        self.panes = Some(panes.into_iter().map(|(k, n)| (k, n.into_node())).collect());
        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
    }
}

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