vertigo 0.1.1

Reactive Real-DOM library 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
108
109
110
111
112
113
114
115

use crate::driver_module::js_value::{js_value_struct::JsValue, memory_block::MemoryBlock};

#[derive(Debug)]
pub struct JsValueBuilder {
    list: Vec<JsValue>,
}

impl JsValueBuilder {
    pub fn new() -> JsValueBuilder {
        JsValueBuilder {
            list: Vec::new(),
        }
    }

    pub fn string(mut self, value: impl Into<String>) -> Self {
        let value = value.into();
        self.list.push(JsValue::String(value));
        self
    }

    #[allow(dead_code)]
    pub fn string_option(self, value: Option<String>) -> Self {
        match value {
            Some(body) => self.string(body),
            None => self.null(),
        }
    }
    pub fn str(mut self, value: &str) -> Self {
        self.list.push(JsValue::String(value.into()));
        self
    }

    pub fn str_push(&mut self, value: &str) {
        self.list.push(JsValue::String(value.into()));
    }

    #[allow(dead_code)]
    pub fn u32(mut self, value: u32) -> Self {
        self.list.push(JsValue::U32(value));
        self
    }

    #[allow(dead_code)]
    pub fn i32(mut self, value: i32) -> Self {
        self.list.push(JsValue::I32(value));
        self
    }

    pub fn u64(mut self, value: u64) -> Self {
        self.list.push(JsValue::U64(value));
        self
    }

    #[allow(dead_code)]
    pub fn i64(mut self, value: i64) -> Self {
        self.list.push(JsValue::I64(value));
        self
    }

    #[allow(dead_code)]
    pub fn bool(mut self, value: bool) -> Self {
        let value = if value {
            JsValue::True
        } else {
            JsValue::False
        };

        self.list.push(value);
        self
    }

    pub fn null(mut self) -> Self {
        self.list.push(JsValue::Null);
        self
    }

    pub fn value(mut self, value: JsValue) -> Self {
        self.list.push(value);
        self
    }

    pub fn value_push(&mut self, value: JsValue) {
        self.list.push(value);
    }

    pub fn list(mut self, create: impl FnOnce(JsValueBuilder) -> JsValueBuilder ) -> Self {
        let sub_list = JsValueBuilder::new();
        let sub_list = create(sub_list);
        self.list.push(JsValue::List(sub_list.list));
        self
    }

    #[allow(dead_code)]
    pub fn list_push(mut self, list: Vec<JsValue>) -> Self {
        self.list.push(JsValue::List(list));
        self
    }

    pub fn extend(mut self, list: Vec<JsValue>) -> Self {
        for item in list {
            self.list.push(item);
        }

        self
    }

    pub fn get(self) -> JsValue {
        JsValue::List(self.list)
    }

    pub fn build(self) -> MemoryBlock {
        self.get().to_snapshot()
    }
}