2021-08-20 15:39:13 +00:00
|
|
|
//! This module contains the stateful DiffMachine and all methods to diff VNodes, their properties, and their children.
|
2021-08-18 02:25:09 +00:00
|
|
|
//!
|
2021-08-20 15:39:13 +00:00
|
|
|
//! The [`DiffMachine`] calculates the diffs between the old and new frames, updates the new nodes, and generates a set
|
2021-08-18 02:25:09 +00:00
|
|
|
//! of mutations for the RealDom to apply.
|
2021-06-16 15:19:37 +00:00
|
|
|
//!
|
2021-07-12 06:23:46 +00:00
|
|
|
//! ## Notice:
|
2021-08-20 15:39:13 +00:00
|
|
|
//!
|
2021-06-27 02:13:57 +00:00
|
|
|
//! The inspiration and code for this module was originally taken from Dodrio (@fitzgen) and then modified to support
|
2021-10-24 17:30:36 +00:00
|
|
|
//! Components, Fragments, Suspense, SubTree memoization, incremental diffing, cancellation, NodeRefs, pausing, priority
|
2021-08-24 15:03:19 +00:00
|
|
|
//! scheduling, and additional batching operations.
|
2021-06-16 15:19:37 +00:00
|
|
|
//!
|
2021-07-11 18:49:52 +00:00
|
|
|
//! ## Implementation Details:
|
|
|
|
//!
|
|
|
|
//! ### IDs for elements
|
2021-07-12 06:23:46 +00:00
|
|
|
//! --------------------
|
2021-06-20 05:52:32 +00:00
|
|
|
//! All nodes are addressed by their IDs. The RealDom provides an imperative interface for making changes to these nodes.
|
2021-08-21 15:29:29 +00:00
|
|
|
//! We don't necessarily require that DOM changes happen instantly during the diffing process, so the implementor may choose
|
2021-10-24 17:30:36 +00:00
|
|
|
//! to batch nodes if it is more performant for their application. The element IDs are indices into the internal element
|
|
|
|
//! array. The expectation is that implementors will use the ID as an index into a Vec of real nodes, allowing for passive
|
2021-08-18 02:25:09 +00:00
|
|
|
//! garbage collection as the VirtualDOM replaces old nodes.
|
2021-07-11 18:49:52 +00:00
|
|
|
//!
|
2021-08-18 02:25:09 +00:00
|
|
|
//! When new vnodes are created through `cx.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.
|
2021-07-11 18:49:52 +00:00
|
|
|
//!
|
2021-07-29 22:04:09 +00:00
|
|
|
//! ### Fragment Support
|
2021-08-20 15:39:13 +00:00
|
|
|
//! --------------------
|
2021-07-29 22:04:09 +00:00
|
|
|
//! Fragments (nodes without a parent) are supported through a combination of "replace with" and anchor vnodes. Fragments
|
2021-08-20 15:39:13 +00:00
|
|
|
//! can be particularly challenging when they are empty, so the anchor node lets us "reserve" a spot for the empty
|
2021-07-29 22:04:09 +00:00
|
|
|
//! fragment to be replaced with when it is no longer empty. This is guaranteed by logic in the NodeFactory - it is
|
2021-08-20 15:39:13 +00:00
|
|
|
//! impossible to craft a fragment with 0 elements - they must always have at least a single placeholder element. Adding
|
|
|
|
//! "dummy" nodes _is_ inefficient, but it makes our diffing algorithm faster and the implementation is completely up to
|
2021-10-24 17:30:36 +00:00
|
|
|
//! the platform.
|
2021-07-29 22:04:09 +00:00
|
|
|
//!
|
2021-08-18 02:25:09 +00:00
|
|
|
//! Other implementations either don't support fragments or use a "child + sibling" pattern to represent them. Our code is
|
|
|
|
//! vastly simpler and more performant when we can just create a placeholder element while the fragment has no children.
|
|
|
|
//!
|
2021-08-22 03:04:34 +00:00
|
|
|
//! ### Suspense
|
|
|
|
//! ------------
|
2021-10-24 17:30:36 +00:00
|
|
|
//! Dioxus implements Suspense slightly differently than React. In React, each fiber is manually progressed until it runs
|
2021-08-22 03:04:34 +00:00
|
|
|
//! into a promise-like value. React will then work on the next "ready" fiber, checking back on the previous fiber once
|
|
|
|
//! it has finished its new work. In Dioxus, we use a similar approach, but try to completely render the tree before
|
|
|
|
//! switching sub-fibers. Instead, each future is submitted into a futures-queue and the node is manually loaded later on.
|
2021-10-24 17:30:36 +00:00
|
|
|
//! Due to the frequent calls to "yield_now" we can get the pure "fetch-as-you-render" behavior of React Fiber.
|
2021-08-22 03:04:34 +00:00
|
|
|
//!
|
|
|
|
//! We're able to use this approach because we use placeholder nodes - futures that aren't ready still get submitted to
|
|
|
|
//! DOM, but as a placeholder.
|
|
|
|
//!
|
2021-10-24 17:30:36 +00:00
|
|
|
//! Right now, the "suspense" queue is intertwined with hooks. In the future, we should allow any future to drive attributes
|
|
|
|
//! and contents, without the need for the "use_suspense" hook. In the interim, this is the quickest way to get Suspense working.
|
2021-08-22 03:04:34 +00:00
|
|
|
//!
|
2021-07-11 18:49:52 +00:00
|
|
|
//! ## Subtree Memoization
|
2021-07-12 06:23:46 +00:00
|
|
|
//! -----------------------
|
2021-10-24 17:30:36 +00:00
|
|
|
//! We also employ "subtree memoization" which saves us from having to check trees which hold no dynamic content. We can
|
2021-07-11 18:49:52 +00:00
|
|
|
//! detect if a subtree is "static" by checking if its children are "static". Since we dive into the tree depth-first, the
|
2021-10-24 17:30:36 +00:00
|
|
|
//! calls to "create" propagate this information upwards. Structures like the one below are entirely static:
|
2021-07-11 18:49:52 +00:00
|
|
|
//! ```rust
|
|
|
|
//! rsx!( div { class: "hello world", "this node is entirely static" } )
|
|
|
|
//! ```
|
2021-10-24 17:30:36 +00:00
|
|
|
//! Because the subtrees won't be diffed, their "real node" data will be stale (invalid), so it's up to the reconciler to
|
2021-08-18 02:25:09 +00:00
|
|
|
//! track nodes created in a scope and clean up all relevant data. Support for this is currently WIP and depends on comp-time
|
|
|
|
//! hashing of the subtree from the rsx! macro. We do a very limited form of static analysis via static string pointers as
|
2021-08-21 15:29:29 +00:00
|
|
|
//! a way of short-circuiting the most expensive checks.
|
2021-07-11 18:49:52 +00:00
|
|
|
//!
|
2021-07-12 06:23:46 +00:00
|
|
|
//! ## Bloom Filter and Heuristics
|
|
|
|
//! ------------------------------
|
|
|
|
//! For all components, we employ some basic heuristics to speed up allocations and pre-size bump arenas. The heuristics are
|
2021-08-18 02:25:09 +00:00
|
|
|
//! currently very rough, but will get better as time goes on. The information currently tracked includes the size of a
|
|
|
|
//! bump arena after first render, the number of hooks, and the number of nodes in the tree.
|
2021-07-24 04:29:23 +00:00
|
|
|
//!
|
2021-07-12 06:23:46 +00:00
|
|
|
//! ## Garbage Collection
|
|
|
|
//! ---------------------
|
2021-10-24 17:30:36 +00:00
|
|
|
//! Dioxus uses a passive garbage collection system to clean up old nodes once the work has been completed. This garbage
|
2021-07-23 21:03:51 +00:00
|
|
|
//! 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.
|
2021-02-15 04:39:46 +00:00
|
|
|
//!
|
2021-10-24 17:30:36 +00:00
|
|
|
//! The IDs used by the key/map are just an index into a Vec. This means that Dioxus will drive the key allocation strategy
|
2021-07-24 04:29:23 +00:00
|
|
|
//! 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.
|
2021-02-15 04:39:46 +00:00
|
|
|
//!
|
2021-08-20 15:39:13 +00:00
|
|
|
//! ## Further Reading and Thoughts
|
2021-06-16 15:19:37 +00:00
|
|
|
//! ----------------------------
|
2021-03-03 07:27:26 +00:00
|
|
|
//! There are more ways of increasing diff performance here that are currently not implemented.
|
2021-08-24 15:03:19 +00:00
|
|
|
//! - Strong memoization of subtrees.
|
|
|
|
//! - Guided diffing.
|
|
|
|
//! - Certain web-dom-specific optimizations.
|
|
|
|
//!
|
2021-03-03 07:27:26 +00:00
|
|
|
//! More info on how to improve this diffing algorithm:
|
|
|
|
//! - https://hacks.mozilla.org/2019/03/fast-bump-allocated-virtual-doms-with-rust-and-wasm/
|
2021-06-16 15:19:37 +00:00
|
|
|
|
2021-09-02 03:22:34 +00:00
|
|
|
use crate::innerlude::*;
|
2021-08-24 15:03:19 +00:00
|
|
|
use fxhash::{FxHashMap, FxHashSet};
|
2021-07-29 04:04:59 +00:00
|
|
|
use DomEdit::*;
|
2021-03-03 07:27:26 +00:00
|
|
|
|
2021-08-19 06:50:35 +00:00
|
|
|
/// Our DiffMachine is an iterative tree differ.
|
|
|
|
///
|
2021-08-20 15:39:13 +00:00
|
|
|
/// It uses techniques of a stack machine to allow pausing and restarting of the diff algorithm. This
|
2021-10-24 17:30:36 +00:00
|
|
|
/// was originally implemented using recursive techniques, but Rust lacks the ability to call async functions recursively,
|
2021-08-20 15:39:13 +00:00
|
|
|
/// meaning we could not "pause" the original diffing algorithm.
|
2021-08-19 06:50:35 +00:00
|
|
|
///
|
2021-08-20 14:34:41 +00:00
|
|
|
/// Instead, we use a traditional stack machine approach to diff and create new nodes. The diff algorithm periodically
|
|
|
|
/// calls "yield_now" which allows the machine to pause and return control to the caller. The caller can then wait for
|
2021-08-20 15:39:13 +00:00
|
|
|
/// the next period of idle time, preventing our diff algorithm from blocking the main thread.
|
|
|
|
///
|
|
|
|
/// Funnily enough, this stack machine's entire job is to create instructions for another stack machine to execute. It's
|
|
|
|
/// stack machines all the way down!
|
2021-11-07 00:59:46 +00:00
|
|
|
pub struct DiffState<'bump> {
|
2021-08-25 21:09:16 +00:00
|
|
|
pub mutations: Mutations<'bump>,
|
2021-11-07 00:59:46 +00:00
|
|
|
pub(crate) stack: DiffStack<'bump>,
|
2021-08-26 06:41:30 +00:00
|
|
|
pub seen_scopes: FxHashSet<ScopeId>,
|
2021-11-07 04:06:00 +00:00
|
|
|
pub force_diff: bool,
|
2021-11-07 00:59:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<'bump> DiffState<'bump> {
|
|
|
|
pub(crate) fn new(mutations: Mutations<'bump>) -> Self {
|
|
|
|
Self {
|
|
|
|
mutations,
|
|
|
|
stack: DiffStack::new(),
|
|
|
|
seen_scopes: Default::default(),
|
2021-11-07 04:06:00 +00:00
|
|
|
force_diff: false,
|
2021-09-13 04:59:08 +00:00
|
|
|
}
|
|
|
|
}
|
2021-08-26 06:41:30 +00:00
|
|
|
}
|
|
|
|
|
2021-11-07 04:06:00 +00:00
|
|
|
impl<'bump> ScopeArena {
|
|
|
|
pub fn diff_scope(&'bump self, state: &mut DiffState<'bump>, id: &ScopeId) {
|
|
|
|
if let Some(component) = self.get_scope(&id) {
|
2021-08-25 14:49:18 +00:00
|
|
|
let (old, new) = (component.frames.wip_head(), component.frames.fin_head());
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.push(DiffInstruction::Diff { new, old });
|
|
|
|
self.work(state, || false);
|
2021-08-25 14:49:18 +00:00
|
|
|
}
|
2021-08-06 02:23:41 +00:00
|
|
|
}
|
|
|
|
|
2021-08-19 06:50:35 +00:00
|
|
|
/// Progress the diffing for this "fiber"
|
|
|
|
///
|
|
|
|
/// This method implements a depth-first iterative tree traversal.
|
|
|
|
///
|
2021-08-22 03:04:34 +00:00
|
|
|
/// We do depth-first to maintain high cache locality (nodes were originally generated recursively).
|
2021-09-02 03:22:34 +00:00
|
|
|
///
|
|
|
|
/// Returns a `bool` indicating that the work completed properly.
|
2021-11-07 00:59:46 +00:00
|
|
|
pub fn work(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
mut deadline_expired: impl FnMut() -> bool,
|
|
|
|
) -> bool {
|
|
|
|
while let Some(instruction) = state.stack.pop() {
|
2021-08-21 17:24:47 +00:00
|
|
|
match instruction {
|
2021-11-07 00:59:46 +00:00
|
|
|
DiffInstruction::Diff { old, new } => self.diff_node(state, old, new),
|
|
|
|
DiffInstruction::Create { node } => self.create_node(state, node),
|
|
|
|
DiffInstruction::Mount { and } => self.mount(state, and),
|
2021-11-05 20:28:08 +00:00
|
|
|
DiffInstruction::PrepareMove { node } => {
|
2021-11-07 00:59:46 +00:00
|
|
|
let num_on_stack = self.push_all_nodes(state, node);
|
|
|
|
state.stack.add_child_count(num_on_stack);
|
2021-11-05 20:28:08 +00:00
|
|
|
}
|
2021-11-07 00:59:46 +00:00
|
|
|
DiffInstruction::PopScope => state.stack.pop_off_scope(),
|
2021-08-21 17:24:47 +00:00
|
|
|
};
|
2021-08-26 06:41:30 +00:00
|
|
|
|
2021-09-02 03:22:34 +00:00
|
|
|
if deadline_expired() {
|
2021-10-24 17:30:36 +00:00
|
|
|
log::debug!("Deadline expired before we could finished!");
|
2021-09-02 03:22:34 +00:00
|
|
|
return false;
|
|
|
|
}
|
2021-08-19 06:50:35 +00:00
|
|
|
}
|
2021-09-02 03:22:34 +00:00
|
|
|
|
|
|
|
true
|
2021-08-19 06:50:35 +00:00
|
|
|
}
|
|
|
|
|
2021-11-05 20:28:08 +00:00
|
|
|
// recursively push all the nodes of a tree onto the stack and return how many are there
|
2021-11-07 00:59:46 +00:00
|
|
|
fn push_all_nodes(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
node: &'bump VNode<'bump>,
|
|
|
|
) -> usize {
|
2021-11-05 20:28:08 +00:00
|
|
|
match node {
|
|
|
|
VNode::Text(_) | VNode::Anchor(_) | VNode::Suspended(_) => {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.push_root(node.mounted_id());
|
2021-11-05 20:28:08 +00:00
|
|
|
1
|
|
|
|
}
|
|
|
|
|
2021-11-07 03:11:17 +00:00
|
|
|
VNode::Linked(linked) => {
|
|
|
|
todo!("load linked");
|
|
|
|
0
|
|
|
|
// let num_on_stack = linked.children.iter().map(|child| {
|
|
|
|
// self.push_all_nodes(state, child)
|
|
|
|
// }).sum();
|
|
|
|
// state.mutations.push_root(node.mounted_id());
|
|
|
|
// num_on_stack + 1
|
|
|
|
}
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
VNode::Fragment(_) | VNode::Component(_) => {
|
|
|
|
//
|
|
|
|
let mut added = 0;
|
|
|
|
for child in node.children() {
|
|
|
|
added += self.push_all_nodes(state, child);
|
|
|
|
}
|
|
|
|
added
|
|
|
|
}
|
2021-11-05 20:28:08 +00:00
|
|
|
|
|
|
|
VNode::Element(el) => {
|
|
|
|
let mut num_on_stack = 0;
|
|
|
|
for child in el.children.iter() {
|
2021-11-07 00:59:46 +00:00
|
|
|
num_on_stack += self.push_all_nodes(state, child);
|
2021-11-05 20:28:08 +00:00
|
|
|
}
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.push_root(el.dom_id.get().unwrap());
|
2021-11-05 20:28:08 +00:00
|
|
|
|
|
|
|
num_on_stack + 1
|
|
|
|
}
|
2021-08-27 13:40:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn mount(&'bump self, state: &mut DiffState<'bump>, and: MountType<'bump>) {
|
|
|
|
let nodes_created = state.stack.pop_nodes_created();
|
2021-08-22 21:08:25 +00:00
|
|
|
match and {
|
|
|
|
// add the nodes from this virtual list to the parent
|
|
|
|
// used by fragments and components
|
|
|
|
MountType::Absorb => {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.add_child_count(nodes_created);
|
2021-08-22 21:08:25 +00:00
|
|
|
}
|
2021-08-24 14:01:01 +00:00
|
|
|
|
2021-08-22 21:08:25 +00:00
|
|
|
MountType::Replace { old } => {
|
2021-09-10 00:58:48 +00:00
|
|
|
if let Some(old_id) = old.try_mounted_id() {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.replace_with(old_id, nodes_created as u32);
|
|
|
|
self.remove_nodes(state, Some(old), true);
|
2021-09-10 00:58:48 +00:00
|
|
|
} else {
|
2021-11-07 00:59:46 +00:00
|
|
|
if let Some(id) = self.find_first_element_id(state, old) {
|
|
|
|
state.mutations.replace_with(id, nodes_created as u32);
|
2021-10-11 22:40:00 +00:00
|
|
|
}
|
2021-11-07 00:59:46 +00:00
|
|
|
self.remove_nodes(state, Some(old), true);
|
2021-09-10 00:58:48 +00:00
|
|
|
}
|
2021-08-22 21:08:25 +00:00
|
|
|
}
|
2021-08-23 16:11:45 +00:00
|
|
|
|
2021-09-20 16:32:21 +00:00
|
|
|
MountType::Append => {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.edits.push(AppendChildren {
|
2021-09-20 16:32:21 +00:00
|
|
|
many: nodes_created as u32,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2021-08-22 21:08:25 +00:00
|
|
|
MountType::InsertAfter { other_node } => {
|
2021-11-07 00:59:46 +00:00
|
|
|
let root = self.find_last_element(state, other_node).unwrap();
|
|
|
|
state.mutations.insert_after(root, nodes_created as u32);
|
2021-08-22 21:08:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
MountType::InsertBefore { other_node } => {
|
2021-11-07 00:59:46 +00:00
|
|
|
let root = self.find_first_element_id(state, other_node).unwrap();
|
|
|
|
state.mutations.insert_before(root, nodes_created as u32);
|
2021-08-22 21:08:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
// =================================
|
|
|
|
// Tools for creating new nodes
|
|
|
|
// =================================
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn create_node(&'bump self, state: &mut DiffState<'bump>, node: &'bump VNode<'bump>) {
|
2021-08-20 15:39:13 +00:00
|
|
|
match node {
|
2021-11-07 00:59:46 +00:00
|
|
|
VNode::Text(vtext) => self.create_text_node(state, vtext, node),
|
|
|
|
VNode::Suspended(suspended) => self.create_suspended_node(state, suspended, node),
|
|
|
|
VNode::Anchor(anchor) => self.create_anchor_node(state, anchor, node),
|
|
|
|
VNode::Element(element) => self.create_element_node(state, element, node),
|
|
|
|
VNode::Fragment(frag) => self.create_fragment_node(state, frag),
|
|
|
|
VNode::Component(component) => self.create_component_node(state, component),
|
2021-11-07 03:11:17 +00:00
|
|
|
VNode::Linked(linked) => self.create_linked_node(state, linked),
|
2021-08-20 15:39:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn create_text_node(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
vtext: &'bump VText<'bump>,
|
|
|
|
node: &'bump VNode<'bump>,
|
|
|
|
) {
|
|
|
|
let real_id = self.reserve_node(node);
|
|
|
|
state.mutations.create_text_node(vtext.text, real_id);
|
2021-08-20 14:44:58 +00:00
|
|
|
vtext.dom_id.set(Some(real_id));
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.add_child_count(1);
|
2021-08-20 14:44:58 +00:00
|
|
|
}
|
2021-08-20 14:34:41 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn create_suspended_node(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
suspended: &'bump VSuspended,
|
|
|
|
node: &'bump VNode<'bump>,
|
|
|
|
) {
|
|
|
|
let real_id = self.reserve_node(node);
|
|
|
|
state.mutations.create_placeholder(real_id);
|
2021-09-13 22:55:43 +00:00
|
|
|
|
2021-08-25 20:40:18 +00:00
|
|
|
suspended.dom_id.set(Some(real_id));
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.add_child_count(1);
|
2021-09-13 22:55:43 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
self.attach_suspended_node_to_scope(state, suspended);
|
2021-08-20 14:44:58 +00:00
|
|
|
}
|
2021-08-19 06:50:35 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn create_anchor_node(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
anchor: &'bump VAnchor,
|
|
|
|
node: &'bump VNode<'bump>,
|
|
|
|
) {
|
|
|
|
let real_id = self.reserve_node(node);
|
|
|
|
state.mutations.create_placeholder(real_id);
|
2021-08-20 14:44:58 +00:00
|
|
|
anchor.dom_id.set(Some(real_id));
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.add_child_count(1);
|
2021-08-20 14:44:58 +00:00
|
|
|
}
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn create_element_node(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
element: &'bump VElement<'bump>,
|
|
|
|
node: &'bump VNode<'bump>,
|
|
|
|
) {
|
2021-08-20 14:44:58 +00:00
|
|
|
let VElement {
|
|
|
|
tag_name,
|
|
|
|
listeners,
|
|
|
|
attributes,
|
|
|
|
children,
|
|
|
|
namespace,
|
|
|
|
dom_id,
|
2021-08-21 17:24:47 +00:00
|
|
|
..
|
2021-08-20 14:44:58 +00:00
|
|
|
} = element;
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
let real_id = self.reserve_node(node);
|
2021-09-20 16:32:21 +00:00
|
|
|
|
2021-08-24 16:43:46 +00:00
|
|
|
dom_id.set(Some(real_id));
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
state
|
|
|
|
.mutations
|
|
|
|
.create_element(tag_name, *namespace, real_id);
|
2021-08-22 03:04:34 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.add_child_count(1);
|
2021-08-22 03:04:34 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
if let Some(cur_scope_id) = state.stack.current_scope() {
|
2021-11-07 04:06:00 +00:00
|
|
|
let scope = self.get_scope(&cur_scope_id).unwrap();
|
2021-09-02 04:10:09 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
for listener in *listeners {
|
|
|
|
self.attach_listener_to_scope(state, listener, scope);
|
2021-09-02 04:10:09 +00:00
|
|
|
listener.mounted_node.set(Some(real_id));
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.new_event_listener(listener, cur_scope_id);
|
|
|
|
}
|
2021-09-02 04:10:09 +00:00
|
|
|
} else {
|
|
|
|
log::warn!("create element called with no scope on the stack - this is an error for a live dom");
|
|
|
|
}
|
2021-08-20 14:44:58 +00:00
|
|
|
|
|
|
|
for attr in *attributes {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.set_attribute(attr, real_id.as_u64());
|
2021-08-20 14:44:58 +00:00
|
|
|
}
|
|
|
|
|
2021-09-22 05:37:45 +00:00
|
|
|
if !children.is_empty() {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.create_children(children, MountType::Append);
|
2021-08-22 03:04:34 +00:00
|
|
|
}
|
2021-08-20 14:44:58 +00:00
|
|
|
}
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn create_fragment_node(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
frag: &'bump VFragment<'bump>,
|
|
|
|
) {
|
|
|
|
state
|
|
|
|
.stack
|
|
|
|
.create_children(frag.children, MountType::Absorb);
|
2021-08-20 14:44:58 +00:00
|
|
|
}
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn create_component_node(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
vcomponent: &'bump VComponent<'bump>,
|
|
|
|
) {
|
2021-11-05 20:28:08 +00:00
|
|
|
// let caller = vcomponent.caller;
|
2021-08-20 14:44:58 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
let parent_idx = state.stack.current_scope().unwrap();
|
2021-08-20 14:44:58 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
let shared = self.sender.clone();
|
2021-09-10 00:58:48 +00:00
|
|
|
|
2021-08-20 14:44:58 +00:00
|
|
|
// Insert a new scope into our component list
|
2021-11-07 00:59:46 +00:00
|
|
|
let parent_scope = self.get_scope(&parent_idx).unwrap();
|
|
|
|
|
|
|
|
let new_idx: ScopeId = todo!();
|
2021-11-07 04:06:00 +00:00
|
|
|
// self
|
2021-11-07 00:59:46 +00:00
|
|
|
// .new_with_key(fc_ptr, vcomp, parent_scope, height, subtree, sender);
|
|
|
|
|
|
|
|
// .(|new_idx| {
|
|
|
|
// // ScopeInner::new(
|
|
|
|
// vcomponent,
|
|
|
|
// new_idx,
|
|
|
|
// Some(parent_idx),
|
|
|
|
// parent_scope.height + 1,
|
|
|
|
// parent_scope.subtree(),
|
|
|
|
// shared,
|
|
|
|
// // )
|
|
|
|
// });
|
2021-08-20 14:44:58 +00:00
|
|
|
|
|
|
|
// Actually initialize the caller's slot with the right address
|
2021-08-27 13:53:26 +00:00
|
|
|
vcomponent.associated_scope.set(Some(new_idx));
|
2021-08-20 14:44:58 +00:00
|
|
|
|
|
|
|
if !vcomponent.can_memoize {
|
2021-11-07 04:06:00 +00:00
|
|
|
let cur_scope = self.get_scope(&parent_idx).unwrap();
|
2021-08-20 14:44:58 +00:00
|
|
|
let extended = vcomponent as *const VComponent;
|
|
|
|
let extended: *const VComponent<'static> = unsafe { std::mem::transmute(extended) };
|
2021-11-05 20:28:08 +00:00
|
|
|
|
|
|
|
cur_scope.items.get_mut().borrowed_props.push(extended);
|
2021-08-20 14:44:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// TODO:
|
|
|
|
// add noderefs to current noderef list Noderefs
|
|
|
|
// add effects to current effect list Effects
|
|
|
|
|
2021-11-07 04:06:00 +00:00
|
|
|
let new_component = self.get_scope(&new_idx).unwrap();
|
2021-08-20 14:44:58 +00:00
|
|
|
|
2021-10-25 19:05:17 +00:00
|
|
|
log::debug!(
|
|
|
|
"initializing component {:?} with height {:?}",
|
|
|
|
new_idx,
|
|
|
|
parent_scope.height + 1
|
|
|
|
);
|
2021-10-11 22:40:00 +00:00
|
|
|
|
2021-08-20 14:44:58 +00:00
|
|
|
// Run the scope for one iteration to initialize it
|
2021-11-07 00:59:46 +00:00
|
|
|
//
|
|
|
|
todo!("run scope");
|
|
|
|
// if new_component.run_scope(self) {
|
|
|
|
// // Take the node that was just generated from running the component
|
|
|
|
// let nextnode = new_component.frames.fin_head();
|
|
|
|
// state.stack.create_component(new_idx, nextnode);
|
2021-10-08 20:01:13 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
// //
|
|
|
|
// /*
|
|
|
|
// tree_item {
|
2021-10-08 20:01:13 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
// }
|
2021-10-08 20:01:13 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
// */
|
|
|
|
// if new_component.is_subtree_root.get() {
|
|
|
|
// state.stack.push_subtree();
|
|
|
|
// }
|
|
|
|
// }
|
2021-08-20 14:44:58 +00:00
|
|
|
|
2021-08-22 03:04:34 +00:00
|
|
|
// Finally, insert this scope as a seen node.
|
2021-11-07 00:59:46 +00:00
|
|
|
state.seen_scopes.insert(new_idx);
|
2021-08-19 06:50:35 +00:00
|
|
|
}
|
|
|
|
|
2021-11-07 03:11:17 +00:00
|
|
|
fn create_linked_node(&'bump self, state: &mut DiffState<'bump>, link: &'bump NodeLink) {
|
|
|
|
todo!()
|
|
|
|
}
|
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
// =================================
|
|
|
|
// Tools for diffing nodes
|
|
|
|
// =================================
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
pub fn diff_node(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
old_node: &'bump VNode<'bump>,
|
|
|
|
new_node: &'bump VNode<'bump>,
|
|
|
|
) {
|
2021-08-20 15:39:13 +00:00
|
|
|
use VNode::*;
|
|
|
|
match (old_node, new_node) {
|
|
|
|
// Check the most common cases first
|
2021-11-07 00:59:46 +00:00
|
|
|
(Text(old), Text(new)) => self.diff_text_nodes(state, old, new),
|
2021-09-10 00:58:48 +00:00
|
|
|
(Component(old), Component(new)) => {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.diff_component_nodes(state, old_node, new_node, old, new)
|
2021-09-10 00:58:48 +00:00
|
|
|
}
|
2021-11-07 00:59:46 +00:00
|
|
|
(Fragment(old), Fragment(new)) => self.diff_fragment_nodes(state, old, new),
|
2021-08-20 15:39:13 +00:00
|
|
|
(Anchor(old), Anchor(new)) => new.dom_id.set(old.dom_id.get()),
|
2021-11-07 00:59:46 +00:00
|
|
|
(Suspended(old), Suspended(new)) => self.diff_suspended_nodes(state, old, new),
|
|
|
|
(Element(old), Element(new)) => {
|
|
|
|
self.diff_element_nodes(state, old, new, old_node, new_node)
|
|
|
|
}
|
2021-11-07 03:11:17 +00:00
|
|
|
(Linked(old), Linked(new)) => self.diff_linked_nodes(state, old, new),
|
2021-08-20 15:39:13 +00:00
|
|
|
|
2021-08-22 21:08:25 +00:00
|
|
|
// Anything else is just a basic replace and create
|
2021-08-20 15:39:13 +00:00
|
|
|
(
|
2021-11-07 03:11:17 +00:00
|
|
|
Linked(_) | Component(_) | Fragment(_) | Text(_) | Element(_) | Anchor(_)
|
|
|
|
| Suspended(_),
|
|
|
|
Linked(_) | Component(_) | Fragment(_) | Text(_) | Element(_) | Anchor(_)
|
|
|
|
| Suspended(_),
|
2021-11-07 00:59:46 +00:00
|
|
|
) => state
|
2021-08-23 16:11:45 +00:00
|
|
|
.stack
|
|
|
|
.create_node(new_node, MountType::Replace { old: old_node }),
|
2021-08-20 15:39:13 +00:00
|
|
|
}
|
|
|
|
}
|
2021-08-19 06:50:35 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn diff_text_nodes(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
old: &'bump VText<'bump>,
|
|
|
|
new: &'bump VText<'bump>,
|
|
|
|
) {
|
2021-09-10 00:58:48 +00:00
|
|
|
if let Some(root) = old.dom_id.get() {
|
|
|
|
if old.text != new.text {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.set_text(new.text, root.as_u64());
|
2021-09-10 00:58:48 +00:00
|
|
|
}
|
2021-08-19 06:50:35 +00:00
|
|
|
|
2021-09-10 00:58:48 +00:00
|
|
|
new.dom_id.set(Some(root));
|
2021-08-20 15:39:13 +00:00
|
|
|
}
|
|
|
|
}
|
2021-08-19 06:50:35 +00:00
|
|
|
|
2021-09-20 16:32:21 +00:00
|
|
|
fn diff_element_nodes(
|
2021-11-07 00:59:46 +00:00
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
2021-09-20 16:32:21 +00:00
|
|
|
old: &'bump VElement<'bump>,
|
|
|
|
new: &'bump VElement<'bump>,
|
2021-10-11 22:40:00 +00:00
|
|
|
old_node: &'bump VNode<'bump>,
|
2021-09-20 16:32:21 +00:00
|
|
|
new_node: &'bump VNode<'bump>,
|
|
|
|
) {
|
2021-10-11 19:35:20 +00:00
|
|
|
let root = old.dom_id.get().unwrap();
|
2021-08-19 06:50:35 +00:00
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
// 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
|
|
|
|
//
|
|
|
|
// This case is rather rare (typically only in non-keyed lists)
|
|
|
|
if new.tag_name != old.tag_name || new.namespace != old.namespace {
|
2021-08-24 14:01:01 +00:00
|
|
|
// maybe make this an instruction?
|
|
|
|
// issue is that we need the "vnode" but this method only has the velement
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.push_nodes_created(0);
|
|
|
|
state.stack.push(DiffInstruction::Mount {
|
2021-10-11 22:40:00 +00:00
|
|
|
and: MountType::Replace { old: old_node },
|
2021-08-24 14:01:01 +00:00
|
|
|
});
|
2021-11-07 00:59:46 +00:00
|
|
|
self.create_element_node(state, new, new_node);
|
2021-08-20 15:39:13 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-10-11 19:35:20 +00:00
|
|
|
new.dom_id.set(Some(root));
|
2021-08-19 06:50:35 +00:00
|
|
|
|
2021-10-04 06:54:20 +00:00
|
|
|
// todo: attributes currently rely on the element on top of the stack, but in theory, we only need the id of the
|
|
|
|
// element to modify its attributes.
|
|
|
|
// it would result in fewer instructions if we just set the id directly.
|
|
|
|
// it would also clean up this code some, but that's not very important anyways
|
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
// Diff Attributes
|
|
|
|
//
|
|
|
|
// It's extraordinarily rare to have the number/order of attributes change
|
|
|
|
// In these cases, we just completely erase the old set and make a new set
|
|
|
|
//
|
|
|
|
// TODO: take a more efficient path than this
|
|
|
|
if old.attributes.len() == new.attributes.len() {
|
|
|
|
for (old_attr, new_attr) in old.attributes.iter().zip(new.attributes.iter()) {
|
2021-10-18 00:18:30 +00:00
|
|
|
if old_attr.value != new_attr.value || new_attr.is_volatile {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.set_attribute(new_attr, root.as_u64());
|
2021-08-19 06:50:35 +00:00
|
|
|
}
|
|
|
|
}
|
2021-08-20 15:39:13 +00:00
|
|
|
} else {
|
|
|
|
for attribute in old.attributes {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.remove_attribute(attribute, root.as_u64());
|
2021-08-20 15:39:13 +00:00
|
|
|
}
|
|
|
|
for attribute in new.attributes {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.set_attribute(attribute, root.as_u64())
|
2021-08-20 15:39:13 +00:00
|
|
|
}
|
|
|
|
}
|
2021-08-19 06:50:35 +00:00
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
// Diff listeners
|
|
|
|
//
|
|
|
|
// It's extraordinarily rare to have the number/order of listeners change
|
|
|
|
// In the cases where the listeners change, we completely wipe the data attributes and add new ones
|
|
|
|
//
|
|
|
|
// We also need to make sure that all listeners are properly attached to the parent scope (fix_listener)
|
|
|
|
//
|
|
|
|
// TODO: take a more efficient path than this
|
2021-11-07 00:59:46 +00:00
|
|
|
if let Some(cur_scope_id) = state.stack.current_scope() {
|
2021-11-07 04:06:00 +00:00
|
|
|
let scope = self.get_scope(&cur_scope_id).unwrap();
|
2021-09-02 04:10:09 +00:00
|
|
|
|
|
|
|
if old.listeners.len() == new.listeners.len() {
|
|
|
|
for (old_l, new_l) in old.listeners.iter().zip(new.listeners.iter()) {
|
|
|
|
if old_l.event != new_l.event {
|
2021-11-07 00:59:46 +00:00
|
|
|
state
|
|
|
|
.mutations
|
2021-10-11 19:35:20 +00:00
|
|
|
.remove_event_listener(old_l.event, root.as_u64());
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.new_event_listener(new_l, cur_scope_id);
|
2021-09-02 04:10:09 +00:00
|
|
|
}
|
|
|
|
new_l.mounted_node.set(old_l.mounted_node.get());
|
2021-11-07 00:59:46 +00:00
|
|
|
self.attach_listener_to_scope(state, new_l, scope);
|
2021-09-02 04:10:09 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for listener in old.listeners {
|
2021-11-07 00:59:46 +00:00
|
|
|
state
|
|
|
|
.mutations
|
2021-10-11 19:35:20 +00:00
|
|
|
.remove_event_listener(listener.event, root.as_u64());
|
2021-09-02 04:10:09 +00:00
|
|
|
}
|
|
|
|
for listener in new.listeners {
|
2021-10-11 19:35:20 +00:00
|
|
|
listener.mounted_node.set(Some(root));
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.new_event_listener(listener, cur_scope_id);
|
|
|
|
self.attach_listener_to_scope(state, listener, scope);
|
2021-08-19 06:50:35 +00:00
|
|
|
}
|
|
|
|
}
|
2021-08-20 15:39:13 +00:00
|
|
|
}
|
2021-08-19 06:50:35 +00:00
|
|
|
|
2021-10-18 00:18:30 +00:00
|
|
|
if old.children.is_empty() && !new.children.is_empty() {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.edits.push(PushRoot {
|
2021-10-11 19:35:20 +00:00
|
|
|
root: root.as_u64(),
|
|
|
|
});
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.create_children(new.children, MountType::Append);
|
2021-10-11 02:27:08 +00:00
|
|
|
} else {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.diff_children(state, old.children, new.children);
|
2021-09-22 05:37:45 +00:00
|
|
|
}
|
2021-08-19 06:50:35 +00:00
|
|
|
}
|
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
fn diff_component_nodes(
|
2021-11-07 00:59:46 +00:00
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
2021-09-10 00:58:48 +00:00
|
|
|
old_node: &'bump VNode<'bump>,
|
|
|
|
new_node: &'bump VNode<'bump>,
|
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
old: &'bump VComponent<'bump>,
|
|
|
|
new: &'bump VComponent<'bump>,
|
|
|
|
) {
|
2021-08-27 13:53:26 +00:00
|
|
|
let scope_addr = old.associated_scope.get().unwrap();
|
2021-07-13 03:44:20 +00:00
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
// Make sure we're dealing with the same component (by function pointer)
|
|
|
|
if old.user_fc == new.user_fc {
|
2021-10-11 22:40:00 +00:00
|
|
|
log::debug!("Diffing component {:?} - {:?}", new.user_fc, scope_addr);
|
2021-08-20 15:39:13 +00:00
|
|
|
//
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.scope_stack.push(scope_addr);
|
2021-03-05 20:02:36 +00:00
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
// Make sure the new component vnode is referencing the right scope id
|
2021-08-27 13:53:26 +00:00
|
|
|
new.associated_scope.set(Some(scope_addr));
|
2021-07-26 16:14:48 +00:00
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
// make sure the component's caller function is up to date
|
2021-11-07 04:06:00 +00:00
|
|
|
let scope = self.get_scope(&scope_addr).unwrap();
|
2021-11-05 20:28:08 +00:00
|
|
|
scope.update_vcomp(new);
|
2021-07-29 01:46:53 +00:00
|
|
|
|
2021-08-20 15:39:13 +00:00
|
|
|
// React doesn't automatically memoize, but we do.
|
2021-11-05 20:28:08 +00:00
|
|
|
let props_are_the_same = todo!("reworking component memoization");
|
|
|
|
// let props_are_the_same = todo!("reworking component memoization");
|
|
|
|
// let props_are_the_same = old.comparator.unwrap();
|
2021-07-29 01:46:53 +00:00
|
|
|
|
2021-11-05 20:28:08 +00:00
|
|
|
// if self.cfg.force_diff || !props_are_the_same(new) {
|
2021-11-07 00:59:46 +00:00
|
|
|
// let succeeded = scope.run_scope(self);
|
2021-09-21 22:13:09 +00:00
|
|
|
|
2021-11-05 20:28:08 +00:00
|
|
|
// if succeeded {
|
|
|
|
// self.diff_node(scope.frames.wip_head(), scope.frames.fin_head());
|
|
|
|
// }
|
|
|
|
// }
|
2021-06-21 04:52:37 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.scope_stack.pop();
|
2021-08-20 15:39:13 +00:00
|
|
|
} else {
|
2021-11-07 00:59:46 +00:00
|
|
|
state
|
|
|
|
.stack
|
2021-09-10 00:58:48 +00:00
|
|
|
.create_node(new_node, MountType::Replace { old: old_node });
|
2021-02-12 08:07:35 +00:00
|
|
|
}
|
2021-03-03 07:27:26 +00:00
|
|
|
}
|
2021-07-11 18:49:52 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn diff_fragment_nodes(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
old: &'bump VFragment<'bump>,
|
|
|
|
new: &'bump VFragment<'bump>,
|
|
|
|
) {
|
2021-08-20 15:39:13 +00:00
|
|
|
// 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 {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.diff_node(state, &old.children[0], &new.children[0]);
|
2021-08-20 15:39:13 +00:00
|
|
|
return;
|
2021-07-29 01:46:53 +00:00
|
|
|
}
|
|
|
|
|
2021-10-18 00:18:30 +00:00
|
|
|
debug_assert!(!old.children.is_empty());
|
|
|
|
debug_assert!(!new.children.is_empty());
|
2021-10-11 02:27:08 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
self.diff_children(state, old.children, new.children);
|
2021-07-29 01:46:53 +00:00
|
|
|
}
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn diff_suspended_nodes(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
old: &'bump VSuspended,
|
|
|
|
new: &'bump VSuspended,
|
|
|
|
) {
|
2021-09-13 22:55:43 +00:00
|
|
|
new.dom_id.set(old.dom_id.get());
|
2021-11-07 00:59:46 +00:00
|
|
|
self.attach_suspended_node_to_scope(state, new);
|
2021-09-13 22:55:43 +00:00
|
|
|
}
|
|
|
|
|
2021-11-07 03:11:17 +00:00
|
|
|
fn diff_linked_nodes(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
old: &'bump NodeLink,
|
|
|
|
new: &'bump NodeLink,
|
|
|
|
) {
|
|
|
|
todo!();
|
|
|
|
// new.dom_id.set(old.dom_id.get());
|
|
|
|
// self.attach_linked_node_to_scope(state, new);
|
|
|
|
}
|
|
|
|
|
2021-08-22 21:08:25 +00:00
|
|
|
// =============================================
|
2021-10-24 17:30:36 +00:00
|
|
|
// Utilities for creating new diff instructions
|
2021-08-22 21:08:25 +00:00
|
|
|
// =============================================
|
|
|
|
|
2021-03-03 07:27:26 +00:00
|
|
|
// 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.
|
2021-07-29 01:46:53 +00:00
|
|
|
//
|
|
|
|
// If old no anchors are provided, then it's assumed that we can freely append to the parent.
|
|
|
|
//
|
|
|
|
// Remember, non-empty lists does not mean that there are real elements, just that there are virtual elements.
|
2021-08-22 03:04:34 +00:00
|
|
|
//
|
2021-10-24 17:30:36 +00:00
|
|
|
// Fragment nodes cannot generate empty children lists, so we can assume that when a list is empty, it belongs only
|
2021-08-22 03:04:34 +00:00
|
|
|
// to an element, and appending makes sense.
|
2021-11-07 00:59:46 +00:00
|
|
|
fn diff_children(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
old: &'bump [VNode<'bump>],
|
|
|
|
new: &'bump [VNode<'bump>],
|
|
|
|
) {
|
2021-08-22 03:04:34 +00:00
|
|
|
// Remember, fragments can never be empty (they always have a single child)
|
2021-08-23 17:41:47 +00:00
|
|
|
match (old, new) {
|
|
|
|
([], []) => {}
|
|
|
|
([], _) => {
|
2021-10-11 02:27:08 +00:00
|
|
|
// we need to push the
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.create_children(new, MountType::Append);
|
2021-07-29 04:04:59 +00:00
|
|
|
}
|
2021-08-23 17:41:47 +00:00
|
|
|
(_, []) => {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.remove_nodes(state, old, true);
|
2021-07-29 01:46:53 +00:00
|
|
|
}
|
2021-08-23 17:41:47 +00:00
|
|
|
([VNode::Anchor(old_anchor)], [VNode::Anchor(new_anchor)]) => {
|
|
|
|
old_anchor.dom_id.set(new_anchor.dom_id.get());
|
|
|
|
}
|
2021-10-11 22:40:00 +00:00
|
|
|
([VNode::Anchor(_)], _) => {
|
2021-11-07 00:59:46 +00:00
|
|
|
state
|
|
|
|
.stack
|
2021-10-11 22:40:00 +00:00
|
|
|
.create_children(new, MountType::Replace { old: &old[0] });
|
2021-08-23 17:41:47 +00:00
|
|
|
}
|
|
|
|
(_, [VNode::Anchor(_)]) => {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.replace_and_create_many_with_one(state, old, &new[0]);
|
2021-08-23 17:41:47 +00:00
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
let new_is_keyed = new[0].key().is_some();
|
|
|
|
let old_is_keyed = old[0].key().is_some();
|
2021-02-14 23:03:16 +00:00
|
|
|
|
2021-08-23 17:41:47 +00:00
|
|
|
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"
|
|
|
|
);
|
2021-07-29 22:56:09 +00:00
|
|
|
|
2021-08-23 17:41:47 +00:00
|
|
|
if new_is_keyed && old_is_keyed {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.diff_keyed_children(state, old, new);
|
2021-08-23 17:41:47 +00:00
|
|
|
} else {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.diff_non_keyed_children(state, old, new);
|
2021-08-23 17:41:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-07-29 22:56:09 +00:00
|
|
|
|
2021-08-23 17:41:47 +00:00
|
|
|
// 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.
|
2021-11-07 00:59:46 +00:00
|
|
|
fn diff_non_keyed_children(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
old: &'bump [VNode<'bump>],
|
|
|
|
new: &'bump [VNode<'bump>],
|
|
|
|
) {
|
2021-08-23 17:41:47 +00:00
|
|
|
// Handled these cases in `diff_children` before calling this function.
|
|
|
|
debug_assert!(!new.is_empty());
|
|
|
|
debug_assert!(!old.is_empty());
|
2021-07-29 22:04:09 +00:00
|
|
|
|
2021-08-23 17:41:47 +00:00
|
|
|
for (new, old) in new.iter().zip(old.iter()).rev() {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.push(DiffInstruction::Diff { new, old });
|
2021-08-23 17:41:47 +00:00
|
|
|
}
|
2021-07-29 22:04:09 +00:00
|
|
|
|
2021-09-21 22:13:09 +00:00
|
|
|
use std::cmp::Ordering;
|
|
|
|
match old.len().cmp(&new.len()) {
|
2021-11-07 00:59:46 +00:00
|
|
|
Ordering::Greater => self.remove_nodes(state, &old[new.len()..], true),
|
2021-09-21 22:13:09 +00:00
|
|
|
Ordering::Less => {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.create_children(
|
2021-09-21 22:13:09 +00:00
|
|
|
&new[old.len()..],
|
|
|
|
MountType::InsertAfter {
|
|
|
|
other_node: old.last().unwrap(),
|
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Ordering::Equal => {
|
|
|
|
// nothing - they're the same size
|
|
|
|
}
|
2021-07-29 01:46:53 +00:00
|
|
|
}
|
2021-02-12 08:07:35 +00:00
|
|
|
}
|
|
|
|
|
2021-03-03 07:27:26 +00:00
|
|
|
// 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
|
|
|
|
//
|
2021-07-30 20:07:42 +00:00
|
|
|
// The stack is empty upon entry.
|
2021-11-07 00:59:46 +00:00
|
|
|
fn diff_keyed_children(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
old: &'bump [VNode<'bump>],
|
|
|
|
new: &'bump [VNode<'bump>],
|
|
|
|
) {
|
2021-06-27 02:13:57 +00:00
|
|
|
if cfg!(debug_assertions) {
|
|
|
|
let mut keys = fxhash::FxHashSet::default();
|
2021-06-28 16:05:17 +00:00
|
|
|
let mut assert_unique_keys = |children: &'bump [VNode<'bump>]| {
|
2021-06-27 02:13:57 +00:00
|
|
|
keys.clear();
|
|
|
|
for child in children {
|
2021-08-20 14:34:41 +00:00
|
|
|
let key = child.key();
|
2021-06-27 02:13:57 +00:00
|
|
|
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);
|
|
|
|
}
|
2021-03-03 07:27:26 +00:00
|
|
|
|
|
|
|
// 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.
|
2021-11-07 00:59:46 +00:00
|
|
|
let (left_offset, right_offset) = match self.diff_keyed_ends(state, old, new) {
|
2021-08-23 19:35:26 +00:00
|
|
|
Some(count) => count,
|
|
|
|
None => return,
|
2021-03-03 07:27:26 +00:00
|
|
|
};
|
2021-10-11 22:40:00 +00:00
|
|
|
// log::debug!(
|
|
|
|
// "Left offset, right offset, {}, {}",
|
|
|
|
// left_offset,
|
|
|
|
// right_offset,
|
|
|
|
// );
|
2021-03-03 07:27:26 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
// log::debug!("stack before lo is {:#?}", state.stack.instructions);
|
2021-03-03 07:27:26 +00:00
|
|
|
// 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.
|
2021-10-11 02:27:08 +00:00
|
|
|
|
|
|
|
let old_middle = &old[left_offset..(old.len() - right_offset)];
|
|
|
|
let new_middle = &new[left_offset..(new.len() - right_offset)];
|
|
|
|
|
|
|
|
debug_assert!(
|
2021-10-18 00:18:30 +00:00
|
|
|
!((old_middle.len() == new_middle.len()) && old_middle.is_empty()),
|
2021-10-11 02:27:08 +00:00
|
|
|
"keyed children must have the same number of children"
|
2021-03-03 07:27:26 +00:00
|
|
|
);
|
2021-10-18 00:18:30 +00:00
|
|
|
if new_middle.is_empty() {
|
2021-10-11 02:27:08 +00:00
|
|
|
// remove the old elements
|
2021-11-07 00:59:46 +00:00
|
|
|
self.remove_nodes(state, old_middle, true);
|
2021-10-18 00:18:30 +00:00
|
|
|
} else if old_middle.is_empty() {
|
2021-10-11 02:27:08 +00:00
|
|
|
// there were no old elements, so just create the new elements
|
2021-10-24 17:30:36 +00:00
|
|
|
// we need to find the right "foothold" though - we shouldn't use the "append" at all
|
2021-10-11 02:27:08 +00:00
|
|
|
if left_offset == 0 {
|
|
|
|
// insert at the beginning of the old list
|
|
|
|
let foothold = &old[old.len() - right_offset];
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.create_children(
|
2021-10-11 02:27:08 +00:00
|
|
|
new_middle,
|
|
|
|
MountType::InsertBefore {
|
|
|
|
other_node: foothold,
|
|
|
|
},
|
|
|
|
);
|
|
|
|
} else if right_offset == 0 {
|
|
|
|
// insert at the end the old list
|
|
|
|
let foothold = old.last().unwrap();
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.create_children(
|
2021-10-11 02:27:08 +00:00
|
|
|
new_middle,
|
|
|
|
MountType::InsertAfter {
|
|
|
|
other_node: foothold,
|
|
|
|
},
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
// inserting in the middle
|
|
|
|
let foothold = &old[left_offset - 1];
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.create_children(
|
2021-10-11 02:27:08 +00:00
|
|
|
new_middle,
|
|
|
|
MountType::InsertAfter {
|
|
|
|
other_node: foothold,
|
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
} else {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.diff_keyed_middle(state, old_middle, new_middle);
|
2021-10-11 02:27:08 +00:00
|
|
|
}
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
log::debug!("stack after km is {:#?}", state.stack.instructions);
|
2021-02-12 08:07:35 +00:00
|
|
|
}
|
|
|
|
|
2021-08-23 19:35:26 +00:00
|
|
|
/// Diff both ends of the children that share keys.
|
|
|
|
///
|
|
|
|
/// Returns a left offset and right offset of that indicates a smaller section to pass onto the middle diffing.
|
|
|
|
///
|
|
|
|
/// If there is no offset, then this function returns None and the diffing is complete.
|
|
|
|
fn diff_keyed_ends(
|
2021-11-07 00:59:46 +00:00
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
2021-07-23 21:03:51 +00:00
|
|
|
old: &'bump [VNode<'bump>],
|
|
|
|
new: &'bump [VNode<'bump>],
|
2021-08-23 19:35:26 +00:00
|
|
|
) -> Option<(usize, usize)> {
|
|
|
|
let mut left_offset = 0;
|
2021-02-12 08:07:35 +00:00
|
|
|
|
2021-07-30 14:35:47 +00:00
|
|
|
for (old, new) in old.iter().zip(new.iter()) {
|
2021-07-23 21:03:51 +00:00
|
|
|
// abort early if we finally run into nodes with different keys
|
|
|
|
if old.key() != new.key() {
|
|
|
|
break;
|
|
|
|
}
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.push(DiffInstruction::Diff { old, new });
|
2021-08-23 19:35:26 +00:00
|
|
|
left_offset += 1;
|
2021-07-23 21:03:51 +00:00
|
|
|
}
|
2021-02-12 08:07:35 +00:00
|
|
|
|
2021-07-23 21:03:51 +00:00
|
|
|
// If that was all of the old children, then create and append the remaining
|
|
|
|
// new children and we're finished.
|
2021-08-23 19:35:26 +00:00
|
|
|
if left_offset == old.len() {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.create_children(
|
2021-08-23 19:35:26 +00:00
|
|
|
&new[left_offset..],
|
|
|
|
MountType::InsertAfter {
|
|
|
|
other_node: old.last().unwrap(),
|
|
|
|
},
|
|
|
|
);
|
|
|
|
return None;
|
2021-07-23 21:03:51 +00:00
|
|
|
}
|
2021-02-12 08:07:35 +00:00
|
|
|
|
2021-07-23 21:03:51 +00:00
|
|
|
// And if that was all of the new children, then remove all of the remaining
|
|
|
|
// old children and we're finished.
|
2021-08-23 19:35:26 +00:00
|
|
|
if left_offset == new.len() {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.remove_nodes(state, &old[left_offset..], true);
|
2021-08-23 19:35:26 +00:00
|
|
|
return None;
|
2021-07-23 21:03:51 +00:00
|
|
|
}
|
2021-02-12 08:07:35 +00:00
|
|
|
|
2021-08-23 19:35:26 +00:00
|
|
|
// if the shared prefix is less than either length, then we need to walk backwards
|
|
|
|
let mut right_offset = 0;
|
|
|
|
for (old, new) in old.iter().rev().zip(new.iter().rev()) {
|
|
|
|
// abort early if we finally run into nodes with different keys
|
|
|
|
if old.key() != new.key() {
|
|
|
|
break;
|
|
|
|
}
|
2021-11-07 00:59:46 +00:00
|
|
|
self.diff_node(state, old, new);
|
2021-08-23 19:35:26 +00:00
|
|
|
right_offset += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
Some((left_offset, right_offset))
|
2021-07-12 06:23:46 +00:00
|
|
|
}
|
|
|
|
|
2021-03-03 07:27:26 +00:00
|
|
|
// 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.
|
|
|
|
//
|
2021-07-30 14:35:47 +00:00
|
|
|
// Upon entry to this function, the change list stack must be empty.
|
2021-03-03 07:27:26 +00:00
|
|
|
//
|
2021-07-30 14:35:47 +00:00
|
|
|
// This function will load the appropriate nodes onto the stack and do diffing in place.
|
2021-03-03 07:27:26 +00:00
|
|
|
//
|
|
|
|
// Upon exit from this function, it will be restored to that same state.
|
2021-11-07 00:59:46 +00:00
|
|
|
fn diff_keyed_middle(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
old: &'bump [VNode<'bump>],
|
|
|
|
new: &'bump [VNode<'bump>],
|
|
|
|
) {
|
2021-08-22 03:04:34 +00:00
|
|
|
/*
|
2021-10-24 17:30:36 +00:00
|
|
|
1. Map the old keys into a numerical ordering based on indices.
|
2021-08-22 03:04:34 +00:00
|
|
|
2. Create a map of old key to its index
|
|
|
|
3. Map each new key to the old key, carrying over the old index.
|
|
|
|
- IE if we have ABCD becomes BACD, our sequence would be 1,0,2,3
|
|
|
|
- if we have ABCD to ABDE, our sequence would be 0,1,3,MAX because E doesn't exist
|
|
|
|
|
|
|
|
now, we should have a list of integers that indicates where in the old list the new items map to.
|
|
|
|
|
|
|
|
4. Compute the LIS of this list
|
|
|
|
- this indicates the longest list of new children that won't need to be moved.
|
|
|
|
|
|
|
|
5. Identify which nodes need to be removed
|
|
|
|
6. Identify which nodes will need to be diffed
|
|
|
|
|
|
|
|
7. Going along each item in the new list, create it and insert it before the next closest item in the LIS.
|
|
|
|
- if the item already existed, just move it to the right place.
|
|
|
|
|
|
|
|
8. Finally, generate instructions to remove any old children.
|
|
|
|
9. Generate instructions to finally diff children that are the same between both
|
|
|
|
*/
|
|
|
|
|
|
|
|
// 0. Debug sanity checks
|
2021-07-29 22:04:09 +00:00
|
|
|
// 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()));
|
|
|
|
|
2021-10-24 17:30:36 +00:00
|
|
|
// 1. Map the old keys into a numerical ordering based on indices.
|
2021-08-22 03:04:34 +00:00
|
|
|
// 2. Create a map of old key to its index
|
2021-07-29 22:04:09 +00:00
|
|
|
// IE if the keys were A B C, then we would have (A, 1) (B, 2) (C, 3).
|
2021-08-22 03:04:34 +00:00
|
|
|
let old_key_to_old_index = old
|
2021-07-29 22:04:09 +00:00
|
|
|
.iter()
|
|
|
|
.enumerate()
|
2021-07-30 20:07:42 +00:00
|
|
|
.map(|(i, o)| (o.key().unwrap(), i))
|
2021-07-29 22:04:09 +00:00
|
|
|
.collect::<FxHashMap<_, _>>();
|
2021-06-21 04:52:37 +00:00
|
|
|
|
2021-07-29 22:04:09 +00:00
|
|
|
let mut shared_keys = FxHashSet::default();
|
2021-06-21 04:52:37 +00:00
|
|
|
|
2021-08-22 03:04:34 +00:00
|
|
|
// 3. Map each new key to the old key, carrying over the old index.
|
|
|
|
let new_index_to_old_index = new
|
2021-07-29 22:04:09 +00:00
|
|
|
.iter()
|
2021-08-23 19:35:26 +00:00
|
|
|
.map(|node| {
|
|
|
|
let key = node.key().unwrap();
|
2021-08-22 03:04:34 +00:00
|
|
|
if let Some(&index) = old_key_to_old_index.get(&key) {
|
|
|
|
shared_keys.insert(key);
|
|
|
|
index
|
|
|
|
} else {
|
|
|
|
u32::MAX as usize
|
2021-07-29 22:04:09 +00:00
|
|
|
}
|
|
|
|
})
|
|
|
|
.collect::<Vec<_>>();
|
|
|
|
|
2021-08-23 19:35:26 +00:00
|
|
|
// 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_keys.is_empty() {
|
2021-10-11 02:27:08 +00:00
|
|
|
log::debug!(
|
|
|
|
"no shared keys, replacing and creating many with many, {:#?}, {:#?}",
|
|
|
|
old,
|
|
|
|
new
|
|
|
|
);
|
|
|
|
log::debug!("old_key_to_old_index, {:#?}", old_key_to_old_index);
|
|
|
|
log::debug!("new_index_to_old_index, {:#?}", new_index_to_old_index);
|
|
|
|
log::debug!("shared_keys, {:#?}", shared_keys);
|
2021-11-07 00:59:46 +00:00
|
|
|
self.replace_and_create_many_with_many(state, old, new);
|
2021-07-29 22:04:09 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-08-22 03:04:34 +00:00
|
|
|
// 4. Compute the LIS of this list
|
2021-08-24 14:01:01 +00:00
|
|
|
let mut lis_sequence = Vec::default();
|
|
|
|
lis_sequence.reserve(new_index_to_old_index.len());
|
2021-07-30 20:07:42 +00:00
|
|
|
|
2021-07-30 14:35:47 +00:00
|
|
|
let mut predecessors = vec![0; new_index_to_old_index.len()];
|
|
|
|
let mut starts = vec![0; new_index_to_old_index.len()];
|
2021-07-30 20:07:42 +00:00
|
|
|
|
2021-07-30 14:35:47 +00:00
|
|
|
longest_increasing_subsequence::lis_with(
|
|
|
|
&new_index_to_old_index,
|
2021-08-24 14:01:01 +00:00
|
|
|
&mut lis_sequence,
|
2021-07-30 14:35:47 +00:00
|
|
|
|a, b| a < b,
|
|
|
|
&mut predecessors,
|
|
|
|
&mut starts,
|
|
|
|
);
|
|
|
|
|
2021-08-24 15:03:19 +00:00
|
|
|
// the lis comes out backwards, I think. can't quite tell.
|
2021-08-24 14:01:01 +00:00
|
|
|
lis_sequence.sort_unstable();
|
|
|
|
|
|
|
|
// if a new node gets u32 max and is at the end, then it might be part of our LIS (because u32 max is a valid LIS)
|
|
|
|
if lis_sequence.last().map(|f| new_index_to_old_index[*f]) == Some(u32::MAX as usize) {
|
|
|
|
lis_sequence.pop();
|
|
|
|
}
|
2021-07-30 14:35:47 +00:00
|
|
|
|
2021-08-24 14:01:01 +00:00
|
|
|
let apply = |new_idx, new_node: &'bump VNode<'bump>, stack: &mut DiffStack<'bump>| {
|
|
|
|
let old_index = new_index_to_old_index[new_idx];
|
2021-08-23 19:35:26 +00:00
|
|
|
if old_index == u32::MAX as usize {
|
2021-08-24 14:01:01 +00:00
|
|
|
stack.create_node(new_node, MountType::Absorb);
|
2021-07-30 20:07:42 +00:00
|
|
|
} else {
|
2021-10-24 17:30:36 +00:00
|
|
|
// this function should never take LIS indices
|
2021-09-10 00:58:48 +00:00
|
|
|
stack.push(DiffInstruction::PrepareMove { node: new_node });
|
|
|
|
stack.push(DiffInstruction::Diff {
|
2021-08-24 14:01:01 +00:00
|
|
|
new: new_node,
|
|
|
|
old: &old[old_index],
|
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// add mount instruction for the last items not covered by the lis
|
|
|
|
let first_lis = *lis_sequence.first().unwrap();
|
|
|
|
if first_lis > 0 {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.push_nodes_created(0);
|
|
|
|
state.stack.push(DiffInstruction::Mount {
|
2021-08-24 14:01:01 +00:00
|
|
|
and: MountType::InsertBefore {
|
|
|
|
other_node: &new[first_lis],
|
|
|
|
},
|
|
|
|
});
|
|
|
|
|
|
|
|
for (idx, new_node) in new[..first_lis].iter().enumerate().rev() {
|
2021-11-07 00:59:46 +00:00
|
|
|
apply(idx, new_node, &mut state.stack);
|
2021-08-24 14:01:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// for each spacing, generate a mount instruction
|
|
|
|
let mut lis_iter = lis_sequence.iter().rev();
|
|
|
|
let mut last = *lis_iter.next().unwrap();
|
2021-09-21 22:13:09 +00:00
|
|
|
for next in lis_iter {
|
2021-08-24 14:01:01 +00:00
|
|
|
if last - next > 1 {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.push_nodes_created(0);
|
|
|
|
state.stack.push(DiffInstruction::Mount {
|
2021-08-24 14:01:01 +00:00
|
|
|
and: MountType::InsertBefore {
|
|
|
|
other_node: &new[last],
|
|
|
|
},
|
|
|
|
});
|
|
|
|
for (idx, new_node) in new[(next + 1)..last].iter().enumerate().rev() {
|
2021-11-07 00:59:46 +00:00
|
|
|
apply(idx + next + 1, new_node, &mut state.stack);
|
2021-08-23 19:35:26 +00:00
|
|
|
}
|
2021-07-30 14:35:47 +00:00
|
|
|
}
|
2021-09-21 22:13:09 +00:00
|
|
|
last = *next;
|
2021-07-30 14:35:47 +00:00
|
|
|
}
|
2021-03-03 07:27:26 +00:00
|
|
|
|
2021-08-24 14:01:01 +00:00
|
|
|
// add mount instruction for the first items not covered by the lis
|
2021-08-24 15:03:19 +00:00
|
|
|
let last = *lis_sequence.last().unwrap();
|
|
|
|
if last < (new.len() - 1) {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.push_nodes_created(0);
|
|
|
|
state.stack.push(DiffInstruction::Mount {
|
2021-08-24 15:03:19 +00:00
|
|
|
and: MountType::InsertAfter {
|
|
|
|
other_node: &new[last],
|
|
|
|
},
|
2021-08-24 14:01:01 +00:00
|
|
|
});
|
2021-08-24 15:03:19 +00:00
|
|
|
for (idx, new_node) in new[(last + 1)..].iter().enumerate().rev() {
|
2021-11-07 00:59:46 +00:00
|
|
|
apply(idx + last + 1, new_node, &mut state.stack);
|
2021-08-24 14:01:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for idx in lis_sequence.iter().rev() {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.push(DiffInstruction::Diff {
|
2021-08-24 15:03:19 +00:00
|
|
|
new: &new[*idx],
|
|
|
|
old: &old[new_index_to_old_index[*idx]],
|
2021-08-24 14:01:01 +00:00
|
|
|
});
|
|
|
|
}
|
2021-03-03 07:27:26 +00:00
|
|
|
}
|
2021-02-14 23:03:16 +00:00
|
|
|
|
2021-08-23 16:11:45 +00:00
|
|
|
// =====================
|
|
|
|
// Utilities
|
|
|
|
// =====================
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn find_last_element(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
vnode: &'bump VNode<'bump>,
|
|
|
|
) -> Option<ElementId> {
|
2021-07-30 14:35:47 +00:00
|
|
|
let mut search_node = Some(vnode);
|
|
|
|
|
|
|
|
loop {
|
2021-08-24 15:03:19 +00:00
|
|
|
match &search_node.take().unwrap() {
|
|
|
|
VNode::Text(t) => break t.dom_id.get(),
|
|
|
|
VNode::Element(t) => break t.dom_id.get(),
|
2021-08-25 20:40:18 +00:00
|
|
|
VNode::Suspended(t) => break t.dom_id.get(),
|
2021-08-24 15:03:19 +00:00
|
|
|
VNode::Anchor(t) => break t.dom_id.get(),
|
2021-11-07 03:11:17 +00:00
|
|
|
VNode::Linked(_) => {
|
|
|
|
todo!()
|
|
|
|
}
|
2021-08-20 14:34:41 +00:00
|
|
|
VNode::Fragment(frag) => {
|
2021-07-30 14:35:47 +00:00
|
|
|
search_node = frag.children.last();
|
|
|
|
}
|
2021-08-20 14:34:41 +00:00
|
|
|
VNode::Component(el) => {
|
2021-08-27 13:53:26 +00:00
|
|
|
let scope_id = el.associated_scope.get().unwrap();
|
2021-11-07 00:59:46 +00:00
|
|
|
let scope = self.get_scope(&scope_id).unwrap();
|
2021-09-13 22:55:43 +00:00
|
|
|
search_node = Some(scope.root_node());
|
2021-07-30 14:35:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn find_first_element_id(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
vnode: &'bump VNode<'bump>,
|
|
|
|
) -> Option<ElementId> {
|
2021-07-30 14:35:47 +00:00
|
|
|
let mut search_node = Some(vnode);
|
|
|
|
|
|
|
|
loop {
|
2021-08-24 15:03:19 +00:00
|
|
|
match &search_node.take().unwrap() {
|
2021-07-30 14:35:47 +00:00
|
|
|
// the ones that have a direct id
|
2021-08-20 14:34:41 +00:00
|
|
|
VNode::Fragment(frag) => {
|
2021-07-30 14:35:47 +00:00
|
|
|
search_node = Some(&frag.children[0]);
|
|
|
|
}
|
2021-08-20 14:34:41 +00:00
|
|
|
VNode::Component(el) => {
|
2021-08-27 13:53:26 +00:00
|
|
|
let scope_id = el.associated_scope.get().unwrap();
|
2021-11-07 00:59:46 +00:00
|
|
|
let scope = self.get_scope(&scope_id).unwrap();
|
2021-09-13 22:55:43 +00:00
|
|
|
search_node = Some(scope.root_node());
|
2021-07-30 14:35:47 +00:00
|
|
|
}
|
2021-11-07 03:11:17 +00:00
|
|
|
VNode::Linked(link) => {
|
|
|
|
todo!("linked")
|
|
|
|
}
|
2021-08-24 14:01:01 +00:00
|
|
|
VNode::Text(t) => break t.dom_id.get(),
|
|
|
|
VNode::Element(t) => break t.dom_id.get(),
|
2021-08-25 20:40:18 +00:00
|
|
|
VNode::Suspended(t) => break t.dom_id.get(),
|
2021-08-24 14:01:01 +00:00
|
|
|
VNode::Anchor(t) => break t.dom_id.get(),
|
2021-07-30 14:35:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-23 14:43:49 +00:00
|
|
|
fn replace_and_create_many_with_one(
|
2021-11-07 00:59:46 +00:00
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
2021-08-23 14:43:49 +00:00
|
|
|
old: &'bump [VNode<'bump>],
|
|
|
|
new: &'bump VNode<'bump>,
|
2021-07-29 22:56:09 +00:00
|
|
|
) {
|
2021-08-23 14:43:49 +00:00
|
|
|
if let Some(first_old) = old.get(0) {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.remove_nodes(state, &old[1..], true);
|
|
|
|
state
|
|
|
|
.stack
|
2021-08-23 14:43:49 +00:00
|
|
|
.create_node(new, MountType::Replace { old: first_old });
|
|
|
|
} else {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.create_node(new, MountType::Append {});
|
2021-08-23 14:43:49 +00:00
|
|
|
}
|
|
|
|
}
|
2021-07-29 22:56:09 +00:00
|
|
|
|
2021-08-23 14:43:49 +00:00
|
|
|
/// schedules nodes for garbage collection and pushes "remove" to the mutation stack
|
|
|
|
/// remove can happen whenever
|
2021-10-25 19:05:17 +00:00
|
|
|
fn remove_nodes(
|
2021-11-07 00:59:46 +00:00
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
2021-10-25 19:05:17 +00:00
|
|
|
nodes: impl IntoIterator<Item = &'bump VNode<'bump>>,
|
|
|
|
gen_muts: bool,
|
|
|
|
) {
|
2021-08-23 14:43:49 +00:00
|
|
|
// or cache the vec on the diff machine
|
|
|
|
for node in nodes {
|
|
|
|
match node {
|
|
|
|
VNode::Text(t) => {
|
2021-10-25 19:05:17 +00:00
|
|
|
let id = t.dom_id.get().unwrap();
|
2021-11-07 00:59:46 +00:00
|
|
|
self.collect_garbage(id);
|
2021-10-25 19:05:17 +00:00
|
|
|
|
|
|
|
if gen_muts {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.remove(id.as_u64());
|
2021-09-21 22:13:09 +00:00
|
|
|
}
|
2021-07-29 22:56:09 +00:00
|
|
|
}
|
2021-08-23 14:43:49 +00:00
|
|
|
VNode::Suspended(s) => {
|
2021-10-25 19:05:17 +00:00
|
|
|
let id = s.dom_id.get().unwrap();
|
2021-11-07 00:59:46 +00:00
|
|
|
self.collect_garbage(id);
|
2021-10-25 19:05:17 +00:00
|
|
|
|
|
|
|
if gen_muts {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.remove(id.as_u64());
|
2021-09-21 22:13:09 +00:00
|
|
|
}
|
2021-08-23 14:43:49 +00:00
|
|
|
}
|
|
|
|
VNode::Anchor(a) => {
|
2021-10-25 19:05:17 +00:00
|
|
|
let id = a.dom_id.get().unwrap();
|
2021-11-07 00:59:46 +00:00
|
|
|
self.collect_garbage(id);
|
2021-10-25 19:05:17 +00:00
|
|
|
|
|
|
|
if gen_muts {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.remove(id.as_u64());
|
2021-09-21 22:13:09 +00:00
|
|
|
}
|
2021-08-23 14:43:49 +00:00
|
|
|
}
|
|
|
|
VNode::Element(e) => {
|
2021-10-25 19:05:17 +00:00
|
|
|
let id = e.dom_id.get().unwrap();
|
|
|
|
|
|
|
|
if gen_muts {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.mutations.remove(id.as_u64());
|
2021-09-21 22:13:09 +00:00
|
|
|
}
|
2021-10-25 19:05:17 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
self.remove_nodes(state, e.children, false);
|
2021-08-23 14:43:49 +00:00
|
|
|
}
|
2021-10-31 00:28:58 +00:00
|
|
|
|
2021-08-23 14:43:49 +00:00
|
|
|
VNode::Fragment(f) => {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.remove_nodes(state, f.children, gen_muts);
|
2021-08-23 14:43:49 +00:00
|
|
|
}
|
2021-08-24 15:03:19 +00:00
|
|
|
|
2021-11-07 03:11:17 +00:00
|
|
|
VNode::Linked(l) => {
|
|
|
|
todo!()
|
|
|
|
}
|
|
|
|
|
2021-08-23 14:43:49 +00:00
|
|
|
VNode::Component(c) => {
|
2021-08-27 13:53:26 +00:00
|
|
|
let scope_id = c.associated_scope.get().unwrap();
|
2021-11-07 04:06:00 +00:00
|
|
|
let scope = self.get_scope(&scope_id).unwrap();
|
2021-09-13 22:55:43 +00:00
|
|
|
let root = scope.root_node();
|
2021-11-07 00:59:46 +00:00
|
|
|
self.remove_nodes(state, Some(root), gen_muts);
|
2021-10-25 19:05:17 +00:00
|
|
|
|
|
|
|
log::debug!("Destroying scope {:?}", scope_id);
|
2021-11-07 00:59:46 +00:00
|
|
|
let mut s = self.try_remove(&scope_id).unwrap();
|
2021-10-11 22:40:00 +00:00
|
|
|
s.hooks.clear_hooks();
|
2021-07-29 22:56:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-08-23 14:43:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Remove all the old nodes and replace them with newly created new nodes.
|
|
|
|
///
|
|
|
|
/// The new nodes *will* be created - don't create them yourself!
|
|
|
|
fn replace_and_create_many_with_many(
|
2021-11-07 00:59:46 +00:00
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
2021-08-23 14:43:49 +00:00
|
|
|
old: &'bump [VNode<'bump>],
|
|
|
|
new: &'bump [VNode<'bump>],
|
|
|
|
) {
|
|
|
|
if let Some(first_old) = old.get(0) {
|
2021-11-07 00:59:46 +00:00
|
|
|
self.remove_nodes(state, &old[1..], true);
|
|
|
|
state
|
|
|
|
.stack
|
2021-08-23 14:43:49 +00:00
|
|
|
.create_children(new, MountType::Replace { old: first_old })
|
|
|
|
} else {
|
2021-11-07 00:59:46 +00:00
|
|
|
state.stack.create_children(new, MountType::Append {});
|
2021-07-29 22:56:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-24 16:43:46 +00:00
|
|
|
/// Adds a listener closure to a scope during diff.
|
2021-11-07 00:59:46 +00:00
|
|
|
fn attach_listener_to_scope(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
listener: &'bump Listener<'bump>,
|
2021-11-07 03:11:17 +00:00
|
|
|
scope: &ScopeState,
|
2021-11-07 00:59:46 +00:00
|
|
|
) {
|
|
|
|
let long_listener: &'bump Listener<'static> = unsafe { std::mem::transmute(listener) };
|
2021-11-05 20:28:08 +00:00
|
|
|
scope
|
|
|
|
.items
|
2021-11-07 00:59:46 +00:00
|
|
|
.borrow_mut()
|
2021-11-05 20:28:08 +00:00
|
|
|
.listeners
|
|
|
|
.push(long_listener as *const _)
|
2021-07-29 22:04:09 +00:00
|
|
|
}
|
2021-09-13 22:55:43 +00:00
|
|
|
|
2021-11-07 00:59:46 +00:00
|
|
|
fn attach_suspended_node_to_scope(
|
|
|
|
&'bump self,
|
|
|
|
state: &mut DiffState<'bump>,
|
|
|
|
suspended: &'bump VSuspended,
|
|
|
|
) {
|
|
|
|
if let Some(scope) = state
|
2021-09-13 22:55:43 +00:00
|
|
|
.stack
|
|
|
|
.current_scope()
|
2021-11-07 04:06:00 +00:00
|
|
|
.and_then(|id| self.get_scope(&id))
|
2021-09-13 22:55:43 +00:00
|
|
|
{
|
|
|
|
// safety: this lifetime is managed by the logic on scope
|
|
|
|
let extended: &VSuspended<'static> = unsafe { std::mem::transmute(suspended) };
|
|
|
|
scope
|
2021-11-05 20:28:08 +00:00
|
|
|
.items
|
2021-11-07 00:59:46 +00:00
|
|
|
.borrow_mut()
|
2021-09-13 22:55:43 +00:00
|
|
|
.suspended_nodes
|
|
|
|
.insert(suspended.task_id, extended as *const _);
|
|
|
|
}
|
|
|
|
}
|
2021-09-01 04:57:04 +00:00
|
|
|
}
|