//! This module contains the stateful DiffMachine and all methods to diff VNodes, their properties, and their children. //! The DiffMachine calculates the diffs between the old and new frames, updates the new nodes, and modifies the real dom. //! //! ## Notice: //! The inspiration and code for this module was originally taken from Dodrio (@fitzgen) and then modified to support //! Components, Fragments, Suspense, SubTree memoization, and additional batching operations. //! //! ## Implementation Details: //! //! ### IDs for elements //! -------------------- //! All nodes are addressed by their IDs. The RealDom provides an imperative interface for making changes to these nodes. //! We don't necessarily require that DOM changes happen instnatly during the diffing process, so the implementor may choose //! to batch nodes if it is more performant for their application. The expectation is that renderers use a Slotmap for nodes //! whose keys can be converted to u64 on FFI boundaries. //! //! When new nodes are created through `render`, they won't know which real node they correspond to. During diffing, we //! always make sure to copy over the ID. If we don't do this properly, the ElementId will be populated incorrectly and //! brick the user's page. //! //! ## Subtree Memoization //! ----------------------- //! We also employ "subtree memoization" which saves us from having to check trees which take no dynamic content. We can //! detect if a subtree is "static" by checking if its children are "static". Since we dive into the tree depth-first, the //! calls to "create" propogate this information upwards. Structures like the one below are entirely static: //! ```rust //! rsx!( div { class: "hello world", "this node is entirely static" } ) //! ``` //! Because the subtrees won't be diffed, their "real node" data will be stale (invalid), so its up to the reconciler to //! track nodes created in a scope and clean up all relevant data. Support for this is currently WIP //! //! ## Bloom Filter and Heuristics //! ------------------------------ //! For all components, we employ some basic heuristics to speed up allocations and pre-size bump arenas. The heuristics are //! currently very rough, but will get better as time goes on. For FFI, we recommend using a bloom filter to cache strings. //! //! //! ## Garbage Collection //! --------------------- //! Dioxus uses a passive garbage collection system to clean up old nodes once the work has been completed. This garabge //! collection is done internally once the main diffing work is complete. After the "garbage" is collected, Dioxus will then //! start to re-use old keys for new nodes. This results in a passive memory management system that is very efficient. //! //! The IDs used by the key/map are just an index into a vec. This means that Dioxus will drive the key allocation strategy //! so the client only needs to maintain a simple list of nodes. By default, Dioxus will not manually clean up old nodes //! for the client. As new nodes are created, old nodes will be over-written. //! //! Further Reading and Thoughts //! ---------------------------- //! There are more ways of increasing diff performance here that are currently not implemented. //! More info on how to improve this diffing algorithm: //! - https://hacks.mozilla.org/2019/03/fast-bump-allocated-virtual-doms-with-rust-and-wasm/ use crate::{arena::SharedResources, innerlude::*}; use fxhash::{FxHashMap, FxHashSet}; use smallvec::{smallvec, SmallVec}; use std::{any::Any, borrow::Borrow}; /// Instead of having handles directly over nodes, Dioxus uses simple u32 as node IDs. /// The expectation is that the underlying renderer will mainain their Nodes in vec where the ids are the index. This allows /// for a form of passive garbage collection where nodes aren't immedately cleaned up. /// /// The "RealDom" abstracts over the... real dom. The RealDom trait assumes that the renderer maintains a stack of real /// nodes as the diffing algorithm descenes through the tree. This means that whatever is on top of the stack will receive /// any modifications that follow. This technique enables the diffing algorithm to avoid directly handling or storing any /// target-specific Node type as well as easily serializing the edits to be sent over a network or IPC connection. pub trait RealDom<'a> { fn raw_node_as_any(&self) -> &mut dyn Any; } pub struct DiffMachine<'real, 'bump> { pub real_dom: &'real dyn RealDom<'bump>, pub vdom: &'bump SharedResources, pub edits: DomEditor<'real, 'bump>, pub scheduled_garbage: Vec<&'bump VNode<'bump>>, pub cur_idxs: SmallVec<[ScopeId; 5]>, pub diffed: FxHashSet, pub seen_nodes: FxHashSet, } impl<'r, 'b> DiffMachine<'r, 'b> { pub fn get_scope_mut(&mut self, id: &ScopeId) -> Option<&'b mut Scope> { // ensure we haven't seen this scope before // if we have, then we're trying to alias it, which is not allowed // debug_assert!(!self.seen_nodes.contains(id)); unsafe { self.vdom.get_scope_mut(*id) } } pub fn get_scope(&mut self, id: &ScopeId) -> Option<&'b Scope> { // ensure we haven't seen this scope before // if we have, then we're trying to alias it, which is not allowed unsafe { self.vdom.get_scope(*id) } } } impl<'real, 'bump> DiffMachine<'real, 'bump> { pub fn new( edits: &'real mut Vec>, dom: &'real dyn RealDom<'bump>, cur_idx: ScopeId, shared: &'bump SharedResources, ) -> Self { Self { real_dom: dom, edits: DomEditor::new(edits), cur_idxs: smallvec![cur_idx], vdom: shared, scheduled_garbage: vec![], diffed: FxHashSet::default(), seen_nodes: FxHashSet::default(), } } // Diff the `old` node with the `new` node. Emits instructions to modify a // physical DOM node that reflects `old` into something that reflects `new`. // // the real stack should be what it is coming in and out of this function (ideally empty) // // each function call assumes the stack is fresh (empty). pub fn diff_node(&mut self, old_node: &'bump VNode<'bump>, new_node: &'bump VNode<'bump>) { // currently busted for components - need to fid let root = old_node.dom_id.get().expect(&format!( "Should not be diffing old nodes that were never assigned, {:#?}", old_node )); match (&old_node.kind, &new_node.kind) { // Handle the "sane" cases first. // The rsx and html macros strongly discourage dynamic lists not encapsulated by a "Fragment". // So the sane (and fast!) cases are where the virtual structure stays the same and is easily diffable. (VNodeKind::Text(old), VNodeKind::Text(new)) => { if old.text != new.text { self.edits.push_root(root); log::debug!("Text has changed {}, {}", old.text, new.text); self.edits.set_text(new.text); self.edits.pop(); } new_node.dom_id.set(Some(root)); } (VNodeKind::Element(old), VNodeKind::Element(new)) => { // If the element type is completely different, the element needs to be re-rendered completely // This is an optimization React makes due to how users structure their code // // In Dioxus, this is less likely to occur unless through a fragment if new.tag_name != old.tag_name || new.namespace != old.namespace { self.edits.push_root(root); let meta = self.create(new_node); self.edits.replace_with(meta.added_to_stack); self.scheduled_garbage.push(old_node); self.edits.pop(); return; } new_node.dom_id.set(Some(root)); // push it just in case // TODO: remove this - it clogs up things and is inefficient self.edits.push_root(root); self.diff_listeners(old.listeners, new.listeners); self.diff_attr(old.attributes, new.attributes, new.namespace); self.diff_children(old.children, new.children); self.edits.pop(); } (VNodeKind::Component(old), VNodeKind::Component(new)) => { log::warn!("diffing components? {:#?}", new.user_fc); if old.user_fc == new.user_fc { // Make sure we're dealing with the same component (by function pointer) self.cur_idxs.push(old.ass_scope.get().unwrap()); // Make sure the new component vnode is referencing the right scope id let scope_addr = old.ass_scope.get().unwrap(); new.ass_scope.set(Some(scope_addr)); // make sure the component's caller function is up to date let scope = self.get_scope_mut(&scope_addr).unwrap(); scope.caller = new.caller.clone(); // ack - this doesn't work on its own! scope.update_children(new.children); // React doesn't automatically memoize, but we do. let should_render = match old.comparator { Some(comparator) => comparator(new), None => true, }; if should_render { scope.run_scope().unwrap(); self.diff_node(scope.old_frame(), scope.next_frame()); } else { // } self.cur_idxs.pop(); self.seen_nodes.insert(scope_addr); } else { // this seems to be a fairy common code path that we could let mut old_iter = RealChildIterator::new(old_node, &self.vdom); let first = old_iter .next() .expect("Components should generate a placeholder root"); // remove any leftovers for to_remove in old_iter { self.edits.push_root(to_remove.element_id().unwrap()); self.edits.remove(); } // seems like we could combine this into a single instruction.... self.edits.push_root(first.element_id().unwrap()); let meta = self.create(new_node); self.edits.replace_with(meta.added_to_stack); self.scheduled_garbage.push(old_node); self.edits.pop(); // Wipe the old one and plant the new one let old_scope = old.ass_scope.get().unwrap(); self.destroy_scopes(old_scope); } } (VNodeKind::Fragment(old), VNodeKind::Fragment(new)) => { // This is the case where options or direct vnodes might be used. // In this case, it's faster to just skip ahead to their diff if old.children.len() == 1 && new.children.len() == 1 { self.diff_node(&old.children[0], &new.children[0]); return; } // Diff using the approach where we're looking for added or removed nodes. if old.children.len() != new.children.len() {} // Diff where we think the elements are the same if old.children.len() == new.children.len() {} self.diff_children(old.children, new.children); } // The strategy here is to pick the first possible node from the previous set and use that as our replace with root // // We also walk the "real node" list to make sure all latent roots are claened up // This covers the case any time a fragment or component shows up with pretty much anything else // // This likely isn't the fastest way to go about replacing one node with a virtual node, but the "insane" cases // are pretty rare. IE replacing a list (component or fragment) with a single node. ( VNodeKind::Component(_) | VNodeKind::Fragment(_) | VNodeKind::Text(_) | VNodeKind::Element(_), VNodeKind::Component(_) | VNodeKind::Fragment(_) | VNodeKind::Text(_) | VNodeKind::Element(_), ) => { // Choose the node to use as the placeholder for replacewith let back_node_id = match old_node.kind { // We special case these two types to avoid allocating the small-vecs VNodeKind::Element(_) | VNodeKind::Text(_) => root, _ => { let mut old_iter = RealChildIterator::new(old_node, &self.vdom); let back_node = old_iter .next() .expect("Empty fragments should generate a placeholder."); // remove any leftovers for to_remove in old_iter { self.edits.push_root(to_remove.element_id().unwrap()); self.edits.remove(); } back_node.element_id().unwrap() } }; // replace the placeholder or first node with the nodes generated from the "new" self.edits.push_root(back_node_id); let meta = self.create(new_node); self.edits.replace_with(meta.added_to_stack); // todo use the is_static metadata to update this subtree } // TODO (VNodeKind::Suspended { node }, new) => todo!(), (old, VNodeKind::Suspended { .. }) => { // a node that was once real is now suspended // } } } } // When we create new nodes, we need to propagate some information back up the call chain. // This gives the caller some information on how to handle things like insertins, appending, and subtree discarding. pub struct CreateMeta { pub is_static: bool, pub added_to_stack: u32, } impl CreateMeta { fn new(is_static: bool, added_to_tack: u32) -> Self { Self { is_static, added_to_stack: added_to_tack, } } } impl<'real, 'bump> DiffMachine<'real, 'bump> { // Emit instructions to create the given virtual node. // // The change list stack may have any shape upon entering this function: // // [...] // // When this function returns, the new node is on top of the change list stack: // // [... node] pub fn create(&mut self, node: &'bump VNode<'bump>) -> CreateMeta { log::warn!("Creating node! ... {:#?}", node); match &node.kind { VNodeKind::Text(text) => { let real_id = self.vdom.reserve_node(); self.edits.create_text_node(text.text, real_id); node.dom_id.set(Some(real_id)); CreateMeta::new(text.is_static, 1) } VNodeKind::Element(el) => { // we have the potential to completely eliminate working on this node in the future(!) // // This can only be done if all of the elements properties (attrs, children, listeners, etc) are static // While creating these things, keep track if we can memoize this element. // At the end, we'll set this flag on the element to skip it let mut is_static: bool = true; let VElement { tag_name, listeners, attributes, children, namespace, static_attrs: _, static_children: _, static_listeners: _, } = el; let real_id = self.vdom.reserve_node(); if let Some(namespace) = namespace { self.edits .create_element(tag_name, Some(namespace), real_id) } else { self.edits.create_element(tag_name, None, real_id) }; node.dom_id.set(Some(real_id)); listeners.iter().enumerate().for_each(|(idx, listener)| { log::info!("setting listener id to {:#?}", real_id); listener.mounted_node.set(Some(real_id)); self.edits .new_event_listener(listener.event, listener.scope, idx, real_id); // if the node has an event listener, then it must be visited ? is_static = false; }); for attr in *attributes { is_static = is_static && attr.is_static; self.edits .set_attribute(&attr.name, &attr.value, *namespace); } // Fast path: if there is a single text child, it is faster to // create-and-append the text node all at once via setting the // parent's `textContent` in a single change list instruction than // to emit three instructions to (1) create a text node, (2) set its // text content, and finally (3) append the text node to this // parent. // // Notice: this is a web-specific optimization and may be changed in the future // // TODO move over // if children.len() == 1 { // if let VNodeKind::Text(text) = &children[0].kind { // self.edits.set_text(text.text); // return CreateMeta::new(is_static, 1); // } // } for child in *children { let child_meta = self.create(child); is_static = is_static && child_meta.is_static; // append whatever children were generated by this call self.edits.append_children(child_meta.added_to_stack); } // if is_static { // log::debug!("created a static node {:#?}", node); // } else { // log::debug!("created a dynamic node {:#?}", node); // } // el_is_static.set(is_static); CreateMeta::new(is_static, 1) } VNodeKind::Component(vcomponent) => { log::debug!("Mounting a new component"); let caller = vcomponent.caller.clone(); let parent_idx = self.cur_idxs.last().unwrap().clone(); // Insert a new scope into our component list let new_idx = self.vdom.insert_scope_with_key(|new_idx| { let parent_scope = self.get_scope(&parent_idx).unwrap(); let height = parent_scope.height + 1; Scope::new( caller, new_idx, Some(parent_idx), height, vcomponent.children, self.vdom.clone(), ) }); // This code is supposed to insert the new idx into the parent's descendent list, but it doesn't really work. // This is mostly used for cleanup - to remove old scopes when components are destroyed. // TODO // // self.components // .try_get_mut(idx) // .unwrap() // .descendents // .borrow_mut() // .insert(idx); // TODO: abstract this unsafe into the arena abstraction let new_component = self.get_scope_mut(&new_idx).unwrap(); // Actually initialize the caller's slot with the right address vcomponent.ass_scope.set(Some(new_idx)); // Run the scope for one iteration to initialize it new_component.run_scope().unwrap(); // TODO: we need to delete (IE relcaim this node, otherwise the arena will grow infinitely) let nextnode = new_component.next_frame(); self.cur_idxs.push(new_idx); let meta = self.create(nextnode); self.cur_idxs.pop(); // Finally, insert this node as a seen node. self.seen_nodes.insert(new_idx); CreateMeta::new(vcomponent.is_static, meta.added_to_stack) } // Fragments are the only nodes that can contain dynamic content (IE through curlies or iterators). // We can never ignore their contents, so the prescence of a fragment indicates that we need always diff them. // Fragments will just put all their nodes onto the stack after creation VNodeKind::Fragment(frag) => { let mut nodes_added = 0; for child in frag.children.iter().rev() { // different types of nodes will generate different amounts on the stack // nested fragments will spew a ton of nodes onto the stack // TODO: make sure that our order (.rev) makes sense in a nested situation let new_meta = self.create(child); nodes_added += new_meta.added_to_stack; } log::info!("This fragment added {} nodes to the stack", nodes_added); // Never ignore CreateMeta::new(false, nodes_added) } VNodeKind::Suspended { node: real_node } => { let id = self.vdom.reserve_node(); self.edits.create_placeholder(id); node.dom_id.set(Some(id)); real_node.set(Some(id)); CreateMeta::new(false, 1) } } } } impl<'a, 'bump> DiffMachine<'a, 'bump> { /// Destroy a scope and all of its descendents. /// /// 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. fn destroy_scopes(&mut self, old_scope: ScopeId) { let mut nodes_to_delete = vec![old_scope]; let mut scopes_to_explore = vec![old_scope]; // explore the scope tree breadth first while let Some(scope_id) = scopes_to_explore.pop() { // If we're planning on deleting this node, then we don't need to both rendering it self.seen_nodes.insert(scope_id); let scope = self.get_scope(&scope_id).unwrap(); for child in scope.descendents.borrow().iter() { // Add this node to be explored scopes_to_explore.push(child.clone()); // Also add it for deletion nodes_to_delete.push(child.clone()); } } // Delete all scopes that we found as part of this subtree for node in nodes_to_delete { log::debug!("Removing scope {:#?}", node); let _scope = self.vdom.try_remove(node).unwrap(); // do anything we need to do to delete the scope // I think we need to run the destructors on the hooks // TODO } } // Diff event listeners between `old` and `new`. // // The listeners' node must be on top of the change list stack: // // [... node] // // The change list stack is left unchanged. fn diff_listeners(&mut self, old: &[Listener<'_>], new: &[Listener<'_>]) { if !old.is_empty() || !new.is_empty() { // self.edits.commit_traversal(); } // TODO // what does "diffing listeners" even mean? 'outer1: for (_l_idx, new_l) in new.iter().enumerate() { // go through each new listener // find its corresponding partner in the old list // if any characteristics changed, remove and then re-add // if nothing changed, then just move on let _event_type = new_l.event; for old_l in old { if new_l.event == old_l.event { new_l.mounted_node.set(old_l.mounted_node.get()); // if new_l.id != old_l.id { // self.edits.remove_event_listener(event_type); // // TODO! we need to mess with events and assign them by ElementId // // self.edits // // .update_event_listener(event_type, new_l.scope, new_l.id) // } continue 'outer1; } } // self.edits // .new_event_listener(event_type, new_l.scope, new_l.id); } // 'outer2: for old_l in old { // for new_l in new { // if new_l.event == old_l.event { // continue 'outer2; // } // } // self.edits.remove_event_listener(old_l.event); // } } // Diff a node's attributes. // // The attributes' node must be on top of the change list stack: // // [... node] // // The change list stack is left unchanged. fn diff_attr( &mut self, old: &'bump [Attribute<'bump>], new: &'bump [Attribute<'bump>], namespace: Option<&'static str>, ) { // Do O(n^2) passes to add/update and remove attributes, since // there are almost always very few attributes. // // The "fast" path is when the list of attributes name is identical and in the same order // With the Rsx and Html macros, this will almost always be the case 'outer: for new_attr in new { if new_attr.is_volatile { // self.edits.commit_traversal(); self.edits .set_attribute(new_attr.name, new_attr.value, namespace); } else { for old_attr in old { if old_attr.name == new_attr.name { if old_attr.value != new_attr.value { // self.edits.commit_traversal(); self.edits .set_attribute(new_attr.name, new_attr.value, namespace); } continue 'outer; } else { // names are different, a varying order of attributes has arrived } } // self.edits.commit_traversal(); self.edits .set_attribute(new_attr.name, new_attr.value, namespace); } } 'outer2: for old_attr in old { for new_attr in new { if old_attr.name == new_attr.name { continue 'outer2; } } // self.edits.commit_traversal(); self.edits.remove_attribute(old_attr.name); } } // Diff the given set of old and new children. // // The parent must be on top of the change list stack when this function is // entered: // // [... parent] // // the change list stack is in the same state when this function returns. fn diff_children(&mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) { if new.is_empty() { if !old.is_empty() { // self.edits.commit_traversal(); self.remove_all_children(old); } return; } if new.len() == 1 { match (&old.first(), &new[0]) { // (Some(VNodeKind::Text(old_vtext)), VNodeKind::Text(new_vtext)) // if old_vtext.text == new_vtext.text => // { // // Don't take this fast path... // } // (_, VNodeKind::Text(text)) => { // // self.edits.commit_traversal(); // log::debug!("using optimized text set"); // self.edits.set_text(text.text); // return; // } // todo: any more optimizations (_, _) => {} } } if old.is_empty() { if !new.is_empty() { // self.edits.commit_traversal(); self.create_and_append_children(new); } return; } let new_is_keyed = new[0].key.is_some(); let old_is_keyed = old[0].key.is_some(); debug_assert!( new.iter().all(|n| n.key.is_some() == new_is_keyed), "all siblings must be keyed or all siblings must be non-keyed" ); debug_assert!( old.iter().all(|o| o.key.is_some() == old_is_keyed), "all siblings must be keyed or all siblings must be non-keyed" ); if new_is_keyed && old_is_keyed { log::warn!("using the wrong approach"); self.diff_non_keyed_children(old, new); // todo!("Not yet implemented a migration away from temporaries"); // let t = self.edits.next_temporary(); // self.diff_keyed_children(old, new); // self.edits.set_next_temporary(t); } else { // log::debug!("diffing non keyed children"); self.diff_non_keyed_children(old, new); } } // Diffing "keyed" children. // // With keyed children, we care about whether we delete, move, or create nodes // versus mutate existing nodes in place. Presumably there is some sort of CSS // transition animation that makes the virtual DOM diffing algorithm // observable. By specifying keys for nodes, we know which virtual DOM nodes // must reuse (or not reuse) the same physical DOM nodes. // // This is loosely based on Inferno's keyed patching implementation. However, we // have to modify the algorithm since we are compiling the diff down into change // list instructions that will be executed later, rather than applying the // changes to the DOM directly as we compare virtual DOMs. // // https://github.com/infernojs/inferno/blob/36fd96/packages/inferno/src/DOM/patching.ts#L530-L739 // // When entering this function, the parent must be on top of the change list // stack: // // [... parent] // // Upon exiting, the change list stack is in the same state. fn diff_keyed_children(&mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) { if cfg!(debug_assertions) { let mut keys = fxhash::FxHashSet::default(); let mut assert_unique_keys = |children: &'bump [VNode<'bump>]| { keys.clear(); for child in children { let key = child.key; debug_assert!( key.is_some(), "if any sibling is keyed, all siblings must be keyed" ); keys.insert(key); } debug_assert_eq!( children.len(), keys.len(), "keyed siblings must each have a unique key" ); }; assert_unique_keys(old); assert_unique_keys(new); } // First up, we diff all the nodes with the same key at the beginning of the // children. // // `shared_prefix_count` is the count of how many nodes at the start of // `new` and `old` share the same keys. let shared_prefix_count = match self.diff_keyed_prefix(old, new) { KeyedPrefixResult::Finished => return, KeyedPrefixResult::MoreWorkToDo(count) => count, }; // Next, we find out how many of the nodes at the end of the children have // the same key. We do _not_ diff them yet, since we want to emit the change // list instructions such that they can be applied in a single pass over the // DOM. Instead, we just save this information for later. // // `shared_suffix_count` is the count of how many nodes at the end of `new` // and `old` share the same keys. let shared_suffix_count = old[shared_prefix_count..] .iter() .rev() .zip(new[shared_prefix_count..].iter().rev()) .take_while(|&(old, new)| old.key == new.key) .count(); let old_shared_suffix_start = old.len() - shared_suffix_count; let new_shared_suffix_start = new.len() - shared_suffix_count; // Ok, we now hopefully have a smaller range of children in the middle // within which to re-order nodes with the same keys, remove old nodes with // now-unused keys, and create new nodes with fresh keys. self.diff_keyed_middle( &old[shared_prefix_count..old_shared_suffix_start], &new[shared_prefix_count..new_shared_suffix_start], shared_prefix_count, shared_suffix_count, old_shared_suffix_start, ); // Finally, diff the nodes at the end of `old` and `new` that share keys. let old_suffix = &old[old_shared_suffix_start..]; let new_suffix = &new[new_shared_suffix_start..]; debug_assert_eq!(old_suffix.len(), new_suffix.len()); if !old_suffix.is_empty() { self.diff_keyed_suffix(old_suffix, new_suffix, new_shared_suffix_start) } } // Diff the prefix of children in `new` and `old` that share the same keys in // the same order. // // Upon entry of this function, the change list stack must be: // // [... parent] // // Upon exit, the change list stack is the same. fn diff_keyed_prefix( &mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>], ) -> KeyedPrefixResult { // self.edits.go_down(); let mut shared_prefix_count = 0; for (i, (old, new)) in old.iter().zip(new.iter()).enumerate() { // abort early if we finally run into nodes with different keys if old.key() != new.key() { break; } // self.edits.go_to_sibling(i); self.diff_node(old, new); shared_prefix_count += 1; } // If that was all of the old children, then create and append the remaining // new children and we're finished. if shared_prefix_count == old.len() { // self.edits.go_up(); // self.edits.commit_traversal(); self.create_and_append_children(&new[shared_prefix_count..]); return KeyedPrefixResult::Finished; } // And if that was all of the new children, then remove all of the remaining // old children and we're finished. if shared_prefix_count == new.len() { // self.edits.go_to_sibling(shared_prefix_count); // self.edits.commit_traversal(); self.remove_self_and_next_siblings(&old[shared_prefix_count..]); return KeyedPrefixResult::Finished; } // // self.edits.go_up(); KeyedPrefixResult::MoreWorkToDo(shared_prefix_count) } // Remove all of a node's children. // // The change list stack must have this shape upon entry to this function: // // [... parent] // // When this function returns, the change list stack is in the same state. pub fn remove_all_children(&mut self, old: &'bump [VNode<'bump>]) { // debug_assert!(self.edits.traversal_is_committed()); log::debug!("REMOVING CHILDREN"); for _child in old { // registry.remove_subtree(child); } // Fast way to remove all children: set the node's textContent to an empty // string. todo!() // self.edits.set_inner_text(""); } // Create the given children and append them to the parent node. // // The parent node must currently be on top of the change list stack: // // [... parent] // // When this function returns, the change list stack is in the same state. pub fn create_and_append_children(&mut self, new: &'bump [VNode<'bump>]) { for child in new { let meta = self.create(child); self.edits.append_children(meta.added_to_stack); } } // The most-general, expensive code path for keyed children diffing. // // We find the longest subsequence within `old` of children that are relatively // ordered the same way in `new` (via finding a longest-increasing-subsequence // of the old child's index within `new`). The children that are elements of // this subsequence will remain in place, minimizing the number of DOM moves we // will have to do. // // Upon entry to this function, the change list stack must be: // // [... parent] // // Upon exit from this function, it will be restored to that same state. fn diff_keyed_middle( &self, old: &[VNode<'bump>], new: &[VNode<'bump>], shared_prefix_count: usize, shared_suffix_count: usize, old_shared_suffix_start: usize, ) { // // Should have already diffed the shared-key prefixes and suffixes. // debug_assert_ne!(new.first().map(|n| n.key()), old.first().map(|o| o.key())); // debug_assert_ne!(new.last().map(|n| n.key()), old.last().map(|o| o.key())); // // The algorithm below relies upon using `u32::MAX` as a sentinel // // value, so if we have that many new nodes, it won't work. This // // check is a bit academic (hence only enabled in debug), since // // wasm32 doesn't have enough address space to hold that many nodes // // in memory. // debug_assert!(new.len() < u32::MAX as usize); // // Map from each `old` node's key to its index within `old`. // // IE if the keys were A B C, then we would have (A, 1) (B, 2) (C, 3). // let mut old_key_to_old_index = old // .iter() // .enumerate() // .map(|(i, o)| (o.key(), i)) // .collect::>(); // // The set of shared keys between `new` and `old`. // let mut shared_keys = FxHashSet::default(); // // Map from each index in `new` to the index of the node in `old` that // // has the same key. // let mut new_index_to_old_index = new // .iter() // .map(|n| { // let key = n.key(); // if let Some(&i) = old_key_to_old_index.get(&key) { // shared_keys.insert(key); // i // } else { // u32::MAX as usize // } // }) // .collect::>(); // // If none of the old keys are reused by the new children, then we // // remove all the remaining old children and create the new children // // afresh. // if shared_suffix_count == 0 && shared_keys.is_empty() { // if shared_prefix_count == 0 { // // self.edits.commit_traversal(); // self.remove_all_children(old); // } else { // // self.edits.go_down_to_child(shared_prefix_count); // // self.edits.commit_traversal(); // self.remove_self_and_next_siblings(&old[shared_prefix_count..]); // } // self.create_and_append_children(new); // return; // } // // Save each of the old children whose keys are reused in the new // // children. // let mut old_index_to_temp = vec![u32::MAX; old.len()]; // let mut start = 0; // loop { // let end = (start..old.len()) // .find(|&i| { // let key = old[i].key(); // !shared_keys.contains(&key) // }) // .unwrap_or(old.len()); // if end - start > 0 { // // self.edits.commit_traversal(); // let mut t = self.edits.save_children_to_temporaries( // shared_prefix_count + start, // shared_prefix_count + end, // ); // for i in start..end { // old_index_to_temp[i] = t; // t += 1; // } // } // debug_assert!(end <= old.len()); // if end == old.len() { // break; // } else { // start = end + 1; // } // } // // Remove any old children whose keys were not reused in the new // // children. Remove from the end first so that we don't mess up indices. // let mut removed_count = 0; // for (i, old_child) in old.iter().enumerate().rev() { // if !shared_keys.contains(&old_child.key()) { // // registry.remove_subtree(old_child); // // todo // // self.edits.commit_traversal(); // self.edits.remove(old_child.dom_id.get()); // self.edits.remove_child(i + shared_prefix_count); // removed_count += 1; // } // } // // If there aren't any more new children, then we are done! // if new.is_empty() { // return; // } // // The longest increasing subsequence within `new_index_to_old_index`. This // // is the longest sequence on DOM nodes in `old` that are relatively ordered // // correctly within `new`. We will leave these nodes in place in the DOM, // // and only move nodes that are not part of the LIS. This results in the // // maximum number of DOM nodes left in place, AKA the minimum number of DOM // // nodes moved. // let mut new_index_is_in_lis = FxHashSet::default(); // new_index_is_in_lis.reserve(new_index_to_old_index.len()); // let mut predecessors = vec![0; new_index_to_old_index.len()]; // let mut starts = vec![0; new_index_to_old_index.len()]; // longest_increasing_subsequence::lis_with( // &new_index_to_old_index, // &mut new_index_is_in_lis, // |a, b| a < b, // &mut predecessors, // &mut starts, // ); // // Now we will iterate from the end of the new children back to the // // beginning, diffing old children we are reusing and if they aren't in the // // LIS moving them to their new destination, or creating new children. Note // // that iterating in reverse order lets us use `Node.prototype.insertBefore` // // to move/insert children. // // // // But first, we ensure that we have a child on the change list stack that // // we can `insertBefore`. We handle this once before looping over `new` // // children, so that we don't have to keep checking on every loop iteration. // if shared_suffix_count > 0 { // // There is a shared suffix after these middle children. We will be // // inserting before that shared suffix, so add the first child of that // // shared suffix to the change list stack. // // // // [... parent] // self.edits // .go_down_to_child(old_shared_suffix_start - removed_count); // // [... parent first_child_of_shared_suffix] // } else { // // There is no shared suffix coming after these middle children. // // Therefore we have to process the last child in `new` and move it to // // the end of the parent's children if it isn't already there. // let last_index = new.len() - 1; // // uhhhh why an unwrap? // let last = new.last().unwrap(); // // let last = new.last().unwrap_throw(); // new = &new[..new.len() - 1]; // if shared_keys.contains(&last.key()) { // let old_index = new_index_to_old_index[last_index]; // let temp = old_index_to_temp[old_index]; // // [... parent] // self.edits.go_down_to_temp_child(temp); // // [... parent last] // self.diff_node(&old[old_index], last); // if new_index_is_in_lis.contains(&last_index) { // // Don't move it, since it is already where it needs to be. // } else { // // self.edits.commit_traversal(); // // [... parent last] // self.edits.append_child(); // // [... parent] // self.edits.go_down_to_temp_child(temp); // // [... parent last] // } // } else { // // self.edits.commit_traversal(); // // [... parent] // self.create(last); // // [... parent last] // self.edits.append_child(); // // [... parent] // self.edits.go_down_to_reverse_child(0); // // [... parent last] // } // } // for (new_index, new_child) in new.iter().enumerate().rev() { // let old_index = new_index_to_old_index[new_index]; // if old_index == u32::MAX as usize { // debug_assert!(!shared_keys.contains(&new_child.key())); // // self.edits.commit_traversal(); // // [... parent successor] // self.create(new_child); // // [... parent successor new_child] // self.edits.insert_before(); // // [... parent new_child] // } else { // debug_assert!(shared_keys.contains(&new_child.key())); // let temp = old_index_to_temp[old_index]; // debug_assert_ne!(temp, u32::MAX); // if new_index_is_in_lis.contains(&new_index) { // // [... parent successor] // self.edits.go_to_temp_sibling(temp); // // [... parent new_child] // } else { // // self.edits.commit_traversal(); // // [... parent successor] // self.edits.push_temporary(temp); // // [... parent successor new_child] // self.edits.insert_before(); // // [... parent new_child] // } // self.diff_node(&old[old_index], new_child); // } // } } // Diff the suffix of keyed children that share the same keys in the same order. // // The parent must be on the change list stack when we enter this function: // // [... parent] // // When this function exits, the change list stack remains the same. fn diff_keyed_suffix( &mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>], new_shared_suffix_start: usize, ) { debug_assert_eq!(old.len(), new.len()); debug_assert!(!old.is_empty()); for (i, (old_child, new_child)) in old.iter().zip(new.iter()).enumerate() { self.diff_node(old_child, new_child); } } // Diff children that are not keyed. // // The parent must be on the top of the change list stack when entering this // function: // // [... parent] // // the change list stack is in the same state when this function returns. fn diff_non_keyed_children(&mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) { // Handled these cases in `diff_children` before calling this function. debug_assert!(!new.is_empty()); debug_assert!(!old.is_empty()); // [... parent] // self.edits.go_down(); // self.edits.push_root() // [... parent child] // todo!() for (_i, (new_child, old_child)) in new.iter().zip(old.iter()).enumerate() { // [... parent prev_child] // self.edits.go_to_sibling(i); // [... parent this_child] // let did = old_child.get_mounted_id(self.components).unwrap(); // if did.0 == 0 { // log::debug!("Root is bad: {:#?}", old_child); // } // self.edits.push_root(did); self.diff_node(old_child, new_child); // let old_id = old_child.get_mounted_id(self.components).unwrap(); // let new_id = new_child.get_mounted_id(self.components).unwrap(); // log::debug!( // "pushed root. {:?}, {:?}", // old_child.get_mounted_id(self.components).unwrap(), // new_child.get_mounted_id(self.components).unwrap() // ); // if old_id != new_id { // log::debug!("Mismatch: {:?}", new_child); // } } // match old.len().cmp(&new.len()) { // // old.len > new.len -> removing some nodes // Ordering::Greater => { // // [... parent prev_child] // self.edits.go_to_sibling(new.len()); // // [... parent first_child_to_remove] // // self.edits.commit_traversal(); // // support::remove_self_and_next_siblings(state, &old[new.len()..]); // self.remove_self_and_next_siblings(&old[new.len()..]); // // [... parent] // } // // old.len < new.len -> adding some nodes // Ordering::Less => { // // [... parent last_child] // self.edits.go_up(); // // [... parent] // // self.edits.commit_traversal(); // self.create_and_append_children(&new[old.len()..]); // } // // old.len == new.len -> no nodes added/removed, but πerhaps changed // Ordering::Equal => { // // [... parent child] // self.edits.go_up(); // // [... parent] // } // } } // ====================== // Support methods // ====================== // Remove the current child and all of its following siblings. // // The change list stack must have this shape upon entry to this function: // // [... parent child] // // After the function returns, the child is no longer on the change list stack: // // [... parent] pub fn remove_self_and_next_siblings(&self, old: &[VNode<'bump>]) { // debug_assert!(self.edits.traversal_is_committed()); for child in old { if let VNodeKind::Component(_vcomp) = child.kind { // dom // .create_text_node("placeholder for vcomponent"); todo!() // let root_id = vcomp.stable_addr.as_ref().borrow().unwrap(); // self.lifecycle_events.push_back(LifeCycleEvent::Remove { // root_id, // stable_scope_addr: Rc::downgrade(&vcomp.ass_scope), // }) // let id = get_id(); // *component.stable_addr.as_ref().borrow_mut() = Some(id); // self.edits.save_known_root(id); // let scope = Rc::downgrade(&component.ass_scope); // self.lifecycle_events.push_back(LifeCycleEvent::Mount { // caller: Rc::downgrade(&component.caller), // root_id: id, // stable_scope_addr: scope, // }); } // registry.remove_subtree(child); } todo!() // self.edits.remove_self_and_next_siblings(); } } enum KeyedPrefixResult { // Fast path: we finished diffing all the children just by looking at the // prefix of shared keys! Finished, // There is more diffing work to do. Here is a count of how many children at // the beginning of `new` and `old` we already processed. MoreWorkToDo(usize), } /// This iterator iterates through a list of virtual children and only returns real children (Elements or Text). /// /// This iterator is useful when it's important to load the next real root onto the top of the stack for operations like /// "InsertBefore". struct RealChildIterator<'a> { scopes: &'a SharedResources, // Heuristcally we should never bleed into 4 completely nested fragments/components // Smallvec lets us stack allocate our little stack machine so the vast majority of cases are sane // TODO: use const generics instead of the 4 estimation stack: smallvec::SmallVec<[(u16, &'a VNode<'a>); 4]>, } impl<'a> RealChildIterator<'a> { fn new(starter: &'a VNode<'a>, scopes: &'a SharedResources) -> Self { Self { scopes, stack: smallvec::smallvec![(0, starter)], } } } impl<'a> Iterator for RealChildIterator<'a> { type Item = &'a VNode<'a>; fn next(&mut self) -> Option<&'a VNode<'a>> { let mut should_pop = false; let mut returned_node: Option<&'a VNode<'a>> = None; let mut should_push = None; while returned_node.is_none() { if let Some((count, node)) = self.stack.last_mut() { match &node.kind { // We can only exit our looping when we get "real" nodes // This includes fragments and components when they're empty (have a single root) VNodeKind::Element(_) | VNodeKind::Text(_) => { // We've recursed INTO an element/text // We need to recurse *out* of it and move forward to the next should_pop = true; returned_node = Some(&*node); } // If we get a fragment we push the next child VNodeKind::Fragment(frag) => { let subcount = *count as usize; if frag.children.len() == 0 { should_pop = true; returned_node = Some(&*node); } if subcount >= frag.children.len() { should_pop = true; } else { should_push = Some(&frag.children[subcount]); } } // Immediately abort suspended nodes - can't do anything with them yet // VNodeKind::Suspended => should_pop = true, VNodeKind::Suspended { node, .. } => { todo!() // *node = node.as_ref().borrow().get().expect("msg"); } // For components, we load their root and push them onto the stack VNodeKind::Component(sc) => { let scope = unsafe { self.scopes.get_scope(sc.ass_scope.get().unwrap()) }.unwrap(); // let scope = self.scopes.get(sc.ass_scope.get().unwrap()).unwrap(); // Simply swap the current node on the stack with the root of the component *node = scope.root(); } } } 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 } } fn compare_strs(a: &str, b: &str) -> bool { // Check by pointer, optimizing for static strs if !std::ptr::eq(a, b) { // If the pointers are different then check by value a == b } else { true } }