|
|
@@ -1,1064 +0,0 @@
|
|
|
-// use proc_macro2::TokenStream;
|
|
|
-// use quote::TokenStreamExt;
|
|
|
-// use quote::{quote, ToTokens};
|
|
|
-// use syn::{Expr, Ident, LitStr};
|
|
|
-
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// pub fn try_parse_template(
|
|
|
-// rsx: &str,
|
|
|
-// location: OwnedCodeLocation,
|
|
|
-// previous_template: Option<DynamicTemplateContextBuilder>,
|
|
|
-// ) -> Result<(OwnedTemplate, DynamicTemplateContextBuilder), Error> {
|
|
|
-// use crate::CallBody;
|
|
|
-
|
|
|
-// let call_body: CallBody =
|
|
|
-// syn::parse_str(rsx).map_err(|e| Error::ParseError(ParseError::new(e, location.clone())))?;
|
|
|
-// let mut template_builder = TemplateBuilder::from_roots_always(call_body.roots);
|
|
|
-// if let Some(prev) = previous_template {
|
|
|
-// template_builder = template_builder
|
|
|
-// .try_switch_dynamic_context(prev)
|
|
|
-// .ok_or_else(|| {
|
|
|
-// Error::RecompileRequiredError(RecompileReason::Variable(
|
|
|
-// "dynamic context updated".to_string(),
|
|
|
-// ))
|
|
|
-// })?;
|
|
|
-// }
|
|
|
-// let dyn_ctx = template_builder.dynamic_context.clone();
|
|
|
-// Ok((template_builder.try_into_owned(&location)?, dyn_ctx))
|
|
|
-// }
|
|
|
-
|
|
|
-// use crate::{BodyNode, ElementAttr, FormattedSegment, Segment};
|
|
|
-
|
|
|
-// struct TemplateElementBuilder {
|
|
|
-// tag: Ident,
|
|
|
-// attributes: Vec<TemplateAttributeBuilder>,
|
|
|
-// children: Vec<TemplateNodeId>,
|
|
|
-// listeners: Vec<usize>,
|
|
|
-// locally_static: bool,
|
|
|
-// }
|
|
|
-
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// type OwndedTemplateElement = TemplateElement<
|
|
|
-// Vec<TemplateAttribute<OwnedAttributeValue>>,
|
|
|
-// OwnedAttributeValue,
|
|
|
-// Vec<TemplateNodeId>,
|
|
|
-// Vec<usize>,
|
|
|
-// >;
|
|
|
-
|
|
|
-// impl TemplateElementBuilder {
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// fn try_into_owned(self, location: &OwnedCodeLocation) -> Result<OwndedTemplateElement, Error> {
|
|
|
-// let Self {
|
|
|
-// tag,
|
|
|
-// attributes,
|
|
|
-// children,
|
|
|
-// listeners,
|
|
|
-// ..
|
|
|
-// } = self;
|
|
|
-// let (element_tag, element_ns) =
|
|
|
-// element_to_static_str(&tag.to_string()).ok_or_else(|| {
|
|
|
-// Error::ParseError(ParseError::new(
|
|
|
-// syn::Error::new(tag.span(), format!("unknown element: {}", tag)),
|
|
|
-// location.clone(),
|
|
|
-// ))
|
|
|
-// })?;
|
|
|
-
|
|
|
-// let mut owned_attributes = Vec::new();
|
|
|
-// for a in attributes {
|
|
|
-// owned_attributes.push(a.try_into_owned(location, element_tag, element_ns)?);
|
|
|
-// }
|
|
|
-
|
|
|
-// Ok(TemplateElement::new(
|
|
|
-// element_tag,
|
|
|
-// element_ns,
|
|
|
-// owned_attributes,
|
|
|
-// children,
|
|
|
-// listeners,
|
|
|
-// ))
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// impl ToTokens for TemplateElementBuilder {
|
|
|
-// fn to_tokens(&self, tokens: &mut TokenStream) {
|
|
|
-// let Self {
|
|
|
-// tag,
|
|
|
-// attributes,
|
|
|
-// children,
|
|
|
-// listeners,
|
|
|
-// ..
|
|
|
-// } = self;
|
|
|
-// let children = children.iter().map(|id| {
|
|
|
-// let raw = id.0;
|
|
|
-// quote! {TemplateNodeId(#raw)}
|
|
|
-// });
|
|
|
-// tokens.append_all(quote! {
|
|
|
-// TemplateElement::new(
|
|
|
-// dioxus_elements::#tag::TAG_NAME,
|
|
|
-// dioxus_elements::#tag::NAME_SPACE,
|
|
|
-// &[#(#attributes),*],
|
|
|
-// &[#(#children),*],
|
|
|
-// &[#(#listeners),*],
|
|
|
-// )
|
|
|
-// })
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// enum AttributeName {
|
|
|
-// Ident(Ident),
|
|
|
-// Str(LitStr),
|
|
|
-// }
|
|
|
-
|
|
|
-// struct TemplateAttributeBuilder {
|
|
|
-// element_tag: Ident,
|
|
|
-// name: AttributeName,
|
|
|
-// value: TemplateAttributeValue<OwnedAttributeValue>,
|
|
|
-// }
|
|
|
-
|
|
|
-// impl TemplateAttributeBuilder {
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// fn try_into_owned(
|
|
|
-// self,
|
|
|
-// location: &OwnedCodeLocation,
|
|
|
-// element_tag: &'static str,
|
|
|
-// element_ns: Option<&'static str>,
|
|
|
-// ) -> Result<TemplateAttribute<OwnedAttributeValue>, Error> {
|
|
|
-// let Self { name, value, .. } = self;
|
|
|
-// let (name, span, literal) = match name {
|
|
|
-// AttributeName::Ident(name) => (name.to_string(), name.span(), false),
|
|
|
-// AttributeName::Str(name) => (name.value(), name.span(), true),
|
|
|
-// };
|
|
|
-// let (name, namespace, volatile) = attrbute_to_static_str(&name, element_tag, element_ns)
|
|
|
-// .ok_or_else(|| {
|
|
|
-// if literal {
|
|
|
-// // literals will be captured when a full recompile is triggered
|
|
|
-// Error::RecompileRequiredError(RecompileReason::Attribute(name.to_string()))
|
|
|
-// } else {
|
|
|
-// Error::ParseError(ParseError::new(
|
|
|
-// syn::Error::new(span, format!("unknown attribute: {}", name)),
|
|
|
-// location.clone(),
|
|
|
-// ))
|
|
|
-// }
|
|
|
-// })?;
|
|
|
-// let attribute = AttributeDiscription {
|
|
|
-// name,
|
|
|
-// namespace,
|
|
|
-// volatile,
|
|
|
-// };
|
|
|
-// Ok(TemplateAttribute { value, attribute })
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// impl ToTokens for TemplateAttributeBuilder {
|
|
|
-// fn to_tokens(&self, tokens: &mut TokenStream) {
|
|
|
-// let Self {
|
|
|
-// element_tag,
|
|
|
-// name,
|
|
|
-// value,
|
|
|
-// } = self;
|
|
|
-// let value = match value {
|
|
|
-// TemplateAttributeValue::Static(val) => {
|
|
|
-// let val = match val {
|
|
|
-// OwnedAttributeValue::Text(txt) => quote! {StaticAttributeValue::Text(#txt)},
|
|
|
-// OwnedAttributeValue::Float32(f) => quote! {StaticAttributeValue::Float32(#f)},
|
|
|
-// OwnedAttributeValue::Float64(f) => quote! {StaticAttributeValue::Float64(#f)},
|
|
|
-// OwnedAttributeValue::Int32(i) => quote! {StaticAttributeValue::Int32(#i)},
|
|
|
-// OwnedAttributeValue::Int64(i) => quote! {StaticAttributeValue::Int64(#i)},
|
|
|
-// OwnedAttributeValue::Uint32(u) => quote! {StaticAttributeValue::Uint32(#u)},
|
|
|
-// OwnedAttributeValue::Uint64(u) => quote! {StaticAttributeValue::Uint64(#u)},
|
|
|
-// OwnedAttributeValue::Bool(b) => quote! {StaticAttributeValue::Bool(#b)},
|
|
|
-// OwnedAttributeValue::Vec3Float(f1, f2, f3) => {
|
|
|
-// quote! {StaticAttributeValue::Vec3Float(#f1, #f2, #f3)}
|
|
|
-// }
|
|
|
-// OwnedAttributeValue::Vec3Int(f1, f2, f3) => {
|
|
|
-// quote! {StaticAttributeValue::Vec3Int(#f1, #f2, #f3)}
|
|
|
-// }
|
|
|
-// OwnedAttributeValue::Vec3Uint(f1, f2, f3) => {
|
|
|
-// quote! {StaticAttributeValue::Vec3Uint(#f1, #f2, #f3)}
|
|
|
-// }
|
|
|
-// OwnedAttributeValue::Vec4Float(f1, f2, f3, f4) => {
|
|
|
-// quote! {StaticAttributeValue::Vec4Float(#f1, #f2, #f3, #f4)}
|
|
|
-// }
|
|
|
-// OwnedAttributeValue::Vec4Int(f1, f2, f3, f4) => {
|
|
|
-// quote! {StaticAttributeValue::Vec4Int(#f1, #f2, #f3, #f4)}
|
|
|
-// }
|
|
|
-// OwnedAttributeValue::Vec4Uint(f1, f2, f3, f4) => {
|
|
|
-// quote! {StaticAttributeValue::Vec4Uint(#f1, #f2, #f3, #f4)}
|
|
|
-// }
|
|
|
-// OwnedAttributeValue::Bytes(b) => {
|
|
|
-// quote! {StaticAttributeValue::Bytes(&[#(#b),*])}
|
|
|
-// }
|
|
|
-// OwnedAttributeValue::Any(_) => todo!(),
|
|
|
-// };
|
|
|
-// quote! {TemplateAttributeValue::Static(#val)}
|
|
|
-// }
|
|
|
-// TemplateAttributeValue::Dynamic(idx) => quote! {TemplateAttributeValue::Dynamic(#idx)},
|
|
|
-// };
|
|
|
-// match name {
|
|
|
-// AttributeName::Ident(name) => tokens.append_all(quote! {
|
|
|
-// TemplateAttribute{
|
|
|
-// attribute: dioxus_elements::#element_tag::#name,
|
|
|
-// value: #value,
|
|
|
-// }
|
|
|
-// }),
|
|
|
-// AttributeName::Str(lit) => tokens.append_all(quote! {
|
|
|
-// TemplateAttribute{
|
|
|
-// attribute: dioxus::prelude::AttributeDiscription{
|
|
|
-// name: #lit,
|
|
|
-// namespace: None,
|
|
|
-// volatile: false
|
|
|
-// },
|
|
|
-// value: #value,
|
|
|
-// }
|
|
|
-// }),
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// enum TemplateNodeTypeBuilder {
|
|
|
-// Element(TemplateElementBuilder),
|
|
|
-// Text(TextTemplate<Vec<TextTemplateSegment<String>>, String>),
|
|
|
-// DynamicNode(usize),
|
|
|
-// }
|
|
|
-
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// type OwnedTemplateNodeType = TemplateNodeType<
|
|
|
-// Vec<TemplateAttribute<OwnedAttributeValue>>,
|
|
|
-// OwnedAttributeValue,
|
|
|
-// Vec<TemplateNodeId>,
|
|
|
-// Vec<usize>,
|
|
|
-// Vec<TextTemplateSegment<String>>,
|
|
|
-// String,
|
|
|
-// >;
|
|
|
-
|
|
|
-// impl TemplateNodeTypeBuilder {
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// fn try_into_owned(self, location: &OwnedCodeLocation) -> Result<OwnedTemplateNodeType, Error> {
|
|
|
-// match self {
|
|
|
-// TemplateNodeTypeBuilder::Element(el) => {
|
|
|
-// Ok(TemplateNodeType::Element(el.try_into_owned(location)?))
|
|
|
-// }
|
|
|
-// TemplateNodeTypeBuilder::Text(txt) => Ok(TemplateNodeType::Text(txt)),
|
|
|
-// TemplateNodeTypeBuilder::DynamicNode(idx) => Ok(TemplateNodeType::DynamicNode(idx)),
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// impl ToTokens for TemplateNodeTypeBuilder {
|
|
|
-// fn to_tokens(&self, tokens: &mut TokenStream) {
|
|
|
-// match self {
|
|
|
-// TemplateNodeTypeBuilder::Element(el) => tokens.append_all(quote! {
|
|
|
-// TemplateNodeType::Element(#el)
|
|
|
-// }),
|
|
|
-// TemplateNodeTypeBuilder::Text(txt) => {
|
|
|
-// let mut length = 0;
|
|
|
-
|
|
|
-// let segments = txt.segments.iter().map(|seg| match seg {
|
|
|
-// TextTemplateSegment::Static(s) => {
|
|
|
-// length += s.len();
|
|
|
-// quote!(TextTemplateSegment::Static(#s))
|
|
|
-// }
|
|
|
-// TextTemplateSegment::Dynamic(idx) => quote!(TextTemplateSegment::Dynamic(#idx)),
|
|
|
-// });
|
|
|
-
|
|
|
-// tokens.append_all(quote! {
|
|
|
-// TemplateNodeType::Text(TextTemplate::new(&[#(#segments),*], #length))
|
|
|
-// });
|
|
|
-// }
|
|
|
-// TemplateNodeTypeBuilder::DynamicNode(idx) => tokens.append_all(quote! {
|
|
|
-// TemplateNodeType::DynamicNode(#idx)
|
|
|
-// }),
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// struct TemplateNodeBuilder {
|
|
|
-// id: TemplateNodeId,
|
|
|
-// depth: usize,
|
|
|
-// parent: Option<TemplateNodeId>,
|
|
|
-// node_type: TemplateNodeTypeBuilder,
|
|
|
-// fully_static: bool,
|
|
|
-// }
|
|
|
-
|
|
|
-// impl TemplateNodeBuilder {
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// fn try_into_owned(self, location: &OwnedCodeLocation) -> Result<OwnedTemplateNode, Error> {
|
|
|
-// let TemplateNodeBuilder {
|
|
|
-// id,
|
|
|
-// node_type,
|
|
|
-// parent,
|
|
|
-// depth,
|
|
|
-// ..
|
|
|
-// } = self;
|
|
|
-// let node_type = node_type.try_into_owned(location)?;
|
|
|
-// Ok(OwnedTemplateNode {
|
|
|
-// id,
|
|
|
-// node_type,
|
|
|
-// parent,
|
|
|
-// depth,
|
|
|
-// })
|
|
|
-// }
|
|
|
-
|
|
|
-// fn to_tokens(&self, tokens: &mut TokenStream) {
|
|
|
-// let Self {
|
|
|
-// id,
|
|
|
-// node_type,
|
|
|
-// parent,
|
|
|
-// depth,
|
|
|
-// ..
|
|
|
-// } = self;
|
|
|
-// let raw_id = id.0;
|
|
|
-// let parent = match parent {
|
|
|
-// Some(id) => {
|
|
|
-// let id = id.0;
|
|
|
-// quote! {Some(TemplateNodeId(#id))}
|
|
|
-// }
|
|
|
-// None => quote! {None},
|
|
|
-// };
|
|
|
-
|
|
|
-// tokens.append_all(quote! {
|
|
|
-// TemplateNode {
|
|
|
-// id: TemplateNodeId(#raw_id),
|
|
|
-// node_type: #node_type,
|
|
|
-// parent: #parent,
|
|
|
-// depth: #depth,
|
|
|
-// }
|
|
|
-// })
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// #[derive(Default)]
|
|
|
-// pub struct TemplateBuilder {
|
|
|
-// nodes: Vec<TemplateNodeBuilder>,
|
|
|
-// root_nodes: Vec<TemplateNodeId>,
|
|
|
-// dynamic_context: DynamicTemplateContextBuilder,
|
|
|
-// }
|
|
|
-
|
|
|
-// impl TemplateBuilder {
|
|
|
-// /// Create a template builder from nodes if it would improve performance to do so.
|
|
|
-// pub fn from_roots(roots: Vec<BodyNode>) -> Option<Self> {
|
|
|
-// let mut builder = Self::default();
|
|
|
-
|
|
|
-// for (i, root) in roots.into_iter().enumerate() {
|
|
|
-// let id = builder.build_node(root, None, vec![i], 0);
|
|
|
-// builder.root_nodes.push(id);
|
|
|
-// }
|
|
|
-
|
|
|
-// // only build a template if there is at least one static node
|
|
|
-// if builder
|
|
|
-// .nodes
|
|
|
-// .iter()
|
|
|
-// .all(|r| matches!(&r.node_type, TemplateNodeTypeBuilder::DynamicNode(_)))
|
|
|
-// {
|
|
|
-// None
|
|
|
-// } else {
|
|
|
-// Some(builder)
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// /// Create a template builder from nodes regardless of performance.
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// fn from_roots_always(roots: Vec<BodyNode>) -> Self {
|
|
|
-// let mut builder = Self::default();
|
|
|
-
|
|
|
-// for (i, root) in roots.into_iter().enumerate() {
|
|
|
-// let id = builder.build_node(root, None, vec![i], 0);
|
|
|
-// builder.root_nodes.push(id);
|
|
|
-// }
|
|
|
-
|
|
|
-// builder
|
|
|
-// }
|
|
|
-
|
|
|
-// fn build_node(
|
|
|
-// &mut self,
|
|
|
-// node: BodyNode,
|
|
|
-// parent: Option<TemplateNodeId>,
|
|
|
-// path: Vec<usize>,
|
|
|
-// depth: usize,
|
|
|
-// ) -> TemplateNodeId {
|
|
|
-// let id = TemplateNodeId(self.nodes.len());
|
|
|
-// match node {
|
|
|
-// BodyNode::Element(el) => {
|
|
|
-// let mut locally_static = true;
|
|
|
-// let mut attributes = Vec::new();
|
|
|
-// let mut listeners = Vec::new();
|
|
|
-// for attr in el.attributes {
|
|
|
-// match attr.attr {
|
|
|
-// ElementAttr::AttrText { name, value } => {
|
|
|
-// if let Some(static_value) = value.to_static() {
|
|
|
-// attributes.push(TemplateAttributeBuilder {
|
|
|
-// element_tag: el.name.clone(),
|
|
|
-// name: AttributeName::Ident(name),
|
|
|
-// value: TemplateAttributeValue::Static(
|
|
|
-// OwnedAttributeValue::Text(static_value),
|
|
|
-// ),
|
|
|
-// })
|
|
|
-// } else {
|
|
|
-// locally_static = false;
|
|
|
-// attributes.push(TemplateAttributeBuilder {
|
|
|
-// element_tag: el.name.clone(),
|
|
|
-// name: AttributeName::Ident(name),
|
|
|
-// value: TemplateAttributeValue::Dynamic(
|
|
|
-// self.dynamic_context.add_attr(quote!(#value)),
|
|
|
-// ),
|
|
|
-// })
|
|
|
-// }
|
|
|
-// }
|
|
|
-// ElementAttr::CustomAttrText { name, value } => {
|
|
|
-// if let Some(static_value) = value.to_static() {
|
|
|
-// attributes.push(TemplateAttributeBuilder {
|
|
|
-// element_tag: el.name.clone(),
|
|
|
-// name: AttributeName::Str(name),
|
|
|
-// value: TemplateAttributeValue::Static(
|
|
|
-// OwnedAttributeValue::Text(static_value),
|
|
|
-// ),
|
|
|
-// })
|
|
|
-// } else {
|
|
|
-// locally_static = false;
|
|
|
-// attributes.push(TemplateAttributeBuilder {
|
|
|
-// element_tag: el.name.clone(),
|
|
|
-// name: AttributeName::Str(name),
|
|
|
-// value: TemplateAttributeValue::Dynamic(
|
|
|
-// self.dynamic_context.add_attr(quote!(#value)),
|
|
|
-// ),
|
|
|
-// })
|
|
|
-// }
|
|
|
-// }
|
|
|
-// ElementAttr::AttrExpression { name, value } => {
|
|
|
-// locally_static = false;
|
|
|
-// attributes.push(TemplateAttributeBuilder {
|
|
|
-// element_tag: el.name.clone(),
|
|
|
-// name: AttributeName::Ident(name),
|
|
|
-// value: TemplateAttributeValue::Dynamic(
|
|
|
-// self.dynamic_context.add_attr(quote!(#value)),
|
|
|
-// ),
|
|
|
-// })
|
|
|
-// }
|
|
|
-// ElementAttr::CustomAttrExpression { name, value } => {
|
|
|
-// locally_static = false;
|
|
|
-// attributes.push(TemplateAttributeBuilder {
|
|
|
-// element_tag: el.name.clone(),
|
|
|
-// name: AttributeName::Str(name),
|
|
|
-// value: TemplateAttributeValue::Dynamic(
|
|
|
-// self.dynamic_context.add_attr(quote!(#value)),
|
|
|
-// ),
|
|
|
-// })
|
|
|
-// }
|
|
|
-// ElementAttr::EventTokens { name, tokens } => {
|
|
|
-// locally_static = false;
|
|
|
-// listeners.push(self.dynamic_context.add_listener(name, tokens))
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// if let Some(key) = el.key {
|
|
|
-// self.dynamic_context.add_key(quote!(
|
|
|
-// dioxus::core::exports::bumpalo::format!(in __bump, "{}", #key)
|
|
|
-// .into_bump_str()
|
|
|
-// ));
|
|
|
-// }
|
|
|
-// self.nodes.push(TemplateNodeBuilder {
|
|
|
-// id,
|
|
|
-// node_type: TemplateNodeTypeBuilder::Element(TemplateElementBuilder {
|
|
|
-// tag: el.name,
|
|
|
-// attributes,
|
|
|
-// children: Vec::new(),
|
|
|
-// listeners,
|
|
|
-// locally_static,
|
|
|
-// }),
|
|
|
-// parent,
|
|
|
-// depth,
|
|
|
-// fully_static: false,
|
|
|
-// });
|
|
|
-// let children: Vec<_> = el
|
|
|
-// .children
|
|
|
-// .into_iter()
|
|
|
-// .enumerate()
|
|
|
-// .map(|(i, child)| {
|
|
|
-// let mut new_path = path.clone();
|
|
|
-// new_path.push(i);
|
|
|
-// self.build_node(child, Some(id), new_path, depth + 1)
|
|
|
-// })
|
|
|
-// .collect();
|
|
|
-// let children_fully_static = children.iter().all(|c| self.nodes[c.0].fully_static);
|
|
|
-// let parent = &mut self.nodes[id.0];
|
|
|
-// parent.fully_static = locally_static && children_fully_static;
|
|
|
-// if let TemplateNodeTypeBuilder::Element(element) = &mut parent.node_type {
|
|
|
-// element.children = children;
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// BodyNode::Component(comp) => {
|
|
|
-// self.nodes.push(TemplateNodeBuilder {
|
|
|
-// id,
|
|
|
-// node_type: TemplateNodeTypeBuilder::DynamicNode(
|
|
|
-// self.dynamic_context.add_node(BodyNode::Component(comp)),
|
|
|
-// ),
|
|
|
-// parent,
|
|
|
-// depth,
|
|
|
-// fully_static: false,
|
|
|
-// });
|
|
|
-// }
|
|
|
-
|
|
|
-// BodyNode::Text(txt) => {
|
|
|
-// let mut segments = Vec::new();
|
|
|
-// let mut length = 0;
|
|
|
-// let mut fully_static = true;
|
|
|
-
|
|
|
-// for segment in txt.segments {
|
|
|
-// segments.push(match segment {
|
|
|
-// Segment::Literal(lit) => {
|
|
|
-// length += lit.len();
|
|
|
-// TextTemplateSegment::Static(lit)
|
|
|
-// }
|
|
|
-// Segment::Formatted(fmted) => {
|
|
|
-// fully_static = false;
|
|
|
-// TextTemplateSegment::Dynamic(self.dynamic_context.add_text(fmted))
|
|
|
-// }
|
|
|
-// })
|
|
|
-// }
|
|
|
-
|
|
|
-// self.nodes.push(TemplateNodeBuilder {
|
|
|
-// id,
|
|
|
-// node_type: TemplateNodeTypeBuilder::Text(TextTemplate::new(segments, length)),
|
|
|
-// parent,
|
|
|
-// depth,
|
|
|
-// fully_static,
|
|
|
-// });
|
|
|
-// }
|
|
|
-
|
|
|
-// BodyNode::RawExpr(expr) => {
|
|
|
-// self.nodes.push(TemplateNodeBuilder {
|
|
|
-// id,
|
|
|
-// node_type: TemplateNodeTypeBuilder::DynamicNode(
|
|
|
-// self.dynamic_context.add_node(BodyNode::RawExpr(expr)),
|
|
|
-// ),
|
|
|
-// parent,
|
|
|
-// depth,
|
|
|
-// fully_static: false,
|
|
|
-// });
|
|
|
-// }
|
|
|
-// }
|
|
|
-// id
|
|
|
-// }
|
|
|
-
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// pub fn try_switch_dynamic_context(
|
|
|
-// mut self,
|
|
|
-// dynamic_context: DynamicTemplateContextBuilder,
|
|
|
-// ) -> Option<Self> {
|
|
|
-// let attribute_mapping: HashMap<String, usize> = dynamic_context
|
|
|
-// .attributes
|
|
|
-// .iter()
|
|
|
-// .enumerate()
|
|
|
-// .map(|(i, ts)| (ts.to_string(), i))
|
|
|
-// .collect();
|
|
|
-// let text_mapping: HashMap<String, usize> = dynamic_context
|
|
|
-// .text
|
|
|
-// .iter()
|
|
|
-// .enumerate()
|
|
|
-// .map(|(i, ts)| (ts.to_token_stream().to_string(), i))
|
|
|
-// .collect();
|
|
|
-// let listener_mapping: HashMap<(String, Expr), usize> = dynamic_context
|
|
|
-// .listeners
|
|
|
-// .iter()
|
|
|
-// .enumerate()
|
|
|
-// .map(|(i, ts)| (ts.clone(), i))
|
|
|
-// .collect();
|
|
|
-// let node_mapping: HashMap<String, usize> = dynamic_context
|
|
|
-// .nodes
|
|
|
-// .iter()
|
|
|
-// .enumerate()
|
|
|
-// .map(|(i, ts)| (ts.to_token_stream().to_string(), i))
|
|
|
-// .collect();
|
|
|
-
|
|
|
-// for node in &mut self.nodes {
|
|
|
-// match &mut node.node_type {
|
|
|
-// TemplateNodeTypeBuilder::Element(element) => {
|
|
|
-// for listener in &mut element.listeners {
|
|
|
-// *listener =
|
|
|
-// *listener_mapping.get(&self.dynamic_context.listeners[*listener])?;
|
|
|
-// }
|
|
|
-// for attribute in &mut element.attributes {
|
|
|
-// if let TemplateAttributeValue::Dynamic(idx) = &mut attribute.value {
|
|
|
-// *idx = *attribute_mapping
|
|
|
-// .get(&self.dynamic_context.attributes[*idx].to_string())?;
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// TemplateNodeTypeBuilder::Text(txt) => {
|
|
|
-// for seg in &mut txt.segments {
|
|
|
-// if let TextTemplateSegment::Dynamic(idx) = seg {
|
|
|
-// *idx = *text_mapping.get(
|
|
|
-// &self.dynamic_context.text[*idx]
|
|
|
-// .to_token_stream()
|
|
|
-// .to_string(),
|
|
|
-// )?;
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// TemplateNodeTypeBuilder::DynamicNode(idx) => {
|
|
|
-// *idx = *node_mapping.get(
|
|
|
-// &self.dynamic_context.nodes[*idx]
|
|
|
-// .to_token_stream()
|
|
|
-// .to_string(),
|
|
|
-// )?;
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// self.dynamic_context = dynamic_context;
|
|
|
-
|
|
|
-// Some(self)
|
|
|
-// }
|
|
|
-
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// pub fn try_into_owned(self, location: &OwnedCodeLocation) -> Result<OwnedTemplate, Error> {
|
|
|
-// let mut nodes = Vec::new();
|
|
|
-// let dynamic_mapping = self.dynamic_mapping(&nodes);
|
|
|
-// let dynamic_path = self.dynamic_path();
|
|
|
-// for node in self.nodes {
|
|
|
-// nodes.push(node.try_into_owned(location)?);
|
|
|
-// }
|
|
|
-
|
|
|
-// Ok(OwnedTemplate {
|
|
|
-// nodes,
|
|
|
-// root_nodes: self.root_nodes,
|
|
|
-// dynamic_mapping,
|
|
|
-// dynamic_path,
|
|
|
-// })
|
|
|
-// }
|
|
|
-
|
|
|
-// #[cfg(any(feature = "hot-reload", debug_assertions))]
|
|
|
-// pub fn dynamic_mapping(
|
|
|
-// &self,
|
|
|
-// resolved_nodes: &Vec<OwnedTemplateNode>,
|
|
|
-// ) -> OwnedDynamicNodeMapping {
|
|
|
-// let dynamic_context = &self.dynamic_context;
|
|
|
-// let mut node_mapping = vec![None; dynamic_context.nodes.len()];
|
|
|
-// let nodes = &self.nodes;
|
|
|
-// for n in nodes {
|
|
|
-// if let TemplateNodeTypeBuilder::DynamicNode(idx) = &n.node_type {
|
|
|
-// node_mapping[*idx] = Some(n.id)
|
|
|
-// }
|
|
|
-// }
|
|
|
-// let mut text_mapping = vec![Vec::new(); dynamic_context.text.len()];
|
|
|
-// for n in nodes {
|
|
|
-// if let TemplateNodeTypeBuilder::Text(txt) = &n.node_type {
|
|
|
-// for seg in &txt.segments {
|
|
|
-// match seg {
|
|
|
-// TextTemplateSegment::Static(_) => (),
|
|
|
-// TextTemplateSegment::Dynamic(idx) => text_mapping[*idx].push(n.id),
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// let mut attribute_mapping = vec![Vec::new(); dynamic_context.attributes.len()];
|
|
|
-// for n in nodes {
|
|
|
-// if let TemplateNodeTypeBuilder::Element(el) = &n.node_type {
|
|
|
-// for (i, attr) in el.attributes.iter().enumerate() {
|
|
|
-// match attr.value {
|
|
|
-// TemplateAttributeValue::Static(_) => (),
|
|
|
-// TemplateAttributeValue::Dynamic(idx) => {
|
|
|
-// attribute_mapping[idx].push((n.id, i));
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// let mut listener_mapping = Vec::new();
|
|
|
-// for n in nodes {
|
|
|
-// if let TemplateNodeTypeBuilder::Element(el) = &n.node_type {
|
|
|
-// if !el.listeners.is_empty() {
|
|
|
-// listener_mapping.push(n.id);
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// let mut volatile_mapping = Vec::new();
|
|
|
-// for n in resolved_nodes {
|
|
|
-// if let TemplateNodeType::Element(el) = &n.node_type {
|
|
|
-// for (i, attr) in el.attributes.iter().enumerate() {
|
|
|
-// if attr.attribute.volatile {
|
|
|
-// volatile_mapping.push((n.id, i));
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// OwnedDynamicNodeMapping::new(
|
|
|
-// node_mapping,
|
|
|
-// text_mapping,
|
|
|
-// attribute_mapping,
|
|
|
-// volatile_mapping,
|
|
|
-// listener_mapping,
|
|
|
-// )
|
|
|
-// }
|
|
|
-
|
|
|
-// fn dynamic_path(&self) -> Option<OwnedPathSeg> {
|
|
|
-// let mut last_seg: Option<OwnedPathSeg> = None;
|
|
|
-// let mut nodes_to_insert_after = Vec::new();
|
|
|
-// // iterating from the last root to the first
|
|
|
-// for root in self.root_nodes.iter().rev() {
|
|
|
-// let root_node = &self.nodes[root.0];
|
|
|
-// if let TemplateNodeTypeBuilder::DynamicNode(_) = root_node.node_type {
|
|
|
-// match &mut last_seg {
|
|
|
-// // if there has been no static nodes, we can append the child to the parent node
|
|
|
-// None => nodes_to_insert_after.push(*root),
|
|
|
-// // otherwise we insert the child before the last static node
|
|
|
-// Some(seg) => {
|
|
|
-// seg.ops.push(UpdateOp::InsertBefore(*root));
|
|
|
-// }
|
|
|
-// }
|
|
|
-// } else if let Some(mut new) = self.construct_path_segment(*root) {
|
|
|
-// if let Some(last) = last_seg.take() {
|
|
|
-// match new.traverse {
|
|
|
-// OwnedTraverse::Halt => {
|
|
|
-// new.traverse = OwnedTraverse::NextSibling(Box::new(last));
|
|
|
-// }
|
|
|
-// OwnedTraverse::FirstChild(b) => {
|
|
|
-// new.traverse = OwnedTraverse::Both(Box::new((*b, last)));
|
|
|
-// }
|
|
|
-// _ => unreachable!(),
|
|
|
-// }
|
|
|
-// } else {
|
|
|
-// for node in nodes_to_insert_after.drain(..) {
|
|
|
-// new.ops.push(UpdateOp::InsertAfter(node));
|
|
|
-// }
|
|
|
-// }
|
|
|
-// last_seg = Some(new);
|
|
|
-// } else if let Some(last) = last_seg.take() {
|
|
|
-// last_seg = Some(OwnedPathSeg {
|
|
|
-// ops: Vec::new(),
|
|
|
-// traverse: OwnedTraverse::NextSibling(Box::new(last)),
|
|
|
-// });
|
|
|
-// }
|
|
|
-// }
|
|
|
-// last_seg
|
|
|
-// }
|
|
|
-
|
|
|
-// fn construct_path_segment(&self, node_id: TemplateNodeId) -> Option<OwnedPathSeg> {
|
|
|
-// let n = &self.nodes[node_id.0];
|
|
|
-// if n.fully_static {
|
|
|
-// return None;
|
|
|
-// }
|
|
|
-// match &n.node_type {
|
|
|
-// TemplateNodeTypeBuilder::Element(el) => {
|
|
|
-// let mut last_seg: Option<OwnedPathSeg> = None;
|
|
|
-// let mut children_to_append = Vec::new();
|
|
|
-// // iterating from the last child to the first
|
|
|
-// for child in el.children.iter().rev() {
|
|
|
-// let child_node = &self.nodes[child.0];
|
|
|
-// if let TemplateNodeTypeBuilder::DynamicNode(_) = child_node.node_type {
|
|
|
-// match &mut last_seg {
|
|
|
-// // if there has been no static nodes, we can append the child to the parent node
|
|
|
-// None => children_to_append.push(*child),
|
|
|
-// // otherwise we insert the child before the last static node
|
|
|
-// Some(seg) => {
|
|
|
-// seg.ops.push(UpdateOp::InsertBefore(*child));
|
|
|
-// }
|
|
|
-// }
|
|
|
-// } else if let Some(mut new) = self.construct_path_segment(*child) {
|
|
|
-// if let Some(last) = last_seg.take() {
|
|
|
-// match new.traverse {
|
|
|
-// OwnedTraverse::Halt => {
|
|
|
-// new.traverse = OwnedTraverse::NextSibling(Box::new(last));
|
|
|
-// }
|
|
|
-// OwnedTraverse::FirstChild(b) => {
|
|
|
-// new.traverse = OwnedTraverse::Both(Box::new((*b, last)));
|
|
|
-// }
|
|
|
-// _ => unreachable!(),
|
|
|
-// }
|
|
|
-// }
|
|
|
-// last_seg = Some(new);
|
|
|
-// } else if let Some(last) = last_seg.take() {
|
|
|
-// last_seg = Some(OwnedPathSeg {
|
|
|
-// ops: Vec::new(),
|
|
|
-// traverse: OwnedTraverse::NextSibling(Box::new(last)),
|
|
|
-// });
|
|
|
-// }
|
|
|
-// }
|
|
|
-// let mut ops = Vec::new();
|
|
|
-// if !el.locally_static || n.parent.is_none() {
|
|
|
-// ops.push(UpdateOp::StoreNode(node_id));
|
|
|
-// }
|
|
|
-// for child in children_to_append.into_iter().rev() {
|
|
|
-// ops.push(UpdateOp::AppendChild(child));
|
|
|
-// }
|
|
|
-// Some(OwnedPathSeg {
|
|
|
-// ops,
|
|
|
-// traverse: match last_seg {
|
|
|
-// Some(last) => OwnedTraverse::FirstChild(Box::new(last)),
|
|
|
-// None => OwnedTraverse::Halt,
|
|
|
-// },
|
|
|
-// })
|
|
|
-// }
|
|
|
-// TemplateNodeTypeBuilder::Text(_) => Some(OwnedPathSeg {
|
|
|
-// ops: vec![UpdateOp::StoreNode(n.id)],
|
|
|
-// traverse: dioxus_core::OwnedTraverse::Halt,
|
|
|
-// }),
|
|
|
-// TemplateNodeTypeBuilder::DynamicNode(_) => unreachable!(
|
|
|
-// "constructing path segment for dynamic nodes is handled in the parent node"
|
|
|
-// ),
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// impl ToTokens for TemplateBuilder {
|
|
|
-// fn to_tokens(&self, tokens: &mut TokenStream) {
|
|
|
-// let Self {
|
|
|
-// nodes,
|
|
|
-// root_nodes,
|
|
|
-// dynamic_context,
|
|
|
-// } = self;
|
|
|
-
|
|
|
-// let mut node_mapping = vec![None; dynamic_context.nodes.len()];
|
|
|
-// for n in nodes {
|
|
|
-// if let TemplateNodeTypeBuilder::DynamicNode(idx) = &n.node_type {
|
|
|
-// node_mapping[*idx] = Some(n.id);
|
|
|
-// }
|
|
|
-// }
|
|
|
-// let mut text_mapping = vec![Vec::new(); dynamic_context.text.len()];
|
|
|
-// for n in nodes {
|
|
|
-// if let TemplateNodeTypeBuilder::Text(txt) = &n.node_type {
|
|
|
-// for seg in &txt.segments {
|
|
|
-// match seg {
|
|
|
-// TextTemplateSegment::Static(_) => (),
|
|
|
-// TextTemplateSegment::Dynamic(idx) => text_mapping[*idx].push(n.id),
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// let mut attribute_mapping = vec![Vec::new(); dynamic_context.attributes.len()];
|
|
|
-// for n in nodes {
|
|
|
-// if let TemplateNodeTypeBuilder::Element(el) = &n.node_type {
|
|
|
-// for (i, attr) in el.attributes.iter().enumerate() {
|
|
|
-// match attr.value {
|
|
|
-// TemplateAttributeValue::Static(_) => (),
|
|
|
-// TemplateAttributeValue::Dynamic(idx) => {
|
|
|
-// attribute_mapping[idx].push((n.id, i));
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// let mut listener_mapping = Vec::new();
|
|
|
-// for n in nodes {
|
|
|
-// if let TemplateNodeTypeBuilder::Element(el) = &n.node_type {
|
|
|
-// if !el.listeners.is_empty() {
|
|
|
-// listener_mapping.push(n.id);
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// let root_nodes = root_nodes.iter().map(|id| {
|
|
|
-// let raw = id.0;
|
|
|
-// quote! { TemplateNodeId(#raw) }
|
|
|
-// });
|
|
|
-// let node_mapping_quoted = node_mapping.iter().map(|op| match op {
|
|
|
-// Some(id) => {
|
|
|
-// let raw_id = id.0;
|
|
|
-// quote! {Some(TemplateNodeId(#raw_id))}
|
|
|
-// }
|
|
|
-// None => quote! {None},
|
|
|
-// });
|
|
|
-// let text_mapping_quoted = text_mapping.iter().map(|inner| {
|
|
|
-// let raw = inner.iter().map(|id| id.0);
|
|
|
-// quote! {&[#(TemplateNodeId(#raw)),*]}
|
|
|
-// });
|
|
|
-// let attribute_mapping_quoted = attribute_mapping.iter().map(|inner| {
|
|
|
-// let raw = inner.iter().map(|(id, _)| id.0);
|
|
|
-// let indecies = inner.iter().map(|(_, idx)| idx);
|
|
|
-// quote! {&[#((TemplateNodeId(#raw), #indecies)),*]}
|
|
|
-// });
|
|
|
-// let listener_mapping_quoted = listener_mapping.iter().map(|id| {
|
|
|
-// let raw = id.0;
|
|
|
-// quote! {TemplateNodeId(#raw)}
|
|
|
-// });
|
|
|
-// let mut nodes_quoted = TokenStream::new();
|
|
|
-// for n in nodes {
|
|
|
-// n.to_tokens(&mut nodes_quoted);
|
|
|
-// quote! {,}.to_tokens(&mut nodes_quoted);
|
|
|
-// }
|
|
|
-
|
|
|
-// let dynamic_path = match self.dynamic_path() {
|
|
|
-// Some(seg) => {
|
|
|
-// let seg = quote_owned_segment(seg);
|
|
|
-// quote! {Some(#seg)}
|
|
|
-// }
|
|
|
-// None => quote! {None},
|
|
|
-// };
|
|
|
-
|
|
|
-// let quoted = quote! {
|
|
|
-// {
|
|
|
-// const __NODES: dioxus::prelude::StaticTemplateNodes = &[#nodes_quoted];
|
|
|
-// const __TEXT_MAPPING: &'static [&'static [dioxus::prelude::TemplateNodeId]] = &[#(#text_mapping_quoted),*];
|
|
|
-// const __ATTRIBUTE_MAPPING: &'static [&'static [(dioxus::prelude::TemplateNodeId, usize)]] = &[#(#attribute_mapping_quoted),*];
|
|
|
-// const __ROOT_NODES: &'static [dioxus::prelude::TemplateNodeId] = &[#(#root_nodes),*];
|
|
|
-// const __NODE_MAPPING: &'static [Option<dioxus::prelude::TemplateNodeId>] = &[#(#node_mapping_quoted),*];
|
|
|
-// const __NODES_WITH_LISTENERS: &'static [dioxus::prelude::TemplateNodeId] = &[#(#listener_mapping_quoted),*];
|
|
|
-// static __VOLITALE_MAPPING_INNER: dioxus::core::exports::once_cell::sync::Lazy<Vec<(dioxus::prelude::TemplateNodeId, usize)>> = dioxus::core::exports::once_cell::sync::Lazy::new(||{
|
|
|
-// // check each property to see if it is volatile
|
|
|
-// let mut volatile = Vec::new();
|
|
|
-// for n in __NODES {
|
|
|
-// if let TemplateNodeType::Element(el) = &n.node_type {
|
|
|
-// for (i, attr) in el.attributes.iter().enumerate() {
|
|
|
-// if attr.attribute.volatile {
|
|
|
-// volatile.push((n.id, i));
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-// volatile
|
|
|
-// });
|
|
|
-// static __VOLITALE_MAPPING: &'static dioxus::core::exports::once_cell::sync::Lazy<Vec<(dioxus::prelude::TemplateNodeId, usize)>> = &__VOLITALE_MAPPING_INNER;
|
|
|
-// static __STATIC_VOLITALE_MAPPING: dioxus::prelude::LazyStaticVec<(dioxus::prelude::TemplateNodeId, usize)> = LazyStaticVec(__VOLITALE_MAPPING);
|
|
|
-// static __TEMPLATE: dioxus::prelude::Template = Template::Static(&StaticTemplate {
|
|
|
-// nodes: __NODES,
|
|
|
-// root_nodes: __ROOT_NODES,
|
|
|
-// dynamic_mapping: StaticDynamicNodeMapping::new(__NODE_MAPPING, __TEXT_MAPPING, __ATTRIBUTE_MAPPING, __STATIC_VOLITALE_MAPPING, __NODES_WITH_LISTENERS),
|
|
|
-// dynamic_path: #dynamic_path,
|
|
|
-// });
|
|
|
-
|
|
|
-// let __bump = __cx.bump();
|
|
|
-// __cx.template_ref(dioxus::prelude::TemplateId(get_line_num!()), __TEMPLATE.clone(), #dynamic_context)
|
|
|
-// }
|
|
|
-// };
|
|
|
-
|
|
|
-// tokens.append_all(quoted)
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// #[derive(Default, Clone, Debug)]
|
|
|
-// pub struct DynamicTemplateContextBuilder {
|
|
|
-// nodes: Vec<BodyNode>,
|
|
|
-// text: Vec<FormattedSegment>,
|
|
|
-// attributes: Vec<TokenStream>,
|
|
|
-// listeners: Vec<(String, Expr)>,
|
|
|
-// key: Option<TokenStream>,
|
|
|
-// }
|
|
|
-
|
|
|
-// impl DynamicTemplateContextBuilder {
|
|
|
-// fn add_node(&mut self, node: BodyNode) -> usize {
|
|
|
-// let node_id = self.nodes.len();
|
|
|
-
|
|
|
-// self.nodes.push(node);
|
|
|
-
|
|
|
-// node_id
|
|
|
-// }
|
|
|
-
|
|
|
-// fn add_text(&mut self, text: FormattedSegment) -> usize {
|
|
|
-// let text_id = self.text.len();
|
|
|
-
|
|
|
-// self.text.push(text);
|
|
|
-
|
|
|
-// text_id
|
|
|
-// }
|
|
|
-
|
|
|
-// fn add_attr(&mut self, attr: TokenStream) -> usize {
|
|
|
-// let attr_id = self.attributes.len();
|
|
|
-
|
|
|
-// self.attributes.push(attr);
|
|
|
-
|
|
|
-// attr_id
|
|
|
-// }
|
|
|
-
|
|
|
-// fn add_listener(&mut self, name: Ident, listener: Expr) -> usize {
|
|
|
-// let listener_id = self.listeners.len();
|
|
|
-
|
|
|
-// self.listeners.push((name.to_string(), listener));
|
|
|
-
|
|
|
-// listener_id
|
|
|
-// }
|
|
|
-
|
|
|
-// fn add_key(&mut self, key: TokenStream) {
|
|
|
-// self.key = Some(key);
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// impl ToTokens for DynamicTemplateContextBuilder {
|
|
|
-// fn to_tokens(&self, tokens: &mut TokenStream) {
|
|
|
-// let nodes = &self.nodes;
|
|
|
-// let text = &self.text;
|
|
|
-// let attributes = &self.attributes;
|
|
|
-// let listeners_names = self
|
|
|
-// .listeners
|
|
|
-// .iter()
|
|
|
-// .map(|(n, _)| syn::parse_str::<Ident>(n).expect(n));
|
|
|
-// let listeners_exprs = self.listeners.iter().map(|(_, e)| e);
|
|
|
-// let key = match &self.key {
|
|
|
-// Some(k) => quote!(Some(#k)),
|
|
|
-// None => quote!(None),
|
|
|
-// };
|
|
|
-// tokens.append_all(quote! {
|
|
|
-// TemplateContext {
|
|
|
-// nodes: __cx.bump().alloc([#(#nodes),*]),
|
|
|
-// text_segments: __cx.bump().alloc([#(&*dioxus::core::exports::bumpalo::format!(in __bump, "{}", #text).into_bump_str()),*]),
|
|
|
-// attributes: __cx.bump().alloc([#({#attributes}.into_value(__cx.bump())),*]),
|
|
|
-// listeners: __cx.bump().alloc([#(dioxus_elements::on::#listeners_names(__cx, #listeners_exprs)),*]),
|
|
|
-// key: #key,
|
|
|
-// }
|
|
|
-// })
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// fn quote_owned_segment(seg: OwnedPathSeg) -> proc_macro2::TokenStream {
|
|
|
-// let OwnedPathSeg { ops, traverse } = seg;
|
|
|
-
|
|
|
-// let ops = ops
|
|
|
-// .into_iter()
|
|
|
-// .map(|op| match op {
|
|
|
-// UpdateOp::StoreNode(id) => {
|
|
|
-// let id = quote_template_node_id(id);
|
|
|
-// quote!(UpdateOp::StoreNode(#id))
|
|
|
-// }
|
|
|
-// UpdateOp::InsertBefore(id) => {
|
|
|
-// let id = quote_template_node_id(id);
|
|
|
-// quote!(UpdateOp::InsertBefore(#id))
|
|
|
-// }
|
|
|
-// UpdateOp::InsertAfter(id) => {
|
|
|
-// let id = quote_template_node_id(id);
|
|
|
-// quote!(UpdateOp::InsertAfter(#id))
|
|
|
-// }
|
|
|
-// UpdateOp::AppendChild(id) => {
|
|
|
-// let id = quote_template_node_id(id);
|
|
|
-// quote!(UpdateOp::AppendChild(#id))
|
|
|
-// }
|
|
|
-// })
|
|
|
-// .collect::<Vec<_>>();
|
|
|
-
|
|
|
-// let traverse = quote_owned_traverse(traverse);
|
|
|
-
|
|
|
-// quote! {
|
|
|
-// StaticPathSeg {
|
|
|
-// ops: &[#(#ops),*],
|
|
|
-// traverse: #traverse,
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// fn quote_owned_traverse(traverse: OwnedTraverse) -> proc_macro2::TokenStream {
|
|
|
-// match traverse {
|
|
|
-// OwnedTraverse::Halt => {
|
|
|
-// quote! {StaticTraverse::Halt}
|
|
|
-// }
|
|
|
-// OwnedTraverse::FirstChild(seg) => {
|
|
|
-// let seg = quote_owned_segment(*seg);
|
|
|
-// quote! {StaticTraverse::FirstChild(&#seg)}
|
|
|
-// }
|
|
|
-// OwnedTraverse::NextSibling(seg) => {
|
|
|
-// let seg = quote_owned_segment(*seg);
|
|
|
-// quote! {StaticTraverse::NextSibling(&#seg)}
|
|
|
-// }
|
|
|
-// OwnedTraverse::Both(b) => {
|
|
|
-// let (child, sibling) = *b;
|
|
|
-// let child = quote_owned_segment(child);
|
|
|
-// let sibling = quote_owned_segment(sibling);
|
|
|
-// quote! {StaticTraverse::Both(&(#child, #sibling))}
|
|
|
-// }
|
|
|
-// }
|
|
|
-// }
|
|
|
-
|
|
|
-// fn quote_template_node_id(id: TemplateNodeId) -> proc_macro2::TokenStream {
|
|
|
-// let raw = id.0;
|
|
|
-// quote! {
|
|
|
-// TemplateNodeId(#raw)
|
|
|
-// }
|
|
|
-// }
|
Evan Almloff