add component support

packages/rsx_interperter/src/captuered_context.rs

@@ -83,6 +83,13 @@ impl ToTokens for CapturedContextBuilder {
             iterators,
             captured_expressions,
         } = self;
+        let compontents_str = components
+            .iter()
+            .map(|comp| comp.to_token_stream().to_string());
+        let components = components.iter().map(|comp| comp);
+        let iterators_str = iterators
+            .iter()
+            .map(|expr| expr.to_token_stream().to_string());
         let captured: Vec<_> = attributes
             .iter()
             .map(|(_, fmt)| fmt.named_args.iter())
@@ -99,8 +106,8 @@ impl ToTokens for CapturedContextBuilder {
                 captured: IfmtArgs{
                     named_args: vec![#((#captured_names, #captured_expr.to_string())),*]
                 },
-                components: vec![#(#components),*],
-                iterators: vec![#(#iterators),*],
+                components: vec![#((#compontents_str, #components)),*],
+                iterators: vec![#((#iterators_str, #iterators)),*],
                 expressions: vec![#((#captured_attr_expressions_text, #captured_expressions.to_string())),*],
             }
         })
@@ -113,9 +120,9 @@ pub struct CapturedContext<'a> {
     // // map of the attribute name and element path to the formated value
     // pub captured_attribute_values: IfmtArgs,
     // the only thing we can update in component is the children
-    pub components: Vec<VNode<'a>>,
+    pub components: Vec<(&'static str, VNode<'a>)>,
     // we can't reasonably interpert iterators, so they are staticly inserted
-    pub iterators: Vec<VNode<'a>>,
+    pub iterators: Vec<(&'static str, VNode<'a>)>,
     // map expression to the value resulting from the expression
     pub expressions: Vec<(&'static str, String)>,
 }

packages/rsx_interperter/src/interperter.rs

@@ -1,7 +1,8 @@
 use dioxus_core::{Attribute, NodeFactory, VNode};
-use dioxus_rsx::{BodyNode, CallBody, ElementAttr};
+use dioxus_rsx::{BodyNode, CallBody, Component, ElementAttr};
+use quote::ToTokens;
 use std::str::FromStr;
-use syn::{parse_str, Expr};
+use syn::{parse2, parse_str, Expr};
 
 use crate::attributes::attrbute_to_static_str;
 use crate::captuered_context::{CapturedContext, IfmtArgs};
@@ -83,17 +84,21 @@ impl FromStr for InterperedIfmt {
     }
 }
 
-pub fn build<'a>(rsx: CallBody, ctx: CapturedContext, factory: &NodeFactory<'a>) -> VNode<'a> {
+pub fn build<'a>(
+    rsx: CallBody,
+    mut ctx: CapturedContext<'a>,
+    factory: &NodeFactory<'a>,
+) -> VNode<'a> {
     let children_built = factory.bump().alloc(Vec::new());
     for (i, child) in rsx.roots.into_iter().enumerate() {
-        children_built.push(build_node(child, &ctx, factory, i.to_string().as_str()));
+        children_built.push(build_node(child, &mut ctx, factory, i.to_string().as_str()));
     }
     factory.fragment_from_iter(children_built.iter())
 }
 
 fn build_node<'a>(
     node: BodyNode,
-    ctx: &CapturedContext,
+    ctx: &mut CapturedContext<'a>,
     factory: &NodeFactory<'a>,
     key: &str,
 ) -> Option<VNode<'a>> {
@@ -190,7 +195,19 @@ fn build_node<'a>(
                 None
             }
         }
-        BodyNode::Component(_) => todo!(),
+        BodyNode::Component(comp) => {
+            let expr: Expr = parse2(comp.to_token_stream()).unwrap();
+            if let Some(idx) = ctx
+                .components
+                .iter()
+                .position(|(code, _)| parse_str::<Expr>(*code).unwrap() == expr)
+            {
+                let (_, vnode) = ctx.components.remove(idx);
+                Some(vnode)
+            } else {
+                panic!("could not resolve component {:?}", comp.name);
+            }
+        }
         BodyNode::RawExpr(_) => todo!(),
         BodyNode::Meta(_) => todo!(),
     }

packages/rsx_interperter/src/lib.rs

@@ -34,7 +34,7 @@ pub fn with_hot_reload(cx: Scope<Component>) -> Element {
 pub fn interpert_rsx<'a, 'b>(
     factory: dioxus_core::NodeFactory<'a>,
     text: &str,
-    context: captuered_context::CapturedContext,
+    context: captuered_context::CapturedContext<'a>,
 ) -> VNode<'a> {
     build(parse_str(text).unwrap(), context, &factory)
 }