GitGreenHand
diff --git a/‎Cargo.lock
Lines changed: 350 additions & 75 deletions b/‎Cargo.lock
Lines changed: 350 additions & 75 deletions
diff --git a/‎Cargo.toml
Lines changed: 9 additions & 3 deletions b/‎Cargo.toml
Lines changed: 9 additions & 3 deletions
diff --git a/‎examples/README.md
Lines changed: 1 addition & 1 deletion b/‎examples/README.md
Lines changed: 1 addition & 1 deletion
diff --git a/‎examples/error_handle.rs
Lines changed: 0 additions & 55 deletions b/‎examples/error_handle.rs
Lines changed: 0 additions & 55 deletions
diff --git a/‎examples/errors.rs
Lines changed: 161 additions & 0 deletions b/‎examples/errors.rs
Lines changed: 161 additions & 0 deletions
diff --git a/‎examples/rsx_usage.rs
Lines changed: 5 additions & 5 deletions b/‎examples/rsx_usage.rs
Lines changed: 5 additions & 5 deletions
diff --git a/‎examples/shorthand.rs
Lines changed: 1 addition & 1 deletion b/‎examples/shorthand.rs
Lines changed: 1 addition & 1 deletion
diff --git a/‎examples/suspense.rs
Lines changed: 28 additions & 7 deletions b/‎examples/suspense.rs
Lines changed: 28 additions & 7 deletions
@@ -35,6 +35,7 @@ members = [
     "packages/fullstack/examples/axum-streaming",
     "packages/fullstack/examples/axum-desktop",
     "packages/fullstack/examples/axum-auth",
+    "packages/fullstack/examples/hackernews",
     "packages/static-generation/examples/simple",
     "packages/static-generation/examples/router",
     "packages/static-generation/examples/github-pages",
@@ -46,6 +47,8 @@ members = [
     "packages/playwright-tests/liveview",
     "packages/playwright-tests/web",
     "packages/playwright-tests/fullstack",
+    "packages/playwright-tests/suspense-carousel",
+    "packages/playwright-tests/nested-suspense",
 ]
 exclude = ["examples/mobile_demo", "examples/openid_connect_demo"]
 
@@ -61,10 +64,10 @@ dioxus-core-macro = { path = "packages/core-macro", version = "0.5.0" }
 dioxus-config-macro = { path = "packages/config-macro", version = "0.5.0" }
 dioxus-router = { path = "packages/router", version = "0.5.0" }
 dioxus-router-macro = { path = "packages/router-macro", version = "0.5.0" }
-dioxus-html = { path = "packages/html", version = "0.5.0" }
+dioxus-html = { path = "packages/html", default-features = false, version = "0.5.0" }
 dioxus-html-internal-macro = { path = "packages/html-internal-macro", version = "0.5.0" }
 dioxus-hooks = { path = "packages/hooks", version = "0.5.0" }
-dioxus-web = { path = "packages/web", version = "0.5.0" }
+dioxus-web = { path = "packages/web", default-features = false, version = "0.5.0" }
 dioxus-ssr = { path = "packages/ssr", version = "0.5.0", default-features = false }
 dioxus-desktop = { path = "packages/desktop", version = "0.5.0", default-features = false }
 dioxus-mobile = { path = "packages/mobile", version = "0.5.0" }
@@ -118,6 +121,9 @@ axum_session_auth = "0.12.1"
 axum-extra = "0.9.2"
 reqwest = "0.11.24"
 owo-colors = "4.0.0"
+ciborium = "0.2.1"
+base64 = "0.21.0"
+once_cell = "1.17.1"
 
 # speed up some macros by optimizing them
 [profile.dev.package.insta]
@@ -275,7 +281,7 @@ required-features = ["desktop"]
 doc-scrape-examples = true
 
 [[example]]
-name = "error_handle"
+name = "errors"
 required-features = ["desktop"]
 doc-scrape-examples = true
 
 
@@ -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
 
 
@@ -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"
+            }
+        },
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -170,13 +170,13 @@ fn app() -> Element {`
`170`	`170`
`171`	`171`	`// Can pass in props directly as an expression`
`172`	`172`	`{`
`173`		`- let props = TallerProps {a: "hello", children: None };`
	`173`	`+ let props = TallerProps {a: "hello", children: VNode::empty() };`
`174`	`174`	`rsx!(Taller { ..props })`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`// Spreading can also be overridden manually`
`178`	`178`	`Taller {`
`179`		`- ..TallerProps { a: "ballin!", children: None },`
	`179`	`+ ..TallerProps { a: "ballin!", children: VNode::empty() },`
`180`	`180`	`a: "not ballin!"`
`181`	`181`	`}`
`182`	`182`
`@@ -193,8 +193,8 @@ fn app() -> Element {`
`193`	`193`	`// Type inference can be used too`
`194`	`194`	`TypedInput { initial: 10.0 }`
`195`	`195`
`196`		- // geneircs with the `inline_props` macro
`197`		`- Label { text: "hello geneirc world!" }`
	`196`	+ // generic with the `inline_props` macro
	`197`	`+ Label { text: "hello generic world!" }`
`198`	`198`	`Label { text: 99.9 }`
`199`	`199`
`200`	`200`	`// Lowercase components work too, as long as they are access using a path`
`@@ -283,7 +283,7 @@ where`
`283`	`283`	`return rsx! { "{props}" };`
`284`	`284`	`}`
`285`	`285`
`286`		`- None`
	`286`	`+ VNode::empty()`
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`#[component]`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ fn app() -> Element {`
`22`	`22`	`rsx! {`
`23`	`23`	`div { class, id, {&children} }`
`24`	`24`	`Component { a, b, c, children, onclick }`
`25`		`- Component { a, ..ComponentProps { a: 1, b: 2, c: 3, children: None, onclick: Default::default() } }`
	`25`	`+ Component { a, ..ComponentProps { a: 1, b: 2, c: 3, children: VNode::empty(), onclick: Default::default() } }`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`