draco 0.1.2

Draco is a Rust library for building client side web applications with Web Assembly.
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

use js_sys as js;
use std::rc::Rc;
use wasm_bindgen::prelude::*;
use wasm_bindgen::JsCast;
use web_sys as web;

pub type Send<Message> = Rc<Fn(Message)>;

pub trait Subscription {
    type Message;

    fn subscribe(self, send: Send<Self::Message>) -> Unsubscribe;
}

pub struct Unsubscribe(Option<Box<FnMut()>>);

impl Unsubscribe {
    pub fn new(f: impl FnMut() + 'static) -> Self {
        Unsubscribe(Some(Box::new(f)))
    }
}

impl std::fmt::Debug for Unsubscribe {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("Unsubscribe").finish()
    }
}

impl Drop for Unsubscribe {
    fn drop(&mut self) {
        if let Some(mut f) = self.0.take() {
            f()
        }
    }
}

#[derive(Debug)]
pub struct OnWindow {
    name: String,
}

impl OnWindow {
    pub fn new<N: Into<String>>(name: N) -> Self {
        OnWindow { name: name.into() }
    }
}

impl Subscription for OnWindow {
    type Message = web::Event;

    fn subscribe(self, send: Send<Self::Message>) -> Unsubscribe {
        let window = web::window().unwrap();
        let closure = Closure::wrap(Box::new(move |event: web::Event| {
            send(event);
        }) as Box<FnMut(web::Event)>);
        (window.as_ref() as &web::EventTarget)
            .add_event_listener_with_callback(&self.name, closure.as_ref().unchecked_ref())
            .unwrap();
        Unsubscribe::new(move || {
            (window.as_ref() as &web::EventTarget)
                .remove_event_listener_with_callback(&self.name, closure.as_ref().unchecked_ref())
                .unwrap();
        })
    }
}

#[derive(Debug)]
pub struct Interval {
    ms: i32,
}

impl Interval {
    pub fn new(ms: i32) -> Self {
        Interval { ms }
    }
}

impl Subscription for Interval {
    type Message = ();

    fn subscribe(self, send: Send<Self::Message>) -> Unsubscribe {
        let window = web::window().unwrap();
        let closure = Closure::wrap(Box::new(move || {
            send(());
        }) as Box<FnMut()>);
        let id = window
            .set_interval_with_callback_and_timeout_and_arguments(
                closure.as_ref().unchecked_ref(),
                self.ms,
                &js::Array::new(),
            )
            .unwrap();
        Unsubscribe::new(move || {
            // We need to move `closure` here so that it isn't dropped too early.
            let _ = closure;
            window.clear_interval_with_handle(id);
        })
    }
}