Basic render to html implementation.

packages/yew/Cargo.toml

@@ -26,6 +26,8 @@ wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
 yew-macro = { version = "^0.19.0", path = "../yew-macro" }
 thiserror = "1.0"
+async-trait = "0.1"
+futures = "0.3"
 
 scoped-tls-hkt = "0.1"
 

packages/yew/src/html/component/lifecycle.rs

@@ -7,6 +7,7 @@ use crate::suspense::{Suspense, Suspension};
 use crate::virtual_dom::{VDiff, VNode};
 use crate::Callback;
 use crate::{Context, NodeRef};
+use futures::channel::oneshot;
 use std::rc::Rc;
 use web_sys::Element;
 
@@ -15,26 +16,32 @@ pub(crate) struct ComponentState<COMP: BaseComponent> {
     pub(crate) root_node: VNode,
 
     context: Context<COMP>,
-    parent: Element,
+
+    /// When a component has no parent, it means that it should not be rendered.
+    parent: Option<Element>,
+
     next_sibling: NodeRef,
     node_ref: NodeRef,
     has_rendered: bool,
 
     suspension: Option<Suspension>,
 
+    html_sender: Option<oneshot::Sender<VNode>>,
+
     // Used for debug logging
     #[cfg(debug_assertions)]
     pub(crate) vcomp_id: u64,
 }
 
 impl<COMP: BaseComponent> ComponentState<COMP> {
     pub(crate) fn new(
-        parent: Element,
+        parent: Option<Element>,
         next_sibling: NodeRef,
         root_node: VNode,
         node_ref: NodeRef,
         scope: Scope<COMP>,
         props: Rc<COMP::Properties>,
+        html_sender: Option<oneshot::Sender<VNode>>,
     ) -> Self {
         #[cfg(debug_assertions)]
         let vcomp_id = {
@@ -55,19 +62,22 @@ impl<COMP: BaseComponent> ComponentState<COMP> {
             suspension: None,
             has_rendered: false,
 
+            html_sender,
+
             #[cfg(debug_assertions)]
             vcomp_id,
         }
     }
 }
 
 pub(crate) struct CreateRunner<COMP: BaseComponent> {
-    pub(crate) parent: Element,
+    pub(crate) parent: Option<Element>,
     pub(crate) next_sibling: NodeRef,
     pub(crate) placeholder: VNode,
     pub(crate) node_ref: NodeRef,
     pub(crate) props: Rc<COMP::Properties>,
     pub(crate) scope: Scope<COMP>,
+    pub(crate) html_sender: Option<oneshot::Sender<VNode>>,
 }
 
 impl<COMP: BaseComponent> Runnable for CreateRunner<COMP> {
@@ -84,6 +94,7 @@ impl<COMP: BaseComponent> Runnable for CreateRunner<COMP> {
                 self.node_ref,
                 self.scope.clone(),
                 self.props,
+                self.html_sender,
             ));
         }
     }
@@ -129,11 +140,13 @@ impl<COMP: BaseComponent> Runnable for UpdateRunner<COMP> {
                     }
                 }
                 UpdateEvent::Shift(parent, next_sibling) => {
-                    state
-                        .root_node
-                        .shift(&state.parent, &parent, next_sibling.clone());
+                    state.root_node.shift(
+                        state.parent.as_ref().unwrap(),
+                        &parent,
+                        next_sibling.clone(),
+                    );
 
-                    state.parent = parent;
+                    state.parent = Some(parent);
                     state.next_sibling = next_sibling;
 
                     false
@@ -173,8 +186,11 @@ impl<COMP: BaseComponent> Runnable for DestroyRunner<COMP> {
             crate::virtual_dom::vcomp::log_event(state.vcomp_id, "destroy");
 
             state.component.destroy(&state.context);
-            state.root_node.detach(&state.parent);
-            state.node_ref.set(None);
+
+            if let Some(ref m) = state.parent {
+                state.root_node.detach(m);
+                state.node_ref.set(None);
+            }
         }
     }
 }
@@ -194,7 +210,9 @@ impl<COMP: BaseComponent> Runnable for RenderRunner<COMP> {
                     // Currently not suspended, we remove any previous suspension and update
                     // normally.
                     let mut root = m;
-                    std::mem::swap(&mut root, &mut state.root_node);
+                    if state.parent.is_some() {
+                        std::mem::swap(&mut root, &mut state.root_node);
+                    }
 
                     if let Some(ref m) = state.suspension {
                         let comp_scope = AnyScope::from(state.context.scope.clone());
@@ -205,13 +223,17 @@ impl<COMP: BaseComponent> Runnable for RenderRunner<COMP> {
                         suspense.resume(m.clone());
                     }
 
-                    let ancestor = Some(root);
-                    let new_root = &mut state.root_node;
-                    let scope = state.context.scope.clone().into();
-                    let next_sibling = state.next_sibling.clone();
+                    if let Some(ref m) = state.parent {
+                        let ancestor = Some(root);
+                        let new_root = &mut state.root_node;
+                        let scope = state.context.scope.clone().into();
+                        let next_sibling = state.next_sibling.clone();
 
-                    let node = new_root.apply(&scope, &state.parent, next_sibling, ancestor);
-                    state.node_ref.link(node);
+                        let node = new_root.apply(&scope, m, next_sibling, ancestor);
+                        state.node_ref.link(node);
+                    } else if let Some(tx) = state.html_sender.take() {
+                        tx.send(root).unwrap();
+                    }
                 }
 
                 Err(RenderError::Suspended(m)) => {
@@ -277,9 +299,11 @@ impl<COMP: BaseComponent> Runnable for RenderedRunner<COMP> {
             #[cfg(debug_assertions)]
             crate::virtual_dom::vcomp::log_event(state.vcomp_id, "rendered");
 
-            let first_render = !state.has_rendered;
-            state.component.rendered(&state.context, first_render);
-            state.has_rendered = true;
+            if state.parent.is_some() {
+                let first_render = !state.has_rendered;
+                state.component.rendered(&state.context, first_render);
+                state.has_rendered = true;
+            }
         }
     }
 }

packages/yew/src/html/component/scope.rs

@@ -12,6 +12,7 @@ use crate::context::{ContextHandle, ContextProvider};
 use crate::html::NodeRef;
 use crate::scheduler::{self, Shared};
 use crate::virtual_dom::{insert_node, VNode};
+use futures::channel::oneshot;
 use gloo_utils::document;
 use std::any::{Any, TypeId};
 use std::cell::{Ref, RefCell};
@@ -234,12 +235,13 @@ impl<COMP: BaseComponent> Scope<COMP> {
 
         scheduler::push_component_create(
             CreateRunner {
-                parent,
+                parent: Some(parent),
                 next_sibling,
                 placeholder,
                 node_ref,
                 props,
                 scope: self.clone(),
+                html_sender: None,
             },
             RenderRunner {
                 state: self.state.clone(),
@@ -414,6 +416,47 @@ impl<COMP: BaseComponent> Scope<COMP> {
     }
 }
 
+mod feat_ssr {
+    use super::*;
+    use crate::html_writer::HtmlWriter;
+
+    impl<COMP: BaseComponent> Scope<COMP> {
+        /// Renders Into a [`HtmlWrite`].
+        pub(crate) async fn render_to_html(&self, w: &HtmlWriter, props: Rc<COMP::Properties>) {
+            let (tx, rx) = oneshot::channel();
+
+            scheduler::push_component_create(
+                CreateRunner {
+                    parent: None,
+                    next_sibling: NodeRef::default(),
+                    placeholder: VNode::default(),
+                    node_ref: NodeRef::default(),
+                    props,
+                    scope: self.clone(),
+                    html_sender: Some(tx),
+                },
+                RenderRunner {
+                    state: self.state.clone(),
+                },
+                RenderedRunner {
+                    state: self.state.clone(),
+                },
+            );
+            scheduler::start();
+
+            let html = rx.await.unwrap();
+
+            let self_any_scope = self.to_any();
+            html.render_to_html(w, &self_any_scope).await;
+
+            scheduler::push_component_destroy(DestroyRunner {
+                state: self.state.clone(),
+            });
+            scheduler::start();
+        }
+    }
+}
+
 /// Defines a message type that can be sent to a component.
 /// Used for the return value of closure given to [Scope::batch_callback](struct.Scope.html#method.batch_callback).
 pub trait SendAsMessage<COMP: BaseComponent> {

packages/yew/src/html_writer.rs

@@ -0,0 +1,22 @@
+//! module to provide an html writer that can be written without mutable borrowing.
+
+mod feat_ssr {
+    use std::cell::RefCell;
+
+    #[derive(Debug, Default)]
+    pub(crate) struct HtmlWriter {
+        inner: RefCell<String>,
+    }
+
+    impl HtmlWriter {
+        pub fn push_str(&self, s: &str) {
+            self.inner.borrow_mut().push_str(s);
+        }
+
+        pub fn into_inner(self) -> String {
+            self.inner.into_inner()
+        }
+    }
+}
+
+pub use feat_ssr::*;

packages/yew/src/lib.rs

@@ -260,6 +260,7 @@ pub mod callback;
 pub mod context;
 pub mod functional;
 pub mod html;
+mod html_writer;
 pub mod scheduler;
 mod sealed;
 pub mod suspense;
@@ -304,6 +305,125 @@ fn set_default_panic_hook() {
     }
 }
 
+// /// A Yew Renderer.
+// #[derive(Debug)]
+// pub struct YewRenderer<COMP>
+// where
+//     COMP: BaseComponent,
+// {
+//     root: Element,
+//     props: COMP::Properties,
+// }
+
+// impl<COMP> YewRenderer<COMP>
+// where
+//     COMP: BaseComponent,
+// {
+//     /// Creates a [`YewRenderer`] with a custom root and properties.
+//     pub fn with_root_and_props(root: Element, props: COMP::Properties) -> Self {
+//         Self { root, props }
+//     }
+
+//     /// Creates a [`YewRenderer`] with document body as root and custom properties.
+//     pub fn with_props(props: COMP::Properties) -> Self {
+//         Self::with_root_and_props(
+//             gloo_utils::document()
+//                 .body()
+//                 .expect("no body node found")
+//                 .into(),
+//             props,
+//         )
+//     }
+
+//     /// Renders a Yew application.
+//     pub fn render(self) -> AppHandle<COMP> {
+//         set_default_panic_hook();
+
+//         AppHandle::<COMP>::mount_with_props(self.root, Rc::new(self.props))
+//     }
+
+//     /// Hydrates a Yew application.
+//     pub fn hydrate(self) -> AppHandle<COMP> {
+//         set_default_panic_hook();
+//         todo!()
+//     }
+// }
+
+// impl<COMP> YewRenderer<COMP>
+// where
+//     COMP: BaseComponent,
+//     COMP::Properties: Default,
+// {
+//     /// Creates a [`YewRenderer`] with a custom root.
+//     pub fn with_root(root: Element) -> Self {
+//         Self::with_root_and_props(root, COMP::Properties::default())
+//     }
+
+//     /// Creates a [`YewRenderer`] with document body as root.
+//     pub fn body() -> Self {
+//         Self::with_props(COMP::Properties::default())
+//     }
+// }
+
+mod feat_ssr {
+    use super::*;
+
+    use crate::html::Scope;
+    use crate::html_writer::HtmlWriter;
+
+    /// A Yew Server-side Renderer.
+    #[derive(Debug)]
+    pub struct YewServerRenderer<COMP>
+    where
+        COMP: BaseComponent,
+    {
+        props: COMP::Properties,
+    }
+
+    impl<COMP> Default for YewServerRenderer<COMP>
+    where
+        COMP: BaseComponent,
+        COMP::Properties: Default,
+    {
+        fn default() -> Self {
+            Self::with_props(COMP::Properties::default())
+        }
+    }
+
+    impl<COMP> YewServerRenderer<COMP>
+    where
+        COMP: BaseComponent,
+        COMP::Properties: Default,
+    {
+        /// Creates a [`YewServerRenderer`] with default properties.
+        pub fn new() -> Self {
+            Self::default()
+        }
+    }
+
+    impl<COMP> YewServerRenderer<COMP>
+    where
+        COMP: BaseComponent,
+    {
+        /// Creates a [`YewServerRenderer`] with custom properties.
+        pub fn with_props(props: COMP::Properties) -> Self {
+            Self { props }
+        }
+
+        /// Renders Yew Application into a string.
+        pub async fn render_to_string(self) -> String {
+            let s = HtmlWriter::default();
+
+            let scope = Scope::<COMP>::new(None);
+            scope.render_to_html(&s, self.props.into()).await;
+
+            s.into_inner()
+        }
+    }
+}
+
+pub use feat_ssr::*;
+
 /// The main entry point of a Yew application.
 /// If you would like to pass props, use the `start_app_with_props_in_element` method.
 pub fn start_app_in_element<COMP>(element: Element) -> AppHandle<COMP>