CLI: Toasts & Tweaks (#2702)

* progress: cli toasts

* forgot the html

* progress: toasts

* revision: don't open splash on desktop

* fix: fmt, spellcheck

packages/cli/src/builder/prepare_html.rs

@@ -10,6 +10,7 @@ use std::path::{Path, PathBuf};
 use tracing::Level;
 
 const DEFAULT_HTML: &str = include_str!("../../assets/index.html");
+const TOAST_HTML: &str = include_str!("../../assets/toast.html");
 
 impl BuildRequest {
     pub(crate) fn prepare_html(
@@ -110,9 +111,16 @@ impl BuildRequest {
                 });
                 }
             );
-            </script></body"#,
+            </script>
+            {DX_TOAST_UTILITIES}
+            </body"#,
         );
 
+        *html = match self.serve && !self.build_arguments.release {
+            true => html.replace("{DX_TOAST_UTILITIES}", TOAST_HTML),
+            false => html.replace("{DX_TOAST_UTILITIES}", ""),
+        };
+
         // And try to insert preload links for the wasm and js files
         *html = html.replace(
             "</head",

packages/cli/src/builder/progress.rs

@@ -43,6 +43,7 @@ impl std::fmt::Display for Stage {
     }
 }
 
+#[derive(Debug, Clone)]
 pub struct UpdateBuildProgress {
     pub stage: Stage,
     pub update: UpdateStage,

packages/cli/src/serve/mod.rs

@@ -1,3 +1,4 @@
+use crate::builder::{Stage, UpdateBuildProgress, UpdateStage};
 use crate::cli::serve::Serve;
 use crate::dioxus_crate::DioxusCrate;
 use crate::Result;
@@ -106,9 +107,17 @@ pub async fn serve_all(serve: Serve, dioxus_crate: DioxusCrate) -> Result<()> {
                 // We also can check the status of the builds here in case we have multiple ongoing builds
                 match application {
                     Ok(BuilderUpdate::Progress { platform, update }) => {
-                        let update_stage = update.stage;
-                        screen.new_build_logs(platform, update);
-                        server.update_build_status(screen.build_progress.progress(), update_stage.to_string()).await;
+                        let update_clone = update.clone();
+                        screen.new_build_logs(platform, update_clone);
+                        server.update_build_status(screen.build_progress.progress(), update.stage.to_string()).await;
+
+                        match update {
+                            // Send rebuild start message.
+                            UpdateBuildProgress { stage: Stage::Compiling, update: UpdateStage::Start } => server.send_reload_start().await,
+                            // Send rebuild failed message.
+                            UpdateBuildProgress { stage: Stage::Finished, update: UpdateStage::Failed(_) } => server.send_reload_failed().await,
+                            _ => {},
+                        }
                     }
                     Ok(BuilderUpdate::Ready { results }) => {
                         if !results.is_empty() {
@@ -130,7 +139,7 @@ pub async fn serve_all(serve: Serve, dioxus_crate: DioxusCrate) -> Result<()> {
                         screen.new_ready_app(&mut builder, results);
 
                         // And then finally tell the server to reload
-                        server.send_reload().await;
+                        server.send_reload_command().await;
                     },
                     Err(err) => {
                         server.send_build_error(err).await;

packages/cli/src/serve/server.rs

@@ -131,6 +131,7 @@ impl Server {
         // Actually just start the server, cloning in a few bits of config
         let web_config = cfg.dioxus_config.web.https.clone();
         let base_path = cfg.dioxus_config.web.app.base_path.clone();
+        let platform = serve.platform();
         let _server_task = tokio::spawn(async move {
             let web_config = web_config.clone();
             // HTTPS
@@ -139,7 +140,7 @@ impl Server {
             let rustls: Option<RustlsConfig> = get_rustls(&web_config).await.unwrap();
 
             // Open the browser
-            if start_browser {
+            if start_browser && platform != Platform::Desktop {
                 open_browser(base_path, addr, rustls.is_some());
             }
 
@@ -175,6 +176,7 @@ impl Server {
         }
     }
 
+    /// Sends the current build status to all clients.
     async fn send_build_status(&mut self) {
         let mut i = 0;
         while i < self.build_status_sockets.len() {
@@ -190,6 +192,7 @@ impl Server {
         }
     }
 
+    /// Sends a start build message to all clients.
     pub async fn start_build(&mut self) {
         self.build_status.set(Status::Building {
             progress: 0.0,
@@ -198,6 +201,7 @@ impl Server {
         self.send_build_status().await;
     }
 
+    /// Sends an updated build status to all clients.
     pub async fn update_build_status(&mut self, progress: f64, build_message: String) {
         if !matches!(self.build_status.get(), Status::Building { .. }) {
             return;
@@ -209,6 +213,7 @@ impl Server {
         self.send_build_status().await;
     }
 
+    /// Sends hot reloadable changes to all clients.
     pub async fn send_hotreload(&mut self, reload: HotReloadMsg) {
         let msg = DevserverMsg::HotReload(reload);
         let msg = serde_json::to_string(&msg).unwrap();
@@ -275,6 +280,7 @@ impl Server {
         None
     }
 
+    /// Converts a `cargo` error to HTML and sends it to clients.
     pub async fn send_build_error(&mut self, error: Error) {
         let error = error.to_string();
         self.build_status.set(Status::BuildError {
@@ -283,25 +289,36 @@ impl Server {
         self.send_build_status().await;
     }
 
-    pub async fn send_reload(&mut self) {
-        self.build_status.set(Status::Ready);
-        self.send_build_status().await;
-        for socket in self.hot_reload_sockets.iter_mut() {
-            _ = socket
-                .send(Message::Text(
-                    serde_json::to_string(&DevserverMsg::FullReload).unwrap(),
-                ))
-                .await;
-        }
+    /// Tells all clients that a full rebuild has started.
+    pub async fn send_reload_start(&mut self) {
+        self.send_devserver_message(DevserverMsg::FullReloadStart)
+            .await;
     }
 
-    /// Send a shutdown message to all connected clients
+    /// Tells all clients that a full rebuild has failed.
+    pub async fn send_reload_failed(&mut self) {
+        self.send_devserver_message(DevserverMsg::FullReloadFailed)
+            .await;
+    }
+
+    /// Tells all clients to reload if possible for new changes.
+    pub async fn send_reload_command(&mut self) {
+        self.build_status.set(Status::Ready);
+        self.send_build_status().await;
+        self.send_devserver_message(DevserverMsg::FullReloadCommand)
+            .await;
+    }
+
+    /// Send a shutdown message to all connected clients.
     pub async fn send_shutdown(&mut self) {
+        self.send_devserver_message(DevserverMsg::Shutdown).await;
+    }
+
+    /// Sends a devserver message to all connected clients.
+    async fn send_devserver_message(&mut self, msg: DevserverMsg) {
         for socket in self.hot_reload_sockets.iter_mut() {
             _ = socket
-                .send(Message::Text(
-                    serde_json::to_string(&DevserverMsg::Shutdown).unwrap(),
-                ))
+                .send(Message::Text(serde_json::to_string(&msg).unwrap()))
                 .await;
         }
     }