afterglow 0.3.0

A rust front-end framework built on typed-html and dodrio. Use trait objects to decouple view/mutation behaviour and data model.
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
123
124
125
126
127

use crate::prelude::*;
use async_std::task;
use async_trait::async_trait;
use dodrio::{RootRender, VdomWeak};
use futures::channel::mpsc::unbounded;
use futures::lock::Mutex;
use std::rc::Rc;

pub type Message<T> = Box<dyn Messenger<Target = T>>;
pub type MessageSender<T> = Sender<(Message<T>, oneshot::Sender<()>)>;
pub type MessageReceiver<T> = Receiver<(Message<T>, oneshot::Sender<()>)>;

pub trait Messenger {
    type Target;

    fn update(
        self: Box<Self>,
        target: &mut Self::Target,
        sender: &MessageSender<Self::Target>,
        render_tx: &Sender<((), oneshot::Sender<()>)>,
    ) -> bool {
        false
    }

    fn dispatch(self, sender: &MessageSender<Self::Target>) -> task::JoinHandle<()>
    where
        Self: Sized + 'static,
    {
        let mut sender = sender.clone();
        let task = task::spawn_local(async move {
            let (tx, rx) = oneshot::channel::<()>();
            let _ = sender.send((Box::new(self), tx)).await;
            let _ = rx.await;
        });
        task
    }
}

pub fn consume<T, M>(
    convert: impl Fn(Event) -> M + 'static,
    sender: &MessageSender<T>,
) -> impl Fn(&mut dyn RootRender, VdomWeak, Event) + 'static
where
    M: Messenger<Target = T> + 'static,
    T: 'static,
{
    let sender = sender.clone();
    move |_, _, event| {
        let msg = convert(event);
        spawn_local(msg.dispatch(&sender));
    }
}

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

    pub struct Data {
        button: bool,
    }

    pub struct Data2 {
        button: bool,
    }

    pub enum Msg {
        Flipit,
    }

    pub enum Msg2 {
        Secret,
    }

    impl Messenger for Msg {
        type Target = Data;

        fn update(
            self: Box<Self>,
            target: &mut Self::Target,
            sender: &MessageSender<Self::Target>,
            render_tx: &Sender<((), oneshot::Sender<()>)>,
        ) -> bool {
            target.button = !target.button;
            true
        }
    }

    impl Messenger for Msg2 {
        type Target = Data;

        fn update(
            self: Box<Self>,
            target: &mut Self::Target,
            sender: &Sender<(
                Box<dyn Messenger<Target = Self::Target>>,
                oneshot::Sender<()>,
            )>,
            render_tx: &Sender<((), oneshot::Sender<()>)>,
        ) -> bool {
            log::info!("not sure what to do, {}", target.button);
            false
        }
    }

    pub struct Container<T> {
        data: Rc<Mutex<T>>,
    }

    impl Container<Data> {
        fn start_handling(&self) {
            let (render_tx, _) = unbounded::<((), oneshot::Sender<()>)>();
            let (tx, mut rx) = unbounded::<(Message<Data>, oneshot::Sender<()>)>();
            let data = self.data.clone();
            let tx_handle = tx.clone();
            let fut = async move {
                while let Some((msg, ready)) = rx.next().await {
                    let mut content = data.lock().await;
                    msg.update(&mut content, &tx_handle, &render_tx);
                    let _ = ready.send(());
                    log::info!("content value: {}", content.button);
                }
            };

            spawn_local(fut);
        }
    }
}