yewstack · ranile · Jul 1, 2022 · May 11, 2022 · May 22, 2022 · May 22, 2022
diff --git a/examples/function_router/src/app.rs b/examples/function_router/src/app.rs
@@ -1,7 +1,6 @@
 use std::collections::HashMap;
 
 use yew::prelude::*;
-use yew::virtual_dom::AttrValue;
 use yew_router::history::{AnyHistory, History, MemoryHistory};
 use yew_router::prelude::*;
 
@@ -55,7 +54,7 @@ pub fn App() -> Html {
 
 #[derive(Properties, PartialEq, Debug)]
 pub struct ServerAppProps {
-    pub url: AttrValue,
+    pub url: String,
     pub queries: HashMap<String, String>,
 }
 

diff --git a/examples/simple_ssr/Cargo.toml b/examples/simple_ssr/Cargo.toml
@@ -10,6 +10,8 @@ yew = { path = "../../packages/yew", features = ["ssr", "hydration"] }
 reqwest = { version = "0.11.8", features = ["json"] }
 serde = { version = "1.0.132", features = ["derive"] }
 uuid = { version = "1.0.0", features = ["serde"] }
+futures = "0.3"
+bytes = "1.0"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen-futures = "0.4"
@@ -19,7 +21,4 @@ log = "0.4"
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 tokio = { version = "1.15.0", features = ["full"] }
 warp = "0.3"
-num_cpus = "1.13"
-tokio-util = { version = "0.7", features = ["rt"] }
-once_cell = "1.5"
 clap = { version = "3.1.7", features = ["derive"] }
diff --git a/examples/simple_ssr/src/bin/simple_ssr_server.rs b/examples/simple_ssr/src/bin/simple_ssr_server.rs
@@ -1,13 +1,13 @@
+use std::error::Error;
 use std::path::PathBuf;
 
+use bytes::Bytes;
 use clap::Parser;
-use once_cell::sync::Lazy;
+use futures::stream::{self, Stream, StreamExt};
 use simple_ssr::App;
-use tokio_util::task::LocalPoolHandle;
 use warp::Filter;
 
-// We spawn a local pool that is as big as the number of cpu threads.
-static LOCAL_POOL: Lazy<LocalPoolHandle> = Lazy::new(|| LocalPoolHandle::new(num_cpus::get()));
+type BoxedError = Box<dyn Error + Send + Sync + 'static>;
 
 /// A basic example
 #[derive(Parser, Debug)]
@@ -17,19 +17,18 @@ struct Opt {
     dir: PathBuf,
 }
 
-async fn render(index_html_s: &str) -> String {
-    let content = LOCAL_POOL
-        .spawn_pinned(move || async move {
-            let renderer = yew::ServerRenderer::<App>::new();
-
-            renderer.render().await
-        })
-        .await
-        .expect("the task has failed.");
-
-    // Good enough for an example, but developers should avoid the replace and extra allocation
-    // here in an actual app.
-    index_html_s.replace("<body>", &format!("<body>{}", content))
+async fn render(
+    index_html_before: String,
+    index_html_after: String,
+) -> Box<dyn Stream<Item = Result<Bytes, BoxedError>> + Send> {
+    let renderer = yew::ServerRenderer::<App>::new();
+
+    Box::new(
+        stream::once(async move { index_html_before })
+            .chain(renderer.render_streamed().await)
+            .chain(stream::once(async move { index_html_after }))
+            .map(|m| Result::<_, BoxedError>::Ok(m.into())),
+    )
 }
 
 #[tokio::main]
@@ -40,10 +39,16 @@ async fn main() {
         .await
         .expect("failed to read index.html");
 
+    let (index_html_before, index_html_after) = index_html_s.split_once("<body>").unwrap();
+    let mut index_html_before = index_html_before.to_owned();
+    index_html_before.push_str("<body>");
+    let index_html_after = index_html_after.to_owned();
+
     let html = warp::path::end().then(move || {
-        let index_html_s = index_html_s.clone();
+        let index_html_before = index_html_before.clone();
+        let index_html_after = index_html_after.clone();
 
-        async move { warp::reply::html(render(&index_html_s).await) }
+        async move { warp::reply::html(render(index_html_before, index_html_after).await) }
     });
 
     let routes = html.or(warp::fs::dir(opts.dir));

diff --git a/examples/ssr_router/Cargo.toml b/examples/ssr_router/Cargo.toml
@@ -9,6 +9,7 @@ edition = "2021"
 yew = { path = "../../packages/yew", features = ["ssr", "hydration"] }
 function_router = { path = "../function_router" }
 log = "0.4"
+futures = "0.3"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 wasm-bindgen-futures = "0.4"
@@ -20,7 +21,4 @@ axum = "0.5"
 tower = { version = "0.4", features = ["make"] }
 tower-http = { version = "0.3", features = ["fs"] }
 env_logger = "0.9"
-num_cpus = "1.13"
-tokio-util = { version = "0.7", features = ["rt"] }
-once_cell = "1.5"
 clap = { version = "3.1.7", features = ["derive"] }
diff --git a/examples/ssr_router/src/bin/ssr_router_server.rs b/examples/ssr_router/src/bin/ssr_router_server.rs
@@ -1,24 +1,21 @@
 use std::collections::HashMap;
+use std::convert::Infallible;
 use std::path::PathBuf;
 
-use axum::body::Body;
+use axum::body::{Body, StreamBody};
 use axum::error_handling::HandleError;
 use axum::extract::Query;
 use axum::handler::Handler;
 use axum::http::{Request, StatusCode};
-use axum::response::Html;
+use axum::response::IntoResponse;
 use axum::routing::get;
 use axum::{Extension, Router};
 use clap::Parser;
 use function_router::{ServerApp, ServerAppProps};
-use once_cell::sync::Lazy;
-use tokio_util::task::LocalPoolHandle;
+use futures::stream::{self, StreamExt};
 use tower::ServiceExt;
 use tower_http::services::ServeDir;
 
-// We spawn a local pool that is as big as the number of cpu threads.
-static LOCAL_POOL: Lazy<LocalPoolHandle> = Lazy::new(|| LocalPoolHandle::new(num_cpus::get()));
-
 /// A basic example
 #[derive(Parser, Debug)]
 struct Opt {
@@ -28,29 +25,21 @@ struct Opt {
 }
 
 async fn render(
-    Extension(index_html_s): Extension<String>,
+    Extension((index_html_before, index_html_after)): Extension<(String, String)>,
     url: Request<Body>,
     Query(queries): Query<HashMap<String, String>>,
-) -> Html<String> {
+) -> impl IntoResponse {
     let url = url.uri().to_string();
 
-    let content = LOCAL_POOL
-        .spawn_pinned(move || async move {
-            let server_app_props = ServerAppProps {
-                url: url.into(),
-                queries,
-            };
-
-            let renderer = yew::ServerRenderer::<ServerApp>::with_props(server_app_props);
-
-            renderer.render().await
-        })
-        .await
-        .expect("the task has failed.");
+    let server_app_props = ServerAppProps { url, queries };
+    let renderer = yew::ServerRenderer::<ServerApp>::with_props(server_app_props);
 
-    // Good enough for an example, but developers should avoid the replace and extra allocation
-    // here in an actual app.
-    Html(index_html_s.replace("<body>", &format!("<body>{}", content)))
+    StreamBody::new(
+        stream::once(async move { index_html_before })
+            .chain(renderer.render_streamed().await)
+            .chain(stream::once(async move { index_html_after }))
+            .map(Result::<_, Infallible>::Ok),
+    )
 }
 
 #[tokio::main]
@@ -63,6 +52,12 @@ async fn main() {
         .await
         .expect("failed to read index.html");
 
+    let (index_html_before, index_html_after) = index_html_s.split_once("<body>").unwrap();
+    let mut index_html_before = index_html_before.to_owned();
+    index_html_before.push_str("<body>");
+
+    let index_html_after = index_html_after.to_owned();
+
     let handle_error = |e| async move {
         (
             StatusCode::INTERNAL_SERVER_ERROR,
@@ -73,13 +68,22 @@ async fn main() {
     let app = Router::new()
         .route("/api/test", get(|| async move { "Hello World" }))
         // needed because /~https://github.com/tower-rs/tower-http/issues/262
-        .route("/", get(render))
+        .route(
+            "/",
+            get(render.layer(Extension((
+                index_html_before.clone(),
+                index_html_after.clone(),
+            )))),
+        )
         .fallback(HandleError::new(
             ServeDir::new(opts.dir)
                 .append_index_html_on_directories(false)
                 .fallback(
                     render
-                        .layer(Extension(index_html_s))
+                        .layer(Extension((
+                            index_html_before.clone(),
+                            index_html_after.clone(),
+                        )))
                         .into_service()
                         .map_err(|err| -> std::io::Error { match err {} }),
                 ),

diff --git a/packages/yew/Cargo.toml b/packages/yew/Cargo.toml
@@ -14,7 +14,7 @@ keywords = ["web", "webasm", "javascript"]
 categories = ["gui", "wasm", "web-programming"]
 description = "A framework for making client-side single-page apps"
 readme = "../../README.md"
-rust-version = "1.56.0"
+rust-version = "1.60.0"
 
 [dependencies]
 console_error_panic_hook = "0.1"
@@ -70,6 +70,9 @@ wasm-bindgen-futures = "0.4"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 tokio = { version = "1.15.0", features = ["rt"], optional = true }
+num_cpus = { version = "1.13", optional = true }
+tokio-util = { version = "0.7", features = ["rt"], optional = true }
+once_cell = "1"
 
 [dev-dependencies]
 wasm-bindgen-test = "0.3"
@@ -87,9 +90,8 @@ features = [
 ]
 
 [features]
-# TODO: `dep:` syntax only supported with MSRV 1.60, would be more precise
-# tokio = ["dep:tokio"]
-ssr = ["futures", "html-escape"] # dep:html-escape
+tokio = ["dep:tokio", "dep:num_cpus", "dep:tokio-util"]
+ssr = ["dep:futures", "dep:html-escape"]
 csr = []
 hydration = ["csr"]
 default = []

diff --git a/packages/yew/Makefile.toml b/packages/yew/Makefile.toml
@@ -1,6 +1,6 @@
 [tasks.native-test]
 command = "cargo"
-args = ["test", "--features", "csr,ssr,hydration"]
+args = ["test", "--features", "csr,ssr,hydration,tokio"]
 
 [tasks.wasm-test]
 command = "wasm-pack"

diff --git a/packages/yew/src/html/component/scope.rs b/packages/yew/src/html/component/scope.rs
@@ -12,7 +12,7 @@ use super::lifecycle::ComponentState;
 use super::BaseComponent;
 use crate::callback::Callback;
 use crate::context::{ContextHandle, ContextProvider};
-use crate::io_coop::spawn_local;
+use crate::platform::spawn_local;
 #[cfg(any(feature = "csr", feature = "ssr"))]
 use crate::scheduler::Shared;
 
@@ -260,6 +260,7 @@ impl<COMP: BaseComponent> Scope<COMP> {
 
 #[cfg(feature = "ssr")]
 mod feat_ssr {
+    use futures::channel::mpsc::UnboundedSender;
     use futures::channel::oneshot;
 
     use super::*;
@@ -270,14 +271,16 @@ mod feat_ssr {
     use crate::virtual_dom::Collectable;
 
     impl<COMP: BaseComponent> Scope<COMP> {
-        pub(crate) async fn render_to_string(
-            self,
-            w: &mut String,
+        pub(crate) async fn render_into_stream(
+            &self,
+            tx: &mut UnboundedSender<String>,
             props: Rc<COMP::Properties>,
             hydratable: bool,
         ) {
-            let (tx, rx) = oneshot::channel();
-            let state = ComponentRenderState::Ssr { sender: Some(tx) };
+            let (html_tx, html_rx) = oneshot::channel();
+            let state = ComponentRenderState::Ssr {
+                sender: Some(html_tx),
+            };
 
             scheduler::push_component_create(
                 self.id,
@@ -295,16 +298,17 @@ mod feat_ssr {
             let collectable = Collectable::for_component::<COMP>();
 
             if hydratable {
-                collectable.write_open_tag(w);
+                collectable.write_open_tag(tx);
             }
 
-            let html = rx.await.unwrap();
+            let html = html_rx.await.unwrap();
 
             let self_any_scope = AnyScope::from(self.clone());
-            html.render_to_string(w, &self_any_scope, hydratable).await;
+            html.render_into_stream(tx, &self_any_scope, hydratable)
+                .await;
 
             if hydratable {
-                collectable.write_close_tag(w);
+                collectable.write_close_tag(tx);
             }
 
             scheduler::push_component_destroy(Box::new(DestroyRunner {

diff --git a/packages/yew/src/io_coop.rs b/packages/yew/src/io_coop.rs
diff --git a/packages/yew/src/lib.rs b/packages/yew/src/lib.rs
@@ -24,9 +24,7 @@
 //! - `csr`: Enables Client-side Rendering support and [`Renderer`]. Only enable this feature if you
 //!   are making a Yew application (not a library).
 //! - `ssr`: Enables Server-side Rendering support and [`ServerRenderer`].
-//! - `tokio`: Enables future-based APIs on non-wasm32 targets with tokio runtime. (You may want to
-//! enable this if your application uses future-based APIs and it does not compile / lint on
-//! non-wasm32 targets.)
+//! - `tokio`: Enables future-based APIs on non-wasm32 targets with tokio runtime.
 //! - `hydration`: Enables Hydration support.
 //!
 //! ## Example
@@ -280,7 +278,7 @@ pub mod context;
 mod dom_bundle;
 pub mod functional;
 pub mod html;
-mod io_coop;
+pub mod platform;
 pub mod scheduler;
 mod sealed;
 #[cfg(feature = "ssr")]