virtual-dom 1.0.4

A virtual DOM implementation for HTML manipulation
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

mod document;
mod dom_node;
mod html;

use std::{collections::VecDeque, iter};

pub use document::*;
pub use dom_node::*;
use html::*;
pub use html::{parse_html, parse_html_from_string, Html};

/// Used in dom-proc for converting braced variables into domnode and to allow any kind of dom element to be appended
#[derive(Debug, PartialEq)]
pub struct IterableNodes(pub Vec<DomNode>);

impl From<String> for IterableNodes {
    fn from(value: String) -> Self {
        Self(vec![DomNode::create_text(value)])
    }
}
impl From<&String> for IterableNodes {
    fn from(value: &String) -> Self {
        Self(vec![DomNode::create_text(value)])
    }
}

impl From<&str> for IterableNodes {
    fn from(value: &str) -> Self {
        Self(vec![DomNode::create_text(value)])
    }
}

impl From<DomNode> for IterableNodes {
    fn from(value: DomNode) -> Self {
        Self(vec![value])
    }
}

impl From<Vec<DomNode>> for IterableNodes {
    fn from(value: Vec<DomNode>) -> Self {
        Self(value)
    }
}

impl FromIterator<DomNode> for IterableNodes {
    fn from_iter<T: IntoIterator<Item = DomNode>>(iter: T) -> Self {
        Self(iter.into_iter().collect())
    }
}

impl FromIterator<Html> for IterableNodes {
    fn from_iter<T: IntoIterator<Item = Html>>(iter: T) -> Self {
        iter.into_iter()
            .map(|value| match value {
                Html::Comment { .. } => panic!("root html can't be comment"),
                Html::Text { text } => DomNode::create_text(text),
                Html::Element {
                    tag,
                    attributes,
                    children,
                } => {
                    let root = DomNode::create_element_with_attributes(tag, attributes);
                    let mut queue: VecDeque<(Html, DomNode)> = VecDeque::from(
                        children
                            .into_iter()
                            .zip(std::iter::repeat(root.clone()))
                            .collect::<Vec<(Html, DomNode)>>(),
                    );
                    while let Some((c, parent)) = queue.pop_front() {
                        if let Some(p) = match c {
                            Html::Text { text } => Some(DomNode::create_text(text)),
                            Html::Element {
                                tag,
                                attributes,
                                children,
                            } => {
                                let p = DomNode::create_element_with_attributes(tag, attributes);
                                queue
                                    .extend(children.into_iter().zip(std::iter::repeat(p.clone())));
                                Some(p)
                            }
                            _ => None,
                        } {
                            parent.append_child(p)
                        }
                    }
                    root
                }
            })
            .collect()
    }
}

impl From<Vec<Html>> for IterableNodes {
    fn from(value: Vec<Html>) -> Self {
        value.into_iter().collect()
    }
}

impl From<Html> for IterableNodes {
    fn from(value: Html) -> Self {
        iter::once(value).collect()
    }
}