Feat: move the rsx macro around

packages/core-macro/src/rsx/element.rs

@@ -0,0 +1,223 @@
+use super::*;
+
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{quote, ToTokens, TokenStreamExt};
+use syn::{
+    ext::IdentExt,
+    parse::{discouraged::Speculative, Parse, ParseBuffer, ParseStream},
+    token, Error, Expr, ExprClosure, Ident, LitStr, Result, Token,
+};
+
+// =======================================
+// Parse the VNode::Element type
+// =======================================
+pub struct Element {
+    name: Ident,
+    attrs: Vec<ElementAttr>,
+    children: Vec<Node>,
+}
+
+impl Parse for Element {
+    fn parse(stream: ParseStream) -> Result<Self> {
+        //
+        let name = Ident::parse(stream)?;
+
+        if !crate::util::is_valid_tag(&name.to_string()) {
+            return Err(Error::new(name.span(), "Not a valid Html tag"));
+        }
+
+        // parse the guts
+        let content: ParseBuffer;
+        syn::braced!(content in stream);
+
+        let mut attrs: Vec<ElementAttr> = vec![];
+        let mut children: Vec<Node> = vec![];
+        'parsing: loop {
+            // [1] Break if empty
+            if content.is_empty() {
+                break 'parsing;
+            }
+
+            let forked = content.fork();
+            if forked.call(Ident::parse_any).is_ok()
+                && forked.parse::<Token![:]>().is_ok()
+                && forked.parse::<Token![:]>().is_err()
+            {
+                attrs.push(content.parse::<ElementAttr>()?);
+            } else {
+                children.push(content.parse::<Node>()?);
+            }
+
+            // consume comma if it exists
+            // we don't actually care if there *are* commas after elements/text
+            if content.peek(Token![,]) {
+                let _ = content.parse::<Token![,]>();
+            }
+        }
+
+        Ok(Self {
+            name,
+            attrs,
+            children,
+        })
+    }
+}
+
+impl ToTokens for Element {
+    fn to_tokens(&self, tokens: &mut TokenStream2) {
+        let name = &self.name.to_string();
+
+        tokens.append_all(quote! {
+            dioxus::builder::ElementBuilder::new(__ctx, #name)
+        });
+
+        for attr in self.attrs.iter() {
+            attr.to_tokens(tokens);
+        }
+
+        let mut children = self.children.iter();
+        while let Some(child) = children.next() {
+            let inner_toks = child.to_token_stream();
+            tokens.append_all(quote! {
+                .iter_child(#inner_toks)
+            })
+        }
+
+        tokens.append_all(quote! {
+            .finish()
+        });
+    }
+}
+
+/// =======================================
+/// Parse a VElement's Attributes
+/// =======================================
+struct ElementAttr {
+    name: Ident,
+    ty: AttrType,
+}
+
+enum AttrType {
+    BumpText(LitStr),
+    FieldTokens(Expr),
+    EventTokens(Expr),
+    Event(ExprClosure),
+}
+
+impl Parse for ElementAttr {
+    fn parse(s: ParseStream) -> Result<Self> {
+        let mut name = Ident::parse_any(s)?;
+        let name_str = name.to_string();
+        s.parse::<Token![:]>()?;
+
+        // Check if this is an event handler
+        // If so, parse into literal tokens
+        let ty = if name_str.starts_with("on") {
+            // remove the "on" bit
+            name = Ident::new(&name_str.trim_start_matches("on"), name.span());
+
+            if s.peek(token::Brace) {
+                let content;
+                syn::braced!(content in s);
+
+                // Try to parse directly as a closure
+                let fork = content.fork();
+                if let Ok(event) = fork.parse::<ExprClosure>() {
+                    content.advance_to(&fork);
+                    AttrType::Event(event)
+                } else {
+                    AttrType::EventTokens(content.parse()?)
+                }
+            } else {
+                AttrType::Event(s.parse()?)
+            }
+        } else {
+            match name_str.as_str() {
+                "style" => {
+                    //
+                    todo!("inline style not yet supported")
+                }
+                "classes" => {
+                    //
+                    todo!("custom class lsit not supported")
+                }
+                "namespace" => {
+                    //
+                    todo!("custom namespace not supported")
+                }
+                "ref" => {
+                    //
+                    todo!("custom ref not supported")
+                }
+                _ => {
+                    if s.peek(LitStr) {
+                        let rawtext = s.parse::<LitStr>().unwrap();
+                        AttrType::BumpText(rawtext)
+                    } else {
+                        let toks = s.parse::<Expr>()?;
+                        AttrType::FieldTokens(toks)
+                    }
+                }
+            }
+
+            // let lit_str = if name_str == "style" && s.peek(token::Brace) {
+            //     // special-case to deal with literal styles.
+            //     let outer;
+            //     syn::braced!(outer in s);
+            //     // double brace for inline style.
+            //     // todo!("Style support not ready yet");
+
+            //     // if outer.peek(token::Brace) {
+            //     //     let inner;
+            //     //     syn::braced!(inner in outer);
+            //     //     let styles: Styles = inner.parse()?;
+            //     //     MaybeExpr::Literal(LitStr::new(&styles.to_string(), Span::call_site()))
+            //     // } else {
+            //     // just parse as an expression
+            //     outer.parse()?
+            // // }
+            // } else {
+            //     s.parse()?
+            // };
+        };
+
+        // consume comma if it exists
+        // we don't actually care if there *are* commas between attrs
+        if s.peek(Token![,]) {
+            let _ = s.parse::<Token![,]>();
+        }
+
+        Ok(ElementAttr { name, ty })
+    }
+}
+
+impl ToTokens for ElementAttr {
+    fn to_tokens(&self, tokens: &mut TokenStream2) {
+        let name = self.name.to_string();
+        let nameident = &self.name;
+        let _attr_stream = TokenStream2::new();
+        match &self.ty {
+            AttrType::BumpText(value) => {
+                tokens.append_all(quote! {
+                    .attr(#name, format_args_f!(#value))
+                });
+            }
+            AttrType::Event(event) => {
+                tokens.append_all(quote! {
+                    .add_listener(dioxus::events::on::#nameident(__ctx, #event))
+                });
+            }
+            AttrType::FieldTokens(exp) => {
+                tokens.append_all(quote! {
+                    .attr(#name, #exp)
+                });
+            }
+            AttrType::EventTokens(event) => {
+                //
+                tokens.append_all(quote! {
+                    .add_listener(dioxus::events::on::#nameident(__ctx, #event))
+                })
+            }
+        }
+    }
+}