Mirrors/dioxus
2
0
Fork 0
mirror of https://github.com/DioxusLabs/dioxus synced 2024-12-19 09:03:13 +00:00
Code Issues Projects Releases Packages Wiki Activity
dioxus/packages/core/src/diff.rs

1588 lines
65 KiB
Rust
Raw Normal View History

Feat: rename recoil to atoms
2021-06-16 15:19:37 +00:00
//! This module contains the stateful DiffMachine and all methods to diff VNodes, their properties, and their children.
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
//! The DiffMachine calculates the diffs between the old and new frames, updates the new nodes, and modifies the real dom.
Feat: rename recoil to atoms
2021-06-16 15:19:37 +00:00
//!
//! Notice:
//! ------
//!
wip: more work on diffing machine
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
//! Components, Fragments, Suspense, and additional batching operations.
Feat: rename recoil to atoms
2021-06-16 15:19:37 +00:00
//!
//! Implementation Details:
//! -----------------------
//!
wip: moving to imperative method of dom
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.
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
//! 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. We care about an ID size of u32
Feat: wire up a very basic dom updater
2021-02-15 04:39:46 +00:00
//!
//!
Feat: rename recoil to atoms
2021-06-16 15:19:37 +00:00
//! Further Reading and Thoughts
//! ----------------------------
Feat: wire up a very basic dom updater
2021-02-15 04:39:46 +00:00
//!
wip: broken, but solved
2021-03-03 07:27:26 +00:00
//! 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/
Feat: rename recoil to atoms
2021-06-16 15:19:37 +00:00
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
use crate::{
arena::{ScopeArena, ScopeArenaInner},
innerlude::*,
};
wip: broken, but solved
2021-03-03 07:27:26 +00:00
use fxhash::{FxHashMap, FxHashSet};
wip: staticify?
2021-03-11 17:27:01 +00:00
use std::{
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
any::Any,
wip: more progress on parity docs. Placeholders in the rsx macro for future features.
2021-05-28 16:56:21 +00:00
rc::{Rc, Weak},
wip: staticify?
2021-03-11 17:27:01 +00:00
};
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
/// The accompanying "real dom" exposes an imperative API for controlling the UI layout
///
wip: more work on diffing
2021-06-29 02:22:11 +00:00
/// Instead of having handles directly over nodes, Dioxus uses simple u64s as node IDs.
/// The expectation is that the underlying renderer will mainain their Nodes in something like slotmap or an ECS memory
/// where indexing is very fast. For reference, the slotmap in the WebSys renderer takes about 3ns to randomly access any
/// node.
///
/// 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.
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
pub trait RealDom<'a> {
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// Navigation
feat: props memoization is more powerful This commit solves the memoization , properly memoizing properties that don't have any generic parameters. This is a rough heuristic to prevent non-static lifetimes from creeping into props and breaking our minual lifetime management. Props that have a generic parameter are opted-out of the `partialeq` requirement and props *without* lifetimes must implement partialeq. We're going to leave manual disabling of memoization for future work.
2021-06-22 21:20:54 +00:00
fn push_root(&mut self, root: RealDomNode);
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// Add Nodes to the dom
feat: props memoization is more powerful This commit solves the memoization , properly memoizing properties that don't have any generic parameters. This is a rough heuristic to prevent non-static lifetimes from creeping into props and breaking our minual lifetime management. Props that have a generic parameter are opted-out of the `partialeq` requirement and props *without* lifetimes must implement partialeq. We're going to leave manual disabling of memoization for future work.
2021-06-22 21:20:54 +00:00
fn append_child(&mut self);
fn replace_with(&mut self);
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// Remove Nodesfrom the dom
feat: props memoization is more powerful This commit solves the memoization , properly memoizing properties that don't have any generic parameters. This is a rough heuristic to prevent non-static lifetimes from creeping into props and breaking our minual lifetime management. Props that have a generic parameter are opted-out of the `partialeq` requirement and props *without* lifetimes must implement partialeq. We're going to leave manual disabling of memoization for future work.
2021-06-22 21:20:54 +00:00
fn remove(&mut self);
fn remove_all_children(&mut self);
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// Create
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
fn create_text_node(&mut self, text: &'a str) -> RealDomNode;
wip: more work on diffing
2021-06-29 02:22:11 +00:00
fn create_element(&mut self, tag: &'static str, ns: Option<&'static str>) -> RealDomNode;
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
// placeholders are nodes that don't get rendered but still exist as an "anchor" in the real dom
fn create_placeholder(&mut self) -> RealDomNode;
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// events
feat: events work again!
2021-06-23 05:44:48 +00:00
fn new_event_listener(
&mut self,
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
event: &'static str,
feat: events work again!
2021-06-23 05:44:48 +00:00
scope: ScopeIdx,
element_id: usize,
realnode: RealDomNode,
);
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
fn remove_event_listener(&mut self, event: &'static str);
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// modify
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
fn set_text(&mut self, text: &'a str);
wip: more work on diffing
2021-06-29 02:22:11 +00:00
fn set_attribute(&mut self, name: &'static str, value: &'a str, ns: Option<&'a str>);
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
fn remove_attribute(&mut self, name: &'static str);
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// node ref
wip: moving to IDs
2021-06-20 06:16:42 +00:00
fn raw_node_as_any_mut(&self) -> &mut dyn Any;
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
/// The DiffState is a cursor internal to the VirtualDOM's diffing algorithm that allows persistence of state while
/// diffing trees of components. This means we can "re-enter" a subtree of a component by queuing a "NeedToDiff" event.
///
/// By re-entering via NodeDiff, we can connect disparate edits together into a single EditList. This batching of edits
/// leads to very fast re-renders (all done in a single animation frame).
///
/// It also means diffing two trees is only ever complex as diffing a single smaller tree, and then re-entering at a
/// different cursor position.
///
/// The order of these re-entrances is stored in the DiffState itself. The DiffState comes pre-loaded with a set of components
wip: staticify?
2021-03-11 17:27:01 +00:00
/// that were modified by the eventtrigger. This prevents doubly evaluating components if they were both updated via
wip: broken, but solved
2021-03-03 07:27:26 +00:00
/// subscriptions and props changes.
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
pub struct DiffMachine<'real, 'bump, Dom: RealDom<'bump>> {
pub dom: &'real mut Dom,
pub components: &'bump ScopeArena,
wip: successfully building
2021-06-07 18:14:49 +00:00
pub cur_idx: ScopeIdx,
WIP: still a bit stumped on DFS vs BFS
2021-03-05 20:02:36 +00:00
pub diffed: FxHashSet<ScopeIdx>,
wip: successfully building
2021-06-07 18:14:49 +00:00
pub event_queue: EventQueue,
pub seen_nodes: FxHashSet<ScopeIdx>,
Feat: major overhaul to diffing, using a "diffing machine" now
2021-02-14 23:03:16 +00:00
}
Feat: event loop
2021-02-12 21:11:33 +00:00
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
impl<'real, 'bump, Dom: RealDom<'bump>> DiffMachine<'real, 'bump, Dom> {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
pub fn new(
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
dom: &'real mut Dom,
components: &'bump ScopeArena,
wip: moving to IDs
2021-06-20 06:16:42 +00:00
cur_idx: ScopeIdx,
event_queue: EventQueue,
) -> Self {
Feat: wire up a very basic dom updater
2021-02-15 04:39:46 +00:00
Self {
wip: successfully building
2021-06-07 18:14:49 +00:00
components,
wip: moving to IDs
2021-06-20 06:16:42 +00:00
dom,
wip: successfully building
2021-06-07 18:14:49 +00:00
cur_idx,
event_queue,
Feat: wire up a very basic dom updater
2021-02-15 04:39:46 +00:00
diffed: FxHashSet::default(),
wip: successfully building
2021-06-07 18:14:49 +00:00
seen_nodes: FxHashSet::default(),
Feat: major overhaul to diffing, using a "diffing machine" now
2021-02-14 23:03:16 +00:00
}
}
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// Diff the `old` node with the `new` node. Emits instructions to modify a
// physical DOM node that reflects `old` into something that reflects `new`.
//
// Upon entry to this function, the physical DOM node must be on the top of the
// change list stack:
//
// [... node]
//
// The change list stack is in the same state when this function exits.
// In the case of Fragments, the parent node is on the stack
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
pub fn diff_node(&mut self, old_node: &'bump VNode<'bump>, new_node: &'bump VNode<'bump>) {
wip: broken, but solved
2021-03-03 07:27:26 +00:00
/*
For each valid case, we "commit traversal", meaning we save this current position in the tree.
Then, we diff and queue an edit event (via chagelist). s single trees - when components show up, we save that traversal and then re-enter later.
When re-entering, we reuse the EditList in DiffState
*/
wip: enable more diffing
2021-07-05 05:11:49 +00:00
log::debug!("diffing...");
match (old_node, new_node) {
// 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.
(VNode::Text(old), VNode::Text(new)) => {
if old.text != new.text {
self.dom.push_root(old.dom_id.get());
log::debug!("Text has changed {}, {}", old.text, new.text);
self.dom.set_text(new.text);
Feat: remove old macro
2021-03-14 00:11:06 +00:00
}
wip: enable more diffing
2021-07-05 05:11:49 +00:00
new.dom_id.set(old.dom_id.get());
}
WIP: still a bit stumped on DFS vs BFS
2021-03-05 20:02:36 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
(VNode::Element(old), VNode::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 {
log::debug!("things have changed....?");
self.dom.push_root(old.dom_id.get());
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
self.create(new_node);
self.dom.replace_with();
wip: enable more diffing
2021-07-05 05:11:49 +00:00
return;
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
}
wip: enable more diffing
2021-07-05 05:11:49 +00:00
log::debug!("Important Things haven't changed!");
new.dom_id.set(old.dom_id.get());
wip: successfully building
2021-06-07 18:14:49 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
self.diff_listeners(old.listeners, new.listeners);
self.diff_attr(old.attributes, new.attributes, new.namespace);
self.diff_children(old.children, new.children);
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
(VNode::Component(old), VNode::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)
// Make sure the new component vnode is referencing the right scope id
let scope_id = old.ass_scope.get();
new.ass_scope.set(scope_id);
// new.mounted_root.set(old.mounted_root.get());
// make sure the component's caller function is up to date
let scope = self.components.try_get_mut(scope_id.unwrap()).unwrap();
// .with_scope(scope_id.unwrap(), |scope| {
scope.caller = Rc::downgrade(&new.caller);
scope.update_children(new.children);
// })
// .unwrap();
// React doesn't automatically memoize, but we do.
// The cost is low enough to make it worth checking
// Rust produces fairly performant comparison methods, sometimes SIMD accelerated
// let should_render = match old.comparator {
// Some(comparator) => comparator(new),
// None => true,
// };
// if should_render {
// // self.dom.commit_traversal();
// let f = self.components.try_get_mut(scope_id.unwrap()).unwrap();
// self.components
// .with_scope(scope_id.unwrap(), |f| {
log::debug!("running scope during diff {:#?}", scope_id);
scope.run_scope().unwrap();
self.diff_node(scope.old_frame(), scope.next_frame());
log::debug!("scope completed {:#?}", scope_id);
self.seen_nodes.insert(scope_id.unwrap());
// })
// .unwrap();
// diff_machine.change_list.load_known_root(root_id);
// run the scope
//
// } else {
// log::error!("Memoized componented");
// // Component has memoized itself and doesn't need to be re-rendered.
// // We still need to make sure the child's props are up-to-date.
// // Don't commit traversal
// }
} else {
// It's an entirely different component
Feat: move the rsx macro around
2021-06-03 14:42:28 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
// A new component has shown up! We need to destroy the old node
// Wipe the old one and plant the new one
// self.dom.commit_traversal();
// self.dom.replace_node_with(old.dom_id, new.dom_id);
// self.create(new_node);
log::warn!("creating and replacing...");
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
self.create(new_node);
wip: pre vnodes instead of vnode
2021-06-08 18:00:29 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
// self.dom.replace_with();
// self.create_and_repalce(new_node, old.mounted_root.get());
// Now we need to remove the old scope and all of its descendents
let old_scope = old.ass_scope.get().unwrap();
self.destroy_scopes(old_scope);
wip: stack-based "real child iterator"
2021-06-26 07:06:29 +00:00
}
wip: enable more diffing
2021-07-05 05:11:49 +00:00
}
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
(VNode::Fragment(old), VNode::Fragment(new)) => {
log::debug!("diffing as fragment");
// 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.get(0).unwrap(), new.children.get(0).unwrap());
return;
}
Feat: rename recoil to atoms
2021-06-16 15:19:37 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
// Diff using the approach where we're looking for added or removed nodes.
if old.children.len() != new.children.len() {}
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
// Diff where we think the elements are the same
if old.children.len() == new.children.len() {}
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
self.diff_children(old.children, new.children);
// todo!()
Feat: move the rsx macro around
2021-06-03 14:42:28 +00:00
}
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
// Okay - these are the "insane" cases where the structure is entirely different.
// The factory and rsx! APIs don't really produce structures like this, so we don't take any too complicated
// code paths.
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
// in the case where the old node was a fragment but the new nodes are text,
(VNode::Fragment(_) | VNode::Component(_), VNode::Element(_) | VNode::Text(_)) => {
// find the first real element int the old node
let mut iter = RealChildIterator::new(old_node, self.components);
if let Some(first) = iter.next() {
// replace the very first node with the creation of the element or text
} else {
// there are no real elements in the old fragment...
// We need to load up the next real
}
if let VNode::Component(old) = old_node {
// schedule this component's destructor to be run
todo!()
docs: add some more sources in the core implementation
2021-06-21 05:35:12 +00:00
}
}
wip: enable more diffing
2021-07-05 05:11:49 +00:00
// In the case where real nodes are being replaced by potentially
(VNode::Element(_) | VNode::Text(_), VNode::Fragment(new)) => {
docs: add some more sources in the core implementation
2021-06-21 05:35:12 +00:00
//
}
wip: enable more diffing
2021-07-05 05:11:49 +00:00
(VNode::Text(_), VNode::Element(_)) => {
self.create(new_node);
self.dom.replace_with();
}
(VNode::Element(_), VNode::Text(_)) => {
self.create(new_node);
self.dom.replace_with();
}
_ => {
//
} /*
*/
//
// VNode::Element(old) => match new_node {
// // New node is an element, old node was en element, need to investiage more deeply
// VNode::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
// if new.tag_name != old.tag_name || new.namespace != old.namespace {
// self.create(new_node);
// self.dom.replace_with();
// return;
// }
// new.dom_id.set(old.dom_id.get());
// self.diff_listeners(old.listeners, new.listeners);
// self.diff_attr(old.attributes, new.attributes, new.namespace);
// self.diff_children(old.children, new.children);
// }
// // New node is a text element, need to replace the element with a simple text node
// VNode::Text(_) => {
// self.create(new_node);
// self.dom.replace_with();
// }
// // New node is a component
// // Make the component and replace our element on the stack with it
// VNode::Component(_) => {
// self.create(new_node);
// self.dom.replace_with();
// }
// // New node is actually a sequence of nodes.
// // We need to replace this one node with a sequence of nodes
// // Not yet implement because it's kinda hairy
// VNode::Fragment(new) => {
// match new.children.len() {
// 0 => {
// // remove
// }
// 1 => {
// // replace
// self.create(&new.children[0]);
// self.dom.replace_with();
// }
// _ => {
// todo!()
// // remove and mount many
// // self.remove_self_and_next_siblings(old)
// //
// // let iter = ChildIterator::new(new_node, self.components).rev();
// // for child in iter {}
// // for child in new.children.iter().skip(1).rev() {
// // self.dom.remove();
// // }
// }
// }
// }
// // New Node is actually suspended. Todo
// VNode::Suspended { real } => todo!(),
// },
// // Old element was text
// VNode::Text(old) => match new_node {
// VNode::Text(new) => {
// if old.text != new.text {
// log::debug!("Text has changed {}, {}", old.text, new.text);
// self.dom.set_text(new.text);
// }
// new.dom_id.set(old.dom_id.get());
// }
// VNode::Element(_) | VNode::Component(_) => {
// self.create(new_node);
// self.dom.replace_with();
// }
// // TODO on handling these types
// VNode::Fragment(frag) => {
// if frag.children.len() == 0 {
// // do nothing
// } else {
// self.create(&frag.children[0]);
// self.dom.replace_with();
// for child in frag.children.iter().skip(1) {
// self.create(child);
// self.dom.append_child();
// }
// }
// }
// VNode::Suspended { real } => todo!(),
// },
// // Old element was a component
// VNode::Component(old) => {
// match new_node {
// // It's something entirely different
// VNode::Element(_) | VNode::Text(_) => {
// self.create(new_node);
// self.dom.replace_with();
// }
// // It's also a component
// VNode::Component(new) => {
// if old.user_fc == new.user_fc {
// // Make sure we're dealing with the same component (by function pointer)
// // Make sure the new component vnode is referencing the right scope id
// let scope_id = old.ass_scope.get();
// new.ass_scope.set(scope_id);
// new.mounted_root.set(old.mounted_root.get());
// // make sure the component's caller function is up to date
// self.components
// .with_scope(scope_id.unwrap(), |scope| {
// scope.caller = Rc::downgrade(&new.caller)
// })
// .unwrap();
// // React doesn't automatically memoize, but we do.
// // The cost is low enough to make it worth checking
// // Rust produces fairly performant comparison methods, sometimes SIMD accelerated
// let should_render = match old.comparator {
// Some(comparator) => comparator(new),
// None => true,
// };
// if should_render {
// // // self.dom.commit_traversal();
// self.components
// .with_scope(scope_id.unwrap(), |f| {
// f.run_scope().unwrap();
// })
// .unwrap();
// // diff_machine.change_list.load_known_root(root_id);
// // run the scope
// //
// } else {
// // Component has memoized itself and doesn't need to be re-rendered.
// // We still need to make sure the child's props are up-to-date.
// // Don't commit traversal
// }
// } else {
// // It's an entirely different component
// // A new component has shown up! We need to destroy the old node
// // Wipe the old one and plant the new one
// // self.dom.commit_traversal();
// // self.dom.replace_node_with(old.dom_id, new.dom_id);
// // self.create(new_node);
// // self.dom.replace_with();
// self.create(new_node);
// // self.create_and_repalce(new_node, old.mounted_root.get());
// // Now we need to remove the old scope and all of its descendents
// let old_scope = old.ass_scope.get().unwrap();
// self.destroy_scopes(old_scope);
// }
// }
// VNode::Fragment(_) => todo!(),
// VNode::Suspended { real } => todo!(),
// }
// }
// VNode::Fragment(old) => {
// //
// match new_node {
// VNode::Fragment(new) => todo!(),
// // going from fragment to element means we're going from many (or potentially none) to one
// VNode::Element(new) => {}
// VNode::Text(_) => todo!(),
// VNode::Suspended { real } => todo!(),
// VNode::Component(_) => todo!(),
// }
// }
// // a suspended node will perform a mem-copy of the previous elements until it is ready
// // this means that event listeners will need to be disabled and removed
// // it also means that props will need to disabled - IE if the node "came out of hibernation" any props should be considered outdated
// VNode::Suspended { real: old_real } => {
// //
// match new_node {
// VNode::Suspended { real: new_real } => {
// //
// }
// VNode::Element(_) => todo!(),
// VNode::Text(_) => todo!(),
// VNode::Fragment(_) => todo!(),
// VNode::Component(_) => todo!(),
// }
// }
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// 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]
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
fn create(&mut self, node: &'bump VNode<'bump>) {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// debug_assert!(self.dom.traversal_is_committed());
wip: enable more diffing
2021-07-05 05:11:49 +00:00
log::warn!("Creating node!");
wip: staticify?
2021-03-11 17:27:01 +00:00
match node {
wip: merge in some code from the other branch
2021-06-06 03:47:54 +00:00
VNode::Text(text) => {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
let real_id = self.dom.create_text_node(text.text);
text.dom_id.set(real_id);
wip: staticify?
2021-03-11 17:27:01 +00:00
}
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
VNode::Element(el) => {
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
let VElement {
key,
tag_name,
listeners,
attributes,
children,
namespace,
dom_id,
} = el;
wip: staticify?
2021-03-11 17:27:01 +00:00
// log::info!("Creating {:#?}", node);
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
let real_id = if let Some(namespace) = namespace {
wip: more work on diffing
2021-06-29 02:22:11 +00:00
self.dom.create_element(tag_name, Some(namespace))
wip: staticify?
2021-03-11 17:27:01 +00:00
} else {
wip: more work on diffing
2021-06-29 02:22:11 +00:00
self.dom.create_element(tag_name, None)
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
};
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
el.dom_id.set(real_id);
wip: staticify?
2021-03-11 17:27:01 +00:00
feat: events work again!
2021-06-23 05:44:48 +00:00
listeners.iter().enumerate().for_each(|(idx, listener)| {
self.dom
.new_event_listener(listener.event, listener.scope, idx, real_id);
listener.mounted_node.set(real_id);
wip: staticify?
2021-03-11 17:27:01 +00:00
});
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
for attr in *attributes {
wip: more work on diffing
2021-06-29 02:22:11 +00:00
self.dom.set_attribute(&attr.name, &attr.value, *namespace);
wip: staticify?
2021-03-11 17:27:01 +00:00
}
// 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.
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
//
// Notice: this is a web-specific optimization and may be changed in the future
//
// TODO move over
feat: events work again!
2021-06-23 05:44:48 +00:00
// if children.len() == 1 {
// if let VNode::Text(text) = &children[0] {
// self.dom.set_text(text.text);
// return;
// }
// }
wip: staticify?
2021-03-11 17:27:01 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
for child in *children {
self.create(child);
wip: pre vnodes instead of vnode
2021-06-08 18:00:29 +00:00
if let VNode::Fragment(_) = child {
// do nothing
// fragments append themselves
} else {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
self.dom.append_child();
wip: pre vnodes instead of vnode
2021-06-08 18:00:29 +00:00
}
wip: staticify?
2021-03-11 17:27:01 +00:00
}
}
VNode::Component(component) => {
wip: enable more diffing
2021-07-05 05:11:49 +00:00
// let real_id = self.dom.create_placeholder();
wip: successfully building
2021-06-07 18:14:49 +00:00
wip: moving to imperative method of dom
2021-06-20 05:52:32 +00:00
// let root_id = next_id();
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// self.dom.save_known_root(root_id);
wip: successfully building
2021-06-07 18:14:49 +00:00
log::debug!("Mounting a new component");
let caller: Weak<OpaqueComponent> = Rc::downgrade(&component.caller);
// We're modifying the component arena while holding onto references into the assoiated bump arenas of its children
// those references are stable, even if the component arena moves around in memory, thanks to the bump arenas.
// However, there is no way to convey this to rust, so we need to use unsafe to pierce through the lifetime.
wip: pre vnodes instead of vnode
2021-06-08 18:00:29 +00:00
let parent_idx = self.cur_idx;
wip: successfully building
2021-06-07 18:14:49 +00:00
// Insert a new scope into our component list
let idx = self
.components
.with(|components| {
feat: move to slotmap
2021-06-30 02:44:21 +00:00
components.insert_with_key(|new_idx| {
wip: pre vnodes instead of vnode
2021-06-08 18:00:29 +00:00
let parent_scope = self.components.try_get(parent_idx).unwrap();
let height = parent_scope.height + 1;
wip: successfully building
2021-06-07 18:14:49 +00:00
Scope::new(
caller,
new_idx,
wip: pre vnodes instead of vnode
2021-06-08 18:00:29 +00:00
Some(parent_idx),
wip: successfully building
2021-06-07 18:14:49 +00:00
height,
self.event_queue.new_channel(height, new_idx),
self.components.clone(),
wip: pre vnodes instead of vnode
2021-06-08 18:00:29 +00:00
component.children,
wip: successfully building
2021-06-07 18:14:49 +00:00
)
})
})
.unwrap();
{
let cur_component = self.components.try_get_mut(idx).unwrap();
let mut ch = cur_component.descendents.borrow_mut();
ch.insert(idx);
std::mem::drop(ch);
}
// yaaaaay lifetimes out of thin air
// really tho, we're merging the frame lifetimes together
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
let inner: &'bump mut _ = unsafe { &mut *self.components.0.borrow().arena.get() };
wip: successfully building
2021-06-07 18:14:49 +00:00
let new_component = inner.get_mut(idx).unwrap();
// Actually initialize the caller's slot with the right address
feat: move to slotmap
2021-06-30 02:44:21 +00:00
component.ass_scope.set(Some(idx));
wip: successfully building
2021-06-07 18:14:49 +00:00
// Run the scope for one iteration to initialize it
new_component.run_scope().unwrap();
// And then run the diff algorithm
wip: enable more diffing
2021-07-05 05:11:49 +00:00
let _real_id = self.dom.create_placeholder();
feat: events work again!
2021-06-23 05:44:48 +00:00
self.diff_node(new_component.old_frame(), new_component.next_frame());
wip: successfully building
2021-06-07 18:14:49 +00:00
// Finally, insert this node as a seen node.
self.seen_nodes.insert(idx);
wip: staticify?
2021-03-11 17:27:01 +00:00
}
wip: successfully building
2021-06-07 18:14:49 +00:00
// we go the the "known root" but only operate on a sibling basis
Feat: move the rsx macro around
2021-06-03 14:42:28 +00:00
VNode::Fragment(frag) => {
wip: pre vnodes instead of vnode
2021-06-08 18:00:29 +00:00
// create the children directly in the space
for child in frag.children {
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
self.create(child);
self.dom.append_child();
wip: pre vnodes instead of vnode
2021-06-08 18:00:29 +00:00
}
}
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
VNode::Suspended { real } => {
let id = self.dom.create_placeholder();
real.set(id);
Feat: move the rsx macro around
2021-06-03 14:42:28 +00:00
}
wip: staticify?
2021-03-11 17:27:01 +00:00
}
}
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
}
wip: staticify?
2021-03-11 17:27:01 +00:00
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
impl<'a, 'bump, Dom: RealDom<'bump>> DiffMachine<'a, 'bump, Dom> {
wip: successfully building
2021-06-07 18:14:49 +00:00
/// 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.
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
fn destroy_scopes(&mut self, old_scope: ScopeIdx) {
wip: successfully building
2021-06-07 18:14:49 +00:00
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.components.try_get(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.components.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
}
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// 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.
feat: props memoization is more powerful This commit solves the memoization , properly memoizing properties that don't have any generic parameters. This is a rough heuristic to prevent non-static lifetimes from creeping into props and breaking our minual lifetime management. Props that have a generic parameter are opted-out of the `partialeq` requirement and props *without* lifetimes must implement partialeq. We're going to leave manual disabling of memoization for future work.
2021-06-22 21:20:54 +00:00
fn diff_listeners(&mut self, old: &[Listener<'_>], new: &[Listener<'_>]) {
wip: broken, but solved
2021-03-03 07:27:26 +00:00
if !old.is_empty() || !new.is_empty() {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// self.dom.commit_traversal();
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
feat: events work again!
2021-06-23 05:44:48 +00:00
// TODO
// what does "diffing listeners" even mean?
wip: broken, but solved
2021-03-03 07:27:26 +00:00
FIx: cargo fix to clean up things
2021-03-11 00:42:31 +00:00
'outer1: for (_l_idx, new_l) in new.iter().enumerate() {
wip: livehost bones
2021-03-16 15:03:59 +00:00
// 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
wip: broken, but solved
2021-03-03 07:27:26 +00:00
let event_type = new_l.event;
for old_l in old {
if new_l.event == old_l.event {
feat: events work again!
2021-06-23 05:44:48 +00:00
new_l.mounted_node.set(old_l.mounted_node.get());
// if new_l.id != old_l.id {
// self.dom.remove_event_listener(event_type);
// // TODO! we need to mess with events and assign them by RealDomNode
// // self.dom
// // .update_event_listener(event_type, new_l.scope, new_l.id)
// }
wip: livehost bones
2021-03-16 15:03:59 +00:00
wip: broken, but solved
2021-03-03 07:27:26 +00:00
continue 'outer1;
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
}
}
feat: events work again!
2021-06-23 05:44:48 +00:00
// self.dom
// .new_event_listener(event_type, new_l.scope, new_l.id);
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
feat: events work again!
2021-06-23 05:44:48 +00:00
// 'outer2: for old_l in old {
// for new_l in new {
// if new_l.event == old_l.event {
// continue 'outer2;
// }
// }
// self.dom.remove_event_listener(old_l.event);
// }
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// 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.
feat: props memoization is more powerful This commit solves the memoization , properly memoizing properties that don't have any generic parameters. This is a rough heuristic to prevent non-static lifetimes from creeping into props and breaking our minual lifetime management. Props that have a generic parameter are opted-out of the `partialeq` requirement and props *without* lifetimes must implement partialeq. We're going to leave manual disabling of memoization for future work.
2021-06-22 21:20:54 +00:00
fn diff_attr(
&mut self,
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
old: &'bump [Attribute<'bump>],
new: &'bump [Attribute<'bump>],
wip: more work on diffing
2021-06-29 02:22:11 +00:00
namespace: Option<&'bump str>,
// is_namespaced: bool,
feat: props memoization is more powerful This commit solves the memoization , properly memoizing properties that don't have any generic parameters. This is a rough heuristic to prevent non-static lifetimes from creeping into props and breaking our minual lifetime management. Props that have a generic parameter are opted-out of the `partialeq` requirement and props *without* lifetimes must implement partialeq. We're going to leave manual disabling of memoization for future work.
2021-06-22 21:20:54 +00:00
) {
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// Do O(n^2) passes to add/update and remove attributes, since
// there are almost always very few attributes.
wip: successfully building
2021-06-07 18:14:49 +00:00
//
// 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
wip: broken, but solved
2021-03-03 07:27:26 +00:00
'outer: for new_attr in new {
if new_attr.is_volatile() {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// self.dom.commit_traversal();
self.dom
wip: more work on diffing
2021-06-29 02:22:11 +00:00
.set_attribute(new_attr.name, new_attr.value, namespace);
wip: broken, but solved
2021-03-03 07:27:26 +00:00
} else {
for old_attr in old {
if old_attr.name == new_attr.name {
if old_attr.value != new_attr.value {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// self.dom.commit_traversal();
self.dom
wip: more work on diffing
2021-06-29 02:22:11 +00:00
.set_attribute(new_attr.name, new_attr.value, namespace);
Feat: wire up a very basic dom updater
2021-02-15 04:39:46 +00:00
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
continue 'outer;
wip: successfully building
2021-06-07 18:14:49 +00:00
} else {
// names are different, a varying order of attributes has arrived
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
}
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// self.dom.commit_traversal();
self.dom
wip: more work on diffing
2021-06-29 02:22:11 +00:00
.set_attribute(new_attr.name, new_attr.value, namespace);
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
}
'outer2: for old_attr in old {
for new_attr in new {
if old_attr.name == new_attr.name {
continue 'outer2;
Feat: wire up a very basic dom updater
2021-02-15 04:39:46 +00:00
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// self.dom.commit_traversal();
self.dom.remove_attribute(old_attr.name);
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
}
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: broken, but solved
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.
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
fn diff_children(&mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) {
wip: broken, but solved
2021-03-03 07:27:26 +00:00
if new.is_empty() {
if !old.is_empty() {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// self.dom.commit_traversal();
wip: broken, but solved
2021-03-03 07:27:26 +00:00
self.remove_all_children(old);
}
return;
}
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: broken, but solved
2021-03-03 07:27:26 +00:00
if new.len() == 1 {
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
match (&old.first(), &new[0]) {
(Some(VNode::Text(old_vtext)), VNode::Text(new_vtext))
if old_vtext.text == new_vtext.text =>
{
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// Don't take this fast path...
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
}
Feat: major overhaul to diffing, using a "diffing machine" now
2021-02-14 23:03:16 +00:00
feat: events work again!
2021-06-23 05:44:48 +00:00
// (_, VNode::Text(text)) => {
// // self.dom.commit_traversal();
// log::debug!("using optimized text set");
// self.dom.set_text(text.text);
// return;
// }
Feat: major overhaul to diffing, using a "diffing machine" now
2021-02-14 23:03:16 +00:00
wip: successfully building
2021-06-07 18:14:49 +00:00
// todo: any more optimizations
wip: broken, but solved
2021-03-03 07:27:26 +00:00
(_, _) => {}
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: broken, but solved
2021-03-03 07:27:26 +00:00
if old.is_empty() {
if !new.is_empty() {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// self.dom.commit_traversal();
wip: broken, but solved
2021-03-03 07:27:26 +00:00
self.create_and_append_children(new);
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
return;
}
Feat: major overhaul to diffing, using a "diffing machine" now
2021-02-14 23:03:16 +00:00
wip: broken, but solved
2021-03-03 07:27:26 +00:00
let new_is_keyed = new[0].key().is_some();
let old_is_keyed = old[0].key().is_some();
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: broken, but solved
2021-03-03 07:27:26 +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"
);
if new_is_keyed && old_is_keyed {
wip: enable more diffing
2021-07-05 05:11:49 +00:00
log::warn!("using the wrong approach");
self.diff_non_keyed_children(old, new);
// todo!("Not yet implemented a migration away from temporaries");
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// let t = self.dom.next_temporary();
// self.diff_keyed_children(old, new);
// self.dom.set_next_temporary(t);
wip: broken, but solved
2021-03-03 07:27:26 +00:00
} else {
wip: enable more diffing
2021-07-05 05:11:49 +00:00
log::debug!("diffing non keyed children");
wip: broken, but solved
2021-03-03 07:27:26 +00:00
self.diff_non_keyed_children(old, new);
}
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
}
wip: broken, but solved
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
//
// 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.
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
fn diff_keyed_children(&self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) {
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
// todo!();
if cfg!(debug_assertions) {
let mut keys = fxhash::FxHashSet::default();
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
let mut assert_unique_keys = |children: &'bump [VNode<'bump>]| {
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
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);
}
wip: broken, but solved
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.
let shared_prefix_count = match self.diff_keyed_prefix(old, new) {
KeyedPrefixResult::Finished => return,
KeyedPrefixResult::MoreWorkToDo(count) => 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)
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
}
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// 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.
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
fn diff_keyed_prefix(
&self,
old: &'bump [VNode<'bump>],
new: &'bump [VNode<'bump>],
) -> KeyedPrefixResult {
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
todo!()
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// self.dom.go_down();
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// let mut shared_prefix_count = 0;
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// for (i, (old, new)) in old.iter().zip(new.iter()).enumerate() {
// if old.key() != new.key() {
// break;
// }
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// self.dom.go_to_sibling(i);
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// self.diff_node(old, new);
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// shared_prefix_count += 1;
// }
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// // 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.dom.go_up();
// // self.dom.commit_traversal();
// self.create_and_append_children(&new[shared_prefix_count..]);
// return KeyedPrefixResult::Finished;
// }
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// // 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.dom.go_to_sibling(shared_prefix_count);
// // self.dom.commit_traversal();
// self.remove_self_and_next_siblings(&old[shared_prefix_count..]);
// return KeyedPrefixResult::Finished;
// }
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// self.dom.go_up();
// KeyedPrefixResult::MoreWorkToDo(shared_prefix_count)
Feat: wire up a very basic dom updater
2021-02-15 04:39:46 +00:00
}
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: broken, but solved
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.
//
// 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.
wip: moving to IDs
2021-06-20 06:16:42 +00:00
fn diff_keyed_middle(
&self,
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
old: &[VNode<'bump>],
mut new: &[VNode<'bump>],
wip: broken, but solved
2021-03-03 07:27:26 +00:00
shared_prefix_count: usize,
shared_suffix_count: usize,
old_shared_suffix_start: usize,
) {
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
todo!()
// // 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`.
// let mut old_key_to_old_index = FxHashMap::default();
// old_key_to_old_index.reserve(old.len());
// old_key_to_old_index.extend(old.iter().enumerate().map(|(i, o)| (o.key(), i)));
// // 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 = Vec::with_capacity(new.len());
// new_index_to_old_index.extend(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
// }
// }));
// // 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.dom.commit_traversal();
// self.remove_all_children(old);
// } else {
// self.dom.go_down_to_child(shared_prefix_count);
// // self.dom.commit_traversal();
// self.remove_self_and_next_siblings(&old[shared_prefix_count..]);
// }
// self.create_and_append_children(new);
// return;
// }
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// // 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.dom.commit_traversal();
// let mut t = self.dom.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;
// }
// }
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// // 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.dom.commit_traversal();
// self.dom.remove_child(i + shared_prefix_count);
// removed_count += 1;
// }
// }
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// // If there aren't any more new children, then we are done!
// if new.is_empty() {
// return;
// }
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// // 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.dom
// .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.dom.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.dom.commit_traversal();
// // [... parent last]
// self.dom.append_child();
// // [... parent]
// self.dom.go_down_to_temp_child(temp);
// // [... parent last]
// }
// } else {
// // self.dom.commit_traversal();
// // [... parent]
// self.create(last);
// // [... parent last]
// self.dom.append_child();
// // [... parent]
// self.dom.go_down_to_reverse_child(0);
// // [... parent last]
// }
// }
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// 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.dom.commit_traversal();
// // [... parent successor]
// self.create(new_child);
// // [... parent successor new_child]
// self.dom.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.dom.go_to_temp_sibling(temp);
// // [... parent new_child]
// } else {
// // self.dom.commit_traversal();
// // [... parent successor]
// self.dom.push_temporary(temp);
// // [... parent successor new_child]
// self.dom.insert_before();
// // [... parent new_child]
// }
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// self.diff_node(&old[old_index], new_child);
// }
// }
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// // [... parent child]
// self.dom.go_up();
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// [... parent]
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// 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.
wip: moving to IDs
2021-06-20 06:16:42 +00:00
fn diff_keyed_suffix(
&self,
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
old: &[VNode<'bump>],
new: &[VNode<'bump>],
wip: broken, but solved
2021-03-03 07:27:26 +00:00
new_shared_suffix_start: usize,
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
) {
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
todo!()
// debug_assert_eq!(old.len(), new.len());
// debug_assert!(!old.is_empty());
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// // [... parent]
// self.dom.go_down();
// // [... parent new_child]
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// for (i, (old_child, new_child)) in old.iter().zip(new.iter()).enumerate() {
// self.dom.go_to_sibling(new_shared_suffix_start + i);
// self.diff_node(old_child, new_child);
// }
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// // [... parent]
// self.dom.go_up();
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
Feat: major overhaul to diffing, using a "diffing machine" now
2021-02-14 23:03:16 +00:00
wip: broken, but solved
2021-03-03 07:27:26 +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.
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
fn diff_non_keyed_children(&mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) {
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// Handled these cases in `diff_children` before calling this function.
debug_assert!(!new.is_empty());
debug_assert!(!old.is_empty());
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// [... parent]
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// self.dom.go_down();
// self.dom.push_root()
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// [... parent child]
feat: events work again!
2021-06-23 05:44:48 +00:00
// todo!()
for (i, (new_child, old_child)) in new.iter().zip(old.iter()).enumerate() {
// [... parent prev_child]
// self.dom.go_to_sibling(i);
// [... parent this_child]
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
// let did = old_child.get_mounted_id(self.components).unwrap();
// if did.0 == 0 {
// log::debug!("Root is bad: {:#?}", old_child);
// }
// self.dom.push_root(did);
feat: events work again!
2021-06-23 05:44:48 +00:00
self.diff_node(old_child, new_child);
wip: enable more diffing
2021-07-05 05:11:49 +00:00
// 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);
// }
feat: events work again!
2021-06-23 05:44:48 +00:00
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// match old.len().cmp(&new.len()) {
// // old.len > new.len -> removing some nodes
// Ordering::Greater => {
// // [... parent prev_child]
// self.dom.go_to_sibling(new.len());
// // [... parent first_child_to_remove]
// // self.dom.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.dom.go_up();
// // [... parent]
// // self.dom.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.dom.go_up();
// // [... parent]
// }
// }
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
// ======================
// Support methods
// ======================
// 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.
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
pub fn remove_all_children(&mut self, old: &'bump [VNode<'bump>]) {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// debug_assert!(self.dom.traversal_is_committed());
WIP: Todomvc in progress
2021-05-19 14:14:02 +00:00
log::debug!("REMOVING CHILDREN");
wip: broken, but solved
2021-03-03 07:27:26 +00:00
for _child in old {
// registry.remove_subtree(child);
}
// Fast way to remove all children: set the node's textContent to an empty
// string.
wip: moving to IDs
2021-06-20 06:16:42 +00:00
todo!()
// self.dom.set_inner_text("");
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// 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.
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
pub fn create_and_append_children(&mut self, new: &'bump [VNode<'bump>]) {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// debug_assert!(self.dom.traversal_is_committed());
wip: broken, but solved
2021-03-03 07:27:26 +00:00
for child in new {
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
// self.create_and_append(node, parent)
self.create(child);
self.dom.append_child();
wip: broken, but solved
2021-03-03 07:27:26 +00:00
}
}
// 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]
feat: integrate serialization and string borrowing This commit adds lifetimes to the diff and realdom methods so consumers may borrow the contents of the DOM for serialization or asynchronous modifications.
2021-06-28 16:05:17 +00:00
pub fn remove_self_and_next_siblings(&self, old: &[VNode<'bump>]) {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// debug_assert!(self.dom.traversal_is_committed());
WIP: Todomvc in progress
2021-05-19 14:14:02 +00:00
for child in old {
if let VNode::Component(vcomp) = child {
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// dom
WIP: Todomvc in progress
2021-05-19 14:14:02 +00:00
// .create_text_node("placeholder for vcomponent");
wip: merge in some code from the other branch
2021-06-06 03:47:54 +00:00
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),
// })
WIP: Todomvc in progress
2021-05-19 14:14:02 +00:00
// let id = get_id();
// *component.stable_addr.as_ref().borrow_mut() = Some(id);
wip: moving to IDs
2021-06-20 06:16:42 +00:00
// self.dom.save_known_root(id);
WIP: Todomvc in progress
2021-05-19 14:14:02 +00:00
// 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,
// });
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
// registry.remove_subtree(child);
}
wip: get diff compiling Currently working through the normalization process. Occasionally, we want to iterate through all the nodes that we know have a real image in the dom. However, fragments and components don't directly have a mirror in the dom. This commit is exploring the concept of a custom iterator that explores every node in an array of nodes, returning only valid nodes which may be mounted to the dom. A big issue we're working through is heavily nested rootless nodes - something not terribly common but important nonetheless. Inferno, React, and Preact all perform a mutative-form of normalization which alter the children list before comparing to the previous. Mostly, we're concerned about fragments in lists and heavily nested components that do not render real elements.
2021-06-21 04:52:37 +00:00
todo!()
// self.dom.remove_self_and_next_siblings();
Feat: major overhaul, wire up event system
2021-02-12 08:07:35 +00:00
}
Feat: major overhaul to diffing, using a "diffing machine" now
2021-02-14 23:03:16 +00:00
}
wip: broken, but solved
2021-03-03 07:27:26 +00:00
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),
}
wip: stack-based "real child iterator"
2021-06-26 07:06:29 +00:00
wip: enable more diffing
2021-07-05 05:11:49 +00:00
/// 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> {
wip: stack-based "real child iterator"
2021-06-26 07:06:29 +00:00
scopes: &'a ScopeArena,
// Heuristcally we should never bleed into 5 completely nested fragments/components
// Smallvec lets us stack allocate our little stack machine so the vast majority of cases are sane
stack: smallvec::SmallVec<[(u16, &'a VNode<'a>); 5]>,
}
wip: enable more diffing
2021-07-05 05:11:49 +00:00
impl<'a> RealChildIterator<'a> {
wip: stack-based "real child iterator"
2021-06-26 07:06:29 +00:00
fn new(starter: &'a VNode<'a>, scopes: &'a ScopeArena) -> Self {
Self {
scopes,
stack: smallvec::smallvec![(0, starter)],
}
}
}
feat: move to slotmap
2021-06-30 02:44:21 +00:00
// impl<'a> DoubleEndedIterator for ChildIterator<'a> {
// fn next_back(&mut self) -> Option<Self::Item> {
// todo!()
// }
// }
wip: enable more diffing
2021-07-05 05:11:49 +00:00
impl<'a> Iterator for RealChildIterator<'a> {
wip: stack-based "real child iterator"
2021-06-26 07:06:29 +00:00
type Item = &'a VNode<'a>;
fn next(&mut self) -> Option<&'a VNode<'a>> {
let mut should_pop = false;
let mut returned_node = None;
let mut should_push = None;
while returned_node.is_none() {
if let Some((count, node)) = self.stack.last_mut() {
match node {
// We can only exit our looping when we get "real" nodes
VNode::Element(_) | VNode::Text(_) => {
// 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
VNode::Fragment(frag) => {
let _count = *count as usize;
if _count >= frag.children.len() {
should_pop = true;
} else {
should_push = Some(&frag.children[_count]);
}
}
// Immediately abort suspended nodes - can't do anything with them yet
// VNode::Suspended => should_pop = true,
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
VNode::Suspended { real } => todo!(),
wip: stack-based "real child iterator"
2021-06-26 07:06:29 +00:00
// For components, we load their root and push them onto the stack
VNode::Component(sc) => {
feat: move to slotmap
2021-06-30 02:44:21 +00:00
let scope = self.scopes.try_get(sc.ass_scope.get().unwrap()).unwrap();
wip: stack-based "real child iterator"
2021-06-26 07:06:29 +00:00
// 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
}
}
mod tests {
use super::*;
use crate as dioxus;
use crate::innerlude::*;
use crate::util::DebugDom;
use dioxus_core_macro::*;
#[test]
fn test_child_iterator() {
static App: FC<()> = |cx| {
cx.render(rsx! {
Fragment {
div {}
h1 {}
h2 {}
h3 {}
Fragment {
"internal node"
div {
"baller text shouldn't show up"
}
p {
}
Fragment {
Fragment {
"wow you really like framgents"
Fragment {
"why are you like this"
Fragment {
"just stop now please"
Fragment {
"this hurts"
Fragment {
"who needs this many fragments?????"
Fragment {
"just... fine..."
Fragment {
"no"
}
}
}
}
}
}
}
}
}
"my text node 1"
"my text node 2"
"my text node 3"
"my text node 4"
}
})
};
let mut dom = VirtualDom::new(App);
let mut renderer = DebugDom::new();
dom.rebuild(&mut renderer).unwrap();
let starter = dom.base_scope().root();
wip: enable more diffing
2021-07-05 05:11:49 +00:00
let ite = RealChildIterator::new(starter, &dom.components);
wip: stack-based "real child iterator"
2021-06-26 07:06:29 +00:00
for child in ite {
match child {
VNode::Element(el) => println!("Found: Element {}", el.tag_name),
VNode::Text(t) => println!("Found: Text {:?}", t.text),
// These would represent failing cases.
VNode::Fragment(_) => panic!("Found: Fragment"),
wip: more work on diffing machine
2021-06-27 02:13:57 +00:00
VNode::Suspended { real } => panic!("Found: Suspended"),
wip: stack-based "real child iterator"
2021-06-26 07:06:29 +00:00
VNode::Component(_) => panic!("Found: Component"),
}
}
}
}
Reference in a new issue Copy permalink