ntui 0.3.1

An Ink-style TUI library for Rust: components, hooks, flexbox layout, and fullscreen rendering.
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

use std::time::Duration;

use ntui::{BorderStyle, Color, FlexDirection, KeyCode, Weight, component, element, render};

#[derive(Clone, PartialEq)]
struct Msg {
    id: usize,
    who: &'static str,
    text: String,
}

#[component]
fn Chat(hooks: &mut ntui::Hooks) -> ntui::Element {
    let messages = hooks.use_state(Vec::<Msg>::new);
    let draft = hooks.use_state(String::new);
    let next_id = hooks.use_state(|| 0usize);
    let app = hooks.use_app();

    let (m, d, n) = (messages.clone(), draft.clone(), next_id.clone());
    hooks.use_input(move |ev, _| match ev.code {
        KeyCode::Esc => app.exit(),
        KeyCode::Backspace => d.update(|s| {
            s.pop();
        }),
        KeyCode::Enter => {
            let text = d.get();
            if text.is_empty() {
                return;
            }
            d.set(String::new());
            let user_id = {
                let v = n.get();
                n.set(v + 2);
                v
            };
            m.update(|ms| {
                ms.push(Msg {
                    id: user_id,
                    who: "you",
                    text: text.clone(),
                });
                ms.push(Msg {
                    id: user_id + 1,
                    who: "claude",
                    text: String::new(),
                });
            });
            // fake streaming reply, one char at a time
            let m2 = m.clone();
            let reply = format!("You said: \"{text}\" — a fine thing to say to a demo.");
            tokio::spawn(async move {
                for ch in reply.chars() {
                    tokio::time::sleep(Duration::from_millis(25)).await;
                    m2.update(|ms| {
                        if let Some(last) = ms.last_mut() {
                            last.text.push(ch);
                        }
                    });
                }
            });
        }
        KeyCode::Char(c) => d.update(|s| s.push(c)),
        _ => {}
    });

    element! {
        View(flex_direction: FlexDirection::Column, padding: 1) {
            View(flex_direction: FlexDirection::Column, flex_grow: 1.0_f32, gap: 1) {
                #(messages.get().into_iter().map(|msg| element! {
                    View(flex_direction: FlexDirection::Column, key: msg.id.to_string()) {
                        Text(content: msg.who, weight: Weight::Bold,
                             color: if msg.who == "you" { Color::Cyan } else { Color::Magenta })
                        Text(content: msg.text)
                    }
                }))
            }
            View(border_style: BorderStyle::Round, border_color: Color::DarkGrey) {
                Text(content: format!("> {}_", draft.get()))
            }
        }
    }
}

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), ntui::Error> {
    render(element!(Chat)).await
}