ratflow 0.1.0

A minimalistic framework for building TUI applications using a reactive architecture.
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

use crossterm::event::{Event, EventStream};
use futures_util::stream::StreamExt;
use ratatui::Terminal;
use ratatui::prelude::Backend;
use reactive_graph::effect::{Effect, RenderEffect};
use reactive_graph::owner::{Owner, provide_context};
use reactive_graph::signal::{ReadSignal, Trigger, signal};
use reactive_graph::traits::{Get, Notify, Set, Track};
use std::io;
use std::io::Error;
use tokio::sync::watch;

use crate::{Component, Render, on_resize};

#[derive(Debug, Clone, Copy)]
pub(crate) struct Events {
    event: ReadSignal<Event>,
}

impl Events {
    #[inline]
    pub fn last(&self) -> Event {
        self.event.get()
    }
}

#[derive(Debug, Clone, Copy)]
pub struct Runtime {
    quit: Trigger,
    redraw: Trigger,
}

impl Runtime {
    #[inline]
    pub fn quit(&self) {
        self.quit.notify();
    }

    #[inline]
    pub fn force_redraw(&self) {
        self.redraw.notify();
    }
}

pub(super) async fn render_loop<
    B: Backend<Error = Error> + 'static,
    F: Render + 'static,
    C: Component<F>,
>(
    app: C,
    mut terminal: Terminal<B>,
) -> Result<(), io::Error> {
    let owner = Owner::new();
    let quit = Trigger::new();
    let (event, set_event) = signal(Event::FocusGained);
    let redraw = Trigger::new();
    let (tx, mut quit_rx) = watch::channel(());

    let app = owner.with(move || {
        provide_context(Runtime { quit, redraw });
        provide_context(Events { event });
        on_resize(move |_, _| redraw.notify());
        Effect::watch(
            move || quit.track(),
            move |_, _, _| {
                tx.send(()).unwrap();
            },
            false,
        );
        app.create()
    });

    let render_effect = RenderEffect::new_with_value(
        move |_| {
            redraw.track();
            let res = terminal.draw(|frame| {
                app.render(frame);
            });
            if let Err(err) = res {
                quit.notify();
                Err(err)
            } else {
                Ok(())
            }
        },
        Some(Ok(())),
    );

    let mut events = EventStream::new();
    loop {
        tokio::select! {
            Some(event) = events.next() => {
                set_event.set(event?);
            },
            _ = quit_rx.changed() => {
                render_effect.take_value().unwrap()?;
                break;
            }
        }
    }

    Ok(())
}