127 lines
4.8 KiB
Rust
127 lines
4.8 KiB
Rust
use dioxus_core::VNode;
|
|
use dioxus_rsx::{BodyNode, CallBody, Component, ElementAttr, IfmtInput};
|
|
use quote::{quote, ToTokens, TokenStreamExt};
|
|
use std::{any::Any, collections::HashMap};
|
|
use syn::Expr;
|
|
|
|
#[derive(Default)]
|
|
pub struct CapturedContextBuilder {
|
|
pub attributes: HashMap<String, IfmtInput>,
|
|
pub text: Vec<IfmtInput>,
|
|
pub components: Vec<Component>,
|
|
pub iterators: Vec<Expr>,
|
|
pub captured_expressions: Vec<Expr>,
|
|
}
|
|
|
|
impl CapturedContextBuilder {
|
|
pub fn extend(&mut self, other: CapturedContextBuilder) {
|
|
self.attributes.extend(other.attributes);
|
|
self.text.extend(other.text);
|
|
self.components.extend(other.components);
|
|
self.iterators.extend(other.iterators);
|
|
self.captured_expressions.extend(other.captured_expressions);
|
|
}
|
|
|
|
pub fn from_call_body(body: CallBody) -> Self {
|
|
let mut new = Self::default();
|
|
for node in body.roots {
|
|
new.extend(Self::find_captured(node));
|
|
}
|
|
new
|
|
}
|
|
|
|
fn find_captured(node: BodyNode) -> Self {
|
|
let mut captured = CapturedContextBuilder::default();
|
|
match node {
|
|
BodyNode::Element(el) => {
|
|
for attr in el.attributes {
|
|
match attr.attr {
|
|
ElementAttr::AttrText { name, value } => {
|
|
let (name, value_tokens) = (name.to_string(), value.to_token_stream());
|
|
let formated: IfmtInput = syn::parse2(value_tokens).unwrap();
|
|
captured.attributes.insert(name, formated);
|
|
}
|
|
ElementAttr::AttrExpression { name, value } => {
|
|
captured.captured_expressions.push(value);
|
|
}
|
|
ElementAttr::CustomAttrText { name, value } => {
|
|
let (name, value_tokens) = (name.value(), value.to_token_stream());
|
|
let formated: IfmtInput = syn::parse2(value_tokens).unwrap();
|
|
captured.attributes.insert(name, formated);
|
|
}
|
|
ElementAttr::CustomAttrExpression { name, value } => {
|
|
captured.captured_expressions.push(value);
|
|
}
|
|
_ => (),
|
|
}
|
|
}
|
|
for child in el.children {
|
|
captured.extend(Self::find_captured(child));
|
|
}
|
|
}
|
|
BodyNode::Component(comp) => {
|
|
captured.components.push(comp);
|
|
}
|
|
BodyNode::Text(t) => {
|
|
let tokens = t.to_token_stream();
|
|
let formated: IfmtInput = syn::parse2(tokens).unwrap();
|
|
captured.text.push(formated);
|
|
}
|
|
BodyNode::RawExpr(expr) => captured.iterators.push(expr),
|
|
BodyNode::Meta(_) => (),
|
|
}
|
|
captured
|
|
}
|
|
}
|
|
|
|
impl ToTokens for CapturedContextBuilder {
|
|
fn to_tokens(&self, tokens: &mut quote::__private::TokenStream) {
|
|
let CapturedContextBuilder {
|
|
attributes,
|
|
text,
|
|
components,
|
|
iterators,
|
|
captured_expressions,
|
|
} = self;
|
|
let captured: Vec<_> = attributes
|
|
.iter()
|
|
.map(|(_, fmt)| fmt.named_args.iter())
|
|
.chain(text.iter().map(|fmt| fmt.named_args.iter()))
|
|
.flatten()
|
|
.collect();
|
|
let captured_names = captured.iter().map(|(n, _)| n.to_string());
|
|
let captured_expr = captured.iter().map(|(_, e)| e);
|
|
let captured_attr_expressions_text = captured_expressions
|
|
.iter()
|
|
.map(|e| format!("{}", e.to_token_stream()));
|
|
tokens.append_all(quote! {
|
|
CapturedContext {
|
|
captured: IfmtArgs{
|
|
named_args: vec![#((#captured_names, #captured_expr.to_string())),*]
|
|
},
|
|
components: vec![#(#components),*],
|
|
iterators: vec![#(#iterators),*],
|
|
expressions: vec![#((#captured_attr_expressions_text, #captured_expressions.to_string())),*],
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
pub struct CapturedContext<'a> {
|
|
// map of the variable name to the formated value
|
|
pub captured: IfmtArgs,
|
|
// // 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>>,
|
|
// we can't reasonably interpert iterators, so they are staticly inserted
|
|
pub iterators: Vec<VNode<'a>>,
|
|
// map expression to the value resulting from the expression
|
|
pub expressions: Vec<(&'static str, String)>,
|
|
}
|
|
|
|
pub struct IfmtArgs {
|
|
// live reload only supports named arguments
|
|
pub named_args: Vec<(&'static str, String)>,
|
|
}
|