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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::render::Events;
use crossterm::event::{Event, KeyEvent, MouseEvent};
use reactive_graph::computed::Memo;
use reactive_graph::effect::{Effect, EffectFunction};
use reactive_graph::owner::{LocalStorage, expect_context};
use reactive_graph::signal::Trigger;
use reactive_graph::traits::{IsDisposed, Notify, Track};
use std::time::Duration;
use tokio::time::sleep;

#[inline]
#[track_caller]
pub fn create_effect<T, M>(fun: impl EffectFunction<T, M> + 'static) -> Effect<LocalStorage>
where
    T: 'static,
{
    Effect::new(fun)
}

#[inline]
#[track_caller]
pub fn on_event(mut fun: impl FnMut(&Event) + 'static) -> Effect<LocalStorage> {
    let events = expect_context::<Events>();
    Effect::watch(
        move || events.last(),
        move |event, _, _| {
            fun(event);
        },
        false,
    )
}

#[inline]
#[track_caller]
pub fn on_key(mut fun: impl FnMut(KeyEvent) + 'static) -> Effect<LocalStorage> {
    on_event(move |event| {
        if let Some(key_event) = event.as_key_event() {
            fun(key_event);
        }
    })
}

#[inline]
#[track_caller]
pub fn on_mouse(mut fun: impl FnMut(MouseEvent) + 'static) -> Effect<LocalStorage> {
    on_event(move |event| {
        if let Some(mouse_event) = event.as_mouse_event() {
            fun(mouse_event);
        }
    })
}

#[inline]
#[track_caller]
pub fn on_resize(mut fun: impl FnMut(u16, u16) + 'static) -> Effect<LocalStorage> {
    on_event(move |event| {
        if let Some((x, y)) = event.as_resize_event() {
            fun(x, y);
        }
    })
}

#[inline]
#[track_caller]
pub fn on_key_press(mut fun: impl FnMut(KeyEvent) + 'static) -> Effect<LocalStorage> {
    on_event(move |event| {
        if let Some(key_event) = event.as_key_press_event() {
            fun(key_event);
        }
    })
}

#[inline]
#[track_caller]
pub fn create_memo<T: Send + Sync + 'static + PartialEq>(
    fun: impl Fn() -> T + Send + Sync + 'static,
) -> Memo<T> {
    Memo::new(move |_| fun())
}

#[inline]
#[track_caller]
pub fn create_timeout(mut fun: impl FnMut() + 'static, duration: Duration) -> Effect<LocalStorage> {
    let trigger = Trigger::new();
    any_spawner::Executor::spawn(async move {
        sleep(duration).await;
        trigger.notify();
    });
    Effect::watch(
        move || trigger.track(),
        move |_, _, _| {
            fun();
        },
        false,
    )
}

#[inline]
#[track_caller]
pub fn create_interval(
    mut fun: impl FnMut() + 'static,
    duration: Duration,
) -> Effect<LocalStorage> {
    let trigger = Trigger::new();
    any_spawner::Executor::spawn(async move {
        loop {
            if trigger.is_disposed() {
                return;
            } else {
                trigger.notify();
            }
            sleep(duration).await;
        }
    });
    Effect::watch(
        move || trigger.track(),
        move |_, _, _| {
            fun();
        },
        false,
    )
}