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

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

use serde::{Deserialize, Serialize};

use crate::node::{ActionId, Common, IntoNode, Node};

/// One key hint.
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Hint {
    /// Key id (pi `KeyId`).
    pub keys: String,
    /// Hint label.
    pub label: String,
    /// Action fired when the hint is tapped (phone shows only tappable hints).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub action: Option<ActionId>,
}

impl Hint {
    /// A hint without an action.
    #[must_use]
    pub fn new(keys: impl Into<String>, label: impl Into<String>) -> Self {
        Self {
            keys: keys.into(),
            label: label.into(),
            action: None,
        }
    }

    /// A hint that fires an action.
    #[must_use]
    pub fn with_action(
        keys: impl Into<String>,
        label: impl Into<String>,
        action: impl Into<ActionId>,
    ) -> Self {
        Self {
            keys: keys.into(),
            label: label.into(),
            action: Some(action.into()),
        }
    }
}

impl From<(&str, &str)> for Hint {
    fn from((keys, label): (&str, &str)) -> Self {
        Self::new(keys, label)
    }
}

impl From<(&str, &str, &str)> for Hint {
    fn from((keys, label, action): (&str, &str, &str)) -> Self {
        Self::with_action(keys, label, action)
    }
}

/// ratatui-style key hints line (§4.5.2): `enter open · n new`.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct KeyHints {
    /// Common node props (`key`, `style`, `block`, `fallback`).
    #[serde(flatten)]
    pub common: Common,
    /// Hints, in display order.
    pub hints: Vec<Hint>,
}

impl KeyHints {
    /// Hints from anything convertible to [`Hint`] (`("enter", "open")` tuples).
    #[must_use]
    pub fn new(hints: impl IntoIterator<Item = impl Into<Hint>>) -> Self {
        Self {
            hints: hints.into_iter().map(Into::into).collect(),
            ..Self::default()
        }
    }

    /// Attaches an action to the hint with the given `keys` (§11.3).
    #[must_use]
    pub fn hint_action(mut self, keys: &str, action: impl Into<ActionId>) -> Self {
        for hint in &mut self.hints {
            if hint.keys == keys {
                hint.action = Some(action.into());
                break;
            }
        }
        self
    }
}

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