>) -> Element;
/// ```
- pub fn component(
+ pub fn component<'child, P>(
&'src self,
- component: fn(Scope<'src, P>) -> Element<'src>,
+ component: fn(Scope<'child, P>) -> Element<'child>,
props: P,
fn_name: &'static str,
) -> DynamicNode<'src>
where
+ // The properties must be valid until the next bump frame
P: Properties + 'src,
+ // The current bump allocator frame must outlive the child's borrowed props
+ 'src: 'child,
{
let vcomp = VProps::new(component, P::memoize, props);
// cast off the lifetime of the render return
- let as_dyn: Box + '_> = Box::new(vcomp);
+ let as_dyn: Box + '_> = Box::new(vcomp);
let extended: Box + 'src> = unsafe { std::mem::transmute(as_dyn) };
DynamicNode::Component(VComponent {
@@ -510,7 +464,10 @@ impl<'src> ScopeState {
let handler: &mut dyn FnMut(T) = self.bump().alloc(f);
let caller = unsafe { BumpBox::from_raw(handler as *mut dyn FnMut(T)) };
let callback = RefCell::new(Some(caller));
- EventHandler { callback }
+ EventHandler {
+ callback,
+ origin: self.context().id,
+ }
}
/// Create a new [`AttributeValue`] with the listener variant from a callback
@@ -564,7 +521,8 @@ impl<'src> ScopeState {
/// Mark this component as suspended and then return None
pub fn suspend(&self) -> Option {
- self.suspended.set(true);
+ let cx = self.context();
+ cx.suspend();
None
}
diff --git a/packages/core/src/virtual_dom.rs b/packages/core/src/virtual_dom.rs
index dce5415f6..c2e56c776 100644
--- a/packages/core/src/virtual_dom.rs
+++ b/packages/core/src/virtual_dom.rs
@@ -9,6 +9,7 @@ use crate::{
mutations::Mutation,
nodes::RenderReturn,
nodes::{Template, TemplateId},
+ runtime::{Runtime, RuntimeGuard},
scopes::{ScopeId, ScopeState},
AttributeValue, Element, Event, Scope,
};
@@ -174,24 +175,24 @@ use std::{any::Any, cell::Cell, collections::BTreeSet, future::Future, rc::Rc};
/// }
/// ```
pub struct VirtualDom {
+ pub(crate) scopes: Slab>,
+
+ pub(crate) dirty_scopes: BTreeSet,
+
// Maps a template path to a map of byteindexes to templates
pub(crate) templates: FxHashMap>>,
- pub(crate) scopes: Slab>,
- pub(crate) dirty_scopes: BTreeSet,
- pub(crate) scheduler: Rc,
// Every element is actually a dual reference - one to the template and the other to the dynamic node in that template
pub(crate) elements: Slab,
- // While diffing we need some sort of way of breaking off a stream of suspended mutations.
- pub(crate) scope_stack: Vec,
+ pub(crate) mutations: Mutations<'static>,
+
+ pub(crate) runtime: Rc,
// Currently suspended scopes
pub(crate) suspended_scopes: FxHashSet,
pub(crate) rx: futures_channel::mpsc::UnboundedReceiver,
-
- pub(crate) mutations: Mutations<'static>,
}
impl VirtualDom {
@@ -251,16 +252,16 @@ impl VirtualDom {
/// ```
pub fn new_with_props(root: fn(Scope) -> Element, root_props: P) -> Self {
let (tx, rx) = futures_channel::mpsc::unbounded();
+ let scheduler = Scheduler::new(tx);
let mut dom = Self {
rx,
- scheduler: Scheduler::new(tx),
- templates: Default::default(),
+ runtime: Runtime::new(scheduler),
scopes: Default::default(),
+ dirty_scopes: Default::default(),
+ templates: Default::default(),
elements: Default::default(),
- scope_stack: Vec::new(),
- dirty_scopes: BTreeSet::new(),
- suspended_scopes: FxHashSet::default(),
mutations: Mutations::default(),
+ suspended_scopes: Default::default(),
};
let root = dom.new_scope(
@@ -269,7 +270,7 @@ impl VirtualDom {
);
// Unlike react, we provide a default error boundary that just renders the error as a string
- root.provide_context(Rc::new(ErrorBoundary::new(ScopeId(0))));
+ root.provide_context(Rc::new(ErrorBoundary::new(ScopeId::ROOT)));
// the root element is always given element ID 0 since it's the container for the entire tree
dom.elements.insert(ElementRef::none());
@@ -281,14 +282,14 @@ impl VirtualDom {
///
/// This is useful for inserting or removing contexts from a scope, or rendering out its root node
pub fn get_scope(&self, id: ScopeId) -> Option<&ScopeState> {
- self.scopes.get(id.0).map(|f| f.as_ref())
+ self.scopes.get(id.0).map(|s| &**s)
}
/// Get the single scope at the top of the VirtualDom tree that will always be around
///
/// This scope has a ScopeId of 0 and is the root of the tree
pub fn base_scope(&self) -> &ScopeState {
- self.get_scope(ScopeId(0)).unwrap()
+ self.get_scope(ScopeId::ROOT).unwrap()
}
/// Build the virtualdom with a global context inserted into the base scope
@@ -301,10 +302,10 @@ impl VirtualDom {
/// Manually mark a scope as requiring a re-render
///
- /// Whenever the VirtualDom "works", it will re-render this scope
+ /// Whenever the Runtime "works", it will re-render this scope
pub fn mark_dirty(&mut self, id: ScopeId) {
if let Some(scope) = self.get_scope(id) {
- let height = scope.height;
+ let height = scope.height();
self.dirty_scopes.insert(DirtyScope { height, id });
}
}
@@ -325,6 +326,8 @@ impl VirtualDom {
element: ElementId,
bubbles: bool,
) {
+ let _runtime = RuntimeGuard::new(self.runtime.clone());
+
/*
------------------------
The algorithm works by walking through the list of dynamic attributes, checking their paths, and breaking when
@@ -387,9 +390,14 @@ impl VirtualDom {
// We check the bubble state between each call to see if the event has been stopped from bubbling
for listener in listeners.drain(..).rev() {
if let AttributeValue::Listener(listener) = listener {
+ let origin = el_ref.scope;
+ self.runtime.scope_stack.borrow_mut().push(origin);
+ self.runtime.rendering.set(false);
if let Some(cb) = listener.borrow_mut().as_deref_mut() {
cb(uievent.clone());
}
+ self.runtime.scope_stack.borrow_mut().pop();
+ self.runtime.rendering.set(true);
if !uievent.propagates.get() {
return;
@@ -418,9 +426,14 @@ impl VirtualDom {
// Only call the listener if this is the exact target element.
if attr.name.trim_start_matches("on") == name && target_path == this_path {
if let AttributeValue::Listener(listener) = &attr.value {
+ let origin = el_ref.scope;
+ self.runtime.scope_stack.borrow_mut().push(origin);
+ self.runtime.rendering.set(false);
if let Some(cb) = listener.borrow_mut().as_deref_mut() {
cb(uievent.clone());
}
+ self.runtime.scope_stack.borrow_mut().pop();
+ self.runtime.rendering.set(true);
break;
}
@@ -501,10 +514,11 @@ impl VirtualDom {
if sync.template.get().name.rsplit_once(':').unwrap().0
== template.name.rsplit_once(':').unwrap().0
{
- let height = scope.height;
+ let context = scope.context();
+ let height = context.height;
self.dirty_scopes.insert(DirtyScope {
height,
- id: scope.id,
+ id: context.id,
});
}
}
@@ -532,10 +546,11 @@ impl VirtualDom {
/// apply_edits(edits);
/// ```
pub fn rebuild(&mut self) -> Mutations {
- match unsafe { self.run_scope(ScopeId(0)).extend_lifetime_ref() } {
+ let _runtime = RuntimeGuard::new(self.runtime.clone());
+ match unsafe { self.run_scope(ScopeId::ROOT).extend_lifetime_ref() } {
// Rebuilding implies we append the created elements to the root
RenderReturn::Ready(node) => {
- let m = self.create_scope(ScopeId(0), node);
+ let m = self.create_scope(ScopeId::ROOT, node);
self.mutations.edits.push(Mutation::AppendChildren {
id: ElementId(0),
m,
@@ -610,9 +625,12 @@ impl VirtualDom {
continue;
}
- // Run the scope and get the mutations
- self.run_scope(dirty.id);
- self.diff_scope(dirty.id);
+ {
+ let _runtime = RuntimeGuard::new(self.runtime.clone());
+ // Run the scope and get the mutations
+ self.run_scope(dirty.id);
+ self.diff_scope(dirty.id);
+ }
}
// If there's more work, then just continue, plenty of work to do
@@ -645,6 +663,6 @@ impl VirtualDom {
impl Drop for VirtualDom {
fn drop(&mut self) {
// Simply drop this scope which drops all of its children
- self.drop_scope(ScopeId(0), true);
+ self.drop_scope(ScopeId::ROOT, true);
}
}
diff --git a/packages/core/tests/attr_cleanup.rs b/packages/core/tests/attr_cleanup.rs
index 683f02260..539a0b399 100644
--- a/packages/core/tests/attr_cleanup.rs
+++ b/packages/core/tests/attr_cleanup.rs
@@ -34,7 +34,7 @@ fn attrs_cycle() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -56,7 +56,7 @@ fn attrs_cycle() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -65,7 +65,7 @@ fn attrs_cycle() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -88,7 +88,7 @@ fn attrs_cycle() {
);
// we take the node taken by attributes since we reused it
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
diff --git a/packages/core/tests/bubble_error.rs b/packages/core/tests/bubble_error.rs
index 7d6966c46..af2a34219 100644
--- a/packages/core/tests/bubble_error.rs
+++ b/packages/core/tests/bubble_error.rs
@@ -24,7 +24,7 @@ fn bubbles_error() {
let _edits = dom.rebuild().santize();
}
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
_ = dom.render_immediate();
}
diff --git a/packages/core/tests/context_api.rs b/packages/core/tests/context_api.rs
index 696810cb0..05c66a41e 100644
--- a/packages/core/tests/context_api.rs
+++ b/packages/core/tests/context_api.rs
@@ -27,11 +27,11 @@ fn state_shares() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
_ = dom.render_immediate();
assert_eq!(dom.base_scope().consume_context::().unwrap(), 1);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
_ = dom.render_immediate();
assert_eq!(dom.base_scope().consume_context::().unwrap(), 2);
@@ -41,7 +41,7 @@ fn state_shares() {
[SetText { value: "Value is 2", id: ElementId(1,) },]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
dom.mark_dirty(ScopeId(2));
let edits = dom.render_immediate();
assert_eq!(
diff --git a/packages/core/tests/cycle.rs b/packages/core/tests/cycle.rs
index 10498f5cc..20d1c9343 100644
--- a/packages/core/tests/cycle.rs
+++ b/packages/core/tests/cycle.rs
@@ -23,7 +23,7 @@ fn cycling_elements() {
);
}
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -33,7 +33,7 @@ fn cycling_elements() {
);
// notice that the IDs cycle back to ElementId(1), preserving a minimal memory footprint
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -42,7 +42,7 @@ fn cycling_elements() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
diff --git a/packages/core/tests/diff_component.rs b/packages/core/tests/diff_component.rs
index 69ab6de6d..4766ad378 100644
--- a/packages/core/tests/diff_component.rs
+++ b/packages/core/tests/diff_component.rs
@@ -75,7 +75,7 @@ fn component_swap() {
);
}
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -84,7 +84,7 @@ fn component_swap() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -93,7 +93,7 @@ fn component_swap() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
diff --git a/packages/core/tests/diff_element.rs b/packages/core/tests/diff_element.rs
index 3ab9b284a..a0b9bfa84 100644
--- a/packages/core/tests/diff_element.rs
+++ b/packages/core/tests/diff_element.rs
@@ -12,19 +12,19 @@ fn text_diff() {
let mut vdom = VirtualDom::new(app);
_ = vdom.rebuild();
- vdom.mark_dirty(ScopeId(0));
+ vdom.mark_dirty(ScopeId::ROOT);
assert_eq!(
vdom.render_immediate().edits,
[SetText { value: "hello 1", id: ElementId(2) }]
);
- vdom.mark_dirty(ScopeId(0));
+ vdom.mark_dirty(ScopeId::ROOT);
assert_eq!(
vdom.render_immediate().edits,
[SetText { value: "hello 2", id: ElementId(2) }]
);
- vdom.mark_dirty(ScopeId(0));
+ vdom.mark_dirty(ScopeId::ROOT);
assert_eq!(
vdom.render_immediate().edits,
[SetText { value: "hello 3", id: ElementId(2) }]
@@ -46,7 +46,7 @@ fn element_swap() {
let mut vdom = VirtualDom::new(app);
_ = vdom.rebuild();
- vdom.mark_dirty(ScopeId(0));
+ vdom.mark_dirty(ScopeId::ROOT);
assert_eq!(
vdom.render_immediate().santize().edits,
[
@@ -55,7 +55,7 @@ fn element_swap() {
]
);
- vdom.mark_dirty(ScopeId(0));
+ vdom.mark_dirty(ScopeId::ROOT);
assert_eq!(
vdom.render_immediate().santize().edits,
[
@@ -64,7 +64,7 @@ fn element_swap() {
]
);
- vdom.mark_dirty(ScopeId(0));
+ vdom.mark_dirty(ScopeId::ROOT);
assert_eq!(
vdom.render_immediate().santize().edits,
[
@@ -73,7 +73,7 @@ fn element_swap() {
]
);
- vdom.mark_dirty(ScopeId(0));
+ vdom.mark_dirty(ScopeId::ROOT);
assert_eq!(
vdom.render_immediate().santize().edits,
[
diff --git a/packages/core/tests/diff_keyed_list.rs b/packages/core/tests/diff_keyed_list.rs
index be26e00c0..ed14c2d95 100644
--- a/packages/core/tests/diff_keyed_list.rs
+++ b/packages/core/tests/diff_keyed_list.rs
@@ -39,7 +39,7 @@ fn keyed_diffing_out_of_order() {
);
}
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().edits,
[
@@ -64,7 +64,7 @@ fn keyed_diffing_out_of_order_adds() {
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().edits,
[
@@ -90,7 +90,7 @@ fn keyed_diffing_out_of_order_adds_3() {
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().edits,
[
@@ -116,7 +116,7 @@ fn keyed_diffing_out_of_order_adds_4() {
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().edits,
[
@@ -142,7 +142,7 @@ fn keyed_diffing_out_of_order_adds_5() {
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().edits,
[
@@ -167,7 +167,7 @@ fn keyed_diffing_additions() {
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -192,7 +192,7 @@ fn keyed_diffing_additions_and_moves_on_ends() {
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -222,7 +222,7 @@ fn keyed_diffing_additions_and_moves_in_middle() {
_ = dom.rebuild();
// LIS: 4, 5, 6
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -256,7 +256,7 @@ fn controlled_keyed_diffing_out_of_order() {
_ = dom.rebuild();
// LIS: 5, 6
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -289,7 +289,7 @@ fn controlled_keyed_diffing_out_of_order_max_test() {
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -318,7 +318,7 @@ fn remove_list() {
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -343,7 +343,7 @@ fn no_common_keys() {
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
diff --git a/packages/core/tests/diff_unkeyed_list.rs b/packages/core/tests/diff_unkeyed_list.rs
index 4934f6080..b5be161ef 100644
--- a/packages/core/tests/diff_unkeyed_list.rs
+++ b/packages/core/tests/diff_unkeyed_list.rs
@@ -27,7 +27,7 @@ fn list_creates_one_by_one() {
);
// Rendering the first item should replace the placeholder with an element
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -38,7 +38,7 @@ fn list_creates_one_by_one() {
);
// Rendering the next item should insert after the previous
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -49,7 +49,7 @@ fn list_creates_one_by_one() {
);
// ... and again!
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -60,7 +60,7 @@ fn list_creates_one_by_one() {
);
// once more
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -107,14 +107,14 @@ fn removes_one_by_one() {
// Remove div(3)
// Rendering the first item should replace the placeholder with an element
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[Remove { id: ElementId(6) }]
);
// Remove div(2)
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[Remove { id: ElementId(4) }]
@@ -122,7 +122,7 @@ fn removes_one_by_one() {
// Remove div(1) and replace with a placeholder
// todo: this should just be a remove with no placeholder
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -133,7 +133,7 @@ fn removes_one_by_one() {
// load the 3 and replace the placeholder
// todo: this should actually be append to, but replace placeholder is fine for now
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -170,7 +170,7 @@ fn list_shrink_multiroot() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -182,7 +182,7 @@ fn list_shrink_multiroot() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -194,7 +194,7 @@ fn list_shrink_multiroot() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -249,19 +249,19 @@ fn removes_one_by_one_multiroot() {
]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[Remove { id: ElementId(10) }, Remove { id: ElementId(12) }]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[Remove { id: ElementId(6) }, Remove { id: ElementId(8) }]
);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
assert_eq!(
dom.render_immediate().santize().edits,
[
@@ -328,7 +328,7 @@ fn remove_many() {
}
{
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
let edits = dom.render_immediate().santize();
assert_eq!(
edits.edits,
@@ -341,7 +341,7 @@ fn remove_many() {
}
{
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
let edits = dom.render_immediate().santize();
assert_eq!(
edits.edits,
@@ -360,7 +360,7 @@ fn remove_many() {
}
{
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
let edits = dom.render_immediate().santize();
assert_eq!(
edits.edits,
@@ -376,7 +376,7 @@ fn remove_many() {
}
{
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
let edits = dom.render_immediate().santize();
assert_eq!(
edits.edits,
diff --git a/packages/core/tests/fuzzing.rs b/packages/core/tests/fuzzing.rs
index 40bb5dcbf..1523c4e22 100644
--- a/packages/core/tests/fuzzing.rs
+++ b/packages/core/tests/fuzzing.rs
@@ -179,7 +179,7 @@ fn create_random_dynamic_node(cx: &ScopeState, depth: usize) -> DynamicNode {
node_paths: &[&[0]],
attr_paths: &[],
}),
- root_ids: Default::default(),
+ root_ids: bumpalo::collections::Vec::new_in(cx.bump()).into(),
dynamic_nodes: cx.bump().alloc([cx.component(
create_random_element,
DepthProps { depth, root: false },
@@ -276,7 +276,7 @@ fn create_random_element(cx: Scope) -> Element {
key: None,
parent: None,
template: Cell::new(template),
- root_ids: Default::default(),
+ root_ids: bumpalo::collections::Vec::new_in(cx.bump()).into(),
dynamic_nodes: {
let dynamic_nodes: Vec<_> = dynamic_node_types
.iter()
diff --git a/packages/core/tests/lifecycle.rs b/packages/core/tests/lifecycle.rs
index 04f6bc3cf..08b342631 100644
--- a/packages/core/tests/lifecycle.rs
+++ b/packages/core/tests/lifecycle.rs
@@ -58,7 +58,7 @@ fn events_generate() {
dom.handle_event("click", Rc::new(MouseData::default()), ElementId(1), true);
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
let edits = dom.render_immediate();
assert_eq!(
@@ -107,7 +107,7 @@ fn events_generate() {
// );
// assert_eq!(
-// dom.hard_diff(ScopeId(0)).edits,
+// dom.hard_diff(ScopeId::ROOT).edits,
// [
// CreateElement { root: Some(2), tag: "div", children: 0 },
// ReplaceWith { root: Some(1), nodes: vec![2] }
@@ -115,7 +115,7 @@ fn events_generate() {
// );
// assert_eq!(
-// dom.hard_diff(ScopeId(0)).edits,
+// dom.hard_diff(ScopeId::ROOT).edits,
// [
// CreateTextNode { root: Some(1), text: "Text2" },
// ReplaceWith { root: Some(2), nodes: vec![1] }
@@ -124,7 +124,7 @@ fn events_generate() {
// // child {}
// assert_eq!(
-// dom.hard_diff(ScopeId(0)).edits,
+// dom.hard_diff(ScopeId::ROOT).edits,
// [
// CreateElement { root: Some(2), tag: "h1", children: 0 },
// ReplaceWith { root: Some(1), nodes: vec![2] }
@@ -133,7 +133,7 @@ fn events_generate() {
// // placeholder
// assert_eq!(
-// dom.hard_diff(ScopeId(0)).edits,
+// dom.hard_diff(ScopeId::ROOT).edits,
// [
// CreatePlaceholder { root: Some(1) },
// ReplaceWith { root: Some(2), nodes: vec![1] }
@@ -141,7 +141,7 @@ fn events_generate() {
// );
// assert_eq!(
-// dom.hard_diff(ScopeId(0)).edits,
+// dom.hard_diff(ScopeId::ROOT).edits,
// [
// CreateTextNode { root: Some(2), text: "text 3" },
// ReplaceWith { root: Some(1), nodes: vec![2] }
@@ -149,7 +149,7 @@ fn events_generate() {
// );
// assert_eq!(
-// dom.hard_diff(ScopeId(0)).edits,
+// dom.hard_diff(ScopeId::ROOT).edits,
// [
// CreateTextNode { text: "text 0", root: Some(1) },
// CreateTextNode { text: "text 1", root: Some(3) },
@@ -158,7 +158,7 @@ fn events_generate() {
// );
// assert_eq!(
-// dom.hard_diff(ScopeId(0)).edits,
+// dom.hard_diff(ScopeId::ROOT).edits,
// [
// CreateElement { tag: "h1", root: Some(2), children: 0 },
// ReplaceWith { root: Some(1), nodes: vec![2] },
diff --git a/packages/core/tests/miri_simple.rs b/packages/core/tests/miri_simple.rs
index 6da2c4bf4..2282cb4e2 100644
--- a/packages/core/tests/miri_simple.rs
+++ b/packages/core/tests/miri_simple.rs
@@ -11,7 +11,7 @@ fn app_drops() {
let mut dom = VirtualDom::new(app);
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
_ = dom.render_immediate();
}
@@ -31,7 +31,7 @@ fn hooks_drop() {
let mut dom = VirtualDom::new(app);
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
_ = dom.render_immediate();
}
@@ -58,7 +58,7 @@ fn contexts_drop() {
let mut dom = VirtualDom::new(app);
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
_ = dom.render_immediate();
}
@@ -77,7 +77,7 @@ fn tasks_drop() {
let mut dom = VirtualDom::new(app);
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
_ = dom.render_immediate();
}
@@ -91,7 +91,7 @@ fn root_props_drop() {
);
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
_ = dom.render_immediate();
}
@@ -121,7 +121,7 @@ fn diffing_drops_old() {
let mut dom = VirtualDom::new(app);
_ = dom.rebuild();
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
_ = dom.render_immediate();
}
diff --git a/packages/core/tests/miri_stress.rs b/packages/core/tests/miri_stress.rs
index 15b7ebf41..ff8d69788 100644
--- a/packages/core/tests/miri_stress.rs
+++ b/packages/core/tests/miri_stress.rs
@@ -62,7 +62,7 @@ fn test_memory_leak() {
_ = dom.rebuild();
for _ in 0..5 {
- dom.mark_dirty(ScopeId(0));
+ dom.mark_dirty(ScopeId::ROOT);
_ = dom.render_immediate();
}
}
@@ -97,13 +97,13 @@ fn memo_works_properly() {
_ = dom.rebuild();
// todo!()
- // dom.hard_diff(ScopeId(0));
- // dom.hard_diff(ScopeId(0));
- // dom.hard_diff(ScopeId(0));
- // dom.hard_diff(ScopeId(0));
- // dom.hard_diff(ScopeId(0));
- // dom.hard_diff(ScopeId(0));
- // dom.hard_diff(ScopeId(0));
+ // dom.hard_diff(ScopeId::ROOT);
+ // dom.hard_diff(ScopeId::ROOT);
+ // dom.hard_diff(ScopeId::ROOT);
+ // dom.hard_diff(ScopeId::ROOT);
+ // dom.hard_diff(ScopeId::ROOT);
+ // dom.hard_diff(ScopeId::ROOT);
+ // dom.hard_diff(ScopeId::ROOT);
}
#[test]
diff --git a/packages/desktop/Cargo.toml b/packages/desktop/Cargo.toml
index a85c2e045..4b2b6df9f 100644
--- a/packages/desktop/Cargo.toml
+++ b/packages/desktop/Cargo.toml
@@ -55,7 +55,8 @@ default = ["tokio_runtime", "hot-reload"]
tokio_runtime = ["tokio"]
fullscreen = ["wry/fullscreen"]
transparent = ["wry/transparent"]
-tray = ["wry/tray"]
+devtools = ["wry/devtools"]
+dox = ["wry/dox"]
hot-reload = ["dioxus-hot-reload"]
[dev-dependencies]
diff --git a/packages/desktop/src/protocol.rs b/packages/desktop/src/protocol.rs
index 89ce50a48..53652f82f 100644
--- a/packages/desktop/src/protocol.rs
+++ b/packages/desktop/src/protocol.rs
@@ -158,8 +158,13 @@ fn get_mime_from_path(trimmed: &Path) -> Result<&'static str> {
}
let res = match infer::get_from_path(trimmed)?.map(|f| f.mime_type()) {
- Some(t) if t == "text/plain" => get_mime_by_ext(trimmed),
- Some(f) => f,
+ Some(f) => {
+ if f == "text/plain" {
+ get_mime_by_ext(trimmed)
+ } else {
+ f
+ }
+ }
None => get_mime_by_ext(trimmed),
};
diff --git a/packages/dioxus-tui/examples/hover.rs b/packages/dioxus-tui/examples/hover.rs
index 77770b46d..3af2d1616 100644
--- a/packages/dioxus-tui/examples/hover.rs
+++ b/packages/dioxus-tui/examples/hover.rs
@@ -1,6 +1,7 @@
use dioxus::{events::MouseData, prelude::*};
use dioxus_core::Event;
use std::convert::TryInto;
+use std::fmt::Write;
use std::rc::Rc;
fn main() {
@@ -9,7 +10,12 @@ fn main() {
fn app(cx: Scope) -> Element {
fn to_str(c: &[i32; 3]) -> String {
- "#".to_string() + &c.iter().map(|c| format!("{c:02X?}")).collect::()
+ let mut result = String::new();
+ result += "#";
+ for c in c.iter() {
+ write!(result, "{c:02X?}").unwrap();
+ }
+ result
}
fn get_brightness(m: &Rc) -> i32 {
diff --git a/packages/fullstack/src/adapters/mod.rs b/packages/fullstack/src/adapters/mod.rs
index 9133f8a08..98d190919 100644
--- a/packages/fullstack/src/adapters/mod.rs
+++ b/packages/fullstack/src/adapters/mod.rs
@@ -112,7 +112,7 @@ impl Service for ServerFnHandler {
let mut res = http::Response::builder();
// Set the headers from the server context
- let parts = server_context.parts.read().unwrap();
+ let parts = server_context.response_parts().unwrap();
*res.headers_mut().expect("empty headers should be valid") = parts.headers.clone();
let serialized = result?;
diff --git a/packages/fullstack/src/launch.rs b/packages/fullstack/src/launch.rs
index 8d125680b..c982a1c90 100644
--- a/packages/fullstack/src/launch.rs
+++ b/packages/fullstack/src/launch.rs
@@ -119,21 +119,22 @@ impl>,
+ invalid_keys: &mut Vec>,
+ path: &mut Vec,
+ ) {
+ let branch_cutoff = 5;
+ let children = if path.len() < branch_cutoff {
+ rand::random::() % 4
+ } else {
+ rand::random::() % 2
+ };
+
+ for i in 0..children {
+ let owner = store.owner();
+ let key = owner.insert(format!("hello world {path:?}"));
+ valid_keys.push(key);
+ path.push(i);
+ // read all keys
+ println!("{:?}", path);
+ for key in valid_keys.iter() {
+ let value = key.read();
+ println!("{:?}", value);
+ assert!(value.starts_with("hello world"));
+ }
+ #[cfg(any(debug_assertions, feature = "check_generation"))]
+ for key in invalid_keys.iter() {
+ assert!(!key.validate());
+ }
+ maybe_owner_scope(store, valid_keys, invalid_keys, path);
+ invalid_keys.push(valid_keys.pop().unwrap());
+ path.pop();
+ }
+ }
+
+ for _ in 0..10 {
+ let store = Store::default();
+ maybe_owner_scope(&store, &mut Vec::new(), &mut Vec::new(), &mut Vec::new());
+ }
+}
+
+/// The core Copy state type. The generational box will be dropped when the [Owner] is dropped.
+pub struct GenerationalBox {
+ raw: MemoryLocation,
+ #[cfg(any(debug_assertions, feature = "check_generation"))]
+ generation: u32,
+ _marker: PhantomData,
+}
+
+impl Debug for GenerationalBox {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ #[cfg(any(debug_assertions, feature = "check_generation"))]
+ f.write_fmt(format_args!(
+ "{:?}@{:?}",
+ self.raw.data.as_ptr(),
+ self.generation
+ ))?;
+ #[cfg(not(any(debug_assertions, feature = "check_generation")))]
+ f.write_fmt(format_args!("{:?}", self.raw.data.as_ptr()))?;
+ Ok(())
+ }
+}
+
+impl GenerationalBox {
+ #[inline(always)]
+ fn validate(&self) -> bool {
+ #[cfg(any(debug_assertions, feature = "check_generation"))]
+ {
+ self.raw.generation.get() == self.generation
+ }
+ #[cfg(not(any(debug_assertions, feature = "check_generation")))]
+ {
+ true
+ }
+ }
+
+ /// Try to read the value. Returns None if the value is no longer valid.
+ pub fn try_read(&self) -> Option> {
+ self.validate()
+ .then(|| {
+ Ref::filter_map(self.raw.data.borrow(), |any| {
+ any.as_ref()?.downcast_ref::()
+ })
+ .ok()
+ })
+ .flatten()
+ }
+
+ /// Read the value. Panics if the value is no longer valid.
+ pub fn read(&self) -> Ref<'_, T> {
+ self.try_read().unwrap()
+ }
+
+ /// Try to write the value. Returns None if the value is no longer valid.
+ pub fn try_write(&self) -> Option> {
+ self.validate()
+ .then(|| {
+ RefMut::filter_map(self.raw.data.borrow_mut(), |any| {
+ any.as_mut()?.downcast_mut::()
+ })
+ .ok()
+ })
+ .flatten()
+ }
+
+ /// Write the value. Panics if the value is no longer valid.
+ pub fn write(&self) -> RefMut<'_, T> {
+ self.try_write().unwrap()
+ }
+
+ /// Set the value. Panics if the value is no longer valid.
+ pub fn set(&self, value: T) {
+ self.validate().then(|| {
+ *self.raw.data.borrow_mut() = Some(Box::new(value));
+ });
+ }
+
+ /// Returns true if the pointer is equal to the other pointer.
+ pub fn ptr_eq(&self, other: &Self) -> bool {
+ #[cfg(any(debug_assertions, feature = "check_generation"))]
+ {
+ self.raw.data.as_ptr() == other.raw.data.as_ptr() && self.generation == other.generation
+ }
+ #[cfg(not(any(debug_assertions, feature = "check_generation")))]
+ {
+ self.raw.data.as_ptr() == other.raw.data.as_ptr()
+ }
+ }
+}
+
+impl Copy for GenerationalBox {}
+
+impl Clone for GenerationalBox {
+ fn clone(&self) -> Self {
+ *self
+ }
+}
+
+#[derive(Clone, Copy)]
+struct MemoryLocation {
+ data: &'static RefCell>>,
+ #[cfg(any(debug_assertions, feature = "check_generation"))]
+ generation: &'static Cell,
+}
+
+impl MemoryLocation {
+ #[allow(unused)]
+ fn drop(&self) {
+ let old = self.data.borrow_mut().take();
+ #[cfg(any(debug_assertions, feature = "check_generation"))]
+ if old.is_some() {
+ drop(old);
+ let new_generation = self.generation.get() + 1;
+ self.generation.set(new_generation);
+ }
+ }
+
+ fn replace(&mut self, value: T) -> GenerationalBox {
+ let mut inner_mut = self.data.borrow_mut();
+
+ let raw = Box::new(value);
+ let old = inner_mut.replace(raw);
+ assert!(old.is_none());
+ GenerationalBox {
+ raw: *self,
+ #[cfg(any(debug_assertions, feature = "check_generation"))]
+ generation: self.generation.get(),
+ _marker: PhantomData,
+ }
+ }
+}
+
+/// Handles recycling generational boxes that have been dropped. Your application should have one store or one store per thread.
+#[derive(Clone)]
+pub struct Store {
+ bump: &'static Bump,
+ recycled: Rc>>,
+}
+
+impl Default for Store {
+ fn default() -> Self {
+ Self {
+ bump: Box::leak(Box::new(Bump::new())),
+ recycled: Default::default(),
+ }
+ }
+}
+
+impl Store {
+ fn recycle(&self, location: MemoryLocation) {
+ location.drop();
+ self.recycled.borrow_mut().push(location);
+ }
+
+ fn claim(&self) -> MemoryLocation {
+ if let Some(location) = self.recycled.borrow_mut().pop() {
+ location
+ } else {
+ let data: &'static RefCell<_> = self.bump.alloc(RefCell::new(None));
+ MemoryLocation {
+ data,
+ #[cfg(any(debug_assertions, feature = "check_generation"))]
+ generation: self.bump.alloc(Cell::new(0)),
+ }
+ }
+ }
+
+ /// Create a new owner. The owner will be responsible for dropping all of the generational boxes that it creates.
+ pub fn owner(&self) -> Owner {
+ Owner {
+ store: self.clone(),
+ owned: Default::default(),
+ }
+ }
+}
+
+/// Owner: Handles dropping generational boxes. The owner acts like a runtime lifetime guard. Any states that you create with an owner will be dropped when that owner is dropped.
+pub struct Owner {
+ store: Store,
+ owned: Rc>>,
+}
+
+impl Owner {
+ /// Insert a value into the store. The value will be dropped when the owner is dropped.
+ pub fn insert(&self, value: T) -> GenerationalBox {
+ let mut location = self.store.claim();
+ let key = location.replace(value);
+ self.owned.borrow_mut().push(location);
+ key
+ }
+
+ /// Creates an invalid handle. This is useful for creating a handle that will be filled in later. If you use this before the value is filled in, you will get may get a panic or an out of date value.
+ pub fn invalid(&self) -> GenerationalBox {
+ let location = self.store.claim();
+ GenerationalBox {
+ raw: location,
+ #[cfg(any(debug_assertions, feature = "check_generation"))]
+ generation: location.generation.get(),
+ _marker: PhantomData,
+ }
+ }
+}
+
+impl Drop for Owner {
+ fn drop(&mut self) {
+ for location in self.owned.borrow().iter() {
+ self.store.recycle(*location)
+ }
+ }
+}
diff --git a/packages/hooks/src/computed.rs b/packages/hooks/src/computed.rs
index 94011d37d..1fcad8bb0 100644
--- a/packages/hooks/src/computed.rs
+++ b/packages/hooks/src/computed.rs
@@ -1,3 +1,5 @@
+//! Tracked and computed state in Dioxus
+
use dioxus_core::{ScopeId, ScopeState};
use slab::Slab;
use std::{
diff --git a/packages/hooks/src/lib.rs b/packages/hooks/src/lib.rs
index 7e5798167..6d7ab6f53 100644
--- a/packages/hooks/src/lib.rs
+++ b/packages/hooks/src/lib.rs
@@ -52,8 +52,7 @@ macro_rules! to_owned {
};
}
-mod computed;
-pub use computed::*;
+pub mod computed;
mod use_on_unmount;
pub use use_on_unmount::*;
diff --git a/packages/hooks/src/use_on_unmount.rs b/packages/hooks/src/use_on_unmount.rs
index 1fa4449c1..1309ca122 100644
--- a/packages/hooks/src/use_on_unmount.rs
+++ b/packages/hooks/src/use_on_unmount.rs
@@ -1,4 +1,4 @@
-/// Creats a callback that will be run before the component is removed. This can be used to clean up side effects from the component (created with use_effect)
+/// Creates a callback that will be run before the component is removed. This can be used to clean up side effects from the component (created with use_effect)
///
/// Example:
/// ```rust
diff --git a/packages/hooks/src/use_shared_state.rs b/packages/hooks/src/use_shared_state.rs
index 019d55942..b900b9dc6 100644
--- a/packages/hooks/src/use_shared_state.rs
+++ b/packages/hooks/src/use_shared_state.rs
@@ -282,6 +282,20 @@ impl UseSharedState {
),
}
}
+
+ /// Take a reference to the inner value temporarily and produce a new value
+ #[cfg_attr(debug_assertions, track_caller)]
+ #[cfg_attr(debug_assertions, inline(never))]
+ pub fn with(&self, immutable_callback: impl FnOnce(&T) -> O) -> O {
+ immutable_callback(&*self.read())
+ }
+
+ /// Take a mutable reference to the inner value temporarily and produce a new value
+ #[cfg_attr(debug_assertions, track_caller)]
+ #[cfg_attr(debug_assertions, inline(never))]
+ pub fn with_mut(&self, mutable_callback: impl FnOnce(&mut T) -> O) -> O {
+ mutable_callback(&mut *self.write())
+ }
}
impl Clone for UseSharedState {
diff --git a/packages/html/Cargo.toml b/packages/html/Cargo.toml
index 86ccb029d..5644b440c 100644
--- a/packages/html/Cargo.toml
+++ b/packages/html/Cargo.toml
@@ -17,7 +17,7 @@ serde_repr = { version = "0.1", optional = true }
wasm-bindgen = { workspace = true, optional = true }
euclid = "0.22.7"
enumset = "1.0.11"
-keyboard-types = "0.6.2"
+keyboard-types = "0.7"
async-trait = "0.1.58"
serde-value = "0.7.0"
tokio = { workspace = true, features = ["fs", "io-util"], optional = true }
diff --git a/packages/html/src/elements.rs b/packages/html/src/elements.rs
index 7e5bed124..7800369a9 100644
--- a/packages/html/src/elements.rs
+++ b/packages/html/src/elements.rs
@@ -1258,6 +1258,8 @@ builder_constructors! {
spellcheck: BoolOrDefault DEFAULT,
wrap: Wrap DEFAULT,
value: String volatile,
+
+ initial_value: String DEFAULT,
};
diff --git a/packages/html/src/eval.rs b/packages/html/src/eval.rs
index b39eef805..c90f5125b 100644
--- a/packages/html/src/eval.rs
+++ b/packages/html/src/eval.rs
@@ -42,7 +42,7 @@ pub fn use_eval(cx: &ScopeState) -> &EvalCreator {
Rc::new(move |script: &str| {
eval_provider
.new_evaluator(script.to_string())
- .map(|evaluator| UseEval::new(evaluator))
+ .map(UseEval::new)
}) as Rc Result>
})
}
diff --git a/packages/html/src/events/form.rs b/packages/html/src/events/form.rs
index 1fe59a640..fab13482b 100644
--- a/packages/html/src/events/form.rs
+++ b/packages/html/src/events/form.rs
@@ -1,4 +1,4 @@
-use std::{collections::HashMap, fmt::Debug};
+use std::{any::Any, collections::HashMap, fmt::Debug};
use dioxus_core::Event;
@@ -45,6 +45,12 @@ impl FileEngine for SerializedFileEngine {
.await
.map(|bytes| String::from_utf8_lossy(&bytes).to_string())
}
+
+ async fn get_native_file(&self, file: &str) -> Option> {
+ self.read_file(file)
+ .await
+ .map(|val| Box::new(val) as Box)
+ }
}
#[cfg(feature = "serialize")]
@@ -89,6 +95,9 @@ pub trait FileEngine {
// read a file to string
async fn read_file_to_string(&self, file: &str) -> Option;
+
+ // returns a file in platform's native representation
+ async fn get_native_file(&self, file: &str) -> Option>;
}
impl_event! {
diff --git a/packages/html/src/native_bind/native_file_engine.rs b/packages/html/src/native_bind/native_file_engine.rs
index e3291fa36..88b996a4d 100644
--- a/packages/html/src/native_bind/native_file_engine.rs
+++ b/packages/html/src/native_bind/native_file_engine.rs
@@ -1,3 +1,4 @@
+use std::any::Any;
use std::path::PathBuf;
use crate::FileEngine;
@@ -40,4 +41,9 @@ impl FileEngine for NativeFileEngine {
Some(contents)
}
+
+ async fn get_native_file(&self, file: &str) -> Option> {
+ let file = File::open(file).await.ok()?;
+ Some(Box::new(file))
+ }
}
diff --git a/packages/native-core/Cargo.toml b/packages/native-core/Cargo.toml
index 5f084732d..6f3f5aa04 100644
--- a/packages/native-core/Cargo.toml
+++ b/packages/native-core/Cargo.toml
@@ -12,7 +12,7 @@ authors = ["Jonathan Kelley", "Evan Almloff"]
[dependencies]
dioxus-core = { workspace = true, optional = true }
-keyboard-types = "0.6.2"
+keyboard-types = "0.7"
smallvec = "1.6"
rustc-hash = { workspace = true }
anymap = "1.0.0-beta.2"
diff --git a/packages/native-core/src/real_dom.rs b/packages/native-core/src/real_dom.rs
index 44c378ddf..b520b2de1 100644
--- a/packages/native-core/src/real_dom.rs
+++ b/packages/native-core/src/real_dom.rs
@@ -446,7 +446,6 @@ impl RealDom {
drop(tree);
children.reverse();
if let Some(node) = self.get_mut(id) {
- let node = node;
f(node);
stack.extend(children.iter());
}
diff --git a/packages/native-core/src/utils/persistant_iterator.rs b/packages/native-core/src/utils/persistant_iterator.rs
index 5d4902b87..2442af29f 100644
--- a/packages/native-core/src/utils/persistant_iterator.rs
+++ b/packages/native-core/src/utils/persistant_iterator.rs
@@ -354,7 +354,7 @@ fn persist_removes() {
// "3"
iter2.next(&rdom).id();
- vdom.mark_dirty(ScopeId(0));
+ vdom.mark_dirty(ScopeId::ROOT);
let update = vdom.render_immediate();
println!("{update:#?}");
dioxus_state.apply_mutations(&mut rdom, update);
@@ -419,7 +419,7 @@ fn persist_instertions_before() {
// "2"
iter.next(&rdom).id();
- vdom.mark_dirty(ScopeId(0));
+ vdom.mark_dirty(ScopeId::ROOT);
let update = vdom.render_immediate();
dioxus_state.apply_mutations(&mut rdom, update);
diff --git a/packages/native-core/tests/fuzzing.rs b/packages/native-core/tests/fuzzing.rs
index 1d1bd881c..4f0a34b70 100644
--- a/packages/native-core/tests/fuzzing.rs
+++ b/packages/native-core/tests/fuzzing.rs
@@ -187,7 +187,7 @@ fn create_random_dynamic_node(cx: &ScopeState, depth: usize) -> DynamicNode {
node_paths: &[&[0]],
attr_paths: &[],
}),
- root_ids: Default::default(),
+ root_ids: dioxus::core::exports::bumpalo::collections::Vec::new_in(cx.bump()).into(),
dynamic_nodes: cx.bump().alloc([cx.component(
create_random_element,
DepthProps { depth, root: false },
@@ -257,7 +257,8 @@ fn create_random_element(cx: Scope) -> Element {
key: None,
parent: None,
template: Cell::new(template),
- root_ids: Default::default(),
+ root_ids: dioxus::core::exports::bumpalo::collections::Vec::new_in(cx.bump())
+ .into(),
dynamic_nodes: {
let dynamic_nodes: Vec<_> = dynamic_node_types
.iter()
diff --git a/packages/router-macro/src/lib.rs b/packages/router-macro/src/lib.rs
index c949cf2f4..1078e5b9a 100644
--- a/packages/router-macro/src/lib.rs
+++ b/packages/router-macro/src/lib.rs
@@ -482,7 +482,8 @@ impl RouteEnum {
let route = s;
let (route, _hash) = route.split_once('#').unwrap_or((route, ""));
let (route, query) = route.split_once('?').unwrap_or((route, ""));
- let mut segments = route.split('/');
+ let query = dioxus_router::exports::urlencoding::decode(query).unwrap_or(query.into());
+ let mut segments = route.split('/').map(|s| dioxus_router::exports::urlencoding::decode(s).unwrap_or(s.into()));
// skip the first empty segment
if s.starts_with('/') {
let _ = segments.next();
diff --git a/packages/router-macro/src/query.rs b/packages/router-macro/src/query.rs
index 8b9db9e51..c97d3be29 100644
--- a/packages/router-macro/src/query.rs
+++ b/packages/router-macro/src/query.rs
@@ -14,7 +14,7 @@ impl QuerySegment {
let ident = &self.ident;
let ty = &self.ty;
quote! {
- let #ident = <#ty as dioxus_router::routable::FromQuery>::from_query(query);
+ let #ident = <#ty as dioxus_router::routable::FromQuery>::from_query(&*query);
}
}
diff --git a/packages/router-macro/src/route_tree.rs b/packages/router-macro/src/route_tree.rs
index 399d20e5e..6b89c80ab 100644
--- a/packages/router-macro/src/route_tree.rs
+++ b/packages/router-macro/src/route_tree.rs
@@ -312,7 +312,8 @@ impl<'a> RouteTreeSegmentData<'a> {
quote! {
{
let mut segments = segments.clone();
- if let Some(segment) = segments.next() {
+ let segment = segments.next();
+ if let Some(segment) = segment.as_deref() {
if #segment == segment {
#(#children)*
}
@@ -369,7 +370,7 @@ impl<'a> RouteTreeSegmentData<'a> {
quote! {
let mut trailing = String::from("/");
for seg in segments.clone() {
- trailing += seg;
+ trailing += &*seg;
trailing += "/";
}
trailing.pop();
@@ -506,7 +507,9 @@ fn return_constructed(
let remaining_segments = segments.clone();
let mut segments_clone = segments.clone();
let next_segment = segments_clone.next();
+ let next_segment = next_segment.as_deref();
let segment_after_next = segments_clone.next();
+ let segment_after_next = segment_after_next.as_deref();
match (next_segment, segment_after_next) {
// This is the last segment, return the parsed route
(None, _) | (Some(""), None) => {
@@ -516,7 +519,7 @@ fn return_constructed(
_ => {
let mut trailing = String::new();
for seg in remaining_segments {
- trailing += seg;
+ trailing += &*seg;
trailing += "/";
}
trailing.pop();
diff --git a/packages/router-macro/src/segment.rs b/packages/router-macro/src/segment.rs
index 62dea59a7..e13141dc0 100644
--- a/packages/router-macro/src/segment.rs
+++ b/packages/router-macro/src/segment.rs
@@ -59,6 +59,7 @@ impl RouteSegment {
{
let mut segments = segments.clone();
let segment = segments.next();
+ let segment = segment.as_deref();
let parsed = if let Some(#segment) = segment {
Ok(())
} else {
@@ -80,7 +81,8 @@ impl RouteSegment {
quote! {
{
let mut segments = segments.clone();
- let parsed = if let Some(segment) = segments.next() {
+ let segment = segments.next();
+ let parsed = if let Some(segment) = segment.as_deref() {
<#ty as dioxus_router::routable::FromRouteSegment>::from_route_segment(segment).map_err(|err| #error_enum_name::#error_enum_varient(#inner_parse_enum::#error_name(err)))
} else {
Err(#error_enum_name::#error_enum_varient(#inner_parse_enum::#missing_error_name))
@@ -100,9 +102,12 @@ impl RouteSegment {
quote! {
{
let parsed = {
- let mut segments = segments.clone();
- let segments: Vec<_> = segments.collect();
- <#ty as dioxus_router::routable::FromRouteSegments>::from_route_segments(&segments).map_err(|err| #error_enum_name::#error_enum_varient(#inner_parse_enum::#error_name(err)))
+ let remaining_segments: Vec<_> = segments.collect();
+ let mut new_segments: Vec<&str> = Vec::new();
+ for segment in &remaining_segments {
+ new_segments.push(&*segment);
+ }
+ <#ty as dioxus_router::routable::FromRouteSegments>::from_route_segments(&new_segments).map_err(|err| #error_enum_name::#error_enum_varient(#inner_parse_enum::#error_name(err)))
};
match parsed {
Ok(#name) => {
diff --git a/packages/router/Cargo.toml b/packages/router/Cargo.toml
index 46d7536b6..f8f967ef2 100644
--- a/packages/router/Cargo.toml
+++ b/packages/router/Cargo.toml
@@ -17,7 +17,7 @@ gloo = { version = "0.8.0", optional = true }
log = { workspace = true }
thiserror = { workspace = true }
futures-util = { workspace = true }
-serde_urlencoded = { version = "0.7.1", optional = true }
+urlencoding = "2.1.3"
serde = { version = "1", features = ["derive"], optional = true }
url = "2.3.1"
wasm-bindgen = { workspace = true, optional = true }
diff --git a/packages/router/examples/static_generation.rs b/packages/router/examples/static_generation.rs
index 4bdc1df5f..19e7c7341 100644
--- a/packages/router/examples/static_generation.rs
+++ b/packages/router/examples/static_generation.rs
@@ -30,6 +30,8 @@ async fn main() {
.join("\n")
);
+ // This function is available if you enable the ssr feature
+ // on the dioxus_router crate.
pre_cache_static_routes::(
&mut renderer,
&DefaultRenderer {
diff --git a/packages/router/src/contexts/router.rs b/packages/router/src/contexts/router.rs
index 5a9a3f0c4..b15956991 100644
--- a/packages/router/src/contexts/router.rs
+++ b/packages/router/src/contexts/router.rs
@@ -2,7 +2,7 @@ use std::{
any::Any,
collections::HashSet,
rc::Rc,
- sync::{Arc, RwLock, RwLockWriteGuard},
+ sync::{Arc, RwLock},
};
use dioxus::prelude::*;
@@ -36,7 +36,7 @@ struct MutableRouterState {
/// A collection of router data that manages all routing functionality.
#[derive(Clone)]
pub struct RouterContext {
- state: Arc>,
+ state: Rc>,
subscribers: Arc>>,
subscriber_update: Arc,
@@ -56,7 +56,7 @@ impl RouterContext {
R: Clone,
::Err: std::fmt::Display,
{
- let state = Arc::new(RwLock::new(MutableRouterState {
+ let state = Rc::new(RefCell::new(MutableRouterState {
prefix: Default::default(),
history: cfg.take_history(),
unresolved_error: None,
@@ -105,7 +105,7 @@ impl RouterContext {
// set the updater
{
- let mut state = myself.state.write().unwrap();
+ let mut state = myself.state.borrow_mut();
state.history.updater(Arc::new(move || {
for &id in subscribers.read().unwrap().iter() {
(mark_dirty)(id);
@@ -117,20 +117,20 @@ impl RouterContext {
}
pub(crate) fn route_from_str(&self, route: &str) -> Result, String> {
- let state = self.state.read().unwrap();
+ let state = self.state.borrow();
state.history.parse_route(route)
}
/// Check whether there is a previous page to navigate back to.
#[must_use]
pub fn can_go_back(&self) -> bool {
- self.state.read().unwrap().history.can_go_back()
+ self.state.borrow().history.can_go_back()
}
/// Check whether there is a future page to navigate forward to.
#[must_use]
pub fn can_go_forward(&self) -> bool {
- self.state.read().unwrap().history.can_go_forward()
+ self.state.borrow().history.can_go_forward()
}
/// Go back to the previous location.
@@ -138,7 +138,7 @@ impl RouterContext {
/// Will fail silently if there is no previous location to go to.
pub fn go_back(&self) {
{
- self.state.write().unwrap().history.go_back();
+ self.state.borrow_mut().history.go_back();
}
self.change_route();
@@ -149,7 +149,7 @@ impl RouterContext {
/// Will fail silently if there is no next location to go to.
pub fn go_forward(&self) {
{
- self.state.write().unwrap().history.go_forward();
+ self.state.borrow_mut().history.go_forward();
}
self.change_route();
@@ -206,8 +206,7 @@ impl RouterContext {
/// The route that is currently active.
pub fn current(&self) -> R {
self.state
- .read()
- .unwrap()
+ .borrow()
.history
.current_route()
.downcast::()
@@ -218,7 +217,7 @@ impl RouterContext {
/// The route that is currently active.
pub fn current_route_string(&self) -> String {
- self.any_route_to_string(&*self.state.read().unwrap().history.current_route())
+ self.any_route_to_string(&*self.state.borrow().history.current_route())
}
pub(crate) fn any_route_to_string(&self, route: &dyn Any) -> String {
@@ -243,7 +242,7 @@ impl RouterContext {
/// The prefix that is currently active.
pub fn prefix(&self) -> Option {
- self.state.read().unwrap().prefix.clone()
+ self.state.borrow().prefix.clone()
}
fn external(&self, external: String) -> Option {
@@ -261,8 +260,8 @@ impl RouterContext {
}
}
- fn state_mut(&self) -> RwLockWriteGuard {
- self.state.write().unwrap()
+ fn state_mut(&self) -> RefMut {
+ self.state.borrow_mut()
}
/// Manually subscribe to the current route
@@ -283,15 +282,14 @@ impl RouterContext {
/// Clear any unresolved errors
pub fn clear_error(&self) {
- self.state.write().unwrap().unresolved_error = None;
+ self.state.borrow_mut().unresolved_error = None;
self.update_subscribers();
}
pub(crate) fn render_error<'a>(&self, cx: Scope<'a>) -> Element<'a> {
self.state
- .read()
- .unwrap()
+ .borrow()
.unresolved_error
.as_ref()
.and_then(|_| (self.failure_external_navigation)(cx))
diff --git a/packages/router/src/lib.rs b/packages/router/src/lib.rs
index 49b7ffc42..a92394513 100644
--- a/packages/router/src/lib.rs
+++ b/packages/router/src/lib.rs
@@ -82,3 +82,8 @@ pub mod prelude {
mod utils {
pub(crate) mod use_router_internal;
}
+
+#[doc(hidden)]
+pub mod exports {
+ pub use urlencoding;
+}
diff --git a/packages/router/src/routable.rs b/packages/router/src/routable.rs
index cd3dd354d..39a5245a9 100644
--- a/packages/router/src/routable.rs
+++ b/packages/router/src/routable.rs
@@ -22,7 +22,11 @@ impl std::fmt::Display for RouteParseError {
}
}
-/// Something that can be created from a query string
+/// Something that can be created from a query string.
+///
+/// This trait needs to be implemented if you want to turn a query string into a struct.
+///
+/// A working example can be found in the `examples` folder in the root package under `query_segments_demo`
pub trait FromQuery {
/// Create an instance of `Self` from a query string
fn from_query(query: &str) -> Self;
@@ -30,7 +34,7 @@ pub trait FromQuery {
impl From<&'a str>> FromQuery for T {
fn from_query(query: &str) -> Self {
- T::from(query)
+ T::from(&*urlencoding::decode(query).expect("Failed to decode url encoding"))
}
}
@@ -50,10 +54,22 @@ where
type Err = ::Err;
fn from_route_segment(route: &str) -> Result {
- T::from_str(route)
+ match urlencoding::decode(route) {
+ Ok(segment) => T::from_str(&segment),
+ Err(err) => {
+ log::error!("Failed to decode url encoding: {}", err);
+ T::from_str(route)
+ }
+ }
}
}
+#[test]
+fn full_circle() {
+ let route = "testing 1234 hello world";
+ assert_eq!(String::from_route_segment(route).unwrap(), route);
+}
+
/// Something that can be converted to route segments
pub trait ToRouteSegments {
/// Display the route segments
@@ -67,12 +83,33 @@ where
fn display_route_segements(self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
for segment in self {
write!(f, "/")?;
- write!(f, "{}", segment)?;
+ let segment = segment.to_string();
+ match urlencoding::decode(&segment) {
+ Ok(segment) => write!(f, "{}", segment)?,
+ Err(err) => {
+ log::error!("Failed to decode url encoding: {}", err);
+ write!(f, "{}", segment)?
+ }
+ }
}
Ok(())
}
}
+#[test]
+fn to_route_segments() {
+ struct DisplaysRoute;
+
+ impl std::fmt::Display for DisplaysRoute {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let segments = vec!["hello", "world"];
+ segments.display_route_segements(f)
+ }
+ }
+
+ assert_eq!(DisplaysRoute.to_string(), "/hello/world");
+}
+
/// Something that can be created from route segments
pub trait FromRouteSegments: Sized {
/// The error that can occur when parsing route segments
diff --git a/packages/rsx/src/lib.rs b/packages/rsx/src/lib.rs
index 1f01fcd72..f52ecad0e 100644
--- a/packages/rsx/src/lib.rs
+++ b/packages/rsx/src/lib.rs
@@ -231,6 +231,7 @@ impl<'a> ToTokens for TemplateRenderer<'a> {
// Render and release the mutable borrow on context
let roots = quote! { #( #root_printer ),* };
+ let root_count = self.roots.len();
let node_printer = &context.dynamic_nodes;
let dyn_attr_printer = &context.dynamic_attributes;
let node_paths = context.node_paths.iter().map(|it| quote!(&[#(#it),*]));
@@ -247,7 +248,7 @@ impl<'a> ToTokens for TemplateRenderer<'a> {
parent: None,
key: #key_tokens,
template: std::cell::Cell::new(TEMPLATE),
- root_ids: Default::default(),
+ root_ids: dioxus::core::exports::bumpalo::collections::Vec::with_capacity_in(#root_count, __cx.bump()).into(),
dynamic_nodes: __cx.bump().alloc([ #( #node_printer ),* ]),
dynamic_attrs: __cx.bump().alloc([ #( #dyn_attr_printer ),* ]),
}
@@ -288,10 +289,7 @@ impl DynamicMapping {
let idx = self.last_attribute_idx;
self.last_attribute_idx += 1;
- self.attribute_to_idx
- .entry(attr)
- .or_insert_with(Vec::new)
- .push(idx);
+ self.attribute_to_idx.entry(attr).or_default().push(idx);
idx
}
@@ -300,10 +298,7 @@ impl DynamicMapping {
let idx = self.last_element_idx;
self.last_element_idx += 1;
- self.node_to_idx
- .entry(node)
- .or_insert_with(Vec::new)
- .push(idx);
+ self.node_to_idx.entry(node).or_default().push(idx);
idx
}
diff --git a/packages/signals/Cargo.toml b/packages/signals/Cargo.toml
index a0c3534b0..0017a1545 100644
--- a/packages/signals/Cargo.toml
+++ b/packages/signals/Cargo.toml
@@ -8,4 +8,16 @@ edition = "2018"
[dependencies]
dioxus-core = { workspace = true }
-slab = { workspace = true }
+generational-box = { workspace = true }
+log.workspace = true
+simple_logger = "4.2.0"
+serde = { version = "1", features = ["derive"], optional = true }
+
+[dev-dependencies]
+dioxus = { workspace = true }
+dioxus-desktop = { workspace = true }
+tokio = { version = "1", features = ["full"] }
+
+[features]
+default = []
+serialize = ["serde"]
\ No newline at end of file
diff --git a/packages/signals/README.md b/packages/signals/README.md
new file mode 100644
index 000000000..020edc18f
--- /dev/null
+++ b/packages/signals/README.md
@@ -0,0 +1,122 @@
+# Dioxus Signals
+
+Dioxus Signals is an ergonomic Copy runtime for data with local subscriptions.
+
+## Copy Data
+
+All signals implement Copy, even if the inner value does not implement copy. This makes it easy to move any data into futures or children.
+
+```rust
+use dioxus::prelude::*;
+use dioxus_signals::*;
+
+fn app(cx: Scope) -> Element {
+ let signal = use_signal(cx, || "hello world".to_string());
+
+ spawn(async move {
+ // signal is Copy even though String is not copy
+ print!("{signal}");
+ });
+
+ render! {
+ "{signal}"
+ }
+}
+```
+
+## Local Subscriptions
+
+Signals will only subscribe to components when you read from the signal in that component. It will never subscribe to a component when reading data in a future or event handler.
+
+```rust
+use dioxus::prelude::*;
+use dioxus_signals::*;
+
+fn app(cx: Scope) -> Element {
+ // Because signal is never read in this component, this component will not rerun when the signal changes
+ let signal = use_signal(cx, || 0);
+
+ render! {
+ button {
+ onclick: move |_| {
+ *signal.write() += 1;
+ },
+ "Increase"
+ }
+ for id in 0..10 {
+ Child {
+ signal: signal,
+ }
+ }
+ }
+}
+
+#[derive(Props, Clone, PartialEq)]
+struct ChildProps {
+ signal: Signal,
+}
+
+fn Child(cx: Scope) -> Element {
+ // This component does read from the signal, so when the signal changes it will rerun
+ render! {
+ "{cx.props.signal}"
+ }
+}
+```
+
+Because subscriptions happen when you read from (not create) the data, you can provide signals through the normal context API:
+
+```rust
+use dioxus::prelude::*;
+use dioxus_signals::*;
+
+fn app(cx: Scope) -> Element {
+ // Because signal is never read in this component, this component will not rerun when the signal changes
+ use_context_provider(cx, || Signal::new(0));
+
+ render! {
+ Child {}
+ }
+}
+
+fn Child(cx: Scope) -> Element {
+ let signal: Signal = *use_context(cx).unwrap();
+ // This component does read from the signal, so when the signal changes it will rerun
+ render! {
+ "{signal}"
+ }
+}
+```
+
+## Computed Data
+
+In addition to local subscriptions in components, `dioxus-signals` provides a way to derive data with local subscriptions.
+
+The use_selector hook will only rerun when any signals inside of the hook change:
+
+```rust
+use dioxus::prelude::*;
+use dioxus_signals::*;
+
+fn app(cx: Scope) -> Element {
+ let signal = use_signal(cx, || 0);
+ let doubled = use_selector(cx, || signal * 2);
+
+ render! {
+ button {
+ onclick: move |_| *signal.write() += 1,
+ "Increase"
+ }
+ Child {
+ signal: signal
+ }
+ }
+}
+
+#[inline_props]
+fn Child(cx: Scope, signal: ReadOnlySignal) -> Element {
+ render! {
+ "{signal}"
+ }
+}
+```
diff --git a/packages/signals/examples/context.rs b/packages/signals/examples/context.rs
new file mode 100644
index 000000000..5e7ea831f
--- /dev/null
+++ b/packages/signals/examples/context.rs
@@ -0,0 +1,25 @@
+#![allow(non_snake_case)]
+
+use dioxus::prelude::*;
+use dioxus_signals::Signal;
+
+fn main() {
+ dioxus_desktop::launch(app);
+}
+
+fn app(cx: Scope) -> Element {
+ // Because signal is never read in this component, this component will not rerun when the signal changes
+ use_context_provider(cx, || Signal::new(0));
+
+ render! {
+ Child {}
+ }
+}
+
+fn Child(cx: Scope) -> Element {
+ let signal: Signal = *use_context(cx).unwrap();
+ // This component does read from the signal, so when the signal changes it will rerun
+ render! {
+ "{signal}"
+ }
+}
diff --git a/packages/signals/examples/dependancies.rs b/packages/signals/examples/dependancies.rs
new file mode 100644
index 000000000..7b744eb3c
--- /dev/null
+++ b/packages/signals/examples/dependancies.rs
@@ -0,0 +1,38 @@
+#![allow(non_snake_case)]
+
+use dioxus::prelude::*;
+use dioxus_signals::*;
+
+fn main() {
+ dioxus_desktop::launch(app);
+}
+
+fn app(cx: Scope) -> Element {
+ let signal = use_signal(cx, || 0);
+
+ use_future!(cx, || async move {
+ loop {
+ tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+ *signal.write() += 1;
+ }
+ });
+
+ let local_state = use_state(cx, || 0);
+ let computed =
+ use_selector_with_dependencies(cx, (local_state.get(),), move |(local_state,)| {
+ local_state * 2 + signal.value()
+ });
+ println!("Running app");
+
+ render! {
+ button {
+ onclick: move |_| {
+ local_state.set(local_state.get() + 1);
+ },
+ "Add one"
+ }
+ div {
+ "{computed}"
+ }
+ }
+}
diff --git a/packages/signals/examples/selector.rs b/packages/signals/examples/selector.rs
new file mode 100644
index 000000000..85d93ae7f
--- /dev/null
+++ b/packages/signals/examples/selector.rs
@@ -0,0 +1,30 @@
+#![allow(non_snake_case)]
+
+use dioxus::prelude::*;
+use dioxus_signals::*;
+
+fn main() {
+ dioxus_desktop::launch(app);
+}
+
+fn app(cx: Scope) -> Element {
+ let signal = use_signal(cx, || 0);
+ let doubled = use_selector(cx, move || signal * 2);
+
+ render! {
+ button {
+ onclick: move |_| *signal.write() += 1,
+ "Increase"
+ }
+ Child {
+ signal: doubled
+ }
+ }
+}
+
+#[inline_props]
+fn Child(cx: Scope, signal: ReadOnlySignal) -> Element {
+ render! {
+ "{signal}"
+ }
+}
diff --git a/packages/signals/examples/split_subscriptions.rs b/packages/signals/examples/split_subscriptions.rs
new file mode 100644
index 000000000..3eb60ed29
--- /dev/null
+++ b/packages/signals/examples/split_subscriptions.rs
@@ -0,0 +1,150 @@
+#![allow(non_snake_case)]
+
+use dioxus::prelude::*;
+use dioxus_signals::Signal;
+
+fn main() {
+ dioxus_desktop::launch(app);
+}
+
+#[derive(Clone, Copy, Default)]
+struct ApplicationData {
+ first_data: Signal,
+ second_data: Signal,
+ many_signals: Signal>>,
+}
+
+fn use_app_data(cx: Scope) -> ApplicationData {
+ *use_context(cx).unwrap()
+}
+
+fn app(cx: Scope) -> Element {
+ use_context_provider(cx, ApplicationData::default);
+
+ render! {
+ div {
+ ReadsFirst {}
+ }
+ div {
+ ReadsSecond {}
+ }
+ div {
+ ReadsManySignals {}
+ }
+ }
+}
+
+fn ReadsFirst(cx: Scope) -> Element {
+ println!("running first");
+ let data = use_app_data(cx);
+
+ render! {
+ button {
+ onclick: move |_| {
+ *data.first_data.write() += 1;
+ },
+ "Increase"
+ }
+ button {
+ onclick: move |_| {
+ *data.first_data.write() -= 1;
+ },
+ "Decrease"
+ }
+ button {
+ onclick: move |_| {
+ *data.first_data.write() = 0;
+ },
+ "Reset"
+ }
+ "{data.first_data}"
+ }
+}
+
+fn ReadsSecond(cx: Scope) -> Element {
+ println!("running second");
+ let data = use_app_data(cx);
+
+ render! {
+ button {
+ onclick: move |_| {
+ *data.second_data.write() += 1;
+ },
+ "Increase"
+ }
+ button {
+ onclick: move |_| {
+ *data.second_data.write() -= 1;
+ },
+ "Decrease"
+ }
+ button {
+ onclick: move |_| {
+ *data.second_data.write() = 0;
+ },
+ "Reset"
+ }
+ "{data.second_data}"
+ }
+}
+
+fn ReadsManySignals(cx: Scope) -> Element {
+ println!("running many signals");
+ let data = use_app_data(cx);
+
+ render! {
+ button {
+ onclick: move |_| {
+ data.many_signals.write().push(Signal::new(0));
+ },
+ "Create"
+ }
+ button {
+ onclick: move |_| {
+ data.many_signals.write().pop();
+ },
+ "Destroy"
+ }
+ button {
+ onclick: move |_| {
+ if let Some(first) = data.many_signals.read().get(0) {
+ *first.write() += 1;
+ }
+ },
+ "Increase First Item"
+ }
+ for signal in data.many_signals {
+ Child {
+ count: signal,
+ }
+ }
+ }
+}
+
+#[derive(Props, PartialEq)]
+struct ChildProps {
+ count: Signal,
+}
+
+fn Child(cx: Scope) -> Element {
+ println!("running child");
+ let count = cx.props.count;
+
+ render! {
+ div {
+ "Child: {count}"
+ button {
+ onclick: move |_| {
+ *count.write() += 1;
+ },
+ "Increase"
+ }
+ button {
+ onclick: move |_| {
+ *count.write() -= 1;
+ },
+ "Decrease"
+ }
+ }
+ }
+}
diff --git a/packages/signals/src/dependency.rs b/packages/signals/src/dependency.rs
new file mode 100644
index 000000000..d6ab65a5f
--- /dev/null
+++ b/packages/signals/src/dependency.rs
@@ -0,0 +1,67 @@
+/// A dependency is a trait that can be used to determine if a effect or selector should be re-run.
+pub trait Dependency: Sized + Clone {
+ /// The output of the dependency
+ type Out: Clone + PartialEq;
+ /// Returns the output of the dependency.
+ fn out(&self) -> Self::Out;
+ /// Returns true if the dependency has changed.
+ fn changed(&self, other: &Self::Out) -> bool {
+ self.out() != *other
+ }
+}
+
+impl Dependency for () {
+ type Out = ();
+ fn out(&self) -> Self::Out {}
+}
+
+/// A dependency is a trait that can be used to determine if a effect or selector should be re-run.
+pub trait Dep: 'static + PartialEq + Clone {}
+impl Dep for T where T: 'static + PartialEq + Clone {}
+
+impl Dependency for &A {
+ type Out = A;
+ fn out(&self) -> Self::Out {
+ (*self).clone()
+ }
+}
+
+macro_rules! impl_dep {
+ (
+ $($el:ident=$name:ident $other:ident,)*
+ ) => {
+ impl< $($el),* > Dependency for ($(&$el,)*)
+ where
+ $(
+ $el: Dep
+ ),*
+ {
+ type Out = ($($el,)*);
+
+ fn out(&self) -> Self::Out {
+ let ($($name,)*) = self;
+ ($((*$name).clone(),)*)
+ }
+
+ fn changed(&self, other: &Self::Out) -> bool {
+ let ($($name,)*) = self;
+ let ($($other,)*) = other;
+ $(
+ if *$name != $other {
+ return true;
+ }
+ )*
+ false
+ }
+ }
+ };
+}
+
+impl_dep!(A = a1 a2,);
+impl_dep!(A = a1 a2, B = b1 b2,);
+impl_dep!(A = a1 a2, B = b1 b2, C = c1 c2,);
+impl_dep!(A = a1 a2, B = b1 b2, C = c1 c2, D = d1 d2,);
+impl_dep!(A = a1 a2, B = b1 b2, C = c1 c2, D = d1 d2, E = e1 e2,);
+impl_dep!(A = a1 a2, B = b1 b2, C = c1 c2, D = d1 d2, E = e1 e2, F = f1 f2,);
+impl_dep!(A = a1 a2, B = b1 b2, C = c1 c2, D = d1 d2, E = e1 e2, F = f1 f2, G = g1 g2,);
+impl_dep!(A = a1 a2, B = b1 b2, C = c1 c2, D = d1 d2, E = e1 e2, F = f1 f2, G = g1 g2, H = h1 h2,);
diff --git a/packages/signals/src/effect.rs b/packages/signals/src/effect.rs
new file mode 100644
index 000000000..0685938a0
--- /dev/null
+++ b/packages/signals/src/effect.rs
@@ -0,0 +1,96 @@
+use core::{self, fmt::Debug};
+use std::cell::RefCell;
+use std::fmt::{self, Formatter};
+use std::rc::Rc;
+//
+use dioxus_core::prelude::*;
+
+use crate::use_signal;
+use crate::{dependency::Dependency, CopyValue};
+
+#[derive(Default, Clone)]
+pub(crate) struct EffectStack {
+ pub(crate) effects: Rc>>,
+}
+
+pub(crate) fn get_effect_stack() -> EffectStack {
+ match consume_context() {
+ Some(rt) => rt,
+ None => {
+ let store = EffectStack::default();
+ provide_root_context(store).expect("in a virtual dom")
+ }
+ }
+}
+
+/// Create a new effect. The effect will be run immediately and whenever any signal it reads changes.
+/// The signal will be owned by the current component and will be dropped when the component is dropped.
+pub fn use_effect(cx: &ScopeState, callback: impl FnMut() + 'static) {
+ cx.use_hook(|| Effect::new(callback));
+}
+
+/// Create a new effect. The effect will be run immediately and whenever any signal it reads changes.
+/// The signal will be owned by the current component and will be dropped when the component is dropped.
+pub fn use_effect_with_dependencies(
+ cx: &ScopeState,
+ dependencies: D,
+ mut callback: impl FnMut(D::Out) + 'static,
+) where
+ D::Out: 'static,
+{
+ let dependencies_signal = use_signal(cx, || dependencies.out());
+ cx.use_hook(|| {
+ Effect::new(move || {
+ let deref = &*dependencies_signal.read();
+ callback(deref.clone());
+ });
+ });
+ let changed = { dependencies.changed(&*dependencies_signal.read()) };
+ if changed {
+ dependencies_signal.set(dependencies.out());
+ }
+}
+
+/// Effects allow you to run code when a signal changes. Effects are run immediately and whenever any signal it reads changes.
+#[derive(Copy, Clone, PartialEq)]
+pub struct Effect {
+ pub(crate) callback: CopyValue>,
+}
+
+impl Debug for Effect {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ f.write_fmt(format_args!("{:?}", self.callback.value))
+ }
+}
+
+impl Effect {
+ pub(crate) fn current() -> Option {
+ get_effect_stack().effects.borrow().last().copied()
+ }
+
+ /// Create a new effect. The effect will be run immediately and whenever any signal it reads changes.
+ ///
+ /// The signal will be owned by the current component and will be dropped when the component is dropped.
+ pub fn new(callback: impl FnMut() + 'static) -> Self {
+ let myself = Self {
+ callback: CopyValue::new(Box::new(callback)),
+ };
+
+ myself.try_run();
+
+ myself
+ }
+
+ /// Run the effect callback immediately. Returns `true` if the effect was run. Returns `false` is the effect is dead.
+ pub fn try_run(&self) {
+ if let Some(mut callback) = self.callback.try_write() {
+ {
+ get_effect_stack().effects.borrow_mut().push(*self);
+ }
+ callback();
+ {
+ get_effect_stack().effects.borrow_mut().pop();
+ }
+ }
+ }
+}
diff --git a/packages/signals/src/impls.rs b/packages/signals/src/impls.rs
new file mode 100644
index 000000000..6427c2e2b
--- /dev/null
+++ b/packages/signals/src/impls.rs
@@ -0,0 +1,294 @@
+use crate::rt::CopyValue;
+use crate::signal::{ReadOnlySignal, Signal, Write};
+
+use std::cell::{Ref, RefMut};
+
+use std::{
+ fmt::{Debug, Display},
+ ops::{Add, Div, Mul, Sub},
+};
+
+macro_rules! read_impls {
+ ($ty:ident) => {
+ impl Default for $ty {
+ fn default() -> Self {
+ Self::new(Default::default())
+ }
+ }
+
+ impl std::clone::Clone for $ty {
+ fn clone(&self) -> Self {
+ *self
+ }
+ }
+
+ impl Copy for $ty {}
+
+ impl Display for $ty {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ self.with(|v| Display::fmt(v, f))
+ }
+ }
+
+ impl Debug for $ty {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ self.with(|v| Debug::fmt(v, f))
+ }
+ }
+
+ impl $ty> {
+ /// Read a value from the inner vector.
+ pub fn get(&self, index: usize) -> Option> {
+ Ref::filter_map(self.read(), |v| v.get(index)).ok()
+ }
+ }
+
+ impl $ty> {
+ /// Unwraps the inner value and clones it.
+ pub fn unwrap(&self) -> T
+ where
+ T: Clone,
+ {
+ self.with(|v| v.clone()).unwrap()
+ }
+
+ /// Attemps to read the inner value of the Option.
+ pub fn as_ref(&self) -> Option> {
+ Ref::filter_map(self.read(), |v| v.as_ref()).ok()
+ }
+ }
+ };
+}
+
+macro_rules! write_impls {
+ ($ty:ident) => {
+ impl + Copy + 'static> std::ops::Add for $ty {
+ type Output = T;
+
+ fn add(self, rhs: T) -> Self::Output {
+ self.with(|v| *v + rhs)
+ }
+ }
+
+ impl