vertigo 0.11.2

Reactive Real-DOM library with SSR for 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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

#[cfg(all(not(test), target_arch = "wasm32", target_os = "unknown"))]
mod inner {
    #[link(wasm_import_module = "mod")]
    unsafe extern "C" {
        pub fn panic_message(long_ptr: u64);
        pub fn dom_access(long_ptr: u64) -> u64;
    }
}

#[cfg(all(not(test), target_arch = "wasm32", target_os = "unknown"))]
pub mod safe_wrappers {
    use crate::dev::LongPtr;

    use super::inner::*;

    pub fn safe_panic_message(long_ptr: LongPtr) {
        let long_ptr = long_ptr.get_long_ptr();
        unsafe { panic_message(long_ptr) }
    }

    pub fn safe_dom_access(long_ptr: LongPtr) -> LongPtr {
        let long_ptr = long_ptr.get_long_ptr();
        let result = unsafe { dom_access(long_ptr) };
        LongPtr::from(result)
    }
}

#[cfg(any(test, not(target_arch = "wasm32"), not(target_os = "unknown")))]
pub mod safe_wrappers {
    use crate::{
        JsJson, JsJsonSerialize,
        dev::{
            LongPtr,
            command::{CommandForBrowser, browser_response, decode_json},
        },
        driver_module::api::api_arguments,
    };

    pub fn safe_panic_message(_long_ptr: LongPtr) {}

    pub fn safe_dom_access(long_ptr: LongPtr) -> LongPtr {
        let json = api_arguments().get_by_long_ptr(long_ptr);

        let command_res = decode_json::<CommandForBrowser>(json);

        match command_res {
            Ok(command) => {
                let response = match command {
                    CommandForBrowser::FetchCacheGet => {
                        browser_response::FetchCacheGet { data: None }.to_json()
                    }
                    CommandForBrowser::IsBrowser => {
                        let response = browser_response::IsBrowser { value: false };
                        response.to_json()
                    }
                    CommandForBrowser::GetDateNow => {
                        let response = browser_response::GetDateNow { value: 0 };
                        response.to_json()
                    }
                    CommandForBrowser::LocationGet { target: _ } => {
                        browser_response::LocationGet { value: "".into() }.to_json()
                    }
                    CommandForBrowser::CookieGet { name: _ } => {
                        browser_response::CookieGet { value: "".into() }.to_json()
                    }
                    CommandForBrowser::CookieJsonGet { name: _ } => {
                        browser_response::CookieJsonGet {
                            value: JsJson::Null,
                        }
                        .to_json()
                    }
                    CommandForBrowser::GetEnv { name: _ } => {
                        browser_response::GetEnv { value: None }.to_json()
                    }
                    CommandForBrowser::TimezoneOffset => {
                        browser_response::TimezoneOffset { value: 0 }.to_json()
                    }
                    CommandForBrowser::GetRandom { min, max: _ } => {
                        browser_response::GetRandom { value: min }.to_json()
                    }
                    CommandForBrowser::FetchExec { .. }
                    | CommandForBrowser::SetStatus { .. }
                    | CommandForBrowser::WebsocketRegister { .. }
                    | CommandForBrowser::WebsocketUnregister { .. }
                    | CommandForBrowser::WebsocketSendMessage { .. }
                    | CommandForBrowser::TimerSet { .. }
                    | CommandForBrowser::TimerClear { .. }
                    | CommandForBrowser::LocationCallback { .. }
                    | CommandForBrowser::LocationSet { .. }
                    | CommandForBrowser::CookieSet { .. }
                    | CommandForBrowser::CookieJsonSet { .. }
                    | CommandForBrowser::Log { .. }
                    | CommandForBrowser::HistoryBack
                    | CommandForBrowser::JsApiCall { .. }
                    | CommandForBrowser::DomBulkUpdate { .. } => JsJson::Null,
                };

                return response.to_ptr_long();
            }
            Err(err) => {
                log::error!("safe_dom_access -> decode error = {err}");
            }
        }

        LongPtr::from(0)
    }
}