620 lines
20 KiB
Rust
620 lines
20 KiB
Rust
use crate::innerlude::{ElementPath, ElementRef, VComponent, VPlaceholder, VText, WriteMutations};
|
|
use crate::nodes::VNode;
|
|
use crate::nodes::{DynamicNode, TemplateNode};
|
|
use crate::virtual_dom::VirtualDom;
|
|
use crate::{AttributeValue, ElementId, RenderReturn, ScopeId, Template};
|
|
use std::cell::Cell;
|
|
use std::iter::Peekable;
|
|
use TemplateNode::*;
|
|
|
|
#[cfg(debug_assertions)]
|
|
fn sort_bfs(paths: &[&'static [u8]]) -> Vec<(usize, &'static [u8])> {
|
|
let mut with_indecies = paths.iter().copied().enumerate().collect::<Vec<_>>();
|
|
with_indecies.sort_unstable_by(|(_, a), (_, b)| {
|
|
let mut a = a.iter();
|
|
let mut b = b.iter();
|
|
loop {
|
|
match (a.next(), b.next()) {
|
|
(Some(a), Some(b)) => {
|
|
if a != b {
|
|
return a.cmp(b);
|
|
}
|
|
}
|
|
// The shorter path goes first
|
|
(None, Some(_)) => return std::cmp::Ordering::Less,
|
|
(Some(_), None) => return std::cmp::Ordering::Greater,
|
|
(None, None) => return std::cmp::Ordering::Equal,
|
|
}
|
|
}
|
|
});
|
|
with_indecies
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(debug_assertions)]
|
|
fn sorting() {
|
|
let r: [(usize, &[u8]); 5] = [
|
|
(0, &[0, 1]),
|
|
(1, &[0, 2]),
|
|
(2, &[1, 0]),
|
|
(3, &[1, 0, 1]),
|
|
(4, &[1, 2]),
|
|
];
|
|
assert_eq!(
|
|
sort_bfs(&[&[0, 1,], &[0, 2,], &[1, 0,], &[1, 0, 1,], &[1, 2,],]),
|
|
r
|
|
);
|
|
let r: [(usize, &[u8]); 6] = [
|
|
(0, &[0]),
|
|
(1, &[0, 1]),
|
|
(2, &[0, 1, 2]),
|
|
(3, &[1]),
|
|
(4, &[1, 2]),
|
|
(5, &[2]),
|
|
];
|
|
assert_eq!(
|
|
sort_bfs(&[&[0], &[0, 1], &[0, 1, 2], &[1], &[1, 2], &[2],]),
|
|
r
|
|
);
|
|
}
|
|
|
|
impl VirtualDom {
|
|
/// Create a new template [`VNode`] and write it to the [`Mutations`] buffer.
|
|
///
|
|
/// This method pushes the ScopeID to the internal scopestack and returns the number of nodes created.
|
|
pub(crate) fn create_scope(
|
|
&mut self,
|
|
scope: ScopeId,
|
|
template: &VNode,
|
|
to: &mut impl WriteMutations,
|
|
) -> usize {
|
|
self.runtime.scope_stack.borrow_mut().push(scope);
|
|
let nodes = self.create(template, to);
|
|
self.runtime.scope_stack.borrow_mut().pop();
|
|
nodes
|
|
}
|
|
|
|
/// Create this template and write its mutations
|
|
pub(crate) fn create(&mut self, node: &VNode, to: &mut impl WriteMutations) -> usize {
|
|
// check for a overriden template
|
|
#[cfg(debug_assertions)]
|
|
{
|
|
let (path, byte_index) = node.template.get().name.rsplit_once(':').unwrap();
|
|
if let Some(template) = self
|
|
.templates
|
|
.get(path)
|
|
.and_then(|map| map.get(&byte_index.parse().unwrap()))
|
|
{
|
|
node.template.set(*template);
|
|
}
|
|
}
|
|
|
|
// Initialize the root nodes slice
|
|
{
|
|
let mut nodes_mut = node.root_ids.borrow_mut();
|
|
let len = node.template.get().roots.len();
|
|
nodes_mut.resize(len, ElementId::default());
|
|
};
|
|
|
|
// The best renderers will have templates prehydrated and registered
|
|
// Just in case, let's create the template using instructions anyways
|
|
self.register_template(node.template.get(), to);
|
|
|
|
// Walk the roots, creating nodes and assigning IDs
|
|
// nodes in an iterator of ((dynamic_node_index, sorted_index), path)
|
|
// todo: adjust dynamic nodes to be in the order of roots and then leaves (ie BFS)
|
|
#[cfg(not(debug_assertions))]
|
|
let (mut attrs, mut nodes) = (
|
|
node.template
|
|
.get()
|
|
.attr_paths
|
|
.iter()
|
|
.copied()
|
|
.enumerate()
|
|
.peekable(),
|
|
node.template
|
|
.get()
|
|
.node_paths
|
|
.iter()
|
|
.copied()
|
|
.enumerate()
|
|
.map(|(i, path)| ((i, i), path))
|
|
.peekable(),
|
|
);
|
|
// If this is a debug build, we need to check that the paths are in the correct order because hot reloading can cause scrambled states
|
|
|
|
#[cfg(debug_assertions)]
|
|
let (attrs_sorted, nodes_sorted) = {
|
|
(
|
|
sort_bfs(node.template.get().attr_paths),
|
|
sort_bfs(node.template.get().node_paths),
|
|
)
|
|
};
|
|
#[cfg(debug_assertions)]
|
|
let (mut attrs, mut nodes) = {
|
|
(
|
|
attrs_sorted.into_iter().peekable(),
|
|
nodes_sorted
|
|
.iter()
|
|
.copied()
|
|
.enumerate()
|
|
.map(|(i, (id, path))| ((id, i), path))
|
|
.peekable(),
|
|
)
|
|
};
|
|
|
|
node.template
|
|
.get()
|
|
.roots
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(idx, root)| match root {
|
|
DynamicText { id } | Dynamic { id } => {
|
|
nodes.next().unwrap();
|
|
self.write_dynamic_root(node, *id, to)
|
|
}
|
|
Element { .. } => {
|
|
#[cfg(not(debug_assertions))]
|
|
let id = self.write_element_root(node, idx, &mut attrs, &mut nodes, &[]);
|
|
#[cfg(debug_assertions)]
|
|
let id = self.write_element_root(
|
|
node,
|
|
idx,
|
|
&mut attrs,
|
|
&mut nodes,
|
|
&nodes_sorted,
|
|
to,
|
|
);
|
|
id
|
|
}
|
|
Text { .. } => self.write_static_text_root(node, idx, to),
|
|
})
|
|
.sum()
|
|
}
|
|
|
|
fn write_static_text_root(
|
|
&mut self,
|
|
node: &VNode,
|
|
idx: usize,
|
|
to: &mut impl WriteMutations,
|
|
) -> usize {
|
|
// Simply just load the template root, no modifications needed
|
|
self.load_template_root(node, idx, to);
|
|
|
|
// Text producs just one node on the stack
|
|
1
|
|
}
|
|
|
|
fn write_dynamic_root(
|
|
&mut self,
|
|
template: &VNode,
|
|
idx: usize,
|
|
to: &mut impl WriteMutations,
|
|
) -> usize {
|
|
use DynamicNode::*;
|
|
match &template.dynamic_nodes[idx] {
|
|
node @ Component { .. } | node @ Fragment(_) => {
|
|
let template_ref = ElementRef {
|
|
path: ElementPath {
|
|
path: template.template.get().node_paths[idx],
|
|
},
|
|
element: template.clone(),
|
|
scope: self.runtime.current_scope_id().unwrap_or(ScopeId(0)),
|
|
};
|
|
self.create_dynamic_node(&template_ref, node, to)
|
|
}
|
|
Placeholder(VPlaceholder { id, parent }) => {
|
|
let template_ref = ElementRef {
|
|
path: ElementPath {
|
|
path: template.template.get().node_paths[idx],
|
|
},
|
|
element: template.clone(),
|
|
scope: self.runtime.current_scope_id().unwrap_or(ScopeId(0)),
|
|
};
|
|
*parent.borrow_mut() = Some(template_ref);
|
|
let id = self.set_slot(id);
|
|
to.create_placeholder(id);
|
|
1
|
|
}
|
|
Text(VText { id, value }) => {
|
|
let id = self.set_slot(id);
|
|
to.create_text_node(value, id);
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
/// We write all the descendent data for this element
|
|
///
|
|
/// Elements can contain other nodes - and those nodes can be dynamic or static
|
|
///
|
|
/// We want to make sure we write these nodes while on top of the root
|
|
fn write_element_root(
|
|
&mut self,
|
|
template: &VNode,
|
|
root_idx: usize,
|
|
dynamic_attrs: &mut Peekable<impl Iterator<Item = (usize, &'static [u8])>>,
|
|
dynamic_nodes_iter: &mut Peekable<impl Iterator<Item = ((usize, usize), &'static [u8])>>,
|
|
dynamic_nodes: &[(usize, &'static [u8])],
|
|
to: &mut impl WriteMutations,
|
|
) -> usize {
|
|
// Load the template root and get the ID for the node on the stack
|
|
let root_on_stack = self.load_template_root(template, root_idx, to);
|
|
|
|
// Write all the attributes below this root
|
|
self.write_attrs_on_root(dynamic_attrs, root_idx as u8, root_on_stack, template, to);
|
|
|
|
// Load in all of the placeholder or dynamic content under this root too
|
|
self.load_placeholders(
|
|
dynamic_nodes_iter,
|
|
dynamic_nodes,
|
|
root_idx as u8,
|
|
template,
|
|
to,
|
|
);
|
|
|
|
1
|
|
}
|
|
|
|
/// Load all of the placeholder nodes for descendents of this root node
|
|
///
|
|
/// ```rust, ignore
|
|
/// rsx! {
|
|
/// div {
|
|
/// // This is a placeholder
|
|
/// some_value,
|
|
///
|
|
/// // Load this too
|
|
/// "{some_text}"
|
|
/// }
|
|
/// }
|
|
/// ```
|
|
#[allow(unused)]
|
|
fn load_placeholders(
|
|
&mut self,
|
|
dynamic_nodes_iter: &mut Peekable<impl Iterator<Item = ((usize, usize), &'static [u8])>>,
|
|
dynamic_nodes: &[(usize, &'static [u8])],
|
|
root_idx: u8,
|
|
template: &VNode,
|
|
to: &mut impl WriteMutations,
|
|
) {
|
|
let (start, end) = match collect_dyn_node_range(dynamic_nodes_iter, root_idx) {
|
|
Some((a, b)) => (a, b),
|
|
None => return,
|
|
};
|
|
|
|
// If hot reloading is enabled, we need to map the sorted index to the original index of the dynamic node. If it is disabled, we can just use the sorted index
|
|
#[cfg(not(debug_assertions))]
|
|
let reversed_iter = (start..=end).rev();
|
|
#[cfg(debug_assertions)]
|
|
let reversed_iter = (start..=end)
|
|
.rev()
|
|
.map(|sorted_index| dynamic_nodes[sorted_index].0);
|
|
|
|
for idx in reversed_iter {
|
|
let boundary_ref = ElementRef {
|
|
path: ElementPath {
|
|
path: template.template.get().node_paths[idx],
|
|
},
|
|
element: template.clone(),
|
|
scope: self.runtime.current_scope_id().unwrap_or(ScopeId(0)),
|
|
};
|
|
let m = self.create_dynamic_node(&boundary_ref, &template.dynamic_nodes[idx], to);
|
|
if m > 0 {
|
|
// The path is one shorter because the top node is the root
|
|
let path = &template.template.get().node_paths[idx][1..];
|
|
to.replace_placeholder_with_nodes(path, m);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn write_attrs_on_root(
|
|
&mut self,
|
|
attrs: &mut Peekable<impl Iterator<Item = (usize, &'static [u8])>>,
|
|
root_idx: u8,
|
|
root: ElementId,
|
|
node: &VNode,
|
|
to: &mut impl WriteMutations,
|
|
) {
|
|
while let Some((mut attr_id, path)) =
|
|
attrs.next_if(|(_, p)| p.first().copied() == Some(root_idx))
|
|
{
|
|
let id = self.assign_static_node_as_dynamic(path, root, to);
|
|
|
|
loop {
|
|
self.write_attribute(node, attr_id, &node.dynamic_attrs[attr_id], id, to);
|
|
|
|
// Only push the dynamic attributes forward if they match the current path (same element)
|
|
match attrs.next_if(|(_, p)| *p == path) {
|
|
Some((next_attr_id, _)) => attr_id = next_attr_id,
|
|
None => break,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn write_attribute(
|
|
&mut self,
|
|
template: &VNode,
|
|
idx: usize,
|
|
attribute: &crate::Attribute,
|
|
id: ElementId,
|
|
to: &mut impl WriteMutations,
|
|
) {
|
|
// Make sure we set the attribute's associated id
|
|
attribute.mounted_element.set(id);
|
|
|
|
// Safety: we promise not to re-alias this text later on after committing it to the mutation
|
|
let unbounded_name: &str = attribute.name;
|
|
|
|
match &attribute.value {
|
|
AttributeValue::Listener(_) => {
|
|
let path = &template.template.get().attr_paths[idx];
|
|
let element_ref = ElementRef {
|
|
path: ElementPath { path },
|
|
element: template.clone(),
|
|
scope: self.runtime.current_scope_id().unwrap_or(ScopeId(0)),
|
|
};
|
|
self.elements[id.0] = Some(element_ref);
|
|
to.create_event_listener(&unbounded_name[2..], id);
|
|
}
|
|
_ => {
|
|
let unbounded_value = &attribute.value;
|
|
|
|
to.set_attribute(unbounded_name, attribute.namespace, unbounded_value, id);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn load_template_root(
|
|
&mut self,
|
|
template: &VNode,
|
|
root_idx: usize,
|
|
to: &mut impl WriteMutations,
|
|
) -> ElementId {
|
|
// Get an ID for this root since it's a real root
|
|
let this_id = self.next_element();
|
|
template.root_ids.borrow_mut()[root_idx] = this_id;
|
|
|
|
to.load_template(template.template.get().name, root_idx, this_id);
|
|
|
|
this_id
|
|
}
|
|
|
|
/// We have some dynamic attributes attached to a some node
|
|
///
|
|
/// That node needs to be loaded at runtime, so we need to give it an ID
|
|
///
|
|
/// If the node in question is on the stack, we just return that ID
|
|
///
|
|
/// If the node is not on the stack, we create a new ID for it and assign it
|
|
fn assign_static_node_as_dynamic(
|
|
&mut self,
|
|
path: &'static [u8],
|
|
this_id: ElementId,
|
|
to: &mut impl WriteMutations,
|
|
) -> ElementId {
|
|
if path.len() == 1 {
|
|
return this_id;
|
|
}
|
|
|
|
// if attribute is on a root node, then we've already created the element
|
|
// Else, it's deep in the template and we should create a new id for it
|
|
let id = self.next_element();
|
|
|
|
to.assign_node_id(&path[1..], id);
|
|
|
|
id
|
|
}
|
|
|
|
/// Insert a new template into the VirtualDom's template registry
|
|
pub(crate) fn register_template_first_byte_index(&mut self, mut template: Template) {
|
|
// First, make sure we mark the template as seen, regardless if we process it
|
|
let (path, _) = template.name.rsplit_once(':').unwrap();
|
|
if let Some((_, old_template)) = self
|
|
.templates
|
|
.entry(path)
|
|
.or_default()
|
|
.iter_mut()
|
|
.min_by_key(|(byte_index, _)| **byte_index)
|
|
{
|
|
// the byte index of the hot reloaded template could be different
|
|
template.name = old_template.name;
|
|
*old_template = template;
|
|
} else {
|
|
// This is a template without any current instances
|
|
self.templates
|
|
.entry(path)
|
|
.or_default()
|
|
.insert(usize::MAX, template);
|
|
}
|
|
|
|
// If it's all dynamic nodes, then we don't need to register it
|
|
if !template.is_completely_dynamic() {
|
|
self.queued_templates.push(template);
|
|
}
|
|
}
|
|
|
|
/// Insert a new template into the VirtualDom's template registry
|
|
// used in conditional compilation
|
|
#[allow(unused_mut)]
|
|
pub(crate) fn register_template(
|
|
&mut self,
|
|
mut template: Template,
|
|
to: &mut impl WriteMutations,
|
|
) {
|
|
let (path, byte_index) = template.name.rsplit_once(':').unwrap();
|
|
|
|
let byte_index = byte_index.parse::<usize>().unwrap();
|
|
// First, check if we've already seen this template
|
|
if self
|
|
.templates
|
|
.get(&path)
|
|
.filter(|set| set.contains_key(&byte_index))
|
|
.is_none()
|
|
{
|
|
// if hot reloading is enabled, then we need to check for a template that has overriten this one
|
|
#[cfg(debug_assertions)]
|
|
if let Some(mut new_template) = self
|
|
.templates
|
|
.get_mut(path)
|
|
.and_then(|map| map.remove(&usize::MAX))
|
|
{
|
|
// the byte index of the hot reloaded template could be different
|
|
new_template.name = template.name;
|
|
template = new_template;
|
|
}
|
|
|
|
self.templates
|
|
.entry(path)
|
|
.or_default()
|
|
.insert(byte_index, template);
|
|
|
|
// If it's all dynamic nodes, then we don't need to register it
|
|
if !template.is_completely_dynamic() {
|
|
to.register_template(template)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn create_dynamic_node(
|
|
&mut self,
|
|
parent: &ElementRef,
|
|
node: &DynamicNode,
|
|
to: &mut impl WriteMutations,
|
|
) -> usize {
|
|
use DynamicNode::*;
|
|
match node {
|
|
Text(text) => self.create_dynamic_text(parent, text, to),
|
|
Placeholder(place) => self.create_placeholder(place, parent, to),
|
|
Component(component) => self.create_component_node(Some(parent), component, to),
|
|
Fragment(frag) => self.create_children(frag, Some(parent), to),
|
|
}
|
|
}
|
|
|
|
fn create_dynamic_text(
|
|
&mut self,
|
|
parent: &ElementRef,
|
|
text: &VText,
|
|
to: &mut impl WriteMutations,
|
|
) -> usize {
|
|
// Allocate a dynamic element reference for this text node
|
|
let new_id = self.next_element();
|
|
|
|
// Make sure the text node is assigned to the correct element
|
|
text.id.set(Some(new_id));
|
|
|
|
// Add the mutation to the list
|
|
to.hydrate_text_node(&parent.path.path[1..], &text.value, new_id);
|
|
|
|
// Since we're hydrating an existing node, we don't create any new nodes
|
|
0
|
|
}
|
|
|
|
pub(crate) fn create_placeholder(
|
|
&mut self,
|
|
placeholder: &VPlaceholder,
|
|
parent: &ElementRef,
|
|
to: &mut impl WriteMutations,
|
|
) -> usize {
|
|
// Allocate a dynamic element reference for this text node
|
|
let id = self.next_element();
|
|
|
|
// Make sure the text node is assigned to the correct element
|
|
placeholder.id.set(Some(id));
|
|
|
|
// Assign the placeholder's parent
|
|
*placeholder.parent.borrow_mut() = Some(parent.clone());
|
|
|
|
// Assign the ID to the existing node in the template
|
|
to.assign_node_id(&parent.path.path[1..], id);
|
|
|
|
// Since the placeholder is already in the DOM, we don't create any new nodes
|
|
0
|
|
}
|
|
|
|
pub(super) fn create_component_node(
|
|
&mut self,
|
|
parent: Option<&ElementRef>,
|
|
component: &VComponent,
|
|
to: &mut impl WriteMutations,
|
|
) -> usize {
|
|
use RenderReturn::*;
|
|
|
|
// Load up a ScopeId for this vcomponent
|
|
let scope = self.load_scope_from_vcomponent(component, to);
|
|
|
|
component.scope.set(Some(scope));
|
|
|
|
let new = self.run_scope(scope);
|
|
|
|
self.scopes[scope.0].last_rendered_node = Some(new.clone());
|
|
|
|
match &new {
|
|
// Create the component's root element
|
|
Ready(t) => {
|
|
self.assign_boundary_ref(parent, t);
|
|
self.create_scope(scope, t, to)
|
|
}
|
|
Aborted(t) => self.mount_aborted(t, parent, to),
|
|
}
|
|
}
|
|
|
|
/// Load a scope from a vcomponent. If the scope id doesn't exist, that means the component is currently "live"
|
|
fn load_scope_from_vcomponent(
|
|
&mut self,
|
|
component: &VComponent,
|
|
_to: &mut impl WriteMutations,
|
|
) -> ScopeId {
|
|
component.scope.get().unwrap_or_else(|| {
|
|
self.new_scope(component.props.clone(), component.name)
|
|
.context()
|
|
.id
|
|
})
|
|
}
|
|
|
|
fn mount_aborted(
|
|
&mut self,
|
|
placeholder: &VPlaceholder,
|
|
parent: Option<&ElementRef>,
|
|
to: &mut impl WriteMutations,
|
|
) -> usize {
|
|
let id = self.next_element();
|
|
to.create_placeholder(id);
|
|
placeholder.id.set(Some(id));
|
|
*placeholder.parent.borrow_mut() = parent.cloned();
|
|
|
|
1
|
|
}
|
|
|
|
fn set_slot(&mut self, slot: &Cell<Option<ElementId>>) -> ElementId {
|
|
let id = self.next_element();
|
|
slot.set(Some(id));
|
|
id
|
|
}
|
|
}
|
|
|
|
fn collect_dyn_node_range(
|
|
dynamic_nodes: &mut Peekable<impl Iterator<Item = ((usize, usize), &'static [u8])>>,
|
|
root_idx: u8,
|
|
) -> Option<(usize, usize)> {
|
|
let start = match dynamic_nodes.peek() {
|
|
Some(((_, idx), [first, ..])) if *first == root_idx => *idx,
|
|
_ => return None,
|
|
};
|
|
|
|
let mut end = start;
|
|
|
|
while let Some(((_, idx), p)) =
|
|
dynamic_nodes.next_if(|(_, p)| matches!(p, [idx, ..] if *idx == root_idx))
|
|
{
|
|
if p.len() == 1 {
|
|
continue;
|
|
}
|
|
|
|
end = idx;
|
|
}
|
|
|
|
Some((start, end))
|
|
}
|