Suspense boundaries/out of order streaming/anyhow like error handling (#2365)

* create static site generation helpers in the router crate * work on integrating static site generation into fullstack * move ssg into a separate crate * integrate ssg with the launch builder * simplify ssg example * fix static_routes for child routes * move CLI hot reloading websocket code into dioxus-hot-reload * fix some unused imports * use the same hot reloading websocket code for fullstack * fix fullstack hot reloading * move cli hot reloading logic into the hot reload crate * ssg example working with dx serve * add more examples * fix clippy * switch to a result for Element * fix formatting * fix hot reload doctest imports * fix axum imports * add show method to error context * implement retaining nodes during suspense * fix unterminated if statements * communicate between tasks and suspense boundaries * make suspense placeholders easier to use * implement IntoDynNode and IntoVNode for more wrappers * fix clippy examples * fix rsx tests * add streaming html utilities to the ssr package * unify hydration and non-hydration ssr cache * fix router with Result Element * don't run server doc tests * Fix hot reload websocket doc examples * simple apps working with fullstack streaming * fix preloading wasm * Report errors encountered while streaming * remove async from incremental renderer * document new VirtualDom suspense methods * make streaming work with incremental rendering * fix static site generation * document suspense structs * create closure type; allow async event handlers in props; allow shorthand event handlers * test forwarding event handlers with the shorthand syntax * fix clippy * fix imports in spawn async doctest * fix empty rsx * fix async result event handlers * fix mounting router in multiple places * Fix task dead cancel race condition * simplify diffing before adding suspense * fix binary size increase * fix attribute diffing * more diffing fixes * create minimal fullstack feature * smaller fullstack bundles * allow mounting nodes that are already created and creating nodes without mounting them * fix hot reload feature * fix replacing components * don't reclaim virtual nodes * client side suspense working! * fix CLI * slightly smaller fullstack builds * fix multiple suspended scopes * fix merge errors * yield back to tokio every few polls to fix suspending on many tasks at once * remove logs * document suspense boundary and update suspense example * fix ssg * make streaming optional * fix some router and core tests * fix suspense example * fix serialization with out of order server futures * add incremental streaming hackernews demo * fix hackernews demo * fix root hackernews redirect * fix formatting * add tests for suspense cases * slightly smaller binaries * slightly smaller * improve error handling docs * fix errors example link * fix doc tests * remove log file * fix ssr cache type inference * remove index.html * fix ssg render template * fix assigning ids on elements with dynamic attributes * add desktop feature to the workspace examples * remove router static generation example; ssg lives in the dioxus-static-generation package * add a test for effects during suspense * only run effects on mounted nodes * fix multiple suspense roots * fix node iterator * fix closures without arguments * fix dioxus-core readme doctest * remove suspense logs * fix scope stack * fix clippy * remove unused suspense boundary from hackernews * assert that launch never returns for better compiler errors * fix static generation launch function * fix web renderer * pass context providers into server functions * add an example for FromContext * clean up DioxusRouterExt * fix server function context * fix fullstack desktop example * forward CLI serve settings to fullstack * re-export serve config at the root of fullstack * forward env directly instead of using a guard * just set the port in the CLI for fullstack playwright tests * fix fullstack dioxus-cli-config feature * fix launch server merge conflicts * fix fullstack launch context * Merge branch 'main' into suspense-2.0 * fix fullstack html data * remove drop virtual dom feature * add a comment about only_write_templates binary size workaround * remove explicit dependencies from use_server_future * make ErrorContext and SuspenseContext more similar * Tweak: small tweaks to tomls to make diff smaller * only rerun components under suspense after the initial placeholders are sent to the client * add module docs for suspense * keep track of when suspense boundaries are resolved * start implementing JS out of order streaming * fix core tests * implement the server side of suspense with js * fix streaming ssr with nested suspense * move streaming ssr code into fullstack * revert minification changes * serialize server future data as the html streams * start loading scripts wasm immediately instead of defering the script * very basic nested suspense example working with minimal html updates * clean up some suspense/error docs * fix hydrating nested pending server futures * sort resolved boundaries by height * Fix disconnecting clients while streaming * fix static generation crate * don't insert extra divs when hydrating streamed chunks * wait to swap in the elements until they are hydrated * remove inline streaming script * hackernews partially working * fix spa mode * banish the open shadow dom * fix removing placeholder * set up streaming playwright test * run web playwright tests on 9999 to avoid port conflicts with other local servers * remove suspense nodes if the suspense boundary is replaced before the suspense resolves on the server * ignore hydration of removed suspense boundaries * use path based indexing to fix hydrating suspense after parent suspense with child is removed * re-export dioxus error * remove resolved suspense divs if the suspense boundary has been removed * Fix client side initialized server futures * ignore comment nodes while traversing nodes in core to avoid lists getting swapped out with suspense * Pass initial hydration data to the client * hide pre nodes * don't panic if reclaiming an element fails * fix scope stack when polling tasks * improve deserialization out of length message * Ok(VNode::placeholder()) -> VNode::empty() * fix typo in rsx usage * restore testing changes from suspense example * clean up some logs and comments * fix playwright tests * clean up more changes in core * clean up core tests * remove anymap dependency * clean up changes to hooks * clean up changes in the router, rsx, and web * revert changes to axum-hello-world * fix use_server_future * fix clippy in dioxus-core * check that the next or previous node exist before checking if we should ignore them * fix formatting * fix suspense playwright test * remove unused suspense code * add more suspense playwright tests * add more docs for error boundaries * fix suspense core tests * fix ErrorBoundary example * remove a bunch of debug logging in js * fix router failure_external_navigation * use absolute paths in the interpreter build.rs * strip '\r' while hashing ts files * add a wrapper with a default error boundary and suspense boundary * restore hot reloading * ignore non-ts files when hashing * sort ts files before hashing them * fix rsx tests * fix fullstack doc tests * fix core tests * fix axum auth example * update suspense hydration diagram * longer playwright build limit * tiny fixes - spelling, formatting * update diagram link * remove comment and template nodes for suspense placeholders * remove comment nodes as we hydrate text * simplify hackernews example * clean up hydrating text nodes * switch to a separate environment variable for the base path for smaller binaries * clean up file system html trait * fix form data * move streaming code into fullstack * implement serialize and deserialize for CapturedError * remove waits in the nested suspense playwright spec * force sequential fullstack builds for CI * longer nested suspense delay for CI * fix --force-sequential flag * wait to launch server until client build is done --------- Co-authored-by: Jonathan Kelley <jkelleyrtp@gmail.com>
2024-07-01 20:50:36 -07:00
1 parent ffa36a67c3
commit 022e4ad203
@@ -74,7 +74,7 @@ cargo run --example hello_world

 [disabled](./disabled.rs) - Disable buttons conditionally

-[error_handle](./error_handle.rs) - Handle errors with early return
+[errors](./errors.rs) - Handle errors with early return

 ## Routing

@@ -1,55 +0,0 @@
-//! This example showcases how to use the ErrorBoundary component to handle errors in your app.
-//!
-//! The ErrorBoundary component is a special component that can be used to catch panics and other errors that occur.
-//! By default, Dioxus will catch panics during rendering, async, and handlers, and bubble them up to the nearest
-//! error boundary. If no error boundary is present, it will be caught by the root error boundary and the app will
-//! render the error message as just a string.
-
-use dioxus::{dioxus_core::CapturedError, prelude::*};
-
-fn main() {
-    launch_desktop(app);
-}
-
-fn app() -> Element {
-    rsx! {
-        ErrorBoundary {
-            handle_error: |error: CapturedError| rsx! {
-                h1 { "An error occurred" }
-                pre { "{error:#?}" }
-            },
-            DemoC { x: 1 }
-        }
-
-        ErrorBoundary {
-            handle_error: |error: CapturedError| rsx! {
-                h1 { "Another error occurred" }
-                pre { "{error:#?}" }
-            },
-            ComponentPanic {}
-        }
-    }
-}
-
-#[component]
-fn DemoC(x: i32) -> Element {
-    rsx! {
-        h1 { "Error handler demo" }
-        button {
-            onclick: move |_| {
-                // Create an error
-                let result: Result<Element, &str> = Err("Error");
-
-                // And then call `throw` on it. The `throw` method is given by the `Throw` trait which is automatically
-                // imported via the prelude.
-                _ = result.throw();
-            },
-            "Click to throw an error"
-        }
-    }
-}
-
-#[component]
-fn ComponentPanic() -> Element {
-    panic!("This component panics")
-}
@@ -0,0 +1,161 @@
+//! This example showcases how to use the ErrorBoundary component to handle errors in your app.
+//!
+//! The ErrorBoundary component is a special component that can be used to catch panics and other errors that occur.
+//! By default, Dioxus will catch panics during rendering, async, and handlers, and bubble them up to the nearest
+//! error boundary. If no error boundary is present, it will be caught by the root error boundary and the app will
+//! render the error message as just a string.
+//!
+//! NOTE: In wasm, panics can currently not be caught by the error boundary. This is a limitation of WASM in rust.
+#![allow(non_snake_case)]
+
+use dioxus::prelude::*;
+
+fn main() {
+    launch(|| rsx! { Router::<Route> {} });
+}
+
+/// You can use an ErrorBoundary to catch errors in children and display a warning
+fn Simple() -> Element {
+    rsx! {
+        GoBackButton { "Home" }
+        ErrorBoundary {
+            handle_error: |error: ErrorContext| rsx! {
+                h1 { "An error occurred" }
+                pre { "{error:#?}" }
+            },
+            ParseNumber {}
+        }
+    }
+}
+
+#[component]
+fn ParseNumber() -> Element {
+    rsx! {
+        h1 { "Error handler demo" }
+        button {
+            onclick: move |_| {
+                // You can return a result from an event handler which lets you easily quit rendering early if something fails
+                let data: i32 = "0.5".parse()?;
+
+                println!("parsed {data}");
+
+                Ok(())
+            },
+            "Click to throw an error"
+        }
+    }
+}
+
+// You can provide additional context for the Error boundary to visualize
+fn Show() -> Element {
+    rsx! {
+        GoBackButton { "Home" }
+        div {
+            ErrorBoundary {
+                handle_error: |errors: ErrorContext| {
+                    rsx! {
+                        for error in errors.errors() {
+                            if let Some(error) = error.show() {
+                                {error}
+                            } else {
+                                pre {
+                                    color: "red",
+                                    "{error}"
+                                }
+                            }
+                        }
+                    }
+                },
+                ParseNumberWithShow {}
+            }
+        }
+    }
+}
+
+#[component]
+fn ParseNumberWithShow() -> Element {
+    rsx! {
+        h1 { "Error handler demo" }
+        button {
+            onclick: move |_| {
+                let request_data = "0.5";
+                let data: i32 = request_data.parse()
+                    // You can attach rsx to results that can be displayed in the Error Boundary
+                    .show(|_| rsx!{
+                        div {
+                            background_color: "red",
+                            border: "black",
+                            border_width: "2px",
+                            border_radius: "5px",
+                            p { "Failed to parse data" }
+                            Link {
+                                to: Route::Home {},
+                                "Go back to the homepage"
+                            }
+                        }
+                    })?;
+
+                println!("parsed {data}");
+
+                Ok(())
+            },
+            "Click to throw an error"
+        }
+    }
+}
+
+// On desktop, dioxus will catch panics in components and insert an error automatically
+fn Panic() -> Element {
+    rsx! {
+        GoBackButton { "Home" }
+        ErrorBoundary {
+            handle_error: |errors: ErrorContext| rsx! {
+                h1 { "Another error occurred" }
+                pre { "{errors:#?}" }
+            },
+            ComponentPanic {}
+        }
+    }
+}
+
+#[component]
+fn ComponentPanic() -> Element {
+    panic!("This component panics")
+}
+
+#[derive(Routable, Clone, Debug, PartialEq)]
+enum Route {
+    #[route("/")]
+    Home {},
+    #[route("/simple")]
+    Simple {},
+    #[route("/panic")]
+    Panic {},
+    #[route("/show")]
+    Show {},
+}
+
+fn Home() -> Element {
+    rsx! {
+        ul {
+            li {
+                Link {
+                    to: Route::Simple {},
+                    "Simple errors"
+                }
+            }
+            li {
+                Link {
+                    to: Route::Panic {},
+                    "Capture panics"
+                }
+            }
+            li {
+                Link {
+                    to: Route::Show {},
+                    "Show errors"
+                }
+            }
+        }
+    }
+}
@@ -170,13 +170,13 @@ fn app() -> Element {

            // Can pass in props directly as an expression
            {
-                let props = TallerProps {a: "hello", children: None };
+                let props = TallerProps {a: "hello", children: VNode::empty() };
                rsx!(Taller { ..props })
            }

            // Spreading can also be overridden manually
            Taller {
-                ..TallerProps { a: "ballin!", children: None },
+                ..TallerProps { a: "ballin!", children: VNode::empty() },
                a: "not ballin!"
            }

@@ -193,8 +193,8 @@ fn app() -> Element {
            // Type inference can be used too
            TypedInput { initial: 10.0 }

-            // geneircs with the `inline_props` macro
-            Label { text: "hello geneirc world!" }
+            // generic with the `inline_props` macro
+            Label { text: "hello generic world!" }
            Label { text: 99.9 }

            // Lowercase components work too, as long as they are access using a path
@@ -283,7 +283,7 @@ where
        return rsx! { "{props}" };
    }

-    None
+    VNode::empty()
 }

 #[component]
@@ -22,7 +22,7 @@ fn app() -> Element {
    rsx! {
        div { class, id, {&children} }
        Component { a, b, c, children, onclick }
-        Component { a, ..ComponentProps { a: 1, b: 2, c: 3, children: None, onclick: Default::default() } }
+        Component { a, ..ComponentProps { a: 1, b: 2, c: 3, children: VNode::empty(), onclick: Default::default() } }
    }
 }

@@ -39,7 +39,14 @@ fn app() -> Element {
            }

            h3 { "Illustrious Dog Photo" }
-            Doggo {}
+            SuspenseBoundary {
+                fallback: move |suspense: SuspenseContext| suspense.suspense_placeholder().unwrap_or_else(|| rsx! {
+                    div {
+                        "Loading..."
+                    }
+                }),
+                Doggo {}
+            }
        }
    }
 }
@@ -49,7 +56,7 @@ fn app() -> Element {
 /// actually renders the data.
 #[component]
 fn Doggo() -> Element {
-    let mut fut = use_resource(move || async move {
+    let mut resource = use_resource(move || async move {
        #[derive(serde::Deserialize)]
        struct DogApi {
            message: String,
@@ -62,12 +69,26 @@ fn Doggo() -> Element {
            .await
    });

-    match fut.read_unchecked().as_ref() {
-        Some(Ok(resp)) => rsx! {
-            button { onclick: move |_| fut.restart(), "Click to fetch another doggo" }
+    // You can suspend the future and only continue rendering when it's ready
+    let value = resource.suspend().with_loading_placeholder(|| {
+        rsx! {
+            div {
+                "Loading doggos..."
+            }
+        }
+    })?;
+
+    match value.read_unchecked().as_ref() {
+        Ok(resp) => rsx! {
+            button { onclick: move |_| resource.restart(), "Click to fetch another doggo" }
            div { img { max_width: "500px", max_height: "500px", src: "{resp.message}" } }
        },
-        Some(Err(_)) => rsx! { div { "loading dogs failed" } },
-        None => rsx! { div { "loading dogs..." } },
+        Err(_) => rsx! {
+            div { "loading dogs failed" }
+            button {
+                onclick: move |_| resource.restart(),
+                "retry"
+            }
+        },
    }
 }