Merge branch 'master' into polled-stream

# Conflicts:
#	packages/yew/src/server_renderer.rs

packages/yew/src/server_renderer.rs

@@ -1,22 +1,23 @@
 use std::fmt;
+use std::future::Future;
 
 use futures::pin_mut;
 use futures::stream::{Stream, StreamExt};
 use tracing::Instrument;
 
 use crate::html::{BaseComponent, Scope};
 use crate::platform::fmt::BufStream;
-use crate::platform::{run_pinned, spawn_local};
+use crate::platform::{LocalHandle, Runtime};
 
 /// A Yew Server-side Renderer that renders on the current thread.
 ///
 /// # Note
 ///
 /// This renderer does not spawn its own runtime and can only be used when:
 ///
-/// - `wasm-bindgen` is selected as the backend of Yew runtime.
+/// - `wasm-bindgen-futures` is selected as the backend of Yew runtime.
 /// - running within a [`Runtime`](crate::platform::Runtime).
-/// - running within a tokio [`LocalSet`](tokio::task::LocalSet).
+/// - running within a tokio [`LocalSet`](struct@tokio::task::LocalSet).
 #[cfg(feature = "ssr")]
 #[derive(Debug)]
 pub struct LocalServerRenderer<COMP>
@@ -74,11 +75,10 @@ where
 
     /// Renders Yew Application.
     pub async fn render(self) -> String {
-        let mut s = String::new();
-
-        self.render_to_string(&mut s).await;
+        let s = self.render_stream();
+        futures::pin_mut!(s);
 
-        s
+        s.collect().await
     }
 
     /// Renders Yew Application to a String.
@@ -115,7 +115,7 @@ where
 
 /// A Yew Server-side Renderer.
 ///
-/// This renderer spawns the rendering task to an internal worker pool and receives result when
+/// This renderer spawns the rendering task to a Yew [`Runtime`]. and receives result when
 /// the rendering process has finished.
 ///
 /// See [`yew::platform`] for more information.
@@ -126,6 +126,7 @@ where
 {
     create_props: Box<dyn Send + FnOnce() -> COMP::Properties>,
     hydratable: bool,
+    rt: Option<Runtime>,
 }
 
 impl<COMP> fmt::Debug for ServerRenderer<COMP>
@@ -175,9 +176,17 @@ where
         Self {
             create_props: Box::new(create_props),
             hydratable: true,
+            rt: None,
         }
     }
 
+    /// Sets the runtime the ServerRenderer will run the rendering task with.
+    pub fn with_runtime(mut self, rt: Runtime) -> Self {
+        self.rt = Some(rt);
+
+        self
+    }
+
     /// Sets whether an the rendered result is hydratable.
     ///
     /// Defaults to `true`.
@@ -192,11 +201,26 @@ where
 
     /// Renders Yew Application.
     pub async fn render(self) -> String {
-        let mut s = String::new();
+        let Self {
+            create_props,
+            hydratable,
+            rt,
+        } = self;
 
-        self.render_to_string(&mut s).await;
+        let (tx, rx) = futures::channel::oneshot::channel();
+        let create_task = move || async move {
+            let props = create_props();
+            let s = LocalServerRenderer::<COMP>::with_props(props)
+                .hydratable(hydratable)
+                .render()
+                .await;
 
-        s
+            let _ = tx.send(s);
+        };
+
+        Self::spawn_rendering_task(rt, create_task);
+
+        rx.await.expect("failed to receive.")
     }
 
     /// Renders Yew Application to a String.
@@ -208,34 +232,47 @@ where
         }
     }
 
-    /// Renders Yew Applications into a string Stream.
-    ///
-    /// # Note
-    ///
-    /// Unlike [`LocalServerRenderer::render_stream`], this method is `async fn`.
-    pub async fn render_stream(self) -> impl Stream<Item = String> {
+    #[inline]
+    fn spawn_rendering_task<F, Fut>(rt: Option<Runtime>, create_task: F)
+    where
+        F: 'static + Send + FnOnce() -> Fut,
+        Fut: Future<Output = ()> + 'static,
+    {
+        match rt {
+            // If a runtime is specified, spawn to the specified runtime.
+            Some(m) => m.spawn_pinned(create_task),
+            None => match LocalHandle::try_current() {
+                // If within a Yew Runtime, spawn to the current runtime.
+                Some(m) => m.spawn_local(create_task()),
+                // Outside of Yew Runtime, spawn to the default runtime.
+                None => Runtime::default().spawn_pinned(create_task),
+            },
+        }
+    }
+
+    /// Renders Yew Application into a string Stream.
+    pub fn render_stream(self) -> impl Send + Stream<Item = String> {
         let Self {
             create_props,
             hydratable,
+            rt,
         } = self;
 
-        run_pinned(move || async move {
-            let (tx, rx) = futures::channel::mpsc::unbounded();
+        let (tx, rx) = futures::channel::mpsc::unbounded();
+        let create_task = move || async move {
+            let props = create_props();
+            let s = LocalServerRenderer::<COMP>::with_props(props)
+                .hydratable(hydratable)
+                .render_stream();
+            pin_mut!(s);
 
-            spawn_local(async move {
-                let props = create_props();
-                let s = LocalServerRenderer::<COMP>::with_props(props)
-                    .hydratable(hydratable)
-                    .render_stream();
-                pin_mut!(s);
+            while let Some(m) = s.next().await {
+                let _ = tx.unbounded_send(m);
+            }
+        };
 
-                while let Some(m) = s.next().await {
-                    let _ = tx.unbounded_send(m);
-                }
-            });
+        Self::spawn_rendering_task(rt, create_task);
 
-            rx
-        })
-        .await
+        rx
     }
 }