oxi-tui 0.61.0

Terminal UI widgets and theme system for oxi, built on ratatui
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

//! Text message component — renders a finalized user/assistant message.
//!
//! Implements the `Component` trait for a static text message. The entire
//! message is FINAL (LiveRegion::None) — all rows are byte-stable.

use super::super::component::{Component, LiveRegion, RenderResult};

/// A finalized text message (user or assistant).
///
/// The `lines` field holds pre-rendered ANSI lines. The entire message is
/// final — no live region.
pub struct TextMessage {
    /// Pre-rendered ANSI lines for this message.
    lines: Vec<String>,
    /// Cached content hash.
    hash: u64,
}

impl TextMessage {
    /// Create from pre-rendered lines.
    #[must_use]
    pub fn new(lines: Vec<String>) -> Self {
        let hash = super::super::component::RenderResult::new(lines.clone()).hash;
        Self { lines, hash }
    }

    /// Create from a single line of text.
    #[must_use]
    pub fn single(text: impl Into<String>) -> Self {
        Self::new(vec![text.into()])
    }

    /// Create from multi-line text, splitting on newlines.
    #[must_use]
    pub fn from_text(text: &str) -> Self {
        Self::new(text.lines().map(String::from).collect())
    }

    /// Number of rendered lines.
    #[must_use]
    pub fn line_count(&self) -> usize {
        self.lines.len()
    }
}

impl Component for TextMessage {
    fn render(&self, _width: u16) -> RenderResult {
        RenderResult {
            lines: self.lines.clone(),
            hash: self.hash,
        }
    }

    fn revision(&self) -> u64 {
        self.hash
    }

    fn live_region(&self) -> LiveRegion {
        LiveRegion::None
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn renders_all_lines() {
        let msg = TextMessage::new(vec!["line1".into(), "line2".into()]);
        let r = msg.render(80);
        assert_eq!(r.lines, vec!["line1", "line2"]);
    }

    #[test]
    fn single_line() {
        let msg = TextMessage::single("hello");
        let r = msg.render(80);
        assert_eq!(r.lines, vec!["hello"]);
    }

    #[test]
    fn from_multiline_text() {
        let msg = TextMessage::from_text("a\nb\nc");
        let r = msg.render(80);
        assert_eq!(r.lines, vec!["a", "b", "c"]);
    }

    #[test]
    fn hash_stable_across_renders() {
        let msg = TextMessage::new(vec!["x".into()]);
        let r1 = msg.render(80);
        let r2 = msg.render(80);
        assert_eq!(r1.hash, r2.hash);
    }

    #[test]
    fn live_region_is_none() {
        let msg = TextMessage::single("hi");
        assert_eq!(msg.live_region(), LiveRegion::None);
    }

    #[test]
    fn line_count() {
        let msg = TextMessage::new(vec!["a".into(), "b".into(), "c".into()]);
        assert_eq!(msg.line_count(), 3);
    }

    #[test]
    fn empty_message() {
        let msg = TextMessage::new(vec![]);
        let r = msg.render(80);
        assert!(r.lines.is_empty());
    }
}