Split out isrg from ssr and reorient build graph to make interpreter build 2x faster (#2969)

* split out isrg and core-types to speed up interpreter build

packages/fullstack/src/lib.rs

@@ -62,7 +62,7 @@ pub mod prelude {
 
     #[cfg(feature = "server")]
     #[cfg_attr(docsrs, doc(cfg(feature = "server")))]
-    pub use dioxus_ssr::incremental::{IncrementalRenderer, IncrementalRendererConfig};
+    pub use dioxus_isrg::{IncrementalRenderer, IncrementalRendererConfig};
 
     pub use dioxus_server_macro::*;
     pub use server_fn::{self, ServerFn as _, ServerFnError};

packages/fullstack/src/render.rs

@@ -1,10 +1,8 @@
 //! A shared pool of renderers for efficient server side rendering.
 use crate::streaming::{Mount, StreamingRenderer};
 use dioxus_interpreter_js::INITIALIZE_STREAMING_JS;
-use dioxus_ssr::{
-    incremental::{CachedRender, RenderFreshness},
-    Renderer,
-};
+use dioxus_isrg::{CachedRender, RenderFreshness};
+use dioxus_ssr::Renderer;
 use futures_channel::mpsc::Sender;
 use futures_util::{Stream, StreamExt};
 use std::sync::Arc;
@@ -48,13 +46,13 @@ where
 
 struct SsrRendererPool {
     renderers: RwLock<Vec<Renderer>>,
-    incremental_cache: Option<RwLock<dioxus_ssr::incremental::IncrementalRenderer>>,
+    incremental_cache: Option<RwLock<dioxus_isrg::IncrementalRenderer>>,
 }
 
 impl SsrRendererPool {
     fn new(
         initial_size: usize,
-        incremental: Option<dioxus_ssr::incremental::IncrementalRendererConfig>,
+        incremental: Option<dioxus_isrg::IncrementalRendererConfig>,
     ) -> Self {
         let renderers = RwLock::new((0..initial_size).map(|_| pre_renderer()).collect());
         Self {
@@ -67,7 +65,7 @@ impl SsrRendererPool {
     fn check_cached_route(
         &self,
         route: &str,
-        render_into: &mut Sender<Result<String, dioxus_ssr::incremental::IncrementalRendererError>>,
+        render_into: &mut Sender<Result<String, dioxus_isrg::IncrementalRendererError>>,
     ) -> Option<RenderFreshness> {
         if let Some(incremental) = &self.incremental_cache {
             if let Ok(mut incremental) = incremental.write() {
@@ -79,11 +77,7 @@ impl SsrRendererPool {
                             ..
                         } = cached_render;
                         _ = render_into.start_send(String::from_utf8(response.to_vec()).map_err(
-                            |err| {
-                                dioxus_ssr::incremental::IncrementalRendererError::Other(Box::new(
-                                    err,
-                                ))
-                            },
+                            |err| dioxus_isrg::IncrementalRendererError::Other(Box::new(err)),
                         ));
                         return Some(freshness);
                     }
@@ -110,19 +104,19 @@ impl SsrRendererPool {
     ) -> Result<
         (
             RenderFreshness,
-            impl Stream<Item = Result<String, dioxus_ssr::incremental::IncrementalRendererError>>,
+            impl Stream<Item = Result<String, dioxus_isrg::IncrementalRendererError>>,
         ),
-        dioxus_ssr::incremental::IncrementalRendererError,
+        dioxus_isrg::IncrementalRendererError,
     > {
         struct ReceiverWithDrop {
             receiver: futures_channel::mpsc::Receiver<
-                Result<String, dioxus_ssr::incremental::IncrementalRendererError>,
+                Result<String, dioxus_isrg::IncrementalRendererError>,
             >,
             cancel_task: Option<tokio::task::JoinHandle<()>>,
         }
 
         impl Stream for ReceiverWithDrop {
-            type Item = Result<String, dioxus_ssr::incremental::IncrementalRendererError>;
+            type Item = Result<String, dioxus_isrg::IncrementalRendererError>;
 
             fn poll_next(
                 mut self: std::pin::Pin<&mut Self>,
@@ -142,7 +136,7 @@ impl SsrRendererPool {
         }
 
         let (mut into, rx) = futures_channel::mpsc::channel::<
-            Result<String, dioxus_ssr::incremental::IncrementalRendererError>,
+            Result<String, dioxus_isrg::IncrementalRendererError>,
         >(1000);
 
         // before we even spawn anything, we can check synchronously if we have the route cached
@@ -302,9 +296,7 @@ impl SsrRendererPool {
                             resolved_data,
                             &mut resolved_chunk,
                         ) {
-                            throw_error!(
-                                dioxus_ssr::incremental::IncrementalRendererError::RenderError(err)
-                            );
+                            throw_error!(dioxus_isrg::IncrementalRendererError::RenderError(err));
                         }
 
                         stream.render(resolved_chunk);
@@ -406,9 +398,9 @@ impl SSRState {
     ) -> Result<
         (
             RenderFreshness,
-            impl Stream<Item = Result<String, dioxus_ssr::incremental::IncrementalRendererError>>,
+            impl Stream<Item = Result<String, dioxus_isrg::IncrementalRendererError>>,
         ),
-        dioxus_ssr::incremental::IncrementalRendererError,
+        dioxus_isrg::IncrementalRendererError,
     > {
         self.renderers
             .clone()
@@ -435,11 +427,11 @@ impl FullstackHTMLTemplate {
         &self,
         to: &mut R,
         virtual_dom: &VirtualDom,
-    ) -> Result<(), dioxus_ssr::incremental::IncrementalRendererError> {
+    ) -> Result<(), dioxus_isrg::IncrementalRendererError> {
         let ServeConfig { index, .. } = &self.cfg;
 
         let title = {
-            let document: Option<std::rc::Rc<dyn dioxus_lib::prelude::document::Document>> =
+            let document: Option<std::rc::Rc<dyn Document>> =
                 virtual_dom.in_runtime(|| ScopeId::ROOT.consume_context());
             let document: Option<&crate::document::server::ServerDocument> = document
                 .as_ref()
@@ -478,7 +470,7 @@ impl FullstackHTMLTemplate {
     fn render_before_body<R: std::fmt::Write>(
         &self,
         to: &mut R,
-    ) -> Result<(), dioxus_ssr::incremental::IncrementalRendererError> {
+    ) -> Result<(), dioxus_isrg::IncrementalRendererError> {
         let ServeConfig { index, .. } = &self.cfg;
 
         to.write_str(&index.close_head)?;
@@ -493,7 +485,7 @@ impl FullstackHTMLTemplate {
         &self,
         to: &mut R,
         virtual_dom: &VirtualDom,
-    ) -> Result<(), dioxus_ssr::incremental::IncrementalRendererError> {
+    ) -> Result<(), dioxus_isrg::IncrementalRendererError> {
         let ServeConfig { index, .. } = &self.cfg;
 
         // Collect the initial server data from the root node. For most apps, no use_server_futures will be resolved initially, so this will be full on `None`s.
@@ -512,7 +504,7 @@ impl FullstackHTMLTemplate {
     pub fn render_after_body<R: std::fmt::Write>(
         &self,
         to: &mut R,
-    ) -> Result<(), dioxus_ssr::incremental::IncrementalRendererError> {
+    ) -> Result<(), dioxus_isrg::IncrementalRendererError> {
         let ServeConfig { index, .. } = &self.cfg;
 
         to.write_str(&index.after_closing_body_tag)?;
@@ -526,7 +518,7 @@ impl FullstackHTMLTemplate {
         to: &mut R,
         virtual_dom: &VirtualDom,
         body: impl std::fmt::Display,
-    ) -> Result<(), dioxus_ssr::incremental::IncrementalRendererError> {
+    ) -> Result<(), dioxus_isrg::IncrementalRendererError> {
         self.render_head(to, virtual_dom)?;
         write!(to, "{body}")?;
         self.render_after_main(to, virtual_dom)?;

packages/fullstack/src/serve_config.rs

@@ -11,7 +11,7 @@ pub struct ServeConfigBuilder {
     pub(crate) root_id: Option<&'static str>,
     pub(crate) index_html: Option<String>,
     pub(crate) index_path: Option<PathBuf>,
-    pub(crate) incremental: Option<dioxus_ssr::incremental::IncrementalRendererConfig>,
+    pub(crate) incremental: Option<dioxus_isrg::IncrementalRendererConfig>,
 }
 
 impl ServeConfigBuilder {
@@ -26,7 +26,7 @@ impl ServeConfigBuilder {
     }
 
     /// Enable incremental static generation
-    pub fn incremental(mut self, cfg: dioxus_ssr::incremental::IncrementalRendererConfig) -> Self {
+    pub fn incremental(mut self, cfg: dioxus_isrg::IncrementalRendererConfig) -> Self {
         self.incremental = Some(cfg);
         self
     }
@@ -166,7 +166,7 @@ pub(crate) struct IndexHtml {
 #[derive(Clone)]
 pub struct ServeConfig {
     pub(crate) index: IndexHtml,
-    pub(crate) incremental: Option<dioxus_ssr::incremental::IncrementalRendererConfig>,
+    pub(crate) incremental: Option<dioxus_isrg::IncrementalRendererConfig>,
 }
 
 impl ServeConfig {