swaits/dioxus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wip: moving to IDs

Browse Source
This commit is contained in:
Jonathan Kelley committed 2021-06-20 02:16:42 -04:00
1 parent 45ee803609
commit 79127ea6cd
5 files changed
+176 -174
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/core/src/diff.rs
+160 -165
View File
@@ -34,47 +34,48 @@ use std::{
/// The accompanying "real dom" exposes an imperative API for controlling the UI layout /// The accompanying "real dom" exposes an imperative API for controlling the UI layout
/// ///
/// Instead of having handles directly over nodes, Dioxus uses simple u32s as node IDs. /// Instead of having handles directly over nodes, Dioxus uses simple u32s as node IDs.
/// This allows layouts with up to 4,294,967,295 nodes. If we /// This allows layouts with up to 4,294,967,295 nodes. If we use nohasher, then retrieving is very fast.
pub trait RealDom { pub trait RealDom {
fn delete_root(&mut self, root: RealDomNode); fn delete_root(&self, root: RealDomNode);
// =========== // ===========
// Create // Create
// =========== // ===========
/// Create a new text node and push it on to the top of the stack /// Create a new text node and push it on to the top of the stack
fn create_text_node(&mut self, text: &str) -> RealDomNode; fn create_text_node(&self, text: &str) -> RealDomNode;
/// Create a new text node and push it on to the top of the stack /// Create a new text node and push it on to the top of the stack
fn create_element(&mut self, tag: &str) -> RealDomNode; fn create_element(&self, tag: &str) -> RealDomNode;
/// Create a new namespaced element and push it on to the top of the stack /// Create a new namespaced element and push it on to the top of the stack
fn create_element_ns(&mut self, tag: &str, namespace: &str) -> RealDomNode; fn create_element_ns(&self, tag: &str, namespace: &str) -> RealDomNode;
fn append_node(&self, child: RealDomNode, parent: RealDomNode); fn append_node(&self, child: RealDomNode, parent: RealDomNode);
// =========== // ===========
// Remove // Remove
// =========== // ===========
fn remove_node(&mut self, node: RealDomNode); fn remove_node(&self, node: RealDomNode);
fn remove_all_children(&mut self, node: RealDomNode); fn remove_all_children(&self, node: RealDomNode);
// =========== // ===========
// Replace // Replace
// =========== // ===========
fn replace_node_with(&mut self, old: RealDomNode, new: RealDomNode); fn replace_node_with(&self, old: RealDomNode, new: RealDomNode);
fn new_event_listener(&mut self, node: RealDomNode, event: &str); fn new_event_listener(&self, node: RealDomNode, event: &str);
fn set_inner_text(&mut self, node: RealDomNode, text: &str); fn set_inner_text(&self, node: RealDomNode, text: &str);
fn set_class(&mut self, node: RealDomNode); fn set_class(&self, node: RealDomNode);
fn set_attr(&mut self, node: RealDomNode, name: &str, value: &str); fn set_attr(&self, node: RealDomNode, name: &str, value: &str);
fn remove_attr(&mut self, node: RealDomNode); fn remove_attr(&self, node: RealDomNode);
fn raw_node_as_any_mut(&mut self) -> &mut dyn Any; fn raw_node_as_any_mut(&self) -> &mut dyn Any;
} }
/// The DiffState is a cursor internal to the VirtualDOM's diffing algorithm that allows persistence of state while /// The DiffState is a cursor internal to the VirtualDOM's diffing algorithm that allows persistence of state while
@@ -89,7 +90,8 @@ pub trait RealDom {
/// The order of these re-entrances is stored in the DiffState itself. The DiffState comes pre-loaded with a set of components /// The order of these re-entrances is stored in the DiffState itself. The DiffState comes pre-loaded with a set of components
/// that were modified by the eventtrigger. This prevents doubly evaluating components if they were both updated via /// that were modified by the eventtrigger. This prevents doubly evaluating components if they were both updated via
/// subscriptions and props changes. /// subscriptions and props changes.
pub struct DiffMachine { pub struct DiffMachine<'a, Dom: RealDom> {
pub dom: &'a mut Dom,
pub cur_idx: ScopeIdx, pub cur_idx: ScopeIdx,
pub diffed: FxHashSet<ScopeIdx>, pub diffed: FxHashSet<ScopeIdx>,
pub components: ScopeArena, pub components: ScopeArena,
@@ -105,10 +107,16 @@ fn next_id() -> u32 {
out out
} }
impl DiffMachine { impl<'a, Dom: RealDom> DiffMachine<'a, Dom> {
pub fn new(components: ScopeArena, cur_idx: ScopeIdx, event_queue: EventQueue) -> Self { pub fn new(
dom: &'a mut Dom,
components: ScopeArena,
cur_idx: ScopeIdx,
event_queue: EventQueue,
) -> Self {
Self { Self {
components, components,
dom,
cur_idx, cur_idx,
event_queue, event_queue,
diffed: FxHashSet::default(), diffed: FxHashSet::default(),
@@ -116,13 +124,8 @@ impl DiffMachine {
} }
} }
pub fn diff_node<'a, Dom: RealDom>( pub fn diff_node(&self, old_node: &mut VNode<'a>, new_node: &mut VNode<'a>) {
&mut self, // pub fn diff_node(&self, old: &VNode<'a>, new: &VNode<'a>) {
dom: &mut Dom,
old_node: &mut VNode<'a>,
new_node: &mut VNode<'a>,
) {
// pub fn diff_node(&mut self, old: &VNode<'a>, new: &VNode<'a>) {
/* /*
For each valid case, we "commit traversal", meaning we save this current position in the tree. For each valid case, we "commit traversal", meaning we save this current position in the tree.
Then, we diff and queue an edit event (via chagelist). s single trees - when components show up, we save that traversal and then re-enter later. Then, we diff and queue an edit event (via chagelist). s single trees - when components show up, we save that traversal and then re-enter later.
@@ -132,30 +135,33 @@ impl DiffMachine {
(VNode::Text(old), VNode::Text(new)) => { (VNode::Text(old), VNode::Text(new)) => {
new.dom_id = old.dom_id; new.dom_id = old.dom_id;
if old.text != new.text { if old.text != new.text {
self.realdom.set_inner_text(new.dom_id, new.text); self.dom.set_inner_text(new.dom_id.get(), new.text);
} }
} }
(VNode::Text(old), VNode::Element(new)) => { (VNode::Text(old), VNode::Element(new)) => {
// // self.realdom.commit_traversal(); // // self.dom.commit_traversal();
self.create(new_node); self.create_and_repalce(new_node, old.dom_id.get())
self.realdom.replace_node_with(old.dom_id, old.dom_id); // self.create(new_node);
// self.realdom.replace_with(); // self.dom.replace_node_with(old.dom_id, old.dom_id);
// self.dom.replace_with();
} }
(VNode::Element(old), VNode::Text(new)) => { (VNode::Element(old), VNode::Text(new)) => {
// // self.realdom.commit_traversal(); // // self.dom.commit_traversal();
self.create(new_node); self.create_and_repalce(new_node, old.dom_id.get())
self.realdom.replace_node_with(old.dom_id, new.dom_id); // self.create(new_node);
// self.realdom.replace_with(); // self.dom.replace_node_with(old.dom_id, new.dom_id);
// self.dom.replace_with();
} }
(VNode::Element(old), VNode::Element(new)) => { (VNode::Element(old), VNode::Element(new)) => {
// If the element type is completely different, the element needs to be re-rendered completely // If the element type is completely different, the element needs to be re-rendered completely
if new.tag_name != old.tag_name || new.namespace != old.namespace { if new.tag_name != old.tag_name || new.namespace != old.namespace {
// // self.realdom.commit_traversal(); // // self.dom.commit_traversal();
// self.realdom.replace_with(); // self.dom.replace_with();
self.realdom.replace_node_with(old.dom_id, new.dom_id); self.dom
.replace_node_with(old.dom_id.get(), new.dom_id.get());
return; return;
} }
@@ -186,7 +192,7 @@ impl DiffMachine {
}; };
if should_render { if should_render {
// // self.realdom.commit_traversal(); // // self.dom.commit_traversal();
self.components self.components
.with_scope(scope_id.unwrap(), |f| { .with_scope(scope_id.unwrap(), |f| {
f.run_scope().unwrap(); f.run_scope().unwrap();
@@ -204,10 +210,11 @@ impl DiffMachine {
// A new component has shown up! We need to destroy the old node // A new component has shown up! We need to destroy the old node
// Wipe the old one and plant the new one // Wipe the old one and plant the new one
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.create(new_node); // self.dom.replace_node_with(old.dom_id, new.dom_id);
// self.realdom.replace_node_with(old.dom_id, new.dom_id); // self.create(new_node);
self.realdom.replace_with(); // self.dom.replace_with();
self.create_and_repalce(new_node, old.mounted_root.get());
// Now we need to remove the old scope and all of its descendents // Now we need to remove the old scope and all of its descendents
let old_scope = old.ass_scope.borrow().as_ref().unwrap().clone(); let old_scope = old.ass_scope.borrow().as_ref().unwrap().clone();
@@ -216,17 +223,19 @@ impl DiffMachine {
} }
// todo: knock out any listeners // todo: knock out any listeners
(_, VNode::Component(_)) => { (old, VNode::Component(_)) => {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.create(new_node); // self.create(new_node);
self.realdom.replace_with(); // self.dom.replace_with();
self.create_and_repalce(new_node, old.dom_id.get())
} }
// A component is being torn down in favor of a non-component node // A component is being torn down in favor of a non-component node
(VNode::Component(_old), _) => { (VNode::Component(_old), _) => {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.create(new_node); // self.create(new_node);
self.realdom.replace_with(); // self.dom.replace_with();
self.create_and_repalce(new_node, old.dom_id.get())
// Destroy the original scope and any of its children // Destroy the original scope and any of its children
self.destroy_scopes(_old.ass_scope.borrow().unwrap()); self.destroy_scopes(_old.ass_scope.borrow().unwrap());
@@ -260,26 +269,18 @@ impl DiffMachine {
} }
} }
// Emit instructions to create the given virtual node. // create a node and replace another node
// // this method doesn't work with
// The change list stack may have any shape upon entering this function: fn create_and_repalce(&self, node: &mut VNode<'a>, parent: RealDomNode) {}
//
// [...] // create and append creates the series of elements and immediately appends them to whatever parent is provided
// // this way we can handle a series of children
// When this function returns, the new node is on top of the change list stack: fn create_and_append(&self, node: &mut VNode<'a>, parent: RealDomNode) {
// // debug_assert!(self.dom.traversal_is_committed());
// [... node]
fn create<'a, Dom: RealDom>(
&mut self,
dom: &mut Dom,
node: &mut VNode<'a>,
parent: RealDomNode,
) {
// debug_assert!(self.realdom.traversal_is_committed());
match node { match node {
VNode::Text(text) => { VNode::Text(text) => {
let real_id = self.realdom.create_text_node(text.text); let real_id = self.dom.create_text_node(text.text);
text.dom_id = real_id; text.dom_id.set(real_id);
} }
VNode::Element(&el) => { VNode::Element(&el) => {
let VElement { let VElement {
@@ -293,21 +294,21 @@ impl DiffMachine {
} = el; } = el;
// log::info!("Creating {:#?}", node); // log::info!("Creating {:#?}", node);
let real_id = if let Some(namespace) = namespace { let real_id = if let Some(namespace) = namespace {
self.realdom.create_element_ns(tag_name, namespace) self.dom.create_element_ns(tag_name, namespace)
} else { } else {
self.realdom.create_element(tag_name) self.dom.create_element(tag_name)
}; };
el.dom_id = real_id; el.dom_id = real_id;
listeners.iter().enumerate().for_each(|(_id, listener)| { listeners.iter().enumerate().for_each(|(_id, listener)| {
todo!() todo!()
// self.realdom // dom
// .new_event_listener(listener.event, listener.scope, listener.id) // .new_event_listener(listener.event, listener.scope, listener.id)
}); });
for attr in attributes { for attr in attributes {
todo!() todo!()
// self.realdom // dom
// .set_attribute(&attr.name, &attr.value, namespace.is_some()); // .set_attribute(&attr.name, &attr.value, namespace.is_some());
} }
@@ -319,7 +320,7 @@ impl DiffMachine {
// parent. // parent.
if children.len() == 1 { if children.len() == 1 {
if let VNode::Text(text) = children[0] { if let VNode::Text(text) = children[0] {
self.realdom.set_inner_text(real_id, text.text); self.dom.set_inner_text(real_id, text.text);
return; return;
} }
} }
@@ -330,16 +331,16 @@ impl DiffMachine {
// do nothing // do nothing
// fragments append themselves // fragments append themselves
} else { } else {
self.realdom.append_child(); self.dom.append_child();
} }
} }
} }
VNode::Component(component) => { VNode::Component(component) => {
self.realdom.create_text_node("placeholder for vcomponent"); self.dom.create_text_node("placeholder for vcomponent");
// let root_id = next_id(); // let root_id = next_id();
// self.realdom.save_known_root(root_id); // self.dom.save_known_root(root_id);
log::debug!("Mounting a new component"); log::debug!("Mounting a new component");
let caller: Weak<OpaqueComponent> = Rc::downgrade(&component.caller); let caller: Weak<OpaqueComponent> = Rc::downgrade(&component.caller);
@@ -402,7 +403,7 @@ impl DiffMachine {
for child in frag.children { for child in frag.children {
todo!() todo!()
// self.create(child); // self.create(child);
// self.realdom.append_child(); // self.dom.append_child();
} }
} }
@@ -416,7 +417,7 @@ impl DiffMachine {
/// ///
/// Calling this will run the destuctors on all hooks in the tree. /// Calling this will run the destuctors on all hooks in the tree.
/// It will also add the destroyed nodes to the `seen_nodes` cache to prevent them from being renderered. /// It will also add the destroyed nodes to the `seen_nodes` cache to prevent them from being renderered.
fn destroy_scopes(&mut self, old_scope: ScopeIdx) { fn destroy_scopes(&self, old_scope: ScopeIdx) {
let mut nodes_to_delete = vec![old_scope]; let mut nodes_to_delete = vec![old_scope];
let mut scopes_to_explore = vec![old_scope]; let mut scopes_to_explore = vec![old_scope];
@@ -451,9 +452,9 @@ impl DiffMachine {
// [... node] // [... node]
// //
// The change list stack is left unchanged. // The change list stack is left unchanged.
fn diff_listeners(&mut self, old: &[Listener<'_>], new: &[Listener<'_>]) { fn diff_listeners(&self, old: &[Listener<'_>], new: &[Listener<'_>]) {
if !old.is_empty() || !new.is_empty() { if !old.is_empty() || !new.is_empty() {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
} }
'outer1: for (_l_idx, new_l) in new.iter().enumerate() { 'outer1: for (_l_idx, new_l) in new.iter().enumerate() {
@@ -468,8 +469,8 @@ impl DiffMachine {
for old_l in old { for old_l in old {
if new_l.event == old_l.event { if new_l.event == old_l.event {
if new_l.id != old_l.id { if new_l.id != old_l.id {
self.realdom.remove_event_listener(event_type); self.dom.remove_event_listener(event_type);
self.realdom self.dom
.update_event_listener(event_type, new_l.scope, new_l.id) .update_event_listener(event_type, new_l.scope, new_l.id)
} }
@@ -477,7 +478,7 @@ impl DiffMachine {
} }
} }
self.realdom self.dom
.new_event_listener(event_type, new_l.scope, new_l.id); .new_event_listener(event_type, new_l.scope, new_l.id);
} }
@@ -487,7 +488,7 @@ impl DiffMachine {
continue 'outer2; continue 'outer2;
} }
} }
self.realdom.remove_event_listener(old_l.event); self.dom.remove_event_listener(old_l.event);
} }
} }
@@ -498,12 +499,7 @@ impl DiffMachine {
// [... node] // [... node]
// //
// The change list stack is left unchanged. // The change list stack is left unchanged.
fn diff_attr<'a>( fn diff_attr(&self, old: &'a [Attribute<'a>], new: &'a [Attribute<'a>], is_namespaced: bool) {
&mut self,
old: &'a [Attribute<'a>],
new: &'a [Attribute<'a>],
is_namespaced: bool,
) {
// Do O(n^2) passes to add/update and remove attributes, since // Do O(n^2) passes to add/update and remove attributes, since
// there are almost always very few attributes. // there are almost always very few attributes.
// //
@@ -511,19 +507,16 @@ impl DiffMachine {
// With the Rsx and Html macros, this will almost always be the case // With the Rsx and Html macros, this will almost always be the case
'outer: for new_attr in new { 'outer: for new_attr in new {
if new_attr.is_volatile() { if new_attr.is_volatile() {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.realdom self.dom
.set_attribute(new_attr.name, new_attr.value, is_namespaced); .set_attribute(new_attr.name, new_attr.value, is_namespaced);
} else { } else {
for old_attr in old { for old_attr in old {
if old_attr.name == new_attr.name { if old_attr.name == new_attr.name {
if old_attr.value != new_attr.value { if old_attr.value != new_attr.value {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.realdom.set_attribute( self.dom
new_attr.name, .set_attribute(new_attr.name, new_attr.value, is_namespaced);
new_attr.value,
is_namespaced,
);
} }
continue 'outer; continue 'outer;
} else { } else {
@@ -531,8 +524,8 @@ impl DiffMachine {
} }
} }
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.realdom self.dom
.set_attribute(new_attr.name, new_attr.value, is_namespaced); .set_attribute(new_attr.name, new_attr.value, is_namespaced);
} }
} }
@@ -544,8 +537,8 @@ impl DiffMachine {
} }
} }
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.realdom.remove_attribute(old_attr.name); self.dom.remove_attribute(old_attr.name);
} }
} }
@@ -557,10 +550,10 @@ impl DiffMachine {
// [... parent] // [... parent]
// //
// the change list stack is in the same state when this function returns. // the change list stack is in the same state when this function returns.
fn diff_children<'a>(&mut self, old: &'a [VNode<'a>], new: &'a [VNode<'a>]) { fn diff_children(&self, old: &'a [VNode<'a>], new: &'a [VNode<'a>]) {
if new.is_empty() { if new.is_empty() {
if !old.is_empty() { if !old.is_empty() {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.remove_all_children(old); self.remove_all_children(old);
} }
return; return;
@@ -573,8 +566,8 @@ impl DiffMachine {
} }
(_, &VNode::Text(text)) => { (_, &VNode::Text(text)) => {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.realdom.set_text(text); self.dom.set_text(text);
return; return;
} }
@@ -585,7 +578,7 @@ impl DiffMachine {
if old.is_empty() { if old.is_empty() {
if !new.is_empty() { if !new.is_empty() {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.create_and_append_children(new); self.create_and_append_children(new);
} }
return; return;
@@ -604,9 +597,9 @@ impl DiffMachine {
); );
if new_is_keyed && old_is_keyed { if new_is_keyed && old_is_keyed {
let t = self.realdom.next_temporary(); let t = self.dom.next_temporary();
self.diff_keyed_children(old, new); self.diff_keyed_children(old, new);
self.realdom.set_next_temporary(t); self.dom.set_next_temporary(t);
} else { } else {
self.diff_non_keyed_children(old, new); self.diff_non_keyed_children(old, new);
} }
@@ -633,7 +626,7 @@ impl DiffMachine {
// [... parent] // [... parent]
// //
// Upon exiting, the change list stack is in the same state. // Upon exiting, the change list stack is in the same state.
fn diff_keyed_children<'a>(&mut self, old: &[VNode<'a>], new: &[VNode<'a>]) { fn diff_keyed_children(&self, old: &[VNode<'a>], new: &[VNode<'a>]) {
// if cfg!(debug_assertions) { // if cfg!(debug_assertions) {
// let mut keys = fxhash::FxHashSet::default(); // let mut keys = fxhash::FxHashSet::default();
// let mut assert_unique_keys = |children: &[VNode]| { // let mut assert_unique_keys = |children: &[VNode]| {
@@ -716,8 +709,8 @@ impl DiffMachine {
// [... parent] // [... parent]
// //
// Upon exit, the change list stack is the same. // Upon exit, the change list stack is the same.
fn diff_keyed_prefix<'a>(&mut self, old: &[VNode<'a>], new: &[VNode<'a>]) -> KeyedPrefixResult { fn diff_keyed_prefix(&self, old: &[VNode<'a>], new: &[VNode<'a>]) -> KeyedPrefixResult {
// self.realdom.go_down(); // self.dom.go_down();
let mut shared_prefix_count = 0; let mut shared_prefix_count = 0;
for (i, (old, new)) in old.iter().zip(new.iter()).enumerate() { for (i, (old, new)) in old.iter().zip(new.iter()).enumerate() {
@@ -725,7 +718,7 @@ impl DiffMachine {
break; break;
} }
self.realdom.go_to_sibling(i); self.dom.go_to_sibling(i);
self.diff_node(old, new); self.diff_node(old, new);
@@ -735,8 +728,8 @@ impl DiffMachine {
// If that was all of the old children, then create and append the remaining // If that was all of the old children, then create and append the remaining
// new children and we're finished. // new children and we're finished.
if shared_prefix_count == old.len() { if shared_prefix_count == old.len() {
self.realdom.go_up(); self.dom.go_up();
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.create_and_append_children(&new[shared_prefix_count..]); self.create_and_append_children(&new[shared_prefix_count..]);
return KeyedPrefixResult::Finished; return KeyedPrefixResult::Finished;
} }
@@ -744,13 +737,13 @@ impl DiffMachine {
// And if that was all of the new children, then remove all of the remaining // And if that was all of the new children, then remove all of the remaining
// old children and we're finished. // old children and we're finished.
if shared_prefix_count == new.len() { if shared_prefix_count == new.len() {
self.realdom.go_to_sibling(shared_prefix_count); self.dom.go_to_sibling(shared_prefix_count);
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.remove_self_and_next_siblings(&old[shared_prefix_count..]); self.remove_self_and_next_siblings(&old[shared_prefix_count..]);
return KeyedPrefixResult::Finished; return KeyedPrefixResult::Finished;
} }
self.realdom.go_up(); self.dom.go_up();
KeyedPrefixResult::MoreWorkToDo(shared_prefix_count) KeyedPrefixResult::MoreWorkToDo(shared_prefix_count)
} }
@@ -767,8 +760,8 @@ impl DiffMachine {
// [... parent] // [... parent]
// //
// Upon exit from this function, it will be restored to that same state. // Upon exit from this function, it will be restored to that same state.
fn diff_keyed_middle<'a>( fn diff_keyed_middle(
&mut self, &self,
old: &[VNode<'a>], old: &[VNode<'a>],
mut new: &[VNode<'a>], mut new: &[VNode<'a>],
shared_prefix_count: usize, shared_prefix_count: usize,
@@ -811,11 +804,11 @@ impl DiffMachine {
// afresh. // afresh.
if shared_suffix_count == 0 && shared_keys.is_empty() { if shared_suffix_count == 0 && shared_keys.is_empty() {
if shared_prefix_count == 0 { if shared_prefix_count == 0 {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.remove_all_children(old); self.remove_all_children(old);
} else { } else {
self.realdom.go_down_to_child(shared_prefix_count); self.dom.go_down_to_child(shared_prefix_count);
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.remove_self_and_next_siblings(&old[shared_prefix_count..]); self.remove_self_and_next_siblings(&old[shared_prefix_count..]);
} }
@@ -837,8 +830,8 @@ impl DiffMachine {
.unwrap_or(old.len()); .unwrap_or(old.len());
if end - start > 0 { if end - start > 0 {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
let mut t = self.realdom.save_children_to_temporaries( let mut t = self.dom.save_children_to_temporaries(
shared_prefix_count + start, shared_prefix_count + start,
shared_prefix_count + end, shared_prefix_count + end,
); );
@@ -863,8 +856,8 @@ impl DiffMachine {
if !shared_keys.contains(&old_child.key()) { if !shared_keys.contains(&old_child.key()) {
// registry.remove_subtree(old_child); // registry.remove_subtree(old_child);
// todo // todo
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.realdom.remove_child(i + shared_prefix_count); self.dom.remove_child(i + shared_prefix_count);
removed_count += 1; removed_count += 1;
} }
} }
@@ -907,7 +900,7 @@ impl DiffMachine {
// shared suffix to the change list stack. // shared suffix to the change list stack.
// //
// [... parent] // [... parent]
self.realdom self.dom
.go_down_to_child(old_shared_suffix_start - removed_count); .go_down_to_child(old_shared_suffix_start - removed_count);
// [... parent first_child_of_shared_suffix] // [... parent first_child_of_shared_suffix]
} else { } else {
@@ -923,29 +916,29 @@ impl DiffMachine {
let old_index = new_index_to_old_index[last_index]; let old_index = new_index_to_old_index[last_index];
let temp = old_index_to_temp[old_index]; let temp = old_index_to_temp[old_index];
// [... parent] // [... parent]
self.realdom.go_down_to_temp_child(temp); self.dom.go_down_to_temp_child(temp);
// [... parent last] // [... parent last]
self.diff_node(&old[old_index], last); self.diff_node(&old[old_index], last);
if new_index_is_in_lis.contains(&last_index) { if new_index_is_in_lis.contains(&last_index) {
// Don't move it, since it is already where it needs to be. // Don't move it, since it is already where it needs to be.
} else { } else {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
// [... parent last] // [... parent last]
self.realdom.append_child(); self.dom.append_child();
// [... parent] // [... parent]
self.realdom.go_down_to_temp_child(temp); self.dom.go_down_to_temp_child(temp);
// [... parent last] // [... parent last]
} }
} else { } else {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
// [... parent] // [... parent]
self.create(last); self.create(last);
// [... parent last] // [... parent last]
self.realdom.append_child(); self.dom.append_child();
// [... parent] // [... parent]
self.realdom.go_down_to_reverse_child(0); self.dom.go_down_to_reverse_child(0);
// [... parent last] // [... parent last]
} }
} }
@@ -954,11 +947,11 @@ impl DiffMachine {
let old_index = new_index_to_old_index[new_index]; let old_index = new_index_to_old_index[new_index];
if old_index == u32::MAX as usize { if old_index == u32::MAX as usize {
debug_assert!(!shared_keys.contains(&new_child.key())); debug_assert!(!shared_keys.contains(&new_child.key()));
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
// [... parent successor] // [... parent successor]
self.create(new_child); self.create(new_child);
// [... parent successor new_child] // [... parent successor new_child]
self.realdom.insert_before(); self.dom.insert_before();
// [... parent new_child] // [... parent new_child]
} else { } else {
debug_assert!(shared_keys.contains(&new_child.key())); debug_assert!(shared_keys.contains(&new_child.key()));
@@ -967,14 +960,14 @@ impl DiffMachine {
if new_index_is_in_lis.contains(&new_index) { if new_index_is_in_lis.contains(&new_index) {
// [... parent successor] // [... parent successor]
self.realdom.go_to_temp_sibling(temp); self.dom.go_to_temp_sibling(temp);
// [... parent new_child] // [... parent new_child]
} else { } else {
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
// [... parent successor] // [... parent successor]
self.realdom.push_temporary(temp); self.dom.push_temporary(temp);
// [... parent successor new_child] // [... parent successor new_child]
self.realdom.insert_before(); self.dom.insert_before();
// [... parent new_child] // [... parent new_child]
} }
@@ -983,7 +976,7 @@ impl DiffMachine {
} }
// [... parent child] // [... parent child]
self.realdom.go_up(); self.dom.go_up();
// [... parent] // [... parent]
} }
@@ -994,8 +987,8 @@ impl DiffMachine {
// [... parent] // [... parent]
// //
// When this function exits, the change list stack remains the same. // When this function exits, the change list stack remains the same.
fn diff_keyed_suffix<'a>( fn diff_keyed_suffix(
&mut self, &self,
old: &[VNode<'a>], old: &[VNode<'a>],
new: &[VNode<'a>], new: &[VNode<'a>],
new_shared_suffix_start: usize, new_shared_suffix_start: usize,
@@ -1004,16 +997,16 @@ impl DiffMachine {
debug_assert!(!old.is_empty()); debug_assert!(!old.is_empty());
// [... parent] // [... parent]
self.realdom.go_down(); self.dom.go_down();
// [... parent new_child] // [... parent new_child]
for (i, (old_child, new_child)) in old.iter().zip(new.iter()).enumerate() { for (i, (old_child, new_child)) in old.iter().zip(new.iter()).enumerate() {
self.realdom.go_to_sibling(new_shared_suffix_start + i); self.dom.go_to_sibling(new_shared_suffix_start + i);
self.diff_node(old_child, new_child); self.diff_node(old_child, new_child);
} }
// [... parent] // [... parent]
self.realdom.go_up(); self.dom.go_up();
} }
// Diff children that are not keyed. // Diff children that are not keyed.
@@ -1024,18 +1017,18 @@ impl DiffMachine {
// [... parent] // [... parent]
// //
// the change list stack is in the same state when this function returns. // the change list stack is in the same state when this function returns.
fn diff_non_keyed_children<'a>(&mut self, old: &'a [VNode<'a>], new: &'a [VNode<'a>]) { fn diff_non_keyed_children(&self, old: &'a [VNode<'a>], new: &'a [VNode<'a>]) {
// Handled these cases in `diff_children` before calling this function. // Handled these cases in `diff_children` before calling this function.
debug_assert!(!new.is_empty()); debug_assert!(!new.is_empty());
debug_assert!(!old.is_empty()); debug_assert!(!old.is_empty());
// [... parent] // [... parent]
self.realdom.go_down(); self.dom.go_down();
// [... parent child] // [... parent child]
for (i, (new_child, old_child)) in new.iter().zip(old.iter()).enumerate() { for (i, (new_child, old_child)) in new.iter().zip(old.iter()).enumerate() {
// [... parent prev_child] // [... parent prev_child]
self.realdom.go_to_sibling(i); self.dom.go_to_sibling(i);
// [... parent this_child] // [... parent this_child]
self.diff_node(old_child, new_child); self.diff_node(old_child, new_child);
} }
@@ -1044,9 +1037,9 @@ impl DiffMachine {
// old.len > new.len -> removing some nodes // old.len > new.len -> removing some nodes
Ordering::Greater => { Ordering::Greater => {
// [... parent prev_child] // [... parent prev_child]
self.realdom.go_to_sibling(new.len()); self.dom.go_to_sibling(new.len());
// [... parent first_child_to_remove] // [... parent first_child_to_remove]
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
// support::remove_self_and_next_siblings(state, &old[new.len()..]); // support::remove_self_and_next_siblings(state, &old[new.len()..]);
self.remove_self_and_next_siblings(&old[new.len()..]); self.remove_self_and_next_siblings(&old[new.len()..]);
// [... parent] // [... parent]
@@ -1054,15 +1047,15 @@ impl DiffMachine {
// old.len < new.len -> adding some nodes // old.len < new.len -> adding some nodes
Ordering::Less => { Ordering::Less => {
// [... parent last_child] // [... parent last_child]
self.realdom.go_up(); self.dom.go_up();
// [... parent] // [... parent]
// self.realdom.commit_traversal(); // self.dom.commit_traversal();
self.create_and_append_children(&new[old.len()..]); self.create_and_append_children(&new[old.len()..]);
} }
// old.len == new.len -> no nodes added/removed, but πerhaps changed // old.len == new.len -> no nodes added/removed, but πerhaps changed
Ordering::Equal => { Ordering::Equal => {
// [... parent child] // [... parent child]
self.realdom.go_up(); self.dom.go_up();
// [... parent] // [... parent]
} }
} }
@@ -1079,15 +1072,16 @@ impl DiffMachine {
// [... parent] // [... parent]
// //
// When this function returns, the change list stack is in the same state. // When this function returns, the change list stack is in the same state.
pub fn remove_all_children<'a>(&mut self, old: &[VNode<'a>]) { pub fn remove_all_children(&self, old: &[VNode<'a>]) {
// debug_assert!(self.realdom.traversal_is_committed()); // debug_assert!(self.dom.traversal_is_committed());
log::debug!("REMOVING CHILDREN"); log::debug!("REMOVING CHILDREN");
for _child in old { for _child in old {
// registry.remove_subtree(child); // registry.remove_subtree(child);
} }
// Fast way to remove all children: set the node's textContent to an empty // Fast way to remove all children: set the node's textContent to an empty
// string. // string.
self.realdom.set_text(""); todo!()
// self.dom.set_inner_text("");
} }
// Create the given children and append them to the parent node. // Create the given children and append them to the parent node.
@@ -1097,11 +1091,12 @@ impl DiffMachine {
// [... parent] // [... parent]
// //
// When this function returns, the change list stack is in the same state. // When this function returns, the change list stack is in the same state.
pub fn create_and_append_children<'a>(&mut self, new: &[VNode<'a>]) { pub fn create_and_append_children(&self, new: &[VNode<'a>]) {
// debug_assert!(self.realdom.traversal_is_committed()); // debug_assert!(self.dom.traversal_is_committed());
for child in new { for child in new {
self.create(child); self.create_and_append(node, parent)
self.realdom.append_child(); // self.create(child);
// self.dom.append_child();
} }
} }
@@ -1114,11 +1109,11 @@ impl DiffMachine {
// After the function returns, the child is no longer on the change list stack: // After the function returns, the child is no longer on the change list stack:
// //
// [... parent] // [... parent]
pub fn remove_self_and_next_siblings<'a>(&mut self, old: &[VNode<'a>]) { pub fn remove_self_and_next_siblings(&self, old: &[VNode<'a>]) {
// debug_assert!(self.realdom.traversal_is_committed()); // debug_assert!(self.dom.traversal_is_committed());
for child in old { for child in old {
if let VNode::Component(vcomp) = child { if let VNode::Component(vcomp) = child {
// self.realdom // dom
// .create_text_node("placeholder for vcomponent"); // .create_text_node("placeholder for vcomponent");
todo!() todo!()
@@ -1129,7 +1124,7 @@ impl DiffMachine {
// }) // })
// let id = get_id(); // let id = get_id();
// *component.stable_addr.as_ref().borrow_mut() = Some(id); // *component.stable_addr.as_ref().borrow_mut() = Some(id);
// self.realdom.save_known_root(id); // self.dom.save_known_root(id);
// let scope = Rc::downgrade(&component.ass_scope); // let scope = Rc::downgrade(&component.ass_scope);
// self.lifecycle_events.push_back(LifeCycleEvent::Mount { // self.lifecycle_events.push_back(LifeCycleEvent::Mount {
// caller: Rc::downgrade(&component.caller), // caller: Rc::downgrade(&component.caller),
@@ -1140,7 +1135,7 @@ impl DiffMachine {
// registry.remove_subtree(child); // registry.remove_subtree(child);
} }
self.realdom.remove_self_and_next_siblings(); self.dom.remove_self_and_next_siblings();
} }
} }
packages/core/src/nodes.rs
+2 -2
View File
@@ -234,7 +234,7 @@ pub type VCompAssociatedScope = Option<ScopeIdx>;
pub struct VComponent<'src> { pub struct VComponent<'src> {
pub key: NodeKey<'src>, pub key: NodeKey<'src>,
pub mounted_root: RealDomNode, pub mounted_root: Cell<RealDomNode>,
pub ass_scope: RefCell<VCompAssociatedScope>, pub ass_scope: RefCell<VCompAssociatedScope>,
// pub comparator: Rc<dyn Fn(&VComponent) -> bool + 'src>, // pub comparator: Rc<dyn Fn(&VComponent) -> bool + 'src>,
@@ -335,7 +335,7 @@ impl<'a> VComponent<'a> {
raw_props, raw_props,
children, children,
caller, caller,
mounted_root: RealDomNode::empty(), mounted_root: Cell::new(RealDomNode::empty()),
} }
} }
} }
packages/core/src/virtual_dom.rs
+11 -7
View File
@@ -192,6 +192,7 @@ impl VirtualDom {
/// Currently this doesn't do what we want it to do /// Currently this doesn't do what we want it to do
pub fn rebuild<'s, Dom: RealDom>(&'s mut self, realdom: &mut Dom) -> Result<()> { pub fn rebuild<'s, Dom: RealDom>(&'s mut self, realdom: &mut Dom) -> Result<()> {
let mut diff_machine = DiffMachine::new( let mut diff_machine = DiffMachine::new(
realdom,
self.components.clone(), self.components.clone(),
self.base_scope, self.base_scope,
self.event_queue.clone(), self.event_queue.clone(),
@@ -206,7 +207,7 @@ impl VirtualDom {
let update = &base.event_channel; let update = &base.event_channel;
update(); update();
self.progress_completely(realdom, &mut diff_machine)?; self.progress_completely(&mut diff_machine)?;
Ok(()) Ok(())
} }
@@ -262,10 +263,14 @@ impl VirtualDom {
self.components.try_get_mut(id)?.call_listener(event)?; self.components.try_get_mut(id)?.call_listener(event)?;
let mut diff_machine = let mut diff_machine = DiffMachine::new(
DiffMachine::new(self.components.clone(), id, self.event_queue.clone()); realdom,
self.components.clone(),
id,
self.event_queue.clone(),
);
self.progress_completely(realdom, &mut diff_machine)?; self.progress_completely(&mut diff_machine)?;
Ok(()) Ok(())
} }
@@ -276,8 +281,7 @@ impl VirtualDom {
/// The DiffMachine logs its progress as it goes which might be useful for certain types of renderers. /// The DiffMachine logs its progress as it goes which might be useful for certain types of renderers.
pub(crate) fn progress_completely<'s, Dom: RealDom>( pub(crate) fn progress_completely<'s, Dom: RealDom>(
&'s mut self, &'s mut self,
realdom: &mut Dom, diff_machine: &'_ mut DiffMachine<'s, Dom>,
diff_machine: &'_ mut DiffMachine,
) -> Result<()> { ) -> Result<()> {
// Add this component to the list of components that need to be difed // Add this component to the list of components that need to be difed
// #[allow(unused_assignments)] // #[allow(unused_assignments)]
@@ -315,7 +319,7 @@ impl VirtualDom {
// diff_machine.change_list.load_known_root(1); // diff_machine.change_list.load_known_root(1);
let (old, new) = cur_component.get_frames_mut(); let (old, new) = cur_component.get_frames_mut();
diff_machine.diff_node(realdom, old, new); diff_machine.diff_node(old, new);
// cur_height = cur_component.height; // cur_height = cur_component.height;
packages/web/src/lib.rs
+1
View File
@@ -13,6 +13,7 @@ use dioxus_core::{events::EventTrigger, prelude::FC};
pub use dioxus_core::prelude; pub use dioxus_core::prelude;
pub mod interpreter; pub mod interpreter;
pub mod new;
/// The `WebsysRenderer` provides a way of rendering a Dioxus Virtual DOM to the browser's DOM. /// The `WebsysRenderer` provides a way of rendering a Dioxus Virtual DOM to the browser's DOM.
/// Under the hood, we leverage WebSys and interact directly with the DOM /// Under the hood, we leverage WebSys and interact directly with the DOM
packages/web/src/new.rs
+2
View File
@@ -0,0 +1,2 @@
pub struct WebsysDom {}
impl WebsysDom {}