workers-rsx-impl 0.1.0

Proc macros for workers-rsx
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

use crate::child::Child;
use crate::children::Children;
use crate::element_attribute::ElementAttribute;
use crate::element_attributes::ElementAttributes;
use crate::tags::{ClosingTag, OpenTag};
use quote::{quote, ToTokens};
use syn::parse::{Parse, ParseStream, Result};

pub struct Element {
    name: syn::Path,
    attributes: ElementAttributes,
    children: Children,
}

impl Parse for Element {
    fn parse(input: ParseStream) -> Result<Self> {
        let open_tag = input.parse::<OpenTag>()?;

        let children = if open_tag.self_closing {
            Children::default()
        } else {
            let children = input.parse::<Children>()?;
            let closing_tag = input.parse::<ClosingTag>()?;
            closing_tag.validate(&open_tag);
            children
        };

        Ok(Element {
            name: open_tag.name,
            attributes: open_tag.attributes,
            children,
        })
    }
}

impl Element {
    pub fn is_custom_element(&self) -> bool {
        match self.name.get_ident() {
            None => true,
            Some(ident) => {
                let name = ident.to_string();
                let first_letter = name.get(0..1).unwrap();
                first_letter.to_uppercase() == first_letter
            }
        }
    }

    /// Collect all static class names from this element and its descendants.
    pub fn collect_class_names(&self) -> Vec<String> {
        let mut classes = Vec::new();

        // Check attributes for "class" with a string literal value
        for attr in &self.attributes.attributes {
            if let ElementAttribute::WithValue(key, block) = attr {
                let key_str = key
                    .iter()
                    .map(|i| i.to_string())
                    .collect::<Vec<_>>()
                    .join("-");
                if key_str == "class" {
                    if block.stmts.len() == 1 {
                        if let syn::Stmt::Expr(syn::Expr::Lit(syn::ExprLit {
                            lit: syn::Lit::Str(s),
                            ..
                        })) = &block.stmts[0]
                        {
                            for class_name in s.value().split_whitespace() {
                                classes.push(class_name.to_string());
                            }
                        }
                    }
                }
            }
        }

        // Recurse into children
        for child in &self.children.nodes {
            Child::collect_class_names_from(child, &mut classes);
        }

        classes
    }

    /// Inject a `TailwindStyle` child into the `<head>` element.
    /// Walks the tree recursively to find `<head>` among children.
    /// Returns `true` if injection succeeded.
    pub fn inject_tailwind_style(&mut self, class_names: Vec<String>) -> bool {
        if let Some(ident) = self.name.get_ident() {
            if ident.to_string() == "head" {
                self.children
                    .nodes
                    .push(Child::TailwindStyle(class_names));
                return true;
            }
        }
        // Recurse into child elements
        for child in &mut self.children.nodes {
            if let Child::Element(el) = child {
                if el.inject_tailwind_style(class_names.clone()) {
                    return true;
                }
            }
        }
        false
    }

    /// Prepend a child node at the beginning of this element's children.
    pub fn prepend_child(&mut self, child: Child) {
        self.children.nodes.insert(0, child);
    }
}

impl ToTokens for Element {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let name = &self.name;

        let declaration = if self.is_custom_element() {
            let attrs = self.attributes.for_custom_element(&self.children);
            quote! { #name #attrs }
        } else {
            let attrs = self.attributes.for_simple_element();
            let children_tuple = self.children.as_option_of_tuples_tokens();
            quote! {
                workers_rsx::SimpleElement {
                    tag_name: stringify!(#name),
                    attributes: #attrs,
                    contents: #children_tuple,
                }
            }
        };

        declaration.to_tokens(tokens);
    }
}