make the macro compile
This commit is contained in:
Evan Almloff committed
1 parent
53094a7bbd
commit
29a61b1855
8 files changed
+1092
-1112
No files matched your search
@@ -1,255 +1,246 @@
|
||||
use anymap::AnyMap;
|
||||
use dioxus::prelude::*;
|
||||
use dioxus_native_core::node_ref::*;
|
||||
use dioxus_native_core::real_dom::*;
|
||||
use dioxus_native_core::state::{ChildDepState, NodeDepState, ParentDepState, State};
|
||||
use dioxus_native_core_macro::State;
|
||||
// use anymap::AnyMap;
|
||||
// use dioxus::prelude::*;
|
||||
// use dioxus_native_core::node_ref::*;
|
||||
// use dioxus_native_core::real_dom::*;
|
||||
// use dioxus_native_core::state::{ChildDepState, NodeDepState, ParentDepState, State};
|
||||
// use dioxus_native_core_macro::State;
|
||||
|
||||
macro_rules! dep {
|
||||
( child( $name:ty, $dep:ty ) ) => {
|
||||
impl ChildDepState for $name {
|
||||
type Ctx = ();
|
||||
type DepState = $dep;
|
||||
const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
fn reduce<'a>(
|
||||
&mut self,
|
||||
_: NodeView,
|
||||
_: impl Iterator<Item = &'a Self::DepState>,
|
||||
_: &Self::Ctx,
|
||||
) -> bool
|
||||
where
|
||||
Self::DepState: 'a,
|
||||
{
|
||||
self.0 += 1;
|
||||
true
|
||||
}
|
||||
}
|
||||
};
|
||||
// macro_rules! dep {
|
||||
// ( child( $name:ty, $dep:ty ) ) => {
|
||||
// impl ChildDepState for $name {
|
||||
// type Ctx = ();
|
||||
// type DepState = $dep;
|
||||
// const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
// fn reduce<'a>(
|
||||
// &mut self,
|
||||
// _: NodeView,
|
||||
// _: impl Iterator<Item = &'a Self::DepState>,
|
||||
// _: &Self::Ctx,
|
||||
// ) -> bool
|
||||
// where
|
||||
// Self::DepState: 'a,
|
||||
// {
|
||||
// self.0 += 1;
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
// };
|
||||
|
||||
( parent( $name:ty, $dep:ty ) ) => {
|
||||
impl ParentDepState for $name {
|
||||
type Ctx = ();
|
||||
type DepState = $dep;
|
||||
const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
fn reduce(
|
||||
&mut self,
|
||||
_: NodeView,
|
||||
_: Option<&Self::DepState>,
|
||||
_: &Self::Ctx,
|
||||
) -> bool {
|
||||
self.0 += 1;
|
||||
true
|
||||
}
|
||||
}
|
||||
};
|
||||
// ( parent( $name:ty, $dep:ty ) ) => {
|
||||
// impl ParentDepState for $name {
|
||||
// type Ctx = ();
|
||||
// type DepState = $dep;
|
||||
// const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
// fn reduce(&mut self, _: NodeView, _: Option<&Self::DepState>, _: &Self::Ctx) -> bool {
|
||||
// self.0 += 1;
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
// };
|
||||
|
||||
( node( $name:ty, ($($l:lifetime),*), $dep:ty ) ) => {
|
||||
impl<$($l),*> NodeDepState<$dep> for $name {
|
||||
type Ctx = ();
|
||||
const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
fn reduce(
|
||||
&mut self,
|
||||
_: NodeView,
|
||||
_: $dep,
|
||||
_: &Self::Ctx,
|
||||
) -> bool {
|
||||
self.0 += 1;
|
||||
true
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
// ( node( $name:ty, $dep:ty ) ) => {
|
||||
// impl NodeDepState for $name {
|
||||
// type Ctx = ();
|
||||
// type DepState<'a> = $dep;
|
||||
// const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
// fn reduce(&mut self, _: NodeView, _: $dep, _: &Self::Ctx) -> bool {
|
||||
// self.0 += 1;
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
// };
|
||||
// }
|
||||
|
||||
macro_rules! test_state{
|
||||
( $s:ty, child: ( $( $child:ident ),* ), node: ( $( $node:ident ),* ), parent: ( $( $parent:ident ),* ) ) => {
|
||||
#[test]
|
||||
fn state_reduce_initally_called_minimally() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
render!(div {
|
||||
div{
|
||||
div{
|
||||
p{}
|
||||
}
|
||||
p{
|
||||
"hello"
|
||||
}
|
||||
div{
|
||||
h1{}
|
||||
}
|
||||
p{
|
||||
"world"
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
// macro_rules! test_state{
|
||||
// ( $s:ty, child: ( $( $child:ident ),* ), node: ( $( $node:ident ),* ), parent: ( $( $parent:ident ),* ) ) => {
|
||||
// #[test]
|
||||
// fn state_reduce_initally_called_minimally() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// render!(div {
|
||||
// div{
|
||||
// div{
|
||||
// p{}
|
||||
// }
|
||||
// p{
|
||||
// "hello"
|
||||
// }
|
||||
// div{
|
||||
// h1{}
|
||||
// }
|
||||
// p{
|
||||
// "world"
|
||||
// }
|
||||
// }
|
||||
// })
|
||||
// }
|
||||
|
||||
let vdom = VirtualDom::new(Base);
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
|
||||
let mutations = vdom.create_vnodes(rsx! {
|
||||
div {
|
||||
div{
|
||||
div{
|
||||
p{}
|
||||
}
|
||||
p{
|
||||
"hello"
|
||||
}
|
||||
div{
|
||||
h1{}
|
||||
}
|
||||
p{
|
||||
"world"
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
// let mutations = vdom.create_vnodes(rsx! {
|
||||
// div {
|
||||
// div{
|
||||
// div{
|
||||
// p{}
|
||||
// }
|
||||
// p{
|
||||
// "hello"
|
||||
// }
|
||||
// div{
|
||||
// h1{}
|
||||
// }
|
||||
// p{
|
||||
// "world"
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// });
|
||||
|
||||
let mut dom: RealDom<$s> = RealDom::new();
|
||||
// let mut dom: RealDom<$s> = RealDom::new();
|
||||
|
||||
let nodes_updated = dom.apply_mutations(vec![mutations]);
|
||||
let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
// let nodes_updated = dom.apply_mutations(vec![mutations]);
|
||||
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
|
||||
dom.traverse_depth_first(|n| {
|
||||
$(
|
||||
assert_eq!(n.state.$child.0, 1);
|
||||
)*
|
||||
$(
|
||||
assert_eq!(n.state.$node.0, 1);
|
||||
)*
|
||||
$(
|
||||
assert_eq!(n.state.$parent.0, 1);
|
||||
)*
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
// dom.traverse_depth_first(|n| {
|
||||
// $(
|
||||
// assert_eq!(n.state.$child.0, 1);
|
||||
// )*
|
||||
// $(
|
||||
// assert_eq!(n.state.$node.0, 1);
|
||||
// )*
|
||||
// $(
|
||||
// assert_eq!(n.state.$parent.0, 1);
|
||||
// )*
|
||||
// });
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
|
||||
mod node_depends_on_child_and_parent {
|
||||
use super::*;
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Node(i32);
|
||||
dep!(node(Node, ('a, 'b), (&'a Child, &'b Parent)));
|
||||
// mod node_depends_on_child_and_parent {
|
||||
// use super::*;
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Node(i32);
|
||||
// dep!(node(Node, (&'a Child, &'a Parent)));
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Child(i32);
|
||||
dep!(child(Child, Child));
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Child(i32);
|
||||
// dep!(child(Child, Child));
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Parent(i32);
|
||||
dep!(parent(Parent, Parent));
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Parent(i32);
|
||||
// dep!(parent(Parent, Parent));
|
||||
|
||||
#[derive(Debug, Clone, Default, State)]
|
||||
struct StateTester {
|
||||
#[node_dep_state((child, parent))]
|
||||
node: Node,
|
||||
#[child_dep_state(child)]
|
||||
child: Child,
|
||||
#[parent_dep_state(parent)]
|
||||
parent: Parent,
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, State)]
|
||||
// struct StateTester {
|
||||
// #[node_dep_state((child, parent))]
|
||||
// node: Node,
|
||||
// #[child_dep_state(child)]
|
||||
// child: Child,
|
||||
// #[parent_dep_state(parent)]
|
||||
// parent: Parent,
|
||||
// }
|
||||
|
||||
test_state!(StateTester, child: (child), node: (node), parent: (parent));
|
||||
}
|
||||
// test_state!(StateTester, child: (child), node: (node), parent: (parent));
|
||||
// }
|
||||
|
||||
mod child_depends_on_node_that_depends_on_parent {
|
||||
use super::*;
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Node(i32);
|
||||
dep!(node(Node, ('a), (&'a Parent,)));
|
||||
// mod child_depends_on_node_that_depends_on_parent {
|
||||
// use super::*;
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Node(i32);
|
||||
// dep!(node(Node, (&'a Parent,)));
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Child(i32);
|
||||
dep!(child(Child, Node));
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Child(i32);
|
||||
// dep!(child(Child, Node));
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Parent(i32);
|
||||
dep!(parent(Parent, Parent));
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Parent(i32);
|
||||
// dep!(parent(Parent, Parent));
|
||||
|
||||
#[derive(Debug, Clone, Default, State)]
|
||||
struct StateTester {
|
||||
#[node_dep_state(parent)]
|
||||
node: Node,
|
||||
#[child_dep_state(node)]
|
||||
child: Child,
|
||||
#[parent_dep_state(parent)]
|
||||
parent: Parent,
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, State)]
|
||||
// struct StateTester {
|
||||
// #[node_dep_state(parent)]
|
||||
// node: Node,
|
||||
// #[child_dep_state(node)]
|
||||
// child: Child,
|
||||
// #[parent_dep_state(parent)]
|
||||
// parent: Parent,
|
||||
// }
|
||||
|
||||
test_state!(StateTester, child: (child), node: (node), parent: (parent));
|
||||
}
|
||||
// test_state!(StateTester, child: (child), node: (node), parent: (parent));
|
||||
// }
|
||||
|
||||
mod parent_depends_on_node_that_depends_on_child {
|
||||
use super::*;
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Node(i32);
|
||||
dep!(node(Node, ('a), (&'a Child,)));
|
||||
// mod parent_depends_on_node_that_depends_on_child {
|
||||
// use super::*;
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Node(i32);
|
||||
// dep!(node(Node, (&'a Child,)));
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Child(i32);
|
||||
dep!(child(Child, Child));
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Child(i32);
|
||||
// dep!(child(Child, Child));
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Parent(i32);
|
||||
dep!(parent(Parent, Node));
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Parent(i32);
|
||||
// dep!(parent(Parent, Node));
|
||||
|
||||
#[derive(Debug, Clone, Default, State)]
|
||||
struct StateTester {
|
||||
#[node_dep_state(child)]
|
||||
node: Node,
|
||||
#[child_dep_state(child)]
|
||||
child: Child,
|
||||
#[parent_dep_state(node)]
|
||||
parent: Parent,
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, State)]
|
||||
// struct StateTester {
|
||||
// #[node_dep_state(child)]
|
||||
// node: Node,
|
||||
// #[child_dep_state(child)]
|
||||
// child: Child,
|
||||
// #[parent_dep_state(node)]
|
||||
// parent: Parent,
|
||||
// }
|
||||
|
||||
test_state!(StateTester, child: (child), node: (node), parent: (parent));
|
||||
}
|
||||
// test_state!(StateTester, child: (child), node: (node), parent: (parent));
|
||||
// }
|
||||
|
||||
mod node_depends_on_other_node_state {
|
||||
use super::*;
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Node1(i32);
|
||||
dep!(node(Node1, ('a), (&'a Node2,)));
|
||||
// mod node_depends_on_other_node_state {
|
||||
// use super::*;
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Node1(i32);
|
||||
// dep!(node(Node1, (&'a Node2,)));
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Node2(i32);
|
||||
dep!(node(Node2, (), ()));
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Node2(i32);
|
||||
// dep!(node(Node2, ()));
|
||||
|
||||
#[derive(Debug, Clone, Default, State)]
|
||||
struct StateTester {
|
||||
#[node_dep_state((node2))]
|
||||
node1: Node1,
|
||||
#[node_dep_state()]
|
||||
node2: Node2,
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, State)]
|
||||
// struct StateTester {
|
||||
// #[node_dep_state((node2))]
|
||||
// node1: Node1,
|
||||
// #[node_dep_state()]
|
||||
// node2: Node2,
|
||||
// }
|
||||
|
||||
test_state!(StateTester, child: (), node: (node1, node2), parent: ());
|
||||
}
|
||||
// test_state!(StateTester, child: (), node: (node1, node2), parent: ());
|
||||
// }
|
||||
|
||||
mod node_child_and_parent_state_depends_on_self {
|
||||
use super::*;
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Node(i32);
|
||||
dep!(node(Node, (), ()));
|
||||
// mod node_child_and_parent_state_depends_on_self {
|
||||
// use super::*;
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Node(i32);
|
||||
// dep!(node(Node, ()));
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Child(i32);
|
||||
dep!(child(Child, Child));
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Child(i32);
|
||||
// dep!(child(Child, Child));
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct Parent(i32);
|
||||
dep!(parent(Parent, Parent));
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct Parent(i32);
|
||||
// dep!(parent(Parent, Parent));
|
||||
|
||||
#[derive(Debug, Clone, Default, State)]
|
||||
struct StateTester {
|
||||
#[node_dep_state()]
|
||||
node: Node,
|
||||
#[child_dep_state(child)]
|
||||
child: Child,
|
||||
#[parent_dep_state(parent)]
|
||||
parent: Parent,
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, State)]
|
||||
// struct StateTester {
|
||||
// #[node_dep_state()]
|
||||
// node: Node,
|
||||
// #[child_dep_state(child)]
|
||||
// child: Child,
|
||||
// #[parent_dep_state(parent)]
|
||||
// parent: Parent,
|
||||
// }
|
||||
|
||||
test_state!(StateTester, child: (child), node: (node), parent: (parent));
|
||||
}
|
||||
// test_state!(StateTester, child: (child), node: (node), parent: (parent));
|
||||
// }
|
||||
@@ -2,7 +2,8 @@ use dioxus::core::ElementId;
|
||||
use dioxus::prelude::*;
|
||||
use dioxus_native_core::real_dom::RealDom;
|
||||
use dioxus_native_core::state::State;
|
||||
use dioxus_native_core::RealNodeId;
|
||||
use dioxus_native_core::tree::*;
|
||||
use dioxus_native_core::NodeId;
|
||||
use dioxus_native_core_macro::State;
|
||||
|
||||
#[derive(State, Default, Clone)]
|
||||
@@ -34,13 +35,13 @@ fn remove_node() {
|
||||
|
||||
let _to_update = dom.apply_mutations(vec![create]);
|
||||
|
||||
assert_eq!(dom[RealNodeId::ElementId(ElementId(0))].node_data.height, 0);
|
||||
assert_eq!(dom[RealNodeId::UnaccessableId(0)].node_data.height, 1);
|
||||
assert_eq!(dom.tree.height(NodeId(0)), Some(0));
|
||||
assert_eq!(dom.tree.height(NodeId(1)), Some(1));
|
||||
|
||||
dom.apply_mutations(vec![edit]);
|
||||
|
||||
assert_eq!(dom.size(), 3);
|
||||
assert_eq!(dom[RealNodeId::ElementId(ElementId(0))].node_data.height, 0);
|
||||
assert_eq!(dom.tree.height(NodeId(0)), Some(0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -68,11 +69,11 @@ fn add_node() {
|
||||
let _to_update = dom.apply_mutations(vec![create]);
|
||||
|
||||
assert_eq!(dom.size(), 2);
|
||||
assert_eq!(dom[RealNodeId::ElementId(ElementId(2))].node_data.height, 1);
|
||||
assert_eq!(dom.tree.height(NodeId(2)), Some(1));
|
||||
|
||||
dom.apply_mutations(vec![update]);
|
||||
|
||||
assert_eq!(dom.size(), 3);
|
||||
assert_eq!(dom[RealNodeId::ElementId(ElementId(3))].node_data.height, 0);
|
||||
assert_eq!(dom[RealNodeId::UnaccessableId(0)].node_data.height, 1);
|
||||
assert_eq!(dom.tree.height(NodeId(3)), Some(0));
|
||||
assert_eq!(dom.tree.height(NodeId(0)), Some(1));
|
||||
}
|
||||
@@ -1,63 +1,63 @@
|
||||
use dioxus::core::ElementId;
|
||||
use dioxus::prelude::*;
|
||||
use dioxus_native_core::real_dom::RealDom;
|
||||
use dioxus_native_core::state::State;
|
||||
use dioxus_native_core::RealNodeId;
|
||||
use dioxus_native_core_macro::State;
|
||||
// use dioxus::core::ElementId;
|
||||
// use dioxus::prelude::*;
|
||||
// use dioxus_native_core::real_dom::RealDom;
|
||||
// use dioxus_native_core::state::State;
|
||||
// use dioxus_native_core::RealNodeId;
|
||||
// use dioxus_native_core_macro::State;
|
||||
|
||||
#[derive(Default, Clone, State)]
|
||||
struct Empty {}
|
||||
// #[derive(Default, Clone, State)]
|
||||
// struct Empty {}
|
||||
|
||||
#[test]
|
||||
fn initial_build_simple() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
render!(div {})
|
||||
}
|
||||
// #[test]
|
||||
// fn initial_build_simple() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// render!(div {})
|
||||
// }
|
||||
|
||||
let vdom = VirtualDom::new(Base);
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
|
||||
let mutations = vdom.create_vnodes(rsx! {
|
||||
div{}
|
||||
});
|
||||
// let mutations = vdom.create_vnodes(rsx! {
|
||||
// div{}
|
||||
// });
|
||||
|
||||
let mut dom: RealDom<Empty> = RealDom::new();
|
||||
// let mut dom: RealDom<Empty> = RealDom::new();
|
||||
|
||||
let _to_update = dom.apply_mutations(vec![mutations]);
|
||||
// let _to_update = dom.apply_mutations(vec![mutations]);
|
||||
|
||||
assert_eq!(dom.size(), 2);
|
||||
assert_eq!(dom[RealNodeId::ElementId(ElementId(2))].node_data.height, 1);
|
||||
}
|
||||
// assert_eq!(dom.size(), 2);
|
||||
// assert_eq!(dom[RealNodeId::ElementId(ElementId(2))].node_data.height, 1);
|
||||
// }
|
||||
|
||||
#[test]
|
||||
fn initial_build_with_children() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
render!(div {})
|
||||
}
|
||||
// #[test]
|
||||
// fn initial_build_with_children() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// render!(div {})
|
||||
// }
|
||||
|
||||
let vdom = VirtualDom::new(Base);
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
|
||||
let mutations = vdom.create_vnodes(rsx! {
|
||||
div{
|
||||
div{
|
||||
"hello"
|
||||
p{
|
||||
"world"
|
||||
}
|
||||
"hello world"
|
||||
}
|
||||
}
|
||||
});
|
||||
// let mutations = vdom.create_vnodes(rsx! {
|
||||
// div{
|
||||
// div{
|
||||
// "hello"
|
||||
// p{
|
||||
// "world"
|
||||
// }
|
||||
// "hello world"
|
||||
// }
|
||||
// }
|
||||
// });
|
||||
|
||||
let mut dom: RealDom<Empty> = RealDom::new();
|
||||
// let mut dom: RealDom<Empty> = RealDom::new();
|
||||
|
||||
let _to_update = dom.apply_mutations(vec![mutations]);
|
||||
assert_eq!(dom.size(), 2);
|
||||
assert_eq!(dom[RealNodeId::ElementId(ElementId(2))].node_data.height, 1);
|
||||
assert_eq!(dom[RealNodeId::UnaccessableId(6)].node_data.height, 2);
|
||||
assert_eq!(dom[RealNodeId::UnaccessableId(5)].node_data.height, 3);
|
||||
assert_eq!(dom[RealNodeId::UnaccessableId(8)].node_data.height, 3);
|
||||
assert_eq!(dom[RealNodeId::UnaccessableId(10)].node_data.height, 3);
|
||||
assert_eq!(dom[RealNodeId::UnaccessableId(9)].node_data.height, 4);
|
||||
}
|
||||
// let _to_update = dom.apply_mutations(vec![mutations]);
|
||||
// assert_eq!(dom.size(), 2);
|
||||
// assert_eq!(dom[RealNodeId::ElementId(ElementId(2))].node_data.height, 1);
|
||||
// assert_eq!(dom[RealNodeId::UnaccessableId(6)].node_data.height, 2);
|
||||
// assert_eq!(dom[RealNodeId::UnaccessableId(5)].node_data.height, 3);
|
||||
// assert_eq!(dom[RealNodeId::UnaccessableId(8)].node_data.height, 3);
|
||||
// assert_eq!(dom[RealNodeId::UnaccessableId(10)].node_data.height, 3);
|
||||
// assert_eq!(dom[RealNodeId::UnaccessableId(9)].node_data.height, 4);
|
||||
// }
|
||||
@@ -1,333 +1,333 @@
|
||||
use dioxus::core_macro::rsx_without_templates;
|
||||
use dioxus::prelude::*;
|
||||
use dioxus_native_core::{
|
||||
real_dom::{NodeType, RealDom},
|
||||
state::State,
|
||||
utils::PersistantElementIter,
|
||||
};
|
||||
use dioxus_native_core_macro::State;
|
||||
// use dioxus::core_macro::rsx_without_templates;
|
||||
// use dioxus::prelude::*;
|
||||
// use dioxus_native_core::{
|
||||
// real_dom::{NodeType, RealDom},
|
||||
// state::State,
|
||||
// utils::PersistantElementIter,
|
||||
// };
|
||||
// use dioxus_native_core_macro::State;
|
||||
|
||||
#[derive(State, Default, Clone)]
|
||||
struct Empty {}
|
||||
// #[derive(State, Default, Clone)]
|
||||
// struct Empty {}
|
||||
|
||||
#[test]
|
||||
#[allow(unused_variables)]
|
||||
fn traverse() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
render!(div {})
|
||||
}
|
||||
let vdom = VirtualDom::new(Base);
|
||||
let mutations = vdom.create_vnodes(rsx! {
|
||||
div{
|
||||
div{
|
||||
"hello"
|
||||
p{
|
||||
"world"
|
||||
}
|
||||
"hello world"
|
||||
}
|
||||
}
|
||||
});
|
||||
// #[test]
|
||||
// #[allow(unused_variables)]
|
||||
// fn traverse() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// render!(div {})
|
||||
// }
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
// let mutations = vdom.create_vnodes(rsx! {
|
||||
// div{
|
||||
// div{
|
||||
// "hello"
|
||||
// p{
|
||||
// "world"
|
||||
// }
|
||||
// "hello world"
|
||||
// }
|
||||
// }
|
||||
// });
|
||||
|
||||
let mut rdom: RealDom<Empty> = RealDom::new();
|
||||
// let mut rdom: RealDom<Empty> = RealDom::new();
|
||||
|
||||
let _to_update = rdom.apply_mutations(vec![mutations]);
|
||||
// let _to_update = rdom.apply_mutations(vec![mutations]);
|
||||
|
||||
let mut iter = PersistantElementIter::new();
|
||||
let div_tag = "div".to_string();
|
||||
assert!(matches!(
|
||||
&rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
NodeType::Element { tag: div_tag, .. }
|
||||
));
|
||||
assert!(matches!(
|
||||
&rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
NodeType::Element { tag: div_tag, .. }
|
||||
));
|
||||
let text1 = "hello".to_string();
|
||||
assert!(matches!(
|
||||
&rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
NodeType::Text { text: text1, .. }
|
||||
));
|
||||
let p_tag = "p".to_string();
|
||||
assert!(matches!(
|
||||
&rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
NodeType::Element { tag: p_tag, .. }
|
||||
));
|
||||
let text2 = "world".to_string();
|
||||
assert!(matches!(
|
||||
&rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
NodeType::Text { text: text2, .. }
|
||||
));
|
||||
let text3 = "hello world".to_string();
|
||||
assert!(matches!(
|
||||
&rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
NodeType::Text { text: text3, .. }
|
||||
));
|
||||
assert!(matches!(
|
||||
&rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
NodeType::Element { tag: div_tag, .. }
|
||||
));
|
||||
// let mut iter = PersistantElementIter::new();
|
||||
// let div_tag = "div".to_string();
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Element { tag: div_tag, .. }
|
||||
// ));
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Element { tag: div_tag, .. }
|
||||
// ));
|
||||
// let text1 = "hello".to_string();
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Text { text: text1, .. }
|
||||
// ));
|
||||
// let p_tag = "p".to_string();
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Element { tag: p_tag, .. }
|
||||
// ));
|
||||
// let text2 = "world".to_string();
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Text { text: text2, .. }
|
||||
// ));
|
||||
// let text3 = "hello world".to_string();
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Text { text: text3, .. }
|
||||
// ));
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.next(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Element { tag: div_tag, .. }
|
||||
// ));
|
||||
|
||||
assert!(matches!(
|
||||
&rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
NodeType::Text { text: text3, .. }
|
||||
));
|
||||
assert!(matches!(
|
||||
&rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
NodeType::Text { text: text2, .. }
|
||||
));
|
||||
assert!(matches!(
|
||||
&rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
NodeType::Element { tag: p_tag, .. }
|
||||
));
|
||||
assert!(matches!(
|
||||
&rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
NodeType::Text { text: text1, .. }
|
||||
));
|
||||
assert!(matches!(
|
||||
&rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
NodeType::Element { tag: div_tag, .. }
|
||||
));
|
||||
assert!(matches!(
|
||||
&rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
NodeType::Element { tag: div_tag, .. }
|
||||
));
|
||||
assert!(matches!(
|
||||
&rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
NodeType::Element { tag: div_tag, .. }
|
||||
));
|
||||
assert!(matches!(
|
||||
&rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
NodeType::Text { text: text3, .. }
|
||||
));
|
||||
}
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Text { text: text3, .. }
|
||||
// ));
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Text { text: text2, .. }
|
||||
// ));
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Element { tag: p_tag, .. }
|
||||
// ));
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Text { text: text1, .. }
|
||||
// ));
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Element { tag: div_tag, .. }
|
||||
// ));
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Element { tag: div_tag, .. }
|
||||
// ));
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Element { tag: div_tag, .. }
|
||||
// ));
|
||||
// assert!(matches!(
|
||||
// &rdom[iter.prev(&rdom).id()].node_data.node_type,
|
||||
// NodeType::Text { text: text3, .. }
|
||||
// ));
|
||||
// }
|
||||
|
||||
#[test]
|
||||
#[allow(unused_variables)]
|
||||
fn persist_removes() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
render!(div {})
|
||||
}
|
||||
let vdom = VirtualDom::new(Base);
|
||||
let (build, update) = vdom.diff_lazynodes(
|
||||
rsx_without_templates! {
|
||||
div{
|
||||
p{
|
||||
key: "1",
|
||||
"hello"
|
||||
}
|
||||
p{
|
||||
key: "2",
|
||||
"world"
|
||||
}
|
||||
p{
|
||||
key: "3",
|
||||
"hello world"
|
||||
}
|
||||
}
|
||||
},
|
||||
rsx_without_templates! {
|
||||
div{
|
||||
p{
|
||||
key: "1",
|
||||
"hello"
|
||||
}
|
||||
p{
|
||||
key: "3",
|
||||
"hello world"
|
||||
}
|
||||
}
|
||||
},
|
||||
);
|
||||
// #[test]
|
||||
// #[allow(unused_variables)]
|
||||
// fn persist_removes() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// render!(div {})
|
||||
// }
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
// let (build, update) = vdom.diff_lazynodes(
|
||||
// rsx_without_templates! {
|
||||
// div{
|
||||
// p{
|
||||
// key: "1",
|
||||
// "hello"
|
||||
// }
|
||||
// p{
|
||||
// key: "2",
|
||||
// "world"
|
||||
// }
|
||||
// p{
|
||||
// key: "3",
|
||||
// "hello world"
|
||||
// }
|
||||
// }
|
||||
// },
|
||||
// rsx_without_templates! {
|
||||
// div{
|
||||
// p{
|
||||
// key: "1",
|
||||
// "hello"
|
||||
// }
|
||||
// p{
|
||||
// key: "3",
|
||||
// "hello world"
|
||||
// }
|
||||
// }
|
||||
// },
|
||||
// );
|
||||
|
||||
let mut rdom: RealDom<Empty> = RealDom::new();
|
||||
// let mut rdom: RealDom<Empty> = RealDom::new();
|
||||
|
||||
let _to_update = rdom.apply_mutations(vec![build]);
|
||||
// let _to_update = rdom.apply_mutations(vec![build]);
|
||||
|
||||
// this will end on the node that is removed
|
||||
let mut iter1 = PersistantElementIter::new();
|
||||
// this will end on the after node that is removed
|
||||
let mut iter2 = PersistantElementIter::new();
|
||||
// div
|
||||
iter1.next(&rdom).id();
|
||||
iter2.next(&rdom).id();
|
||||
// p
|
||||
iter1.next(&rdom).id();
|
||||
iter2.next(&rdom).id();
|
||||
// "hello"
|
||||
iter1.next(&rdom).id();
|
||||
iter2.next(&rdom).id();
|
||||
// p
|
||||
iter1.next(&rdom).id();
|
||||
iter2.next(&rdom).id();
|
||||
// "world"
|
||||
iter1.next(&rdom).id();
|
||||
iter2.next(&rdom).id();
|
||||
// p
|
||||
iter2.next(&rdom).id();
|
||||
// "hello world"
|
||||
iter2.next(&rdom).id();
|
||||
// // this will end on the node that is removed
|
||||
// let mut iter1 = PersistantElementIter::new();
|
||||
// // this will end on the after node that is removed
|
||||
// let mut iter2 = PersistantElementIter::new();
|
||||
// // div
|
||||
// iter1.next(&rdom).id();
|
||||
// iter2.next(&rdom).id();
|
||||
// // p
|
||||
// iter1.next(&rdom).id();
|
||||
// iter2.next(&rdom).id();
|
||||
// // "hello"
|
||||
// iter1.next(&rdom).id();
|
||||
// iter2.next(&rdom).id();
|
||||
// // p
|
||||
// iter1.next(&rdom).id();
|
||||
// iter2.next(&rdom).id();
|
||||
// // "world"
|
||||
// iter1.next(&rdom).id();
|
||||
// iter2.next(&rdom).id();
|
||||
// // p
|
||||
// iter2.next(&rdom).id();
|
||||
// // "hello world"
|
||||
// iter2.next(&rdom).id();
|
||||
|
||||
iter1.prune(&update, &rdom);
|
||||
iter2.prune(&update, &rdom);
|
||||
let _to_update = rdom.apply_mutations(vec![update]);
|
||||
// iter1.prune(&update, &rdom);
|
||||
// iter2.prune(&update, &rdom);
|
||||
// let _to_update = rdom.apply_mutations(vec![update]);
|
||||
|
||||
let p_tag = "p".to_string();
|
||||
let idx = iter1.next(&rdom).id();
|
||||
assert!(matches!(
|
||||
&rdom[idx].node_data.node_type,
|
||||
NodeType::Element { tag: p_tag, .. }
|
||||
));
|
||||
let text = "hello world".to_string();
|
||||
let idx = iter1.next(&rdom).id();
|
||||
assert!(matches!(
|
||||
&rdom[idx].node_data.node_type,
|
||||
NodeType::Text { text, .. }
|
||||
));
|
||||
let div_tag = "div".to_string();
|
||||
let idx = iter2.next(&rdom).id();
|
||||
assert!(matches!(
|
||||
&rdom[idx].node_data.node_type,
|
||||
NodeType::Element { tag: div_tag, .. }
|
||||
));
|
||||
}
|
||||
// let p_tag = "p".to_string();
|
||||
// let idx = iter1.next(&rdom).id();
|
||||
// assert!(matches!(
|
||||
// &rdom[idx].node_data.node_type,
|
||||
// NodeType::Element { tag: p_tag, .. }
|
||||
// ));
|
||||
// let text = "hello world".to_string();
|
||||
// let idx = iter1.next(&rdom).id();
|
||||
// assert!(matches!(
|
||||
// &rdom[idx].node_data.node_type,
|
||||
// NodeType::Text { text, .. }
|
||||
// ));
|
||||
// let div_tag = "div".to_string();
|
||||
// let idx = iter2.next(&rdom).id();
|
||||
// assert!(matches!(
|
||||
// &rdom[idx].node_data.node_type,
|
||||
// NodeType::Element { tag: div_tag, .. }
|
||||
// ));
|
||||
// }
|
||||
|
||||
#[test]
|
||||
#[allow(unused_variables)]
|
||||
fn persist_instertions_before() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
render!(div {})
|
||||
}
|
||||
let vdom = VirtualDom::new(Base);
|
||||
let (build, update) = vdom.diff_lazynodes(
|
||||
rsx_without_templates! {
|
||||
div{
|
||||
p{
|
||||
key: "1",
|
||||
"hello"
|
||||
}
|
||||
p{
|
||||
key: "3",
|
||||
"hello world"
|
||||
}
|
||||
}
|
||||
},
|
||||
rsx_without_templates! {
|
||||
div{
|
||||
p{
|
||||
key: "1",
|
||||
"hello"
|
||||
}
|
||||
p{
|
||||
key: "2",
|
||||
"world"
|
||||
}
|
||||
p{
|
||||
key: "3",
|
||||
"hello world"
|
||||
}
|
||||
}
|
||||
},
|
||||
);
|
||||
// #[test]
|
||||
// #[allow(unused_variables)]
|
||||
// fn persist_instertions_before() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// render!(div {})
|
||||
// }
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
// let (build, update) = vdom.diff_lazynodes(
|
||||
// rsx_without_templates! {
|
||||
// div{
|
||||
// p{
|
||||
// key: "1",
|
||||
// "hello"
|
||||
// }
|
||||
// p{
|
||||
// key: "3",
|
||||
// "hello world"
|
||||
// }
|
||||
// }
|
||||
// },
|
||||
// rsx_without_templates! {
|
||||
// div{
|
||||
// p{
|
||||
// key: "1",
|
||||
// "hello"
|
||||
// }
|
||||
// p{
|
||||
// key: "2",
|
||||
// "world"
|
||||
// }
|
||||
// p{
|
||||
// key: "3",
|
||||
// "hello world"
|
||||
// }
|
||||
// }
|
||||
// },
|
||||
// );
|
||||
|
||||
let mut rdom: RealDom<Empty> = RealDom::new();
|
||||
// let mut rdom: RealDom<Empty> = RealDom::new();
|
||||
|
||||
let _to_update = rdom.apply_mutations(vec![build]);
|
||||
// let _to_update = rdom.apply_mutations(vec![build]);
|
||||
|
||||
let mut iter = PersistantElementIter::new();
|
||||
// div
|
||||
iter.next(&rdom).id();
|
||||
// p
|
||||
iter.next(&rdom).id();
|
||||
// "hello"
|
||||
iter.next(&rdom).id();
|
||||
// p
|
||||
iter.next(&rdom).id();
|
||||
// "hello world"
|
||||
iter.next(&rdom).id();
|
||||
// let mut iter = PersistantElementIter::new();
|
||||
// // div
|
||||
// iter.next(&rdom).id();
|
||||
// // p
|
||||
// iter.next(&rdom).id();
|
||||
// // "hello"
|
||||
// iter.next(&rdom).id();
|
||||
// // p
|
||||
// iter.next(&rdom).id();
|
||||
// // "hello world"
|
||||
// iter.next(&rdom).id();
|
||||
|
||||
iter.prune(&update, &rdom);
|
||||
let _to_update = rdom.apply_mutations(vec![update]);
|
||||
// iter.prune(&update, &rdom);
|
||||
// let _to_update = rdom.apply_mutations(vec![update]);
|
||||
|
||||
let p_tag = "div".to_string();
|
||||
let idx = iter.next(&rdom).id();
|
||||
assert!(matches!(
|
||||
&rdom[idx].node_data.node_type,
|
||||
NodeType::Element { tag: p_tag, .. }
|
||||
));
|
||||
}
|
||||
// let p_tag = "div".to_string();
|
||||
// let idx = iter.next(&rdom).id();
|
||||
// assert!(matches!(
|
||||
// &rdom[idx].node_data.node_type,
|
||||
// NodeType::Element { tag: p_tag, .. }
|
||||
// ));
|
||||
// }
|
||||
|
||||
#[test]
|
||||
#[allow(unused_variables)]
|
||||
fn persist_instertions_after() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
render!(div {})
|
||||
}
|
||||
let vdom = VirtualDom::new(Base);
|
||||
let (build, update) = vdom.diff_lazynodes(
|
||||
rsx_without_templates! {
|
||||
div{
|
||||
p{
|
||||
key: "1",
|
||||
"hello"
|
||||
}
|
||||
p{
|
||||
key: "2",
|
||||
"world"
|
||||
}
|
||||
}
|
||||
},
|
||||
rsx_without_templates! {
|
||||
div{
|
||||
p{
|
||||
key: "1",
|
||||
"hello"
|
||||
}
|
||||
p{
|
||||
key: "2",
|
||||
"world"
|
||||
}
|
||||
p{
|
||||
key: "3",
|
||||
"hello world"
|
||||
}
|
||||
}
|
||||
},
|
||||
);
|
||||
// #[test]
|
||||
// #[allow(unused_variables)]
|
||||
// fn persist_instertions_after() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// render!(div {})
|
||||
// }
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
// let (build, update) = vdom.diff_lazynodes(
|
||||
// rsx_without_templates! {
|
||||
// div{
|
||||
// p{
|
||||
// key: "1",
|
||||
// "hello"
|
||||
// }
|
||||
// p{
|
||||
// key: "2",
|
||||
// "world"
|
||||
// }
|
||||
// }
|
||||
// },
|
||||
// rsx_without_templates! {
|
||||
// div{
|
||||
// p{
|
||||
// key: "1",
|
||||
// "hello"
|
||||
// }
|
||||
// p{
|
||||
// key: "2",
|
||||
// "world"
|
||||
// }
|
||||
// p{
|
||||
// key: "3",
|
||||
// "hello world"
|
||||
// }
|
||||
// }
|
||||
// },
|
||||
// );
|
||||
|
||||
let mut rdom: RealDom<Empty> = RealDom::new();
|
||||
// let mut rdom: RealDom<Empty> = RealDom::new();
|
||||
|
||||
let _to_update = rdom.apply_mutations(vec![build]);
|
||||
// let _to_update = rdom.apply_mutations(vec![build]);
|
||||
|
||||
let mut iter = PersistantElementIter::new();
|
||||
// div
|
||||
iter.next(&rdom).id();
|
||||
// p
|
||||
iter.next(&rdom).id();
|
||||
// "hello"
|
||||
iter.next(&rdom).id();
|
||||
// p
|
||||
iter.next(&rdom).id();
|
||||
// "world"
|
||||
iter.next(&rdom).id();
|
||||
// let mut iter = PersistantElementIter::new();
|
||||
// // div
|
||||
// iter.next(&rdom).id();
|
||||
// // p
|
||||
// iter.next(&rdom).id();
|
||||
// // "hello"
|
||||
// iter.next(&rdom).id();
|
||||
// // p
|
||||
// iter.next(&rdom).id();
|
||||
// // "world"
|
||||
// iter.next(&rdom).id();
|
||||
|
||||
iter.prune(&update, &rdom);
|
||||
let _to_update = rdom.apply_mutations(vec![update]);
|
||||
// iter.prune(&update, &rdom);
|
||||
// let _to_update = rdom.apply_mutations(vec![update]);
|
||||
|
||||
let p_tag = "p".to_string();
|
||||
let idx = iter.next(&rdom).id();
|
||||
assert!(matches!(
|
||||
&rdom[idx].node_data.node_type,
|
||||
NodeType::Element { tag: p_tag, .. }
|
||||
));
|
||||
let text = "hello world".to_string();
|
||||
let idx = iter.next(&rdom).id();
|
||||
assert!(matches!(
|
||||
&rdom[idx].node_data.node_type,
|
||||
NodeType::Text { text, .. }
|
||||
));
|
||||
}
|
||||
// let p_tag = "p".to_string();
|
||||
// let idx = iter.next(&rdom).id();
|
||||
// assert!(matches!(
|
||||
// &rdom[idx].node_data.node_type,
|
||||
// NodeType::Element { tag: p_tag, .. }
|
||||
// ));
|
||||
// let text = "hello world".to_string();
|
||||
// let idx = iter.next(&rdom).id();
|
||||
// assert!(matches!(
|
||||
// &rdom[idx].node_data.node_type,
|
||||
// NodeType::Text { text, .. }
|
||||
// ));
|
||||
// }
|
||||
@@ -1,516 +1,516 @@
|
||||
use anymap::AnyMap;
|
||||
use dioxus::core::ElementId;
|
||||
use dioxus::core::{AttributeValue, DomEdit, Mutations};
|
||||
use dioxus::core_macro::rsx_without_templates;
|
||||
use dioxus::prelude::*;
|
||||
use dioxus_native_core::real_dom::*;
|
||||
use dioxus_native_core::state::{ChildDepState, NodeDepState, ParentDepState, State};
|
||||
use dioxus_native_core::{node_ref::*, RealNodeId};
|
||||
use dioxus_native_core_macro::State;
|
||||
// use anymap::AnyMap;
|
||||
// use dioxus::core::ElementId;
|
||||
// use dioxus::core::{AttributeValue, DomEdit, Mutations};
|
||||
// use dioxus::core_macro::rsx_without_templates;
|
||||
// use dioxus::prelude::*;
|
||||
// use dioxus_native_core::real_dom::*;
|
||||
// use dioxus_native_core::state::{ChildDepState, NodeDepState, ParentDepState, State};
|
||||
// use dioxus_native_core::{node_ref::*, RealNodeId};
|
||||
// use dioxus_native_core_macro::State;
|
||||
|
||||
#[derive(Debug, Clone, Default, State)]
|
||||
struct CallCounterStatePart1 {
|
||||
#[child_dep_state(child_counter)]
|
||||
child_counter: ChildDepCallCounter,
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, State)]
|
||||
// struct CallCounterStatePart1 {
|
||||
// #[child_dep_state(child_counter)]
|
||||
// child_counter: ChildDepCallCounter,
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, Default, State)]
|
||||
struct CallCounterStatePart2 {
|
||||
#[parent_dep_state(parent_counter)]
|
||||
parent_counter: ParentDepCallCounter,
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, State)]
|
||||
// struct CallCounterStatePart2 {
|
||||
// #[parent_dep_state(parent_counter)]
|
||||
// parent_counter: ParentDepCallCounter,
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, Default, State)]
|
||||
struct CallCounterStatePart3 {
|
||||
#[node_dep_state()]
|
||||
node_counter: NodeDepCallCounter,
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, State)]
|
||||
// struct CallCounterStatePart3 {
|
||||
// #[node_dep_state()]
|
||||
// node_counter: NodeDepCallCounter,
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, Default, State)]
|
||||
struct CallCounterState {
|
||||
#[child_dep_state(child_counter)]
|
||||
child_counter: ChildDepCallCounter,
|
||||
#[state]
|
||||
part2: CallCounterStatePart2,
|
||||
#[parent_dep_state(parent_counter)]
|
||||
parent_counter: ParentDepCallCounter,
|
||||
#[state]
|
||||
part1: CallCounterStatePart1,
|
||||
#[state]
|
||||
part3: CallCounterStatePart3,
|
||||
#[node_dep_state()]
|
||||
node_counter: NodeDepCallCounter,
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, State)]
|
||||
// struct CallCounterState {
|
||||
// #[child_dep_state(child_counter)]
|
||||
// child_counter: ChildDepCallCounter,
|
||||
// #[state]
|
||||
// part2: CallCounterStatePart2,
|
||||
// #[parent_dep_state(parent_counter)]
|
||||
// parent_counter: ParentDepCallCounter,
|
||||
// #[state]
|
||||
// part1: CallCounterStatePart1,
|
||||
// #[state]
|
||||
// part3: CallCounterStatePart3,
|
||||
// #[node_dep_state()]
|
||||
// node_counter: NodeDepCallCounter,
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, Default)]
|
||||
struct ChildDepCallCounter(u32);
|
||||
impl ChildDepState for ChildDepCallCounter {
|
||||
type Ctx = ();
|
||||
type DepState = Self;
|
||||
const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
fn reduce<'a>(
|
||||
&mut self,
|
||||
_: NodeView,
|
||||
_: impl Iterator<Item = &'a Self::DepState>,
|
||||
_: &Self::Ctx,
|
||||
) -> bool
|
||||
where
|
||||
Self::DepState: 'a,
|
||||
{
|
||||
self.0 += 1;
|
||||
true
|
||||
}
|
||||
}
|
||||
// #[derive(Debug, Clone, Default)]
|
||||
// struct ChildDepCallCounter(u32);
|
||||
// impl ChildDepState for ChildDepCallCounter {
|
||||
// type Ctx = ();
|
||||
// type DepState = Self;
|
||||
// const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
// fn reduce<'a>(
|
||||
// &mut self,
|
||||
// _: NodeView,
|
||||
// _: impl Iterator<Item = &'a Self::DepState>,
|
||||
// _: &Self::Ctx,
|
||||
// ) -> bool
|
||||
// where
|
||||
// Self::DepState: 'a,
|
||||
// {
|
||||
// self.0 += 1;
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, Default)]
|
||||
struct ParentDepCallCounter(u32);
|
||||
impl ParentDepState for ParentDepCallCounter {
|
||||
type Ctx = ();
|
||||
type DepState = Self;
|
||||
const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
fn reduce(
|
||||
&mut self,
|
||||
_node: NodeView,
|
||||
_parent: Option<&Self::DepState>,
|
||||
_ctx: &Self::Ctx,
|
||||
) -> bool {
|
||||
self.0 += 1;
|
||||
true
|
||||
}
|
||||
}
|
||||
// #[derive(Debug, Clone, Default)]
|
||||
// struct ParentDepCallCounter(u32);
|
||||
// impl ParentDepState for ParentDepCallCounter {
|
||||
// type Ctx = ();
|
||||
// type DepState = Self;
|
||||
// const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
// fn reduce(
|
||||
// &mut self,
|
||||
// _node: NodeView,
|
||||
// _parent: Option<&Self::DepState>,
|
||||
// _ctx: &Self::Ctx,
|
||||
// ) -> bool {
|
||||
// self.0 += 1;
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, Default)]
|
||||
struct NodeDepCallCounter(u32);
|
||||
impl NodeDepState<()> for NodeDepCallCounter {
|
||||
type Ctx = ();
|
||||
const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
fn reduce(&mut self, _node: NodeView, _sibling: (), _ctx: &Self::Ctx) -> bool {
|
||||
self.0 += 1;
|
||||
true
|
||||
}
|
||||
}
|
||||
// #[derive(Debug, Clone, Default)]
|
||||
// struct NodeDepCallCounter(u32);
|
||||
// impl NodeDepState<()> for NodeDepCallCounter {
|
||||
// type Ctx = ();
|
||||
// const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
// fn reduce(&mut self, _node: NodeView, _sibling: (), _ctx: &Self::Ctx) -> bool {
|
||||
// self.0 += 1;
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
|
||||
#[allow(clippy::vec_box)]
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
struct BubbledUpStateTester(Option<String>, Vec<Box<BubbledUpStateTester>>);
|
||||
impl ChildDepState for BubbledUpStateTester {
|
||||
type Ctx = u32;
|
||||
type DepState = Self;
|
||||
const NODE_MASK: NodeMask = NodeMask::new().with_tag();
|
||||
fn reduce<'a>(
|
||||
&mut self,
|
||||
node: NodeView,
|
||||
children: impl Iterator<Item = &'a Self::DepState>,
|
||||
ctx: &Self::Ctx,
|
||||
) -> bool
|
||||
where
|
||||
Self::DepState: 'a,
|
||||
{
|
||||
assert_eq!(*ctx, 42);
|
||||
*self = BubbledUpStateTester(
|
||||
node.tag().map(|s| s.to_string()),
|
||||
children.into_iter().map(|c| Box::new(c.clone())).collect(),
|
||||
);
|
||||
true
|
||||
}
|
||||
}
|
||||
// #[allow(clippy::vec_box)]
|
||||
// #[derive(Debug, Clone, PartialEq, Default)]
|
||||
// struct BubbledUpStateTester(Option<String>, Vec<Box<BubbledUpStateTester>>);
|
||||
// impl ChildDepState for BubbledUpStateTester {
|
||||
// type Ctx = u32;
|
||||
// type DepState = Self;
|
||||
// const NODE_MASK: NodeMask = NodeMask::new().with_tag();
|
||||
// fn reduce<'a>(
|
||||
// &mut self,
|
||||
// node: NodeView,
|
||||
// children: impl Iterator<Item = &'a Self::DepState>,
|
||||
// ctx: &Self::Ctx,
|
||||
// ) -> bool
|
||||
// where
|
||||
// Self::DepState: 'a,
|
||||
// {
|
||||
// assert_eq!(*ctx, 42);
|
||||
// *self = BubbledUpStateTester(
|
||||
// node.tag().map(|s| s.to_string()),
|
||||
// children.into_iter().map(|c| Box::new(c.clone())).collect(),
|
||||
// );
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
struct PushedDownStateTester(Option<String>, Option<Box<PushedDownStateTester>>);
|
||||
impl ParentDepState for PushedDownStateTester {
|
||||
type Ctx = u32;
|
||||
type DepState = Self;
|
||||
const NODE_MASK: NodeMask = NodeMask::new().with_tag();
|
||||
fn reduce(&mut self, node: NodeView, parent: Option<&Self::DepState>, ctx: &Self::Ctx) -> bool {
|
||||
assert_eq!(*ctx, 42);
|
||||
*self = PushedDownStateTester(
|
||||
node.tag().map(|s| s.to_string()),
|
||||
parent.map(|c| Box::new(c.clone())),
|
||||
);
|
||||
true
|
||||
}
|
||||
}
|
||||
// #[derive(Debug, Clone, PartialEq, Default)]
|
||||
// struct PushedDownStateTester(Option<String>, Option<Box<PushedDownStateTester>>);
|
||||
// impl ParentDepState for PushedDownStateTester {
|
||||
// type Ctx = u32;
|
||||
// type DepState = Self;
|
||||
// const NODE_MASK: NodeMask = NodeMask::new().with_tag();
|
||||
// fn reduce(&mut self, node: NodeView, parent: Option<&Self::DepState>, ctx: &Self::Ctx) -> bool {
|
||||
// assert_eq!(*ctx, 42);
|
||||
// *self = PushedDownStateTester(
|
||||
// node.tag().map(|s| s.to_string()),
|
||||
// parent.map(|c| Box::new(c.clone())),
|
||||
// );
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Default)]
|
||||
struct NodeStateTester(Option<String>, Vec<(String, String)>);
|
||||
impl NodeDepState<()> for NodeStateTester {
|
||||
type Ctx = u32;
|
||||
const NODE_MASK: NodeMask = NodeMask::new_with_attrs(AttributeMask::All).with_tag();
|
||||
fn reduce(&mut self, node: NodeView, _sibling: (), ctx: &Self::Ctx) -> bool {
|
||||
assert_eq!(*ctx, 42);
|
||||
*self = NodeStateTester(
|
||||
node.tag().map(|s| s.to_string()),
|
||||
node.attributes()
|
||||
.map(|iter| {
|
||||
iter.map(|a| {
|
||||
(
|
||||
a.attribute.name.to_string(),
|
||||
a.value.as_text().unwrap().to_string(),
|
||||
)
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default(),
|
||||
);
|
||||
true
|
||||
}
|
||||
}
|
||||
// #[derive(Debug, Clone, PartialEq, Default)]
|
||||
// struct NodeStateTester(Option<String>, Vec<(String, String)>);
|
||||
// impl NodeDepState<()> for NodeStateTester {
|
||||
// type Ctx = u32;
|
||||
// const NODE_MASK: NodeMask = NodeMask::new_with_attrs(AttributeMask::All).with_tag();
|
||||
// fn reduce(&mut self, node: NodeView, _sibling: (), ctx: &Self::Ctx) -> bool {
|
||||
// assert_eq!(*ctx, 42);
|
||||
// *self = NodeStateTester(
|
||||
// node.tag().map(|s| s.to_string()),
|
||||
// node.attributes()
|
||||
// .map(|iter| {
|
||||
// iter.map(|a| {
|
||||
// (
|
||||
// a.attribute.name.to_string(),
|
||||
// a.value.as_text().unwrap().to_string(),
|
||||
// )
|
||||
// })
|
||||
// .collect()
|
||||
// })
|
||||
// .unwrap_or_default(),
|
||||
// );
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
|
||||
#[derive(State, Clone, Default, Debug)]
|
||||
struct StateTester {
|
||||
#[child_dep_state(bubbled, u32)]
|
||||
bubbled: BubbledUpStateTester,
|
||||
#[parent_dep_state(pushed, u32)]
|
||||
pushed: PushedDownStateTester,
|
||||
#[node_dep_state(NONE, u32)]
|
||||
node: NodeStateTester,
|
||||
}
|
||||
// #[derive(State, Clone, Default, Debug)]
|
||||
// struct StateTester {
|
||||
// #[child_dep_state(bubbled, u32)]
|
||||
// bubbled: BubbledUpStateTester,
|
||||
// #[parent_dep_state(pushed, u32)]
|
||||
// pushed: PushedDownStateTester,
|
||||
// #[node_dep_state(NONE, u32)]
|
||||
// node: NodeStateTester,
|
||||
// }
|
||||
|
||||
#[test]
|
||||
fn state_initial() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
render!(div {
|
||||
p{}
|
||||
h1{}
|
||||
})
|
||||
}
|
||||
// #[test]
|
||||
// fn state_initial() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// render!(div {
|
||||
// p{}
|
||||
// h1{}
|
||||
// })
|
||||
// }
|
||||
|
||||
let vdom = VirtualDom::new(Base);
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
|
||||
let mutations = vdom.create_vnodes(rsx! {
|
||||
div {
|
||||
p{
|
||||
color: "red"
|
||||
}
|
||||
h1{}
|
||||
}
|
||||
});
|
||||
// let mutations = vdom.create_vnodes(rsx! {
|
||||
// div {
|
||||
// p{
|
||||
// color: "red"
|
||||
// }
|
||||
// h1{}
|
||||
// }
|
||||
// });
|
||||
|
||||
let mut dom: RealDom<StateTester> = RealDom::new();
|
||||
// let mut dom: RealDom<StateTester> = RealDom::new();
|
||||
|
||||
let nodes_updated = dom.apply_mutations(vec![mutations]);
|
||||
let mut ctx = AnyMap::new();
|
||||
ctx.insert(42u32);
|
||||
let _to_rerender = dom.update_state(nodes_updated, ctx);
|
||||
// let nodes_updated = dom.apply_mutations(vec![mutations]);
|
||||
// let mut ctx = AnyMap::new();
|
||||
// ctx.insert(42u32);
|
||||
// let _to_rerender = dom.update_state(nodes_updated, ctx);
|
||||
|
||||
let root_div = &dom[RealNodeId::ElementId(ElementId(2))];
|
||||
assert_eq!(root_div.state.bubbled.0, Some("div".to_string()));
|
||||
assert_eq!(
|
||||
root_div.state.bubbled.1,
|
||||
vec![
|
||||
Box::new(BubbledUpStateTester(Some("p".to_string()), Vec::new())),
|
||||
Box::new(BubbledUpStateTester(Some("h1".to_string()), Vec::new()))
|
||||
]
|
||||
);
|
||||
assert_eq!(root_div.state.pushed.0, Some("div".to_string()));
|
||||
assert_eq!(
|
||||
root_div.state.pushed.1,
|
||||
Some(Box::new(PushedDownStateTester(
|
||||
Some("Root".to_string()),
|
||||
None
|
||||
)))
|
||||
);
|
||||
assert_eq!(root_div.state.node.0, Some("div".to_string()));
|
||||
assert_eq!(root_div.state.node.1, vec![]);
|
||||
// let root_div = &dom[RealNodeId::ElementId(ElementId(2))];
|
||||
// assert_eq!(root_div.state.bubbled.0, Some("div".to_string()));
|
||||
// assert_eq!(
|
||||
// root_div.state.bubbled.1,
|
||||
// vec![
|
||||
// Box::new(BubbledUpStateTester(Some("p".to_string()), Vec::new())),
|
||||
// Box::new(BubbledUpStateTester(Some("h1".to_string()), Vec::new()))
|
||||
// ]
|
||||
// );
|
||||
// assert_eq!(root_div.state.pushed.0, Some("div".to_string()));
|
||||
// assert_eq!(
|
||||
// root_div.state.pushed.1,
|
||||
// Some(Box::new(PushedDownStateTester(
|
||||
// Some("Root".to_string()),
|
||||
// None
|
||||
// )))
|
||||
// );
|
||||
// assert_eq!(root_div.state.node.0, Some("div".to_string()));
|
||||
// assert_eq!(root_div.state.node.1, vec![]);
|
||||
|
||||
let child_p = &dom[RealNodeId::UnaccessableId(3)];
|
||||
assert_eq!(child_p.state.bubbled.0, Some("p".to_string()));
|
||||
assert_eq!(child_p.state.bubbled.1, Vec::new());
|
||||
assert_eq!(child_p.state.pushed.0, Some("p".to_string()));
|
||||
assert_eq!(
|
||||
child_p.state.pushed.1,
|
||||
Some(Box::new(PushedDownStateTester(
|
||||
Some("div".to_string()),
|
||||
Some(Box::new(PushedDownStateTester(
|
||||
Some("Root".to_string()),
|
||||
None
|
||||
)))
|
||||
)))
|
||||
);
|
||||
assert_eq!(child_p.state.node.0, Some("p".to_string()));
|
||||
assert_eq!(
|
||||
child_p.state.node.1,
|
||||
vec![("color".to_string(), "red".to_string())]
|
||||
);
|
||||
// let child_p = &dom[RealNodeId::UnaccessableId(3)];
|
||||
// assert_eq!(child_p.state.bubbled.0, Some("p".to_string()));
|
||||
// assert_eq!(child_p.state.bubbled.1, Vec::new());
|
||||
// assert_eq!(child_p.state.pushed.0, Some("p".to_string()));
|
||||
// assert_eq!(
|
||||
// child_p.state.pushed.1,
|
||||
// Some(Box::new(PushedDownStateTester(
|
||||
// Some("div".to_string()),
|
||||
// Some(Box::new(PushedDownStateTester(
|
||||
// Some("Root".to_string()),
|
||||
// None
|
||||
// )))
|
||||
// )))
|
||||
// );
|
||||
// assert_eq!(child_p.state.node.0, Some("p".to_string()));
|
||||
// assert_eq!(
|
||||
// child_p.state.node.1,
|
||||
// vec![("color".to_string(), "red".to_string())]
|
||||
// );
|
||||
|
||||
let child_h1 = &dom[RealNodeId::UnaccessableId(4)];
|
||||
assert_eq!(child_h1.state.bubbled.0, Some("h1".to_string()));
|
||||
assert_eq!(child_h1.state.bubbled.1, Vec::new());
|
||||
assert_eq!(child_h1.state.pushed.0, Some("h1".to_string()));
|
||||
assert_eq!(
|
||||
child_h1.state.pushed.1,
|
||||
Some(Box::new(PushedDownStateTester(
|
||||
Some("div".to_string()),
|
||||
Some(Box::new(PushedDownStateTester(
|
||||
Some("Root".to_string()),
|
||||
None
|
||||
)))
|
||||
)))
|
||||
);
|
||||
assert_eq!(child_h1.state.node.0, Some("h1".to_string()));
|
||||
assert_eq!(child_h1.state.node.1, vec![]);
|
||||
}
|
||||
// let child_h1 = &dom[RealNodeId::UnaccessableId(4)];
|
||||
// assert_eq!(child_h1.state.bubbled.0, Some("h1".to_string()));
|
||||
// assert_eq!(child_h1.state.bubbled.1, Vec::new());
|
||||
// assert_eq!(child_h1.state.pushed.0, Some("h1".to_string()));
|
||||
// assert_eq!(
|
||||
// child_h1.state.pushed.1,
|
||||
// Some(Box::new(PushedDownStateTester(
|
||||
// Some("div".to_string()),
|
||||
// Some(Box::new(PushedDownStateTester(
|
||||
// Some("Root".to_string()),
|
||||
// None
|
||||
// )))
|
||||
// )))
|
||||
// );
|
||||
// assert_eq!(child_h1.state.node.0, Some("h1".to_string()));
|
||||
// assert_eq!(child_h1.state.node.1, vec![]);
|
||||
// }
|
||||
|
||||
#[test]
|
||||
fn state_reduce_parent_called_minimally_on_update() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
render!(div {
|
||||
width: "100%",
|
||||
div{
|
||||
div{
|
||||
p{}
|
||||
}
|
||||
p{
|
||||
"hello"
|
||||
}
|
||||
div{
|
||||
h1{}
|
||||
}
|
||||
p{
|
||||
"world"
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
// #[test]
|
||||
// fn state_reduce_parent_called_minimally_on_update() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// render!(div {
|
||||
// width: "100%",
|
||||
// div{
|
||||
// div{
|
||||
// p{}
|
||||
// }
|
||||
// p{
|
||||
// "hello"
|
||||
// }
|
||||
// div{
|
||||
// h1{}
|
||||
// }
|
||||
// p{
|
||||
// "world"
|
||||
// }
|
||||
// }
|
||||
// })
|
||||
// }
|
||||
|
||||
let vdom = VirtualDom::new(Base);
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
|
||||
let mutations = vdom.create_vnodes(rsx_without_templates! {
|
||||
div {
|
||||
width: "100%",
|
||||
div{
|
||||
div{
|
||||
p{}
|
||||
}
|
||||
p{
|
||||
"hello"
|
||||
}
|
||||
div{
|
||||
h1{}
|
||||
}
|
||||
p{
|
||||
"world"
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
// let mutations = vdom.create_vnodes(rsx_without_templates! {
|
||||
// div {
|
||||
// width: "100%",
|
||||
// div{
|
||||
// div{
|
||||
// p{}
|
||||
// }
|
||||
// p{
|
||||
// "hello"
|
||||
// }
|
||||
// div{
|
||||
// h1{}
|
||||
// }
|
||||
// p{
|
||||
// "world"
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// });
|
||||
|
||||
let mut dom: RealDom<CallCounterState> = RealDom::new();
|
||||
// let mut dom: RealDom<CallCounterState> = RealDom::new();
|
||||
|
||||
let nodes_updated = dom.apply_mutations(vec![mutations]);
|
||||
let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
let nodes_updated = dom.apply_mutations(vec![Mutations {
|
||||
edits: vec![DomEdit::SetAttribute {
|
||||
root: Some(1),
|
||||
field: "width",
|
||||
value: AttributeValue::Text("99%"),
|
||||
ns: Some("style"),
|
||||
}],
|
||||
dirty_scopes: rustc_hash::FxHashSet::default(),
|
||||
refs: Vec::new(),
|
||||
}]);
|
||||
let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
// let nodes_updated = dom.apply_mutations(vec![mutations]);
|
||||
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
// let nodes_updated = dom.apply_mutations(vec![Mutations {
|
||||
// edits: vec![DomEdit::SetAttribute {
|
||||
// root: Some(1),
|
||||
// field: "width",
|
||||
// value: AttributeValue::Text("99%"),
|
||||
// ns: Some("style"),
|
||||
// }],
|
||||
// dirty_scopes: rustc_hash::FxHashSet::default(),
|
||||
// refs: Vec::new(),
|
||||
// }]);
|
||||
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
|
||||
dom.traverse_depth_first(|n| {
|
||||
assert_eq!(n.state.part2.parent_counter.0, 2);
|
||||
assert_eq!(n.state.parent_counter.0, 2);
|
||||
});
|
||||
}
|
||||
// dom.traverse_depth_first(|n| {
|
||||
// assert_eq!(n.state.part2.parent_counter.0, 2);
|
||||
// assert_eq!(n.state.parent_counter.0, 2);
|
||||
// });
|
||||
// }
|
||||
|
||||
#[test]
|
||||
fn state_reduce_child_called_minimally_on_update() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
cx.render(rsx_without_templates!(div {
|
||||
div{
|
||||
div{
|
||||
p{
|
||||
width: "100%",
|
||||
}
|
||||
}
|
||||
p{
|
||||
"hello"
|
||||
}
|
||||
div{
|
||||
h1{}
|
||||
}
|
||||
p{
|
||||
"world"
|
||||
}
|
||||
}
|
||||
}))
|
||||
}
|
||||
// #[test]
|
||||
// fn state_reduce_child_called_minimally_on_update() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// cx.render(rsx_without_templates!(div {
|
||||
// div{
|
||||
// div{
|
||||
// p{
|
||||
// width: "100%",
|
||||
// }
|
||||
// }
|
||||
// p{
|
||||
// "hello"
|
||||
// }
|
||||
// div{
|
||||
// h1{}
|
||||
// }
|
||||
// p{
|
||||
// "world"
|
||||
// }
|
||||
// }
|
||||
// }))
|
||||
// }
|
||||
|
||||
let vdom = VirtualDom::new(Base);
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
|
||||
let mutations = vdom.create_vnodes(rsx_without_templates! {
|
||||
div {
|
||||
div{
|
||||
div{
|
||||
p{
|
||||
width: "100%",
|
||||
}
|
||||
}
|
||||
p{
|
||||
"hello"
|
||||
}
|
||||
div{
|
||||
h1{}
|
||||
}
|
||||
p{
|
||||
"world"
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
// let mutations = vdom.create_vnodes(rsx_without_templates! {
|
||||
// div {
|
||||
// div{
|
||||
// div{
|
||||
// p{
|
||||
// width: "100%",
|
||||
// }
|
||||
// }
|
||||
// p{
|
||||
// "hello"
|
||||
// }
|
||||
// div{
|
||||
// h1{}
|
||||
// }
|
||||
// p{
|
||||
// "world"
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// });
|
||||
|
||||
let mut dom: RealDom<CallCounterState> = RealDom::new();
|
||||
// let mut dom: RealDom<CallCounterState> = RealDom::new();
|
||||
|
||||
let nodes_updated = dom.apply_mutations(vec![mutations]);
|
||||
let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
let nodes_updated = dom.apply_mutations(vec![Mutations {
|
||||
edits: vec![DomEdit::SetAttribute {
|
||||
root: Some(4),
|
||||
field: "width",
|
||||
value: AttributeValue::Text("99%"),
|
||||
ns: Some("style"),
|
||||
}],
|
||||
dirty_scopes: rustc_hash::FxHashSet::default(),
|
||||
refs: Vec::new(),
|
||||
}]);
|
||||
let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
// let nodes_updated = dom.apply_mutations(vec![mutations]);
|
||||
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
// let nodes_updated = dom.apply_mutations(vec![Mutations {
|
||||
// edits: vec![DomEdit::SetAttribute {
|
||||
// root: Some(4),
|
||||
// field: "width",
|
||||
// value: AttributeValue::Text("99%"),
|
||||
// ns: Some("style"),
|
||||
// }],
|
||||
// dirty_scopes: rustc_hash::FxHashSet::default(),
|
||||
// refs: Vec::new(),
|
||||
// }]);
|
||||
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
|
||||
dom.traverse_depth_first(|n| {
|
||||
assert_eq!(
|
||||
n.state.part1.child_counter.0,
|
||||
if let Some(RealNodeId::ElementId(ElementId(id))) = n.node_data.id {
|
||||
if id > 4 {
|
||||
1
|
||||
} else {
|
||||
2
|
||||
}
|
||||
} else {
|
||||
panic!()
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
n.state.child_counter.0,
|
||||
if let Some(RealNodeId::ElementId(ElementId(id))) = n.node_data.id {
|
||||
if id > 4 {
|
||||
1
|
||||
} else {
|
||||
2
|
||||
}
|
||||
} else {
|
||||
panic!()
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
// dom.traverse_depth_first(|n| {
|
||||
// assert_eq!(
|
||||
// n.state.part1.child_counter.0,
|
||||
// if let Some(RealNodeId::ElementId(ElementId(id))) = n.node_data.id {
|
||||
// if id > 4 {
|
||||
// 1
|
||||
// } else {
|
||||
// 2
|
||||
// }
|
||||
// } else {
|
||||
// panic!()
|
||||
// }
|
||||
// );
|
||||
// assert_eq!(
|
||||
// n.state.child_counter.0,
|
||||
// if let Some(RealNodeId::ElementId(ElementId(id))) = n.node_data.id {
|
||||
// if id > 4 {
|
||||
// 1
|
||||
// } else {
|
||||
// 2
|
||||
// }
|
||||
// } else {
|
||||
// panic!()
|
||||
// }
|
||||
// );
|
||||
// });
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, Default, State)]
|
||||
struct UnorderedDependanciesState {
|
||||
#[node_dep_state(c)]
|
||||
b: BDepCallCounter,
|
||||
#[node_dep_state()]
|
||||
c: CDepCallCounter,
|
||||
#[node_dep_state(b)]
|
||||
a: ADepCallCounter,
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, State)]
|
||||
// struct UnorderedDependanciesState {
|
||||
// #[node_dep_state(c)]
|
||||
// b: BDepCallCounter,
|
||||
// #[node_dep_state()]
|
||||
// c: CDepCallCounter,
|
||||
// #[node_dep_state(b)]
|
||||
// a: ADepCallCounter,
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct ADepCallCounter(usize, BDepCallCounter);
|
||||
impl<'a> NodeDepState<(&'a BDepCallCounter,)> for ADepCallCounter {
|
||||
type Ctx = ();
|
||||
const NODE_MASK: NodeMask = NodeMask::NONE;
|
||||
fn reduce(
|
||||
&mut self,
|
||||
_node: NodeView,
|
||||
(sibling,): (&'a BDepCallCounter,),
|
||||
_ctx: &Self::Ctx,
|
||||
) -> bool {
|
||||
self.0 += 1;
|
||||
self.1 = sibling.clone();
|
||||
true
|
||||
}
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct ADepCallCounter(usize, BDepCallCounter);
|
||||
// impl<'a> NodeDepState<(&'a BDepCallCounter,)> for ADepCallCounter {
|
||||
// type Ctx = ();
|
||||
// const NODE_MASK: NodeMask = NodeMask::NONE;
|
||||
// fn reduce(
|
||||
// &mut self,
|
||||
// _node: NodeView,
|
||||
// (sibling,): (&'a BDepCallCounter,),
|
||||
// _ctx: &Self::Ctx,
|
||||
// ) -> bool {
|
||||
// self.0 += 1;
|
||||
// self.1 = sibling.clone();
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct BDepCallCounter(usize, CDepCallCounter);
|
||||
impl<'a> NodeDepState<(&'a CDepCallCounter,)> for BDepCallCounter {
|
||||
type Ctx = ();
|
||||
const NODE_MASK: NodeMask = NodeMask::NONE;
|
||||
fn reduce(
|
||||
&mut self,
|
||||
_node: NodeView,
|
||||
(sibling,): (&'a CDepCallCounter,),
|
||||
_ctx: &Self::Ctx,
|
||||
) -> bool {
|
||||
self.0 += 1;
|
||||
self.1 = sibling.clone();
|
||||
true
|
||||
}
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct BDepCallCounter(usize, CDepCallCounter);
|
||||
// impl<'a> NodeDepState<(&'a CDepCallCounter,)> for BDepCallCounter {
|
||||
// type Ctx = ();
|
||||
// const NODE_MASK: NodeMask = NodeMask::NONE;
|
||||
// fn reduce(
|
||||
// &mut self,
|
||||
// _node: NodeView,
|
||||
// (sibling,): (&'a CDepCallCounter,),
|
||||
// _ctx: &Self::Ctx,
|
||||
// ) -> bool {
|
||||
// self.0 += 1;
|
||||
// self.1 = sibling.clone();
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq)]
|
||||
struct CDepCallCounter(usize);
|
||||
impl NodeDepState<()> for CDepCallCounter {
|
||||
type Ctx = ();
|
||||
const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
fn reduce(&mut self, _node: NodeView, _sibling: (), _ctx: &Self::Ctx) -> bool {
|
||||
self.0 += 1;
|
||||
true
|
||||
}
|
||||
}
|
||||
// #[derive(Debug, Clone, Default, PartialEq)]
|
||||
// struct CDepCallCounter(usize);
|
||||
// impl NodeDepState<()> for CDepCallCounter {
|
||||
// type Ctx = ();
|
||||
// const NODE_MASK: NodeMask = NodeMask::ALL;
|
||||
// fn reduce(&mut self, _node: NodeView, _sibling: (), _ctx: &Self::Ctx) -> bool {
|
||||
// self.0 += 1;
|
||||
// true
|
||||
// }
|
||||
// }
|
||||
|
||||
#[test]
|
||||
fn dependancies_order_independant() {
|
||||
#[allow(non_snake_case)]
|
||||
fn Base(cx: Scope) -> Element {
|
||||
render!(div {
|
||||
width: "100%",
|
||||
p{
|
||||
"hello"
|
||||
}
|
||||
})
|
||||
}
|
||||
// #[test]
|
||||
// fn dependancies_order_independant() {
|
||||
// #[allow(non_snake_case)]
|
||||
// fn Base(cx: Scope) -> Element {
|
||||
// render!(div {
|
||||
// width: "100%",
|
||||
// p{
|
||||
// "hello"
|
||||
// }
|
||||
// })
|
||||
// }
|
||||
|
||||
let vdom = VirtualDom::new(Base);
|
||||
// let vdom = VirtualDom::new(Base);
|
||||
|
||||
let mutations = vdom.create_vnodes(rsx! {
|
||||
div {
|
||||
width: "100%",
|
||||
p{
|
||||
"hello"
|
||||
}
|
||||
}
|
||||
});
|
||||
// let mutations = vdom.create_vnodes(rsx! {
|
||||
// div {
|
||||
// width: "100%",
|
||||
// p{
|
||||
// "hello"
|
||||
// }
|
||||
// }
|
||||
// });
|
||||
|
||||
let mut dom: RealDom<UnorderedDependanciesState> = RealDom::new();
|
||||
// let mut dom: RealDom<UnorderedDependanciesState> = RealDom::new();
|
||||
|
||||
let nodes_updated = dom.apply_mutations(vec![mutations]);
|
||||
let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
// let nodes_updated = dom.apply_mutations(vec![mutations]);
|
||||
// let _to_rerender = dom.update_state(nodes_updated, AnyMap::new());
|
||||
|
||||
let c = CDepCallCounter(1);
|
||||
let b = BDepCallCounter(1, c.clone());
|
||||
let a = ADepCallCounter(1, b.clone());
|
||||
dom.traverse_depth_first(|n| {
|
||||
assert_eq!(&n.state.a, &a);
|
||||
assert_eq!(&n.state.b, &b);
|
||||
assert_eq!(&n.state.c, &c);
|
||||
});
|
||||
}
|
||||
// let c = CDepCallCounter(1);
|
||||
// let b = BDepCallCounter(1, c.clone());
|
||||
// let a = ADepCallCounter(1, b.clone());
|
||||
// dom.traverse_depth_first(|n| {
|
||||
// assert_eq!(&n.state.a, &a);
|
||||
// assert_eq!(&n.state.b, &b);
|
||||
// assert_eq!(&n.state.c, &c);
|
||||
// });
|
||||
// }
|
||||
|
||||
#[derive(Clone, Default, State)]
|
||||
struct DependanciesStateTest {
|
||||
#[node_dep_state(c)]
|
||||
b: BDepCallCounter,
|
||||
#[node_dep_state()]
|
||||
c: CDepCallCounter,
|
||||
#[node_dep_state(b)]
|
||||
a: ADepCallCounter,
|
||||
#[state]
|
||||
child: UnorderedDependanciesState,
|
||||
}
|
||||
// #[derive(Clone, Default, State)]
|
||||
// struct DependanciesStateTest {
|
||||
// #[node_dep_state(c)]
|
||||
// b: BDepCallCounter,
|
||||
// #[node_dep_state()]
|
||||
// c: CDepCallCounter,
|
||||
// #[node_dep_state(b)]
|
||||
// a: ADepCallCounter,
|
||||
// #[state]
|
||||
// child: UnorderedDependanciesState,
|
||||
// }
|
||||
Reference in new issue
Block a user