feat: beaf up the use_state hook

packages/core-macro/src/rsx/component.rs

@@ -72,6 +72,8 @@ pub struct BodyParseConfig {
     pub allow_manual_props: bool,
 }
 
+// todo: unify this body parsing for both elements and components
+// both are style rather ad-hoc, though components are currently more configured
 pub fn parse_component_body(
     content: &ParseBuffer,
     cfg: &BodyParseConfig,
@@ -87,18 +89,27 @@ pub fn parse_component_body(
 
         if content.peek(Token![..]) {
             if !cfg.allow_manual_props {
-                // toss an error
+                return Err(Error::new(
+                    content.span(),
+                    "Props spread syntax is not allowed in this context. \nMake to only use the elipsis `..` in Components.",
+                ));
             }
             content.parse::<Token![..]>()?;
             *manual_props = Some(content.parse::<Expr>()?);
         } else if content.peek(Ident) && content.peek2(Token![:]) {
             if !cfg.allow_fields {
-                // toss an error
+                return Err(Error::new(
+                    content.span(),
+                    "Property fields is not allowed in this context. \nMake to only use fields in Components or Elements.",
+                ));
             }
             body.push(content.parse::<ComponentField>()?);
         } else {
             if !cfg.allow_children {
-                // toss an error
+                return Err(Error::new(
+                    content.span(),
+                    "This item is not allowed to accept children.",
+                ));
             }
             children.push(content.parse::<Node>()?);
         }

packages/core-macro/src/rsx/element.rs

@@ -22,14 +22,14 @@ pub struct Element {
 impl ToTokens for Element {
     fn to_tokens(&self, tokens: &mut TokenStream2) {
         let name = &self.name;
-        // let name = &self.name.to_string();
 
         tokens.append_all(quote! {
             __cx.element(dioxus_elements::#name)
         });
 
-        // Add attributes
-        // TODO: conver to the "attrs" syntax for compile-time known sizes
+        // By gating these methods, we can keep the output of `cargo expand` readable.
+        // We also prevent the issue where zero-sized arrays fail to have propery type inference.
+
         if self.attributes.len() > 0 {
             let attr = &self.attributes;
             tokens.append_all(quote! {

packages/core/src/hooks.rs

@@ -8,7 +8,7 @@
 use crate::innerlude::Context;
 
 use std::{
-    cell::RefCell,
+    cell::{Cell, RefCell},
     ops::{Deref, DerefMut},
     rc::Rc,
 };
@@ -87,39 +87,47 @@ use std::{
 };
 
 pub struct UseState<T: 'static> {
-    modifier: Rc<RefCell<Option<Box<dyn FnOnce(&mut T)>>>>,
     current_val: T,
-    update: Box<dyn Fn() + 'static>,
-    setter: Box<dyn Fn(T) + 'static>,
-    // setter: Box<dyn Fn(T) + 'static>,
+    callback: Rc<dyn Fn()>,
+    wip: RefCell<Option<T>>,
 }
 
-// #[derive(Clone, Copy)]
-// pub struct UseStateHandle<'a, T: 'static> {
-//     inner: &'a UseState<T>,
-//     // pub setter: &'a dyn Fn(T),
-//     // pub modifier: &'a dyn Fn(&mut T),
-// }
-
-impl<'a, T: 'static> UseState<T> {
-    pub fn setter(&self) -> &dyn Fn(T) {
-        &self.setter
-        // let r = self.setter.as_mut();
-        // unsafe { Pin::get_unchecked_mut(r) }
+impl<T: 'static> UseState<T> {
+    /// Tell the Dioxus Scheduler that we need to be processed
+    pub fn needs_update(&self) {
+        (self.callback)();
     }
 
     pub fn set(&self, new_val: T) {
-        self.modify(|f| *f = new_val);
+        self.needs_update();
+        *self.wip.borrow_mut() = Some(new_val);
     }
 
-    // signal that we need to be updated
-    // save the modifier
-    pub fn modify(&self, f: impl FnOnce(&mut T) + 'static) {
-        let mut slot = self.modifier.as_ref().borrow_mut();
-        *slot = Some(Box::new(f));
-        (self.update)();
+    pub fn get(&self) -> &T {
+        &self.current_val
+    }
+
+    /// Get the current status of the work-in-progress data
+    pub fn get_wip(&self) -> Ref<Option<T>> {
+        self.wip.borrow()
     }
 }
+impl<'a, T: 'static + ToOwned<Owned = T>> UseState<T> {
+    pub fn get_mut<'r>(&'r self) -> RefMut<'r, T> {
+        // make sure we get processed
+        self.needs_update();
+
+        // Bring out the new value, cloning if it we need to
+        // "get_mut" is locked behind "ToOwned" to make it explicit that cloning occurs to use this
+        RefMut::map(self.wip.borrow_mut(), |slot| {
+            if slot.is_none() {
+                *slot = Some(self.current_val.to_owned());
+            }
+            slot.as_mut().unwrap()
+        })
+    }
+}
+
 impl<'a, T: 'static> std::ops::Deref for UseState<T> {
     type Target = T;
 
@@ -163,67 +171,23 @@ pub fn use_state<'a, 'c, T: 'static, F: FnOnce() -> T, P>(
 ) -> &'a UseState<T> {
     cx.use_hook(
         move || UseState {
-            modifier: Rc::new(RefCell::new(None)),
             current_val: initial_state_fn(),
-            update: Box::new(|| {}),
-            setter: Box::new(|_| {}),
+            callback: cx.schedule_update(),
+            wip: RefCell::new(None),
         },
         move |hook| {
             log::debug!("addr of hook: {:#?}", hook as *const _);
-            let scheduled_update = cx.schedule_update();
-
-            // log::debug!("Checking if new value {:#?}", &hook.current_val);
-            // get ownership of the new val and replace the current with the new
-            // -> as_ref -> borrow_mut -> deref_mut -> take
-            // -> rc     -> &RefCell   -> RefMut    -> &Option<T> -> T
-            if let Some(new_val) = hook.modifier.as_ref().borrow_mut().deref_mut().take() {
-                // log::debug!("setting prev {:#?}", &hook.current_val);
-                (new_val)(&mut hook.current_val);
-                // log::debug!("setting new value {:#?}", &hook.current_val);
+            let mut new_val = hook.wip.borrow_mut();
+            if new_val.is_some() {
+                hook.current_val = new_val.take().unwrap();
             }
 
-            hook.update = Box::new(move || scheduled_update());
-
-            let modifier = hook.modifier.clone();
-            hook.setter = Box::new(move |new_val: T| {
-                let mut slot = modifier.as_ref().borrow_mut();
-
-                let slot2 = slot.deref_mut();
-                *slot2 = Some(Box::new(move |old: &mut T| *old = new_val));
-            });
-
             &*hook
         },
         |_| {},
     )
 }
 
-// pub struct UseRef<T: 'static> {
-//     _current: RefCell<T>,
-// }
-// impl<T: 'static> UseRef<T> {
-//     fn new(val: T) -> Self {
-//         Self {
-//             _current: RefCell::new(val),
-//         }
-//     }
-
-//     pub fn set(&self, new: T) {
-//         let mut val = self._current.borrow_mut();
-//         *val = new;
-//     }
-
-//     pub fn modify(&self, modifier: impl FnOnce(&mut T)) {
-//         let mut val = self._current.borrow_mut();
-//         let val_as_ref = val.deref_mut();
-//         modifier(val_as_ref);
-//     }
-
-//     pub fn current(&self) -> std::cell::Ref<'_, T> {
-//         self._current.borrow()
-//     }
-// }
-
 /// Store a mutable value between renders!
 /// To read the value, borrow the ref.
 /// To change it, use modify.

packages/core/src/nodebuilder.rs

@@ -549,13 +549,8 @@ impl<'a> IntoVNode<'a> for VNode<'a> {
 }
 
 impl<'a> IntoVNode<'a> for &VNode<'a> {
-    fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a>
-// where
-    //     'a: 'c,
-    {
-        todo!()
-        // cloning is cheap since vnodes are just references into bump arenas
-        // self.clone()
+    fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a> {
+        self.clone()
     }
 }
 
@@ -563,14 +558,6 @@ pub trait IntoVNode<'a> {
     fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a>;
 }
 
-// pub trait VNodeBuilder<'a, G>: IntoIterator<Item = G>
-// where
-//     G: IntoVNode<'a>,
-// {
-// }
-
-// impl<'a, F> VNodeBuilder<'a, LazyNodes<F>> for LazyNodes<F> where F: FnOnce(NodeFactory) -> VNode {}
-
 // Wrap the the node-builder closure in a concrete type.
 // ---
 // This is a bit of a hack to implement the IntoVNode trait for closure types.

packages/html/src/lib.rs

@@ -62,18 +62,22 @@ builder_constructors! {
     /// [`<head>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/head)
     /// element.
     head;
+
     /// Build a
     /// [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
     /// element.
     link;
+
     /// Build a
     /// [`<meta>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta)
     /// element.
     meta;
+
     /// Build a
     /// [`<style>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/style)
     /// element.
     style;
+
     /// Build a
     /// [`<title>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/title)
     /// element.
@@ -109,7 +113,6 @@ builder_constructors! {
     /// element.
     header;
 
-
     /// Build a
     /// [`<h1>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/h1)
     /// element.
@@ -122,11 +125,13 @@ builder_constructors! {
     /// - The `<h1>` heading is usually a large bolded font.
     ///
     /// # Usage
+    ///
     /// ```
     /// html!(<h1> A header element </h1>)
     /// rsx!(h1 { "A header element" })
     /// LazyNodes::new(|f| f.el(h1).children([f.text("A header element")]).finish())
     /// ```
+    ///
     h1;
 
 

packages/webview/src/lib.rs

@@ -10,15 +10,15 @@ mod dom;
 static HTML_CONTENT: &'static str = include_str!("./index.html");
 
 pub fn launch(
-    builder: impl FnOnce(DioxusWebviewBuilder) -> DioxusWebviewBuilder,
     root: FC<()>,
+    builder: impl FnOnce(DioxusWebviewBuilder) -> DioxusWebviewBuilder,
 ) -> anyhow::Result<()> {
-    launch_with_props(builder, (), root)
+    launch_with_props(root, (), builder)
 }
 pub fn launch_with_props<P: Properties + 'static>(
-    builder: impl FnOnce(DioxusWebviewBuilder) -> DioxusWebviewBuilder,
-    props: P,
     root: FC<P>,
+    props: P,
+    builder: impl FnOnce(DioxusWebviewBuilder) -> DioxusWebviewBuilder,
 ) -> anyhow::Result<()> {
     WebviewRenderer::run(root, props, builder)
 }