wip: doesnt share on thread

packages/core/src/arena.rs

@@ -1,13 +1,14 @@
 use std::{
     cell::{RefCell, UnsafeCell},
     collections::HashMap,
-    rc::Rc,
+    sync::Arc,
 };
 
 use generational_arena::Arena;
 
 use crate::innerlude::*;
 
+type Rc<T> = Arc<T>;
 #[derive(Clone)]
 pub struct ScopeArena(Rc<RefCell<ScopeArenaInner>>);
 

packages/core/src/debug_renderer.rs

@@ -15,7 +15,7 @@ impl DebugRenderer {
     ///
     /// This means that the root component must either consumes its own context, or statics are used to generate the page.
     /// The root component can access things like routing in its context.
-    pub fn new(root: FC<()>) -> Self {
+    pub fn new(root: impl for<'a> Fn(Context<'a>, &'a ()) -> DomTree + 'static) -> Self {
         Self::new_with_props(root, ())
     }
 
@@ -23,7 +23,10 @@ impl DebugRenderer {
     /// Automatically progresses the creation of the VNode tree to completion.
     ///
     /// A VDom is automatically created. If you want more granular control of the VDom, use `from_vdom`
-    pub fn new_with_props<T: Properties + 'static>(root: FC<T>, root_props: T) -> Self {
+    pub fn new_with_props<T: Properties + 'static>(
+        root: impl for<'a> Fn(Context<'a>, &'a T) -> DomTree + 'static,
+        root_props: T,
+    ) -> Self {
         Self::from_vdom(VirtualDom::new_with_props(root, root_props))
     }
 

packages/core/src/diff.rs

@@ -41,9 +41,11 @@ use std::{
     cell::{RefCell, RefMut},
     cmp::Ordering,
     collections::VecDeque,
-    rc::{Rc, Weak},
     sync::atomic::AtomicU32,
+    // rc::{Rc, Weak},
+    sync::{Arc, Weak},
 };
+type Rc<T> = Arc<T>;
 
 /// The DiffState is a cursor internal to the VirtualDOM's diffing algorithm that allows persistence of state while
 /// diffing trees of components. This means we can "re-enter" a subtree of a component by queuing a "NeedToDiff" event.

packages/core/src/nodes.rs

@@ -10,7 +10,9 @@ use crate::{
 
 use bumpalo::Bump;
 use std::fmt::Debug;
-use std::{any::Any, cell::RefCell, marker::PhantomData, rc::Rc};
+use std::sync::Arc;
+use std::{any::Any, cell::RefCell, marker::PhantomData};
+type Rc<T> = Arc<T>;
 
 /// A domtree represents the result of "Viewing" the context
 /// It's a placeholder over vnodes, to make working with lifetimes easier

packages/core/src/virtual_dom.rs

@@ -29,9 +29,12 @@ use std::{
     fmt::Debug,
     future::Future,
     pin::Pin,
-    rc::{Rc, Weak},
+    // rc::{Rc, Weak},
+    sync::{Arc, Weak},
 };
 
+type Rc<T> = Arc<T>;
+
 /// An integrated virtual node system that progresses events and diffs UI trees.
 /// Differences are converted into patches which a renderer can use to draw the UI.
 pub struct VirtualDom {
@@ -96,7 +99,7 @@ impl VirtualDom {
     ///
     /// let dom = VirtualDom::new(Example);
     /// ```
-    pub fn new(root: FC<()>) -> Self {
+    pub fn new(root: impl Fn(Context, &()) -> DomTree + 'static) -> Self {
         Self::new_with_props(root, ())
     }
 
@@ -128,7 +131,10 @@ impl VirtualDom {
     ///
     /// let dom = VirtualDom::new(Example);
     /// ```
-    pub fn new_with_props<P: Properties + 'static>(root: FC<P>, root_props: P) -> Self {
+    pub fn new_with_props<P: Properties + 'static>(
+        root: impl for<'a> Fn(Context<'a>, &'a P) -> DomTree + 'static,
+        root_props: P,
+    ) -> Self {
         let components = ScopeArena::new(Arena::new());
 
         // Normally, a component would be passed as a child in the RSX macro which automatically produces OpaqueComponents
@@ -887,12 +893,11 @@ impl Scope {
             let shared_contexts = inner.shared_contexts.borrow();
             if let Some(shared_ctx) = shared_contexts.get(&ty) {
                 let rc = shared_ctx
-                    .clone()
-                    .downcast()
+                    .downcast_ref()
                     .expect("Should not fail, already validated the type from the hashmap");
 
                 *cached_root.borrow_mut() = Some(Rc::downgrade(&rc));
-                return Ok(rc);
+                return Ok(rc.clone());
             } else {
                 match inner.parent {
                     Some(parent_id) => {
@@ -1086,4 +1091,18 @@ mod tests {
         });
         // let root = dom.components.get(dom.base_scope).unwrap();
     }
+
+    // ensure the virtualdom is send + sync
+    // needed for use in async/await contexts
+    fn is_send_sync() {
+        fn check_send<T: Send>(a: T) -> T {
+            todo!()
+        }
+        fn check_sync<T: Sync>(a: T) -> T {
+            todo!()
+        }
+
+        let _ = check_send(VirtualDom::new(|ctx, props| ctx.render(rsx! { div {}})));
+        let _ = check_sync(VirtualDom::new(|ctx, props| ctx.render(rsx! { div {}})));
+    }
 }