128 lines
4.4 KiB
Rust
128 lines
4.4 KiB
Rust
use crate::innerlude::{VNode, VirtualDom};
|
|
|
|
/// An iterator that only yields "real" [`Element`]s. IE only Elements that are
|
|
/// not [`VNode::Component`] or [`VNode::Fragment`], .
|
|
pub struct ElementIdIterator<'a> {
|
|
vdom: &'a VirtualDom,
|
|
|
|
// Heuristically we should never bleed into 5 completely nested fragments/components
|
|
// Smallvec lets us stack allocate our little stack machine so the vast majority of cases are sane
|
|
stack: smallvec::SmallVec<[(u16, &'a VNode<'a>); 5]>,
|
|
}
|
|
|
|
impl<'a> ElementIdIterator<'a> {
|
|
/// Create a new iterator from the given [`VirtualDom`] and [`VNode`]
|
|
///
|
|
/// This will allow you to iterate through all the real childrne of the [`VNode`].
|
|
pub fn new(vdom: &'a VirtualDom, node: &'a VNode<'a>) -> Self {
|
|
Self {
|
|
vdom,
|
|
stack: smallvec::smallvec![(0, node)],
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Iterator for ElementIdIterator<'a> {
|
|
type Item = &'a VNode<'a>;
|
|
|
|
fn next(&mut self) -> Option<&'a VNode<'a>> {
|
|
let mut should_pop = false;
|
|
let mut returned_node = None;
|
|
let mut should_push = None;
|
|
|
|
while returned_node.is_none() {
|
|
if let Some((count, node)) = self.stack.last_mut() {
|
|
match node {
|
|
// We can only exit our looping when we get "real" nodes
|
|
VNode::Element(_)
|
|
| VNode::Text(_)
|
|
| VNode::Placeholder(_)
|
|
| VNode::TemplateRef(_) => {
|
|
// We've recursed INTO an element/text
|
|
// We need to recurse *out* of it and move forward to the next
|
|
// println!("Found element! Returning it!");
|
|
should_pop = true;
|
|
returned_node = Some(&**node);
|
|
}
|
|
|
|
// If we get a fragment we push the next child
|
|
VNode::Fragment(frag) => {
|
|
let count = *count as usize;
|
|
if count >= frag.children.len() {
|
|
should_pop = true;
|
|
} else {
|
|
should_push = Some(&frag.children[count]);
|
|
}
|
|
}
|
|
|
|
// For components, we load their root and push them onto the stack
|
|
VNode::Component(sc) => {
|
|
let scope = self.vdom.get_scope(sc.scope.get().unwrap()).unwrap();
|
|
// Simply swap the current node on the stack with the root of the component
|
|
*node = scope.root_node();
|
|
}
|
|
}
|
|
} else {
|
|
// If there's no more items on the stack, we're done!
|
|
return None;
|
|
}
|
|
|
|
if should_pop {
|
|
self.stack.pop();
|
|
if let Some((id, _)) = self.stack.last_mut() {
|
|
*id += 1;
|
|
}
|
|
should_pop = false;
|
|
}
|
|
|
|
if let Some(push) = should_push {
|
|
self.stack.push((0, push));
|
|
should_push = None;
|
|
}
|
|
}
|
|
|
|
returned_node
|
|
}
|
|
}
|
|
|
|
/// This intentionally leaks once per element name to allow more flexability when hot reloding templetes
|
|
#[cfg(all(any(feature = "hot-reload", debug_assertions), feature = "serde"))]
|
|
mod leaky {
|
|
use std::sync::Mutex;
|
|
|
|
use once_cell::sync::Lazy;
|
|
use rustc_hash::FxHashSet;
|
|
static STATIC_CACHE: Lazy<Mutex<FxHashSet<&'static str>>> =
|
|
Lazy::new(|| Mutex::new(FxHashSet::default()));
|
|
|
|
pub fn deserialize_static_leaky<'de, D>(d: D) -> Result<&'static str, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
use serde::Deserialize;
|
|
let s = <&str>::deserialize(d)?;
|
|
Ok(if let Some(stat) = STATIC_CACHE.lock().unwrap().get(s) {
|
|
*stat
|
|
} else {
|
|
Box::leak(s.into())
|
|
})
|
|
}
|
|
|
|
pub fn deserialize_static_leaky_ns<'de, D>(d: D) -> Result<Option<&'static str>, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
use serde::Deserialize;
|
|
Ok(<Option<&str>>::deserialize(d)?.map(|s| {
|
|
if let Some(stat) = STATIC_CACHE.lock().unwrap().get(s) {
|
|
*stat
|
|
} else {
|
|
Box::leak(s.into())
|
|
}
|
|
}))
|
|
}
|
|
}
|
|
|
|
#[cfg(all(any(feature = "hot-reload", debug_assertions), feature = "serde"))]
|
|
pub use leaky::*;
|