iweb 0.1.0

Use web_sys like call link
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

pub mod fetch;
pub mod sys;
pub mod theme;

use js_sys;
use serde_json;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use wasm_bindgen::prelude::*;

pub fn perf_to_system(amt: f64) -> SystemTime {
    let secs = (amt as u64) / 1_000;
    let nanos = (((amt as u64) % 1_000) as u32) * 1_000_000;
    UNIX_EPOCH + Duration::new(secs, nanos)
}

pub fn now() -> SystemTime {
    perf_to_system(js_sys::Date::now())
}

#[derive(Debug, PartialEq, Clone)]
pub struct Ele {
    pub ele: web_sys::HtmlElement,
}

impl From<web_sys::HtmlElement> for Ele {
    fn from(e: web_sys::HtmlElement) -> Ele {
        Ele { ele: e }
    }
}

impl From<web_sys::Element> for Ele {
    fn from(e: web_sys::Element) -> Ele {
        Ele {
            ele: web_sys::HtmlElement::from(JsValue::from(e)),
        }
    }
}

impl From<web_sys::Document> for Ele {
    fn from(e: web_sys::Document) -> Ele {
        Ele {
            ele: web_sys::HtmlElement::from(JsValue::from(e)),
        }
    }
}

impl From<web_sys::Node> for Ele {
    fn from(e: web_sys::Node) -> Ele {
        Ele {
            ele: web_sys::HtmlElement::from(JsValue::from(e)),
        }
    }
}

impl From<JsValue> for Ele {
    fn from(e: JsValue) -> Ele {
        Ele {
            ele: web_sys::HtmlElement::from(e),
        }
    }
}

pub fn tag(tag: &str) -> Ele {
    Ele::from(sys::create_element(tag))
}

pub fn body() -> Ele {
    Ele::from(sys::body())
}

pub fn document() -> Ele {
    Ele {
        ele: web_sys::HtmlElement::from(JsValue::from(
            web_sys::window().unwrap().document().unwrap(),
        )),
    }
}

pub fn get_element_by_id(id: &str) -> Option<Ele> {
    if let Some(e) = sys::document().get_element_by_id(id) {
        return Some(Ele::from(e));
    }
    None
}

pub fn log(data: serde_json::Value) {
    web_sys::console::log_1(&JsValue::from_str(data.to_string().as_str()));
}

impl Ele {
    pub fn append(self, node: &Ele) -> Self {
        if let Err(e) = self.ele.append_child(&node.ele) {
            web_sys::console::log(&js_sys::Array::from(&e));
        };
        self
    }
    pub fn query_selector(self, txt: &str) -> Option<Ele> {
        if let Some(ele) = self.ele.query_selector(txt).expect("query_selecor error") {
            return Some(Ele::from(ele));
        }
        None
    }
    pub fn query_selector_all(self, txt: &str) -> Vec<Ele> {
        let list = self
            .ele
            .query_selector_all(txt)
            .expect("query_selecor error");

        let mut out = Vec::new();
        for i in 0..list.length() {
            if let Some(ele) = list.item(i) {
                out.push(Ele::from(ele));
            }
        }
        out
    }
    pub fn text(self, txt: &str) -> Self {
        self.ele.set_text_content(Some(txt));
        self
    }
    pub fn id(self, txt: &str) -> Self {
        self.ele.set_id(txt);
        self
    }
    pub fn class(self, txt: &str) -> Self {
        self.ele.set_class_name(txt);
        self
    }
    pub fn attr(self, name: &str, txt: &str) -> Self {
        self.ele
            .set_attribute(name, txt)
            .expect(format!("can not set attribute: {} {}", name, txt).as_str());

        self
    }
    pub fn inner_html(self, txt: &str) -> Self {
        self.ele.set_inner_html(txt);
        self
    }
    pub fn inner_text(self, txt: &str) -> Self {
        self.ele.set_inner_text(txt);
        self
    }
}