From 4b087316881585847bf18e322d525eff34de8488 Mon Sep 17 00:00:00 2001
From: Alexander Baranov <baranovas@vtb.ru>
Date: Sun, 24 May 2026 11:04:45 +0300
Subject: [PATCH] =?UTF-8?q?smart-house-web:=20leptos=20=D1=8D=D1=81=D0=BF?=
 =?UTF-8?q?=D0=B5=D1=80=D0=B8=D0=BC=D0=B5=D0=BD=D1=82=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 smart-house-web/frontend/src/main.rs | 114 +++++++++------------------
 1 file changed, 39 insertions(+), 75 deletions(-)

diff --git a/smart-house-web/frontend/src/main.rs b/smart-house-web/frontend/src/main.rs
index da7fc9a..d7c5702 100644
--- a/smart-house-web/frontend/src/main.rs
+++ b/smart-house-web/frontend/src/main.rs
@@ -3,83 +3,47 @@ use leptos::prelude::*;
 
 #[component]
 fn App() -> impl IntoView {
-    let (value, set_value) = signal(0);
-    let is_odd = move || value.get() & 1 == 1;
-    let odd_text = move || if is_odd() { Some("How odd!") } else { None };
+    let (value, set_value) = signal(Ok(0));
 
     view! {
-        <h1>"Control Flow"</h1>
-
-        // Simple UI to update and show a value
-        <button on:click=move |_| *set_value.write() += 1>
-            "+1"
-        </button>
-        <p>"Value is: " {value}</p>
-
-        <hr/>
-
-        <h2><code>"Option<T>"</code></h2>
-        // For any `T` that implements `IntoView`,
-        // so does `Option<T>`
-
-        <p>{odd_text}</p>
-        // This means you can use `Option` methods on it
-        <p>{move || odd_text().map(|text| text.len())}</p>
-
-        <h2>"Conditional Logic"</h2>
-        // You can do dynamic conditional if-then-else
-        // logic in several ways
-        //
-        // a. An "if" expression in a function
-        //    This will simply re-render every time the value
-        //    changes, which makes it good for lightweight UI
-        <p>
-            {move || if is_odd() {
-                "Odd"
-            } else {
-                "Even"
-            }}
-        </p>
-
-        // b. Toggling some kind of class
-        //    This is smart for an element that's going to
-        //    toggled often, because it doesn't destroy
-        //    it in between states
-        //    (you can find the `hidden` class in `index.html`)
-        <p class:hidden=is_odd>"Appears if even."</p>
-
-        // c. The <Show/> component
-        //    This only renders the fallback and the child
-        //    once, lazily, and toggles between them when
-        //    needed. This makes it more efficient in many cases
-        //    than a {move || if ...} block
-        <Show when=is_odd
-            fallback=|| view! { <p>"Even steven"</p> }
-        >
-            <p>"Oddment"</p>
-        </Show>
-
-        // d. Because `bool::then()` converts a `bool` to
-        //    `Option`, you can use it to create a show/hide toggled
-        {move || is_odd().then(|| view! { <p>"Oddity!"</p> })}
-
-        <h2>"Converting between Types"</h2>
-        // e. Note: if branches return different types,
-        //    you can convert between them with
-        //    `.into_any()` or using the `Either` enums
-        //    (`Either`, `EitherOf3`, `EitherOf4`, etc.)
-        {move || match is_odd() {
-            true if value.get() == 1 => {
-                // <pre> returns HtmlElement<Pre>
-                view! { <pre>"One"</pre> }.into_any()
-            },
-            false if value.get() == 2 => {
-                // <p> returns HtmlElement<P>
-                // so we convert into a more generic type
-                view! { <p>"Two"</p> }.into_any()
-            }
-            _ => view! { <textarea>{value.get()}</textarea> }.into_any()
-        }}
+        <h1>"Error Handling"</h1>
+        <label>
+            "Type a number (or something that's not a number!)"
+            <input type="number" on:input:target=move |ev| {
+                // when input changes, try to parse a number from the input
+                set_value.set(ev.target().value().parse::<i32>())
+            }/>
+            // If an `Err(_) had been rendered inside the <ErrorBoundary/>,
+            // the fallback will be displayed. Otherwise, the children of the
+            // <ErrorBoundary/> will be displayed.
+            <ErrorBoundary
+                // the fallback receives a signal containing current errors
+                fallback=|errors| view! {
+                    <div class="error">
+                        <p>"Not a number! Errors: "</p>
+                        // we can render a list of errors
+                        // as strings, if we'd like
+                        <ul>
+                            {move || errors.get()
+                                .into_iter()
+                                .map(|(_, e)| view! { <li>{e.to_string()}</li>})
+                                .collect::<Vec<_>>()
+                            }
+                        </ul>
+                    </div>
+                }
+            >
+                <p>
+                    "You entered "
+                    // because `value` is `Result<i32, _>`,
+                    // it will render the `i32` if it is `Ok`,
+                    // and render nothing and trigger the error boundary
+                    // if it is `Err`. It's a signal, so this will dynamically
+                    // update when `value` changes
+                    <strong>{value}</strong>
+                </p>
+            </ErrorBoundary>
+        </label>
     }
 }