suspense works in desktop

packages/core/src/scheduler/suspense.rs

@@ -1,4 +1,5 @@
 use super::{waker::RcWake, SchedulerMsg};
+use crate::ElementId;
 use crate::{innerlude::Mutations, Element, ScopeId};
 use std::future::Future;
 use std::{
@@ -10,22 +11,24 @@ use std::{
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct SuspenseId(pub usize);
 
-pub type SuspenseContext = Rc<RefCell<SuspenseBoundary>>;
+pub type SuspenseContext = Rc<SuspenseBoundary>;
 
 /// Essentially a fiber in React
 pub struct SuspenseBoundary {
     pub id: ScopeId,
-    pub waiting_on: HashSet<SuspenseId>,
-    pub mutations: Mutations<'static>,
+    pub waiting_on: RefCell<HashSet<SuspenseId>>,
+    pub mutations: RefCell<Mutations<'static>>,
+    pub placeholder: Cell<Option<ElementId>>,
 }
 
 impl SuspenseBoundary {
-    pub fn new(id: ScopeId) -> Rc<RefCell<Self>> {
-        Rc::new(RefCell::new(Self {
+    pub fn new(id: ScopeId) -> Rc<Self> {
+        Rc::new(Self {
             id,
             waiting_on: Default::default(),
-            mutations: Mutations::new(0),
-        }))
+            mutations: RefCell::new(Mutations::new(0)),
+            placeholder: Cell::new(None),
+        })
     }
 }
 

packages/core/src/scheduler/wait.rs

@@ -53,14 +53,12 @@ impl VirtualDom {
         // we should attach them to that component and then render its children
         // continue rendering the tree until we hit yet another suspended component
         if let Poll::Ready(new_nodes) = as_pinned_mut.poll_unpin(&mut cx) {
-            let boundary = &self.scopes[leaf.scope_id.0]
+            let fiber = &self.scopes[leaf.scope_id.0]
                 .consume_context::<SuspenseContext>()
                 .unwrap();
 
             println!("ready pool");
 
-            let mut fiber = boundary.borrow_mut();
-
             println!(
                 "Existing mutations {:?}, scope {:?}",
                 fiber.mutations, fiber.id
@@ -72,16 +70,33 @@ impl VirtualDom {
             let ret = arena.bump.alloc(RenderReturn::Sync(new_nodes));
             arena.node.set(ret);
 
+            fiber.waiting_on.borrow_mut().remove(&id);
+
             if let RenderReturn::Sync(Some(template)) = ret {
-                let mutations = &mut fiber.mutations;
+                let mutations_ref = &mut fiber.mutations.borrow_mut();
+                let mutations = &mut **mutations_ref;
                 let template: &VNode = unsafe { std::mem::transmute(template) };
                 let mutations: &mut Mutations = unsafe { std::mem::transmute(mutations) };
 
+                let place_holder_id = scope.placeholder.get().unwrap();
                 self.scope_stack.push(scope_id);
-                self.create(mutations, template);
+                let created = self.create(mutations, template);
                 self.scope_stack.pop();
+                mutations.push(Mutation::ReplaceWith {
+                    id: place_holder_id,
+                    m: created,
+                });
 
-                println!("{:#?}", mutations);
+                // for leaf in self.collected_leaves.drain(..) {
+                //     fiber.waiting_on.borrow_mut().insert(leaf);
+                // }
+
+                if fiber.waiting_on.borrow().is_empty() {
+                    println!("fiber is finished!");
+                    self.finished_fibers.push(fiber.id);
+                } else {
+                    println!("fiber is not finished {:?}", fiber.waiting_on);
+                }
             } else {
                 println!("nodes arent right");
             }