rnk 0.19.1

A React-like declarative terminal UI framework for Rust, inspired by Ink and Bubbletea
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

//! Runtime queue bridge for App event-loop orchestration.

use std::sync::Arc;

use crate::cmd::run_exec_process;

use super::Terminal;
use super::registry::{AppRuntime, AppSink};
use super::terminal_controller::TerminalController;

/// Bridge that drains runtime/registry queues and delegates to terminal handlers.
pub(crate) struct RuntimeBridge;

impl RuntimeBridge {
    /// Drain and process queued exec requests.
    pub(crate) fn handle_exec_requests(
        terminal: &mut Terminal,
        runtime: &Arc<AppRuntime>,
    ) -> std::io::Result<()> {
        let exec_requests = runtime.take_exec_requests();
        for request in exec_requests {
            terminal.suspend()?;
            let result = run_exec_process(&request.config);
            terminal.resume()?;
            (request.callback)(result);
            runtime.request_render();
        }
        Ok(())
    }

    /// Drain and process queued terminal commands.
    pub(crate) fn handle_terminal_commands(
        terminal: &mut Terminal,
        runtime: &Arc<AppRuntime>,
        last_width: &mut u16,
        last_height: &mut u16,
    ) -> std::io::Result<()> {
        let terminal_cmds = runtime.take_terminal_cmds();
        for cmd in terminal_cmds {
            TerminalController::handle_terminal_cmd(
                terminal,
                runtime,
                cmd,
                last_width,
                last_height,
            )?;
        }
        Ok(())
    }

    /// Process one pending mode switch request.
    pub(crate) fn handle_mode_switch_request(
        terminal: &mut Terminal,
        runtime: &Arc<AppRuntime>,
    ) -> std::io::Result<()> {
        if let Some(mode_switch) = runtime.take_mode_switch_request() {
            TerminalController::handle_mode_switch(terminal, runtime, mode_switch)?;
        }
        Ok(())
    }

    /// Process queued println messages.
    pub(crate) fn handle_println_messages(
        terminal: &mut Terminal,
        runtime: &Arc<AppRuntime>,
    ) -> std::io::Result<()> {
        let messages = runtime.take_println_messages();
        if !messages.is_empty() {
            TerminalController::handle_println_messages(terminal, &messages)?;
        }
        Ok(())
    }
}