fix: top-level SVG in view macro with new exports

* leptos_dom erros.rs remove<E>() does not need to be generic.

* fixed up errors.remove().

.github/workflows/test.yml

@@ -30,6 +30,9 @@ jobs:
           override: true
           components: rustfmt
 
+      - name: Add wasm32-unknown-unknown
+        run: rustup target add wasm32-unknown-unknown
+
       - name: Setup cargo-make
         uses: davidB/rust-cargo-make@v1
 
@@ -43,4 +46,3 @@ jobs:
 
       - name: Run tests with all features
         run: cargo make ci
-

Cargo.toml

@@ -15,26 +15,21 @@ members = [
   # libraries
   "meta",
   "router",
-
-  # book
-  "docs/book/project/ch02_getting_started",
-  "docs/book/project/ch03_building_ui",
-  "docs/book/project/ch04_reactivity",
 ]
 exclude = ["benchmarks", "examples"]
 
 [workspace.package]
-version = "0.1.3"
+version = "0.2.0-alpha"
 
 [workspace.dependencies]
-leptos = { path = "./leptos", default-features = false, version = "0.1.3" }
-leptos_dom = { path = "./leptos_dom", default-features = false, version = "0.1.3" }
-leptos_macro = { path = "./leptos_macro", default-features = false, version = "0.1.3" }
-leptos_reactive = { path = "./leptos_reactive", default-features = false, version = "0.1.3" }
-leptos_server = { path = "./leptos_server", default-features = false, version = "0.1.3" }
-leptos_config = { path = "./leptos_config", default-features = false, version = "0.1.3" }
-leptos_router = { path = "./router", version = "0.1.3" }
-leptos_meta = { path = "./meta", default-feature = false, version = "0.1.3" }
+leptos = { path = "./leptos", default-features = false, version = "0.2.0-alpha" }
+leptos_dom = { path = "./leptos_dom", default-features = false, version = "0.2.0-alpha" }
+leptos_macro = { path = "./leptos_macro", default-features = false, version = "0.2.0-alpha" }
+leptos_reactive = { path = "./leptos_reactive", default-features = false, version = "0.2.0-alpha" }
+leptos_server = { path = "./leptos_server", default-features = false, version = "0.2.0-alpha" }
+leptos_config = { path = "./leptos_config", default-features = false, version = "0.2.0-alpha" }
+leptos_router = { path = "./router", version = "0.2.0-alpha" }
+leptos_meta = { path = "./meta", default-feature = false, version = "0.2.0-alpha" }
 
 [profile.release]
 codegen-units = 1

Makefile.toml

@@ -12,13 +12,17 @@ dependencies = ["build", "check-examples", "test"]
 
 [tasks.build]
 clear = true
-dependencies = ["build-all"]
+dependencies = ["build-all", "build-wasm"]
 
 [tasks.build-all]
 command = "cargo"
 args = ["+nightly", "build-all-features"]
 install_crate = "cargo-all-features"
 
+[tasks.build-wasm]
+clear = true
+dependencies = [{ name = "build-wasm", path = "leptos" }]
+
 [tasks.check-examples]
 clear = true
 dependencies = [

README.md

@@ -78,7 +78,7 @@ rustup target add wasm32-unknown-unknown
 
 If you’re on `stable`, note the following:
 
-1. You need to enable the `"stable"` flag in `Cargo.toml`: `leptos = { version = "0.1.0-alpha", features = ["stable"] }`
+1. You need to enable the `"stable"` flag in `Cargo.toml`: `leptos = { version = "0.1.0", features = ["stable"] }`
 2. `nightly` enables the function call syntax for accessing and setting signals. If you’re using `stable`,
    you’ll just call `.get()`, `.set()`, or `.update()` manually. Check out the
    [`counters_stable` example](https://github.com/leptos-rs/leptos/blob/main/examples/counters_stable/src/main.rs)

docs/book/.gitignore

@@ -1 +1 @@
-book
+book

docs/book/README.md

@@ -0,0 +1,14 @@
+This project contains the core of a new introductory guide to Leptos.
+
+It is built using `mdbook`. You can view a local copy by installing `mdbook`
+
+```bash
+cargo install mdbook
+```
+
+and run the book with
+```
+mdbook serve
+```
+
+It should be available at `http://localhost:3000`.

docs/book/book.toml

@@ -1,16 +0,0 @@
-[book]
-authors = ["Greg Johnston"]
-language = "en"
-multilingual = false
-src = "src"
-title = "The Leptos Guide"
-
-[preprocessor]
-
-[preprocessor.mermaid]
-command = "mdbook-mermaid"
-
-[output]
-
-[output.html]
-additional-js = ["mermaid.min.js", "mermaid-init.js"]

docs/book/mermaid-init.js

@@ -1 +0,0 @@
-mermaid.initialize({startOnLoad:true});

docs/book/project/ch02_getting_started/Cargo.toml

@@ -1,7 +0,0 @@
-[package]
-name = "ch02_getting_started"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-leptos = "0.1"

docs/book/project/ch02_getting_started/index.html

@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width, initial-scale=1" />
-		<title>Leptos • Todos</title>
-
-		<!-- This custom link tag with `data-trunk` tells Trunk to insert code here to load our Rust/Wasm code -->
-		<!-- `data-wasm-opt=z` tells the compiler to optimize for binary size in a release build -->
-		<link data-trunk rel="rust" data-wasm-opt="z" />
-
-	</head>
-	<body></body>
-</html>

docs/book/project/ch02_getting_started/src/main.rs

@@ -1,5 +0,0 @@
-use leptos::*;
-
-fn main() {
-    mount_to_body(|cx| view! { cx,  <p>"Hello, world!"</p> })
-}

docs/book/project/ch03_building_ui/Cargo.toml

@@ -1,7 +0,0 @@
-[package]
-name = "ch03_building_ui"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-leptos = "0.1"

docs/book/project/ch03_building_ui/index.html

@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width, initial-scale=1" />
-		<title>Leptos • Todos</title>
-
-		<!-- This custom link tag with `data-trunk` tells Trunk to insert code here to load our Rust/Wasm code -->
-		<!-- `data-wasm-opt=z` tells the compiler to optimize for binary size in a release build -->
-		<link data-trunk rel="rust" data-wasm-opt="z" />
-
-	</head>
-	<body></body>
-</html>

docs/book/project/ch03_building_ui/src/main.rs

@@ -1,41 +0,0 @@
-use leptos::*;
-
-fn main() {
-    mount_to_body(|cx| {
-        let name = "gbj";
-        let userid = 0;
-
-        // This will be filled by _ref=input below.
-        let input_element = NodeRef::<HtmlElement<Input>>::new(cx);
-
-        view! {
-            cx,
-            <main>
-                <h1>"My Tasks"</h1>     // text nodes are wrapped in quotation marks
-                <h2>"by " {name}</h2>
-                <input
-                    type="text"         // attributes work just like they do in HTML
-                    name="new-todo"
-                    prop:value="todo"   // `prop:` lets you set a property on a DOM node
-                    value="initial"     // side note: the DOM `value` attribute only sets *initial* value
-                                        // this is very important when working with forms!
-                    _ref=input_element // `_ref` stores tis element in a variable
-                />
-                <ul data-user=userid>   // attributes can take expressions as values
-                    <li class="todo my-todo" // here we set the `class` attribute
-                        class:completed=true // `class:` also lets you toggle individual classes
-                        on:click=|_| todo!() // `on:` adds an event listener
-                    >
-                        "Buy milk."
-                    </li>
-                    <li class="todo my-todo" class:completed=false>
-                        "???"
-                    </li>
-                    <li class="todo my-todo" class:completed=false>
-                        "Profit!!!"
-                    </li>
-                </ul>
-            </main>
-        }
-    })
-}

docs/book/project/ch04_reactivity/Cargo.toml

@@ -1,7 +0,0 @@
-[package]
-name = "ch04_reactivity"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-leptos = "0.1"

docs/book/project/ch04_reactivity/src/main.rs

@@ -1,28 +0,0 @@
-use leptos::*;
-
-fn main() {
-    run_scope(create_runtime(), |cx| {
-        // signal
-        let (count, set_count) = create_signal(cx, 1);
-
-        // derived signal
-        let double_count = move || count() * 2;
-
-        // memo
-        let memoized_square = create_memo(cx, move |_| count() * count());
-
-        // effect
-        create_effect(cx, move |_| {
-            println!(
-                "count =\t\t{} \ndouble_count = \t{}, \nsquare = \t{}",
-                count(),
-                double_count(),
-                memoized_square()
-            );
-        });
-
-        set_count(1);
-        set_count(2);
-        set_count(3);
-    });
-}

docs/book/src/01_introduction.md

@@ -1,10 +1,19 @@
 # Introduction
 
-This book is intended as an introduction to the [Leptos](https://github.com/leptos-rs/leptos) Web framework. Together, we’ll build a simple todo app—first as a client-side app, then as a full-stack app.
+This book is intended as an introduction to the [Leptos](https://github.com/leptos-rs/leptos) Web framework. 
+It will walk through the fundamental concepts you need to build applications, 
+beginning with a simple application rendered in the browser, and building toward a
+full-stack application with server-side rendering and hydration.
 
-The guide doesn’t assume you know anything about fine-grained reactivity or the details of modern Web frameworks. It does assume you are familiar with the Rust programming language, HTML, CSS, and the DOM and other Web APIs.
+The guide doesn’t assume you know anything about fine-grained reactivity or the 
+details of modern Web frameworks. It does assume you are familiar with the Rust 
+programming language, HTML, CSS, and the DOM and basic Web APIs.
 
-Leptos is most similar to frameworks like [Solid](https://www.solidjs.com) (JavaScript) and [Sycamore](https://sycamore-rs.netlify.app/) (Rust). There are some similarities to other frameworks like React (JavaScript), Yew (Rust), and Dioxus (Rust), so knowledge of one of those frameworks may also make it easier to understand Leptos.
+Leptos is most similar to frameworks like [Solid](https://www.solidjs.com) (JavaScript) 
+and [Sycamore](https://sycamore-rs.netlify.app/) (Rust). There are some similarities 
+to other frameworks like React (JavaScript), Svelte (JavaScript), Yew (Rust), and 
+Dioxus (Rust), so knowledge of one of those frameworks may also make it easier to 
+understand Leptos.
 
 You can find more detailed docs for each part of the API at [Docs.rs](https://docs.rs/leptos/latest/leptos/).
 

docs/book/src/02_getting_started.md

@@ -1,37 +1,48 @@
 # Getting Started
 
-> The code for this chapter can be found [here](https://github.com/leptos-rs/leptos/tree/main/docs/book/project/ch02_getting_started).
+There are two basic paths to getting started with Leptos:
+1. Client-side rendering with [Trunk](https://trunkrs.dev/)
+2. Full-stack rendering with [`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos)
+
+For the early examples, it will be easiest to begin with Trunk. We’ll introduce
+`cargo-leptos` a little later in this series.
 
-The easiest way to get started using Leptos is to use [Trunk](https://trunkrs.dev/), as many of our [examples](https://github.com/leptos-rs/leptos/tree/main/examples) do. (Trunk is a simple build tool that includes a dev server.)
 
 If you don’t already have it installed, you can install Trunk by running
 
 ```bash
-cargo install --lock trunk
+cargo install trunk
 ```
 
 Create a basic Rust binary project
 
 ```bash
-cargo init leptos-todo
+cargo init leptos-tutorial
 ```
 
-Add `leptos` as a dependency to your `Cargo.toml` with the `csr` featured enabled. (That stands for “client-side rendering.” We’ll talk more about Leptos’s support for server-side rendering and hydration later.)
-
-```toml
-leptos = "0.0"
+`cd` into your new `leptos-tutorial` project and add `leptos` as a dependency 
+```bash
+cargo add leptos
 ```
 
-You’ll want to set up a basic `index.html` with the following content:
-
+Create a simple `index.html` in the root of the `leptos-tutorial` directory
 ```html
-{{#include ../project/ch02_getting_started/index.html}}
+<!DOCTYPE html>
+<html>
+  <head></head>
+  <body></body>
+</html>
 ```
 
-Let’s start with a very simple `main.rs`
+And add a simple “Hello, world!” to your `main.rs`
+```rust 
+use leptos::*;
 
-```rust
-{{#include ../project/ch02_getting_started/src/main.rs}}
+fn main() {
+    mount_to_body(|_cx| view! { cx,  <p>"Hello, world!"</p> })
+}
 ```
 
-Now run `trunk serve --open`. Trunk should automatically compile your app and open it in your default browser. If you make edits to `main.rs`, Trunk will recompile your source code and live-reload the page.
+Now run `trunk serve --open`. Trunk should automatically compile your app and 
+open it in your default browser. If you make edits to `main.rs`, Trunk will 
+recompile your source code and live-reload the page.

docs/book/src/03_building_ui.md

@@ -1,49 +0,0 @@
-# Templating: Building User Interfaces
-
-> The code for this chapter can be found [here](https://github.com/leptos-rs/leptos/tree/main/docs/book/project/ch03_building_ui).
-
-## RSX and the `view!` macro
-
-Okay, that “Hello, world!” was a little boring. We’re going to be building a todo app, so let’s look at something a little more complicated.
-
-As you noticed in the first example, Leptos lets you describe your user interface with a declarative `view!` macro. It looks something like this:
-
-```
-view! {
-	cx, // this is the "reactive scope": more on that in the next chapter
-	<p>"..."</p> // this is some HTML-ish stuff
-}
-```
-
-The “HTML-ish stuff” is what we call “RSX”: XML in Rust. (You may recognize the similarity to JSX, which is the mixed JavaScript/XML syntax used by frameworks like React.)
-
-Here’s a more in-depth example:
-
-```rust
-{{#include ../project/ch03_building_ui/src/main.rs}}
-```
-
-You’ll probably notice a few things right away:
-
-1. Elements without children need to be explicit closed with a `/` (`<input/>`, not `<input>`)
-2. Text nodes are formatted as strings, i.e., wrapped in quotation marks (`"My Tasks"`)
-3. Dynamic blocks can be inserted as children of elements, if wrapped in curly braces (`<h2>"by " {name}</h2>`)
-4. Attributes can be given Rust expressions as values. This could be a string literal as in HTML (`<input type="text" .../>)` or a variable or block (`data-user=userid` or `on:click=move |_| { ... }`)
-5. Unlike in HTML, whitespace is ignored and should be manually added (it’s `<h2>"by " {name}</h2>`, not `<h2>"by" {name}</h2>`; the space between `"by"` and `{name}` is ignored.)
-6. Normal attributes work exactly like you'd think they would.
-7. There are also special, prefixed attributes.
-
-- `class:` lets you make targeted updates to a single class
-- `on:` lets you add an event listener
-- `prop:` lets you set a property on a DOM element
-- `_ref` stores the DOM element you’re creating in a variable
-
-> You can find more information in the [reference docs for the `view!` macro](https://docs.rs/leptos/0.0.15/leptos/macro.view.html).
-
-## But, wait...
-
-This example shows some parts of the Leptos templating syntax. But it’s completely static.
-
-How do you actually make the user interface interactive?
-
-In the next chapter, we’ll talk about “fine-grained reactivity,” which is the core of the Leptos framework.

docs/book/src/04_reactivity.md

@@ -1,240 +0,0 @@
-# Reactivity
-
-## What is reactivity?
-
-A few months ago, I completely baffled a friend by trying to explain what I was working on. “You have two variables, right? Call them `a` and `b`. And then you have a third variable, `c`. And when you update `a` or `b`, the value of `c` just _automatically changes_. And it changes _on the screen_! Automatically!”
-
-“Isn’t that just... how computers work?” she asked me, puzzled. If your programming experience is limited to something like spreadsheets, it’s a reasonable enough assumption. This is, after all, how math works.
-
-But you know this isn't how ordinary imperative programming works.
-
-```rust,should_panic
-let mut a = 0;
-let mut b = 0;
-let c = a + b;
-
-assert_eq!(c, 0); // sanity check
-
-a = 2;
-b = 2;
-
-// now c = 4, right?
-assert_eq!(c, 4); // nope. we all know this is wrong!
-```
-
-But that’s _exactly_ how reactive programming works.
-
-```rust
-use leptos::*;
-
-run_scope(create_runtime(), |cx| {
-    let (a, set_a) = create_signal(cx, 0);
-    let (b, set_b) = create_signal(cx, 0);
-    let c = move || a() + b();
-
-    assert_eq!(c(), 0); // yep, still true
-
-    set_a(2);
-    set_b(2);
-
-    assert_eq!(c(), 4); // ohhhhh yeah.
-});
-```
-
-Hopefully, this makes some intuitive sense. After all, `c` is a closure. Calling it again causes it to access its values a second time. This isn’t _that_ cool.
-
-```rust
-use leptos::*;
-
-run_scope(create_runtime(), |cx| {
-    let (a, set_a) = create_signal(cx, 0);
-    let (b, set_b) = create_signal(cx, 0);
-    let c = move || a() + b();
-
-    create_effect(cx, move |_| {
-        println!("c = {}", c()); // prints "c = 0"
-    });
-
-    set_a(2); // prints "c = 2"
-    set_b(2); // prints "c = 4"
-});
-```
-
-This example’s a little different. [`create_effect`](https://docs.rs/leptos/latest/leptos/fn.create_effect.html) defines a “side effect,” a bridge between the reactive system of signals and the outside world. Effects synchronize the reactive system with everything else: the console, the filesystem, an HTTP request, whatever.
-
-Because the closure `c` is called within the effect and in turns calls the signals `a` and `b`, the effect automatically subscribes to the signals `a` and `b`. This means that whenever `a` or `b` is updated, the effect will re-run, logging the value again.
-
-You can picture the reactive graph for this system like this:
-
-```mermaid
-graph TD;
-    A-->C;
-    B-->C;
-    C-->Effect;
-```
-
-This is the foundation on which _everything_ else is built.
-
-## Reactive Primitives
-
-### Overview
-
-The reactive system is built on the interaction between these two halves: **signals** and **effects**. When a signal is called inside an effect, the effect automatically subscribes to the signal. When a signal’s value is updated, it automatically notifies all its subscribers, and they re-run.
-
-The following simple example contains most of the core reactive concepts:
-
-```rust
-{{#include ../project/ch04_reactivity/src/main.rs}}
-```
-
-This creates a reactive graph like this:
-
-```mermaid
-graph TD;
-    count-->double_count;
-    count-->memoized_square;
-    count-->effect;
-    double_count-->effect;
-    memoized_square-->effect;
-```
-
-**Signals** are reactive values created using [`create_signal`](https://docs.rs/leptos/latest/leptos/fn.create_signal.html) or [`create_rw_signal`](https://docs.rs/leptos/latest/leptos/fn.create_rw_signal.html).
-
-**Derived Signals** computations in ordinary closures that rely on other signals. The computation re-runs whenever you access its value.
-
-**Memos** are computations that are memoized with [create_memo](https://docs.rs/leptos/latest/leptos/fn.create_memo.html). Memos only re-run when one of their signal dependencies has changed.
-
-And **effects** (created with [create_effect](<(https://docs.rs/leptos/latest/leptos/fn.create_effect.html)>) synchronize the reactive system with something outside it.
-
-The rest of this chapter will walk through each of these concepts in more depth.
-
-### Signals
-
-A **signal** is a piece of data that may change over time, and notifies other code when it has changed. This is the core primitive of Leptos’s reactive system.
-
-Creating a signal is very simple. You call `create_signal`, passing in the reactive scope and the default value, and receive a tuple containing a `ReadSignal` and a `WriteSignal`.
-
-```rust
-let (value, set_value) = create_signal(cx, 0);
-```
-
-> If you’ve used signals in Sycamore or Solid, observables in MobX or Knockout, or a similar primitive in reactive library, you probably have a pretty good idea of how signals work in Leptos. If you’re familiar with React, Yew, or Dioxus, you may recognize a similar pattern to their `use_state` hooks.
-
-#### `ReadSignal<T>`
-
-The [`ReadSignal`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html) half of this tuple allows you to get the current value of the signal. Reading that value in a reactive context automatically subscribes to any further changes. You can access the value by simply calling the `ReadSignal` as a function.
-
-```rust
-let (value, set_value) = create_signal(cx, 0);
-
-// calling value() with return the current value of the signal,
-// and automatically track changes if you're in a reactive context
-assert_eq!(value(), 0);
-```
-
-> Here, a **reactive context** means anywhere within an `Effect`. Leptos’s templating system is built on top of its reactive system, so if you’re reading the signal’s value within the template, the template will automatically subscribe to the signal and update exactly the value that needs to change in the DOM.
-
-Calling a `ReadSignal` clones the value it contains. If that’s too expensive, use [`ReadSignal::with()`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html#method.with) to borrow the value and do whatever you need.
-
-```rust
-struct MySuperExpensiveStruct {
-    a: String,
-    b: StructThatsSuperExpensiveToClone
-}
-let (value, set_value) = create_signal(cx, MySuperExpensiveStruct::default());
-
-// ❌ this is going to clone the `StructThatsSuperExpensiveToClone` unnecessarily!
-let lowercased = move || value().a.to_lowercase();
-// ✅ only use what we need
-let lowercased = move || value.with(|value: &MySuperExpensiveStruct| value.a.to_lowercase());
-```
-
-#### `WriteSignal<T>`
-
-The [`WriteSignal`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html) half of this tuple allows you to update the value of the signal, which will automatically notify anything that’s listening to the value that something has changed. If you simply call the `WriteSignal` as a function, its value will be set to the argument you pass. If you want to mutate the value in place instead of replacing it, you can call [`WriteSignal::update`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html#method.update) instead.
-
-```rust
-// often you just want to replace the value
-let (value, set_value) = create_signal(cx, 0);
-set_value(1);
-assert_eq!(value(), 1);
-
-// sometimes you want to mutate something in place, like a Vec. Just call update()
-let (items, set_items) = create_signal(cx, vec![0]);
-set_items.update(|items: &mut Vec<i32>| items.push(1));
-assert_eq!(items(), vec![1]);
-```
-
-> Under the hood, `set_value(1)` is just syntactic sugar for `set_value.update(|n| *n = 1)`.
-
-#### `RwSignal<T>`
-
-This kind of “read-write segregation,” in which the getter and the setter are stored in separate variables, may be familiar from the tuple-based ”hooks” pattern in libraries like React, Solid, Yew, or Dioxus. It encourages clear contracts between components. For example, if a child component only needs to be able to read a signal, but shouldn’t be able to update it (and therefore trigger changes in other parts of the application), you can pass it only the `ReadSignal`.
-
-Sometimes, however, you may prefer to keep the getter and setter combined in one variable. For example, it’s awkward and repetitive to store both halves of a signal in another data structure:
-
-```rust
-# use leptos::*;
-
-// pretty repetitive
-struct AppState {
-    count: ReadSignal<i32>,
-    set_count: WriteSignal<i32>,
-    name: ReadSignal<String>,
-    set_name: WriteSignal<String>
-}
-
-#[component]
-fn App(cx: Scope) {
-    let (count, set_count) = create_signal(cx, 0);
-    let (name, set_name) = create_signal(cx, "Alice".to_string());
-    provide_context(cx, AppState {
-        count,
-        set_count,
-        name,
-        set_name
-    })
-
-    todo!()
-}
-```
-
-Or maybe you just like to keep your getters and setters in one place.
-
-In this case, you can use [`create_rw_signal`](https://docs.rs/leptos/latest/leptos/fn.create_rw_signal.html) and the [`RwSignal`](https://docs.rs/leptos/latest/leptos/struct.RwSignal.html) type. This returns a **R**ead-**w**rite Signal, which has the same [`get`](https://docs.rs/leptos/latest/leptos/struct.RwSignal.html#method.get), [`with`](https://docs.rs/leptos/latest/leptos/struct.RwSignal.html#method.with), [`set`](https://docs.rs/leptos/latest/leptos/struct.RwSignal.html#method.set), and [`update`](https://docs.rs/leptos/latest/leptos/struct.RwSignal.html#method.update) functions as the `ReadSignal` and `WriteSignal` halves.
-
-```rust
-# use leptos::*;
-
-// better
-struct AppState {
-    count: RwSignal<i32>,
-    name: RwSignal<String>,
-}
-
-#[component]
-fn App(cx: Scope) {
-    let count = create_rw_signal(cx, 0);
-    let name = create_rw_signal(cx, "Alice".to_string());
-    provide_context(cx, AppState {
-        count,
-        name,
-    })
-
-    todo!()
-}
-```
-
-If you still want to hand off read-only access to another part of the app, you can get a `ReadSignal` with [`RwSignal::read_only()`](https://docs.rs/leptos/latest/leptos/struct.RwSignal.html#method.get).
-
-### Derived Signals
-
-(todo)
-
-### Memos
-
-(todo)
-
-### Effects
-
-(todo)

docs/book/src/SUMMARY.md

@@ -2,5 +2,40 @@
 
 - [Introduction](./01_introduction.md)
 - [Getting Started](./02_getting_started.md)
-- [Templating: Building User Interfaces](./03_building_ui.md)
-- [Reactivity: Making Things Interactive](./04_reactivity.md)
+- [Building User Interfaces](./view/README.md)
+  - [A Basic Component](./view/01_basic_component.md)
+  - [Dynamic Attributes](./view/02_dynamic_attributes.md)
+  - [Components and Props](./view/03_components.md)
+  - [Iteration](./view/04_iteration.md)
+  - [Forms and Inputs](./view/05_forms.md)
+  - [Control Flow](./view/06_control_flow.md)
+  - [Error Handling](./view/07_errors.md)
+  - [Parent-Child Communication](./view/08_parent_child.md)
+  - [Passing Children to Components](./view/09_component_children.md)
+- [Interlude: Reactivity and Functions](./interlude_functions.md)
+- [Testing](./testing.md)
+- [Interlude: Styling — CSS, Tailwind, Style.rs, and more]()
+- [Async]()
+  - [Resource]()
+  - [Suspense]()
+  - [Transition]()
+- [State Management]()
+- [Interlude: Advanced Reactivity]()
+- [Router]()
+  - [Fundamentals]()
+  - [defining `<Routes/>`]()
+  - [`<A/>`]()
+  - [`<Form/>`]()
+- [Metadata]()
+- [SSR]()
+  - [Models of SSR]()
+  - [`cargo-leptos`]()
+  - [Hydration Footguns]()
+- [Request/Response]()
+  - [Headers]()
+  - [Cookies]()
+- [Server Functions]()
+  - [Actions]()
+  - [Forms]()
+  - [`<ActionForm/>`s]()
+  - [Turning off WebAssembly]()

docs/book/src/interlude_functions.md

@@ -0,0 +1,76 @@
+# Interlude: Reactivity and Functions
+
+One of our core contributors said to me recently: “I never used closures this often
+until I started using Leptos.” And it’s true. Closures are at the heart of any Leptos
+application. It sometimes looks a little silly:
+
+```rust
+// a signal holds a value, and can be updated
+let (count, set_count) = create_signal(cx, 0);
+
+// a derived signal is a function that accesses other signals
+let double_count = move || count() * 2;
+let count_is_odd = move || count() & 1 == 1;
+let text = move || if count_is_odd() {
+	"odd"
+} else {
+	"even"
+};
+
+// an effect automatically tracks the signals it depends on
+// and re-runs when they change
+create_effect(cx, move |_| {
+	log!("text = {}", text());
+});
+
+view! { cx,
+	<p>{move || text().to_uppercase()}</p>
+}
+```
+
+Closures, closures everywhere!
+
+But why?
+
+## Functions and UI Frameworks
+
+Functions are at the heart of every UI framework. And this makes perfect sense. Creating a user interface is basically divided into two phases:
+
+1. initial rendering
+2. updates
+
+In a web framework, the framework does some kind of initial rendering. Then it hands control back over to the browser. When certain events fire (like a mouse click) or asynchronous tasks finish (like an HTTP request finishing), the browser wakes the framework back up to update something. The framework runs some kind of code to update your user interface, and goes back asleep until the browser wakes it up again.
+
+The key phrase here is “runs some kind of code.” The natural way to “run some kind of code” at an arbitrary point in time—in Rust or in any other programming language—is to call a function. And in fact every UI framework is based on rerunning some kind of function over and over:
+
+1. virtual DOM (VDOM) frameworks like React, Yew, or Dioxus rerun a component or render function over and over, to generate a virtual DOM tree that can be reconciled with the previous result to patch the DOM
+2. compiled frameworks like Angular and Svelte divide your component templates into “create” and “update” functions, rerunning the update function when they detect a change to the component’s state
+3. in fine-grained reactive frameworks like SolidJS, Sycamore, or Leptos, _you_ define the functions that re-run
+
+That’s what all our components are doing.
+
+Take our typical `<SimpleCounter/>` example in its simplest form:
+
+```rust
+#[component]
+pub fn SimpleCounter(cx: Scope) -> impl IntoView {
+    let (value, set_value) = create_signal(cx, 0);
+
+    let increment = move |_| set_value.update(|value| *value += 1);
+
+    view! { cx,
+		<button on:click=increment>
+			{value}
+		</button>
+    }
+}
+```
+
+The `SimpleCounter` function itself runs once. The `value` signal is created once. The framework hands off the `increment` function to the browser as an event listener. When you click the button, the browser calls `increment`, which updates `value` via `set_value`. And that updates the single text node represented in our view by `{value}`.
+
+Closures are key to reactivity. They provide the framework with the ability to re-run the smallest possible unit of your application in responsive to a change.
+
+So remember two things:
+
+1. Your component function is a setup function, not a render function: it only runs once.
+2. For values in your view template to be reactive, they must be functions: either signals (which implement the `Fn` traits) or closures.

docs/book/src/testing.md

@@ -0,0 +1,180 @@
+# Testing Your Components
+
+Testing user interfaces can be relatively tricky, but really important. This article
+will discuss a couple principles and approaches for testing a Leptos app.
+
+## 1. Test business logic with ordinary Rust tests
+
+In many cases, it makes sense to pull the logic out of your components and test
+it separately. For some simple components, there’s no particular logic to test, but
+for many it’s worth using a testable wrapping type and implementing the logic in
+ordinary Rust `impl` blocks.
+
+For example, instead of embedding logic in a component directly like this:
+
+```rust
+#[component]
+pub fn TodoApp(cx: Scope) -> impl IntoView {
+	let (todos, set_todos) = create_signal(cx, vec![Todo { /* ... */ }]);
+	// ⚠️ this is hard to test because it's embedded in the component
+	let maximum = move || todos.with(|todos| {
+		todos.iter().filter(|todo| todo.completed).sum()
+	});
+}
+```
+
+You could pull that logic out into a separate data structure and test it:
+
+```rust
+pub struct Todos(Vec<Todo>);
+
+impl Todos {
+	pub fn remaining(&self) -> usize {
+		todos.iter().filter(|todo| todo.completed).sum()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	#[test]
+	fn test_remaining {
+		// ...
+	}
+}
+
+#[component]
+pub fn TodoApp(cx: Scope) -> impl IntoView {
+	let (todos, set_todos) = create_signal(cx, Todos(vec![Todo { /* ... */ }]));
+	// ✅ this has a test associated with it
+	let maximum = move || todos.with(Todos::remaining);
+}
+```
+
+In general, the less of your logic is wrapped into your components themselves, the
+more idiomatic your code will feel and the easier it will be to test.
+
+## 2. Test components with `wasm-bindgen-test`
+
+[`wasm-bindgen-test`](https://crates.io/crates/wasm-bindgen-test) is a great utility
+for integrating or end-to-end testing WebAssembly apps in a headless browser.
+
+To use this testing utility, you need to add `wasm-bindgen-test` to your `Cargo.toml`:
+
+```toml
+[dev-dependencies]
+wasm-bindgen-test = "0.3.0"
+```
+
+You should create tests in a separate `tests` directory. You can then run your tests in the browser of your choice:
+
+```bash
+wasm-pack test --firefox
+```
+
+> To see the full setup, check out the tests for the [`counter`](https://github.com/leptos-rs/leptos/tree/main/examples/counter) example.
+
+### Writing Your Tests
+
+Most tests will involve some combination of vanilla DOM manipulation and comparison to a `view`. For example, here’s a test [for the
+`counter` example](https://github.com/leptos-rs/leptos/blob/main/examples/counter/tests/mod.rs).
+
+First, we set up the testing environment.
+
+```rust
+use wasm_bindgen_test::*;
+use counter::*;
+use leptos::*;
+use web_sys::HtmlElement;
+
+// tell the test runner to run tests in the browser
+wasm_bindgen_test_configure!(run_in_browser);
+```
+
+I’m going to create a simpler wrapper for each test case, and mount it there.
+This makes it easy to encapsulate the test results.
+
+```rust
+// like marking a regular test with #[test]
+#[wasm_bindgen_test]
+fn clear() {
+    let document = leptos::document();
+    let test_wrapper = document.create_element("section").unwrap();
+    document.body().unwrap().append_child(&test_wrapper);
+
+    // start by rendering our counter and mounting it to the DOM
+    // note that we start at the initial value of 10
+    mount_to(
+        test_wrapper.clone().unchecked_into(),
+        |cx| view! { cx, <SimpleCounter initial_value=10 step=1/> },
+    );
+```
+
+We’ll use some manual DOM operations to grab the `<div>` that wraps
+the whole component, as well as the `clear` button.
+
+```rust
+    // now we extract the buttons by iterating over the DOM
+    // this would be easier if they had IDs
+    let div = test_wrapper.query_selector("div").unwrap().unwrap();
+    let clear = test_wrapper
+        .query_selector("button")
+        .unwrap()
+        .unwrap()
+        .unchecked_into::<web_sys::HtmlElement>();
+```
+
+Now we can use ordinary DOM APIs to simulate user interaction.
+
+```rust
+    // now let's click the `clear` button
+    clear.click();
+```
+
+You can test individual DOM element attributes or text node values. Sometimes
+I like to test the whole view at once. We can do this by testing the element’s
+`outerHTML` against our expectations.
+
+```rust
+    assert_eq!(
+        div.outer_html(),
+        // here we spawn a mini reactive system to render the test case
+        run_scope(create_runtime(), |cx| {
+            // it's as if we're creating it with a value of 0, right?
+            let (value, set_value) = create_signal(cx, 0);
+
+            // we can remove the event listeners because they're not rendered to HTML
+            view! { cx,
+                <div>
+                    <button>"Clear"</button>
+                    <button>"-1"</button>
+                    <span>"Value: " {value} "!"</span>
+                    <button>"+1"</button>
+                </div>
+            }
+            // the view returned an HtmlElement<Div>, which is a smart pointer for
+            // a DOM element. So we can still just call .outer_html()
+            .outer_html()
+        })
+    );
+```
+
+That test involved us manually replicating the `view` that’s inside the component.
+There's actually an easier way to do this... We can just test against a `<SimpleCounter/>`
+with the initial value `0`. This is where our wrapping element comes in: I’ll just test
+the wrapper’s `innerHTML` against another comparison case.
+
+```rust
+    assert_eq!(test_wrapper.inner_html(), {
+        let comparison_wrapper = document.create_element("section").unwrap();
+        leptos::mount_to(
+            comparison_wrapper.clone().unchecked_into(),
+            |cx| view! { cx, <SimpleCounter initial_value=0 step=1/>},
+        );
+        comparison_wrapper.inner_html()
+    });
+}
+```
+
+This is only a very limited introduction to testing. But I hope it’s useful as you begin to build applications.
+
+> For more, see [the testing section of the `wasm-bindgen` guide](https://rustwasm.github.io/wasm-bindgen/wasm-bindgen-test/index.html#testing-on-wasm32-unknown-unknown-with-wasm-bindgen-test).

docs/book/src/view/01_basic_component.md

@@ -0,0 +1,143 @@
+# A Basic Component
+
+That “Hello, world!” was a *very* simple example. Let’s move on to something a
+little more like an ordinary app.
+
+First, let’s edit the `main` function so that, instead of rendering the whole
+app, it just renders an `<App/>` component. Components are the basic unit of
+composition and design in most web frameworks, and Leptos is no exception. 
+Conceptually, they are similar to HTML elements: they represent a section of the 
+DOM, with self-contained, defined behavior. Unlike HTML elements, they are in 
+`PascalCase`, so most Leptos applications will start with something like an 
+`<App/>` component.
+
+```rust
+fn main() {
+    leptos::mount_to_body(|cx| view! { cx, <App/> })
+}
+```
+
+Now let’s define our `<App/>` component itself. Because it’s relatively simple,
+I’ll give you the whole thing up front, then walk through it line by line.
+
+```rust
+#[component]
+fn App(cx: Scope) -> impl IntoView {
+    let (count, set_count) = create_signal(cx, 0);
+
+    view! { cx,
+        <button
+            on:click=move |_| {
+                set_count.update(|n| *n += 1);
+            }
+        >
+            "Click me"
+            {move || count.get()}
+        </button>
+    }
+}
+```
+
+## The Component Signature
+```rust
+#[component]
+```
+
+Like all component definitions, this begins with the [`#[component]`](https://docs.rs/leptos/latest/leptos/attr.component.html) macro. `#[component]` annotates a function so it can be 
+used as a component in your Leptos application. We’ll see some of the other features of
+this macro in a couple chapters.
+
+```rust
+fn App(cx: Scope) -> impl IntoView
+```
+
+Every component is a function with the following characteristics
+1. It takes a reactive [`Scope`](https://docs.rs/leptos/latest/leptos/struct.Scope.html)
+   as its first argument. This `Scope` is our entrypoint into the reactive system.
+   By convention, it’s usually named `cx`.
+2. You can include other arguments, which will be available as component “props.”
+3. Component functions return `impl IntoView`, which is an opaque type that includes
+   anything you could return from a Leptos `view`.
+
+## The Component Body
+The body of the component function is a set-up function that runs once, not a 
+render function that re-runs multiple times. You’ll typically use it to create a
+few reactive variables, define any side effects that run in response to those values
+changing, and describe the user interface.
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+```
+[`create_signal`](https://docs.rs/leptos/latest/leptos/fn.create_signal.html)
+creates a signal, the basic unit of reactive change and state management in Leptos.
+This returns a `(getter, setter)` tuple. To access the current value, you’ll 
+use `count.get()` (or, on `nightly` Rust, the shorthand `count()`). To set the 
+current value, you’ll call `set_count.set(...)` (or `set_count(...)`).
+
+> `.get()` clones the value and `.set()` overwrites it. In many cases, it’s more 
+efficient to use `.with()` or `.update()`; check out the docs for [`ReadSignal`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html) and [`WriteSignal`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html) if you’d like to learn more about those trade-offs at this point.
+
+## The View 
+
+Leptos defines user interfaces using a JSX-like format via the [`view`](https://docs.rs/leptos/latest/leptos/macro.view.html) macro.
+
+```rust
+view! { cx,
+    <button
+        // define an event listener with on:
+        on:click=move |_| {
+            set_count.update(|n| *n += 1);
+        }
+    >
+        // text nodes are wrapped in quotation marks
+        "Click me: "
+        // blocks can include Rust code
+        {move || count.get()}
+    </button>
+}
+```
+
+This should mostly be easy to understand: it looks like HTML, with a special
+`on:click` to define a `click` event listener, a text node that’s formatted like
+a Rust string, and then...
+```rust
+{move || count.get()}
+```
+whatever that is.
+
+People sometimes joke that they use more closures in their first Leptos application 
+than they’ve ever used in their lives. And fair enough. Basically, passing a function 
+into the view tells the framework: “Hey, this is something that might change.”
+
+When we click the button and call `set_count`, the `count` signal is updated. This 
+`move || count.get()` closure, whose value depends on the value of `count`, re-runs, 
+and the framework makes a targeted update to that one specific text node, touching 
+nothing else in your application. This is what allows for extremely efficient updates
+to the DOM.
+
+Now, if you have Clippy on—or if you have a particularly sharp eye—you might notice
+that this closure is redundant, at least if you’re in `nightly` Rust. If you’re using 
+Leptos with `nightly` Rust, signals are already functions, so the closure is unnecessary.
+As a result, you can write a simpler view: 
+```rust
+view! { cx,
+    <button /* ... */>
+        "Click me: "
+        // identical to {move || count.get()}
+        {count}
+    </button>
+}
+```
+
+Remember—and this is *very important*—only functions are reactive. This means that 
+`{count}` and `{count()}` do very different things in your view. `{count}` passes 
+in a function, telling the framework to update the view every time `count` changes.
+`{count()}` access the value of `count` once, and passes an `i32` into the view, 
+rendering it once, unreactively. You can see the difference in the CodeSandbox below!
+
+> Throughout this tutorial, we’ll use CodeSandbox to show interactive examples. To 
+show the browser in the sandbox, you may need to click `Add DevTools >
+Other Previews > 8080.` Hover over any of the variables to show Rust-Analyzer details 
+and docs for what’s going on. Feel free to fork the examples to play with them yourself!
+
+<iframe src="https://codesandbox.io/p/sandbox/1-basic-component-3d74p3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A31%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A31%2C%22startLineNumber%22%3A19%7D%5D" width="100%" height="1000px"></iframe>

docs/book/src/view/02_dynamic_attributes.md

@@ -0,0 +1,104 @@
+# `view`: Dynamic Attributes and Classes
+
+So far we’ve seen how to use the `view` macro to create event listeners and to 
+create dynamic text by passing a function (such as a signal) into the view.
+
+But of course there are other things you might want to update in your user interface.
+In this section, we’ll look at how to update attributes and classes dynamically, 
+and we’ll introduce the concept of a **derived signal**.
+
+Let’s start with a simple component that should be familiar: click a button to 
+increment a counter.
+
+```rust
+#[component]
+fn App(cx: Scope) -> impl IntoView {
+    let (count, set_count) = create_signal(cx, 0);
+
+    view! { cx,
+        <button
+            on:click=move |_| {
+                set_count.update(|n| *n += 1);
+            }
+```
+
+So far, this is just the example from the last chapter.
+
+## Dynamic Classes
+
+Now let’s say I’d like to update the list of CSS classes on this element dynamically.
+For example, let’s say I want to add the class `red` when the count is odd. I can
+do this using the `class:` syntax. 
+```rust
+class:red=move || count() & 1 == 1
+```
+`class:` attributes take
+1. the class name, following the colon (`red`)
+2. a value, which can be a `bool` or a function that returns a `bool`
+
+When the value is `true`, the class is added. When the value is `false`, the class
+is removed. And if the value is a function that accesses a signal, the class will 
+reactively update when the signal changes.
+
+Now every time I click the button, the text should toggle between red and black as 
+the number switches between even and odd.
+
+## Dynamic Attributes
+
+The same applies to plain attributes. Passing a plain string or primitive value to
+an attribute gives it a static value. Passing a function (including a signal) to
+an attribute causes it to update its value reactively. Let’s add another element 
+to our view:
+```rust
+<progress
+    max="50"
+    // signals are functions, so this <=> `move || count.get()`
+    value=count
+/>
+```
+
+Now every time we set the count, not only will the `class` of the `<button>` be 
+toggled, but the `value` of the `<progress>` bar will increase, which means that 
+our progress bar will move forward.
+
+## Derived Signals 
+
+Let’s go one layer deeper, just for fun.
+
+You already know that we create reactive interfaces just by passing functions into 
+the `view`. This means that we can easily change our progress bar. For example,
+suppose we want it to move twice as fast:
+```rust
+<progress
+    max="50"
+    value=move || count() * 2
+/>
+```
+
+But imagine we want to reuse that calculation in more than one place. You can do this
+using a **derived signal**: a closure that accesses a signal.
+```rust
+let double_count = move || count() * 2;
+
+/* insert the rest of the view */ 
+<progress
+    max="50"
+    // we use it once here
+    value=double_count
+/>
+<p>
+    "Double Count: " 
+    // and again here
+    {double_count}
+</p>
+```
+
+Derived signals let you create reactive computed values that can be used in multiple 
+places in your application with minimal overhead.
+
+> Note: Using a derived signal like this means that the calculation runs once per 
+signal change per place we access `double_count`; in other words, twice. This is a
+very cheap calculation, so that’s fine. We’ll look at memos in a later chapter, which 
+are designed to solve this problem for expensive calculations.
+
+<iframe src="https://codesandbox.io/p/sandbox/2-dynamic-attribute-pqyvzl?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px"></iframe>

docs/book/src/view/03_components.md

@@ -0,0 +1,317 @@
+# Components and Props
+
+So far, we’ve been building our whole application in a single component. This 
+is fine for really tiny examples, but in any real application you’ll need to 
+break the user interface out into multiple components, so you can break your 
+interface down into smaller, reusable, composable chunks.
+
+Let’s take our progress bar example. Imagine that you want two progress bars 
+instead of one: one that advances one tick per click, one that advances two ticks
+per click.
+
+You _could_ do this by just creating two `<progress>` elements:
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+let double_count = move || count() * 2;
+
+view! { 
+    <progress
+        max="50"
+        value=progress
+    />
+    <progress
+        max="50"
+        value=double_count
+    />
+```
+
+But of course, this doesn’t scale very well. If you want to add a third progress
+bar, you need to add this code another time. And if you want to edit anything 
+about it, you need to edit it in triplicate.
+
+Instead, let’s create a `<ProgressBar/>` component.
+
+```rust
+#[component]
+fn ProgressBar(
+    cx: Scope
+) -> impl IntoView {
+    view! { cx,
+        <progress
+            max="50"
+            // hmm... where will we get this from?
+            value=progress
+        />
+    }
+}
+```
+
+There’s just one problem: `progress` is not defined. Where should it come from? 
+When we were defining everything manually, we just used the local variable names. 
+Now we need some way to pass an argument into the component.
+
+## Component Props 
+
+We do this using component properties, or “props.” If you’ve used another frontend
+framework, this is probably a familiar idea. Basically, properties are to components 
+as attributes are to HTML elements: they let you pass additional information into 
+the component.
+
+In Leptos, you define props by giving additional arguments to the component function.
+
+```rust
+#[component]
+fn ProgressBar(
+    cx: Scope,
+    progress: ReadSignal<i32>
+) -> impl IntoView {
+    view! { cx,
+        <progress
+            max="50"
+            // now this works 
+            value=progress
+        />
+    }
+}
+```
+
+Now we can use our component in the main `<App/>` component’s view.
+
+```rust
+#[component]
+fn App(cx: Scope) -> impl IntoView {
+    let (count, set_count) = create_signal(cx, 0);
+    view! { cx,
+        <button on:click=move |_| { set_count.update(|n| *n += 1); }>
+            "Click me"
+        </button>
+        // now we use our component!
+        <ProgressBar progress=count/>
+    }
+}
+```
+
+Using a component in the view looks a lot like using an HTML element. You’ll 
+notice that you can easily tell the difference between an element and a component 
+because components always have `PascalCase` names. You pass the `progress` prop 
+in as if it were an HTML element attribute. Simple.
+
+> ### Important Note 
+> For every `Component`, Leptos generates a corresponding `ComponentProps` type. This 
+is what allows us to have named props, when Rust does not have named function parameters.
+If you’re defining a component in one module and importing it into another, make 
+sure you include this `ComponentProps` type:
+>
+> `use progress_bar::{ProgressBar, ProgressBarProps};`
+
+### Reactive and Static Props
+
+You’ll notice that throughout this example, `progress` takes a reactive 
+`ReadSignal<i32>`, and not a plain `i32`. This is **very important**.
+
+Component props have no special meaning attached to them. A component is simply 
+a function that runs once to set up the user interface. The only way to tell the 
+interface to respond to changing is to pass it a signal type. So if you have a 
+component property that will change over time, like our `progress`, it should 
+be a signal.
+
+### `optional` Props 
+
+Right now the `max` setting is hard-coded. Let’s take that as a prop too. But 
+let’s add a catch: let’s make this prop optional by annotating the particular 
+argument to the component function with `#[prop(optional)]`.
+
+```rust
+#[component]
+fn ProgressBar(
+    cx: Scope,
+    // mark this prop optional 
+    // you can specify it or not when you use <ProgressBar/>
+    #[prop(optional)]
+    max: u16,
+    progress: ReadSignal<i32>
+) -> impl IntoView {
+    view! { cx,
+        <progress
+            max=max
+            value=progress
+        />
+    }
+}
+```
+
+Now, we can use `<ProgressBar max=50 value=count/>`, or we can omit `max`
+to use the default value (i.e., `<ProgressBar value=count/>`). The default value 
+on an `optional` is its `Default::default()` value, which for a `u16` is going to
+be `0`. In the case of a progress bar, a max value of `0` is not very useful.
+
+So let’s give it a particular default value instead.
+
+### `default` props
+
+You can specify a default value other than `Default::default()` pretty simply
+with `#[prop(default = ...)`.
+
+```rust
+#[component]
+fn ProgressBar(
+    cx: Scope,
+    #[prop(default = 100)]
+    max: u16,
+    progress: ReadSignal<i32>
+) -> impl IntoView {
+    view! { cx,
+        <progress
+            max=max
+            value=progress
+        />
+    }
+}
+```
+
+### Generic Props
+
+This is great. But we began with two counters, one driven by `count`, and one by
+the derived signal `double_count`. Let’s recreate that by using `double_count`
+as the `progress` prop on another `<ProgressBar/>`.
+
+```rust
+#[component]
+fn App(cx: Scope) -> impl IntoView {
+    let (count, set_count) = create_signal(cx, 0);
+    let double_count = move || count() * 2;
+
+    view! { cx,
+        <button on:click=move |_| { set_count.update(|n| *n += 1); }>
+            "Click me"
+        </button>
+        <ProgressBar progress=count/>
+        // add a second progress bar 
+        <ProgressBar progress=double_count/>
+    }
+}
+```
+
+Hm... this won’t compile. It should be pretty easy to understand why: we’ve declared
+that the `progress` prop takes `ReadSignal<i32>`, and `double_count` is not 
+`ReadSignal<i32>`. As rust-analyzer will tell you, its type is `|| -> i32`, i.e., 
+it’s a closure that returns an `i32`.
+
+There are a couple ways to handle this. One would be to say: “Well, I know that 
+a `ReadSignal` is a function, and I know that a closure is a function; maybe I 
+could just take any function?” If you’re savvy, you may know that both these 
+implement the trait `Fn() -> i32`. So you could use a generic component:
+
+```rust
+#[component]
+fn ProgressBar<F>(
+    cx: Scope,
+    #[prop(default = 100)]
+    max: u16,
+    progress: F
+) -> impl IntoView 
+where 
+    F: Fn() -> i32
+{
+    view! { cx,
+        <progress
+            max=max
+            value=progress
+        />
+    }
+}
+```
+
+This is a perfectly reasonable way to write this component: `progress` now takes 
+any value that implements this `Fn()` trait.
+
+> Note that generic component props _cannot_ be specified inline (as `<F: Fn() -> i32>`)
+or as `progress: impl Fn() -> i32`, in part because they’re actually used to generate 
+a `struct ProgressBarProps`, and struct fields cannot be `impl` types.
+
+### `into` Props 
+
+There’s one more way we could implement this, and it would be to use `#[prop(into)]`. 
+This attribute automatically calls `.into()` on the values you pass as proprs,
+which allows you to pass props of different values easily.
+
+In this case, it’s helpful to know about the 
+[`Signal`](https://docs.rs/leptos/latest/leptos/struct.Signal.html) type. `Signal`
+is a enumerated type that represents any kind of readable reactive signal. It can 
+be useful when defining APIs for components you’ll want to reuse while passing 
+different sorts of signals. The [`MaybeSignal`](https://docs.rs/leptos/latest/leptos/enum.MaybeSignal.html) type is useful when you want to be able to take either a static or 
+reactive value.
+
+
+```rust
+#[component]
+fn ProgressBar(
+    cx: Scope,
+    #[prop(default = 100)]
+    max: u16,
+    #[prop(into)]
+    progress: Signal<i32>
+) -> impl IntoView 
+{
+    view! { cx,
+        <progress
+            max=max
+            value=progress
+        />
+    }
+}
+
+#[component]
+fn App(cx: Scope) -> impl IntoView {
+    let (count, set_count) = create_signal(cx, 0);
+    let double_count = move || count() * 2;
+
+    view! { cx,
+        <button on:click=move |_| { set_count.update(|n| *n += 1); }>
+            "Click me"
+        </button>
+        // .into() converts `ReadSignal` to `Signal`
+        <ProgressBar progress=count/>
+        // use `Signal::derive()` to wrap a derived signal
+        <ProgressBar progress=Signal::derive(cx, double_count)/>
+    }
+}
+```
+
+## Documenting Components
+
+This is one of the least essential but most important sections of this book. 
+It’s not strictly necessary to document your components and their props. It may 
+be very important, depending on the size of your team and your app. But it’s very 
+easy, and bears immediate fruit.
+
+To document a component and its props, you can simply add doc comments on the 
+component function, and each one of the props:
+
+```rust
+/// Shows progress toward a goal.
+#[component]
+fn ProgressBar(
+    cx: Scope,
+    /// The maximum value of the progress bar.
+    #[prop(default = 100)]
+    max: u16,
+    /// How much progress should be displayed.
+    #[prop(into)]
+    progress: Signal<i32>,
+) -> impl IntoView {
+    /* ... */
+}
+```
+
+That’s all you need to do. These behave like ordinary Rust doc comments, except
+that you can document individual component props, which can’t be done with Rust
+function arguments.
+
+This will automatically generate documentation for your component, its `Props` 
+type, and each of the fields used to add props. It can be a little hard to 
+understand how powerful this is until you hover over the component name or props 
+and see the power of the `#[component]` macro combined with rust-analyzer here.
+
+<iframe src="https://codesandbox.io/p/sandbox/3-components-50t2e7?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A7%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A7%7D%5D" width="100%" height="1000px"></iframe>

docs/book/src/view/04_iteration.md

@@ -0,0 +1,88 @@
+# Iteration
+
+Whether you’re listing todos, displaying a table, or showing product images, 
+iterating over a list of items is a common task in web applications. Reconciling
+the differences between changing sets of items can also be one of the trickiest
+tasks for a framework to handle well.
+
+Leptos supports to two different patterns for iterating over items:
+1. For static views: `Vec<_>`
+2. For dynamic lists: `<For/>`
+
+## Static Views with `Vec<_>`
+
+Sometimes you need to show an item repeatedly, but the list you’re drawing from 
+does not often change. In this case, it’s important to know that you can insert 
+any `Vec<IV> where IV: IntoView` into your view. In other views, if you can render
+`T`, you can render `Vec<T>`.
+
+```rust
+let values = vec![0, 1, 2];
+view! { cx,
+    // this will just render "012"
+    <p>{values.clone()}</p>
+    // or we can wrap them in <li>
+    <ul>
+        {values.into_iter()
+            .map(|n| view! { cx, <li>{n}</li>})
+            .collect::<Vec<_>>()}
+    </ul>
+}
+```
+
+The fact that the _list_ is static doesn’t mean the interface needs to be static.
+You can render dynamic items as part of a static list.
+
+```rust
+// create a list of N signals
+let counters = (1..=length).map(|idx| create_signal(cx, idx));
+
+// each item manages a reactive view
+// but the list itself will never change
+let counter_buttons = counters
+    .map(|(count, set_count)| {
+        view! { cx,
+            <li>
+                <button
+                    on:click=move |_| set_count.update(|n| *n += 1)
+                >
+                    {count}
+                </button>
+            </li>
+        }
+    })
+    .collect::<Vec<_>>();
+
+view! { cx,
+    <ul>{counter_buttons}</ul>
+}
+```
+
+You _can_ render a `Fn() -> Vec<_>` reactively as well. But note that every time 
+it changes, this will rerender every item in the list. This is quite inefficient!
+Fortunately, there’s a better way.
+
+## Dynamic Rendering with the `<For/>` Component
+
+The [`<For/>`](https://docs.rs/leptos/latest/leptos/fn.For.html) component is a 
+keyed dynamic list. It takes three props:
+- `each`: a function (such as a signal) that returns the items `T` to be iterated over
+- `key`: a key function that takes `&T` and returns a stable, unique key or ID
+- `view`: renders each `T` into a view 
+
+`key` is, well, the key. You can add, remove, and move items within the list. As
+long as each item’s key is stable over time, the framework does not need to rerender
+any of the items, unless they are new additions, and it can very efficiently add,
+remove, and move items as they change. This allows for extremely efficient updates 
+to the list as it changes, with minimal additional work.
+
+Creating a good `key` can be a little tricky. You generally do _not_ want to use 
+an index for this purpose, as it is not stable—if you remove or move items, their 
+indices change.
+
+But it’s a great idea to do something like generating a unique ID for each row as 
+it is generated, and using that as an ID for the key function.
+
+Check out the `<DynamicList/>` component below for an example.
+
+<iframe src="https://codesandbox.io/p/sandbox/4-iteration-sglt1o?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A6%2C%22endLineNumber%22%3A55%2C%22startColumn%22%3A5%2C%22startLineNumber%22%3A31%7D%5D" width="100%" height="100px"></iframe>

docs/book/src/view/05_forms.md

@@ -0,0 +1,107 @@
+# Forms and Inputs
+
+Forms and form inputs are an important part of interactive apps. There are two 
+basic patterns for interacting with inputs in Leptos, which you may recognize
+if you’re familiar with React, SolidJS, or a similar framework: using **controlled**
+or **uncontrolled** inputs.
+
+## Controlled Inputs
+
+In a "controlled input," the framework controls the state of the input 
+element. On every `input` event, it updates a local signal that holds the current 
+state, which in turn updates the `value` prop of the input.
+
+There are two important things to remember:
+1. The `input` event fires on (almost) every change to the element, while the 
+   `change` event fires (more or less) when you unfocus the input. You probably 
+   want `on:input`, but we give you the freedom to choose.
+2. The `value` *attribute* only sets the initial value of the input, i.e., it 
+   only updates the input up to the point that you begin typing. The `value` 
+   *property* continues updating the input after that. You usually want to set 
+   `prop:value` for this reason.
+
+```rust
+let (name, set_name) = create_signal(cx, "Controlled".to_string());
+
+view! { cx,
+    <input type="text"
+        on:input=move |ev| {
+            // event_target_value is a Leptos helper function
+            // it functions the same way as event.target.value
+            // in JavaScript, but smooths out some of the typecasting
+            // necessary to make this work in Rust
+            set_name(event_target_value(&ev));
+        }
+
+        // the `prop:` syntax lets you update a DOM property,
+        // rather than an attribute.
+        prop:value=name
+    />
+    <p>"Name is: " {name}</p>
+}
+```
+
+## Uncontrolled Inputs 
+
+In an "uncontrolled input," the browser controls the state of the input element. 
+Rather than continuously updating a signal to hold its value, we use a 
+[`NodeRef`](https://docs.rs/leptos/latest/leptos/struct.NodeRef.html) to access 
+the input once when we want to get its value.
+
+In this example, we only notify the framework when the `<form>` fires a `submit` 
+event.
+
+```rust
+let (name, set_name) = create_signal(cx, "Uncontrolled".to_string());
+
+let input_element: NodeRef<HtmlElement<Input>> = NodeRef::new(cx);
+```
+`NodeRef` is a kind of reactive smart pointer: we can use it to access the 
+underlying DOM node. Its value will be set when the element is rendered.
+
+```rust
+let on_submit = move |ev: SubmitEvent| {
+    // stop the page from reloading!
+    ev.prevent_default();
+
+    // here, we'll extract the value from the input
+    let value = input_element()
+        // event handlers can only fire after the view
+        // is mounted to the DOM, so the `NodeRef` will be `Some`
+        .expect("<input> to exist")
+        // `NodeRef` implements `Deref` for the DOM element type
+        // this means we can call`HtmlInputElement::value()`
+        // to get the current value of the input
+        .value();
+    set_name(value);
+};
+```
+Our `on_submit` handler will access the input’s value and use it to call `set_name`.
+To access the DOM node stored in the `NodeRef`, we can simply call it as a function
+(or using `.get()`). This will return `Option<web_sys::HtmlInputElement>`, but we 
+know it will already have been filled when we rendered the view, so it’s safe to 
+unwrap here.
+
+We can then call `.value()` to get the value out of the input, because `NodeRef` 
+gives us access to a correctly-typed HTML element.
+
+```rust
+view! { cx,
+    <form on:submit=on_submit>
+        <input type="text"
+            value=name
+            node_ref=input_element
+        />
+        <input type="submit" value="Submit"/>
+    </form>
+    <p>"Name is: " {name}</p>
+}
+```
+The view should be pretty self-explanatory by now. Note two things:
+1. Unlike in the controlled input example, we use `value` (not `prop:value`).
+   This is because we’re just setting the initial value of the input, and letting 
+   the browser control its state. (We could use `prop:value` instead.)
+2. We use `node_ref` to fill the `NodeRef`. (Older examples sometimes use `_ref`.
+   They are the same thing, but `node_ref` has better rust-analyzer support.)
+
+<iframe src="https://codesandbox.io/p/sandbox/5-form-inputs-ih9m62?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A12%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A12%7D%5D" width="100%" height="1000px"></iframe>

docs/book/src/view/06_control_flow.md

@@ -0,0 +1,285 @@
+# Control Flow
+
+In most applications, you sometimes need to make a decision: Should I render this
+part of the view, or not? Should I render `<ButtonA/>` or `<WidgetB/>`? This is
+**control flow**.
+
+## A Few Tips
+
+When thinking about how to do this with Leptos, it’s important to remember a few
+things:
+
+1. Rust is an expression-oriented language: control-flow expressions like
+   `if x() { y } else { z }` and `match x() { ... }` return their values. This
+   makes them very useful for declarative user interfaces.
+2. For any `T` that implements `IntoView`—in other words, for any type that Leptos
+   knows how to render—`Option<T>` and `Result<T, impl Error>` _also_ implement
+   `IntoView`. And just as `Fn() -> T` renders a reactive `T`, `Fn() -> Option<T>`
+   and `Fn() -> Result<T, impl Error>` are reactive.
+3. Rust has lots of handy helpers like [Option::map](https://doc.rust-lang.org/std/option/enum.Option.html#method.map),
+   [Option::and_then](https://doc.rust-lang.org/std/option/enum.Option.html#method.and_then),
+   [Option::ok_or](https://doc.rust-lang.org/std/option/enum.Option.html#method.ok_or),
+   [Result::map](https://doc.rust-lang.org/std/result/enum.Result.html#method.map),
+   [Result::ok](https://doc.rust-lang.org/std/result/enum.Result.html#method.ok), and
+   [bool::then](https://doc.rust-lang.org/std/primitive.bool.html#method.then) that
+   allow you to convert, in a declarative way, between a few different standard types,
+   all of which can be rendered. Spending time in the `Option` and `Result` docs in particular
+   is one of the best ways to level up your Rust game.
+4. And always remember: to be reactive, values must be functions. You’ll see me constantly
+   wrap things in a `move ||` closure, below. This is to ensure that they actually re-run
+   when the signal they depend on changes, keeping the UI reactive.
+
+## So What?
+
+To connect the dots a little: this means that you can actually implement most of
+your control flow with native Rust code, without any control-flow components or
+special knowledge.
+
+For example, let’s start with a simple signal and derived signal:
+
+```rust
+let (value, set_value) = create_signal(cx, 0);
+let is_odd = move || value() & 1 == 1;
+```
+
+> If you don’t recognize what’s going on with `is_odd`, don’t worry about it
+> too much. It’s just a simple way to test whether an integer is odd by doing a
+> bitwise `AND` with `1`.
+
+We can use these signals and ordinary Rust to build most control flow.
+
+### `if` statements
+
+Let’s say I want to render some text if the number is odd, and some other text
+if it’s even. Well, how about this?
+
+```rust
+view! { cx,
+	<p>
+	{move || if is_odd() {
+		"Odd"
+	} else {
+		"Even"
+	}}
+	</p>
+}
+```
+
+An `if` expression returns its value, and a `&str` implements `IntoView`, so a
+`Fn() -> &str` implements `IntoView`, so this... just works!
+
+### `Option<T>`
+
+Let’s say we want to render some text if it’s odd, and nothing if it’s even.
+
+```rust
+let message = move || {
+	if is_odd() {
+		Some("Ding ding ding!")
+	} else {
+		None
+	}
+};
+
+view! { cx,
+	<p>{message}</p>
+}
+```
+
+This works fine. We can make it a little shorter if we’d like, using `bool::then()`.
+
+```rust
+let message = move || is_odd().then(|| "Ding ding ding!");
+view! { cx,
+	<p>{message}</p>
+}
+```
+
+You could even inline this if you’d like, although personally I sometimes like the
+better `cargo fmt` and `rust-analyzer` support I get by pulling things out of the `view`.
+
+### `match` statements
+
+We’re still just writing ordinary Rust code, right? So you have all the power of Rust’s
+pattern matching at your disposal.
+
+```rust
+let message = move || {
+	match value() {
+		0 => "Zero",
+		1 => "One",
+		n if is_odd() => "Odd",
+		_ => "Even"
+	}
+};
+view! { cx,
+	<p>{message}</p>
+}
+```
+
+And why not? YOLO, right?
+
+## Preventing Over-Rendering
+
+Not so YOLO.
+
+Everything we’ve just done is basically fine. But there’s one thing you should remember
+and try to be careful with. Each one of the control-flow functions we’ve created so far
+is basically a derived signal: it will rerun every time the value changes. In the examples
+above, where the value switches from even to odd on every change, this is fine.
+
+But consider the following example:
+
+```rust
+let (value, set_value) = create_signal(cx, 0);
+
+let message = move || if value() > 5 {
+	"Big"
+} else {
+	"Small"
+};
+
+view! { cx,
+	<p>{message}</p>
+}
+```
+
+This _works_, for sure. But if you added a log, you might be surprised
+
+```rust
+let message = move || if value() > 5 {
+	log!("{}: rendering Big", value());
+	"Big"
+} else {
+	log!("{}: rendering Small", value());
+	"Small"
+};
+```
+
+As a user clicks a button, you’d see something like this:
+
+```
+1: rendering Small
+2: rendering Small
+3: rendering Small
+4: rendering Small
+5: rendering Small
+6: rendering Big
+7: rendering Big
+8: rendering Big
+... ad infinitum
+```
+
+Every time `value` changes, it reruns the `if` statement. This makes sense, with
+how reactivity works. But it has a downside. For a simple text node, rerunning
+the `if` statement and rerendering isn’t a big deal. But imagine it were
+like this:
+
+```rust
+let message = move || if value() > 5 {
+	<Big/>
+} else {
+	<Small/>
+};
+```
+
+This rerenders `<Small/>` five times, then `<Big/>` infinitely. If they’re
+loading resources, creating signals, or even just creating DOM nodes, this is
+unnecessary work.
+
+### `<Show/>`
+
+The [`<Show/>`](https://docs.rs/leptos/latest/leptos/fn.Show.html) component is
+the answer. You pass it a `when` condition function, a `fallback` to be shown if
+the `when` function returns `false`, and children to be rendered if `when` is `true`.
+
+```rust
+let (value, set_value) = create_signal(cx, 0);
+
+view! { cx,
+  <Show
+    when=move || value() > 5
+    fallback=|cx| view! { cx, <Small/> }
+  >
+    <Big/>
+  </Show>
+}
+```
+
+`<Show/>` memoizes the `when` condition, so it only renders its `<Small/>` once,
+continuing to show the same component until `value` is greater than five;
+then it renders `<Big/>` once, continuing to show it indefinitely.
+
+This is a helpful tool to avoid rerendering when using dynamic `if` expressions.
+As always, there's some overhead: for a very simple node (like updating a single
+text node, or updating a class or attribute), a `move || if ...` will be more
+efficient. But if it’s at all expensive to render either branch, reach for
+`<Show/>`.
+
+## Note: Type Conversions
+
+There‘s one final thing it’s important to say in this section.
+
+The `view` macro doesn’t return the most-generic wrapping type
+[`View`](https://docs.rs/leptos/latest/leptos/enum.View.html).
+Instead, it returns things with types like `Fragment` or `HtmlElement<Input>`. This
+can be a little annoying if you’re returning different HTML elements from
+different branches of a conditional:
+
+```rust,compile_error
+view! { cx,
+	<main>
+		{move || match is_odd() {
+			true if value() == 1 => {
+				// returns HtmlElement<Pre>
+				view! { cx, <pre>"One"</pre> }
+			},
+			false if value() == 2 => {
+				// returns HtmlElement<P>
+				view! { cx, <p>"Two"</p> }
+			}
+			// returns HtmlElement<Textarea>
+			_ => view! { cx, <textarea>{value()}</textarea> }
+		}}
+	</main>
+}
+```
+
+This strong typing is actually very powerful, because
+[`HtmlElement`](https://docs.rs/leptos/0.1.3/leptos/struct.HtmlElement.html) is,
+among other things, a smart pointer: each `HtmlElement<T>` type implements
+`Deref` for the appropriate underlying `web_sys` type. In other words, in the browser
+your `view` returns real DOM elements, and you can access native DOM methods on
+them.
+
+But it can be a little annoying in conditional logic like this, because you can’t
+return different types from different branches of a condition in Rust. There are two ways
+to get yourself out of this situation:
+
+1. If you have multiple `HtmlElement` types, convert them to `HtmlElement<AnyElement>`
+   with [`.into_any()`](https://docs.rs/leptos/latest/leptos/struct.HtmlElement.html#method.into_any)
+2. If you have a variety of view types that are not all `HtmlElement`, convert them to
+   `View`s with [`.into_view(cx)`](https://docs.rs/leptos/latest/leptos/trait.IntoView.html#tymethod.into_view).
+
+Here’s the same example, with the conversion added:
+
+```rust,compile_error
+view! { cx,
+	<main>
+		{move || match is_odd() {
+			true if value() == 1 => {
+				// returns HtmlElement<Pre>
+				view! { cx, <pre>"One"</pre> }.into_any()
+			},
+			false if value() == 2 => {
+				// returns HtmlElement<P>
+				view! { cx, <p>"Two"</p> }.into_any()
+			}
+			// returns HtmlElement<Textarea>
+			_ => view! { cx, <textarea>{value()}</textarea> }.into_any()
+		}}
+	</main>
+}
+```
+
+<iframe src="https://codesandbox.io/p/sandbox/6-control-flow-in-view-zttwfx?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px"></iframe>

docs/book/src/view/07_errors.md

@@ -0,0 +1,115 @@
+# Error Handling
+
+[In the last chapter](./06_control_flow.md), we saw that you can render `Option<T>`:
+in the `None` case, it will render nothing, and in the `T` case, it will render `T`
+(that is, if `T` implements `IntoView`). You can actually do something very similar
+with a `Result<T, E>`. In the `Err(_)` case, it will render nothing. In the `Ok(T)`
+case, it will render the `T`.
+
+Let’s start with a simple component to capture a number input.
+
+```rust
+#[component]
+fn NumericInput(cx: Scope) -> impl IntoView {
+    let (value, set_value) = create_signal(cx, Ok(0));
+
+    // when input changes, try to parse a number from the input
+    let on_input = move |ev| set_value(event_target_value(&ev).parse::<i32>());
+
+    view! { cx,
+        <label>
+            "Type a number (or not!)"
+            <input type="number" on:input=on_input/>
+            <p>
+                "You entered "
+                <strong>{value}</strong>
+            </p>
+        </label>
+    }
+}
+```
+
+Every time you change the input, `on_input` will attempt to parse its value into a 32-bit
+integer (`i32`), and store it in our `value` signal, which is a `Result<i32, _>`. If you
+type the number `42`, the UI will display
+
+```
+You entered 42
+```
+
+But if you type the string`foo`, it will display
+
+```
+You entered
+```
+
+This is not great. It saves us using `.unwrap_or_default()` or something, but it would be
+much nicer if we could catch the error and do something with it.
+
+You can do that, with the [`<ErrorBoundary/>`](https://docs.rs/leptos/latest/leptos/fn.ErrorBoundary.html)
+component.
+
+## `<ErrorBoundary/>`
+
+An `<ErrorBoundary/>` is a little like the `<Show/>` component we saw in the last chapter.
+If everything’s okay—which is to say, if everything is `Ok(_)`—it renders its children.
+But if there’s an `Err(_)` rendered among those children, it will trigger the
+`<ErrorBoundary/>`’s `fallback`.
+
+Let’s add an `<ErrorBoundary/>` to this example.
+
+```rust
+#[component]
+fn NumericInput(cx: Scope) -> impl IntoView {
+    let (value, set_value) = create_signal(cx, Ok(0));
+
+let on_input = move |ev| set_value(event_target_value(&ev).parse::<i32>());
+
+    view! { cx,
+        <h1>"Error Handling"</h1>
+        <label>
+            "Type a number (or something that's not a number!)"
+            <input type="number" on:input=on_input/>
+            <ErrorBoundary
+                // the fallback receives a signal containing current errors
+                fallback=|cx, errors| view! { cx,
+                    <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.unwrap()
+                                .get()
+                                .0
+                                .into_iter()
+                                .map(|(_, e)| view! { cx, <li>{e.to_string()}</li>})
+                                .collect::<Vec<_>>()
+                            }
+                        </ul>
+                    </div>
+                }
+            >
+                <p>"You entered " <strong>{value}</strong></p>
+            </ErrorBoundary>
+        </label>
+    }
+}
+```
+
+Now, if you type `42`, `value` is `Ok(42)` and you’ll see
+
+```
+You entered 42
+```
+
+If you type `foo`, value is `Err(_)` and the `fallback` will render. We’ve chosen to render
+the list of errors as a `String`, so you’ll see something like
+
+```
+Not a number! Errors:
+- cannot parse integer from empty string
+```
+
+If you fix the error, the error message will disappear and the content you’re wrapping in
+an `<ErrorBoundary/>` will appear again.
+
+<iframe src="https://codesandbox.io/p/sandbox/7-error-handling-and-error-boundaries-sroncx?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px"></iframe>

docs/book/src/view/08_parent_child.md

@@ -0,0 +1,286 @@
+# Parent-Child Communication
+
+You can think of your application as a nested tree of components. Each component
+handles its own local state and manages a section of the user interface, so
+components tend to be relatively self-contained.
+
+Sometimes, though, you’ll want to communicate between a parent component and its
+child. For example, imagine you’ve defined a `<FancyButton/>` component that adds
+some styling, logging, or something else to a `<button/>`. You want to use a
+`<FancyButton/>` in your `<App/>` component. But how can you communicate between
+the two?
+
+It’s easy to communicate state from a parent component to a child component. We
+covered some of this in the material on [components and props](./03_components.md).
+Basically if you want the parent to communicate to the child, you can pass a
+[`ReadSignal`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html), a
+[`Signal`](https://docs.rs/leptos/latest/leptos/struct.Signal.html), or even a
+[`MaybeSignal`](https://docs.rs/leptos/latest/leptos/struct.MaybeSignal.html) as a prop.
+
+But what about the other direction? How can a child send notifications about events
+or state changes back up to the parent?
+
+There are four basic patterns of parent-child communication in Leptos.
+
+## 1. Pass a [`WriteSignal`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html)
+
+One approach is simply to pass a `WriteSignal` from the parent down to the child, and update
+it in the child. This lets you manipulate the state of the parent from the child.
+
+```rust
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+	let (toggled, set_toggled) = create_signal(cx, false);
+	view! { cx,
+		<p>"Toggled? " {toggled}</p>
+		<ButtonA setter=set_toggled/>
+	}
+}
+
+#[component]
+pub fn ButtonA(cx: Scope, setter: WriteSignal<bool>) -> impl IntoView {
+    view! { cx,
+        <button
+            on:click=move |_| setter.update(|value| *value = !*value)
+        >
+            "Toggle"
+        </button>
+    }
+}
+```
+
+This pattern is simple, but you should be careful with it: passing around a `WriteSignal`
+can make it hard to reason about your code. In this example, it’s pretty clear when you
+read `<App/>` that you are handing off the ability to mutate `toggled`, but it’s not at
+all clear when or how it will change. In this small, local example it’s easy to understand,
+but if you find yourself passing around `WriteSignal`s like this throughout your code,
+you should really consider whether this is making it too easy to write spaghetti code.
+
+## 2. Use a Callback
+
+Another approach would be to pass a callback to the child: say, `on_click`.
+
+```rust
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+	let (toggled, set_toggled) = create_signal(cx, false);
+	view! { cx,
+		<p>"Toggled? " {toggled}</p>
+		<ButtonB on_click=move |_| set_toggled.update(|value| *value = !*value)/>
+	}
+}
+
+
+#[component]
+pub fn ButtonB<F>(
+    cx: Scope,
+    on_click: F,
+) -> impl IntoView
+where
+    F: Fn(MouseEvent) + 'static,
+{
+    view! { cx,
+        <button on:click=on_click>
+            "Toggle"
+        </button>
+    }
+}
+```
+
+You’ll notice that whereas `<ButtonA/>` was given a `WriteSignal` and decided how to mutate it,
+`<ButtonB/>` simply fires an event: the mutation happens back in `<App/>`. This has the advantage
+of keeping local state local, preventing the problem of spaghetti mutation. But it also means
+the logic to mutate that signal needs to exist up in `<App/>`, not down in `<ButtonB/>`. These
+are real trade-offs, not a simple right-or-wrong choice.
+
+> Note the way we declare the generic type `F` here for the callback. If you’re
+> confused, look back at the [generic props](./03_components.html#generic-props) section
+> of the chapter on components.
+
+## 3. Use an Event Listener
+
+You can actually write Option 2 in a slightly different way. If the callback maps directly onto
+a native DOM event, you can add an `on:` listener directly to the place you use the component
+in your `view` macro in `<App/>`.
+
+```rust
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+	let (toggled, set_toggled) = create_signal(cx, false);
+	view! { cx,
+		<p>"Toggled? " {toggled}</p>
+		// note the on:click instead of on_click
+		// this is the same syntax as an HTML element event listener
+		<ButtonC on:click=move |_| set_toggled.update(|value| *value = !*value)/>
+	}
+}
+
+
+#[component]
+pub fn ButtonC<F>(cx: Scope) -> impl IntoView {
+    view! { cx,
+        <button>"Toggle"</button>
+    }
+}
+```
+
+This lets you write way less code in `<ButtonC/>` than you did for `<ButtonB/>`,
+and still gives a correctly-typed event to the listener. This works by adding an
+`on:` event listener to each element that `<ButtonC/>` returns: in this case, just
+the one `<button>`.
+
+Of course, this only works for actual DOM events that you’re passing directly through
+to the elements you’re rendering in the component. For more complex logic that
+doesn’t map directly onto an element (say you create `<ValidatedForm/>` and want an
+`on_valid_form_submit` callback) you should use Option 2.
+
+## 4. Providing a Context
+
+This version is actually a variant on Option 1. Say you have a deeply-nested component
+tree:
+
+```rust
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+	let (toggled, set_toggled) = create_signal(cx, false);
+	view! { cx,
+		<p>"Toggled? " {toggled}</p>
+		<Layout/>
+	}
+}
+
+#[component]
+pub fn Layout(cx: Scope) -> impl IntoView {
+	view! { cx,
+		<header>
+			<h1>"My Page"</h1>
+		<main>
+			<Content/>
+		</main>
+	}
+}
+
+#[component]
+pub fn Content(cx: Scope) -> impl IntoView {
+	view! { cx,
+		<div class="content">
+			<ButtonD/>
+		</div>
+	}
+}
+
+#[component]
+pub fn ButtonD<F>(cx: Scope) -> impl IntoView {
+    todo!()
+}
+```
+
+Now `<ButtonD/>` is no longer a direct child of `<App/>`, so you can’t simply
+pass your `WriteSignal` to its props. You could do what’s sometimes called
+“prop drilling,” adding a prop to each layer between the two:
+
+```rust
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+	let (toggled, set_toggled) = create_signal(cx, false);
+	view! { cx,
+		<p>"Toggled? " {toggled}</p>
+		<Layout set_toggled/>
+	}
+}
+
+#[component]
+pub fn Layout(cx: Scope, set_toggled: WriteSignal<bool>) -> impl IntoView {
+	view! { cx,
+		<header>
+			<h1>"My Page"</h1>
+		<main>
+			<Content set_toggled/>
+		</main>
+	}
+}
+
+#[component]
+pub fn Content(cx: Scope, set_toggled: WriteSignal<bool>) -> impl IntoView {
+	view! { cx,
+		<div class="content">
+			<ButtonD set_toggled/>
+		</div>
+	}
+}
+
+#[component]
+pub fn ButtonD<F>(cx: Scope, set_toggled: WriteSignal<bool>) -> impl IntoView {
+    todo!()
+}
+```
+
+This is a mess. `<Layout/>` and `<Content/>` don’t need `set_toggled`; they just
+pass it through to `<ButtonD/>`. But I need to declare the prop in triplicate.
+This is not only annoying but hard to maintain: imagine we add a “half-toggled”
+option and the type of `set_toggled` needs to change to an `enum`. We have to change
+it in three places!
+
+Isn’t there some way to skip levels?
+
+There is!
+
+### The Context API
+
+You can provide data that skips levels by using [`provide_context`](https://docs.rs/leptos/latest/leptos/fn.provide_context.html)
+and [`use_context`](https://docs.rs/leptos/latest/leptos/fn.use_context.html). Contexts are identified
+by the type of the data you provide (in this example, `WriteSignal<bool>`), and they exist in a top-down
+tree that follows the contours of your UI tree. In this example, we can use context to skip the
+unnecessary prop drilling.
+
+```rust
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+	let (toggled, set_toggled) = create_signal(cx, false);
+
+	// share `set_toggled` with all children of this component
+	provide_context(cx, set_toggled);
+
+	view! { cx,
+		<p>"Toggled? " {toggled}</p>
+		<Layout/>
+	}
+}
+
+// <Layout/> and <Content/> omitted
+
+#[component]
+pub fn ButtonD(cx: Scope) -> impl IntoView {
+	// use_context searches up the context tree, hoping to
+	// find a `WriteSignal<bool>`
+	// in this case, I .expect() because I know I provided it
+	let setter = use_context::<WriteSignal<bool>>(cx)
+		.expect("to have found the setter provided");
+
+    view! { cx,
+        <button
+            on:click=move |_| setter.update(|value| *value = !*value)
+        >
+            "Toggle"
+        </button>
+    }
+}
+```
+
+The same caveats apply to this as to `<ButtonA/>`: passing a `WriteSignal`
+around should be done with caution, as it allows you to mutate state from
+arbitrary parts of your code. But when done carefully, this can be one of
+the most effective techniques for global state management in Leptos: simply
+provide the state at the highest level you’ll need it, and use it wherever
+you need it lower down.
+
+Note that there are no performance downsides to this approach. Because you
+are passing a fine-grained reactive signal, _nothing happens_ in the intervening
+components (`<Layout/>` and `<Content/>`) when you update it. You are communicating
+directly between `<ButtonD/>` and `<App/>`. In fact—and this is the power of
+fine-grained reactivity—you are communicating directly between a button click
+in `<ButtonD/>` and a single text node in `<App/>`. It’s as if the components
+themselves don’t exist at all. And, well... at runtime, they don’t. It’s just
+signals and effects, all the way down.
+
+<iframe src="https://codesandbox.io/p/sandbox/8-parent-child-communication-84we8m?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px"></iframe>

docs/book/src/view/09_component_children.md

@@ -0,0 +1,124 @@
+# Component Children
+
+It’s pretty common to want to pass children into a component, just as you can pass
+children into an HTML element. For example, imagine I have a `<FancyForm/>` component
+that enhances an HTML `<form>`. I need some way to pass all its inputs.
+
+```rust
+view! { cx,
+	<Form>
+		<fieldset>
+			<label>
+				"Some Input"
+				<input type="text" name="something"/>
+			</label>
+		</fieldset>
+		<button>"Submit"</button>
+	</Form>
+}
+```
+
+How can you do this in Leptos? There are basically two ways to pass components to
+other components:
+
+1. **render props**: properties that are functions that return a view
+2. the **`children`** prop: a special component property that includes anything
+   you pass as a child to the component.
+
+In fact, you’ve already seen these both in action in the [`<Show/>`](/view/06_control_flow.html#show) component:
+
+```rust
+view! { cx,
+  <Show
+	// `when` is a normal prop
+    when=move || value() > 5
+	// `fallback` is a "render prop": a function that returns a view
+    fallback=|cx| view! { cx, <Small/> }
+  >
+	// `<Big/>` (and anything else here)
+	// will be given to the `children` prop
+    <Big/>
+  </Show>
+}
+```
+
+Let’s define a component that takes some children and a render prop.
+
+```rust
+#[component]
+pub fn TakesChildren<F, IV>(
+    cx: Scope,
+    /// Takes a function (type F) that returns anything that can be
+    /// converted into a View (type IV)
+    render_prop: F,
+    /// `children` takes the `Children` type
+    children: Children,
+) -> impl IntoView
+where
+    F: Fn() -> IV,
+    IV: IntoView,
+{
+    view! { cx,
+        <h2>"Render Prop"</h2>
+        {render_prop()}
+
+		<h2>"Children"</h2>
+        {children(cx)}
+    }
+}
+```
+
+`render_prop` and `children` are both functions, so we can call them to generate
+the appropriate views. `children`, in particular, is an alias for
+`Box<dyn FnOnce(Scope) -> Fragment>`. (Aren't you glad we named it `Children` instead?)
+
+> If you need a `Fn` or `FnMut` here because you need to call `children` more than once,
+> we also provide `ChildrenFn` and `ChildrenMut` aliases.
+
+We can use the component like this:
+
+```rust
+view! { cx,
+	<TakesChildren render_prop=|| view! { cx, <p>"Hi, there!"</p> }>
+		// these get passed to `children`
+		"Some text"
+		<span>"A span"</span>
+	</TakesChildren>
+}
+```
+
+## Manipulating Children
+
+The [`Fragment`](https://docs.rs/leptos/latest/leptos/struct.Fragment.html) type is
+basically a way of wrapping a `Vec<View>`. You can insert it anywhere into your view.
+
+But you can also access those inner views directly to manipulate them. For example, here’s
+a component that takes its children and turns them into an unordered list.
+
+```rust
+#[component]
+pub fn WrapsChildren(cx: Scope, children: Children) -> impl IntoView {
+    // Fragment has `nodes` field that contains a Vec<View>
+    let children = children(cx)
+        .nodes
+        .into_iter()
+        .map(|child| view! { cx, <li>{child}</li> })
+        .collect::<Vec<_>>();
+
+    view! { cx,
+        <ul>{children}</ul>
+    }
+}
+```
+
+Calling it like this will create a list:
+
+```rust
+view! { cx,
+	<WrappedChildren>
+		"A"
+		"B"
+		"C"
+	</WrappedChildren>
+}
+```

docs/book/src/view/README.md

@@ -0,0 +1,5 @@
+# Building User Interfaces
+
+This first section will introduce you to the basic tools you need to build a reactive
+user interface using Leptos. By the end of this section, you should be able to 
+build a simple, synchronous application that is rendered in the browser.

examples/counter/tests/mod.rs

@@ -1,16 +1,86 @@
 use wasm_bindgen_test::*;
 
 wasm_bindgen_test_configure!(run_in_browser);
+use counter::*;
 use leptos::*;
 use web_sys::HtmlElement;
-use counter::*;
+
+#[wasm_bindgen_test]
+fn clear() {
+    let document = leptos::document();
+    let test_wrapper = document.create_element("section").unwrap();
+    document.body().unwrap().append_child(&test_wrapper);
+
+    // start by rendering our counter and mounting it to the DOM
+    // note that we start at the initial value of 10
+    mount_to(
+        test_wrapper.clone().unchecked_into(),
+        |cx| view! { cx, <SimpleCounter initial_value=10 step=1/> },
+    );
+
+    // now we extract the buttons by iterating over the DOM
+    // this would be easier if they had IDs
+    let div = test_wrapper.query_selector("div").unwrap().unwrap();
+    let clear = test_wrapper
+        .query_selector("button")
+        .unwrap()
+        .unwrap()
+        .unchecked_into::<web_sys::HtmlElement>();
+
+    // now let's click the `clear` button
+    clear.click();
+
+    // now let's test the <div> against the expected value
+    // we can do this by testing its `outerHTML`
+    assert_eq!(
+        div.outer_html(),
+        // here we spawn a mini reactive system, just to render the
+        // test case
+        run_scope(create_runtime(), |cx| {
+            // it's as if we're creating it with a value of 0, right?
+            let (value, set_value) = create_signal(cx, 0);
+
+            // we can remove the event listeners because they're not rendered to HTML
+            view! { cx,
+                <div>
+                    <button>"Clear"</button>
+                    <button>"-1"</button>
+                    <span>"Value: " {value} "!"</span>
+                    <button>"+1"</button>
+                </div>
+            }
+            // the view returned an HtmlElement<Div>, which is a smart pointer for
+            // a DOM element. So we can still just call .outer_html()
+            .outer_html()
+        })
+    );
+
+    // There's actually an easier way to do this...
+    // We can just test against a <SimpleCounter/> with the initial value 0
+    assert_eq!(test_wrapper.inner_html(), {
+        let comparison_wrapper = document.create_element("section").unwrap();
+        leptos::mount_to(
+            comparison_wrapper.clone().unchecked_into(),
+            |cx| view! { cx, <SimpleCounter initial_value=0 step=1/>},
+        );
+        comparison_wrapper.inner_html()
+    });
+}
 
 #[wasm_bindgen_test]
 fn inc() {
-    mount_to_body(|cx| view! { cx, <SimpleCounter initial_value=0 step=1/> });
-
     let document = leptos::document();
-    let div = document.query_selector("div").unwrap().unwrap();
+    let test_wrapper = document.create_element("section").unwrap();
+    document.body().unwrap().append_child(&test_wrapper);
+
+    mount_to(
+        test_wrapper.clone().unchecked_into(),
+        |cx| view! { cx, <SimpleCounter initial_value=0 step=1/> },
+    );
+
+    // You can do testing with vanilla DOM operations
+    let document = leptos::document();
+    let div = test_wrapper.query_selector("div").unwrap().unwrap();
     let clear = div
         .first_child()
         .unwrap()
@@ -47,4 +117,40 @@ fn inc() {
     clear.click();
 
     assert_eq!(text.text_content(), Some("Value: 0!".to_string()));
+
+    // Or you can test against a sample view!
+    assert_eq!(
+        div.outer_html(),
+        run_scope(create_runtime(), |cx| {
+            let (value, _) = create_signal(cx, 0);
+            view! { cx,
+                <div>
+                    <button>"Clear"</button>
+                    <button>"-1"</button>
+                    <span>"Value: " {value} "!"</span>
+                    <button>"+1"</button>
+                </div>
+            }
+        }
+        .outer_html())
+    );
+
+    inc.click();
+
+    assert_eq!(
+        div.outer_html(),
+        run_scope(create_runtime(), |cx| {
+            // because we've clicked, it's as if the signal is starting at 1
+            let (value, _) = create_signal(cx, 1);
+            view! { cx,
+                <div>
+                    <button>"Clear"</button>
+                    <button>"-1"</button>
+                    <span>"Value: " {value} "!"</span>
+                    <button>"+1"</button>
+                </div>
+            }
+        }
+        .outer_html())
+    );
 }

examples/counter_isomorphic/Cargo.toml

@@ -8,7 +8,7 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 actix-files = { version = "0.6", optional = true }
-actix-web = { version = "4", optional = true, features = ["openssl", "macros"] }
+actix-web = { version = "4", optional = true, features = ["macros"] }
 broadcaster = "1"
 console_log = "0.2"
 console_error_panic_hook = "0.1"
@@ -25,6 +25,7 @@ leptos_router = { path = "../../router", default-features = false }
 log = "0.4"
 simple_logger = "4.0.0"
 gloo-net = { git = "https://github.com/rustwasm/gloo" }
+wasm-bindgen = "0.2"
 
 [features]
 default = []

examples/counter_isomorphic/src/counters.rs

@@ -194,16 +194,16 @@ pub fn MultiuserCounter(cx: Scope) -> impl IntoView {
         use futures::StreamExt;
 
         let mut source = gloo_net::eventsource::futures::EventSource::new("/api/events")
-            .expect_throw("couldn't connect to SSE stream");
+            .expect("couldn't connect to SSE stream");
         let s = create_signal_from_stream(
             cx,
             source.subscribe("message").unwrap().map(|value| {
                 value
-                    .expect_throw("no message event")
+                    .expect("no message event")
                     .1
                     .data()
                     .as_string()
-                    .expect_throw("expected string value")
+                    .expect("expected string value")
             }),
         );
 

examples/counter_isomorphic/src/main.rs

@@ -37,7 +37,7 @@ cfg_if! {
             // when not using cargo-leptos None must be replaced with Some("Cargo.toml")
             let conf = get_configuration(None).await.unwrap();
 
-            let addr = conf.leptos_options.site_address.clone();
+            let addr = conf.leptos_options.site_addr.clone();
             let routes = generate_route_list(|cx| view! { cx, <Counters/> });
 
             HttpServer::new(move || {

examples/counter_without_macros/src/lib.rs

@@ -1,4 +1,4 @@
-use leptos::{ev, *};
+use leptos::{ev, html::*, *};
 
 pub struct Props {
     /// The starting value for the counter
@@ -25,7 +25,9 @@ pub fn view(cx: Scope, props: Props) -> impl IntoView {
         .child((
             cx,
             button(cx)
-                .on(ev::click, move |_| set_value.update(|value| *value -= step))
+                .on(ev::click, move |_| {
+                    set_value.update(|value| *value -= step)
+                })
                 .child((cx, "-1")),
         ))
         .child((
@@ -38,7 +40,9 @@ pub fn view(cx: Scope, props: Props) -> impl IntoView {
         .child((
             cx,
             button(cx)
-                .on(ev::click, move |_| set_value.update(|value| *value += step))
+                .on(ev::click, move |_| {
+                    set_value.update(|value| *value += step)
+                })
                 .child((cx, "+1")),
         ))
 }

examples/counters/src/lib.rs

@@ -1,5 +1,4 @@
-use leptos::*;
-use leptos::{For, ForProps};
+use leptos::{For, ForProps, *};
 
 const MANY_COUNTERS: usize = 1000;
 
@@ -66,9 +65,8 @@ pub fn Counters(cx: Scope) -> impl IntoView {
                 <For
                     each=counters
                     key=|counter| counter.0
-                    view=move |(id, (value, set_value)): (usize, (ReadSignal<i32>, WriteSignal<i32>))| {
-                        view! {
-                            cx,
+                    view=move |cx, (id, (value, set_value)): (usize, (ReadSignal<i32>, WriteSignal<i32>))| {
+                        view! { cx,
                             <Counter id value set_value/>
                         }
                     }
@@ -85,9 +83,11 @@ fn Counter(
     value: ReadSignal<i32>,
     set_value: WriteSignal<i32>,
 ) -> impl IntoView {
-    let CounterUpdater { set_counters } = use_context(cx).unwrap_throw();
+    let CounterUpdater { set_counters } = use_context(cx).unwrap();
 
-    let input = move |ev| set_value(event_target_value(&ev).parse::<i32>().unwrap_or_default());
+    let input = move |ev| {
+        set_value(event_target_value(&ev).parse::<i32>().unwrap_or_default())
+    };
 
     // just an example of how a cleanup function works
     // this will run when the scope is disposed, i.e., when this row is deleted

examples/counters_stable/src/main.rs

@@ -72,7 +72,7 @@ pub fn Counters(cx: Scope) -> impl IntoView {
                 <For
                     each={move || counters.get()}
                     key={|counter| counter.0}
-                    view=move |(id, (value, set_value))| {
+                    view=move |cx, (id, (value, set_value))| {
                         view! {
                             cx,
                             <Counter id value set_value/>
@@ -91,9 +91,12 @@ fn Counter(
     value: ReadSignal<i32>,
     set_value: WriteSignal<i32>,
 ) -> impl IntoView {
-    let CounterUpdater { set_counters } = use_context(cx).unwrap_throw();
+    let CounterUpdater { set_counters } = use_context(cx).unwrap();
 
-    let input = move |ev| set_value.set(event_target_value(&ev).parse::<i32>().unwrap_or_default());
+    let input = move |ev| {
+        set_value
+            .set(event_target_value(&ev).parse::<i32>().unwrap_or_default())
+    };
 
     view! { cx,
         <li>

examples/error_boundary/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "error_boundary"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+leptos = { path = "../../leptos" }
+console_log = "0.2"
+log = "0.4"
+console_error_panic_hook = "0.1.7"

examples/error_boundary/Makefile.toml

@@ -0,0 +1,9 @@
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/error_boundary/README.md

@@ -0,0 +1,7 @@
+# Leptos `<ErrorBoundary/>` Example
+
+This example shows how to handle basic errors using Leptos.
+
+To run it, just issue the `trunk serve --open` command in the example root. This will build the app, run it, and open a new browser to serve it.
+
+> If you don't have `trunk` installed, [click here for install instructions.](https://trunkrs.dev/)

examples/error_boundary/index.html

@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<link data-trunk rel="rust" data-wasm-opt="z"/>
+		<link data-trunk rel="icon" type="image/ico" href="/public/favicon.ico"/>
+	</head>
+	<body></body>
+</html>

examples/error_boundary/src/lib.rs

@@ -0,0 +1,48 @@
+use leptos::*;
+
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+    let (value, set_value) = create_signal(cx, Ok(0));
+
+    // when input changes, try to parse a number from the input
+    let on_input = move |ev| set_value(event_target_value(&ev).parse::<i32>());
+
+    view! { cx,
+        <h1>"Error Handling"</h1>
+        <label>
+            "Type a number (or something that's not a number!)"
+            <input type="number" on:input=on_input/>
+            // 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=|cx, errors| view! { cx,
+                    <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()
+                                .0
+                                .into_iter()
+                                .map(|(_, e)| view! { cx, <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>
+    }
+}

examples/error_boundary/src/main.rs

@@ -0,0 +1,12 @@
+use error_boundary::*;
+use leptos::*;
+
+pub fn main() {
+    _ = console_log::init_with_level(log::Level::Debug);
+    console_error_panic_hook::set_once();
+    mount_to_body(|cx| {
+        view! { cx,
+            <App/>
+        }
+    })
+}

examples/errors_axum/Cargo.toml

@@ -32,45 +32,49 @@ tokio = { version = "1.22.0", features = ["full"], optional = true }
 http = { version = "0.2.8" }
 thiserror = "1.0.38"
 tracing = "0.1.37"
+wasm-bindgen = "0.2"
 
 [features]
 default = ["csr"]
 csr = ["leptos/csr", "leptos_meta/csr", "leptos_router/csr"]
 hydrate = ["leptos/hydrate", "leptos_meta/hydrate", "leptos_router/hydrate"]
-ssr = ["dep:axum", "dep:tower", "dep:tower-http", "dep:tokio", "leptos/ssr", "leptos_meta/ssr", "leptos_router/ssr", "dep:leptos_axum"]
+ssr = [
+	"dep:axum",
+	"dep:tower",
+	"dep:tower-http",
+	"dep:tokio",
+	"leptos/ssr",
+	"leptos_meta/ssr",
+	"leptos_router/ssr",
+	"dep:leptos_axum",
+]
 
 [package.metadata.cargo-all-features]
-denylist = [
-	"axum",
-	"tower",
-	"tower-http",
-	"tokio",
-	"leptos_axum",
-]
+denylist = ["axum", "tower", "tower-http", "tokio", "leptos_axum"]
 skip_feature_sets = [["csr", "ssr"], ["csr", "hydrate"], ["ssr", "hydrate"]]
 
 [package.metadata.leptos]
 # The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
-output-name = "errors_axum"	
+output-name = "errors_axum"
 # The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
 site-root = "target/site"
 # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
 # Defaults to pkg	
-site-pkg-dir = "pkg" 	
+site-pkg-dir = "pkg"
 # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
 style-file = "./style.css"
 # [Optional] Files in the asset-dir will be copied to the site-root directory
 assets-dir = "public"
 # The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
-site-addr = "127.0.0.1:3000"	
+site-addr = "127.0.0.1:3000"
 # The port to use for automatic reload monitoring
-reload-port = 3001	
+reload-port = 3001
 # [Optional] Command to use when running end2end tests. It will run in the end2end dir.
 end2end-cmd = "npx playwright test"
 #  The browserlist query used for optimizing the CSS.
-browserquery = "defaults" 	
+browserquery = "defaults"
 # Set by cargo-leptos watch when building with tha tool. Controls whether autoreload JS will be included in the head
-watch = false 	
+watch = false
 # The environment Leptos will run in, usually either "DEV" or "PROD"
 env = "DEV"
 # The features to use when compiling the bin target

examples/errors_axum/src/error_template.rs

@@ -1,8 +1,6 @@
 use crate::errors::AppError;
 use cfg_if::cfg_if;
-use leptos::Errors;
-use leptos::*;
-
+use leptos::{Errors, *};
 #[cfg(feature = "ssr")]
 use leptos_axum::ResponseOptions;
 
@@ -23,14 +21,13 @@ pub fn ErrorTemplate(
     };
 
     // Get Errors from Signal
-    let errors = errors.get().0;
-
     // Downcast lets us take a type that implements `std::error::Error`
     let errors: Vec<AppError> = errors
+        .get()
         .into_iter()
-        .filter_map(|(_k, v)| v.downcast_ref::<AppError>().cloned())
+        .filter_map(|(_, v)| v.downcast_ref::<AppError>().cloned())
         .collect();
-    println!("Errors: {errors:#?}");
+    log!("Errors: {errors:#?}");
 
     // Only the response code for the first error is actually sent from the server
     // this may be customized by the specific application
@@ -47,9 +44,9 @@ pub fn ErrorTemplate(
             // a function that returns the items we're iterating over; a signal is fine
             each= move || {errors.clone().into_iter().enumerate()}
             // a unique key for each item as a reference
-            key=|(index, _error)| *index
+            key=|(index, _)| *index
             // renders each item to a view
-            view= move |error| {
+            view=move |cx, error| {
                 let error_string = error.1.to_string();
                 let error_code= error.1.status_code();
                 view! { cx,

examples/errors_axum/src/fallback.rs

@@ -12,8 +12,7 @@ cfg_if! { if #[cfg(feature = "ssr")] {
     use tower_http::services::ServeDir;
     use std::sync::Arc;
     use leptos::{LeptosOptions, Errors, view};
-    use crate::error_template::{ErrorTemplate, ErrorTemplateProps};
-    use crate::errors::AppError;
+    use crate::landing::{App, AppProps};
 
     pub async fn file_and_error_handler(uri: Uri, Extension(options): Extension<Arc<LeptosOptions>>, req: Request<Body>) -> AxumResponse {
         let options = &*options;
@@ -23,9 +22,10 @@ cfg_if! { if #[cfg(feature = "ssr")] {
         if res.status() == StatusCode::OK {
            res.into_response()
         } else{
-            let mut errors = Errors::default();
-            errors.insert_with_default_key(AppError::NotFound);
-            let handler = leptos_axum::render_app_to_stream(options.to_owned(), move |cx| view!{cx, <ErrorTemplate outside_errors=errors.clone()/>});
+            let handler = leptos_axum::render_app_to_stream(
+                options.to_owned(),
+                move |cx| view!{ cx, <App/> }
+            );
             handler(req).await.into_response()
         }
     }

examples/errors_axum/src/landing.rs

@@ -29,7 +29,14 @@ pub fn App(cx: Scope) -> impl IntoView {
         cx,
         <Link rel="shortcut icon" type_="image/ico" href="/favicon.ico"/>
         <Stylesheet id="leptos" href="/pkg/errors_axum.css"/>
-        <Router>
+        <Router fallback=|cx| {
+            let mut outside_errors = Errors::default();
+            outside_errors.insert_with_default_key(AppError::NotFound);
+            view! { cx,
+                <ErrorTemplate outside_errors/>
+            }
+            .into_view(cx)
+        }>
             <header>
                 <h1>"Error Examples:"</h1>
             </header>

examples/errors_axum/src/main.rs

@@ -44,7 +44,7 @@ async fn main() {
     // Setting this to None means we'll be using cargo-leptos and its env vars
     let conf = get_configuration(None).await.unwrap();
     let leptos_options = conf.leptos_options;
-    let addr = leptos_options.site_address;
+    let addr = leptos_options.site_addr;
     let routes = generate_route_list(|cx| view! { cx, <App/> }).await;
 
     // build our application with a route

examples/fetch/index.html

@@ -9,6 +9,12 @@
 			max-width: 250px;
 			height: auto;
 		}
+
+		.error {
+			border: 1px solid red;
+			color: red;
+			background-color: lightpink;
+		}
 	</style>
 	<body></body>
 </html>

examples/fetch/src/lib.rs

@@ -1,3 +1,4 @@
+use anyhow::Result;
 use leptos::*;
 use serde::{Deserialize, Serialize};
 
@@ -6,18 +7,18 @@ pub struct Cat {
     url: String,
 }
 
-async fn fetch_cats(count: u32) -> Result<Vec<String>, ()> {
+async fn fetch_cats(count: u32) -> Result<Vec<String>> {
     if count > 0 {
+        // make the request
         let res = reqwasm::http::Request::get(&format!(
-            "https://api.thecatapi.com/v1/images/search?limit={}",
-            count
+            "https://api.thecatapi.com/v1/images/search?limit={count}",
         ))
         .send()
-        .await
-        .map_err(|_| ())?
+        .await?
+        // convert it to JSON
         .json::<Vec<Cat>>()
-        .await
-        .map_err(|_| ())?
+        .await?
+        // extract the URL field for each cat
         .into_iter()
         .map(|cat| cat.url)
         .collect::<Vec<_>>();
@@ -29,9 +30,45 @@ async fn fetch_cats(count: u32) -> Result<Vec<String>, ()> {
 
 pub fn fetch_example(cx: Scope) -> impl IntoView {
     let (cat_count, set_cat_count) = create_signal::<u32>(cx, 1);
-    let cats = create_resource(cx, cat_count, |count| fetch_cats(count));
 
-    view! { cx, 
+    // we use local_resource here because
+    // 1) anyhow::Result isn't serializable/deserializable
+    // 2) we're not doing server-side rendering in this example anyway
+    //    (during SSR, create_resource will begin loading on the server and resolve on the client)
+    let cats = create_local_resource(cx, cat_count, fetch_cats);
+
+    let fallback = move |cx, errors: RwSignal<Errors>| {
+        let error_list = move || {
+            errors.with(|errors| {
+                errors
+                    .iter()
+                    .map(|(_, e)| view! { cx, <li>{e.to_string()}</li>})
+                    .collect::<Vec<_>>()
+            })
+        };
+
+        view! { cx,
+            <div class="error">
+                <h2>"Error"</h2>
+                <ul>{error_list}</ul>
+            </div>
+        }
+    };
+
+    // the renderer can handle Option<_> and Result<_> states
+    // by displaying nothing for None if the resource is still loading
+    // and by using the ErrorBoundary fallback to catch Err(_)
+    // so we'll just implement our happy path and let the framework handle the rest
+    let cats_view = move || {
+        cats.with(|data| {
+            data.iter()
+                .flatten()
+                .map(|cat| view! { cx, <img src={cat}/> })
+                .collect::<Vec<_>>()
+        })
+    };
+
+    view! { cx,
         <div>
             <label>
                 "How many cats would you like?"
@@ -43,25 +80,11 @@ pub fn fetch_example(cx: Scope) -> impl IntoView {
                     }
                 />
             </label>
-            <Transition fallback=move || view! { cx, <div>"Loading (Suspense Fallback)..."</div>}>
-                {move || {
-                        cats.read().map(|data| match data {
-                            Err(_) => view! { cx, <pre>"Error"</pre> }.into_view(cx),
-                            Ok(cats) => view! { cx, 
-                                <div>{
-                                    cats.iter()
-                                        .map(|src| {
-                                            view! { cx, 
-                                                <img src={src}/>
-                                            }
-                                        })
-                                        .collect::<Vec<_>>()
-                                }</div>
-                            }.into_view(cx),
-                        })
-                    }
-                }
-            </Transition>
+            <ErrorBoundary fallback>
+                <Transition fallback=move || view! { cx, <div>"Loading (Suspense Fallback)..."</div>}>
+                    {cats_view}
+                </Transition>
+            </ErrorBoundary>
         </div>
     }
 }

examples/hackernews/Cargo.toml

@@ -9,12 +9,14 @@ crate-type = ["cdylib", "rlib"]
 [dependencies]
 anyhow = "1"
 actix-files = { version = "0.6", optional = true }
-actix-web = { version = "4", optional = true, features = ["openssl", "macros"] }
+actix-web = { version = "4", optional = true, features = ["macros"] }
 console_log = "0.2"
 console_error_panic_hook = "0.1"
 futures = "0.3"
 cfg-if = "1"
-leptos = { path = "../../leptos", default-features = false, features = ["serde"] }
+leptos = { path = "../../leptos", default-features = false, features = [
+	"serde",
+] }
 leptos_meta = { path = "../../meta", default-features = false }
 leptos_actix = { path = "../../integrations/actix", default-features = false, optional = true }
 leptos_router = { path = "../../router", default-features = false }
@@ -47,26 +49,26 @@ skip_feature_sets = [["csr", "ssr"], ["csr", "hydrate"], ["ssr", "hydrate"]]
 
 [package.metadata.leptos]
 # The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
-output-name = "hackernews"	
+output-name = "hackernews"
 # The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
 site-root = "target/site"
 # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
 # Defaults to pkg	
-site-pkg-dir = "pkg" 	
+site-pkg-dir = "pkg"
 # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
 style-file = "./style.css"
 # [Optional] Files in the asset-dir will be copied to the site-root directory
 assets-dir = "public"
 # The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
-site-addr = "127.0.0.1:3000"	
+site-addr = "127.0.0.1:3000"
 # The port to use for automatic reload monitoring
-reload-port = 3001	
+reload-port = 3001
 # [Optional] Command to use when running end2end tests. It will run in the end2end dir.
 end2end-cmd = "npx playwright test"
 #  The browserlist query used for optimizing the CSS.
-browserquery = "defaults" 	
+browserquery = "defaults"
 # Set by cargo-leptos watch when building with tha tool. Controls whether autoreload JS will be included in the head
-watch = false 	
+watch = false
 # The environment Leptos will run in, usually either "DEV" or "PROD"
 env = "DEV"
 # The features to use when compiling the bin target
@@ -87,4 +89,4 @@ lib-features = ["hydrate"]
 # If the --no-default-features flag should be used when compiling the lib target
 #
 # Optional. Defaults to false.
-lib-default-features = false
+lib-default-features = false

examples/hackernews/src/main.rs

@@ -24,7 +24,7 @@ cfg_if! {
             // Setting this to None means we'll be using cargo-leptos and its env vars.
             let conf = get_configuration(None).await.unwrap();
 
-            let addr = conf.leptos_options.site_address.clone();
+            let addr = conf.leptos_options.site_addr.clone();
             // Generate the list of routes in your Leptos App
             let routes = generate_route_list(|cx| view! { cx, <App/> });
 

examples/hackernews/src/routes/stories.rs

@@ -91,7 +91,7 @@ pub fn Stories(cx: Scope) -> impl IntoView {
                                         <For
                                             each=move || stories.clone()
                                             key=|story| story.id
-                                            view=move |story: api::Story| {
+                                            view=move |cx, story: api::Story| {
                                                 view! { cx,
                                                     <Story story/>
                                                 }

examples/hackernews/src/routes/story.rs

@@ -53,7 +53,7 @@ pub fn Story(cx: Scope) -> impl IntoView {
                                     <For
                                         each=move || story.comments.clone().unwrap_or_default()
                                         key=|comment| comment.id
-                                        view=move |comment| view! { cx,  <Comment comment /> }
+                                        view=move |cx, comment| view! { cx,  <Comment comment /> }
                                     />
                                 </ul>
                             </div>
@@ -98,7 +98,7 @@ pub fn Comment(cx: Scope, comment: api::Comment) -> impl IntoView {
                                 <For
                                     each=move || comments.clone()
                                     key=|comment| comment.id
-                                    view=move |comment: api::Comment| view! { cx, <Comment comment /> }
+                                    view=move |cx, comment: api::Comment| view! { cx, <Comment comment /> }
                                 />
                             </ul>
                         }

examples/hackernews_axum/src/error_template.rs

@@ -1,5 +1,4 @@
-use leptos::Errors;
-use leptos::{view, For, ForProps, IntoView, RwSignal, Scope, View};
+use leptos::{view, Errors, For, ForProps, IntoView, RwSignal, Scope, View};
 
 // A basic function to display errors served by the error boundaries. Feel free to do more complicated things
 // here than just displaying them
@@ -11,12 +10,12 @@ pub fn error_template(cx: Scope, errors: Option<RwSignal<Errors>>) -> View {
     <h1>"Errors"</h1>
     <For
         // a function that returns the items we're iterating over; a signal is fine
-        each= move || {errors.get().0.into_iter()}
+        each=errors
         // a unique key for each item as a reference
-        key=|error| error.0.clone()
+        key=|(key, _)| key.clone()
         // renders each item to a view
-        view= move |error| {
-        let error_string = error.1.to_string();
+        view= move |cx, (_, error)| {
+        let error_string = error.to_string();
           view! {
             cx,
             <p>"Error: " {error_string}</p>

examples/hackernews_axum/src/main.rs

@@ -19,7 +19,7 @@ if #[cfg(feature = "ssr")] {
 
         let conf = get_configuration(Some("Cargo.toml")).await.unwrap();
         let leptos_options = conf.leptos_options;
-        let addr = leptos_options.site_address.clone();
+        let addr = leptos_options.site_addr.clone();
         let routes = generate_route_list(|cx| view! { cx, <App/> }).await;
 
         simple_logger::init_with_level(log::Level::Debug).expect("couldn't initialize logging");

examples/hackernews_axum/src/routes/stories.rs

@@ -91,7 +91,7 @@ pub fn Stories(cx: Scope) -> impl IntoView {
                                         <For
                                             each=move || stories.clone()
                                             key=|story| story.id
-                                            view=move |story: api::Story| {
+                                            view=move |cx, story: api::Story| {
                                                 view! { cx,
                                                     <Story story/>
                                                 }

examples/hackernews_axum/src/routes/story.rs

@@ -53,7 +53,7 @@ pub fn Story(cx: Scope) -> impl IntoView {
                                     <For
                                         each=move || story.comments.clone().unwrap_or_default()
                                         key=|comment| comment.id
-                                        view=move |comment| view! { cx,  <Comment comment /> }
+                                        view=move |cx, comment| view! { cx,  <Comment comment /> }
                                     />
                                 </ul>
                             </div>
@@ -98,7 +98,7 @@ pub fn Comment(cx: Scope, comment: api::Comment) -> impl IntoView {
                                 <For
                                     each=move || comments.clone()
                                     key=|comment| comment.id
-                                    view=move |comment: api::Comment| view! { cx, <Comment comment /> }
+                                    view=move |cx, comment: api::Comment| view! { cx, <Comment comment /> }
                                 />
                             </ul>
                         }

examples/parent_child/Cargo.toml

@@ -8,4 +8,4 @@ leptos = { path = "../../leptos" }
 console_log = "0.2"
 log = "0.4"
 console_error_panic_hook = "0.1.7"
-
+web-sys = "0.3"

examples/router/src/lib.rs

@@ -1,14 +1,18 @@
 mod api;
-
+use crate::api::*;
 use leptos::*;
 use leptos_router::*;
 
-use crate::api::{get_contact, get_contacts};
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+struct ExampleContext(i32);
 
 #[component]
 pub fn RouterExample(cx: Scope) -> impl IntoView {
     log::debug!("rendering <RouterExample/>");
 
+    // contexts are passed down through the route tree
+    provide_context(cx, ExampleContext(0));
+
     view! { cx,
         <Router>
             <nav>
@@ -59,6 +63,13 @@ pub fn RouterExample(cx: Scope) -> impl IntoView {
 pub fn ContactList(cx: Scope) -> impl IntoView {
     log::debug!("rendering <ContactList/>");
 
+    // contexts are passed down through the route tree
+    provide_context(cx, ExampleContext(42));
+
+    on_cleanup(cx, || {
+        log!("cleaning up <ContactList/>");
+    });
+
     let location = use_location(cx);
     let contacts = create_resource(cx, move || location.search.get(), get_contacts);
     let contacts = move || {
@@ -86,21 +97,28 @@ pub fn ContactList(cx: Scope) -> impl IntoView {
     }
 }
 
+#[derive(Params, PartialEq, Clone, Debug)]
+pub struct ContactParams {
+    id: usize,
+}
+
 #[component]
 pub fn Contact(cx: Scope) -> impl IntoView {
     log::debug!("rendering <Contact/>");
 
-    let params = use_params_map(cx);
+    log::debug!(
+        "ExampleContext should be Some(42). It is {:?}",
+        use_context::<ExampleContext>(cx)
+    );
+
+    on_cleanup(cx, || {
+        log!("cleaning up <Contact/>");
+    });
+
+    let params = use_params::<ContactParams>(cx);
     let contact = create_resource(
         cx,
-        move || {
-            params()
-                .get("id")
-                .cloned()
-                .unwrap_or_default()
-                .parse::<usize>()
-                .ok()
-        },
+        move || params().map(|params| params.id).ok(),
         // any of the following would work (they're identical)
         // move |id| async move { get_contact(id).await }
         // move |id| get_contact(id),
@@ -138,6 +156,16 @@ pub fn Contact(cx: Scope) -> impl IntoView {
 #[component]
 pub fn About(cx: Scope) -> impl IntoView {
     log::debug!("rendering <About/>");
+
+    on_cleanup(cx, || {
+        log!("cleaning up <About/>");
+    });
+
+    log::debug!(
+        "ExampleContext should be Some(0). It is {:?}",
+        use_context::<ExampleContext>(cx)
+    );
+
     // use_navigate allows you to navigate programmatically by calling a function
     let navigate = use_navigate(cx);
 
@@ -159,6 +187,11 @@ pub fn About(cx: Scope) -> impl IntoView {
 #[component]
 pub fn Settings(cx: Scope) -> impl IntoView {
     log::debug!("rendering <Settings/>");
+
+    on_cleanup(cx, || {
+        log!("cleaning up <Settings/>");
+    });
+
     view! { cx,
         <>
             <h1>"Settings"</h1>

examples/tailwind/index.html

@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <title>Cargo Leptos</title>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <!-- INJECT HEAD -->
-  </head>
-  <body>
-    <!-- INJECT BODY -->
-  </body>
-</html>

examples/tailwind/src/main.rs

@@ -20,7 +20,7 @@ cfg_if! {
             // Setting this to None means we'll be using cargo-leptos and its env vars.
             let conf = get_configuration(None).await.unwrap();
 
-            let addr = conf.leptos_options.site_address.clone();
+            let addr = conf.leptos_options.site_addr.clone();
 
             // Generate the list of routes in your Leptos App
             let routes = generate_route_list(|cx| view! { cx, <App/> });

examples/todo_app_sqlite/Cargo.toml

@@ -8,7 +8,7 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 actix-files = { version = "0.6.2", optional = true }
-actix-web = { version = "4.2.1", optional = true, features = ["openssl", "macros"] }
+actix-web = { version = "4.2.1", optional = true, features = ["macros"] }
 anyhow = "1.0.68"
 broadcaster = "1.0.0"
 console_log = "0.2.0"
@@ -29,6 +29,7 @@ sqlx = { version = "0.6.2", features = [
 	"runtime-tokio-rustls",
 	"sqlite",
 ], optional = true }
+wasm-bindgen = "0.2"
 
 [features]
 default = ["ssr"]
@@ -49,26 +50,26 @@ skip_feature_sets = [["csr", "ssr"], ["csr", "hydrate"], ["ssr", "hydrate"]]
 
 [package.metadata.leptos]
 # The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
-output-name = "todo_app_sqlite"	
+output-name = "todo_app_sqlite"
 # The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
 site-root = "target/site"
 # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
 # Defaults to pkg	
-site-pkg-dir = "pkg" 	
+site-pkg-dir = "pkg"
 # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
 style-file = "./style.css"
 # [Optional] Files in the asset-dir will be copied to the site-root directory
 assets-dir = "public"
 # The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
-site-addr = "127.0.0.1:3000"	
+site-addr = "127.0.0.1:3000"
 # The port to use for automatic reload monitoring
-reload-port = 3001	
+reload-port = 3001
 # [Optional] Command to use when running end2end tests. It will run in the end2end dir.
 end2end-cmd = "npx playwright test"
 #  The browserlist query used for optimizing the CSS.
-browserquery = "defaults" 	
+browserquery = "defaults"
 # Set by cargo-leptos watch when building with tha tool. Controls whether autoreload JS will be included in the head
-watch = false 	
+watch = false
 # The environment Leptos will run in, usually either "DEV" or "PROD"
 env = "DEV"
 # The features to use when compiling the bin target

examples/todo_app_sqlite/src/main.rs

@@ -29,7 +29,7 @@ cfg_if! {
             // Setting this to None means we'll be using cargo-leptos and its env vars.
             let conf = get_configuration(None).await.unwrap();
 
-            let addr = conf.leptos_options.site_address.clone();
+            let addr = conf.leptos_options.site_addr.clone();
 
             // Generate the list of routes in your Leptos App
             let routes = generate_route_list(|cx| view! { cx, <TodoApp/> });

examples/todo_app_sqlite_axum/Cargo.toml

@@ -36,22 +36,26 @@ sqlx = { version = "0.6.2", features = [
 ], optional = true }
 thiserror = "1.0.38"
 tracing = "0.1.37"
+wasm-bindgen = "0.2"
 
 [features]
 default = ["csr"]
 csr = ["leptos/csr", "leptos_meta/csr", "leptos_router/csr"]
 hydrate = ["leptos/hydrate", "leptos_meta/hydrate", "leptos_router/hydrate"]
-ssr = ["dep:axum", "dep:tower", "dep:tower-http", "dep:tokio", "dep:sqlx", "leptos/ssr", "leptos_meta/ssr", "leptos_router/ssr", "dep:leptos_axum"]
+ssr = [
+	"dep:axum",
+	"dep:tower",
+	"dep:tower-http",
+	"dep:tokio",
+	"dep:sqlx",
+	"leptos/ssr",
+	"leptos_meta/ssr",
+	"leptos_router/ssr",
+	"dep:leptos_axum",
+]
 
 [package.metadata.cargo-all-features]
-denylist = [
-	"axum",
-	"tower",
-	"tower-http",
-	"tokio",
-	"sqlx",
-	"leptos_axum",
-]
+denylist = ["axum", "tower", "tower-http", "tokio", "sqlx", "leptos_axum"]
 skip_feature_sets = [["csr", "ssr"], ["csr", "hydrate"], ["ssr", "hydrate"]]
 
 [package.metadata.leptos]

examples/todo_app_sqlite_axum/src/error_template.rs

@@ -1,8 +1,6 @@
 use crate::errors::TodoAppError;
 use cfg_if::cfg_if;
-use leptos::Errors;
-use leptos::*;
-
+use leptos::{Errors, *};
 #[cfg(feature = "ssr")]
 use leptos_axum::ResponseOptions;
 
@@ -23,14 +21,12 @@ pub fn ErrorTemplate(
     };
 
     // Get Errors from Signal
-    let errors = errors.get().0;
-
     // Downcast lets us take a type that implements `std::error::Error`
     let errors: Vec<TodoAppError> = errors
+        .get()
         .into_iter()
-        .filter_map(|(_k, v)| v.downcast_ref::<TodoAppError>().cloned())
+        .filter_map(|(_, v)| v.downcast_ref::<TodoAppError>().cloned())
         .collect();
-    println!("Errors: {errors:#?}");
 
     // Only the response code for the first error is actually sent from the server
     // this may be customized by the specific application
@@ -51,7 +47,7 @@ pub fn ErrorTemplate(
         // a unique key for each item as a reference
         key=|(index, _error)| *index
         // renders each item to a view
-        view= move |error| {
+        view= move |cx, error| {
         let error_string = error.1.to_string();
         let error_code= error.1.status_code();
           view! {

examples/todo_app_sqlite_axum/src/main.rs

@@ -43,7 +43,7 @@ if #[cfg(feature = "ssr")] {
         // Setting this to None means we'll be using cargo-leptos and its env vars
         let conf = get_configuration(None).await.unwrap();
         let leptos_options = conf.leptos_options;
-        let addr = leptos_options.site_address;
+        let addr = leptos_options.site_addr;
         let routes = generate_route_list(|cx| view! { cx, <TodoApp/> }).await;
 
         // build our application with a route

examples/todomvc/src/lib.rs

@@ -1,4 +1,4 @@
-use leptos::{web_sys::HtmlInputElement, *};
+use leptos::{html::Input, leptos_dom::helpers::location_hash, *};
 use storage::TodoSerialized;
 use uuid::Uuid;
 
@@ -12,12 +12,15 @@ const STORAGE_KEY: &str = "todos-leptos";
 // Basic operations to manipulate the todo list: nothing really interesting here
 impl Todos {
     pub fn new(cx: Scope) -> Self {
-        let starting_todos = if let Ok(Some(storage)) = window().local_storage() {
+        let starting_todos = if let Ok(Some(storage)) = window().local_storage()
+        {
             storage
                 .get_item(STORAGE_KEY)
                 .ok()
                 .flatten()
-                .and_then(|value| serde_json::from_str::<Vec<TodoSerialized>>(&value).ok())
+                .and_then(|value| {
+                    serde_json::from_str::<Vec<TodoSerialized>>(&value).ok()
+                })
                 .map(|values| {
                     values
                         .into_iter()
@@ -89,7 +92,12 @@ impl Todo {
         Self::new_with_completed(cx, id, title, false)
     }
 
-    pub fn new_with_completed(cx: Scope, id: Uuid, title: String, completed: bool) -> Self {
+    pub fn new_with_completed(
+        cx: Scope,
+        id: Uuid,
+        title: String,
+        completed: bool,
+    ) -> Self {
         // RwSignal combines the getter and setter in one struct, rather than separating
         // the getter from the setter. This makes it more convenient in some cases, such
         // as when we're putting the signals into a struct and passing it around. There's
@@ -129,22 +137,24 @@ pub fn TodoMVC(cx: Scope) -> impl IntoView {
     // Handle the three filter modes: All, Active, and Completed
     let (mode, set_mode) = create_signal(cx, Mode::All);
     window_event_listener("hashchange", move |_| {
-        let new_mode = location_hash().map(|hash| route(&hash)).unwrap_or_default();
+        let new_mode =
+            location_hash().map(|hash| route(&hash)).unwrap_or_default();
         set_mode(new_mode);
     });
 
     // Callback to add a todo on pressing the `Enter` key, if the field isn't empty
+    let input_ref = NodeRef::<Input>::new(cx);
     let add_todo = move |ev: web_sys::KeyboardEvent| {
-        let target = event_target::<HtmlInputElement>(&ev);
+        let input = input_ref.get().unwrap();
         ev.stop_propagation();
         let key_code = ev.key_code();
         if key_code == ENTER_KEY {
-            let title = event_target_value(&ev);
+            let title = input.value();
             let title = title.trim();
             if !title.is_empty() {
                 let new = Todo::new(cx, Uuid::new_v4(), title.to_string());
                 set_todos.update(|t| t.add(new));
-                target.set_value("");
+                input.set_value("");
             }
         }
     };
@@ -184,7 +194,8 @@ pub fn TodoMVC(cx: Scope) -> impl IntoView {
                 .iter()
                 .map(TodoSerialized::from)
                 .collect::<Vec<_>>();
-            let json = serde_json::to_string(&objs).expect("couldn't serialize Todos");
+            let json =
+                serde_json::to_string(&objs).expect("couldn't serialize Todos");
             if storage.set_item(STORAGE_KEY, &json).is_err() {
                 log::error!("error while trying to set item in localStorage");
             }
@@ -201,6 +212,7 @@ pub fn TodoMVC(cx: Scope) -> impl IntoView {
                         placeholder="What needs to be done?"
                         autofocus
                         on:keydown=add_todo
+                        node_ref=input_ref
                     />
                 </header>
                 <section
@@ -216,7 +228,7 @@ pub fn TodoMVC(cx: Scope) -> impl IntoView {
                         <For
                             each=filtered_todos
                             key=|todo| todo.id
-                            view=move |todo: Todo| view! { cx,  <Todo todo /> }
+                            view=move |cx, todo: Todo| view! { cx,  <Todo todo /> }
                         />
                     </ul>
                 </section>
@@ -262,7 +274,7 @@ pub fn Todo(cx: Scope, todo: Todo) -> impl IntoView {
     let set_todos = use_context::<WriteSignal<Todos>>(cx).unwrap();
 
     // this will be filled by _ref=input below
-    let todo_input = NodeRef::<HtmlElement<Input>>::new(cx);
+    let todo_input = NodeRef::<Input>::new(cx);
 
     let save = move |value: &str| {
         let value = value.trim();

integrations/actix/src/lib.rs

@@ -15,7 +15,11 @@ use actix_web::{
 };
 use futures::{Future, StreamExt};
 use http::StatusCode;
-use leptos::*;
+use leptos::{
+    leptos_dom::ssr::render_to_stream_with_prefix_undisposed_with_context,
+    leptos_server::{server_fn_by_path, Payload},
+    *,
+};
 use leptos_meta::*;
 use leptos_router::*;
 use parking_lot::RwLock;
@@ -32,11 +36,19 @@ pub struct ResponseParts {
 
 impl ResponseParts {
     /// Insert a header, overwriting any previous value with the same key
-    pub fn insert_header(&mut self, key: header::HeaderName, value: header::HeaderValue) {
+    pub fn insert_header(
+        &mut self,
+        key: header::HeaderName,
+        value: header::HeaderValue,
+    ) {
         self.headers.insert(key, value);
     }
     /// Append a header, leaving any header with the same key intact
-    pub fn append_header(&mut self, key: header::HeaderName, value: header::HeaderValue) {
+    pub fn append_header(
+        &mut self,
+        key: header::HeaderName,
+        value: header::HeaderValue,
+    ) {
         self.headers.append(key, value);
     }
 }
@@ -60,13 +72,21 @@ impl ResponseOptions {
         res_parts.status = Some(status);
     }
     /// Insert a header, overwriting any previous value with the same key
-    pub fn insert_header(&self, key: header::HeaderName, value: header::HeaderValue) {
+    pub fn insert_header(
+        &self,
+        key: header::HeaderName,
+        value: header::HeaderValue,
+    ) {
         let mut writeable = self.0.write();
         let res_parts = &mut *writeable;
         res_parts.headers.insert(key, value);
     }
     /// Append a header, leaving any header with the same key intact
-    pub fn append_header(&self, key: header::HeaderName, value: header::HeaderValue) {
+    pub fn append_header(
+        &self,
+        key: header::HeaderName,
+        value: header::HeaderValue,
+    ) {
         let mut writeable = self.0.write();
         let res_parts = &mut *writeable;
         res_parts.headers.append(key, value);
@@ -77,12 +97,14 @@ impl ResponseOptions {
 /// it sets a [StatusCode] of 302 and a [LOCATION](header::LOCATION) header with the provided value.
 /// If looking to redirect from the client, `leptos_router::use_navigate()` should be used instead.
 pub fn redirect(cx: leptos::Scope, path: &str) {
-    let response_options = use_context::<ResponseOptions>(cx).unwrap();
-    response_options.set_status(StatusCode::FOUND);
-    response_options.insert_header(
-        header::LOCATION,
-        header::HeaderValue::from_str(path).expect("Failed to create HeaderValue"),
-    );
+    if let Some(response_options) = use_context::<ResponseOptions>(cx) {
+        response_options.set_status(StatusCode::FOUND);
+        response_options.insert_header(
+            header::LOCATION,
+            header::HeaderValue::from_str(path)
+                .expect("Failed to create HeaderValue"),
+        );
+    }
 }
 
 /// An Actix [Route](actix_web::Route) that listens for a `POST` request with
@@ -173,7 +195,8 @@ pub fn handle_server_fns_with_context(
 
                     match server_fn(cx, body).await {
                         Ok(serialized) => {
-                            let res_options = use_context::<ResponseOptions>(cx).unwrap();
+                            let res_options =
+                                use_context::<ResponseOptions>(cx).unwrap();
 
                             // clean up the scope, which we only needed to run the server fn
                             disposer.dispose();
@@ -183,7 +206,8 @@ pub fn handle_server_fns_with_context(
                             let mut res_parts = res_options.0.write();
 
                             if accept_header == Some("application/json")
-                                || accept_header == Some("application/x-www-form-urlencoded")
+                                || accept_header
+                                    == Some("application/x-www-form-urlencoded")
                                 || accept_header == Some("application/cbor")
                             {
                                 res = HttpResponse::Ok();
@@ -221,7 +245,9 @@ pub fn handle_server_fns_with_context(
                                     res.body(Bytes::from(data))
                                 }
                                 Payload::Url(data) => {
-                                    res.content_type("application/x-www-form-urlencoded");
+                                    res.content_type(
+                                        "application/x-www-form-urlencoded",
+                                    );
                                     res.body(data)
                                 }
                                 Payload::Json(data) => {
@@ -230,13 +256,15 @@ pub fn handle_server_fns_with_context(
                                 }
                             }
                         }
-                        Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
+                        Err(e) => HttpResponse::InternalServerError()
+                            .body(e.to_string()),
                     }
                 } else {
                     HttpResponse::BadRequest().body(format!(
                         "Could not find a server function at the route {:?}. \
-                        \n\nIt's likely that you need to call ServerFn::register() on the \
-                        server function type, somewhere in your `main` function.",
+                         \n\nIt's likely that you need to call \
+                         ServerFn::register() on the server function type, \
+                         somewhere in your `main` function.",
                         req.path()
                     ))
                 }
@@ -256,27 +284,33 @@ pub fn handle_server_fns_with_context(
 ///
 /// This can then be set up at an appropriate route in your application:
 /// ```
-/// use actix_web::{HttpServer, App};
+/// use actix_web::{App, HttpServer};
 /// use leptos::*;
-/// use std::{env,net::SocketAddr};
+/// use std::{env, net::SocketAddr};
 ///
 /// #[component]
 /// fn MyApp(cx: Scope) -> impl IntoView {
-///   view! { cx, <main>"Hello, world!"</main> }
+///     view! { cx, <main>"Hello, world!"</main> }
 /// }
 ///
 /// # if false { // don't actually try to run a server in a doctest...
 /// #[actix_web::main]
 /// async fn main() -> std::io::Result<()> {
 ///     let conf = get_configuration(Some("Cargo.toml")).await.unwrap();
-///     let addr = conf.leptos_options.site_address.clone();
+///     let addr = conf.leptos_options.site_addr.clone();
 ///     HttpServer::new(move || {
 ///         let leptos_options = &conf.leptos_options;
-///     
+///
 ///         App::new()
 ///             // {tail:.*} passes the remainder of the URL as the route
 ///             // the actual routing will be handled by `leptos_router`
-///             .route("/{tail:.*}", leptos_actix::render_app_to_stream(leptos_options.to_owned(), |cx| view! { cx, <MyApp/> }))
+///             .route(
+///                 "/{tail:.*}",
+///                 leptos_actix::render_app_to_stream(
+///                     leptos_options.to_owned(),
+///                     |cx| view! { cx, <MyApp/> },
+///                 ),
+///             )
 ///     })
 ///     .bind(&addr)?
 ///     .run()
@@ -353,31 +387,38 @@ where
 ///
 /// This can then be set up at an appropriate route in your application:
 /// ```
-/// use actix_web::{HttpServer, App};
+/// use actix_web::{App, HttpServer};
 /// use leptos::*;
-/// use std::{env,net::SocketAddr};
 /// use leptos_actix::DataResponse;
+/// use std::{env, net::SocketAddr};
 ///
 /// #[component]
 /// fn MyApp(cx: Scope, data: &'static str) -> impl IntoView {
-///   view! { cx, <main>"Hello, world!"</main> }
+///     view! { cx, <main>"Hello, world!"</main> }
 /// }
 ///
 /// # if false { // don't actually try to run a server in a doctest...
 /// #[actix_web::main]
 /// async fn main() -> std::io::Result<()> {
 ///     let conf = get_configuration(Some("Cargo.toml")).await.unwrap();
-///     let addr = conf.leptos_options.site_address.clone();
+///     let addr = conf.leptos_options.site_addr.clone();
 ///     HttpServer::new(move || {
 ///         let leptos_options = &conf.leptos_options;
-///     
+///
 ///         App::new()
 ///             // {tail:.*} passes the remainder of the URL as the route
 ///             // the actual routing will be handled by `leptos_router`
-///             .route("/{tail:.*}", leptos_actix::render_preloaded_data_app(
-///                 leptos_options.to_owned(),
-///                 |req| async move { Ok(DataResponse::Data("async func that can preload data")) },
-///                 |cx, data| view! { cx, <MyApp data/> })
+///             .route(
+///                 "/{tail:.*}",
+///                 leptos_actix::render_preloaded_data_app(
+///                     leptos_options.to_owned(),
+///                     |req| async move {
+///                         Ok(DataResponse::Data(
+///                             "async func that can preload data",
+///                         ))
+///                     },
+///                     |cx, data| view! { cx, <MyApp data/> },
+///                 ),
 ///             )
 ///     })
 ///     .bind(&addr)?
@@ -430,7 +471,11 @@ where
     })
 }
 
-fn provide_contexts(cx: leptos::Scope, req: &HttpRequest, res_options: ResponseOptions) {
+fn provide_contexts(
+    cx: leptos::Scope,
+    req: &HttpRequest,
+    res_options: ResponseOptions,
+) {
     let path = leptos_corrected_path(req);
 
     let integration = ServerIntegration { path };
@@ -457,25 +502,27 @@ async fn stream_app(
     res_options: ResponseOptions,
     additional_context: impl Fn(leptos::Scope) + 'static + Clone + Send,
 ) -> HttpResponse<BoxBody> {
-    let (stream, runtime, scope) = render_to_stream_with_prefix_undisposed_with_context(
-        app,
-        move |cx| {
-            let meta = use_context::<MetaContext>(cx);
-            let head = meta
-                .as_ref()
-                .map(|meta| meta.dehydrate())
-                .unwrap_or_default();
-            let body_meta = meta
-                .as_ref()
-                .and_then(|meta| meta.body.as_string())
-                .unwrap_or_default();
-            format!("{head}</head><body{body_meta}>").into()
-        },
-        additional_context,
-    );
+    let (stream, runtime, scope) =
+        render_to_stream_with_prefix_undisposed_with_context(
+            app,
+            move |cx| {
+                let meta = use_context::<MetaContext>(cx);
+                let head = meta
+                    .as_ref()
+                    .map(|meta| meta.dehydrate())
+                    .unwrap_or_default();
+                let body_meta = meta
+                    .as_ref()
+                    .and_then(|meta| meta.body.as_string())
+                    .unwrap_or_default();
+                format!("{head}</head><body{body_meta}>").into()
+            },
+            additional_context,
+        );
 
     let cx = leptos::Scope { runtime, id: scope };
-    let (head, tail) = html_parts(options, use_context::<MetaContext>(cx).as_ref());
+    let (head, tail) =
+        html_parts(options, use_context::<MetaContext>(cx).as_ref());
 
     let mut stream = Box::pin(
         futures::stream::once(async move { head.clone() })
@@ -487,22 +534,19 @@ async fn stream_app(
             .map(|html| Ok(web::Bytes::from(html)) as Result<web::Bytes>),
     );
 
-    // Get the first, second, and third chunks in the stream, which renders the app shell, and thus allows Resources to run
+    // Get the first and second in the stream, which renders the app shell, and thus allows Resources to run
     let first_chunk = stream.next().await;
     let second_chunk = stream.next().await;
-    let third_chunk = stream.next().await;
 
     let res_options = res_options.0.read();
 
-    let (status, mut headers) = (res_options.status, res_options.headers.clone());
+    let (status, mut headers) =
+        (res_options.status, res_options.headers.clone());
     let status = status.unwrap_or_default();
 
-    let complete_stream = futures::stream::iter([
-        first_chunk.unwrap(),
-        second_chunk.unwrap(),
-        third_chunk.unwrap(),
-    ])
-    .chain(stream);
+    let complete_stream =
+        futures::stream::iter([first_chunk.unwrap(), second_chunk.unwrap()])
+            .chain(stream);
     let mut res = HttpResponse::Ok()
         .content_type("text/html")
         .streaming(complete_stream);
@@ -519,7 +563,10 @@ async fn stream_app(
     res
 }
 
-fn html_parts(options: &LeptosOptions, meta_context: Option<&MetaContext>) -> (String, String) {
+fn html_parts(
+    options: &LeptosOptions,
+    meta_context: Option<&MetaContext>,
+) -> (String, String) {
     // Because wasm-pack adds _bg to the end of the WASM filename, and we want to mantain compatibility with it's default options
     // we add _bg to the wasm files if cargo-leptos doesn't set the env var LEPTOS_OUTPUT_NAME
     // Otherwise we need to add _bg because wasm_pack always does. This is not the same as options.output_name, which is set regardless
@@ -529,7 +576,7 @@ fn html_parts(options: &LeptosOptions, meta_context: Option<&MetaContext>) -> (S
         wasm_output_name.push_str("_bg");
     }
 
-    let site_ip = &options.site_address.ip().to_string();
+    let site_ip = &options.site_addr.ip().to_string();
     let reload_port = options.reload_port;
     let pkg_path = &options.site_pkg_dir;
 
@@ -542,14 +589,15 @@ fn html_parts(options: &LeptosOptions, meta_context: Option<&MetaContext>) -> (S
                     let msg = JSON.parse(ev.data);
                     if (msg.all) window.location.reload();
                     if (msg.css) {{
-                        const link = document.querySelector("link#leptos");
-                        if (link) {{
-                            let href = link.getAttribute('href').split('?')[0];
-                            let newHref = href + '?version=' + new Date().getMilliseconds();
-                            link.setAttribute('href', newHref);
-                        }} else {{
-                            console.warn("Could not find link#leptos");
-                        }}
+                        let found = false;
+                        document.querySelectorAll("link").forEach((link) => {{
+                            if (link.getAttribute('href').includes(msg.css)) {{
+                                let newHref = '/' + msg.css + '?version=' + new Date().getMilliseconds();
+                                link.setAttribute('href', newHref);
+                                found = true;
+                            }}
+                        }});
+                        if (!found) console.warn(`CSS hot-reload: Could not find a <link href=/\"${{msg.css}}\"> element`);
                     }};
                 }};
                 ws.onclose = () => console.warn('Live-reload stopped. Manual reload necessary.');
@@ -583,7 +631,9 @@ fn html_parts(options: &LeptosOptions, meta_context: Option<&MetaContext>) -> (S
 /// Generates a list of all routes defined in Leptos's Router in your app. We can then use this to automatically
 /// create routes in Actix's App without having to use wildcard matching or fallbacks. Takes in your root app Element
 /// as an argument so it can walk you app tree. This version is tailored to generated Actix compatible paths.
-pub fn generate_route_list<IV>(app_fn: impl FnOnce(leptos::Scope) -> IV + 'static) -> Vec<String>
+pub fn generate_route_list<IV>(
+    app_fn: impl FnOnce(leptos::Scope) -> IV + 'static,
+) -> Vec<String>
 where
     IV: IntoView + 'static,
 {
@@ -663,7 +713,12 @@ pub trait LeptosRoutes {
 /// to those paths to Leptos's renderer.
 impl<T> LeptosRoutes for actix_web::App<T>
 where
-    T: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>,
+    T: ServiceFactory<
+        ServiceRequest,
+        Config = (),
+        Error = Error,
+        InitError = (),
+    >,
 {
     fn leptos_routes<IV>(
         self,
@@ -676,7 +731,10 @@ where
     {
         let mut router = self;
         for path in paths.iter() {
-            router = router.route(path, render_app_to_stream(options.clone(), app_fn.clone()));
+            router = router.route(
+                path,
+                render_app_to_stream(options.clone(), app_fn.clone()),
+            );
         }
         router
     }
@@ -698,7 +756,11 @@ where
         for path in paths.iter() {
             router = router.route(
                 path,
-                render_preloaded_data_app(options.clone(), data_fn.clone(), app_fn.clone()),
+                render_preloaded_data_app(
+                    options.clone(),
+                    data_fn.clone(),
+                    app_fn.clone(),
+                ),
             );
         }
         router

integrations/axum/src/lib.rs

@@ -9,19 +9,25 @@
 use axum::{
     body::{Body, Bytes, Full, StreamBody},
     extract::Path,
-    http::{header::HeaderName, header::HeaderValue, HeaderMap, Request, StatusCode},
+    http::{
+        header::{HeaderName, HeaderValue},
+        HeaderMap, Request, StatusCode,
+    },
     response::IntoResponse,
     routing::get,
 };
 use futures::{Future, SinkExt, Stream, StreamExt};
 use http::{header, method::Method, uri::Uri, version::Version, Response};
 use hyper::body;
-use leptos::*;
+use leptos::{
+    leptos_server::{server_fn_by_path, Payload},
+    *,
+};
 use leptos_meta::MetaContext;
 use leptos_router::*;
 use parking_lot::RwLock;
 use std::{io, pin::Pin, sync::Arc};
-use tokio::{task::spawn_blocking, task::LocalSet};
+use tokio::task::{spawn_blocking, LocalSet};
 
 /// A struct to hold the parts of the incoming Request. Since `http::Request` isn't cloneable, we're forced
 /// to construct this for Leptos to use in Axum
@@ -88,12 +94,14 @@ impl ResponseOptions {
 /// it sets a StatusCode of 302 and a LOCATION header with the provided value.
 /// If looking to redirect from the client, `leptos_router::use_navigate()` should be used instead
 pub fn redirect(cx: leptos::Scope, path: &str) {
-    let response_options = use_context::<ResponseOptions>(cx).unwrap();
-    response_options.set_status(StatusCode::FOUND);
-    response_options.insert_header(
-        header::LOCATION,
-        header::HeaderValue::from_str(path).expect("Failed to create HeaderValue"),
-    );
+    if let Some(response_options) = use_context::<ResponseOptions>(cx) {
+        response_options.set_status(StatusCode::FOUND);
+        response_options.insert_header(
+            header::LOCATION,
+            header::HeaderValue::from_str(path)
+                .expect("Failed to create HeaderValue"),
+        );
+    }
 }
 
 /// Decomposes an HTTP request into its parts, allowing you to read its headers
@@ -118,8 +126,8 @@ pub async fn generate_request_parts(req: Request<Body>) -> RequestParts {
 ///
 /// ```
 /// use axum::{handler::Handler, routing::post, Router};
-/// use std::net::SocketAddr;
 /// use leptos::*;
+/// use std::net::SocketAddr;
 ///
 /// # if false { // don't actually try to run a server in a doctest...
 /// #[tokio::main]
@@ -128,7 +136,7 @@ pub async fn generate_request_parts(req: Request<Body>) -> RequestParts {
 ///
 ///     // build our application with a route
 ///     let app = Router::new()
-///       .route("/api/*fn_name", post(leptos_axum::handle_server_fns));
+///         .route("/api/*fn_name", post(leptos_axum::handle_server_fns));
 ///
 ///     // run our app with hyper
 ///     // `axum::Server` is a re-export of `hyper::Server`
@@ -196,9 +204,12 @@ async fn handle_server_fns_inner(
                 .expect("couldn't spawn runtime")
                 .block_on({
                     async move {
-                        let res = if let Some(server_fn) = server_fn_by_path(fn_name.as_str()) {
+                        let res = if let Some(server_fn) =
+                            server_fn_by_path(fn_name.as_str())
+                        {
                             let runtime = create_runtime();
-                            let (cx, disposer) = raw_scope_and_disposer(runtime);
+                            let (cx, disposer) =
+                                raw_scope_and_disposer(runtime);
 
                             additional_context(cx);
 
@@ -211,34 +222,43 @@ async fn handle_server_fns_inner(
                             match server_fn(cx, &req_parts.body).await {
                                 Ok(serialized) => {
                                     // If ResponseOptions are set, add the headers and status to the request
-                                    let res_options = use_context::<ResponseOptions>(cx);
+                                    let res_options =
+                                        use_context::<ResponseOptions>(cx);
 
                                     // clean up the scope, which we only needed to run the server fn
                                     disposer.dispose();
                                     runtime.dispose();
 
                                     // if this is Accept: application/json then send a serialized JSON response
-                                    let accept_header =
-                                        headers.get("Accept").and_then(|value| value.to_str().ok());
+                                    let accept_header = headers
+                                        .get("Accept")
+                                        .and_then(|value| value.to_str().ok());
                                     let mut res = Response::builder();
 
                                     // Add headers from ResponseParts if they exist. These should be added as long
                                     // as the server function returns an OK response
-                                    let res_options_outer = res_options.unwrap().0;
-                                    let res_options_inner = res_options_outer.read();
+                                    let res_options_outer =
+                                        res_options.unwrap().0;
+                                    let res_options_inner =
+                                        res_options_outer.read();
                                     let (status, mut res_headers) = (
                                         res_options_inner.status,
                                         res_options_inner.headers.clone(),
                                     );
 
-                                    if let Some(header_ref) = res.headers_mut() {
-                                           header_ref.extend(res_headers.drain());
+                                    if let Some(header_ref) = res.headers_mut()
+                                    {
+                                        header_ref.extend(res_headers.drain());
                                     };
 
                                     if accept_header == Some("application/json")
                                         || accept_header
-                                            == Some("application/x-www-form-urlencoded")
-                                        || accept_header == Some("application/cbor")
+                                            == Some(
+                                                "application/\
+                                                 x-www-form-urlencoded",
+                                            )
+                                        || accept_header
+                                            == Some("application/cbor")
                                     {
                                         res = res.status(StatusCode::OK);
                                     }
@@ -246,7 +266,9 @@ async fn handle_server_fns_inner(
                                     else {
                                         let referer = headers
                                             .get("Referer")
-                                            .and_then(|value| value.to_str().ok())
+                                            .and_then(|value| {
+                                                value.to_str().ok()
+                                            })
                                             .unwrap_or("/");
 
                                         res = res
@@ -260,16 +282,23 @@ async fn handle_server_fns_inner(
                                     };
                                     match serialized {
                                         Payload::Binary(data) => res
-                                            .header("Content-Type", "application/cbor")
+                                            .header(
+                                                "Content-Type",
+                                                "application/cbor",
+                                            )
                                             .body(Full::from(data)),
                                         Payload::Url(data) => res
                                             .header(
                                                 "Content-Type",
-                                                "application/x-www-form-urlencoded",
+                                                "application/\
+                                                 x-www-form-urlencoded",
                                             )
                                             .body(Full::from(data)),
                                         Payload::Json(data) => res
-                                            .header("Content-Type", "application/json")
+                                            .header(
+                                                "Content-Type",
+                                                "application/json",
+                                            )
                                             .body(Full::from(data)),
                                     }
                                 }
@@ -280,11 +309,13 @@ async fn handle_server_fns_inner(
                         } else {
                             Response::builder()
                                 .status(StatusCode::BAD_REQUEST)
-                                .body(Full::from(
-                                    format!("Could not find a server function at the route {fn_name}. \
-                                    \n\nIt's likely that you need to call ServerFn::register() on the \
-                                    server function type, somewhere in your `main` function." )
-                                ))
+                                .body(Full::from(format!(
+                                    "Could not find a server function at the \
+                                     route {fn_name}. \n\nIt's likely that \
+                                     you need to call ServerFn::register() on \
+                                     the server function type, somewhere in \
+                                     your `main` function."
+                                )))
                         }
                         .expect("could not build Response");
 
@@ -297,7 +328,8 @@ async fn handle_server_fns_inner(
     rx.await.unwrap()
 }
 
-pub type PinnedHtmlStream = Pin<Box<dyn Stream<Item = io::Result<Bytes>> + Send>>;
+pub type PinnedHtmlStream =
+    Pin<Box<dyn Stream<Item = io::Result<Bytes>> + Send>>;
 
 /// Returns an Axum [Handler](axum::handler::Handler) that listens for a `GET` request and tries
 /// to route it using [leptos_router], serving an HTML stream of your application.
@@ -310,28 +342,28 @@ pub type PinnedHtmlStream = Pin<Box<dyn Stream<Item = io::Result<Bytes>> + Send>
 ///
 /// This can then be set up at an appropriate route in your application:
 /// ```
-/// use axum::handler::Handler;
-/// use axum::Router;
-/// use std::{net::SocketAddr, env};
+/// use axum::{handler::Handler, Router};
 /// use leptos::*;
 /// use leptos_config::get_configuration;
+/// use std::{env, net::SocketAddr};
 ///
 /// #[component]
 /// fn MyApp(cx: Scope) -> impl IntoView {
-///   view! { cx, <main>"Hello, world!"</main> }
+///     view! { cx, <main>"Hello, world!"</main> }
 /// }
 ///
 /// # if false { // don't actually try to run a server in a doctest...
 /// #[tokio::main]
 /// async fn main() {
-///     
 ///     let conf = get_configuration(Some("Cargo.toml")).await.unwrap();
 ///     let leptos_options = conf.leptos_options;
-///     let addr = leptos_options.site_address.clone();
-///     
+///     let addr = leptos_options.site_addr.clone();
+///
 ///     // build our application with a route
-///     let app = Router::new()
-///     .fallback(leptos_axum::render_app_to_stream(leptos_options, |cx| view! { cx, <MyApp/> }));
+///     let app = Router::new().fallback(leptos_axum::render_app_to_stream(
+///         leptos_options,
+///         |cx| view! { cx, <MyApp/> },
+///     ));
 ///
 ///     // run our app with hyper
 ///     // `axum::Server` is a re-export of `hyper::Server`
@@ -354,8 +386,13 @@ pub fn render_app_to_stream<IV>(
     app_fn: impl Fn(leptos::Scope) -> IV + Clone + Send + 'static,
 ) -> impl Fn(
     Request<Body>,
-) -> Pin<Box<dyn Future<Output = Response<StreamBody<PinnedHtmlStream>>> + Send + 'static>>
-       + Clone
+) -> Pin<
+    Box<
+        dyn Future<Output = Response<StreamBody<PinnedHtmlStream>>>
+            + Send
+            + 'static,
+    >,
+> + Clone
        + Send
        + 'static
 where
@@ -395,8 +432,13 @@ pub fn render_app_to_stream_with_context<IV>(
     app_fn: impl Fn(leptos::Scope) -> IV + Clone + Send + 'static,
 ) -> impl Fn(
     Request<Body>,
-) -> Pin<Box<dyn Future<Output = Response<StreamBody<PinnedHtmlStream>>> + Send + 'static>>
-       + Clone
+) -> Pin<
+    Box<
+        dyn Future<Output = Response<StreamBody<PinnedHtmlStream>>>
+            + Send
+            + 'static,
+    >,
+> + Clone
        + Send
        + 'static
 where
@@ -453,7 +495,7 @@ where
                                             };
 
                                             let (bundle, runtime, scope) =
-                                                render_to_stream_with_prefix_undisposed_with_context(
+                                                leptos::leptos_dom::ssr::render_to_stream_with_prefix_undisposed_with_context(
                                                     app,
                                                     |cx| {
                                                         let head = use_context::<MetaContext>(cx)
@@ -495,10 +537,9 @@ where
 
                 let mut stream = Box::pin(rx.map(|html| Ok(Bytes::from(html))));
 
-                // Get the first, second, and third chunks in the stream, which renders the app shell, and thus allows Resources to run
+                // Get the first and second chunks in the stream, which renders the app shell, and thus allows Resources to run
                 let first_chunk = stream.next().await;
                 let second_chunk = stream.next().await;
-                let third_chunk = stream.next().await;
 
                 // Extract the resources now that they've been rendered
                 let res_options = res_options3.0.read();
@@ -506,13 +547,13 @@ where
                 let complete_stream = futures::stream::iter([
                     first_chunk.unwrap(),
                     second_chunk.unwrap(),
-                    third_chunk.unwrap(),
                 ])
                 .chain(stream);
 
-                let mut res = Response::new(StreamBody::new(
-                    Box::pin(complete_stream) as PinnedHtmlStream
-                ));
+                let mut res = Response::new(StreamBody::new(Box::pin(
+                    complete_stream,
+                )
+                    as PinnedHtmlStream));
 
                 if let Some(status) = res_options.status {
                     *res.status_mut() = status
@@ -526,7 +567,10 @@ where
     }
 }
 
-fn html_parts(options: &LeptosOptions, meta: Option<&MetaContext>) -> (String, &'static str) {
+fn html_parts(
+    options: &LeptosOptions,
+    meta: Option<&MetaContext>,
+) -> (String, &'static str) {
     let pkg_path = &options.site_pkg_dir;
     let output_name = &options.output_name;
 
@@ -538,7 +582,7 @@ fn html_parts(options: &LeptosOptions, meta: Option<&MetaContext>) -> (String, &
         wasm_output_name.push_str("_bg");
     }
 
-    let site_ip = &options.site_address.ip().to_string();
+    let site_ip = &options.site_addr.ip().to_string();
     let reload_port = options.reload_port;
 
     let leptos_autoreload = match std::env::var("LEPTOS_WATCH").is_ok() {
@@ -550,14 +594,15 @@ fn html_parts(options: &LeptosOptions, meta: Option<&MetaContext>) -> (String, &
                         let msg = JSON.parse(ev.data);
                         if (msg.all) window.location.reload();
                         if (msg.css) {{
-                            const link = document.querySelector("link#leptos");
-                            if (link) {{
-                                let href = link.getAttribute('href').split('?')[0];
-                                let newHref = href + '?version=' + new Date().getMilliseconds();
-                                link.setAttribute('href', newHref);
-                            }} else {{
-                                console.warn("Could not find link#leptos");
-                            }}
+                            let found = false;
+                            document.querySelectorAll("link").forEach((link) => {{
+                                if (link.getAttribute('href').includes(msg.css)) {{
+                                    let newHref = '/' + href + '?version=' + new Date().getMilliseconds();
+                                    link.setAttribute('href', newHref);
+                                    found = true;
+                                }}
+                            }});
+                            if (!found) console.warn(`CSS hot-reload: Could not find a <link href=/\"${{msg.css}}\"> element`);
                         }};
                     }};
                     ws.onclose = () => console.warn('Live-reload stopped. Manual reload necessary.');
@@ -568,7 +613,8 @@ fn html_parts(options: &LeptosOptions, meta: Option<&MetaContext>) -> (String, &
         false => "".to_string(),
     };
 
-    let html_metadata = meta.and_then(|mc| mc.html.as_string()).unwrap_or_default();
+    let html_metadata =
+        meta.and_then(|mc| mc.html.as_string()).unwrap_or_default();
     let head = format!(
         r#"<!DOCTYPE html>
             <html{html_metadata}>
@@ -588,7 +634,9 @@ fn html_parts(options: &LeptosOptions, meta: Option<&MetaContext>) -> (String, &
 /// Generates a list of all routes defined in Leptos's Router in your app. We can then use this to automatically
 /// create routes in Axum's Router without having to use wildcard matching or fallbacks. Takes in your root app Element
 /// as an argument so it can walk you app tree. This version is tailored to generate Axum compatible paths.
-pub async fn generate_route_list<IV>(app_fn: impl FnOnce(Scope) -> IV + 'static) -> Vec<String>
+pub async fn generate_route_list<IV>(
+    app_fn: impl FnOnce(Scope) -> IV + 'static,
+) -> Vec<String>
 where
     IV: IntoView + 'static,
 {
@@ -649,7 +697,11 @@ pub trait LeptosRoutes {
     where
         IV: IntoView + 'static;
 
-    fn leptos_routes_with_handler<H, T>(self, paths: Vec<String>, handler: H) -> Self
+    fn leptos_routes_with_handler<H, T>(
+        self,
+        paths: Vec<String>,
+        handler: H,
+    ) -> Self
     where
         H: axum::handler::Handler<T, (), axum::body::Body>,
         T: 'static;
@@ -700,7 +752,11 @@ impl LeptosRoutes for axum::Router {
         router
     }
 
-    fn leptos_routes_with_handler<H, T>(self, paths: Vec<String>, handler: H) -> Self
+    fn leptos_routes_with_handler<H, T>(
+        self,
+        paths: Vec<String>,
+        handler: H,
+    ) -> Self
     where
         H: axum::handler::Handler<T, (), axum::body::Body>,
         T: 'static,

leptos/Makefile.toml

@@ -0,0 +1,21 @@
+[tasks.build-wasm]
+clear = true
+dependencies = ["build-hydrate", "build-csr"]
+
+[tasks.build-hydrate]
+command = "cargo"
+args = [
+	"build",
+	"--no-default-features",
+	"--features=hydrate",
+	"--target=wasm32-unknown-unknown",
+]
+
+[tasks.build-csr]
+command = "cargo"
+args = [
+	"build",
+	"--no-default-features",
+	"--features=csr",
+	"--target=wasm32-unknown-unknown",
+]

leptos/src/error_boundary.rs

@@ -1,6 +1,6 @@
 use crate::Children;
 use leptos_dom::{Errors, IntoView};
-use leptos_macro::component;
+use leptos_macro::{component, view};
 use leptos_reactive::{create_rw_signal, provide_context, RwSignal, Scope};
 
 /// When you render a `Result<_, _>` in your view, in the `Err` case it will
@@ -45,8 +45,16 @@ where
     // Run children so that they render and execute resources
     let children = children(cx);
 
-    move || match errors.get().0.is_empty() {
-        true => children.clone().into_view(cx),
-        false => fallback(cx, errors).into_view(cx),
+    move || {
+        match errors.with(Errors::is_empty) {
+            true => children.clone().into_view(cx),
+            false => view! { cx,
+                <>
+                    {fallback(cx, errors)}
+                    <leptos-error-boundary style="display: none">{children.clone()}</leptos-error-boundary>
+                </>
+            }
+            .into_view(cx),
+        }
     }
 }

leptos/src/for_loop.rs

@@ -30,7 +30,7 @@ use std::hash::Hash;
 ///         // a unique key for each item
 ///         key=|counter| counter.id
 ///         // renders each item to a view
-///         view=move |counter: Counter| {
+///         view=move |cx, counter: Counter| {
 ///           view! {
 ///             cx,
 ///             <button>"Value: " {move || counter.count.get()}</button>
@@ -54,7 +54,7 @@ pub fn For<IF, I, T, EF, N, KF, K>(
 where
     IF: Fn() -> I + 'static,
     I: IntoIterator<Item = T>,
-    EF: Fn(T) -> N + 'static,
+    EF: Fn(Scope, T) -> N + 'static,
     N: IntoView,
     KF: Fn(&T) -> K + 'static,
     K: Eq + Hash + 'static,

leptos/src/lib.rs

@@ -34,6 +34,8 @@
 //!   communication via contexts, and the `<For/>` component for efficient keyed list updates.
 //! - [`counters_stable`](https://github.com/leptos-rs/leptos/tree/main/examples/counters_stable) adapts the `counters` example
 //!   to show how to use Leptos with `stable` Rust.
+//! - [`error_boundary`](https://github.com/leptos-rs/leptos/tree/main/examples/error_boundary) shows how to use
+//!   `Result` types to handle errors.
 //! - [`parent_child`](https://github.com/leptos-rs/leptos/tree/main/examples/parent_child) shows four different
 //!   ways a parent component can communicate with a child, including passing a closure, context, and more
 //! - [`todomvc`](https://github.com/leptos-rs/leptos/tree/main/examples/todomvc) implements the classic to-do
@@ -130,7 +132,7 @@
 //!
 //! #[component]
 //! fn SimpleCounter(cx: Scope, initial_value: i32) -> impl IntoView {
-//!   todo!()
+//!     todo!()
 //! }
 //!
 //! pub fn main() {
@@ -139,16 +141,29 @@
 //! # }
 //! ```
 
-pub use leptos_config::*;
-pub use leptos_dom;
-pub use leptos_dom::wasm_bindgen::{JsCast, UnwrapThrowExt};
-pub use leptos_dom::*;
+pub use leptos_config::{self, get_configuration, LeptosOptions};
+#[cfg(not(all(
+    target_arch = "wasm32",
+    any(feature = "csr", feature = "hydrate")
+)))]
+pub use leptos_dom::ssr::{self, render_to_string};
+pub use leptos_dom::{
+    self, create_node_ref, debug_warn, document, error, ev,
+    helpers::{
+        event_target, event_target_checked, event_target_value,
+        request_animation_frame, request_idle_callback, set_interval,
+        set_timeout, window_event_listener,
+    },
+    html, log, math, mount_to, mount_to_body, svg, warn, window, Attribute,
+    Class, Errors, Fragment, HtmlElement, IntoAttribute, IntoClass,
+    IntoProperty, IntoView, NodeRef, Property, View,
+};
 pub use leptos_macro::*;
 pub use leptos_reactive::*;
-pub use leptos_server;
-pub use leptos_server::*;
-
-pub use tracing;
+pub use leptos_server::{
+    self, create_action, create_multi_action, create_server_action,
+    create_server_multi_action, Action, MultiAction, ServerFn, ServerFnError,
+};
 pub use typed_builder;
 mod error_boundary;
 pub use error_boundary::*;
@@ -159,10 +174,11 @@ pub use show::*;
 mod suspense;
 pub use suspense::*;
 mod transition;
+#[cfg(debug_assertions)]
+#[doc(hidden)]
+pub use tracing;
 pub use transition::*;
 
-pub use leptos_reactive::debug_warn;
-
 extern crate self as leptos;
 
 /// The most common type for the `children` property on components,
@@ -176,3 +192,22 @@ pub type ChildrenFn = Box<dyn Fn(Scope) -> Fragment>;
 /// A type for the `children` property on components that can be called
 /// more than once, but may mutate the children.
 pub type ChildrenFnMut = Box<dyn FnMut(Scope) -> Fragment>;
+
+/// A type for taking anything that implements [`IntoAttribute`].
+///
+/// ```rust
+/// use leptos::*;
+///
+/// #[component]
+/// pub fn MyHeading(
+///     cx: Scope,
+///     text: String,
+///     #[prop(optional, into)] class: Option<AttributeValue>,
+/// ) -> impl IntoView {
+///     view! {
+///       cx,
+///       <h1 class=class>{text}</h1>
+///     }
+/// }
+/// ```
+pub type AttributeValue = Box<dyn IntoAttribute>;

leptos/src/suspense.rs

@@ -1,6 +1,5 @@
 use cfg_if::cfg_if;
-use leptos_dom::HydrationCtx;
-use leptos_dom::{DynChild, Fragment, IntoView};
+use leptos_dom::{DynChild, Fragment, HydrationCtx, IntoView};
 use leptos_macro::component;
 use leptos_reactive::{provide_context, Scope, SuspenseContext};
 use std::rc::Rc;
@@ -92,7 +91,7 @@ where
                     let initial = {
                         // no resources were read under this, so just return the child
                         if context.pending_resources.get() == 0 {
-                            child.clone()
+                            child
                         }
                         // show the fallback, but also prepare to stream HTML
                         else {

leptos/src/transition.rs

@@ -19,7 +19,9 @@ use std::{cell::RefCell, rc::Rc};
 /// # use leptos::*;
 /// # if false {
 /// # run_scope(create_runtime(), |cx| {
-/// async fn fetch_cats(how_many: u32) -> Option<Vec<String>> { Some(vec![]) }
+/// async fn fetch_cats(how_many: u32) -> Option<Vec<String>> {
+///     Some(vec![])
+/// }
 ///
 /// let (cat_count, set_cat_count) = create_signal::<u32>(cx, 1);
 /// let (pending, set_pending) = create_signal(cx, false);

leptos/tests/ssr.rs

@@ -16,7 +16,11 @@ fn simple_ssr_test() {
 
         assert_eq!(
             rendered.into_view(cx).render_to_string(cx),
-            "<div id=\"_0-1\"><button id=\"_0-2\">-1</button><span id=\"_0-3\">Value: <!--hk=_0-4o|leptos-dyn-child-start-->0<!--hk=_0-4c|leptos-dyn-child-end-->!</span><button id=\"_0-5\">+1</button></div>"
+            "<div id=\"_0-1\"><button id=\"_0-2\">-1</button><span \
+             id=\"_0-3\">Value: \
+             <!--hk=_0-4o|leptos-dyn-child-start-->0<!\
+             --hk=_0-4c|leptos-dyn-child-end-->!</span><button \
+             id=\"_0-5\">+1</button></div>"
         );
     });
 }
@@ -50,7 +54,21 @@ fn ssr_test_with_components() {
 
         assert_eq!(
             rendered.into_view(cx).render_to_string(cx),
-            "<div id=\"_0-1\" class=\"counters\"><!--hk=_0-1-0o|leptos-counter-start--><div id=\"_0-1-1\"><button id=\"_0-1-2\">-1</button><span id=\"_0-1-3\">Value: <!--hk=_0-1-4o|leptos-dyn-child-start-->1<!--hk=_0-1-4c|leptos-dyn-child-end-->!</span><button id=\"_0-1-5\">+1</button></div><!--hk=_0-1-0c|leptos-counter-end--><!--hk=_0-1-5-0o|leptos-counter-start--><div id=\"_0-1-5-1\"><button id=\"_0-1-5-2\">-1</button><span id=\"_0-1-5-3\">Value: <!--hk=_0-1-5-4o|leptos-dyn-child-start-->2<!--hk=_0-1-5-4c|leptos-dyn-child-end-->!</span><button id=\"_0-1-5-5\">+1</button></div><!--hk=_0-1-5-0c|leptos-counter-end--></div>"
+            "<div id=\"_0-1\" \
+             class=\"counters\"><!--hk=_0-1-0o|leptos-counter-start--><div \
+             id=\"_0-1-1\"><button id=\"_0-1-2\">-1</button><span \
+             id=\"_0-1-3\">Value: \
+             <!--hk=_0-1-4o|leptos-dyn-child-start-->1<!\
+             --hk=_0-1-4c|leptos-dyn-child-end-->!</span><button \
+             id=\"_0-1-5\">+1</button></div><!\
+             --hk=_0-1-0c|leptos-counter-end--><!\
+             --hk=_0-1-5-0o|leptos-counter-start--><div \
+             id=\"_0-1-5-1\"><button id=\"_0-1-5-2\">-1</button><span \
+             id=\"_0-1-5-3\">Value: \
+             <!--hk=_0-1-5-4o|leptos-dyn-child-start-->2<!\
+             --hk=_0-1-5-4c|leptos-dyn-child-end-->!</span><button \
+             id=\"_0-1-5-5\">+1</button></div><!\
+             --hk=_0-1-5-0c|leptos-counter-end--></div>"
         );
     });
 }
@@ -84,7 +102,22 @@ fn ssr_test_with_snake_case_components() {
 
         assert_eq!(
             rendered.into_view(cx).render_to_string(cx),
-            "<div id=\"_0-1\" class=\"counters\"><!--hk=_0-1-0o|leptos-snake-case-counter-start--><div id=\"_0-1-1\"><button id=\"_0-1-2\">-1</button><span id=\"_0-1-3\">Value: <!--hk=_0-1-4o|leptos-dyn-child-start-->1<!--hk=_0-1-4c|leptos-dyn-child-end-->!</span><button id=\"_0-1-5\">+1</button></div><!--hk=_0-1-0c|leptos-snake-case-counter-end--><!--hk=_0-1-5-0o|leptos-snake-case-counter-start--><div id=\"_0-1-5-1\"><button id=\"_0-1-5-2\">-1</button><span id=\"_0-1-5-3\">Value: <!--hk=_0-1-5-4o|leptos-dyn-child-start-->2<!--hk=_0-1-5-4c|leptos-dyn-child-end-->!</span><button id=\"_0-1-5-5\">+1</button></div><!--hk=_0-1-5-0c|leptos-snake-case-counter-end--></div>"
+            "<div id=\"_0-1\" \
+             class=\"counters\"><!\
+             --hk=_0-1-0o|leptos-snake-case-counter-start--><div \
+             id=\"_0-1-1\"><button id=\"_0-1-2\">-1</button><span \
+             id=\"_0-1-3\">Value: \
+             <!--hk=_0-1-4o|leptos-dyn-child-start-->1<!\
+             --hk=_0-1-4c|leptos-dyn-child-end-->!</span><button \
+             id=\"_0-1-5\">+1</button></div><!\
+             --hk=_0-1-0c|leptos-snake-case-counter-end--><!\
+             --hk=_0-1-5-0o|leptos-snake-case-counter-start--><div \
+             id=\"_0-1-5-1\"><button id=\"_0-1-5-2\">-1</button><span \
+             id=\"_0-1-5-3\">Value: \
+             <!--hk=_0-1-5-4o|leptos-dyn-child-start-->2<!\
+             --hk=_0-1-5-4c|leptos-dyn-child-end-->!</span><button \
+             id=\"_0-1-5-5\">+1</button></div><!\
+             --hk=_0-1-5-0c|leptos-snake-case-counter-end--></div>"
         );
     });
 }
@@ -125,7 +158,8 @@ fn ssr_with_styles() {
 
         assert_eq!(
             rendered.into_view(cx).render_to_string(cx),
-            "<div id=\"_0-1\" class=\" myclass\"><button id=\"_0-2\" class=\"btn myclass\">-1</button></div>"
+            "<div id=\"_0-1\" class=\" myclass\"><button id=\"_0-2\" \
+             class=\"btn myclass\">-1</button></div>"
         );
     });
 }

leptos_config/src/errors.rs

@@ -1,5 +1,4 @@
 use std::{net::AddrParseError, num::ParseIntError};
-
 use thiserror::Error;
 
 #[derive(Debug, Error, Clone)]

leptos_config/src/lib.rs

@@ -5,9 +5,7 @@ pub mod errors;
 use crate::errors::LeptosConfigError;
 use config::{Config, File, FileFormat};
 use regex::Regex;
-use std::convert::TryFrom;
-use std::fs;
-use std::{env::VarError, net::SocketAddr, str::FromStr};
+use std::{convert::TryFrom, env::VarError, fs, net::SocketAddr, str::FromStr};
 use typed_builder::TypedBuilder;
 
 /// A Struct to allow us to parse LeptosOptions from the file. Not really needed, most interactions should
@@ -43,7 +41,7 @@ pub struct LeptosOptions {
     /// Using an env variable here would allow you to run the same code in dev and prod
     /// Defaults to `127.0.0.1:3000`
     #[builder(setter(into), default=SocketAddr::from(([127,0,0,1], 3000)))]
-    pub site_address: SocketAddr,
+    pub site_addr: SocketAddr,
     /// The port the Websocket watcher listens on. Should match the `reload_port` in cargo-leptos(if using).
     /// Defaults to `3001`
     #[builder(default = 3001)]
@@ -53,18 +51,26 @@ pub struct LeptosOptions {
 impl LeptosOptions {
     fn try_from_env() -> Result<Self, LeptosConfigError> {
         Ok(LeptosOptions {
-            output_name: std::env::var("LEPTOS_OUTPUT_NAME")
-                .map_err(|e| LeptosConfigError::EnvVarError(format!("LEPTOS_OUTPUT_NAME: {e}")))?,
+            output_name: std::env::var("LEPTOS_OUTPUT_NAME").map_err(|e| {
+                LeptosConfigError::EnvVarError(format!(
+                    "LEPTOS_OUTPUT_NAME: {e}"
+                ))
+            })?,
             site_root: env_w_default("LEPTOS_SITE_ROOT", "target/site")?,
             site_pkg_dir: env_w_default("LEPTOS_SITE_PKG_DIR", "pkg")?,
             env: Env::default(),
-            site_address: env_w_default("LEPTOS_SITE_ADDR", "127.0.0.1:3000")?.parse()?,
-            reload_port: env_w_default("LEPTOS_RELOAD_PORT", "3001")?.parse()?,
+            site_addr: env_w_default("LEPTOS_SITE_ADDR", "127.0.0.1:3000")?
+                .parse()?,
+            reload_port: env_w_default("LEPTOS_RELOAD_PORT", "3001")?
+                .parse()?,
         })
     }
 }
 
-fn env_w_default(key: &str, default: &str) -> Result<String, LeptosConfigError> {
+fn env_w_default(
+    key: &str,
+    default: &str,
+) -> Result<String, LeptosConfigError> {
     match std::env::var(key) {
         Ok(val) => Ok(val),
         Err(VarError::NotPresent) => Ok(default.to_string()),
@@ -93,7 +99,8 @@ fn from_str(input: &str) -> Result<Env, String> {
         "dev" | "development" => Ok(Env::DEV),
         "prod" | "production" => Ok(Env::PROD),
         _ => Err(format!(
-            "{input} is not a supported environment. Use either `dev` or `production`.",
+            "{input} is not a supported environment. Use either `dev` or \
+             `production`.",
         )),
     }
 }
@@ -132,11 +139,15 @@ impl TryFrom<String> for Env {
 /// you'll need to set the options as environment variables or rely on the defaults. This is the preferred
 /// approach for cargo-leptos. If Some("./Cargo.toml") is provided, Leptos will read in the settings itself. This
 /// option currently does not allow dashes in file or foldernames, as all dashes become underscores
-pub async fn get_configuration(path: Option<&str>) -> Result<ConfFile, LeptosConfigError> {
+pub async fn get_configuration(
+    path: Option<&str>,
+) -> Result<ConfFile, LeptosConfigError> {
     if let Some(path) = path {
-        let text = fs::read_to_string(path).map_err(|_| LeptosConfigError::ConfigNotFound)?;
+        let text = fs::read_to_string(path)
+            .map_err(|_| LeptosConfigError::ConfigNotFound)?;
 
-        let re: Regex = Regex::new(r#"(?m)^\[package.metadata.leptos\]"#).unwrap();
+        let re: Regex =
+            Regex::new(r#"(?m)^\[package.metadata.leptos\]"#).unwrap();
         let start = match re.find(&text) {
             Some(found) => found.start(),
             None => return Err(LeptosConfigError::ConfigSectionNotFound),
@@ -154,7 +165,9 @@ pub async fn get_configuration(path: Option<&str>) -> Result<ConfFile, LeptosCon
             // Layer on the environment-specific values.
             // Add in settings from environment variables (with a prefix of LEPTOS and '_' as separator)
             // E.g. `LEPTOS_RELOAD_PORT=5001 would set `LeptosOptions.reload_port`
-            .add_source(config::Environment::with_prefix("LEPTOS").separator("_"))
+            .add_source(
+                config::Environment::with_prefix("LEPTOS").separator("_"),
+            )
             .build()?;
 
         settings

leptos_dom/examples/test-bench/src/main.rs

@@ -32,7 +32,7 @@ fn view_fn(cx: Scope) -> impl IntoView {
    <For
      each=|| vec![0, 1, 2, 3, 4, 5, 6, 7]
      key=|i| *i
-     view=|i| view! { cx, {i} }
+     view=|cx, i| view! { cx, {i} }
      />
   }
   .into_view(cx);

leptos_dom/rustfmt.toml

@@ -1,4 +0,0 @@
-max_width = 80
-imports_granularity = "Crate"
-tab_spaces = 2
-format_strings = true

leptos_dom/src/components.rs

@@ -5,8 +5,8 @@ mod fragment;
 mod unit;
 
 use crate::{
-  hydration::{HydrationCtx, HydrationKey},
-  Comment, IntoView, View,
+    hydration::{HydrationCtx, HydrationKey},
+    Comment, IntoView, View,
 };
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
 use crate::{mount_child, prepare_to_move, MountKind, Mountable};
@@ -28,231 +28,234 @@ use wasm_bindgen::JsCast;
 #[derive(educe::Educe)]
 #[educe(Default, Clone, PartialEq, Eq)]
 pub enum CoreComponent {
-  /// The [Unit] component.
-  #[educe(Default)]
-  Unit(UnitRepr),
-  /// The [DynChild] component.
-  DynChild(DynChildRepr),
-  /// The [Each] component.
-  Each(EachRepr),
+    /// The [Unit] component.
+    #[educe(Default)]
+    Unit(UnitRepr),
+    /// The [DynChild] component.
+    DynChild(DynChildRepr),
+    /// The [Each] component.
+    Each(EachRepr),
 }
 
 impl fmt::Debug for CoreComponent {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    match self {
-      Self::Unit(u) => u.fmt(f),
-      Self::DynChild(dc) => dc.fmt(f),
-      Self::Each(e) => e.fmt(f),
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Unit(u) => u.fmt(f),
+            Self::DynChild(dc) => dc.fmt(f),
+            Self::Each(e) => e.fmt(f),
+        }
     }
-  }
 }
 
 /// Custom leptos component.
 #[derive(Clone, PartialEq, Eq)]
 pub struct ComponentRepr {
-  #[cfg(all(target_arch = "wasm32", feature = "web"))]
-  pub(crate) document_fragment: web_sys::DocumentFragment,
-  #[cfg(all(target_arch = "wasm32", feature = "web"))]
-  mounted: Rc<OnceCell<()>>,
-  #[cfg(debug_assertions)]
-  pub(crate) name: Cow<'static, str>,
-  #[cfg(debug_assertions)]
-  _opening: Comment,
-  /// The children of the component.
-  pub children: Vec<View>,
-  closing: Comment,
-  #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-  pub(crate) id: HydrationKey,
+    #[cfg(all(target_arch = "wasm32", feature = "web"))]
+    pub(crate) document_fragment: web_sys::DocumentFragment,
+    #[cfg(all(target_arch = "wasm32", feature = "web"))]
+    mounted: Rc<OnceCell<()>>,
+    #[cfg(debug_assertions)]
+    pub(crate) name: Cow<'static, str>,
+    #[cfg(debug_assertions)]
+    _opening: Comment,
+    /// The children of the component.
+    pub children: Vec<View>,
+    closing: Comment,
+    #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
+    pub(crate) id: HydrationKey,
 }
 
 impl fmt::Debug for ComponentRepr {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    use fmt::Write;
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use fmt::Write;
 
-    if self.children.is_empty() {
-      #[cfg(debug_assertions)]
-      return write!(f, "<{} />", self.name);
+        if self.children.is_empty() {
+            #[cfg(debug_assertions)]
+            return write!(f, "<{} />", self.name);
 
-      #[cfg(not(debug_assertions))]
-      return f.write_str("<Component />");
-    } else {
-      #[cfg(debug_assertions)]
-      writeln!(f, "<{}>", self.name)?;
-      #[cfg(not(debug_assertions))]
-      f.write_str("<Component>")?;
+            #[cfg(not(debug_assertions))]
+            return f.write_str("<Component />");
+        } else {
+            #[cfg(debug_assertions)]
+            writeln!(f, "<{}>", self.name)?;
+            #[cfg(not(debug_assertions))]
+            f.write_str("<Component>")?;
 
-      let mut pad_adapter = pad_adapter::PadAdapter::new(f);
+            let mut pad_adapter = pad_adapter::PadAdapter::new(f);
 
-      for child in &self.children {
-        writeln!(pad_adapter, "{child:#?}")?;
-      }
+            for child in &self.children {
+                writeln!(pad_adapter, "{child:#?}")?;
+            }
 
-      #[cfg(debug_assertions)]
-      write!(f, "</{}>", self.name)?;
-      #[cfg(not(debug_assertions))]
-      f.write_str("</Component>")?;
+            #[cfg(debug_assertions)]
+            write!(f, "</{}>", self.name)?;
+            #[cfg(not(debug_assertions))]
+            f.write_str("</Component>")?;
 
-      Ok(())
+            Ok(())
+        }
     }
-  }
 }
 
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
 impl Mountable for ComponentRepr {
-  fn get_mountable_node(&self) -> web_sys::Node {
-    if self.mounted.get().is_none() {
-      self.mounted.set(()).unwrap();
+    fn get_mountable_node(&self) -> web_sys::Node {
+        if self.mounted.get().is_none() {
+            self.mounted.set(()).unwrap();
 
-      self
-        .document_fragment
-        .unchecked_ref::<web_sys::Node>()
-        .to_owned()
+            self.document_fragment
+                .unchecked_ref::<web_sys::Node>()
+                .to_owned()
+        }
+        // We need to prepare all children to move
+        else {
+            let opening = self.get_opening_node();
+
+            prepare_to_move(
+                &self.document_fragment,
+                &opening,
+                &self.closing.node,
+            );
+
+            self.document_fragment.clone().unchecked_into()
+        }
     }
-    // We need to prepare all children to move
-    else {
-      let opening = self.get_opening_node();
 
-      prepare_to_move(&self.document_fragment, &opening, &self.closing.node);
+    fn get_opening_node(&self) -> web_sys::Node {
+        #[cfg(debug_assertions)]
+        return self._opening.node.clone();
 
-      self.document_fragment.clone().unchecked_into()
+        #[cfg(not(debug_assertions))]
+        return if let Some(child) = self.children.get(0) {
+            child.get_opening_node()
+        } else {
+            self.closing.node.clone()
+        };
     }
-  }
 
-  fn get_opening_node(&self) -> web_sys::Node {
-    #[cfg(debug_assertions)]
-    return self._opening.node.clone();
-
-    #[cfg(not(debug_assertions))]
-    return if let Some(child) = self.children.get(0) {
-      child.get_opening_node()
-    } else {
-      self.closing.node.clone()
-    };
-  }
-
-  fn get_closing_node(&self) -> web_sys::Node {
-    self.closing.node.clone()
-  }
+    fn get_closing_node(&self) -> web_sys::Node {
+        self.closing.node.clone()
+    }
 }
 
 impl IntoView for ComponentRepr {
-  #[cfg_attr(debug_assertions, instrument(level = "trace", name = "<Component />", skip_all, fields(name = %self.name)))]
-  fn into_view(self, _: Scope) -> View {
-    #[cfg(all(target_arch = "wasm32", feature = "web"))]
-    if !HydrationCtx::is_hydrating() {
-      for child in &self.children {
-        mount_child(MountKind::Before(&self.closing.node), child);
-      }
-    }
+    #[cfg_attr(debug_assertions, instrument(level = "trace", name = "<Component />", skip_all, fields(name = %self.name)))]
+    fn into_view(self, _: Scope) -> View {
+        #[cfg(all(target_arch = "wasm32", feature = "web"))]
+        if !HydrationCtx::is_hydrating() {
+            for child in &self.children {
+                mount_child(MountKind::Before(&self.closing.node), child);
+            }
+        }
 
-    View::Component(self)
-  }
+        View::Component(self)
+    }
 }
 
 impl ComponentRepr {
-  /// Creates a new [`Component`].
-  pub fn new(name: impl Into<Cow<'static, str>>) -> Self {
-    Self::new_with_id(name, HydrationCtx::id())
-  }
-
-  /// Creates a new [`Component`] with the given hydration ID.
-  pub fn new_with_id(
-    name: impl Into<Cow<'static, str>>,
-    id: HydrationKey,
-  ) -> Self {
-    let name = name.into();
-
-    let markers = (
-      Comment::new(Cow::Owned(format!("</{name}>")), &id, true),
-      #[cfg(debug_assertions)]
-      Comment::new(Cow::Owned(format!("<{name}>")), &id, false),
-    );
-
-    #[cfg(all(target_arch = "wasm32", feature = "web"))]
-    let document_fragment = {
-      let fragment = crate::document().create_document_fragment();
-
-      // Insert the comments into the document fragment
-      // so they can serve as our references when inserting
-      // future nodes
-      if !HydrationCtx::is_hydrating() {
-        #[cfg(debug_assertions)]
-        fragment
-          .append_with_node_2(&markers.1.node, &markers.0.node)
-          .expect("append to not err");
-        #[cfg(not(debug_assertions))]
-        fragment
-          .append_with_node_1(&markers.0.node)
-          .expect("append to not err");
-      }
-
-      fragment
-    };
-
-    Self {
-      #[cfg(all(target_arch = "wasm32", feature = "web"))]
-      document_fragment,
-      #[cfg(all(target_arch = "wasm32", feature = "web"))]
-      mounted: Default::default(),
-      #[cfg(debug_assertions)]
-      _opening: markers.1,
-      closing: markers.0,
-      #[cfg(debug_assertions)]
-      name,
-      children: Vec::with_capacity(1),
-      #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-      id,
+    /// Creates a new [`Component`].
+    pub fn new(name: impl Into<Cow<'static, str>>) -> Self {
+        Self::new_with_id(name, HydrationCtx::id())
+    }
+
+    /// Creates a new [`Component`] with the given hydration ID.
+    pub fn new_with_id(
+        name: impl Into<Cow<'static, str>>,
+        id: HydrationKey,
+    ) -> Self {
+        let name = name.into();
+
+        let markers = (
+            Comment::new(Cow::Owned(format!("</{name}>")), &id, true),
+            #[cfg(debug_assertions)]
+            Comment::new(Cow::Owned(format!("<{name}>")), &id, false),
+        );
+
+        #[cfg(all(target_arch = "wasm32", feature = "web"))]
+        let document_fragment = {
+            let fragment = crate::document().create_document_fragment();
+
+            // Insert the comments into the document fragment
+            // so they can serve as our references when inserting
+            // future nodes
+            if !HydrationCtx::is_hydrating() {
+                #[cfg(debug_assertions)]
+                fragment
+                    .append_with_node_2(&markers.1.node, &markers.0.node)
+                    .expect("append to not err");
+                #[cfg(not(debug_assertions))]
+                fragment
+                    .append_with_node_1(&markers.0.node)
+                    .expect("append to not err");
+            }
+
+            fragment
+        };
+
+        Self {
+            #[cfg(all(target_arch = "wasm32", feature = "web"))]
+            document_fragment,
+            #[cfg(all(target_arch = "wasm32", feature = "web"))]
+            mounted: Default::default(),
+            #[cfg(debug_assertions)]
+            _opening: markers.1,
+            closing: markers.0,
+            #[cfg(debug_assertions)]
+            name,
+            children: Vec::with_capacity(1),
+            #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
+            id,
+        }
     }
-  }
 }
 
 /// A user-defined `leptos` component.
 pub struct Component<F, V>
 where
-  F: FnOnce(Scope) -> V,
-  V: IntoView,
+    F: FnOnce(Scope) -> V,
+    V: IntoView,
 {
-  id: HydrationKey,
-  name: Cow<'static, str>,
-  children_fn: F,
+    id: HydrationKey,
+    name: Cow<'static, str>,
+    children_fn: F,
 }
 
 impl<F, V> Component<F, V>
 where
-  F: FnOnce(Scope) -> V,
-  V: IntoView,
+    F: FnOnce(Scope) -> V,
+    V: IntoView,
 {
-  /// Creates a new component.
-  pub fn new(name: impl Into<Cow<'static, str>>, f: F) -> Self {
-    Self {
-      id: HydrationCtx::next_component(),
-      name: name.into(),
-      children_fn: f,
+    /// Creates a new component.
+    pub fn new(name: impl Into<Cow<'static, str>>, f: F) -> Self {
+        Self {
+            id: HydrationCtx::next_component(),
+            name: name.into(),
+            children_fn: f,
+        }
     }
-  }
 }
 
 impl<F, V> IntoView for Component<F, V>
 where
-  F: FnOnce(Scope) -> V,
-  V: IntoView,
+    F: FnOnce(Scope) -> V,
+    V: IntoView,
 {
-  #[track_caller]
-  fn into_view(self, cx: Scope) -> View {
-    let Self {
-      id,
-      name,
-      children_fn,
-    } = self;
+    #[track_caller]
+    fn into_view(self, cx: Scope) -> View {
+        let Self {
+            id,
+            name,
+            children_fn,
+        } = self;
 
-    let mut repr = ComponentRepr::new_with_id(name, id);
+        let mut repr = ComponentRepr::new_with_id(name, id);
 
-    // disposed automatically when the parent scope is disposed
-    let (child, _) =
-      cx.run_child_scope(|cx| cx.untrack(|| children_fn(cx).into_view(cx)));
+        // disposed automatically when the parent scope is disposed
+        let (child, _) = cx
+            .run_child_scope(|cx| cx.untrack(|| children_fn(cx).into_view(cx)));
 
-    repr.children.push(child);
+        repr.children.push(child);
 
-    repr.into_view(cx)
-  }
+        repr.into_view(cx)
+    }
 }

leptos_dom/src/components/dyn_child.rs

@@ -1,6 +1,6 @@
 use crate::{
-  hydration::{HydrationCtx, HydrationKey},
-  Comment, IntoView, View,
+    hydration::{HydrationCtx, HydrationKey},
+    Comment, IntoView, View,
 };
 use cfg_if::cfg_if;
 use leptos_reactive::Scope;
@@ -16,320 +16,349 @@ cfg_if! {
 /// The internal representation of the [`DynChild`] core-component.
 #[derive(Clone, PartialEq, Eq)]
 pub struct DynChildRepr {
-  #[cfg(all(target_arch = "wasm32", feature = "web"))]
-  document_fragment: web_sys::DocumentFragment,
-  #[cfg(debug_assertions)]
-  opening: Comment,
-  pub(crate) child: Rc<RefCell<Box<Option<View>>>>,
-  closing: Comment,
-  #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-  pub(crate) id: HydrationKey,
+    #[cfg(all(target_arch = "wasm32", feature = "web"))]
+    document_fragment: web_sys::DocumentFragment,
+    #[cfg(debug_assertions)]
+    opening: Comment,
+    pub(crate) child: Rc<RefCell<Box<Option<View>>>>,
+    closing: Comment,
+    #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
+    pub(crate) id: HydrationKey,
 }
 
 impl fmt::Debug for DynChildRepr {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    use fmt::Write;
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use fmt::Write;
 
-    f.write_str("<DynChild>\n")?;
+        f.write_str("<DynChild>\n")?;
 
-    let mut pad_adapter = pad_adapter::PadAdapter::new(f);
+        let mut pad_adapter = pad_adapter::PadAdapter::new(f);
 
-    writeln!(
-      pad_adapter,
-      "{:#?}",
-      self.child.borrow().deref().deref().as_ref().unwrap()
-    )?;
+        writeln!(
+            pad_adapter,
+            "{:#?}",
+            self.child.borrow().deref().deref().as_ref().unwrap()
+        )?;
 
-    f.write_str("</DynChild>")
-  }
+        f.write_str("</DynChild>")
+    }
 }
 
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
 impl Mountable for DynChildRepr {
-  fn get_mountable_node(&self) -> web_sys::Node {
-    if self.document_fragment.child_nodes().length() != 0 {
-      self.document_fragment.clone().unchecked_into()
-    } else {
-      let opening = self.get_opening_node();
+    fn get_mountable_node(&self) -> web_sys::Node {
+        if self.document_fragment.child_nodes().length() != 0 {
+            self.document_fragment.clone().unchecked_into()
+        } else {
+            let opening = self.get_opening_node();
 
-      prepare_to_move(&self.document_fragment, &opening, &self.closing.node);
+            prepare_to_move(
+                &self.document_fragment,
+                &opening,
+                &self.closing.node,
+            );
 
-      self.document_fragment.clone().unchecked_into()
+            self.document_fragment.clone().unchecked_into()
+        }
     }
-  }
 
-  fn get_opening_node(&self) -> web_sys::Node {
-    #[cfg(debug_assertions)]
-    return self.opening.node.clone();
+    fn get_opening_node(&self) -> web_sys::Node {
+        #[cfg(debug_assertions)]
+        return self.opening.node.clone();
 
-    #[cfg(not(debug_assertions))]
-    return self
-      .child
-      .borrow()
-      .as_ref()
-      .as_ref()
-      .unwrap()
-      .get_opening_node();
-  }
+        #[cfg(not(debug_assertions))]
+        return self
+            .child
+            .borrow()
+            .as_ref()
+            .as_ref()
+            .unwrap()
+            .get_opening_node();
+    }
 
-  fn get_closing_node(&self) -> web_sys::Node {
-    self.closing.node.clone()
-  }
+    fn get_closing_node(&self) -> web_sys::Node {
+        self.closing.node.clone()
+    }
 }
 
 impl DynChildRepr {
-  fn new_with_id(id: HydrationKey) -> Self {
-    let markers = (
-      Comment::new(Cow::Borrowed("</DynChild>"), &id, true),
-      #[cfg(debug_assertions)]
-      Comment::new(Cow::Borrowed("<DynChild>"), &id, false),
-    );
+    fn new_with_id(id: HydrationKey) -> Self {
+        let markers = (
+            Comment::new(Cow::Borrowed("</DynChild>"), &id, true),
+            #[cfg(debug_assertions)]
+            Comment::new(Cow::Borrowed("<DynChild>"), &id, false),
+        );
 
-    #[cfg(all(target_arch = "wasm32", feature = "web"))]
-    let document_fragment = {
-      let fragment = crate::document().create_document_fragment();
+        #[cfg(all(target_arch = "wasm32", feature = "web"))]
+        let document_fragment = {
+            let fragment = crate::document().create_document_fragment();
 
-      // Insert the comments into the document fragment
-      // so they can serve as our references when inserting
-      // future nodes
-      if !HydrationCtx::is_hydrating() {
-        #[cfg(debug_assertions)]
-        fragment
-          .append_with_node_2(&markers.1.node, &markers.0.node)
-          .unwrap();
-        #[cfg(not(debug_assertions))]
-        fragment.append_with_node_1(&markers.0.node).unwrap();
-      }
+            // Insert the comments into the document fragment
+            // so they can serve as our references when inserting
+            // future nodes
+            if !HydrationCtx::is_hydrating() {
+                #[cfg(debug_assertions)]
+                fragment
+                    .append_with_node_2(&markers.1.node, &markers.0.node)
+                    .unwrap();
+                #[cfg(not(debug_assertions))]
+                fragment.append_with_node_1(&markers.0.node).unwrap();
+            }
 
-      fragment
-    };
+            fragment
+        };
 
-    Self {
-      #[cfg(all(target_arch = "wasm32", feature = "web"))]
-      document_fragment,
-      #[cfg(debug_assertions)]
-      opening: markers.1,
-      child: Default::default(),
-      closing: markers.0,
-      #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-      id,
+        Self {
+            #[cfg(all(target_arch = "wasm32", feature = "web"))]
+            document_fragment,
+            #[cfg(debug_assertions)]
+            opening: markers.1,
+            child: Default::default(),
+            closing: markers.0,
+            #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
+            id,
+        }
     }
-  }
 }
 
 /// Represents any [`View`] that can change over time.
 pub struct DynChild<CF, N>
 where
-  CF: Fn() -> N + 'static,
-  N: IntoView,
+    CF: Fn() -> N + 'static,
+    N: IntoView,
 {
-  id: crate::HydrationKey,
-  child_fn: CF,
+    id: crate::HydrationKey,
+    child_fn: CF,
 }
 
 impl<CF, N> DynChild<CF, N>
 where
-  CF: Fn() -> N + 'static,
-  N: IntoView,
+    CF: Fn() -> N + 'static,
+    N: IntoView,
 {
-  /// Creates a new dynamic child which will re-render whenever it's
-  /// signal dependencies change.
-  pub fn new(child_fn: CF) -> Self {
-    Self::new_with_id(HydrationCtx::id(), child_fn)
-  }
+    /// Creates a new dynamic child which will re-render whenever it's
+    /// signal dependencies change.
+    pub fn new(child_fn: CF) -> Self {
+        Self::new_with_id(HydrationCtx::id(), child_fn)
+    }
 
-  #[doc(hidden)]
-  pub fn new_with_id(id: HydrationKey, child_fn: CF) -> Self {
-    Self { id, child_fn }
-  }
+    #[doc(hidden)]
+    pub fn new_with_id(id: HydrationKey, child_fn: CF) -> Self {
+        Self { id, child_fn }
+    }
 }
 
 impl<CF, N> IntoView for DynChild<CF, N>
 where
-  CF: Fn() -> N + 'static,
-  N: IntoView,
+    CF: Fn() -> N + 'static,
+    N: IntoView,
 {
-  #[cfg_attr(
-    debug_assertions,
-    instrument(level = "trace", name = "<DynChild />", skip_all)
-  )]
-  fn into_view(self, cx: Scope) -> View {
-    // concrete inner function
-    fn create_dyn_view(
-      cx: Scope,
-      component: DynChildRepr,
-      child_fn: Box<dyn Fn() -> View>,
-    ) -> DynChildRepr {
-      #[cfg(all(target_arch = "wasm32", feature = "web"))]
-      let closing = component.closing.node.clone();
+    #[cfg_attr(
+        debug_assertions,
+        instrument(level = "trace", name = "<DynChild />", skip_all)
+    )]
+    fn into_view(self, cx: Scope) -> View {
+        // concrete inner function
+        fn create_dyn_view(
+            cx: Scope,
+            component: DynChildRepr,
+            child_fn: Box<dyn Fn() -> View>,
+        ) -> DynChildRepr {
+            #[cfg(all(target_arch = "wasm32", feature = "web"))]
+            let closing = component.closing.node.clone();
 
-      let child = component.child.clone();
+            let child = component.child.clone();
 
-      #[cfg(all(debug_assertions, target_arch = "wasm32", feature = "web"))]
-      let span = tracing::Span::current();
+            #[cfg(all(
+                debug_assertions,
+                target_arch = "wasm32",
+                feature = "web"
+            ))]
+            let span = tracing::Span::current();
 
-      #[cfg(all(target_arch = "wasm32", feature = "web"))]
-      create_effect(
-        cx,
-        move |prev_run: Option<(Option<web_sys::Node>, ScopeDisposer)>| {
-          #[cfg(debug_assertions)]
-          let _guard = span.enter();
+            #[cfg(all(target_arch = "wasm32", feature = "web"))]
+            create_effect(
+                cx,
+                move |prev_run: Option<(
+                    Option<web_sys::Node>,
+                    ScopeDisposer,
+                )>| {
+                    #[cfg(debug_assertions)]
+                    let _guard = span.enter();
 
-          let (new_child, disposer) =
-            cx.run_child_scope(|cx| child_fn().into_view(cx));
+                    let (new_child, disposer) =
+                        cx.run_child_scope(|cx| child_fn().into_view(cx));
 
-          let mut child_borrow = child.borrow_mut();
+                    let mut child_borrow = child.borrow_mut();
 
-          // Is this at least the second time we are loading a child?
-          if let Some((prev_t, prev_disposer)) = prev_run {
-            let child = child_borrow.take().unwrap();
+                    // Is this at least the second time we are loading a child?
+                    if let Some((prev_t, prev_disposer)) = prev_run {
+                        let child = child_borrow.take().unwrap();
 
-            // Dispose of the scope
-            prev_disposer.dispose();
+                        // Dispose of the scope
+                        prev_disposer.dispose();
 
-            // We need to know if our child wasn't moved elsewhere.
-            // If it was, `DynChild` no longer "owns" that child, and
-            // is therefore no longer sound to unmount it from the DOM
-            // or to reuse it in the case of a text node
+                        // We need to know if our child wasn't moved elsewhere.
+                        // If it was, `DynChild` no longer "owns" that child, and
+                        // is therefore no longer sound to unmount it from the DOM
+                        // or to reuse it in the case of a text node
 
-            // TODO check does this still detect moves correctly?
-            let was_child_moved = prev_t.is_none()
-              && child.get_closing_node().next_sibling().as_ref()
-                != Some(&closing);
+                        // TODO check does this still detect moves correctly?
+                        let was_child_moved = prev_t.is_none()
+                            && child.get_closing_node().next_sibling().as_ref()
+                                != Some(&closing);
 
-            // If the previous child was a text node, we would like to
-            // make use of it again if our current child is also a text
-            // node
-            let ret = if let Some(prev_t) = prev_t {
-              // Here, our child is also a text node
-              if let Some(new_t) = new_child.get_text() {
-                if !was_child_moved && child != new_child {
-                  prev_t
-                    .unchecked_ref::<web_sys::Text>()
-                    .set_data(&new_t.content);
+                        // If the previous child was a text node, we would like to
+                        // make use of it again if our current child is also a text
+                        // node
+                        let ret = if let Some(prev_t) = prev_t {
+                            // Here, our child is also a text node
+                            if let Some(new_t) = new_child.get_text() {
+                                if !was_child_moved && child != new_child {
+                                    prev_t
+                                        .unchecked_ref::<web_sys::Text>()
+                                        .set_data(&new_t.content);
 
-                  **child_borrow = Some(new_child);
+                                    **child_borrow = Some(new_child);
 
-                  (Some(prev_t), disposer)
-                } else {
-                  mount_child(MountKind::Before(&closing), &new_child);
+                                    (Some(prev_t), disposer)
+                                } else {
+                                    mount_child(
+                                        MountKind::Before(&closing),
+                                        &new_child,
+                                    );
 
-                  **child_borrow = Some(new_child.clone());
+                                    **child_borrow = Some(new_child.clone());
 
-                  (Some(new_t.node.clone()), disposer)
-                }
-              }
-              // Child is not a text node, so we can remove the previous
-              // text node
-              else {
-                if !was_child_moved && child != new_child {
-                  // Remove the text
-                  closing
-                    .previous_sibling()
-                    .unwrap()
-                    .unchecked_into::<web_sys::Element>()
-                    .remove();
-                }
+                                    (Some(new_t.node.clone()), disposer)
+                                }
+                            }
+                            // Child is not a text node, so we can remove the previous
+                            // text node
+                            else {
+                                if !was_child_moved && child != new_child {
+                                    // Remove the text
+                                    closing
+                                        .previous_sibling()
+                                        .unwrap()
+                                        .unchecked_into::<web_sys::Element>()
+                                        .remove();
+                                }
 
-                // Mount the new child, and we're done
-                mount_child(MountKind::Before(&closing), &new_child);
+                                // Mount the new child, and we're done
+                                mount_child(
+                                    MountKind::Before(&closing),
+                                    &new_child,
+                                );
 
-                **child_borrow = Some(new_child);
+                                **child_borrow = Some(new_child);
 
-                (None, disposer)
-              }
-            }
-            // Otherwise, the new child can still be a text node,
-            // but we know the previous child was not, so no special
-            // treatment here
-            else {
-              // Technically, I think this check shouldn't be necessary, but
-              // I can imagine some edge case that the child changes while
-              // hydration is ongoing
-              if !HydrationCtx::is_hydrating() {
-                if !was_child_moved && child != new_child {
-                  // Remove the child
-                  let start = child.get_opening_node();
-                  let end = &closing;
+                                (None, disposer)
+                            }
+                        }
+                        // Otherwise, the new child can still be a text node,
+                        // but we know the previous child was not, so no special
+                        // treatment here
+                        else {
+                            // Technically, I think this check shouldn't be necessary, but
+                            // I can imagine some edge case that the child changes while
+                            // hydration is ongoing
+                            if !HydrationCtx::is_hydrating() {
+                                if !was_child_moved && child != new_child {
+                                    // Remove the child
+                                    let start = child.get_opening_node();
+                                    let end = &closing;
 
-                  unmount_child(&start, end);
-                }
+                                    unmount_child(&start, end);
+                                }
 
-                // Mount the new child
-                mount_child(MountKind::Before(&closing), &new_child);
-              }
+                                // Mount the new child
+                                mount_child(
+                                    MountKind::Before(&closing),
+                                    &new_child,
+                                );
+                            }
 
-              // We want to reuse text nodes, so hold onto it if
-              // our child is one
-              let t = new_child.get_text().map(|t| t.node.clone());
+                            // We want to reuse text nodes, so hold onto it if
+                            // our child is one
+                            let t =
+                                new_child.get_text().map(|t| t.node.clone());
 
-              **child_borrow = Some(new_child);
+                            **child_borrow = Some(new_child);
 
-              (t, disposer)
-            };
+                            (t, disposer)
+                        };
 
-            ret
-          }
-          // Otherwise, we know for sure this is our first time
-          else {
-            // We need to remove the text created from SSR
-            if HydrationCtx::is_hydrating() && new_child.get_text().is_some() {
-              let t = closing
-                .previous_sibling()
-                .unwrap()
-                .unchecked_into::<web_sys::Element>();
+                        ret
+                    }
+                    // Otherwise, we know for sure this is our first time
+                    else {
+                        // We need to remove the text created from SSR
+                        if HydrationCtx::is_hydrating()
+                            && new_child.get_text().is_some()
+                        {
+                            let t = closing
+                                .previous_sibling()
+                                .unwrap()
+                                .unchecked_into::<web_sys::Element>();
 
-              // See note on ssr.rs when matching on `DynChild`
-              // for more details on why we need to do this for
-              // release
-              if !cfg!(debug_assertions) {
-                t.previous_sibling()
-                  .unwrap()
-                  .unchecked_into::<web_sys::Element>()
-                  .remove();
-              }
+                            // See note on ssr.rs when matching on `DynChild`
+                            // for more details on why we need to do this for
+                            // release
+                            if !cfg!(debug_assertions) {
+                                t.previous_sibling()
+                                    .unwrap()
+                                    .unchecked_into::<web_sys::Element>()
+                                    .remove();
+                            }
 
-              t.remove();
+                            t.remove();
 
-              mount_child(MountKind::Before(&closing), &new_child);
+                            mount_child(
+                                MountKind::Before(&closing),
+                                &new_child,
+                            );
+                        }
+
+                        // If we are not hydrating, we simply mount the child
+                        if !HydrationCtx::is_hydrating() {
+                            mount_child(
+                                MountKind::Before(&closing),
+                                &new_child,
+                            );
+                        }
+
+                        // We want to update text nodes, rather than replace them, so
+                        // make sure to hold onto the text node
+                        let t = new_child.get_text().map(|t| t.node.clone());
+
+                        **child_borrow = Some(new_child);
+
+                        (t, disposer)
+                    }
+                },
+            );
+
+            #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
+            {
+                let new_child = child_fn().into_view(cx);
+
+                **child.borrow_mut() = Some(new_child);
             }
 
-            // If we are not hydrating, we simply mount the child
-            if !HydrationCtx::is_hydrating() {
-              mount_child(MountKind::Before(&closing), &new_child);
-            }
+            component
+        }
 
-            // We want to update text nodes, rather than replace them, so
-            // make sure to hold onto the text node
-            let t = new_child.get_text().map(|t| t.node.clone());
+        // monomorphized outer function
+        let Self { id, child_fn } = self;
 
-            **child_borrow = Some(new_child);
+        let component = DynChildRepr::new_with_id(id);
+        let component = create_dyn_view(
+            cx,
+            component,
+            Box::new(move || child_fn().into_view(cx)),
+        );
 
-            (t, disposer)
-          }
-        },
-      );
-
-      #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-      {
-        let new_child = child_fn().into_view(cx);
-
-        **child.borrow_mut() = Some(new_child);
-      }
-
-      component
+        View::CoreComponent(crate::CoreComponent::DynChild(component))
     }
-
-    // monomorphized outer function
-    let Self { id, child_fn } = self;
-
-    let component = DynChildRepr::new_with_id(id);
-    let component = create_dyn_view(
-      cx,
-      component,
-      Box::new(move || child_fn().into_view(cx)),
-    );
-
-    View::CoreComponent(crate::CoreComponent::DynChild(component))
-  }
 }

leptos_dom/src/components/errors.rs

@@ -1,79 +1,162 @@
-use crate::{HydrationCtx, HydrationKey, IntoView};
+use crate::{HydrationCtx, IntoView};
 use cfg_if::cfg_if;
 use leptos_reactive::{use_context, RwSignal};
 use std::{collections::HashMap, error::Error, sync::Arc};
 
 /// A struct to hold all the possible errors that could be provided by child Views
 #[derive(Debug, Clone, Default)]
-pub struct Errors(pub HashMap<HydrationKey, Arc<dyn Error + Send + Sync>>);
+pub struct Errors(HashMap<ErrorKey, Arc<dyn Error + Send + Sync>>);
+
+/// A unique key for an error that occurs at a particular location in the user interface.
+#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
+pub struct ErrorKey(String);
+
+impl<T> From<T> for ErrorKey
+where
+    T: Into<String>,
+{
+    fn from(key: T) -> ErrorKey {
+        ErrorKey(key.into())
+    }
+}
+
+impl IntoIterator for Errors {
+    type Item = (ErrorKey, Arc<dyn Error + Send + Sync>);
+    type IntoIter = IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter(self.0.into_iter())
+    }
+}
+
+/// An owning iterator over all the errors contained in the [Errors] struct.
+pub struct IntoIter(
+    std::collections::hash_map::IntoIter<
+        ErrorKey,
+        Arc<dyn Error + Send + Sync>,
+    >,
+);
+
+impl Iterator for IntoIter {
+    type Item = (ErrorKey, Arc<dyn Error + Send + Sync>);
+
+    fn next(
+        &mut self,
+    ) -> std::option::Option<<Self as std::iter::Iterator>::Item> {
+        self.0.next()
+    }
+}
+
+/// An iterator over all the errors contained in the [Errors] struct.
+pub struct Iter<'a>(
+    std::collections::hash_map::Iter<
+        'a,
+        ErrorKey,
+        Arc<dyn Error + Send + Sync>,
+    >,
+);
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = (&'a ErrorKey, &'a Arc<dyn Error + Send + Sync>);
+
+    fn next(
+        &mut self,
+    ) -> std::option::Option<<Self as std::iter::Iterator>::Item> {
+        self.0.next()
+    }
+}
 
 impl<T, E> IntoView for Result<T, E>
 where
-  T: IntoView + 'static,
-  E: Error + Send + Sync + 'static,
+    T: IntoView + 'static,
+    E: Error + Send + Sync + 'static,
 {
-  fn into_view(self, cx: leptos_reactive::Scope) -> crate::View {
-    match self {
-      Ok(stuff) => stuff.into_view(cx),
-      Err(error) => {
-        match use_context::<RwSignal<Errors>>(cx) {
-          Some(errors) => {
-            let id = HydrationCtx::id();
-            errors.update({
-              #[cfg(all(target_arch = "wasm32", feature = "web"))]
-              let id = id.clone();
-              move |errors: &mut Errors| errors.insert(id, error)
-            });
-
-            // remove the error from the list if this drops,
-            // i.e., if it's in a DynChild that switches from Err to Ok
-            // Only can run on the client, will panic on the server
-            cfg_if! {
-              if #[cfg(all(target_arch = "wasm32", feature = "web"))] {
-                use leptos_reactive::{on_cleanup, queue_microtask};
-                on_cleanup(cx, move || {
-                  queue_microtask(move || {
-                    errors.update(|errors: &mut Errors| {
-                      errors.remove::<E>(&id);
+    fn into_view(self, cx: leptos_reactive::Scope) -> crate::View {
+        let id = ErrorKey(HydrationCtx::peek().previous);
+        let errors = use_context::<RwSignal<Errors>>(cx);
+        match self {
+            Ok(stuff) => {
+                if let Some(errors) = errors {
+                    errors.update(|errors| {
+                        errors.0.remove(&id);
                     });
-                  });
-                });
-              }
+                }
+                stuff.into_view(cx)
+            }
+            Err(error) => {
+                match errors {
+                    Some(errors) => {
+                        errors.update({
+                            #[cfg(all(
+                                target_arch = "wasm32",
+                                feature = "web"
+                            ))]
+                            let id = id.clone();
+                            move |errors: &mut Errors| errors.insert(id, error)
+                        });
+
+                        // remove the error from the list if this drops,
+                        // i.e., if it's in a DynChild that switches from Err to Ok
+                        // Only can run on the client, will panic on the server
+                        cfg_if! {
+                          if #[cfg(all(target_arch = "wasm32", feature = "web"))] {
+                            use leptos_reactive::{on_cleanup, queue_microtask};
+                            on_cleanup(cx, move || {
+                              queue_microtask(move || {
+                                errors.update(|errors: &mut Errors| {
+                                  errors.remove(&id);
+                                });
+                              });
+                            });
+                          }
+                        }
+                    }
+                    None => {
+                        #[cfg(debug_assertions)]
+                        warn!(
+                            "No ErrorBoundary components found! Returning \
+                             errors will not be handled and will silently \
+                             disappear"
+                        );
+                    }
+                }
+                ().into_view(cx)
             }
-          }
-          None => {
-            #[cfg(debug_assertions)]
-            warn!(
-              "No ErrorBoundary components found! Returning errors will not \
-               be handled and will silently disappear"
-            );
-          }
         }
-        ().into_view(cx)
-      }
     }
-  }
 }
 impl Errors {
-  /// Add an error to Errors that will be processed by `<ErrorBoundary/>`
-  pub fn insert<E>(&mut self, key: HydrationKey, error: E)
-  where
-    E: Error + Send + Sync + 'static,
-  {
-    self.0.insert(key, Arc::new(error));
-  }
-  /// Add an error with the default key for errors outside the reactive system
-  pub fn insert_with_default_key<E>(&mut self, error: E)
-  where
-    E: Error + Send + Sync + 'static,
-  {
-    self.0.insert(HydrationKey::default(), Arc::new(error));
-  }
-  /// Remove an error to Errors that will be processed by `<ErrorBoundary/>`
-  pub fn remove<E>(&mut self, key: &HydrationKey)
-  where
-    E: Error + Send + Sync + 'static,
-  {
-    self.0.remove(key);
-  }
+    /// Returns `true` if there are no errors.
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Add an error to Errors that will be processed by `<ErrorBoundary/>`
+    pub fn insert<E>(&mut self, key: ErrorKey, error: E)
+    where
+        E: Error + Send + Sync + 'static,
+    {
+        self.0.insert(key, Arc::new(error));
+    }
+
+    /// Add an error with the default key for errors outside the reactive system
+    pub fn insert_with_default_key<E>(&mut self, error: E)
+    where
+        E: Error + Send + Sync + 'static,
+    {
+        self.0.insert(Default::default(), Arc::new(error));
+    }
+
+    /// Remove an error to Errors that will be processed by `<ErrorBoundary/>`
+    pub fn remove(
+        &mut self,
+        key: &ErrorKey,
+    ) -> Option<Arc<dyn Error + Send + Sync>> {
+        self.0.remove(key)
+    }
+
+    /// An iterator over all the errors, in arbitrary order.
+    pub fn iter(&self) -> Iter<'_> {
+        Iter(self.0.iter())
+    }
 }

leptos_dom/src/components/fragment.rs

@@ -1,79 +1,78 @@
-use leptos_reactive::Scope;
-
 use crate::{
-  hydration::HydrationKey, ComponentRepr, HydrationCtx, IntoView, View,
+    hydration::HydrationKey, ComponentRepr, HydrationCtx, IntoView, View,
 };
+use leptos_reactive::Scope;
 
 /// Trait for converting any iterable into a [`Fragment`].
 pub trait IntoFragment {
-  /// Consumes this type, returning [`Fragment`].
-  fn into_fragment(self, cx: Scope) -> Fragment;
+    /// Consumes this type, returning [`Fragment`].
+    fn into_fragment(self, cx: Scope) -> Fragment;
 }
 
 impl<I, V> IntoFragment for I
 where
-  I: IntoIterator<Item = V>,
-  V: IntoView,
+    I: IntoIterator<Item = V>,
+    V: IntoView,
 {
-  fn into_fragment(self, cx: Scope) -> Fragment {
-    self.into_iter().map(|v| v.into_view(cx)).collect()
-  }
+    fn into_fragment(self, cx: Scope) -> Fragment {
+        self.into_iter().map(|v| v.into_view(cx)).collect()
+    }
 }
 
 /// Represents a group of [`views`](View).
 #[derive(Debug, Clone)]
 pub struct Fragment {
-  id: HydrationKey,
-  /// The nodes contained in the fragment.
-  pub nodes: Vec<View>,
+    id: HydrationKey,
+    /// The nodes contained in the fragment.
+    pub nodes: Vec<View>,
 }
 
 impl FromIterator<View> for Fragment {
-  fn from_iter<T: IntoIterator<Item = View>>(iter: T) -> Self {
-    Fragment::new(iter.into_iter().collect())
-  }
+    fn from_iter<T: IntoIterator<Item = View>>(iter: T) -> Self {
+        Fragment::new(iter.into_iter().collect())
+    }
 }
 
 impl From<View> for Fragment {
-  fn from(view: View) -> Self {
-    Fragment::new(vec![view])
-  }
+    fn from(view: View) -> Self {
+        Fragment::new(vec![view])
+    }
 }
 
 impl Fragment {
-  /// Creates a new [`Fragment`] from a [`Vec<Node>`].
-  pub fn new(nodes: Vec<View>) -> Self {
-    Self::new_with_id(HydrationCtx::id(), nodes)
-  }
+    /// Creates a new [`Fragment`] from a [`Vec<Node>`].
+    pub fn new(nodes: Vec<View>) -> Self {
+        Self::new_with_id(HydrationCtx::id(), nodes)
+    }
 
-  /// Creates a new [`Fragment`] from a function that returns [`Vec<Node>`].
-  pub fn lazy(nodes: impl FnOnce() -> Vec<View>) -> Self {
-    Self::new_with_id(HydrationCtx::id(), nodes())
-  }
+    /// Creates a new [`Fragment`] from a function that returns [`Vec<Node>`].
+    pub fn lazy(nodes: impl FnOnce() -> Vec<View>) -> Self {
+        Self::new_with_id(HydrationCtx::id(), nodes())
+    }
 
-  /// Creates a new [`Fragment`] with the given hydration ID from a [`Vec<Node>`].
-  pub fn new_with_id(id: HydrationKey, nodes: Vec<View>) -> Self {
-    Self { id, nodes }
-  }
+    /// Creates a new [`Fragment`] with the given hydration ID from a [`Vec<Node>`].
+    pub fn new_with_id(id: HydrationKey, nodes: Vec<View>) -> Self {
+        Self { id, nodes }
+    }
 
-  /// Gives access to the [View] children contained within the fragment.
-  pub fn as_children(&self) -> &[View] {
-    &self.nodes
-  }
+    /// Gives access to the [View] children contained within the fragment.
+    pub fn as_children(&self) -> &[View] {
+        &self.nodes
+    }
 
-  /// Returns the fragment's hydration ID.
-  pub fn id(&self) -> &HydrationKey {
-    &self.id
-  }
+    /// Returns the fragment's hydration ID.
+    pub fn id(&self) -> &HydrationKey {
+        &self.id
+    }
 }
 
 impl IntoView for Fragment {
-  #[cfg_attr(debug_assertions, instrument(level = "trace", name = "</>", skip_all, fields(children = self.nodes.len())))]
-  fn into_view(self, cx: leptos_reactive::Scope) -> View {
-    let mut frag = ComponentRepr::new_with_id("", self.id.clone());
+    #[cfg_attr(debug_assertions, instrument(level = "trace", name = "</>", skip_all, fields(children = self.nodes.len())))]
+    fn into_view(self, cx: leptos_reactive::Scope) -> View {
+        let mut frag = ComponentRepr::new_with_id("", self.id.clone());
 
-    frag.children = self.nodes;
+        frag.children = self.nodes;
 
-    frag.into_view(cx)
-  }
+        frag.into_view(cx)
+    }
 }

leptos_dom/src/components/unit.rs

@@ -15,42 +15,42 @@ use crate::{hydration::HydrationCtx, Comment, CoreComponent, IntoView, View};
 /// The internal representation of the [`Unit`] core-component.
 #[derive(Clone, PartialEq, Eq)]
 pub struct UnitRepr {
-  comment: Comment,
-  #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-  pub(crate) id: HydrationKey,
+    comment: Comment,
+    #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
+    pub(crate) id: HydrationKey,
 }
 
 impl fmt::Debug for UnitRepr {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    f.write_str("<() />")
-  }
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("<() />")
+    }
 }
 
 impl Default for UnitRepr {
-  fn default() -> Self {
-    let id = HydrationCtx::id();
+    fn default() -> Self {
+        let id = HydrationCtx::id();
 
-    Self {
-      comment: Comment::new("<() />", &id, true),
-      #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-      id,
+        Self {
+            comment: Comment::new("<() />", &id, true),
+            #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
+            id,
+        }
     }
-  }
 }
 
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
 impl Mountable for UnitRepr {
-  fn get_mountable_node(&self) -> web_sys::Node {
-    self.comment.node.clone().unchecked_into()
-  }
+    fn get_mountable_node(&self) -> web_sys::Node {
+        self.comment.node.clone().unchecked_into()
+    }
 
-  fn get_opening_node(&self) -> web_sys::Node {
-    self.comment.node.clone().unchecked_into()
-  }
+    fn get_opening_node(&self) -> web_sys::Node {
+        self.comment.node.clone().unchecked_into()
+    }
 
-  fn get_closing_node(&self) -> web_sys::Node {
-    self.comment.node.clone().unchecked_into()
-  }
+    fn get_closing_node(&self) -> web_sys::Node {
+        self.comment.node.clone().unchecked_into()
+    }
 }
 
 /// The unit `()` leptos counterpart.
@@ -58,13 +58,13 @@ impl Mountable for UnitRepr {
 pub struct Unit;
 
 impl IntoView for Unit {
-  #[cfg_attr(
-    debug_assertions,
-    instrument(level = "trace", name = "<() />", skip_all)
-  )]
-  fn into_view(self, _: leptos_reactive::Scope) -> crate::View {
-    let component = UnitRepr::default();
+    #[cfg_attr(
+        debug_assertions,
+        instrument(level = "trace", name = "<() />", skip_all)
+    )]
+    fn into_view(self, _: leptos_reactive::Scope) -> crate::View {
+        let component = UnitRepr::default();
 
-    View::CoreComponent(CoreComponent::Unit(component))
-  }
+        View::CoreComponent(CoreComponent::Unit(component))
+    }
 }

leptos_dom/src/events.rs

@@ -3,146 +3,152 @@ pub mod typed;
 use std::{borrow::Cow, cell::RefCell, collections::HashSet};
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
 use wasm_bindgen::{
-  convert::FromWasmAbi, intern, prelude::Closure, JsCast, JsValue,
-  UnwrapThrowExt,
+    convert::FromWasmAbi, intern, prelude::Closure, JsCast, JsValue,
+    UnwrapThrowExt,
 };
 
 thread_local! {
-    pub static GLOBAL_EVENTS: RefCell<HashSet<Cow<'static, str>>> = RefCell::new(HashSet::new());
+    pub(crate) static GLOBAL_EVENTS: RefCell<HashSet<Cow<'static, str>>> = RefCell::new(HashSet::new());
 }
 
 /// Adds an event listener to the target DOM element using implicit event delegation.
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
-pub fn add_event_listener<E>(
-  target: &web_sys::Element,
-  event_name: Cow<'static, str>,
-  #[cfg(debug_assertions)] mut cb: impl FnMut(E) + 'static,
-  #[cfg(not(debug_assertions))] cb: impl FnMut(E) + 'static,
+pub(crate) fn add_event_listener<E>(
+    target: &web_sys::Element,
+    event_name: Cow<'static, str>,
+    #[cfg(debug_assertions)] mut cb: impl FnMut(E) + 'static,
+    #[cfg(not(debug_assertions))] cb: impl FnMut(E) + 'static,
 ) where
-  E: FromWasmAbi + 'static,
+    E: FromWasmAbi + 'static,
 {
-  cfg_if::cfg_if! {
-    if #[cfg(debug_assertions)] {
-      let span = ::tracing::Span::current();
-      let cb = move |e| {
-        let _guard = span.enter();
-        cb(e);
-      };
+    cfg_if::cfg_if! {
+      if #[cfg(debug_assertions)] {
+        let span = ::tracing::Span::current();
+        let cb = move |e| {
+          let _guard = span.enter();
+          cb(e);
+        };
+      }
     }
-  }
 
-  let cb = Closure::wrap(Box::new(cb) as Box<dyn FnMut(E)>).into_js_value();
-  let key = event_delegation_key(&event_name);
-  _ = js_sys::Reflect::set(target, &JsValue::from_str(&key), &cb);
-  add_delegated_event_listener(event_name);
+    let cb = Closure::wrap(Box::new(cb) as Box<dyn FnMut(E)>).into_js_value();
+    let key = event_delegation_key(&event_name);
+    _ = js_sys::Reflect::set(target, &JsValue::from_str(&key), &cb);
+    add_delegated_event_listener(event_name);
 }
 
 #[doc(hidden)]
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
-pub fn add_event_listener_undelegated<E>(
-  target: &web_sys::Element,
-  event_name: &str,
-  mut cb: impl FnMut(E) + 'static,
+pub(crate) fn add_event_listener_undelegated<E>(
+    target: &web_sys::Element,
+    event_name: &str,
+    mut cb: impl FnMut(E) + 'static,
 ) where
-  E: FromWasmAbi + 'static,
+    E: FromWasmAbi + 'static,
 {
-  cfg_if::cfg_if! {
-    if #[cfg(debug_assertions)] {
-      let span = ::tracing::Span::current();
-      let cb = move |e| {
-        let _guard = span.enter();
-        cb(e);
-      };
+    cfg_if::cfg_if! {
+      if #[cfg(debug_assertions)] {
+        let span = ::tracing::Span::current();
+        let cb = move |e| {
+          let _guard = span.enter();
+          cb(e);
+        };
+      }
     }
-  }
 
-  let event_name = intern(event_name);
-  let cb = Closure::wrap(Box::new(cb) as Box<dyn FnMut(E)>).into_js_value();
-  _ = target.add_event_listener_with_callback(event_name, cb.unchecked_ref());
+    let event_name = intern(event_name);
+    let cb = Closure::wrap(Box::new(cb) as Box<dyn FnMut(E)>).into_js_value();
+    _ = target.add_event_listener_with_callback(event_name, cb.unchecked_ref());
 }
 
 // cf eventHandler in ryansolid/dom-expressions
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
 pub(crate) fn add_delegated_event_listener(event_name: Cow<'static, str>) {
-  GLOBAL_EVENTS.with(|global_events| {
-    let mut events = global_events.borrow_mut();
-    if !events.contains(&event_name) {
-      // create global handler
-      let key = JsValue::from_str(&event_delegation_key(&event_name));
-      let handler = move |ev: web_sys::Event| {
-        let target = ev.target();
-        let node = ev.composed_path().get(0);
-        let mut node = if node.is_undefined() || node.is_null() {
-          JsValue::from(target)
-        } else {
-          node
-        };
+    GLOBAL_EVENTS.with(|global_events| {
+        let mut events = global_events.borrow_mut();
+        if !events.contains(&event_name) {
+            // create global handler
+            let key = JsValue::from_str(&event_delegation_key(&event_name));
+            let handler = move |ev: web_sys::Event| {
+                let target = ev.target();
+                let node = ev.composed_path().get(0);
+                let mut node = if node.is_undefined() || node.is_null() {
+                    JsValue::from(target)
+                } else {
+                    node
+                };
 
-        // TODO reverse Shadow DOM retargetting
+                // TODO reverse Shadow DOM retargetting
 
-        // TODO simulate currentTarget
+                // TODO simulate currentTarget
 
-        while !node.is_null() {
-          let node_is_disabled =
-            js_sys::Reflect::get(&node, &JsValue::from_str("disabled"))
-              .unwrap_throw()
-              .is_truthy();
-          if !node_is_disabled {
-            let maybe_handler =
-              js_sys::Reflect::get(&node, &key).unwrap_throw();
-            if !maybe_handler.is_undefined() {
-              let f = maybe_handler.unchecked_ref::<js_sys::Function>();
-              let _ = f.call1(&node, &ev);
+                while !node.is_null() {
+                    let node_is_disabled = js_sys::Reflect::get(
+                        &node,
+                        &JsValue::from_str("disabled"),
+                    )
+                    .unwrap_throw()
+                    .is_truthy();
+                    if !node_is_disabled {
+                        let maybe_handler =
+                            js_sys::Reflect::get(&node, &key).unwrap_throw();
+                        if !maybe_handler.is_undefined() {
+                            let f = maybe_handler
+                                .unchecked_ref::<js_sys::Function>();
+                            let _ = f.call1(&node, &ev);
 
-              if ev.cancel_bubble() {
-                return;
+                            if ev.cancel_bubble() {
+                                return;
+                            }
+                        }
+                    }
+
+                    // navigate up tree
+                    let host =
+                        js_sys::Reflect::get(&node, &JsValue::from_str("host"))
+                            .unwrap_throw();
+                    if host.is_truthy()
+                        && host != node
+                        && host.dyn_ref::<web_sys::Node>().is_some()
+                    {
+                        node = host;
+                    } else if let Some(parent) =
+                        node.unchecked_into::<web_sys::Node>().parent_node()
+                    {
+                        node = parent.into()
+                    } else {
+                        node = JsValue::null()
+                    }
+                }
+            };
+
+            cfg_if::cfg_if! {
+              if #[cfg(debug_assertions)] {
+                let span = ::tracing::Span::current();
+                let handler = move |e| {
+                  let _guard = span.enter();
+                  handler(e);
+                };
               }
             }
-          }
 
-          // navigate up tree
-          let host = js_sys::Reflect::get(&node, &JsValue::from_str("host"))
-            .unwrap_throw();
-          if host.is_truthy()
-            && host != node
-            && host.dyn_ref::<web_sys::Node>().is_some()
-          {
-            node = host;
-          } else if let Some(parent) =
-            node.unchecked_into::<web_sys::Node>().parent_node()
-          {
-            node = parent.into()
-          } else {
-            node = JsValue::null()
-          }
+            let handler = Box::new(handler) as Box<dyn FnMut(web_sys::Event)>;
+            let handler = Closure::wrap(handler).into_js_value();
+            _ = crate::window().add_event_listener_with_callback(
+                &event_name,
+                handler.unchecked_ref(),
+            );
+
+            // register that we've created handler
+            events.insert(event_name);
         }
-      };
-
-      cfg_if::cfg_if! {
-        if #[cfg(debug_assertions)] {
-          let span = ::tracing::Span::current();
-          let handler = move |e| {
-            let _guard = span.enter();
-            handler(e);
-          };
-        }
-      }
-
-      let handler = Box::new(handler) as Box<dyn FnMut(web_sys::Event)>;
-      let handler = Closure::wrap(handler).into_js_value();
-      _ = crate::window()
-        .add_event_listener_with_callback(&event_name, handler.unchecked_ref());
-
-      // register that we've created handler
-      events.insert(event_name);
-    }
-  })
+    })
 }
 
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
 pub(crate) fn event_delegation_key(event_name: &str) -> String {
-  let event_name = intern(event_name);
-  let mut n = String::from("$$$");
-  n.push_str(event_name);
-  n
+    let event_name = intern(event_name);
+    let mut n = String::from("$$$");
+    n.push_str(event_name);
+    n
 }

leptos_dom/src/events/typed.rs

@@ -1,24 +1,24 @@
-//! Collection of typed events.
+//! Types for all DOM events.
 
 use std::{borrow::Cow, marker::PhantomData};
 use wasm_bindgen::convert::FromWasmAbi;
 
 /// A trait for converting types into [web_sys events](web_sys).
 pub trait EventDescriptor: Clone {
-  /// The [`web_sys`] event type, such as [`web_sys::MouseEvent`].
-  type EventType: FromWasmAbi;
+    /// The [`web_sys`] event type, such as [`web_sys::MouseEvent`].
+    type EventType: FromWasmAbi;
 
-  /// The name of the event, such as `click` or `mouseover`.
-  fn name(&self) -> Cow<'static, str>;
+    /// The name of the event, such as `click` or `mouseover`.
+    fn name(&self) -> Cow<'static, str>;
 
-  /// Indicates if this event bubbles. For example, `click` bubbles,
-  /// but `focus` does not.
-  ///
-  /// If this method returns true, then the event will be delegated globally,
-  /// otherwise, event listeners will be directly attached to the element.
-  fn bubbles(&self) -> bool {
-    true
-  }
+    /// Indicates if this event bubbles. For example, `click` bubbles,
+    /// but `focus` does not.
+    ///
+    /// If this method returns true, then the event will be delegated globally,
+    /// otherwise, event listeners will be directly attached to the element.
+    fn bubbles(&self) -> bool {
+        true
+    }
 }
 
 /// Overrides the [`EventDescriptor::bubbles`] method to always return
@@ -28,54 +28,54 @@ pub trait EventDescriptor: Clone {
 pub struct undelegated<Ev: EventDescriptor>(pub Ev);
 
 impl<Ev: EventDescriptor> EventDescriptor for undelegated<Ev> {
-  type EventType = Ev::EventType;
+    type EventType = Ev::EventType;
 
-  fn name(&self) -> Cow<'static, str> {
-    self.0.name()
-  }
+    fn name(&self) -> Cow<'static, str> {
+        self.0.name()
+    }
 
-  fn bubbles(&self) -> bool {
-    false
-  }
+    fn bubbles(&self) -> bool {
+        false
+    }
 }
 
 /// A custom event.
 pub struct Custom<E: FromWasmAbi = web_sys::Event> {
-  name: Cow<'static, str>,
-  _event_type: PhantomData<E>,
+    name: Cow<'static, str>,
+    _event_type: PhantomData<E>,
 }
 
 impl<E: FromWasmAbi> Clone for Custom<E> {
-  fn clone(&self) -> Self {
-    Self {
-      name: self.name.clone(),
-      _event_type: PhantomData,
+    fn clone(&self) -> Self {
+        Self {
+            name: self.name.clone(),
+            _event_type: PhantomData,
+        }
     }
-  }
 }
 
 impl<E: FromWasmAbi> EventDescriptor for Custom<E> {
-  type EventType = E;
+    type EventType = E;
 
-  fn name(&self) -> Cow<'static, str> {
-    self.name.clone()
-  }
+    fn name(&self) -> Cow<'static, str> {
+        self.name.clone()
+    }
 
-  fn bubbles(&self) -> bool {
-    false
-  }
+    fn bubbles(&self) -> bool {
+        false
+    }
 }
 
 impl<E: FromWasmAbi> Custom<E> {
-  /// Creates a custom event type that can be used within
-  /// [`HtmlElement::on`](crate::HtmlElement::on), for events
-  /// which are not covered in the [`ev`](crate::ev) module.
-  pub fn new(name: impl Into<Cow<'static, str>>) -> Self {
-    Self {
-      name: name.into(),
-      _event_type: PhantomData,
+    /// Creates a custom event type that can be used within
+    /// [`HtmlElement::on`](crate::HtmlElement::on), for events
+    /// which are not covered in the [`ev`](crate::ev) module.
+    pub fn new(name: impl Into<Cow<'static, str>>) -> Self {
+        Self {
+            name: name.into(),
+            _event_type: PhantomData,
+        }
     }
-  }
 }
 
 macro_rules! generate_event_types {
@@ -268,3 +268,13 @@ generate_event_types! {
   readystatechange: Event,
   visibilitychange: Event,
 }
+
+// Export `web_sys` event types
+pub use web_sys::{
+    AnimationEvent, BeforeUnloadEvent, CompositionEvent, DeviceMotionEvent,
+    DeviceOrientationEvent, DragEvent, ErrorEvent, FocusEvent, GamepadEvent,
+    HashChangeEvent, InputEvent, KeyboardEvent, MouseEvent,
+    PageTransitionEvent, PointerEvent, PopStateEvent, ProgressEvent,
+    PromiseRejectionEvent, SecurityPolicyViolationEvent, StorageEvent,
+    SubmitEvent, TouchEvent, TransitionEvent, UiEvent, WheelEvent,
+};

leptos_dom/src/helpers.rs

@@ -1,56 +1,58 @@
+//! A variety of DOM utility functions.
+
 use crate::{is_server, window};
 use std::time::Duration;
 use wasm_bindgen::{prelude::Closure, JsCast, JsValue, UnwrapThrowExt};
 
 /// Sets a property on a DOM element.
 pub fn set_property(
-  el: &web_sys::Element,
-  prop_name: &str,
-  value: &Option<JsValue>,
+    el: &web_sys::Element,
+    prop_name: &str,
+    value: &Option<JsValue>,
 ) {
-  let key = JsValue::from_str(prop_name);
-  match value {
-    Some(value) => _ = js_sys::Reflect::set(el, &key, value),
-    None => _ = js_sys::Reflect::delete_property(el, &key),
-  };
+    let key = JsValue::from_str(prop_name);
+    match value {
+        Some(value) => _ = js_sys::Reflect::set(el, &key, value),
+        None => _ = js_sys::Reflect::delete_property(el, &key),
+    };
 }
 
 /// Gets the value of a property set on a DOM element.
 pub fn get_property(
-  el: &web_sys::Element,
-  prop_name: &str,
+    el: &web_sys::Element,
+    prop_name: &str,
 ) -> Result<JsValue, JsValue> {
-  let key = JsValue::from_str(prop_name);
-  js_sys::Reflect::get(el, &key)
+    let key = JsValue::from_str(prop_name);
+    js_sys::Reflect::get(el, &key)
 }
 
 /// Returns the current [`window.location`](https://developer.mozilla.org/en-US/docs/Web/API/Window/location).
 pub fn location() -> web_sys::Location {
-  window().location()
+    window().location()
 }
 
 /// Current [`window.location.hash`](https://developer.mozilla.org/en-US/docs/Web/API/Window/location)
 /// without the beginning #.
 pub fn location_hash() -> Option<String> {
-  if is_server() {
-    None
-  } else {
-    location().hash().ok().map(|hash| hash.replace('#', ""))
-  }
+    if is_server() {
+        None
+    } else {
+        location().hash().ok().map(|hash| hash.replace('#', ""))
+    }
 }
 
 /// Current [`window.location.pathname`](https://developer.mozilla.org/en-US/docs/Web/API/Window/location).
 pub fn location_pathname() -> Option<String> {
-  location().pathname().ok()
+    location().pathname().ok()
 }
 
 /// Helper function to extract [`Event.target`](https://developer.mozilla.org/en-US/docs/Web/API/Event/target)
 /// from any event.
 pub fn event_target<T>(event: &web_sys::Event) -> T
 where
-  T: JsCast,
+    T: JsCast,
 {
-  event.target().unwrap_throw().unchecked_into::<T>()
+    event.target().unwrap_throw().unchecked_into::<T>()
 }
 
 /// Helper function to extract `event.target.value` from an event.
@@ -58,60 +60,60 @@ where
 /// This is useful in the `on:input` or `on:change` listeners for an `<input>` element.
 pub fn event_target_value<T>(event: &T) -> String
 where
-  T: JsCast,
+    T: JsCast,
 {
-  event
-    .unchecked_ref::<web_sys::Event>()
-    .target()
-    .unwrap_throw()
-    .unchecked_into::<web_sys::HtmlInputElement>()
-    .value()
+    event
+        .unchecked_ref::<web_sys::Event>()
+        .target()
+        .unwrap_throw()
+        .unchecked_into::<web_sys::HtmlInputElement>()
+        .value()
 }
 
 /// Helper function to extract `event.target.checked` from an event.
 ///
 /// This is useful in the `on:change` listeners for an `<input type="checkbox">` element.
 pub fn event_target_checked(ev: &web_sys::Event) -> bool {
-  ev.target()
-    .unwrap()
-    .unchecked_into::<web_sys::HtmlInputElement>()
-    .checked()
+    ev.target()
+        .unwrap()
+        .unchecked_into::<web_sys::HtmlInputElement>()
+        .checked()
 }
 
 /// Runs the given function between the next repaint
 /// using [`Window.requestAnimationFrame`](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame).
 #[cfg_attr(debug_assertions, instrument(level = "trace", skip_all))]
 pub fn request_animation_frame(cb: impl FnOnce() + 'static) {
-  cfg_if::cfg_if! {
-    if #[cfg(debug_assertions)] {
-      let span = ::tracing::Span::current();
-      let cb = move || {
-        let _guard = span.enter();
-        cb();
-      };
+    cfg_if::cfg_if! {
+      if #[cfg(debug_assertions)] {
+        let span = ::tracing::Span::current();
+        let cb = move || {
+          let _guard = span.enter();
+          cb();
+        };
+      }
     }
-  }
 
-  let cb = Closure::once_into_js(cb);
-  _ = window().request_animation_frame(cb.as_ref().unchecked_ref());
+    let cb = Closure::once_into_js(cb);
+    _ = window().request_animation_frame(cb.as_ref().unchecked_ref());
 }
 
 /// Queues the given function during an idle period  
 /// using [`Window.requestIdleCallback`](https://developer.mozilla.org/en-US/docs/Web/API/window/requestIdleCallback).
 #[cfg_attr(debug_assertions, instrument(level = "trace", skip_all))]
 pub fn request_idle_callback(cb: impl Fn() + 'static) {
-  cfg_if::cfg_if! {
-    if #[cfg(debug_assertions)] {
-      let span = ::tracing::Span::current();
-      let cb = move || {
-        let _guard = span.enter();
-        cb();
-      };
+    cfg_if::cfg_if! {
+      if #[cfg(debug_assertions)] {
+        let span = ::tracing::Span::current();
+        let cb = move || {
+          let _guard = span.enter();
+          cb();
+        };
+      }
     }
-  }
 
-  let cb = Closure::wrap(Box::new(cb) as Box<dyn Fn()>).into_js_value();
-  _ = window().request_idle_callback(cb.as_ref().unchecked_ref());
+    let cb = Closure::wrap(Box::new(cb) as Box<dyn Fn()>).into_js_value();
+    _ = window().request_idle_callback(cb.as_ref().unchecked_ref());
 }
 
 /// Executes the given function after the given duration of time has passed.
@@ -121,21 +123,21 @@ pub fn request_idle_callback(cb: impl Fn() + 'static) {
   instrument(level = "trace", skip_all, fields(duration = ?duration))
 )]
 pub fn set_timeout(cb: impl FnOnce() + 'static, duration: Duration) {
-  cfg_if::cfg_if! {
-    if #[cfg(debug_assertions)] {
-      let span = ::tracing::Span::current();
-      let cb = move || {
-        let _guard = span.enter();
-        cb();
-      };
+    cfg_if::cfg_if! {
+      if #[cfg(debug_assertions)] {
+        let span = ::tracing::Span::current();
+        let cb = move || {
+          let _guard = span.enter();
+          cb();
+        };
+      }
     }
-  }
 
-  let cb = Closure::once_into_js(Box::new(cb) as Box<dyn FnOnce()>);
-  _ = window().set_timeout_with_callback_and_timeout_and_arguments_0(
-    cb.as_ref().unchecked_ref(),
-    duration.as_millis().try_into().unwrap_throw(),
-  );
+    let cb = Closure::once_into_js(Box::new(cb) as Box<dyn FnOnce()>);
+    _ = window().set_timeout_with_callback_and_timeout_and_arguments_0(
+        cb.as_ref().unchecked_ref(),
+        duration.as_millis().try_into().unwrap_throw(),
+    );
 }
 
 /// Handle that is generated by [set_interval] and can be used to clear the interval.
@@ -143,11 +145,11 @@ pub fn set_timeout(cb: impl FnOnce() + 'static, duration: Duration) {
 pub struct IntervalHandle(i32);
 
 impl IntervalHandle {
-  /// Cancels the repeating event to which this refers.
-  /// See [`clearInterval()`](https://developer.mozilla.org/en-US/docs/Web/API/clearInterval)
-  pub fn clear(&self) {
-    window().clear_interval_with_handle(self.0);
-  }
+    /// Cancels the repeating event to which this refers.
+    /// See [`clearInterval()`](https://developer.mozilla.org/en-US/docs/Web/API/clearInterval)
+    pub fn clear(&self) {
+        window().clear_interval_with_handle(self.0);
+    }
 }
 
 /// Repeatedly calls the given function, with a delay of the given duration between calls.
@@ -157,26 +159,26 @@ impl IntervalHandle {
   instrument(level = "trace", skip_all, fields(duration = ?duration))
 )]
 pub fn set_interval(
-  cb: impl Fn() + 'static,
-  duration: Duration,
+    cb: impl Fn() + 'static,
+    duration: Duration,
 ) -> Result<IntervalHandle, JsValue> {
-  cfg_if::cfg_if! {
-    if #[cfg(debug_assertions)] {
-      let span = ::tracing::Span::current();
-      let cb = move || {
-        let _guard = span.enter();
-        cb();
-      };
+    cfg_if::cfg_if! {
+      if #[cfg(debug_assertions)] {
+        let span = ::tracing::Span::current();
+        let cb = move || {
+          let _guard = span.enter();
+          cb();
+        };
+      }
     }
-  }
 
-  let cb = Closure::wrap(Box::new(cb) as Box<dyn Fn()>).into_js_value();
-  let handle = window()
-    .set_interval_with_callback_and_timeout_and_arguments_0(
-      cb.as_ref().unchecked_ref(),
-      duration.as_millis().try_into().unwrap_throw(),
-    )?;
-  Ok(IntervalHandle(handle))
+    let cb = Closure::wrap(Box::new(cb) as Box<dyn Fn()>).into_js_value();
+    let handle = window()
+        .set_interval_with_callback_and_timeout_and_arguments_0(
+            cb.as_ref().unchecked_ref(),
+            duration.as_millis().try_into().unwrap_throw(),
+        )?;
+    Ok(IntervalHandle(handle))
 }
 
 /// Adds an event listener to the `Window`.
@@ -185,34 +187,34 @@ pub fn set_interval(
   instrument(level = "trace", skip_all, fields(event_name = %event_name))
 )]
 pub fn window_event_listener(
-  event_name: &str,
-  cb: impl Fn(web_sys::Event) + 'static,
+    event_name: &str,
+    cb: impl Fn(web_sys::Event) + 'static,
 ) {
-  cfg_if::cfg_if! {
-    if #[cfg(debug_assertions)] {
-      let span = ::tracing::Span::current();
-      let cb = move |e| {
-        let _guard = span.enter();
-        cb(e);
-      };
+    cfg_if::cfg_if! {
+      if #[cfg(debug_assertions)] {
+        let span = ::tracing::Span::current();
+        let cb = move |e| {
+          let _guard = span.enter();
+          cb(e);
+        };
+      }
     }
-  }
 
-  if !is_server() {
-    let handler = Box::new(cb) as Box<dyn FnMut(web_sys::Event)>;
+    if !is_server() {
+        let handler = Box::new(cb) as Box<dyn FnMut(web_sys::Event)>;
 
-    let cb = Closure::wrap(handler).into_js_value();
-    _ =
-      window().add_event_listener_with_callback(event_name, cb.unchecked_ref());
-  }
+        let cb = Closure::wrap(handler).into_js_value();
+        _ = window()
+            .add_event_listener_with_callback(event_name, cb.unchecked_ref());
+    }
 }
 
 #[doc(hidden)]
 /// This exists only to enable type inference on event listeners when in SSR mode.
 pub fn ssr_event_listener<E: crate::ev::EventDescriptor + 'static>(
-  event: E,
-  event_handler: impl FnMut(E::EventType) + 'static,
+    event: E,
+    event_handler: impl FnMut(E::EventType) + 'static,
 ) {
-  _ = event;
-  _ = event_handler;
+    _ = event;
+    _ = event_handler;
 }

leptos_dom/src/hydration.rs

@@ -51,25 +51,25 @@ cfg_if! {
 /// A stable identifer within the server-rendering or hydration process.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct HydrationKey {
-  /// The key of the previous component.
-  pub previous: String,
-  /// The element offset within the current component.
-  pub offset: usize,
+    /// The key of the previous component.
+    pub previous: String,
+    /// The element offset within the current component.
+    pub offset: usize,
 }
 
 impl Display for HydrationKey {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    write!(f, "{}{}", self.previous, self.offset)
-  }
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}{}", self.previous, self.offset)
+    }
 }
 
 impl Default for HydrationKey {
-  fn default() -> Self {
-    Self {
-      previous: "0-".to_string(),
-      offset: 0,
+    fn default() -> Self {
+        Self {
+            previous: "0-".to_string(),
+            offset: 0,
+        }
     }
-  }
 }
 
 thread_local!(static ID: RefCell<HydrationKey> = Default::default());
@@ -78,65 +78,65 @@ thread_local!(static ID: RefCell<HydrationKey> = Default::default());
 pub struct HydrationCtx;
 
 impl HydrationCtx {
-  /// Get the next `id` without incrementing it.
-  pub fn peek() -> HydrationKey {
-    ID.with(|id| id.borrow().clone())
-  }
-
-  /// Increments the current hydration `id` and returns it
-  pub fn id() -> HydrationKey {
-    ID.with(|id| {
-      let mut id = id.borrow_mut();
-      id.offset = id.offset.wrapping_add(1);
-      id.clone()
-    })
-  }
-
-  /// Resets the hydration `id` for the next component, and returns it
-  pub fn next_component() -> HydrationKey {
-    ID.with(|id| {
-      let mut id = id.borrow_mut();
-      let offset = id.offset;
-      id.previous.push_str(&offset.to_string());
-      id.previous.push('-');
-      id.offset = 0;
-      id.clone()
-    })
-  }
-
-  #[doc(hidden)]
-  #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
-  pub fn reset_id() {
-    ID.with(|id| *id.borrow_mut() = Default::default());
-  }
-
-  /// Resums hydration from the provided `id`. Usefull for
-  /// `Suspense` and other fancy things.
-  pub fn continue_from(id: HydrationKey) {
-    ID.with(|i| *i.borrow_mut() = id);
-  }
-
-  #[cfg(all(target_arch = "wasm32", feature = "web"))]
-  pub(crate) fn stop_hydrating() {
-    IS_HYDRATING.with(|is_hydrating| {
-      std::mem::take(&mut *is_hydrating.borrow_mut());
-    })
-  }
-
-  #[cfg(all(target_arch = "wasm32", feature = "web"))]
-  pub(crate) fn is_hydrating() -> bool {
-    IS_HYDRATING.with(|is_hydrating| **is_hydrating.borrow())
-  }
-
-  pub(crate) fn to_string(id: &HydrationKey, closing: bool) -> String {
-    #[cfg(debug_assertions)]
-    return format!("_{id}{}", if closing { 'c' } else { 'o' });
-
-    #[cfg(not(debug_assertions))]
-    {
-      let _ = closing;
-
-      format!("_{id}")
+    /// Get the next `id` without incrementing it.
+    pub fn peek() -> HydrationKey {
+        ID.with(|id| id.borrow().clone())
+    }
+
+    /// Increments the current hydration `id` and returns it
+    pub fn id() -> HydrationKey {
+        ID.with(|id| {
+            let mut id = id.borrow_mut();
+            id.offset = id.offset.wrapping_add(1);
+            id.clone()
+        })
+    }
+
+    /// Resets the hydration `id` for the next component, and returns it
+    pub fn next_component() -> HydrationKey {
+        ID.with(|id| {
+            let mut id = id.borrow_mut();
+            let offset = id.offset;
+            id.previous.push_str(&offset.to_string());
+            id.previous.push('-');
+            id.offset = 0;
+            id.clone()
+        })
+    }
+
+    #[doc(hidden)]
+    #[cfg(not(all(target_arch = "wasm32", feature = "web")))]
+    pub fn reset_id() {
+        ID.with(|id| *id.borrow_mut() = Default::default());
+    }
+
+    /// Resumes hydration from the provided `id`. Useful for
+    /// `Suspense` and other fancy things.
+    pub fn continue_from(id: HydrationKey) {
+        ID.with(|i| *i.borrow_mut() = id);
+    }
+
+    #[cfg(all(target_arch = "wasm32", feature = "web"))]
+    pub(crate) fn stop_hydrating() {
+        IS_HYDRATING.with(|is_hydrating| {
+            std::mem::take(&mut *is_hydrating.borrow_mut());
+        })
+    }
+
+    #[cfg(all(target_arch = "wasm32", feature = "web"))]
+    pub(crate) fn is_hydrating() -> bool {
+        IS_HYDRATING.with(|is_hydrating| **is_hydrating.borrow())
+    }
+
+    pub(crate) fn to_string(id: &HydrationKey, closing: bool) -> String {
+        #[cfg(debug_assertions)]
+        return format!("_{id}{}", if closing { 'c' } else { 'o' });
+
+        #[cfg(not(debug_assertions))]
+        {
+            let _ = closing;
+
+            format!("_{id}")
+        }
     }
-  }
 }

leptos_dom/src/logging.rs

@@ -44,45 +44,45 @@ macro_rules! debug_warn {
 /// Log a string to the console (in the browser)
 /// or via `println!()` (if not in the browser).
 pub fn console_log(s: &str) {
-  if is_server() {
-    println!("{s}");
-  } else {
-    web_sys::console::log_1(&JsValue::from_str(s));
-  }
+    if is_server() {
+        println!("{s}");
+    } else {
+        web_sys::console::log_1(&JsValue::from_str(s));
+    }
 }
 
 /// Log a warning to the console (in the browser)
 /// or via `println!()` (if not in the browser).
 pub fn console_warn(s: &str) {
-  if is_server() {
-    eprintln!("{s}");
-  } else {
-    web_sys::console::warn_1(&JsValue::from_str(s));
-  }
+    if is_server() {
+        eprintln!("{s}");
+    } else {
+        web_sys::console::warn_1(&JsValue::from_str(s));
+    }
 }
 
 /// Log an error to the console (in the browser)
 /// or via `println!()` (if not in the browser).
 pub fn console_error(s: &str) {
-  if is_server() {
-    eprintln!("{s}");
-  } else {
-    web_sys::console::warn_1(&JsValue::from_str(s));
-  }
+    if is_server() {
+        eprintln!("{s}");
+    } else {
+        web_sys::console::warn_1(&JsValue::from_str(s));
+    }
 }
 
 /// Log an error to the console (in the browser)
 /// or via `println!()` (if not in the browser), but only in a debug build.
 pub fn console_debug_warn(s: &str) {
-  cfg_if! {
-      if #[cfg(debug_assertions)] {
-          if is_server() {
-              eprintln!("{s}");
-          } else {
-              web_sys::console::warn_1(&JsValue::from_str(s));
-          }
-      } else {
-        let _ = s;
-      }
-  }
+    cfg_if! {
+        if #[cfg(debug_assertions)] {
+            if is_server() {
+                eprintln!("{s}");
+            } else {
+                web_sys::console::warn_1(&JsValue::from_str(s));
+            }
+        } else {
+          let _ = s;
+        }
+    }
 }

leptos_dom/src/macro_helpers/into_attribute.rs

@@ -1,158 +1,236 @@
-use std::rc::Rc;
-
 use leptos_reactive::Scope;
+use std::rc::Rc;
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
 use wasm_bindgen::UnwrapThrowExt;
 
 /// Represents the different possible values an attribute node could have.
 ///
 /// This mostly exists for the [`view`](https://docs.rs/leptos_macro/latest/leptos_macro/macro.view.html)
-/// macro’s use. You usually won't need to interact with it directly.
+/// macro’s use. You usually won't need to interact with it directly, but it can be useful for defining
+/// permissive APIs for certain components.
 #[derive(Clone)]
 pub enum Attribute {
-  /// A plain string value.
-  String(String),
-  /// A (presumably reactive) function, which will be run inside an effect to do targeted updates to the attribute.
-  Fn(Scope, Rc<dyn Fn() -> Attribute>),
-  /// An optional string value, which sets the attribute to the value if `Some` and removes the attribute if `None`.
-  Option(Scope, Option<String>),
-  /// A boolean attribute, which sets the attribute if `true` and removes the attribute if `false`.
-  Bool(bool),
+    /// A plain string value.
+    String(String),
+    /// A (presumably reactive) function, which will be run inside an effect to do targeted updates to the attribute.
+    Fn(Scope, Rc<dyn Fn() -> Attribute>),
+    /// An optional string value, which sets the attribute to the value if `Some` and removes the attribute if `None`.
+    Option(Scope, Option<String>),
+    /// A boolean attribute, which sets the attribute if `true` and removes the attribute if `false`.
+    Bool(bool),
 }
 
 impl Attribute {
-  /// Converts the attribute to its HTML value at that moment, including the attribute name,
-  /// so it can be rendered on the server.
-  pub fn as_value_string(&self, attr_name: &'static str) -> String {
-    match self {
-      Attribute::String(value) => format!("{attr_name}=\"{value}\""),
-      Attribute::Fn(_, f) => {
-        let mut value = f();
-        while let Attribute::Fn(_, f) = value {
-          value = f();
+    /// Converts the attribute to its HTML value at that moment, including the attribute name,
+    /// so it can be rendered on the server.
+    pub fn as_value_string(&self, attr_name: &'static str) -> String {
+        match self {
+            Attribute::String(value) => format!("{attr_name}=\"{value}\""),
+            Attribute::Fn(_, f) => {
+                let mut value = f();
+                while let Attribute::Fn(_, f) = value {
+                    value = f();
+                }
+                value.as_value_string(attr_name)
+            }
+            Attribute::Option(_, value) => value
+                .as_ref()
+                .map(|value| format!("{attr_name}=\"{value}\""))
+                .unwrap_or_default(),
+            Attribute::Bool(include) => {
+                if *include {
+                    attr_name.to_string()
+                } else {
+                    String::new()
+                }
+            }
         }
-        value.as_value_string(attr_name)
-      }
-      Attribute::Option(_, value) => value
-        .as_ref()
-        .map(|value| format!("{attr_name}=\"{value}\""))
-        .unwrap_or_default(),
-      Attribute::Bool(include) => {
-        if *include {
-          attr_name.to_string()
-        } else {
-          String::new()
-        }
-      }
     }
-  }
 
-  /// Converts the attribute to its HTML value at that moment, not including
-  /// the attribute name, so it can be rendered on the server.
-  pub fn as_nameless_value_string(&self) -> Option<String> {
-    match self {
-      Attribute::String(value) => Some(value.to_string()),
-      Attribute::Fn(_, f) => {
-        let mut value = f();
-        while let Attribute::Fn(_, f) = value {
-          value = f();
+    /// Converts the attribute to its HTML value at that moment, not including
+    /// the attribute name, so it can be rendered on the server.
+    pub fn as_nameless_value_string(&self) -> Option<String> {
+        match self {
+            Attribute::String(value) => Some(value.to_string()),
+            Attribute::Fn(_, f) => {
+                let mut value = f();
+                while let Attribute::Fn(_, f) = value {
+                    value = f();
+                }
+                value.as_nameless_value_string()
+            }
+            Attribute::Option(_, value) => {
+                value.as_ref().map(|value| value.to_string())
+            }
+            Attribute::Bool(include) => {
+                if *include {
+                    Some("".to_string())
+                } else {
+                    None
+                }
+            }
         }
-        value.as_nameless_value_string()
-      }
-      Attribute::Option(_, value) => {
-        value.as_ref().map(|value| value.to_string())
-      }
-      Attribute::Bool(include) => {
-        if *include {
-          Some("".to_string())
-        } else {
-          None
-        }
-      }
     }
-  }
 }
 
 impl PartialEq for Attribute {
-  fn eq(&self, other: &Self) -> bool {
-    match (self, other) {
-      (Self::String(l0), Self::String(r0)) => l0 == r0,
-      (Self::Fn(_, _), Self::Fn(_, _)) => false,
-      (Self::Option(_, l0), Self::Option(_, r0)) => l0 == r0,
-      (Self::Bool(l0), Self::Bool(r0)) => l0 == r0,
-      _ => false,
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::String(l0), Self::String(r0)) => l0 == r0,
+            (Self::Fn(_, _), Self::Fn(_, _)) => false,
+            (Self::Option(_, l0), Self::Option(_, r0)) => l0 == r0,
+            (Self::Bool(l0), Self::Bool(r0)) => l0 == r0,
+            _ => false,
+        }
     }
-  }
 }
 
 impl std::fmt::Debug for Attribute {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    match self {
-      Self::String(arg0) => f.debug_tuple("String").field(arg0).finish(),
-      Self::Fn(_, _) => f.debug_tuple("Fn").finish(),
-      Self::Option(_, arg0) => f.debug_tuple("Option").field(arg0).finish(),
-      Self::Bool(arg0) => f.debug_tuple("Bool").field(arg0).finish(),
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::String(arg0) => f.debug_tuple("String").field(arg0).finish(),
+            Self::Fn(_, _) => f.debug_tuple("Fn").finish(),
+            Self::Option(_, arg0) => {
+                f.debug_tuple("Option").field(arg0).finish()
+            }
+            Self::Bool(arg0) => f.debug_tuple("Bool").field(arg0).finish(),
+        }
     }
-  }
 }
 
 /// Converts some type into an [Attribute].
 ///
 /// This is implemented by default for Rust primitive and string types.
 pub trait IntoAttribute {
-  /// Converts the object into an [Attribute].
-  fn into_attribute(self, cx: Scope) -> Attribute;
+    /// Converts the object into an [Attribute].
+    fn into_attribute(self, cx: Scope) -> Attribute;
+    /// Helper function for dealing with `Box<dyn IntoAttribute>`.
+    fn into_attribute_boxed(self: Box<Self>, cx: Scope) -> Attribute;
+}
+
+impl<T: IntoAttribute + 'static> From<T> for Box<dyn IntoAttribute> {
+    fn from(value: T) -> Self {
+        Box::new(value)
+    }
+}
+
+impl IntoAttribute for Attribute {
+    #[inline]
+    fn into_attribute(self, _: Scope) -> Attribute {
+        self
+    }
+
+    #[inline]
+    fn into_attribute_boxed(self: Box<Self>, _: Scope) -> Attribute {
+        *self
+    }
+}
+
+macro_rules! impl_into_attr_boxed {
+    () => {
+        #[inline]
+        fn into_attribute_boxed(self: Box<Self>, cx: Scope) -> Attribute {
+            self.into_attribute(cx)
+        }
+    };
+}
+
+impl IntoAttribute for Option<Attribute> {
+    fn into_attribute(self, cx: Scope) -> Attribute {
+        self.unwrap_or(Attribute::Option(cx, None))
+    }
+
+    impl_into_attr_boxed! {}
 }
 
 impl IntoAttribute for String {
-  fn into_attribute(self, _: Scope) -> Attribute {
-    Attribute::String(self)
-  }
+    fn into_attribute(self, _: Scope) -> Attribute {
+        Attribute::String(self)
+    }
+
+    impl_into_attr_boxed! {}
 }
 
 impl IntoAttribute for bool {
-  fn into_attribute(self, _: Scope) -> Attribute {
-    Attribute::Bool(self)
-  }
+    fn into_attribute(self, _: Scope) -> Attribute {
+        Attribute::Bool(self)
+    }
+
+    impl_into_attr_boxed! {}
 }
 
 impl IntoAttribute for Option<String> {
-  fn into_attribute(self, cx: Scope) -> Attribute {
-    Attribute::Option(cx, self)
-  }
+    fn into_attribute(self, cx: Scope) -> Attribute {
+        Attribute::Option(cx, self)
+    }
+
+    impl_into_attr_boxed! {}
 }
 
 impl<T, U> IntoAttribute for T
 where
-  T: Fn() -> U + 'static,
-  U: IntoAttribute,
+    T: Fn() -> U + 'static,
+    U: IntoAttribute,
 {
-  fn into_attribute(self, cx: Scope) -> Attribute {
-    let modified_fn = Rc::new(move || (self)().into_attribute(cx));
-    Attribute::Fn(cx, modified_fn)
-  }
+    fn into_attribute(self, cx: Scope) -> Attribute {
+        let modified_fn = Rc::new(move || (self)().into_attribute(cx));
+        Attribute::Fn(cx, modified_fn)
+    }
+
+    impl_into_attr_boxed! {}
 }
 
 impl<T: IntoAttribute> IntoAttribute for (Scope, T) {
-  fn into_attribute(self, _: Scope) -> Attribute {
-    self.1.into_attribute(self.0)
-  }
+    fn into_attribute(self, _: Scope) -> Attribute {
+        self.1.into_attribute(self.0)
+    }
+
+    impl_into_attr_boxed! {}
+}
+
+impl IntoAttribute for (Scope, Option<Box<dyn IntoAttribute>>) {
+    fn into_attribute(self, _: Scope) -> Attribute {
+        match self.1 {
+            Some(bx) => bx.into_attribute_boxed(self.0),
+            None => Attribute::Option(self.0, None),
+        }
+    }
+
+    impl_into_attr_boxed! {}
+}
+
+impl IntoAttribute for (Scope, Box<dyn IntoAttribute>) {
+    fn into_attribute(self, _: Scope) -> Attribute {
+        self.1.into_attribute_boxed(self.0)
+    }
+
+    impl_into_attr_boxed! {}
 }
 
 macro_rules! attr_type {
-  ($attr_type:ty) => {
-    impl IntoAttribute for $attr_type {
-      fn into_attribute(self, _: Scope) -> Attribute {
-        Attribute::String(self.to_string())
-      }
-    }
+    ($attr_type:ty) => {
+        impl IntoAttribute for $attr_type {
+            fn into_attribute(self, _: Scope) -> Attribute {
+                Attribute::String(self.to_string())
+            }
 
-    impl IntoAttribute for Option<$attr_type> {
-      fn into_attribute(self, cx: Scope) -> Attribute {
-        Attribute::Option(cx, self.map(|n| n.to_string()))
-      }
-    }
-  };
+            #[inline]
+            fn into_attribute_boxed(self: Box<Self>, cx: Scope) -> Attribute {
+                self.into_attribute(cx)
+            }
+        }
+
+        impl IntoAttribute for Option<$attr_type> {
+            fn into_attribute(self, cx: Scope) -> Attribute {
+                Attribute::Option(cx, self.map(|n| n.to_string()))
+            }
+
+            #[inline]
+            fn into_attribute_boxed(self: Box<Self>, cx: Scope) -> Attribute {
+                self.into_attribute(cx)
+            }
+        }
+    };
 }
 
 attr_type!(&String);
@@ -177,64 +255,64 @@ attr_type!(char);
 use std::borrow::Cow;
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
 pub(crate) fn attribute_helper(
-  el: &web_sys::Element,
-  name: Cow<'static, str>,
-  value: Attribute,
+    el: &web_sys::Element,
+    name: Cow<'static, str>,
+    value: Attribute,
 ) {
-  use leptos_reactive::create_render_effect;
-  match value {
-    Attribute::Fn(cx, f) => {
-      let el = el.clone();
-      create_render_effect(cx, move |old| {
-        let new = f();
-        if old.as_ref() != Some(&new) {
-          attribute_expression(&el, &name, new.clone());
+    use leptos_reactive::create_render_effect;
+    match value {
+        Attribute::Fn(cx, f) => {
+            let el = el.clone();
+            create_render_effect(cx, move |old| {
+                let new = f();
+                if old.as_ref() != Some(&new) {
+                    attribute_expression(&el, &name, new.clone());
+                }
+                new
+            });
         }
-        new
-      });
-    }
-    _ => attribute_expression(el, &name, value),
-  };
+        _ => attribute_expression(el, &name, value),
+    };
 }
 
 #[cfg(all(target_arch = "wasm32", feature = "web"))]
 pub(crate) fn attribute_expression(
-  el: &web_sys::Element,
-  attr_name: &str,
-  value: Attribute,
+    el: &web_sys::Element,
+    attr_name: &str,
+    value: Attribute,
 ) {
-  match value {
-    Attribute::String(value) => {
-      let value = wasm_bindgen::intern(&value);
-      if attr_name == "inner_html" {
-        el.set_inner_html(value);
-      } else {
-        let attr_name = wasm_bindgen::intern(attr_name);
-        el.set_attribute(attr_name, value).unwrap_throw();
-      }
-    }
-    Attribute::Option(_, value) => {
-      if attr_name == "inner_html" {
-        el.set_inner_html(&value.unwrap_or_default());
-      } else {
-        let attr_name = wasm_bindgen::intern(attr_name);
-        match value {
-          Some(value) => {
+    match value {
+        Attribute::String(value) => {
             let value = wasm_bindgen::intern(&value);
-            el.set_attribute(attr_name, value).unwrap_throw();
-          }
-          None => el.remove_attribute(attr_name).unwrap_throw(),
+            if attr_name == "inner_html" {
+                el.set_inner_html(value);
+            } else {
+                let attr_name = wasm_bindgen::intern(attr_name);
+                el.set_attribute(attr_name, value).unwrap_throw();
+            }
         }
-      }
+        Attribute::Option(_, value) => {
+            if attr_name == "inner_html" {
+                el.set_inner_html(&value.unwrap_or_default());
+            } else {
+                let attr_name = wasm_bindgen::intern(attr_name);
+                match value {
+                    Some(value) => {
+                        let value = wasm_bindgen::intern(&value);
+                        el.set_attribute(attr_name, value).unwrap_throw();
+                    }
+                    None => el.remove_attribute(attr_name).unwrap_throw(),
+                }
+            }
+        }
+        Attribute::Bool(value) => {
+            let attr_name = wasm_bindgen::intern(attr_name);
+            if value {
+                el.set_attribute(attr_name, attr_name).unwrap_throw();
+            } else {
+                el.remove_attribute(attr_name).unwrap_throw();
+            }
+        }
+        _ => panic!("Remove nested Fn in Attribute"),
     }
-    Attribute::Bool(value) => {
-      let attr_name = wasm_bindgen::intern(attr_name);
-      if value {
-        el.set_attribute(attr_name, attr_name).unwrap_throw();
-      } else {
-        el.remove_attribute(attr_name).unwrap_throw();
-      }
-    }
-    _ => panic!("Remove nested Fn in Attribute"),
-  }
 }