wal-core 0.1.1

A framework for creating client-side single-page apps using Rust.
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

macro_rules! define_events {
    ($($event:ident),*) => {
        $(
            pub struct $event(web_sys::$event);

            impl Deref for $event {
                type Target = web_sys::$event;

                fn deref(&self) -> &Self::Target {
                    &self.0
                }
            }

            impl $event {
                #[allow(dead_code)]
                fn new(event: web_sys::$event) -> Self {
                    Self(event)
                }
            }
        )*
    };
}

macro_rules! event_creators {
    ($($handler_name:ident ($event_type:ty)),*) => {
        $(
            struct $handler_name {
                event_type: Cow<'static, str>,
                callback: Callback<$event_type>,
            }

            impl EventCreator for $handler_name {
                fn get_event_type(&self) -> Cow<'static, str> {
                    self.event_type.clone()
                }

                fn create_callback(&self) -> Box<dyn FnMut(&web_sys::Event)> {
                    let callback = self.callback.clone();
                    Box::new(move |event: &web_sys::Event| {
                        let event = <$event_type>::new(event.clone().unchecked_into());
                        callback.emit(event);
                    })
                }
            }

            impl $handler_name {
                fn new(event_type: Cow<'static, str>, callback: Callback<$event_type>) -> Self {
                    Self {
                        event_type,
                        callback,
                    }
                }
            }

            impl EventCreatorType for $event_type {
                type Creator = $handler_name;
            }
        )*
    }
}

macro_rules! unspecialized_event_creators_constructor {
    ($($event_name:ident),*) => {
        $(
            #[allow(dead_code)]
            pub fn $event_name(callback: Callback<Event>) -> Box<dyn EventCreator> {
                Box::new(UnspecializedEventCreator {
                    event_type: Cow::from(stringify!($event_name)[2..].to_string()),
                    callback,
                })
            }
        )*
    };
}

macro_rules! event_creators_constructor {
    ($($event_name:ident ($event_type:ty) ),*) => {
        $(
            pub fn $event_name(callback: Callback<$event_type>) -> Box<dyn EventCreator> {
                Box::new(<$event_type as EventCreatorType>::Creator::new(
                    Cow::from(stringify!($event_name)[2..].to_string()),
                    callback
                ))
            }
        )*
    };
}