fix: issue with ordering of class attribute and class=("fancy-name-200", true) (closes #907) (#914)

* Fixes #890 that was using OnceLock, which is nightly only, by adding the once_cell crate as a dependency.

* Make `cargo fmt` happy

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: gbj

.github/workflows/check-examples.yml

@@ -0,0 +1,45 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Check examples ${{ matrix.os }} (using rustc ${{ matrix.rust }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust:
+          - nightly
+        os:
+          - ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          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
+
+      - name: Cargo generate-lockfile
+        run: cargo generate-lockfile
+
+      - uses: Swatinem/rust-cache@v2
+
+      - name: Run cargo check on all examples
+        run: cargo make check-examples

.github/workflows/check-stable.yml

@@ -0,0 +1,45 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Check examples ${{ matrix.os }} (using rustc ${{ matrix.rust }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust:
+          - stable
+        os:
+          - ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          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
+
+      - name: Cargo generate-lockfile
+        run: cargo generate-lockfile
+
+      - uses: Swatinem/rust-cache@v2
+
+      - name: Run cargo check on all examples
+        run: cargo make --profile=github-actions check-stable

.github/workflows/check.yml

@@ -0,0 +1,45 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Run `cargo check` ${{ matrix.os }} (using rustc ${{ matrix.rust }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust:
+          - nightly
+        os:
+          - ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          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
+
+      - name: Cargo generate-lockfile
+        run: cargo generate-lockfile
+
+      - uses: Swatinem/rust-cache@v2
+
+      - name: Run cargo check on all libraries
+        run: cargo make --profile=github-actions check

.github/workflows/fmt.yml

@@ -0,0 +1,34 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Run rustfmt
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust:
+          - nightly
+        os:
+          - ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt
+
+      - name: Run Rustfmt
+        run: cargo fmt -- --check

.github/workflows/publish-book.yml

@@ -0,0 +1,37 @@
+name: Deploy book
+on:
+  push:
+    paths: ['docs/book/**']
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write  # To push a branch 
+      pull-requests: write  # To create a PR from that branch
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+    - name: Install mdbook
+      run: |
+        mkdir mdbook
+        curl -sSL https://github.com/rust-lang/mdBook/releases/download/v0.4.27/mdbook-v0.4.27-x86_64-unknown-linux-gnu.tar.gz | tar -xz --directory=./mdbook
+        echo `pwd`/mdbook >> $GITHUB_PATH
+    - name: Deploy GitHub Pages
+      run: |
+        cd docs/book
+        mdbook build
+        git worktree add gh-pages
+        git config user.name "Deploy book from CI"
+        git config user.email ""
+        cd gh-pages
+        # Delete the ref to avoid keeping history.
+        git update-ref -d refs/heads/gh-pages
+        rm -rf *
+        mv ../book/* .
+        git add .
+        git commit -m "Deploy book $GITHUB_SHA to gh-pages"
+        git push --force --set-upstream origin gh-pages

.github/workflows/test.yml

@@ -11,7 +11,7 @@ env:
 
 jobs:
   test:
-    name: Test on ${{ matrix.os }} (using rustc ${{ matrix.rust }})
+    name: Run tests ${{ matrix.os }} (using rustc ${{ matrix.rust }})
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
@@ -28,6 +28,10 @@ jobs:
         with:
           toolchain: ${{ matrix.rust }}
           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
@@ -35,17 +39,7 @@ jobs:
       - name: Cargo generate-lockfile
         run: cargo generate-lockfile
 
-      - name: Cargo cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-          key: ${{ runner.os }}-cargo-${{ matrix.rust }}-${{ hashFiles('**/Cargo.lock') }}
+      - uses: Swatinem/rust-cache@v2
 
       - name: Run tests with all features
-        run: cargo make ci
-
+        run: cargo make --profile=github-actions test

.gitignore

@@ -6,3 +6,4 @@ blob.rs
 Cargo.lock
 **/*.rs.bk
 .DS_Store
+.idea

CODE_OF_CONDUCT.md

@@ -0,0 +1,51 @@
+# Contributor Covenant Code of Conduct
+
+_This Code of Conduct is based on the [Rust Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct)
+and the [Bevy Code of Conduct](https://raw.githubusercontent.com/bevyengine/bevy/main/CODE_OF_CONDUCT.md),
+which are adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling) 
+and the [Contributor Covenant](https://www.contributor-covenant.org)._
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+We are a community of people learning and exploring how to build better web applications
+with Rust. When interacting with one another, please remember that there are no experts and there are
+no stupid questions. Assume the best in other people's communication, and take a step back if
+you find yourself getting defensive.
+
+Please note the following guidelines as well:
+
+* Please avoid using overtly sexual aliases or other nicknames that might detract from a friendly, safe and welcoming environment for all.
+* Please be kind and courteous. There’s no need to be mean or rude.
+* Respect that people have differences of opinion and that every design or implementation choice carries a trade-off and numerous costs. There is seldom a right answer.
+* Please keep unstructured critique to a minimum. If you have solid ideas you want to experiment with, make a fork and see how it works.
+* We will exclude you from interaction if you insult, demean or harass anyone. That is not welcome behavior. We interpret the term “harassment” as including the definition in the [Citizen Code of Conduct](https://github.com/stumpsyn/policies/blob/master/citizen_code_of_conduct.md); if you have any lack of clarity about what might be included in that concept, please read their definition. In particular, we don’t tolerate behavior that excludes people in socially marginalized groups.
+* Private harassment is also unacceptable. No matter who you are, if you feel you have been or are being harassed or made uncomfortable by a community member, please contact the maintainers immediately. Whether you’re a regular contributor or a newcomer, we care about making this community a safe place for you and we’ve got your back.
+* Do not make casual mention of slavery or indentured servitude and/or false comparisons of one's occupation or situation to slavery. Please consider using or asking about alternate terminology when referring to such metaphors in technology.
+* Likewise any spamming, trolling, flaming, baiting or other attention-stealing behavior is not welcome.
+
+## Moderation
+
+These are the policies for upholding [our community’s standards of conduct](#our-standards). If you feel that a thread needs moderation, please contact the maintainers.
+
+1. Remarks that violate the community standards of conduct, including hateful, hurtful, oppressive, or exclusionary remarks, are not allowed. (Cursing is allowed, but never targeting another user, and never in a hateful manner).
+2. Remarks that maintainers find inappropriate, whether listed in the code of conduct or not, are also not allowed.
+3. Maintainers will first respond to such remarks with a warning.
+4. If the warning is unheeded, the user will be “kicked,” i.e., kicked out of the communication channel to cool off.
+5. If the user comes back and continues to make trouble, they will be banned, i.e., indefinitely excluded.
+6. Maintainers may choose at their discretion to un-ban the user if it was a first offense and they offer the offended party a genuine apology.
+7. If a maintainer bans someone and you think it was unjustified, please take it up with that maintainer, or with a different maintainer, in private. Complaints about bans in-channel are not allowed.
+8. Maintainers are held to a higher standard than other community members. If a maintainer creates an inappropriate situation, they should expect less leeway than others.
+
+The enforcement policies in the code of conduct apply to all official venues, including Discord channels, GitHub repositories, and all other forums.

Cargo.toml

@@ -4,37 +4,43 @@ members = [
   "leptos",
   "leptos_dom",
   "leptos_config",
+  "leptos_hot_reload",
   "leptos_macro",
   "leptos_reactive",
   "leptos_server",
+  "server_fn",
+  "server_fn_macro",
+  "server_fn/server_fn_macro_default",
 
   # integrations
   "integrations/actix",
   "integrations/axum",
+  "integrations/viz",
+  "integrations/utils",
 
   # 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.0-beta"
+version = "0.2.5"
 
 [workspace.dependencies]
-leptos = { path = "./leptos", default-features = false, version = "0.1.0-beta" }
-leptos_dom = { path = "./leptos_dom", default-features = false, version = "0.1.0-beta" }
-leptos_macro = { path = "./leptos_macro", default-features = false, version = "0.1.0-beta" }
-leptos_reactive = { path = "./leptos_reactive", default-features = false, version = "0.1.0-beta" }
-leptos_server = { path = "./leptos_server", default-features = false, version = "0.1.0-beta" }
-leptos_config = { path = "./leptos_config", default-features = false, version = "0.1.0-beta" }
-leptos_router = { path = "./router", version = "0.1.0-beta" }
-leptos_meta = { path = "./meta", default-feature = false, version = "0.1.0-beta" }
+leptos = { path = "./leptos", default-features = false, version = "0.2.5" }
+leptos_dom = { path = "./leptos_dom", default-features = false, version = "0.2.5" }
+leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.2.5" }
+leptos_macro = { path = "./leptos_macro", default-features = false, version = "0.2.5" }
+leptos_reactive = { path = "./leptos_reactive", default-features = false, version = "0.2.5" }
+leptos_server = { path = "./leptos_server", default-features = false, version = "0.2.5" }
+server_fn = { path = "./server_fn", default-features = false, version = "0.2.5" }
+server_fn_macro = { path = "./server_fn_macro", default-features = false, version = "0.2.5" }
+server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", default-features = false, version = "0.2.5" }
+leptos_config = { path = "./leptos_config", default-features = false, version = "0.2.5" }
+leptos_router = { path = "./router", version = "0.2.5" }
+leptos_meta = { path = "./meta", default-features = false, version = "0.2.5" }
+leptos_integration_utils = { path = "./integrations/utils", version = "0.2.5" }
 
 [profile.release]
 codegen-units = 1

Makefile.toml

@@ -7,34 +7,63 @@
 # make tasks run at the workspace root
 default_to_workspace = false
 
-[tasks.ci]
-dependencies = ["build", "build-examples", "test"]
-
-[tasks.build]
-clear = true
-dependencies = ["build-all"]
-
-[tasks.build-all]
-command = "cargo"
-args = ["+nightly", "build-all-features"]
-install_crate = "cargo-all-features"
-
-[tasks.build-examples]
+[tasks.check]
 clear = true
 dependencies = [
-	{ name = "build", path = "examples/counter" },
-	{ name = "build", path = "examples/counter_isomorphic" },
-	{ name = "build", path = "examples/counters" },
-	{ name = "build", path = "examples/counters_stable" },
-	{ name = "build", path = "examples/fetch" },
-	{ name = "build", path = "examples/hackernews" },
-	{ name = "build", path = "examples/hackernews_axum" },
-	{ name = "build", path = "examples/parent_child" },
-	{ name = "build", path = "examples/router" },
-	{ name = "build", path = "examples/tailwind" },
-	{ name = "build", path = "examples/todo_app_sqlite" },
-	{ name = "build", path = "examples/todo_app_sqlite_axum" },
-	{ name = "build", path = "examples/todomvc" },
+	"check-all",
+	"check-wasm",
+	"check-all-release",
+	"check-wasm-release",
+]
+
+[tasks.check-all]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check-wasm]
+clear = true
+dependencies = [{ name = "check-wasm", path = "leptos" }]
+
+[tasks.check-all-release]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check-wasm-release]
+clear = true
+dependencies = [{ name = "check-wasm-release", path = "leptos" }]
+
+[tasks.check-examples]
+clear = true
+dependencies = [
+	{ name = "check", path = "examples/counter" },
+	{ name = "check", path = "examples/counter_isomorphic" },
+	{ name = "check", path = "examples/counters" },
+	{ name = "check", path = "examples/error_boundary" },
+	{ name = "check", path = "examples/errors_axum" },
+	{ name = "check", path = "examples/fetch" },
+	{ name = "check", path = "examples/hackernews" },
+	{ name = "check", path = "examples/hackernews_axum" },
+	{ name = "check", path = "examples/login_with_token_csr_only" },
+	{ name = "check", path = "examples/parent_child" },
+	{ name = "check", path = "examples/router" },
+	{ name = "check", path = "examples/session_auth_axum" },
+	{ name = "check", path = "examples/ssr_modes" },
+	{ name = "check", path = "examples/ssr_modes_axum" },
+	{ name = "check", path = "examples/tailwind" },
+	{ name = "check", path = "examples/tailwind_csr_trunk" },
+	{ name = "check", path = "examples/todo_app_sqlite" },
+	{ name = "check", path = "examples/todo_app_sqlite_axum" },
+	{ name = "check", path = "examples/todo_app_sqlite_viz" },
+	{ name = "check", path = "examples/todomvc" },
+]
+
+[tasks.check-stable]
+clear = true
+dependencies = [
+	{ name = "check", path = "examples/counter_without_macros" },
+	{ name = "check", path = "examples/counters_stable" },
 ]
 
 [tasks.test]
@@ -45,3 +74,21 @@ dependencies = ["test-all"]
 command = "cargo"
 args = ["+nightly", "test-all-features"]
 install_crate = "cargo-all-features"
+
+[tasks.test-examples]
+description = "Run all unit and web tests for examples"
+cwd = "examples"
+command = "cargo"
+args = ["make", "test-unit-and-web"]
+
+[tasks.verify-examples]
+description = "Run all quality checks and tests for examples"
+cwd = "examples"
+command = "cargo"
+args = ["make", "verify-flow"]
+
+[env]
+RUSTFLAGS = ""
+
+[env.github-actions]
+RUSTFLAGS = "-D warnings"

README.md

@@ -1,10 +1,12 @@
-**NOTE: We're in the middle of merging changes and making fixes to support our upcoming `0.1.0` release. Some of the examples may be in a broken state. You can continue using the `0.0` releases with no issues.**
-
-<img src="https://raw.githubusercontent.com/gbj/leptos/main/docs/logos/logo.svg" alt="Leptos Logo" style="width: 100%; height: auto; display: block; margin: auto;">
+<picture>
+    <source srcset="https://raw.githubusercontent.com/leptos-rs/leptos/main/docs/logos/Leptos_logo_pref_dark_RGB.svg" media="(prefers-color-scheme: dark)">
+    <img src="https://raw.githubusercontent.com/leptos-rs/leptos/main/docs/logos/Leptos_logo_RGB.svg" alt="Leptos Logo">
+</picture>
 
 [![crates.io](https://img.shields.io/crates/v/leptos.svg)](https://crates.io/crates/leptos)
 [![docs.rs](https://docs.rs/leptos/badge.svg)](https://docs.rs/leptos)
 [![Discord](https://img.shields.io/discord/1031524867910148188?color=%237289DA&label=discord)](https://discord.gg/YdRAhS7eQB)
+[![Matrix](https://img.shields.io/badge/Matrix-leptos-grey?logo=matrix&labelColor=white&logoColor=black)](https://matrix.to/#/#leptos:matrix.org)
 
 # Leptos
 
@@ -23,12 +25,11 @@ pub fn SimpleCounter(cx: Scope, initial_value: i32) -> impl IntoView {
     let increment = move |_| set_value.update(|value| *value += 1);
 
     // create user interfaces with the declarative `view!` macro
-    view! {
-        cx,
+    view! { cx,
         <div>
             <button on:click=clear>"Clear"</button>
             <button on:click=decrement>"-1"</button>
-            <span>"Value: " {move || value().to_string()} "!"</span>
+            <span>"Value: " {value} "!"</span>
             <button on:click=increment>"+1"</button>
         </div>
     }
@@ -47,28 +48,27 @@ Leptos is a full-stack, isomorphic Rust web framework leveraging fine-grained re
 
 ## What does that mean?
 
-- **Full-stack**: Leptos can be used to build apps that run in the browser (_client-side rendering_), on the server (_server-side rendering_), or by rendering HTML on the server and then adding interactivity in the browser (_hydration_). This includes support for _HTTP streaming_ of both data (`Resource`s) and HTML (out-of-order streaming of `<Suspense/>` components.)
-- **Isomorphic**: Leptos provides primitives to write isomorphic server functions, i.e., functions that can be called with the “same shape” on the client or server, but only run on the server. This means you can write your server-only logic (database requests, authentication etc.) alongside the client-side components that will consume it, and call server functions as if they were running in the browser.
-- **Web**: Leptos is built on the Web platform and Web standards. The router is designed to use Web fundamentals (like links and forms) and build on top of them rather than trying to replace them.
+- **Full-stack**: Leptos can be used to build apps that run in the browser (client-side rendering), on the server (server-side rendering), or by rendering HTML on the server and then adding interactivity in the browser (server-side rendering with hydration). This includes support for HTTP streaming of both data ([`Resource`s](https://docs.rs/leptos/latest/leptos/struct.Resource.html)) and HTML (out-of-order or in-order streaming of [`<Suspense/>`](https://docs.rs/leptos/latest/leptos/fn.Suspense.html) components.)
+- **Isomorphic**: Leptos provides primitives to write isomorphic [server functions](https://docs.rs/leptos_server/0.2.5/leptos_server/index.html), i.e., functions that can be called with the “same shape” on the client or server, but only run on the server. This means you can write your server-only logic (database requests, authentication etc.) alongside the client-side components that will consume it, and call server functions as if they were running in the browser, without needing to create and maintain a separate REST or other API.
+- **Web**: Leptos is built on the Web platform and Web standards. The [router](https://docs.rs/leptos_router/latest/leptos_router/) is designed to use Web fundamentals (like links and forms) and build on top of them rather than trying to replace them.
 - **Framework**: Leptos provides most of what you need to build a modern web app: a reactive system, templating library, and a router that works on both the server and client side.
-- **Fine-grained reactivity**: The entire framework is built from reactive primitives. This allows for extremely performant code with minimal overhead: when a reactive signal’s value changes, it can update a single text node, toggle a single class, or remove an element from the DOM without any other code running. (_So, no virtual DOM!_)
+- **Fine-grained reactivity**: The entire framework is built from reactive primitives. This allows for extremely performant code with minimal overhead: when a reactive signal’s value changes, it can update a single text node, toggle a single class, or remove an element from the DOM without any other code running. (So, no virtual DOM overhead!)
 - **Declarative**: Tell Leptos how you want the page to look, and let the framework tell the browser how to do it.
 
 ## Learn more
 
 Here are some resources for learning more about Leptos:
 
-- [Examples](https://github.com/gbj/leptos/tree/main/examples)
+- [Book](https://leptos-rs.github.io/leptos/) (work in progress)
+- [Examples](https://github.com/leptos-rs/leptos/tree/main/examples)
 - [API Documentation](https://docs.rs/leptos/latest/leptos/)
-- [Common Bugs](https://github.com/gbj/leptos/tree/main/docs/COMMON_BUGS.md) (and how to fix them!)
-- Leptos Guide (in progress)
-
+- [Common Bugs](https://github.com/leptos-rs/leptos/tree/main/docs/COMMON_BUGS.md) (and how to fix them!)
 
 ## `nightly` Note
 
-Most of the examples assume you’re using `nightly` Rust.
+Most of the examples assume you’re using `nightly` version of Rust. For this, you can either set your toolchain globally or on per-project basis.
 
-To set up your Rust toolchain using `nightly` (and add the ability to compile Rust to WebAssembly, if you haven’t already)
+To set `nightly` as a default toolchain for all projects (and add the ability to compile Rust to WebAssembly, if you haven’t already):
 
 ```
 rustup toolchain install nightly
@@ -76,17 +76,25 @@ rustup default nightly
 rustup target add wasm32-unknown-unknown
 ```
 
+If you'd like to use `nightly` only in your Leptos project however, add [`rust-toolchain.toml`](https://rust-lang.github.io/rustup/overrides.html#the-toolchain-file) file with the following content:
+
+```toml
+[toolchain]
+channel = "nightly"
+targets = ["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.2", 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/gbj/leptos/blob/main/examples/counters-stable/src/main.rs)
+   [`counters_stable` example](https://github.com/leptos-rs/leptos/blob/main/examples/counters_stable/src/main.rs)
    for examples of the correct API.
 
 ## `cargo-leptos`
 
-[`cargo-leptos`](https://github.com/akesson/cargo-leptos) is a build tool that's designed to make it easy to build apps that run on both the client and the server, with seamless integration. The best way to get started with a real Leptos project right now is to use `cargo-leptos` and our [starter template](https://github.com/leptos-rs/start).
+[`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) is a build tool that's designed to make it easy to build apps that run on both the client and the server, with seamless integration. The best way to get started with a real Leptos project right now is to use `cargo-leptos` and our starter templates for [Actix](https://github.com/leptos-rs/start) or [Axum](https://github.com/leptos-rs/start-axum).
 
 ```bash
 cargo install cargo-leptos
@@ -95,8 +103,32 @@ cd [your project name]
 cargo leptos watch
 ```
 
+Open browser to [http://localhost:3000/](http://localhost:3000/).
+
 ## FAQs
 
+### What’s up with the name?
+
+_Leptos_ (λεπτός) is an ancient Greek word meaning “thin, light, refine, fine-grained.” To me, a classicist and not a dog owner, it evokes the lightweight reactive system that powers the framework. I've since learned the same word is at the root of the medical term “leptospirosis,” a blood infection that affects humans and animals... My bad. No dogs were harmed in the creation of this framework.
+
+### Is it production ready?
+
+People usually mean one of three things by this question.
+
+1. **Are the APIs stable?** i.e., will I have to rewrite my whole app from Leptos 0.1 to 0.2 to 0.3 to 0.4, or can I write it now and benefit from new features and updates as new versions come?
+
+The APIs are basically settled. We’re adding new features, but we’re very happy with where the type system and patterns have landed. I would not expect major breaking changes to your code to adapt to future releases. The sorts of breaking changes that we discuss are things like “Oh yeah, that function should probably take `cx` as its argument...” not major changes to the way you write your application.
+
+2. **Are there bugs?**
+
+Yes, I’m sure there are. You can see from the state of our issue tracker over time that there aren’t that _many_ bugs and they’re usually resolved pretty quickly. But for sure, there may be moments where you encounter something that requires a fix at the framework level, which may not be immediately resolved.
+
+3. **Am I a consumer or a contributor?**
+
+This may be the big one: “production ready” implies a certain orientation to a library: that you can basically use it, without any special knowledge of its internals or ability to contribute. Everyone has this at some level in their stack: for example I (@gbj) don’t have the capacity or knowledge to contribute to something like `wasm-bindgen` at this point: I simply rely on it to work.
+
+There are several people in the community using Leptos right now for internal apps at work, who have also become significant contributors. I think this is the right level of production use for now. There may be missing features that you need, and you may end up building them! But for internal apps, if you’re willing to build and contribute missing pieces along the way, the framework is definitely usable right now.
+
 ### Can I use this for native GUI?
 
 Sure! Obviously the `view` macro is for generating DOM nodes but you can use the reactive system to drive native any GUI toolkit that uses the same kind of object-oriented, event-callback-based framework as the DOM pretty easily. The principles are the same:
@@ -106,15 +138,15 @@ Sure! Obviously the `view` macro is for generating DOM nodes but you can use the
 - Use event listeners to update signals
 - Create effects to update the UI
 
-I've put together a [very simple GTK example](https://github.com/gbj/leptos/blob/main/examples/gtk/src/main.rs) so you can see what I mean.
+I've put together a [very simple GTK example](https://github.com/leptos-rs/leptos/blob/main/examples/gtk/src/main.rs) so you can see what I mean.
 
 ### How is this different from Yew/Dioxus?
 
 On the surface level, these libraries may seem similar. Yew is, of course, the most mature Rust library for web UI development and has a huge ecosystem. Dioxus is similar in many ways, being heavily inspired by React. Here are some conceptual differences between Leptos and these frameworks:
 
 - **VDOM vs. fine-grained:** Yew is built on the virtual DOM (VDOM) model: state changes cause components to re-render, generating a new virtual DOM tree. Yew diffs this against the previous VDOM, and applies those patches to the actual DOM. Component functions rerun whenever state changes. Leptos takes an entirely different approach. Components run once, creating (and returning) actual DOM nodes and setting up a reactive system to update those DOM nodes.
-- **Performance:** This has huge performance implications: Leptos is simply _much_ faster at both creating and updating the UI than Yew is.
-- **Mental model:** Adopting fine-grained reactivity also tends to simplify the mental model. There are no surprising component re-renders because there are no re-renders. Your app can be divided into components based on what makes sense for your app, because they have no performance implications.
+- **Performance:** This has huge performance implications: Leptos is simply much faster at both creating and updating the UI than Yew is. (Dioxus has made huge advances in performance with its recent 0.3 release, and is now roughly on par with Leptos.)
+- **Mental model:** Adopting fine-grained reactivity also tends to simplify the mental model. There are no surprising component re-renders because there are no re-renders. You can call functions, create timeouts, etc. within the body of your component functions because they won’t be re-run. You don’t need to think about manual dependency tracking for effects; fine-grained reactivity tracks dependencies automatically.
 
 ### How is this different from Sycamore?
 
@@ -122,10 +154,9 @@ Conceptually, these two frameworks are very similar: because both are built on f
 
 There are some practical differences that make a significant difference:
 
-- **Maturity:** Sycamore is obviously a much more mature and stable library with a larger ecosystem.
 - **Templating:** Leptos uses a JSX-like template format (built on [syn-rsx](https://github.com/stoically/syn-rsx)) for its `view` macro. Sycamore offers the choice of its own templating DSL or a builder syntax.
-- **Template node cloning:** Leptos's `view` macro compiles to a static HTML string and a set of instructions of how to assign its reactive values. This means that at runtime, Leptos can clone a `<template>` node rather than calling `document.createElement()` to create DOM nodes. This is a _significantly_ faster way of rendering components.
-- **Read-write segregation:** Leptos, like Solid, encourages read-write segregation between signal getters and setters, so you end up accessing signals with tuples like `let (count, set_count) = create_signal(cx, 0);` _(If you prefer or if it's more convenient for your API, you can use `create_rw_signal` to give a unified read/write signal.)_
+- **Server integration:** Leptos provides primitives that encourage HTML streaming and allow for easy async integration and RPC calls, even without WASM enabled, making it easy to opt into integrations between your frontend and backend code without pushing you toward any particular metaframework patterns.
+- **Read-write segregation:** Leptos, like Solid, encourages read-write segregation between signal getters and setters, so you end up accessing signals with tuples like `let (count, set_count) = create_signal(cx, 0);` _(If you prefer or if it's more convenient for your API, you can use [`create_rw_signal`](https://docs.rs/leptos/latest/leptos/fn.create_rw_signal.html) to give a unified read/write signal.)_
 - **Signals are functions:** In Leptos, you can call a signal to access it rather than calling a specific method (so, `count()` instead of `count.get()`) This creates a more consistent mental model: accessing a reactive value is always a matter of calling a function. For example:
 
   ```rust

benchmarks/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+l021 = { package = "leptos", version = "0.2.1" }
 leptos = { path = "../leptos", default-features = false, features = ["ssr"] }
 sycamore = { version = "0.8", features = ["ssr"] }
 yew = { git = "https://github.com/yewstack/yew", features = ["ssr"] }
@@ -16,15 +17,11 @@ lazy_static = "1"
 log = "0.4"
 strum = "0.24"
 strum_macros = "0.24"
-serde = { version = "1", features = ["derive", "rc"]}
+serde = { version = "1", features = ["derive", "rc"] }
 serde_json = "1"
 tera = "1"
+reactive-signals = "0.1.0-alpha.4"
 
 [dependencies.web-sys]
 version = "0.3"
-features = [
-	"Window",
-	"Document",
-	"HtmlElement",
-	"HtmlInputElement"
-]
+features = ["Window", "Document", "HtmlElement", "HtmlInputElement"]

benchmarks/src/lib.rs

@@ -2,6 +2,6 @@
 
 extern crate test;
 
-//mod reactive;
-mod ssr;
+//åmod reactive;
+//mod ssr;
 mod todomvc;

benchmarks/src/reactive.rs

@@ -1,35 +1,113 @@
+use std::{cell::Cell, rc::Rc};
 use test::Bencher;
 
-use std::{cell::Cell, rc::Rc};
-
 #[bench]
-fn leptos_create_1000_signals(b: &mut Bencher) {
-    use leptos::{create_isomorphic_effect, create_memo, create_scope, create_signal};
+fn leptos_deep_creation(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
 
     b.iter(|| {
-        create_scope(|cx| {
-            let acc = Rc::new(Cell::new(0));
-            let sigs = (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
+        create_scope(runtime, |cx| {
+            let signal = create_rw_signal(cx, 0);
+            let mut memos = Vec::<Memo<usize>>::new();
+            for _ in 0..1000usize {
+                let prev = memos.last().copied();
+                if let Some(prev) = prev {
+                    memos.push(create_memo(cx, move |_| prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move |_| signal.get() + 1));
+                }
+            }
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn leptos_deep_update(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let signal = create_rw_signal(cx, 0);
+            let mut memos = Vec::<Memo<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move |_| prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move |_| signal.get() + 1));
+                }
+            }
+            signal.set(1);
+            assert_eq!(memos[999].get(), 1001);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn leptos_narrowing_down(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let sigs =
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
             let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
             let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
-            let memo = create_memo(cx, move |_| reads.iter().map(|r| r.get()).sum::<i32>());
+            let memo = create_memo(cx, move |_| {
+                reads.iter().map(|r| r.get()).sum::<i32>()
+            });
             assert_eq!(memo(), 499500);
         })
         .dispose()
     });
+
+    runtime.dispose();
 }
 
 #[bench]
-fn leptos_create_and_update_1000_signals(b: &mut Bencher) {
-    use leptos::{create_isomorphic_effect, create_memo, create_scope, create_signal};
+fn leptos_fanning_out(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
 
     b.iter(|| {
-        create_scope(|cx| {
+        create_scope(runtime, |cx| {
+            let sig = create_rw_signal(cx, 0);
+            let memos = (0..1000)
+                .map(|_| create_memo(cx, move |_| sig.get()))
+                .collect::<Vec<_>>();
+            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+            sig.set(1);
+            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn leptos_narrowing_update(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
             let acc = Rc::new(Cell::new(0));
-            let sigs = (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
+            let sigs =
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
             let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
             let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
-            let memo = create_memo(cx, move |_| reads.iter().map(|r| r.get()).sum::<i32>());
+            let memo = create_memo(cx, move |_| {
+                reads.iter().map(|r| r.get()).sum::<i32>()
+            });
             assert_eq!(memo(), 499500);
             create_isomorphic_effect(cx, {
                 let acc = Rc::clone(&acc);
@@ -48,17 +126,20 @@ fn leptos_create_and_update_1000_signals(b: &mut Bencher) {
         })
         .dispose()
     });
+
+    runtime.dispose();
 }
 
 #[bench]
-fn leptos_create_and_dispose_1000_scopes(b: &mut Bencher) {
-    use leptos::{create_isomorphic_effect, create_scope, create_signal};
+fn leptos_scope_creation_and_disposal(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
 
     b.iter(|| {
         let acc = Rc::new(Cell::new(0));
         let disposers = (0..1000)
             .map(|_| {
-                create_scope({
+                create_scope(runtime, {
                     let acc = Rc::clone(&acc);
                     move |cx| {
                         let (r, w) = create_signal(cx, 0);
@@ -76,16 +157,252 @@ fn leptos_create_and_dispose_1000_scopes(b: &mut Bencher) {
             disposer.dispose();
         }
     });
+
+    runtime.dispose();
 }
 
 #[bench]
-fn sycamore_create_1000_signals(b: &mut Bencher) {
-    use sycamore::reactive::{create_effect, create_memo, create_scope, create_signal};
+fn rs_deep_update(b: &mut Bencher) {
+    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
+
+    let sc = ClientRuntime::new_root_scope();
+    b.iter(|| {
+        let signal = signal!(sc, 0);
+        let mut memos = Vec::<Signal<Func<i32>, ClientRuntime>>::new();
+        for i in 0..1000usize {
+            let prev = memos.get(i.saturating_sub(1)).copied();
+            if let Some(prev) = prev {
+                memos.push(signal!(sc, move || prev.get() + 1))
+            } else {
+                memos.push(signal!(sc, move || signal.get() + 1))
+            }
+        }
+        signal.set(1);
+        assert_eq!(memos[999].get(), 1001);
+    });
+}
+
+#[bench]
+fn rs_fanning_out(b: &mut Bencher) {
+    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
+    let cx = ClientRuntime::new_root_scope();
+
+    b.iter(|| {
+        let sig = signal!(cx, 0);
+        let memos = (0..1000)
+            .map(|_| signal!(cx, move || sig.get()))
+            .collect::<Vec<_>>();
+        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+        sig.set(1);
+        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+    });
+}
+
+#[bench]
+fn rs_narrowing_update(b: &mut Bencher) {
+    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
+    let cx = ClientRuntime::new_root_scope();
+
+    b.iter(|| {
+        let acc = Rc::new(Cell::new(0));
+        let sigs =
+            (0..1000).map(|n| signal!(cx, n)).collect::<Vec<_>>();
+        let memo = signal!(cx, {
+            let sigs = sigs.clone();
+            move || {
+                sigs.iter().map(|r| r.get()).sum::<i32>()
+            }
+        });
+        assert_eq!(memo.get(), 499500);
+        signal!(cx, {
+            let acc = Rc::clone(&acc);
+            move || {
+                acc.set(memo.get());
+            }
+        });
+
+        assert_eq!(acc.get(), 499500);
+
+        sigs[1].update(|n| *n += 1);
+        sigs[10].update(|n| *n += 1);
+        sigs[100].update(|n| *n += 1);
+
+        assert_eq!(acc.get(), 499503);
+        assert_eq!(memo.get(), 499503);
+    });
+}
+
+#[bench]
+fn l021_deep_creation(b: &mut Bencher) {
+    use l021::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let signal = create_rw_signal(cx, 0);
+            let mut memos = Vec::<Memo<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move |_| prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move |_| signal.get() + 1));
+                }
+            }
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn l021_deep_update(b: &mut Bencher) {
+    use l021::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let signal = create_rw_signal(cx, 0);
+            let mut memos = Vec::<Memo<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move |_| prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move |_| signal.get() + 1));
+                }
+            }
+            signal.set(1);
+            assert_eq!(memos[999].get(), 1001);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn l021_narrowing_down(b: &mut Bencher) {
+    use l021::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let acc = Rc::new(Cell::new(0));
+            let sigs =
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
+            let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
+            let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
+            let memo = create_memo(cx, move |_| {
+                reads.iter().map(|r| r.get()).sum::<i32>()
+            });
+            assert_eq!(memo(), 499500);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn l021_fanning_out(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let sig = create_rw_signal(cx, 0);
+            let memos = (0..1000)
+                .map(|_| create_memo(cx, move |_| sig.get()))
+                .collect::<Vec<_>>();
+            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+            sig.set(1);
+            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+#[bench]
+fn l021_narrowing_update(b: &mut Bencher) {
+    use l021::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let acc = Rc::new(Cell::new(0));
+            let sigs =
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
+            let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
+            let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
+            let memo = create_memo(cx, move |_| {
+                reads.iter().map(|r| r.get()).sum::<i32>()
+            });
+            assert_eq!(memo(), 499500);
+            create_isomorphic_effect(cx, {
+                let acc = Rc::clone(&acc);
+                move |_| {
+                    acc.set(memo());
+                }
+            });
+            assert_eq!(acc.get(), 499500);
+
+            writes[1].update(|n| *n += 1);
+            writes[10].update(|n| *n += 1);
+            writes[100].update(|n| *n += 1);
+
+            assert_eq!(acc.get(), 499503);
+            assert_eq!(memo(), 499503);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn l021_scope_creation_and_disposal(b: &mut Bencher) {
+    use l021::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        let acc = Rc::new(Cell::new(0));
+        let disposers = (0..1000)
+            .map(|_| {
+                create_scope(runtime, {
+                    let acc = Rc::clone(&acc);
+                    move |cx| {
+                        let (r, w) = create_signal(cx, 0);
+                        create_isomorphic_effect(cx, {
+                            move |_| {
+                                acc.set(r());
+                            }
+                        });
+                        w.update(|n| *n += 1);
+                    }
+                })
+            })
+            .collect::<Vec<_>>();
+        for disposer in disposers {
+            disposer.dispose();
+        }
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn sycamore_narrowing_down(b: &mut Bencher) {
+    use sycamore::reactive::{
+        create_effect, create_memo, create_scope, create_signal,
+    };
 
     b.iter(|| {
         let d = create_scope(|cx| {
             let acc = Rc::new(Cell::new(0));
-            let sigs = Rc::new((0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>());
+            let sigs = Rc::new(
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>(),
+            );
             let memo = create_memo(cx, {
                 let sigs = Rc::clone(&sigs);
                 move || sigs.iter().map(|r| *r.get()).sum::<i32>()
@@ -97,13 +414,78 @@ fn sycamore_create_1000_signals(b: &mut Bencher) {
 }
 
 #[bench]
-fn sycamore_create_and_update_1000_signals(b: &mut Bencher) {
-    use sycamore::reactive::{create_effect, create_memo, create_scope, create_signal};
+fn sycamore_fanning_out(b: &mut Bencher) {
+    use sycamore::reactive::{
+        create_effect, create_memo, create_scope, create_signal,
+    };
+
+    b.iter(|| {
+        let d = create_scope(|cx| {
+            let sig = create_signal(cx, 0);
+            let memos = (0..1000)
+                .map(|_| create_memo(cx, move || sig.get()))
+                .collect::<Vec<_>>();
+            assert_eq!(memos.iter().map(|m| *(*m.get())).sum::<i32>(), 0);
+            sig.set(1);
+            assert_eq!(memos.iter().map(|m| *(*m.get())).sum::<i32>(), 1000);
+        });
+        unsafe { d.dispose() };
+    });
+}
+
+#[bench]
+fn sycamore_deep_creation(b: &mut Bencher) {
+    use sycamore::reactive::*;
+
+    b.iter(|| {
+        let d = create_scope(|cx| {
+            let signal = create_signal(cx, 0);
+            let mut memos = Vec::<&ReadSignal<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move || *prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move || *signal.get() + 1));
+                }
+            }
+        });
+        unsafe { d.dispose() };
+    });
+}
+
+#[bench]
+fn sycamore_deep_update(b: &mut Bencher) {
+    use sycamore::reactive::*;
+
+    b.iter(|| {
+        let d = create_scope(|cx| {
+            let signal = create_signal(cx, 0);
+            let mut memos = Vec::<&ReadSignal<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move || *prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move || *signal.get() + 1));
+                }
+            }
+            signal.set(1);
+            assert_eq!(*memos[999].get(), 1001);
+        });
+        unsafe { d.dispose() };
+    });
+}
+#[bench]
+fn sycamore_narrowing_update(b: &mut Bencher) {
+    use sycamore::reactive::{
+        create_effect, create_memo, create_scope, create_signal,
+    };
 
     b.iter(|| {
         let d = create_scope(|cx| {
             let acc = Rc::new(Cell::new(0));
-            let sigs = Rc::new((0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>());
+            let sigs = Rc::new(
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>(),
+            );
             let memo = create_memo(cx, {
                 let sigs = Rc::clone(&sigs);
                 move || sigs.iter().map(|r| *r.get()).sum::<i32>()
@@ -129,7 +511,7 @@ fn sycamore_create_and_update_1000_signals(b: &mut Bencher) {
 }
 
 #[bench]
-fn sycamore_create_and_dispose_1000_scopes(b: &mut Bencher) {
+fn sycamore_scope_creation_and_disposal(b: &mut Bencher) {
     use sycamore::reactive::{create_effect, create_scope, create_signal};
 
     b.iter(|| {

benchmarks/src/ssr.rs

@@ -2,9 +2,9 @@ use test::Bencher;
 
 #[bench]
 fn leptos_ssr_bench(b: &mut Bencher) {
-	b.iter(|| {
+    b.iter(|| {
 		use leptos::*;
-
+		leptos_dom::HydrationCtx::reset_id();
 		_ = create_scope(create_runtime(), |cx| {
 			#[component]
 			fn Counter(cx: Scope, initial: i32) -> impl IntoView {
@@ -32,18 +32,18 @@ fn leptos_ssr_bench(b: &mut Bencher) {
 
 			assert_eq!(
 				rendered,
-				"<main><h1>Welcome to our benchmark page.</h1><p>Here's some introductory text.</p><div><button>-1</button><span>Value: <!>1<template id=\"_3\"></template>!</span><button>+1</button></div><template id=\"_1\"></template><div><button>-1</button><span>Value: <!>2<template id=\"_2\"></template>!</span><button>+1</button></div><template id=\"_0\"></template><div><button>-1</button><span>Value: <!>3<template id=\"_2\"></template>!</span><button>+1</button></div><template id=\"_0\"></template></main>"
+				"<main id=\"_0-1\"><h1 id=\"_0-2\">Welcome to our benchmark page.</h1><p id=\"_0-3\">Here&#x27;s some introductory text.</p><div id=\"_0-3-1\"><button id=\"_0-3-2\">-1</button><span id=\"_0-3-3\">Value: <!>1<!--hk=_0-3-4-->!</span><button id=\"_0-3-5\">+1</button></div><!--hk=_0-3-0--><div id=\"_0-3-5-1\"><button id=\"_0-3-5-2\">-1</button><span id=\"_0-3-5-3\">Value: <!>2<!--hk=_0-3-5-4-->!</span><button id=\"_0-3-5-5\">+1</button></div><!--hk=_0-3-5-0--><div id=\"_0-3-5-5-1\"><button id=\"_0-3-5-5-2\">-1</button><span id=\"_0-3-5-5-3\">Value: <!>3<!--hk=_0-3-5-5-4-->!</span><button id=\"_0-3-5-5-5\">+1</button></div><!--hk=_0-3-5-5-0--></main>"
 			);
 		});
 	});
 }
-/* 
+
 #[bench]
 fn tera_ssr_bench(b: &mut Bencher) {
-	use tera::*;
-	use serde::{Serialize, Deserialize};
+    use serde::{Deserialize, Serialize};
+    use tera::*;
 
-	static TEMPLATE: &str = r#"<main>
+    static TEMPLATE: &str = r#"<main>
 	<h1>Welcome to our benchmark page.</h1>
 	<p>Here's some introductory text.</p>
 	{% for counter in counters %}
@@ -55,37 +55,40 @@ fn tera_ssr_bench(b: &mut Bencher) {
 	{% endfor %}
 	</main>"#;
 
-	lazy_static::lazy_static! { 
-		static ref TERA: Tera = {
-			let mut tera = Tera::default();
-			tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
-			tera
-		};
-	}
+    lazy_static::lazy_static! {
+        static ref TERA: Tera = {
+            let mut tera = Tera::default();
+            tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
+            tera
+        };
+    }
 
-	#[derive(Serialize, Deserialize)]
-	struct Counter {
-		value: i32
-	}
+    #[derive(Serialize, Deserialize)]
+    struct Counter {
+        value: i32,
+    }
 
-	b.iter(|| {
-		let mut ctx = Context::new();
-		ctx.insert("counters", &vec![
-			Counter { value: 0 },
-			Counter { value: 1},
-			Counter { value: 2 }
-		]);
+    b.iter(|| {
+        let mut ctx = Context::new();
+        ctx.insert(
+            "counters",
+            &vec![
+                Counter { value: 0 },
+                Counter { value: 1 },
+                Counter { value: 2 },
+            ],
+        );
 
-		let _ = TERA.render("template.html", &ctx).unwrap();
-	});
+        let _ = TERA.render("template.html", &ctx).unwrap();
+    });
 }
 
 #[bench]
 fn sycamore_ssr_bench(b: &mut Bencher) {
-	use sycamore::*;
-	use sycamore::prelude::*;
+    use sycamore::prelude::*;
+    use sycamore::*;
 
-	b.iter(|| {
+    b.iter(|| {
 		_ = create_scope(|cx| {
 			#[derive(Prop)]
 			struct CounterProps {
@@ -139,10 +142,10 @@ fn sycamore_ssr_bench(b: &mut Bencher) {
 
 #[bench]
 fn yew_ssr_bench(b: &mut Bencher) {
-	use yew::prelude::*;
-	use yew::ServerRenderer;
+    use yew::prelude::*;
+    use yew::ServerRenderer;
 
-	b.iter(|| {
+    b.iter(|| {
 		#[derive(Properties, PartialEq, Eq, Debug)]
 		struct CounterProps {
 			initial: i32
@@ -194,4 +197,3 @@ fn yew_ssr_bench(b: &mut Bencher) {
 		});
 	});
 }
- */

benchmarks/src/todomvc/leptos.rs

@@ -1,6 +1,7 @@
 pub use leptos::*;
 use miniserde::*;
 use web_sys::HtmlInputElement;
+use wasm_bindgen::JsCast;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Todos(pub Vec<Todo>);
@@ -8,320 +9,327 @@ pub struct Todos(pub Vec<Todo>);
 const STORAGE_KEY: &str = "todos-leptos";
 
 impl Todos {
-  pub fn new(cx: Scope) -> Self {
-    Self(vec![])
-  }
+    pub fn new(cx: Scope) -> Self {
+        Self(vec![])
+    }
 
-  pub fn new_with_1000(cx: Scope) -> Self {
-    let todos = (0..1000)
-      .map(|id| Todo::new(cx, id, format!("Todo #{id}")))
-      .collect();
-    Self(todos)
-  }
+    pub fn new_with_1000(cx: Scope) -> Self {
+        let todos = (0..1000)
+            .map(|id| Todo::new(cx, id, format!("Todo #{id}")))
+            .collect();
+        Self(todos)
+    }
 
-  pub fn is_empty(&self) -> bool {
-    self.0.is_empty()
-  }
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
 
-  pub fn add(&mut self, todo: Todo) {
-    self.0.push(todo);
-  }
+    pub fn add(&mut self, todo: Todo) {
+        self.0.push(todo);
+    }
 
-  pub fn remove(&mut self, id: usize) {
-    self.0.retain(|todo| todo.id != id);
-  }
+    pub fn remove(&mut self, id: usize) {
+        self.0.retain(|todo| todo.id != id);
+    }
 
-  pub fn remaining(&self) -> usize {
-    self.0.iter().filter(|todo| !(todo.completed)()).count()
-  }
+    pub fn remaining(&self) -> usize {
+        self.0.iter().filter(|todo| !(todo.completed)()).count()
+    }
 
-  pub fn completed(&self) -> usize {
-    self.0.iter().filter(|todo| (todo.completed)()).count()
-  }
+    pub fn completed(&self) -> usize {
+        self.0.iter().filter(|todo| (todo.completed)()).count()
+    }
 
-  pub fn toggle_all(&self) {
-    // if all are complete, mark them all active instead
-    if self.remaining() == 0 {
-      for todo in &self.0 {
-        if todo.completed.get() {
-          (todo.set_completed)(false);
+    pub fn toggle_all(&self) {
+        // if all are complete, mark them all active instead
+        if self.remaining() == 0 {
+            for todo in &self.0 {
+                if todo.completed.get() {
+                    (todo.set_completed)(false);
+                }
+            }
+        }
+        // otherwise, mark them all complete
+        else {
+            for todo in &self.0 {
+                (todo.set_completed)(true);
+            }
         }
-      }
     }
-    // otherwise, mark them all complete
-    else {
-      for todo in &self.0 {
-        (todo.set_completed)(true);
-      }
-    }
-  }
 
-  fn clear_completed(&mut self) {
-    self.0.retain(|todo| !todo.completed.get());
-  }
+    fn clear_completed(&mut self) {
+        self.0.retain(|todo| !todo.completed.get());
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Todo {
-  pub id: usize,
-  pub title: ReadSignal<String>,
-  pub set_title: WriteSignal<String>,
-  pub completed: ReadSignal<bool>,
-  pub set_completed: WriteSignal<bool>,
+    pub id: usize,
+    pub title: ReadSignal<String>,
+    pub set_title: WriteSignal<String>,
+    pub completed: ReadSignal<bool>,
+    pub set_completed: WriteSignal<bool>,
 }
 
 impl Todo {
-  pub fn new(cx: Scope, id: usize, title: String) -> Self {
-    Self::new_with_completed(cx, id, title, false)
-  }
-
-  pub fn new_with_completed(
-    cx: Scope,
-    id: usize,
-    title: String,
-    completed: bool,
-  ) -> Self {
-    let (title, set_title) = create_signal(cx, title);
-    let (completed, set_completed) = create_signal(cx, completed);
-    Self {
-      id,
-      title,
-      set_title,
-      completed,
-      set_completed,
+    pub fn new(cx: Scope, id: usize, title: String) -> Self {
+        Self::new_with_completed(cx, id, title, false)
     }
-  }
 
-  pub fn toggle(&self) {
-    self
-      .set_completed
-      .update(|completed| *completed = !*completed);
-  }
+    pub fn new_with_completed(cx: Scope, id: usize, title: String, completed: bool) -> Self {
+        let (title, set_title) = create_signal(cx, title);
+        let (completed, set_completed) = create_signal(cx, completed);
+        Self {
+            id,
+            title,
+            set_title,
+            completed,
+            set_completed,
+        }
+    }
+
+    pub fn toggle(&self) {
+        self.set_completed
+            .update(|completed| *completed = !*completed);
+    }
 }
 
 const ESCAPE_KEY: u32 = 27;
 const ENTER_KEY: u32 = 13;
 
 #[component]
-pub fn TodoMVC(cx: Scope,todos: Todos) -> impl IntoView {
-  let mut next_id = todos
-    .0
-    .iter()
-    .map(|todo| todo.id)
-    .max()
-    .map(|last| last + 1)
-    .unwrap_or(0);
-
-  let (todos, set_todos) = create_signal(cx, todos);
-  provide_context(cx, set_todos);
-
-  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();
-    set_mode(new_mode);
-  });
-
-  let add_todo = move |ev: web_sys::KeyboardEvent| {
-    let target = event_target::<HtmlInputElement>(&ev);
-    ev.stop_propagation();
-    let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
-    if key_code == ENTER_KEY {
-      let title = event_target_value(&ev);
-      let title = title.trim();
-      if !title.is_empty() {
-        let new = Todo::new(cx, next_id, title.to_string());
-        set_todos.update(|t| t.add(new));
-        next_id += 1;
-        target.set_value("");
-      }
-    }
-  };
-
-  let filtered_todos = create_memo::<Vec<Todo>>(cx, move |_| {
-    todos.with(|todos| match mode.get() {
-      Mode::All => todos.0.to_vec(),
-      Mode::Active => todos
+pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
+    let mut next_id = todos
         .0
         .iter()
-        .filter(|todo| !todo.completed.get())
-        .cloned()
-        .collect(),
-      Mode::Completed => todos
-        .0
-        .iter()
-        .filter(|todo| todo.completed.get())
-        .cloned()
-        .collect(),
-    })
-  });
+        .map(|todo| todo.id)
+        .max()
+        .map(|last| last + 1)
+        .unwrap_or(0);
 
-  // effect to serialize to JSON
-  // this does reactive reads, so it will automatically serialize on any relevant change
-  create_effect(cx, move |_| {
-    if let Ok(Some(storage)) = window().local_storage() {
-      let objs = todos
-        .get()
-        .0
-        .iter()
-        .map(TodoSerialized::from)
-        .collect::<Vec<_>>();
-      let json = json::to_string(&objs);
-      if storage.set_item(STORAGE_KEY, &json).is_err() {
-        log::error!("error while trying to set item in localStorage");
-      }
-    }
-  });
+    let (todos, set_todos) = create_signal(cx, todos);
+    provide_context(cx, set_todos);
 
-  view! { cx,
-      <main>
-          <section class="todoapp">
-              <header class="header">
-                  <h1>"todos"</h1>
-                  <input class="new-todo" placeholder="What needs to be done?" autofocus="" on:keydown=add_todo />
-              </header>
-              <section class="main" class:hidden={move || todos.with(|t| t.is_empty())}>
-                  <input id="toggle-all" class="toggle-all" type="checkbox"
-                      prop:checked={move || todos.with(|t| t.remaining() > 0)}
-                      on:input=move |_| set_todos.update(|t| t.toggle_all())
-                  />
-                  <label for="toggle-all">"Mark all as complete"</label>
-                  <ul class="todo-list">
-                      <For
-                        each=filtered_todos
-                        key=|todo| todo.id
-                        view=move |todo: Todo| view! { cx,  <Todo todo=todo.clone() /> }
-                      />
-                  </ul>
-              </section>
-              <footer class="footer" class:hidden={move || todos.with(|t| t.is_empty())}>
-                  <span class="todo-count">
-                      <strong>{move || todos.with(|t| t.remaining().to_string())}</strong>
-                      {move || if todos.with(|t| t.remaining()) == 1 {
-                          " item"
-                      } else {
-                          " items"
-                      }}
-                      " left"
-                  </span>
-                  <ul class="filters">
-                      <li><a href="#/" class="selected" class:selected={move || mode() == Mode::All}>"All"</a></li>
-                      <li><a href="#/active" class:selected={move || mode() == Mode::Active}>"Active"</a></li>
-                      <li><a href="#/completed" class:selected={move || mode() == Mode::Completed}>"Completed"</a></li>
-                  </ul>
-                  <button
-                      class="clear-completed hidden"
-                      class:hidden={move || todos.with(|t| t.completed() == 0)}
-                      on:click=move |_| set_todos.update(|t| t.clear_completed())
-                  >
-                      "Clear completed"
-                  </button>
-              </footer>
-          </section>
-          <footer class="info">
-              <p>"Double-click to edit a todo"</p>
-              <p>"Created by "<a href="http://todomvc.com">"Greg Johnston"</a></p>
-              <p>"Part of "<a href="http://todomvc.com">"TodoMVC"</a></p>
-          </footer>
-      </main>
-  }.into_view(cx)
+    let (mode, set_mode) = create_signal(cx, Mode::All);
+
+    let add_todo = move |ev: web_sys::KeyboardEvent| {
+        let target = event_target::<HtmlInputElement>(&ev);
+        ev.stop_propagation();
+        let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
+        if key_code == ENTER_KEY {
+            let title = event_target_value(&ev);
+            let title = title.trim();
+            if !title.is_empty() {
+                let new = Todo::new(cx, next_id, title.to_string());
+                set_todos.update(|t| t.add(new));
+                next_id += 1;
+                target.set_value("");
+            }
+        }
+    };
+
+    let filtered_todos = create_memo::<Vec<Todo>>(cx, move |_| {
+        todos.with(|todos| match mode.get() {
+            Mode::All => todos.0.to_vec(),
+            Mode::Active => todos
+                .0
+                .iter()
+                .filter(|todo| !todo.completed.get())
+                .cloned()
+                .collect(),
+            Mode::Completed => todos
+                .0
+                .iter()
+                .filter(|todo| todo.completed.get())
+                .cloned()
+                .collect(),
+        })
+    });
+
+    // effect to serialize to JSON
+    // this does reactive reads, so it will automatically serialize on any relevant change
+    create_effect(cx, move |_| {
+        if let Ok(Some(storage)) = window().local_storage() {
+            let objs = todos
+                .get()
+                .0
+                .iter()
+                .map(TodoSerialized::from)
+                .collect::<Vec<_>>();
+            let json = json::to_string(&objs);
+            if storage.set_item(STORAGE_KEY, &json).is_err() {
+                log::error!("error while trying to set item in localStorage");
+            }
+        }
+    });
+
+    view! { cx,
+        <main>
+            <section class="todoapp">
+                <header class="header">
+                    <h1>"todos"</h1>
+                    <input
+                        class="new-todo"
+                        placeholder="What needs to be done?"
+                        autofocus=""
+                        on:keydown=add_todo
+                    />
+                </header>
+                <section class="main" class:hidden=move || todos.with(|t| t.is_empty())>
+                    <input
+                        id="toggle-all"
+                        class="toggle-all"
+                        type="checkbox"
+                        prop:checked=move || todos.with(|t| t.remaining() > 0)
+                        on:input=move |_| set_todos.update(|t| t.toggle_all())
+                    />
+                    <label for="toggle-all">"Mark all as complete"</label>
+                    <ul class="todo-list">
+                        <For
+                            each=filtered_todos
+                            key=|todo| todo.id
+                            view=move |cx, todo: Todo| {
+                                view! { cx, <Todo todo=todo.clone()/> }
+                            }
+                        />
+                    </ul>
+                </section>
+                <footer class="footer" class:hidden=move || todos.with(|t| t.is_empty())>
+                    <span class="todo-count">
+                        <strong>{move || todos.with(|t| t.remaining().to_string())}</strong>
+                        {move || if todos.with(|t| t.remaining()) == 1 { " item" } else { " items" }}
+                        " left"
+                    </span>
+                    <ul class="filters">
+                        <li>
+                            <a
+                                href="#/"
+                                class="selected"
+                                class:selected=move || mode() == Mode::All
+                            >
+                                "All"
+                            </a>
+                        </li>
+                        <li>
+                            <a href="#/active" class:selected=move || mode() == Mode::Active>
+                                "Active"
+                            </a>
+                        </li>
+                        <li>
+                            <a href="#/completed" class:selected=move || mode() == Mode::Completed>
+                                "Completed"
+                            </a>
+                        </li>
+                    </ul>
+                    <button
+                        class="clear-completed hidden"
+                        class:hidden=move || todos.with(|t| t.completed() == 0)
+                        on:click=move |_| set_todos.update(|t| t.clear_completed())
+                    >
+                        "Clear completed"
+                    </button>
+                </footer>
+            </section>
+            <footer class="info">
+                <p>"Double-click to edit a todo"</p>
+                <p>"Created by " <a href="http://todomvc.com">"Greg Johnston"</a></p>
+                <p>"Part of " <a href="http://todomvc.com">"TodoMVC"</a></p>
+            </footer>
+        </main>
+    }.into_view(cx)
 }
 
 #[component]
 pub fn Todo(cx: Scope, todo: Todo) -> impl IntoView {
-  let (editing, set_editing) = create_signal(cx, false);
-  let set_todos = use_context::<WriteSignal<Todos>>(cx).unwrap();
-  //let input = NodeRef::new(cx);
+    let (editing, set_editing) = create_signal(cx, false);
+    let set_todos = use_context::<WriteSignal<Todos>>(cx).unwrap();
+    //let input = NodeRef::new(cx);
 
-  let save = move |value: &str| {
-    let value = value.trim();
-    if value.is_empty() {
-      set_todos.update(|t| t.remove(todo.id));
-    } else {
-      (todo.set_title)(value.to_string());
+    let save = move |value: &str| {
+        let value = value.trim();
+        if value.is_empty() {
+            set_todos.update(|t| t.remove(todo.id));
+        } else {
+            (todo.set_title)(value.to_string());
+        }
+        set_editing(false);
+    };
+
+    view! { cx,
+        <li class="todo" class:editing=editing class:completed=move || (todo.completed)()>
+            <div class="view">
+                <input class="toggle" type="checkbox" prop:checked=move || (todo.completed)()/>
+                <label on:dblclick=move |_| set_editing(true)>{move || todo.title.get()}</label>
+                <button
+                    class="destroy"
+                    on:click=move |_| set_todos.update(|t| t.remove(todo.id))
+                ></button>
+            </div>
+            {move || {
+                editing()
+                    .then(|| {
+                        view! { cx,
+                            <input
+                                class="edit"
+                                class:hidden=move || !(editing)()
+                                prop:value=move || todo.title.get()
+                                on:focusout=move |ev| save(&event_target_value(&ev))
+                                on:keyup=move |ev| {
+                                    let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
+                                    if key_code == ENTER_KEY {
+                                        save(&event_target_value(&ev));
+                                    } else if key_code == ESCAPE_KEY {
+                                        set_editing(false);
+                                    }
+                                }
+                            />
+                        }
+                    })
+            }}
+        </li>
     }
-    set_editing(false);
-  };
-
-  view! { cx,
-      <li
-          class="todo"
-          class:editing={editing}
-          class:completed={move || (todo.completed)()}
-          //_ref=input
-      >
-          <div class="view">
-              <input
-                  class="toggle"
-                  type="checkbox"
-                  prop:checked={move || (todo.completed)()}
-
-              />
-              <label on:dblclick=move |_| set_editing(true)>
-                  {move || todo.title.get()}
-              </label>
-              <button class="destroy" on:click=move |_| set_todos.update(|t| t.remove(todo.id))/>
-          </div>
-          {move || editing().then(|| view! { cx,
-              <input
-                  class="edit"
-                  class:hidden={move || !(editing)()}
-                  prop:value={move || todo.title.get()}
-                  on:focusout=move |ev| save(&event_target_value(&ev))
-                  on:keyup={move |ev| {
-                      let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
-                      if key_code == ENTER_KEY {
-                          save(&event_target_value(&ev));
-                      } else if key_code == ESCAPE_KEY {
-                          set_editing(false);
-                      }
-                  }}
-              />
-          })
-      }
-      </li>
-  }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Mode {
-  Active,
-  Completed,
-  All,
+    Active,
+    Completed,
+    All,
 }
 
 impl Default for Mode {
-  fn default() -> Self {
-    Mode::All
-  }
+    fn default() -> Self {
+        Mode::All
+    }
 }
 
 pub fn route(hash: &str) -> Mode {
-  match hash {
-    "/active" => Mode::Active,
-    "/completed" => Mode::Completed,
-    _ => Mode::All,
-  }
+    match hash {
+        "/active" => Mode::Active,
+        "/completed" => Mode::Completed,
+        _ => Mode::All,
+    }
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct TodoSerialized {
-  pub id: usize,
-  pub title: String,
-  pub completed: bool,
+    pub id: usize,
+    pub title: String,
+    pub completed: bool,
 }
 
 impl TodoSerialized {
-  pub fn into_todo(self, cx: Scope) -> Todo {
-    Todo::new_with_completed(cx, self.id, self.title, self.completed)
-  }
+    pub fn into_todo(self, cx: Scope) -> Todo {
+        Todo::new_with_completed(cx, self.id, self.title, self.completed)
+    }
 }
 
 impl From<&Todo> for TodoSerialized {
-  fn from(todo: &Todo) -> Self {
-    Self {
-      id: todo.id,
-      title: todo.title.get(),
-      completed: (todo.completed)(),
+    fn from(todo: &Todo) -> Self {
+        Self {
+            id: todo.id,
+            title: todo.title.get(),
+            completed: (todo.completed)(),
+        }
     }
-  }
 }

benchmarks/src/todomvc/mod.rs

@@ -7,17 +7,15 @@ mod yew;
 
 #[bench]
 fn leptos_todomvc_ssr(b: &mut Bencher) {
+    use ::leptos::*;
+    let runtime = create_runtime();
     b.iter(|| {
         use crate::todomvc::leptos::*;
 
-        _ = create_scope(create_runtime(), |cx| {
-            let rendered = view! {
-                cx,
-                <TodoMVC todos=Todos::new(cx)/>
-            }.into_view(cx).render_to_string(cx);
-
-            assert!(rendered.len() > 1);
+        let html = ::leptos::ssr::render_to_string(|cx| {
+            view! { cx, <TodoMVC todos=Todos::new(cx)/> }
         });
+        assert!(html.len() > 1);
     });
 }
 
@@ -62,14 +60,13 @@ fn leptos_todomvc_ssr_with_1000(b: &mut Bencher) {
         use self::leptos::*;
         use ::leptos::*;
 
-        _ = create_scope(create_runtime(), |cx| {
-            let rendered = view! {
+        let html = ::leptos::ssr::render_to_string(|cx| {
+            view! {
                 cx,
                 <TodoMVC todos=Todos::new_with_1000(cx)/>
-            }.into_view(cx).render_to_string(cx);
-
-            assert!(rendered.len() > 1);
+            }
         });
+        assert!(html.len() > 1);
     });
 }
 
@@ -106,4 +103,4 @@ fn yew_todomvc_ssr_with_1000(b: &mut Bencher) {
             assert!(rendered.len() > 1);
         });
     });
-}
+}

benchmarks/src/todomvc/tera.rs

@@ -174,4 +174,4 @@ fn tera_todomvc_1000(b: &mut Bencher) {
 
         let _ = TERA.render("template.html", &ctx).unwrap();
     });
-}
+}

docs/COMMON_BUGS.md

@@ -61,3 +61,19 @@ view! {
 	<input prop:value=a on:input=on_input />
 }
 ```
+
+## Build configuration
+
+### Cargo feature resolution in workspaces
+
+A new [version](https://doc.rust-lang.org/cargo/reference/resolver.html#resolver-versions) of Cargo's feature resolver was introduced for the 2021 edition of Rust.
+For single crate projects it will select a resolver version based on the Rust edition in `Cargo.toml`. As there is no Rust edition present for `Cargo.toml` in a workspace, Cargo will default to the pre 2021 edition resolver.
+This can cause issues resulting in non WASM compatible code being built for a WASM target. Seeing `mio` failing to build is often a sign that none WASM compatible code is being included in the build.
+
+The resolver version can be set in the workspace `Cargo.toml` to remedy this issue.
+
+```toml
+[workspace]
+members = ["member1", "member2"]
+resolver = "2"
+```

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.0.18"

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.0.18"

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,39 +0,0 @@
-use leptos::*;
-
-fn main() {
-    mount_to_body(|cx| {
-        let name = "gbj";
-        let userid = 0;
-        let _input_element: Element;
-
-        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.0.18"

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/gbj/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,70 @@
 # Getting Started
 
-> The code for this chapter can be found [here](https://github.com/gbj/leptos/tree/main/docs/book/project/ch02_getting_started).
+There are two basic paths to getting started with Leptos:
 
-The easiest way to get started using Leptos is to use [Trunk](https://trunkrs.dev/), as many of our [examples](https://github.com/gbj/leptos/tree/main/examples) do. (Trunk is a simple build tool that includes a dev server.)
+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.
 
 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.)
+> We recommend using `nightly` Rust, as it enables [a few nice features](https://github.com/leptos-rs/leptos#nightly-note). To use `nightly` Rust with WebAssembly, you can run
+>
+> ```bash
+> rustup toolchain install nightly
+> rustup default nightly
+> rustup target add wasm32-unknown-unknown
+> ```
 
-```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
-{{#include ../project/ch02_getting_started/src/main.rs}}
+use leptos::*;
+
+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.
+Your directory structure should now look something like this
+
+```
+leptos_tutorial
+├── src
+│   └── main.rs
+├── Cargo.toml
+├── index.html
+```
+
+Now run `trunk serve --open` from the root of the `leptos-tutorial` directory.
+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/gbj/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/14_create_effect.md

@@ -0,0 +1,112 @@
+# Responding to Changes with `create_effect`
+
+Believe it or not, we’ve made it this far without having mentioned half of the reactive system: effects.
+
+Leptos is built on a fine-grained reactive system, which means that individual reactive values (“signals,” sometimes known as observables) trigger rerunning the code that reacts to them (“effects,” sometimes known as observers). These two halves of the reactive system are inter-dependent. Without effects, signals can change within the reactive system but never be observed in a way that interacts with the outside world. Without signals, effects run once but never again, as there’s no observable value to subscribe to.
+
+[`create_effect`](https://docs.rs/leptos_reactive/latest/leptos_reactive/fn.create_effect.html) takes a function as its argument. It immediately runs the function. If you access any reactive signal inside that function, it registers the fact that the effect depends on that signal with the reactive runtime. Whenever one of the signals that the effect depends on changes, the effect runs again.
+
+```rust
+let (a, set_a) = create_signal(cx, 0);
+let (b, set_b) = create_signal(cx, 0);
+
+create_effect(cx, move |_| {
+  // immediately prints "Value: 0" and subscribes to `a`
+  log::debug!("Value: {}", a());
+});
+```
+
+The effect function is called with an argument containing whatever value it returned the last time it ran. On the initial run, this is `None`.
+
+By default, effects **do not run on the server**. This means you can call browser-specific APIs within the effect function without causing issues. If you need an effect to run on the server, use [`create_isomorphic_effect`](https://docs.rs/leptos_reactive/latest/leptos_reactive/fn.create_isomorphic_effect.html).
+
+## Autotracking and Dynamic Dependencies
+
+If you’re familiar with a framework like React, you might notice one key difference. React and similar frameworks typically require you to pass a “dependency array,” an explicit set of variables that determine when the effect should rerun.
+
+Because Leptos comes from the tradition of synchronous reactive programming, we don’t need this explicit dependency list. Instead, we automatically track dependencies depending on which signals are accessed within the effect.
+
+This has two effects (no pun intended). Dependencies are
+
+1. **Automatic**: You don’t need to maintain a dependency list, or worry about what should or shouldn’t be included. The framework simply tracks which signals might cause the effect to rerun, and handles it for you.
+2. **Dynamic**: The dependency list is cleared and updated every time the effect runs. If your effect contains a conditional (for example), only signals that are used in the current branch are tracked. This means that effects rerun the absolute minimum number of times.
+
+> If this sounds like magic, and if you want a deep dive into how automatic dependency tracking works, [check out this video](https://www.youtube.com/watch?v=GWB3vTWeLd4). (Apologies for the low volume!)
+
+## Effects as Zero-Cost-ish Abstraction
+
+While they’re not a “zero-cost abstraction” in the most technical sense—they require some additional memory use, exist at runtime, etc.—at a higher level, from the perspective of whatever expensive API calls or other work you’re doing within them, effects are a zero-cost abstraction. They rerun the absolute minimum number of times necessary, given how you’ve described them.
+
+Imagine that I’m creating some kind of chat software, and I want people to be able to display their full name, or just their first name, and to notify the server whenever their name changes:
+
+```rust
+let (first, set_first) = create_signal(cx, String::new());
+let (last, set_last) = create_signal(cx, String::new());
+let (use_last, set_use_last) = create_signal(cx, true);
+
+// this will add the name to the log
+// any time one of the source signals changes
+create_effect(cx, move |_| {
+    log(
+        cx,
+        if use_last() {
+            format!("{} {}", first(), last())
+        } else {
+            first()
+        },
+    )
+});
+```
+
+If `use_last` is `true`, effect should rerun whenever `first`, `last`, or `use_last` changes. But if I toggle `use_last` to `false`, a change in `last` will never cause the full name to change. In fact, `last` will be removed from the dependency list until `use_last` toggles again. This saves us from sending multiple unnecessary requests to the API if I change `last` multiple times while `use_last` is still `false`.
+
+## To `create_effect`, or not to `create_effect`?
+
+Effects are intended to run _side-effects_ of the system, not to synchronize state _within_ the system. In other words: don’t write to signals within effects.
+
+If you need to define a signal that depends on the value of other signals, use a derived signal or [`create_memo`](https://docs.rs/leptos_reactive/latest/leptos_reactive/fn.create_memo.html).
+
+If you need to synchronize some reactive value with the non-reactive world outside—like a web API, the console, the filesystem, or the DOM—create an effect.
+
+> If you’re curious for more information about when you should and shouldn’t use `create_effect`, [check out this video](https://www.youtube.com/watch?v=aQOFJQ2JkvQ) for a more in-depth consideration!
+
+## Effects and Rendering
+
+We’ve managed to get this far without mentioning effects because they’re built into the Leptos DOM renderer. We’ve seen that you can create a signal and pass it into the `view` macro, and it will update the relevant DOM node whenever the signal changes:
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+
+view! { cx,
+    <p>{count}</p>
+}
+```
+
+This works because the framework essentially creates an effect wrapping this update. You can imagine Leptos translating this view into something like this:
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+
+// create a DOM element
+let p = create_element("p");
+
+// create an effect to reactively update the text
+create_effect(cx, move |prev_value| {
+    // first, access the signal’s value and convert it to a string
+    let text = count().to_string();
+
+    // if this is different from the previous value, update the node
+    if prev_value != Some(text) {
+        p.set_text_content(&text);
+    }
+
+    // return this value so we can memoize the next update
+    text
+});
+```
+
+Every time `count` is updated, this effect wil rerun. This is what allows reactive, fine-grained updates to the DOM.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/serene-thompson-40974n?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/serene-thompson-40974n?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" style="max-height: 100vh"></iframe>

docs/book/src/15_global_state.md

@@ -0,0 +1,174 @@
+# Global State Management
+
+So far, we've only been working with local state in components
+We've only seen how to communicate between parent and child components
+But there are also more general ways to manage global state
+
+The three best approaches to global state are
+
+1. Using the router to drive global state via the URL
+2. Passing signals through context
+3. Creating a global state struct and creating lenses into it with `create_slice`
+
+## Option #1: URL as Global State
+
+The next few sections of the tutorial will be about the router.
+So for now, we'll just look at options #2 and #3.
+
+## Option #2: Passing Signals through Context
+
+In virtual DOM libraries like React, using the Context API to manage global
+state is a bad idea: because the entire app exists in a tree, changing
+some value provided high up in the tree can cause the whole app to render.
+
+In fine-grained reactive libraries like Leptos, this is simply not the case.
+You can create a signal in the root of your app and pass it down to other
+components using provide_context(). Changing it will only cause rerendering
+in the specific places it is actually used, not the whole app.
+
+We start by creating a signal in the root of the app and providing it to
+all its children and descendants using `provide_context`.
+
+```rust
+#[component]
+fn App(cx: Scope) -> impl IntoView {
+    // here we create a signal in the root that can be consumed
+    // anywhere in the app.
+    let (count, set_count) = create_signal(cx, 0);
+    // we'll pass the setter to specific components,
+    // but provide the count itself to the whole app via context
+    provide_context(cx, count);
+
+    view! { cx,
+        // SetterButton is allowed to modify the count
+        <SetterButton set_count/>
+        // These consumers can only read from it
+        // But we could give them write access by passing `set_count` if we wanted
+        <FancyMath/>
+        <ListItems/>
+    }
+}
+```
+
+`<SetterButton/>` is the kind of counter we’ve written several times now.
+(See the sandbox below if you don’t understand what I mean.)
+
+`<FancyMath/>` and `<ListItems/>` both consume the signal we’re providing via
+`use_context` and do something with it.
+
+```rust
+/// A component that does some "fancy" math with the global count
+#[component]
+fn FancyMath(cx: Scope) -> impl IntoView {
+    // here we consume the global count signal with `use_context`
+    let count = use_context::<ReadSignal<u32>>(cx)
+        // we know we just provided this in the parent component
+        .expect("there to be a `count` signal provided");
+    let is_even = move || count() & 1 == 0;
+
+    view! { cx,
+        <div class="consumer blue">
+            "The number "
+            <strong>{count}</strong>
+            {move || if is_even() {
+                " is"
+            } else {
+                " is not"
+            }}
+            " even."
+        </div>
+    }
+}
+```
+
+This kind of “provide a signal in a parent, consume it in a child” should be familiar
+from the chapter on [parent-child interactions](./view/08_parent_child.md). The same
+pattern you use to communicate between parents and children works for grandparents and
+grandchildren, or any ancestors and descendants: in other words, between “global” state
+in the root component of your app and any other components anywhere else in the app.
+
+Because of the fine-grained nature of updates, this is usually all you need. However,
+in some cases with more complex state changes, you may want to use a slightly more
+structured approach to global state.
+
+## Option #3: Create a Global State Struct
+
+You can use this approach to build a single global data structure
+that holds the state for your whole app, and then access it by
+taking fine-grained slices using
+[`create_slice`](https://docs.rs/leptos/latest/leptos/fn.create_slice.html)
+or [`create_memo`](https://docs.rs/leptos/latest/leptos/fn.create_memo.html),
+so that changing one part of the state doesn't cause parts of your
+app that depend on other parts of the state to change.
+
+You can begin by defining a simple state struct:
+
+```rust
+#[derive(Default, Clone, Debug)]
+struct GlobalState {
+    count: u32,
+    name: String,
+}
+```
+
+Provide it in the root of your app so it’s available everywhere.
+
+```rust
+#[component]
+fn App(cx: Scope) -> impl IntoView {
+    // we'll provide a single signal that holds the whole state
+    // each component will be responsible for creating its own "lens" into it
+    let state = create_rw_signal(cx, GlobalState::default());
+    provide_context(cx, state);
+
+    // ...
+}
+```
+
+Then child components can access “slices” of that state with fine-grained
+updates via `create_slice`. Each slice signal only updates when the particular
+piece of the larger struct it accesses updates. This means you can create a single
+root signal, and then take independent, fine-grained slices of it in different
+components, each of which can update without notifying the others of changes.
+
+```rust
+/// A component that updates the count in the global state.
+#[component]
+fn GlobalStateCounter(cx: Scope) -> impl IntoView {
+    let state = use_context::<RwSignal<GlobalState>>(cx).expect("state to have been provided");
+
+    // `create_slice` lets us create a "lens" into the data
+    let (count, set_count) = create_slice(
+        cx,
+        // we take a slice *from* `state`
+        state,
+        // our getter returns a "slice" of the data
+        |state| state.count,
+        // our setter describes how to mutate that slice, given a new value
+        |state, n| state.count = n,
+    );
+
+    view! { cx,
+        <div class="consumer blue">
+            <button
+                on:click=move |_| {
+                    set_count(count() + 1);
+                }
+            >
+                "Increment Global Count"
+            </button>
+            <br/>
+            <span>"Count is: " {count}</span>
+        </div>
+    }
+}
+```
+
+Clicking this button only updates `state.count`, so if we create another slice
+somewhere else that only takes `state.name`, clicking the button won’t cause
+that other slice to update. This allows you to combine the benefits of a top-down
+data flow and of fine-grained reactive updates.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/1-basic-component-forked-8bte19?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/1-basic-component-forked-8bte19?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh">

docs/book/src/SUMMARY.md

@@ -2,5 +2,48 @@
 
 - [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)
+- [Async](./async/README.md)
+  - [Loading Data with Resources](./async/10_resources.md)
+  - [Suspense](./async/11_suspense.md)
+  - [Transition](./async/12_transition.md)
+  - [Actions](./async/13_actions.md)
+- [Responding to Changes with `create_effect`](./14_create_effect.md)
+- [Global State Management](./15_global_state.md)
+- [Router](./router/README.md)
+  - [Defining `<Routes/>`](./router/16_routes.md)
+  - [Nested Routing](./router/17_nested_routing.md)
+  - [Params and Queries](./router/18_params_and_queries.md)
+  - [`<A/>`](./router/19_a.md)
+  - [`<Form/>`](./router/20_form.md)
+- [Interlude: Styling](./interlude_styling.md)
+- [Metadata]()
+- [Server Side Rendering](./ssr/README.md)
+  - [`cargo-leptos`]()
+  - [The Life of a Page Load](./ssr/21_life_cycle.md)
+  - [Async Rendering and SSR “Modes”](./ssr/22_ssr_modes.md)
+  - [Hydration Footguns]()
+- [Request/Response]()
+  - [Extractors]()
+    - [Axum]()
+    - [Actix]()
+  - [Headers]()
+  - [Cookies]()
+- [Server Functions]()
+  - [Actions]()
+  - [Forms]()
+  - [`<ActionForm/>`s]()
+  - [Turning off WebAssembly]()
+- [Advanced Reactivity]()
+- [Appendix: Optimizing WASM Binary Size]()

docs/book/src/async/10_resources.md

@@ -0,0 +1,55 @@
+# Loading Data with Resources
+
+A [Resource](https://docs.rs/leptos/latest/leptos/struct.Resource.html) is a reactive data structure that reflects the current state of an asynchronous task, allowing you to integrate asynchronous `Future`s into the synchronous reactive system. Rather than waiting for its data to load with `.await`, you transform the `Future` into a signal that returns `Some(T)` if it has resolved, and `None` if it’s still pending.
+
+You do this by using the [`create_resource`](https://docs.rs/leptos/latest/leptos/fn.create_resource.html) function. This takes two arguments (other than the ubiquitous `cx`):
+
+1. a source signal, which will generate a new `Future` whenever it changes
+2. a fetcher function, which takes the data from that signal and returns a `Future`
+
+Here’s an example
+
+```rust
+// our source signal: some synchronous, local state
+let (count, set_count) = create_signal(cx, 0);
+
+// our resource
+let async_data = create_resource(cx,
+    count,
+    // every time `count` changes, this will run
+    |value| async move {
+        log!("loading data from API");
+        load_data(value).await
+    },
+);
+```
+
+To create a resource that simply runs once, you can pass a non-reactive, empty source signal:
+
+```rust
+let once = create_resource(cx, || (), |_| async move { load_data().await });
+```
+
+To access the value you can use `.read(cx)` or `.with(cx, |data| /* */)`. These work just like `.get()` and `.with()` on a signal—`read` clones the value and returns it, `with` applies a closure to it—but with two differences
+
+1. For any `Resource<_, T>`, they always return `Option<T>`, not `T`: because it’s always possible that your resource is still loading.
+2. They take a `Scope` argument. You’ll see why in the next chapter, on `<Suspense/>`.
+
+So, you can show the current state of a resource in your view:
+
+```rust
+let once = create_resource(cx, || (), |_| async move { load_data().await });
+view! { cx,
+    <h1>"My Data"</h1>
+    {move || match once.read(cx) {
+        None => view! { cx, <p>"Loading..."</p> }.into_view(cx),
+        Some(data) => view! { cx, <ShowData data/> }.into_view(cx)
+    }}
+}
+```
+
+Resources also provide a `refetch()` method that allows you to manually reload the data (for example, in response to a button click) and a `loading()` method that returns a `ReadSignal<bool>` indicating whether the resource is currently loading or not.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/10-async-resources-4z0qt3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/10-async-resources-4z0qt3?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" style="max-height: 100vh"></iframe>

docs/book/src/async/11_suspense.md

@@ -0,0 +1,74 @@
+# `<Suspense/>`
+
+In the previous chapter, we showed how you can create a simple loading screen to show some fallback while a resource is loading.
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+let a = create_resource(cx, count, |count| async move { load_a(count).await });
+
+view! { cx,
+    <h1>"My Data"</h1>
+    {move || match once.read(cx) {
+        None => view! { cx, <p>"Loading..."</p> }.into_view(cx),
+        Some(data) => view! { cx, <ShowData data/> }.into_view(cx)
+    }}
+}
+```
+
+But what if we have two resources, and want to wait for both of them?
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+let (count2, set_count2) = create_signal(cx, 0);
+let a = create_resource(cx, count, |count| async move { load_a(count).await });
+let b = create_resource(cx, count2, |count| async move { load_b(count).await });
+
+view! { cx,
+    <h1>"My Data"</h1>
+    {move || match (a.read(cx), b.read(cx)) {
+        (Some(a), Some(b)) => view! { cx,
+            <ShowA a/>
+            <ShowA b/>
+        }.into_view(cx),
+        _ => view! { cx, <p>"Loading..."</p> }.into_view(cx)
+    }}
+}
+```
+
+That’s not _so_ bad, but it’s kind of annoying. What if we could invert the flow of control?
+
+The [`<Suspense/>`](https://docs.rs/leptos/latest/leptos/fn.Suspense.html) component lets us do exactly that. You give it a `fallback` prop and children, one or more of which usually involves reading from a resource. Reading from a resource “under” a `<Suspense/>` (i.e., in one of its children) registers that resource with the `<Suspense/>`. If it’s still waiting for resources to load, it shows the `fallback`. When they’ve all loaded, it shows the children.
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+let (count2, set_count2) = create_signal(cx, 0);
+let a = create_resource(cx, count, |count| async move { load_a(count).await });
+let b = create_resource(cx, count2, |count| async move { load_b(count).await });
+
+view! { cx,
+    <h1>"My Data"</h1>
+    <Suspense
+        fallback=move || view! { cx, <p>"Loading..."</p> }
+    >
+        <h2>"My Data"</h2>
+        <h3>"A"</h3>
+        {move || {
+            a.read(cx)
+                .map(|a| view! { cx, <ShowA a/> })
+        }}
+        <h3>"B"</h3>
+        {move || {
+            b.read(cx)
+                .map(|b| view! { cx, <ShowB b/> })
+        }}
+    </Suspense>
+}
+```
+
+Every time one of the resources is reloading, the `"Loading..."` fallback will show again.
+
+This inversion of the flow of control makes it easier to add or remove individual resources, as you don’t need to handle the matching yourself. It also unlocks some massive performance improvements during server-side rendering, which we’ll talk about during a later chapter.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/11-suspense-907niv?file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/11-suspense-907niv?file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/async/12_transition.md

@@ -0,0 +1,11 @@
+# `<Transition/>`
+
+You’ll notice in the `<Suspense/>` example that if you keep reloading the data, it keeps flickering back to `"Loading..."`. Sometimes this is fine. For other times, there’s [`<Transition/>`](https://docs.rs/leptos/latest/leptos/fn.Suspense.html).
+
+`<Transition/>` behaves exactly the same as `<Suspense/>`, but instead of falling back every time, it only shows the fallback the first time. On all subsequent loads, it continues showing the old data until the new data are ready. This can be really handy to prevent the flickering effect, and to allow users to continue interacting with your application.
+
+This example shows how you can create a simple tabbed contact list with `<Transition/>`. When you select a new tab, it continues showing the current contact until the new data loads. This can be a much better user experience than constantly falling back to a loading message.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/12-transition-sn38sd?selection=%5B%7B%22endColumn%22%3A15%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A15%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/12-transition-sn38sd?selection=%5B%7B%22endColumn%22%3A15%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A15%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/async/13_actions.md

@@ -0,0 +1,96 @@
+# Mutating Data with Actions
+
+We’ve talked about how to load `async` data with resources. Resources immediately load data and work closely with `<Suspense/>` and `<Transition/>` components to show whether data is loading in your app. But what if you just want to call some arbitrary `async` function and keep track of what it’s doing?
+
+Well, you could always use [`spawn_local`](https://docs.rs/leptos/latest/leptos/fn.spawn_local.html). This allows you to just spawn an `async` task in a synchronous environment by handing the `Future` off to the browser (or, on the server, Tokio or whatever other runtime you’re using). But how do you know if it’s still pending? Well, you could just set a signal to show whether it’s loading, and another one to show the result...
+
+All of this is true. Or you could use the final `async` primitive: [`create_action`](https://docs.rs/leptos/latest/leptos/fn.create_action.html).
+
+Actions and resources seem similar, but they represent fundamentally different things. If you’re trying to load data by running an `async` function, either once or when some other value changes, you probably want to use `create_resource`. If you’re trying to occasionally run an `async` function in response to something like a user clicking a button, you probably want to use `create_action`.
+
+Say we have some `async` function we want to run.
+
+```rust
+async fn add_todo(new_title: &str) -> Uuid {
+    /* do some stuff on the server to add a new todo */
+}
+```
+
+`create_action` takes a reactive `Scope` and an `async` function that takes a reference to a single argument, which you could think of as its “input type.”
+
+> The input is always a single type. If you want to pass in multiple arguments, you can do it with a struct or tuple.
+>
+> ```rust
+> // if there's a single argument, just use that
+> let action1 = create_action(cx, |input: &String| {
+>    let input = input.clone();
+>    async move { todo!() }
+> });
+>
+> // if there are no arguments, use the unit type `()`
+> let action2 = create_action(cx, |input: &()| async { todo!() });
+>
+> // if there are multiple arguments, use a tuple
+> let action3 = create_action(cx,
+>   |input: &(usize, String)| async { todo!() }
+> );
+> ```
+>
+> Because the action function takes a reference but the `Future` needs to have a `'static` lifetime, you’ll usually need to clone the value to pass it into the `Future`. This is admittedly awkward but it unlocks some powerful features like optimistic UI. We’ll see a little more about that in future chapters.
+
+So in this case, all we need to do to create an action is
+
+```rust
+let add_todo = create_action(cx, |input: &String| {
+    let input = input.to_owned();
+    async move { add_todo(&input).await }
+});
+```
+
+Rather than calling `add_todo` directly, we’ll call it with `.dispatch()`, as in
+
+```rust
+add_todo.dispatch("Some value".to_string());
+```
+
+You can do this from an event listener, a timeout, or anywhere; because `.dispatch()` isn’t an `async` function, it can be called from a synchronous context.
+
+Actions provide access to a few signals that synchronize between the asynchronous action you’re calling and the synchronous reactive system:
+
+```rust
+let submitted = add_todo.input(); // RwSignal<Option<String>>
+let pending = add_todo.pending(); // ReadSignal<bool>
+let todo_id = add_todo.value(); // RwSignal<Option<Uuid>>
+```
+
+This makes it easy to track the current state of your request, show a loading indicator, or do “optimistic UI” based on the assumption that the submission will succeed.
+
+```rust
+let input_ref = create_node_ref::<Input>(cx);
+
+view! { cx,
+    <form
+        on:submit=move |ev| {
+            ev.prevent_default(); // don't reload the page...
+            let input = input_ref.get().expect("input to exist");
+            add_todo.dispatch(input.value());
+        }
+    >
+        <label>
+            "What do you need to do?"
+            <input type="text"
+                node_ref=input_ref
+            />
+        </label>
+        <button type="submit">"Add Todo"</button>
+    </form>
+    // use our loading state
+    <p>{move || pending().then("Loading...")}</p>
+}
+```
+
+Now, there’s a chance this all seems a little over-complicated, or maybe too restricted. I wanted to include actions here, alongside resources, as the missing piece of the puzzle. In a real Leptos app, you’ll actually most often use actions alongside server functions, [`create_server_action`](https://docs.rs/leptos/latest/leptos/fn.create_server_action.html), and the [`<ActionForm/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.ActionForm.html) component to create really powerful progressively-enhanced forms. So if this primitive seems useless to you... Don’t worry! Maybe it will make sense later. (Or check out our [`todo_app_sqlite`](https://github.com/leptos-rs/leptos/blob/main/examples/todo_app_sqlite/src/todo.rs) example now.)
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/10-async-resources-forked-hgpfp0?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A4%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A4%7D%5D&file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/10-async-resources-forked-hgpfp0?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A4%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A4%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/async/README.md

@@ -0,0 +1,9 @@
+# Working with `async`
+
+So far we’ve only been working with synchronous users interfaces: You provide some input,
+the app immediately process it and updates the interface. This is great, but is a tiny
+subset of what web applications do. In particular, most web apps have to deal with some kind
+of asynchronous data loading, usually loading something from an API.
+
+Asynchronous data is notoriously hard to integrate with the synchronous parts of your code.
+In this chapter, we’ll see how Leptos helps smooth out that process for you.

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 reruns 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 rerun
+
+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 rerun 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/interlude_styling.md

@@ -0,0 +1,112 @@
+# Interlude: Styling
+
+Anyone creating a website or application soon runs into the question of styling. For a small app, a single CSS file is probably plenty to style your user interface. But as an application grows, many developers find that plain CSS becomes increasingly hard to manage.
+
+Some frontend frameworks (like Angular, Vue, and Svelte) provide built-in ways to scope your CSS to particular components, making it easier to manage styles across a whole application without styles meant to modify one small component having a global effect. Other frameworks (like React or Solid) don’t provide built-in CSS scoping, but rely on libraries in the ecosystem to do it for them. Leptos is in this latter camp: the framework itself has no opinions about CSS at all, but provides a few tools and primitives that allow others to build styling libraries.
+
+Here are a few different approaches to styling your Leptos app, other than plain CSS.
+
+## TailwindCSS: Utility-first CSS
+
+[TailwindCSS](https://tailwindcss.com/) is a popular utility-first CSS library. It allows you to style your application by using inline utility classes, with a custom CLI tool that scans your files for Tailwind class names and bundles the necessary CSS.
+
+This allows you to write components like this:
+
+```rust
+#[component]
+fn Home(cx: Scope) -> impl IntoView {
+    let (count, set_count) = create_signal(cx, 0);
+
+    view! { cx,
+        <main class="my-0 mx-auto max-w-3xl text-center">
+            <h2 class="p-6 text-4xl">"Welcome to Leptos with Tailwind"</h2>
+            <p class="px-10 pb-10 text-left">"Tailwind will scan your Rust files for Tailwind class names and compile them into a CSS file."</p>
+            <button
+                class="bg-sky-600 hover:bg-sky-700 px-5 py-3 text-white rounded-lg"
+                on:click=move |_| set_count.update(|count| *count += 1)
+            >
+                {move || if count() == 0 {
+                    "Click me!".to_string()
+                } else {
+                    count().to_string()
+                }}
+            </button>
+        </main>
+    }
+}
+```
+
+It can be a little complicated to set up the Tailwind integration at first, but you can check out our two examples of how to use Tailwind with a [client-side-rendered `trunk` application](https://github.com/leptos-rs/leptos/tree/main/examples/tailwind_csr_trunk) or with a [server-rendered `cargo-leptos` application](https://github.com/leptos-rs/leptos/tree/main/examples/tailwind). `cargo-leptos` also has some [built-in Tailwind support](https://github.com/leptos-rs/cargo-leptos#site-parameters) that you can use as an alternative to Tailwind’s CLI.
+
+## Stylers: Compile-time CSS Extraction
+
+[Stylers](https://github.com/abishekatp/stylers) is a compile-time scoped CSS library that lets you declare scoped CSS in the body of your component. Stylers will extract this CSS at compile time into CSS files that you can then import into your app, which means that it doesn’t add anything to the WASM binary size of your application.
+
+This allows you to write components like this:
+
+```rust
+use stylers::style;
+
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+    let styler_class = style! { "App",
+        #two{
+            color: blue;
+        }
+        div.one{
+            color: red;
+            content: raw_str(r#"\hello"#);
+            font: "1.3em/1.2" Arial, Helvetica, sans-serif;
+        }
+        div {
+            border: 1px solid black;
+            margin: 25px 50px 75px 100px;
+            background-color: lightblue;
+        }
+        h2 {
+            color: purple;
+        }
+        @media only screen and (max-width: 1000px) {
+            h3 {
+                background-color: lightblue;
+                color: blue
+            }
+        }
+    };
+
+    view! { cx, class = styler_class,
+        <div class="one">
+            <h1 id="two">"Hello"</h1>
+            <h2>"World"</h2>
+            <h2>"and"</h2>
+            <h3>"friends!"</h3>
+        </div>
+    }
+}
+```
+
+## Styled: Runtime CSS Scoping
+
+[Styled](https://github.com/eboody/styled) is a runtime scoped CSS library that integrates well with Leptos. It lets you declare scoped CSS in the body of your component function, and then applies those styles at runtime.
+
+```rust
+use styled::style;
+
+#[component]
+pub fn MyComponent(cx: Scope) -> impl IntoView {
+    let styles = style!(
+      div {
+        background-color: red;
+        color: white;
+      }
+    );
+
+    styled::view! { cx, styles,
+        <div>"This text should be red with white text."</div>
+    }
+}
+```
+
+## Contributions Welcome
+
+Leptos no opinions on how you style your website or app, but we’re very happy to provide support to any tools you’re trying to create to make it easier. If you’re working on a CSS or styling approach that you’d like to add to this list, please let us know!

docs/book/src/router/16_routes.md

@@ -0,0 +1,101 @@
+# Defining Routes
+
+## Getting Started
+
+It’s easy to get started with the router.
+
+First things first, make sure you’ve added the `leptos_router` package to your dependencies.
+
+> It’s important that the router is a separate package from `leptos` itself. This means that everything in the router can be defined in user-land code. If you want to create your own router, or use no router, you’re completely free to do that!
+
+And import the relevant types from the router, either with something like
+
+```rust
+use leptos_router::{Route, RouteProps, Router, RouterProps, Routes, RoutesProps};
+```
+
+or simply
+
+```rust
+use leptos_router::*;
+```
+
+## Providing the `<Router/>`
+
+Routing behavior is provided by the [`<Router/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.Router.html) component. This should usually be somewhere near the root of your application, the rest of the app.
+
+> You shouldn’t try to use multiple `<Router/>`s in your app. Remember that the router drives global state: if you have multiple routers, which ones decides what to do when the URL changes?
+
+Let’s start with a simple `<App/>` component using the router:
+
+```rust
+use leptos::*;
+use leptos_router::*;
+
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+  view! {
+    <Router>
+      <nav>
+        /* ... */
+      </nav>
+      <main>
+        /* ... */
+      </main>
+    </Router>
+  }
+}
+```
+
+## Defining `<Routes/>`
+
+The [`<Routes/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.Routes.html) component is where you define all the routes to which a user can navigate in your application. Each possible route is defined by a [`<Route/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.Route.html) component.
+
+You should place the `<Routes/>` component at the location within your app where you want routes to be rendered. Everything outside `<Routes/>` will be present on every page, so you can leave things like a navigation bar or menu outside the `<Routes/>`.
+
+```rust
+use leptos::*;
+use leptos_router::*;
+
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+  view! {
+    <Router>
+      <nav>
+        /* ... */
+      </nav>
+      <main>
+        // all our routes will appear inside <main>
+        <Routes>
+          /* ... */
+        </Routes>
+      </main>
+    </Router>
+  }
+}
+```
+
+Individual routes are defined by providing children to `<Routes/>` with the `<Route/>` component. `<Route/>` takes a `path` and a `view`. When the current location matches `path`, the `view` will be created and displayed.
+
+The `path` can include
+
+- a static path (`/users`),
+- dynamic, named parameters beginning with a colon (`/:id`),
+- and/or a wildcard beginning with an asterisk (`/user/*any`)
+
+The `view` is a function that takes a `Scope` and returns a view.
+
+```rust
+<Routes>
+  <Route path="/" view=|cx| view! { cx, <Home/> }/>
+  <Route path="/users" view=|cx| view! { cx, <Users/> }/>
+  <Route path="/users/:id" view=|cx| view! { cx, <UserProfile/> }/>
+  <Route path="/*any" view=|cx| view! { cx, <NotFound/> }/>
+</Routes>
+```
+
+> The router scores each route to see how good a match it is, so you can define your routes in any order.
+
+Now if you navigate to `/` or to `/users` you’ll get the home page or the `<Users/>`. If you go to `/users/3` or `/blahblah` you’ll get a user profile or your 404 page (`<NotFound/>`). On every navigation, the router determines which `<Route/>` should be matched, and therefore what content should be displayed where the `<Routes/>` component is defined.
+
+Simple enough?

docs/book/src/router/17_nested_routing.md

@@ -0,0 +1,172 @@
+# Nested Routing
+
+We just defined the following set of routes:
+
+```rust
+<Routes>
+  <Route path="/" view=|cx| view! { cx, <Home /> }/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }/>
+  <Route path="/users/:id" view=|cx| view! { cx, <UserProfile /> }/>
+  <Route path="/*any" view=|cx| view! { cx, <NotFound /> }/>
+</Routes>
+```
+
+There’s a certain amount of duplication here: `/users` and `/users/:id`. This is fine for a small app, but you can probably already tell it won’t scale well. Wouldn’t it be nice if we could nest these routes?
+
+Well... you can!
+
+```rust
+<Routes>
+  <Route path="/" view=|cx| view! { cx, <Home /> }/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }>
+    <Route path=":id" view=|cx| view! { cx, <UserProfile /> }/>
+  </Route>
+  <Route path="/*any" view=|cx| view! { cx, <NotFound /> }/>
+</Routes>
+```
+
+But wait. We’ve just subtly changed what our application does.
+
+The next section is one of the most important in this entire routing section of the guide. Read it carefully, and feel free to ask questions if there’s anything you don’t understand.
+
+# Nested Routes as Layout
+
+Nested routes are a form of layout, not a method of route definition.
+
+Let me put that another way: The goal of defining nested routes is not primarily to avoid repeating yourself when typing out the paths in your route definitions. It is actually to tell the router to display multiple `<Route/>`s on the page at the same time, side by side.
+
+Let’s look back at our practical example.
+
+```rust
+<Routes>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }/>
+  <Route path="/users/:id" view=|cx| view! { cx, <UserProfile /> }/>
+</Routes>
+```
+
+This means:
+
+- If I go to `/users`, I get the `<Users/>` component.
+- If I go to `/users/3`, I get the `<UserProfile/>` component (with the parameter `id` set to `3`; more on that later)
+
+Let’s say I use nested routes instead:
+
+```rust
+<Routes>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }>
+    <Route path=":id" view=|cx| view! { cx, <UserProfile /> }/>
+  </Route>
+</Routes>
+```
+
+This means:
+
+- If I go to `/users/3`, the path matches two `<Route/>`s: `<Users/>` and `<UserProfile/>`.
+- If I go to `/users`, the path is not matched.
+
+I actually need to add a fallback route
+
+```rust
+<Routes>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }>
+    <Route path=":id" view=|cx| view! { cx, <UserProfile /> }/>
+    <Route path="" view=|cx| view! { cx, <NoUser /> }/>
+  </Route>
+</Routes>
+```
+
+Now:
+
+- If I go to `/users/3`, the path matches `<Users/>` and `<UserProfile/>`.
+- If I go to `/users`, the path matches `<Users/>` and `<NoUser/>`.
+
+When I use nested routes, in other words, each **path** can match multiple **routes**: each URL can render the views provided by multiple `<Route/>` components, at the same time, on the same page.
+
+This may be counter-intuitive, but it’s very powerful, for reasons you’ll hopefully see in a few minutes.
+
+## Why Nested Routing?
+
+Why bother with this?
+
+Most web applications contain levels of navigation that correspond to different parts of the layout. For example, in an email app you might have a URL like `/contacts/greg`, which shows a list of contacts on the left of the screen, and contact details for Greg on the right of the screen. The contact list and the contact details should always appear on the screen at the same time. If there’s no contact selected, maybe you want to show a little instructional text.
+
+You can easily define this with nested routes
+
+```rust
+<Routes>
+  <Route path="/contacts" view=|cx| view! { cx, <ContactList/> }>
+    <Route path=":id" view=|cx| view! { cx, <ContactInfo/> }/>
+    <Route path="" view=|cx| view! { cx,
+      <p>"Select a contact to view more info."</p>
+    }/>
+  </Route>
+</Routes>
+```
+
+You can go even deeper. Say you want to have tabs for each contact’s address, email/phone, and your conversations with them. You can add _another_ set of nested routes inside `:id`:
+
+```rust
+<Routes>
+  <Route path="/contacts" view=|cx| view! { cx, <ContactList/> }>
+    <Route path=":id" view=|cx| view! { cx, <ContactInfo/> }>
+      <Route path="" view=|cx| view! { cx, <EmailAndPhone/> }/>
+      <Route path="address" view=|cx| view! { cx, <Address/> }/>
+      <Route path="messages" view=|cx| view! { cx, <Messages/> }/>
+    </Route>
+    <Route path="" view=|cx| view! { cx,
+      <p>"Select a contact to view more info."</p>
+    }/>
+  </Route>
+</Routes>
+```
+
+> The main page of the [Remix website](https://remix.run/), a React framework from the creators of React Router, has a great visual example if you scroll down, with three levels of nested routing: Sales > Invoices > an invoice.
+
+## `<Outlet/>`
+
+Parent routes do not automatically render their nested routes. After all, they are just components; they don’t know exactly where they should render their children, and “just stick at at the end of the parent component” is not a great answer.
+
+Instead, you tell a parent component where to render any nested components with an `<Outlet/>` component. The `<Outlet/>` simply renders one of two things:
+
+- if there is no nested route that has been matched, it shows nothing
+- if there is a nested route that has been matched, it shows its `view`
+
+That’s all! But it’s important to know and to remember, because it’s a common source of “Why isn’t this working?” frustration. If you don’t provide an `<Outlet/>`, the nested route won’t be displayed.
+
+```rust
+#[component]
+pub fn ContactList(cx: Scope) -> impl IntoView {
+  let contacts = todo!();
+
+  view! { cx,
+    <div style="display: flex">
+      // the contact list
+      <For each=contacts
+        key=|contact| contact.id
+        view=|cx, contact| todo!()
+      >
+      // the nested child, if any
+      // don’t forget this!
+      <Outlet/>
+    </div>
+  }
+}
+```
+
+## Nested Routing and Performance
+
+All of this is nice, conceptually, but again—what’s the big deal?
+
+Performance.
+
+In a fine-grained reactive library like Leptos, it’s always important to do the least amount of rendering work you can. Because we’re working with real DOM nodes and not diffing a virtual DOM, we want to “rerender” components as infrequently as possible. Nested routing makes this extremely easy.
+
+Imagine my contact list example. If I navigate from Greg to Alice to Bob and back to Greg, the contact information needs to change on each navigation. But the `<ContactList/>` should never be rerendered. Not only does this save on rendering performance, it also maintains state in the UI. For example, if I have a search bar at the top of `<ContactList/>`, navigating from Greg to Alice to Bob won’t clear the search.
+
+In fact, in this case, we don’t even need to rerender the `<Contact/>` component when moving between contacts. The router will just reactively update the `:id` parameter as we navigate, allowing us to make fine-grained updates. As we navigate between contacts, we’ll update single text nodes to change the contact’s name, address, and so on, without doing _any_ additional rerendering.
+
+> This sandbox includes a couple features (like nested routing) discussed in this section and the previous one, and a couple we’ll cover in the rest of this chapter. The router is such an integrated system that it makes sense to provide a single example, so don’t be surprised if there’s anything you don’t understand.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?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" style="max-height: 100vh"></iframe>

docs/book/src/router/18_params_and_queries.md

@@ -0,0 +1,79 @@
+# Params and Queries
+
+Static paths are useful for distinguishing between different pages, but almost every application wants to pass data through the URL at some point.
+
+There are two ways you can do this:
+
+1. named route **params** like `id` in `/users/:id`
+2. named route **queries** like `q` in `/search?q=Foo`
+
+Because of the way URLs are built, you can access the query from _any_ `<Route/>` view. You can access route params from the `<Route/>` that defines them or any of its nested children.
+
+Accessing params and queries is pretty simple with a couple of hooks:
+
+- [`use_query`](https://docs.rs/leptos_router/latest/leptos_router/fn.use_query.html) or [`use_query_map`](https://docs.rs/leptos_router/latest/leptos_router/fn.use_query_map.html)
+- [`use_params`](https://docs.rs/leptos_router/latest/leptos_router/fn.use_params.html) or [`use_params_map`](https://docs.rs/leptos_router/latest/leptos_router/fn.use_query_map.html)
+
+Each of these comes with a typed option (`use_query` and `use_params`) and an untyped option (`use_query_map` and `use_params_map`).
+
+The untyped versions hold a simple key-value map. To use the typed versions, derive the [`Params`](https://docs.rs/leptos_router/0.2.3/leptos_router/trait.Params.html) trait on a struct.
+
+> `Params` is a very lightweight trait to convert a flat key-value map of strings into a struct by applying `FromStr` to each field. Because of the flat structure of route params and URL queries, it’s significantly less flexible than something like `serde`; it also adds much less weight to your binary.
+
+```rust
+use leptos::*;
+use leptos_router::*;
+
+#[derive(Params)]
+struct ContactParams {
+	id: usize
+}
+
+#[derive(Params)]
+struct ContactSearch {
+	q: String
+}
+```
+
+> Note: The `Params` derive macro is located at `leptos::Params`, and the `Params` trait is at `leptos_router::Params`. If you avoid using glob imports like `use leptos::*;`, make sure you’re importing the right one for the derive macro.
+
+Now we can use them in a component. Imagine a URL that has both params and a query, like `/contacts/:id?q=Search`.
+
+The typed versions return `Memo<Result<T>, _>`. It’s a Memo so it reacts to changes in the URL. It’s a `Result` because the params or query need to be parsed from the URL, and may or may not be valid.
+
+```rust
+let params = use_params::<ContactParams>(cx);
+let query = use_query::<ContactSearch>(cx);
+
+// id: || -> usize
+let id = move || {
+	params.with(|params| {
+		params
+			.map(|params| params.id)
+			.unwrap_or_default()
+	})
+};
+```
+
+The untyped versions return `Memo<ParamsMap>`. Again, it’s memo to react to changes in the URL. [`ParamsMap`](https://docs.rs/leptos_router/0.2.3/leptos_router/struct.ParamsMap.html) behaves a lot like any other map type, with a `.get()` method that returns `Option<&String>`.
+
+```rust
+let params = use_params_map(cx);
+let query = use_query_map(cx);
+
+// id: || -> Option<String>
+let id = move || {
+	params.with(|params| params.get("id").cloned())
+};
+```
+
+This can get a little messy: deriving a signal that wraps an `Option<_>` or `Result<_>` can involve a couple steps. But it’s worth doing this for two reasons:
+
+1. It’s correct, i.e., it forces you to consider the cases, “What if the user doesn’t pass a value for this query field? What if they pass an invalid value?”
+2. It’s performant. Specifically, when you navigate between different paths that match the same `<Route/>` with only params or the query changing, you can get fine-grained updates to different parts of your app without rerendering. For example, navigating between different contacts in our contact-list example does a targeted update to the name field (and eventually contact info) without needing to replacing or rerender the wrapping `<Contact/>`. This is what fine-grained reactivity is for.
+
+> This is the same example from the previous section. The router is such an integrated system that it makes sense to provide a single example highlighting multiple features, even if we haven’t explain them all yet.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?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" style="max-height: 100vh"></iframe>

docs/book/src/router/19_a.md

@@ -0,0 +1,23 @@
+# The `<A/>` Component
+
+Client-side navigation works perfectly fine with ordinary HTML `<a>` elements. The router adds a listener that handles every click on a `<a>` element and tries to handle it on the client side, i.e., without doing another round trip to the server to request HTML. This is what enables the snappy “single-page app” navigations you’re probably familiar with from most modern web apps.
+
+The router will bail out of handling an `<a>` click under a number of situations
+
+- the click event has had `prevent_default()` called on it
+- the <kbd>Meta</kbd>, <kbd>Alt</kbd>, <kbd>Ctrl</kbd>, or <kbd>Shift</kbd> keys were held during click
+- the `<a>` has a `target` or `download` attribute, or `rel="external"`
+- the link has a different origin from the current location
+
+In other words, the router will only try to do a client-side navigation when it’s pretty sure it can handle it, and it will upgrade every `<a>` element to get this special behavior.
+
+The router also provides an [`<A>`](https://docs.rs/leptos_router/latest/leptos_router/fn.A.html) component, which does two additional things:
+
+1. Correctly resolves relative nested routes. Relative routing with ordinary `<a>` tags can be tricky. For example, if you have a route like `/post/:id`, `<A href="1">` will generate the correct relative route, but `<a href="1">` likely will not (depending on where it appears in your view.) `<A/>` resolves routes relative to the path of the nested route within which it appears.
+2. Sets the `aria-current` attribute to `page` if this link is the active link (i.e., it’s a link to the page you’re on). This is helpful for accessibility and for styling. For example, if you want to set the link a different color if it’s a link to the page you’re currently on, you can match this attribute with a CSS selector.
+
+> Once again, this is the same example. Check out the relative `<A/>` components, and take a look at the CSS in `index.html` to see the ARIA-based styling.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?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" style="max-height: 100vh"></iframe>

docs/book/src/router/20_form.md

@@ -0,0 +1,69 @@
+# The `<Form/>` Component
+
+Links and forms sometimes seem completely unrelated. But in fact, they work in very similar ways.
+
+In plain HTML, there are three ways to navigate to another page:
+
+1. An `<a>` element that links to another page. Navigates to the URL in its `href` attribute with the `GET` HTTP method.
+2. A `<form method="GET">`. Navigates to the URL in its `action` attribute with the `GET` HTTP method and the form data from its inputs encoded in the URL query string.
+3. A `<form method="POST">`. Navigates to the URL in its `action` attribute with the `POST` HTTP method and the form data from its inputs encoded in the body of the request.
+
+Since we have a client-side router, we can do client-side link navigations without reloading the page, i.e., without a full round-trip to the server and back. It makes sense that we can do client-side form navigations in the same way.
+
+The router provides a [`<Form>`](https://docs.rs/leptos_router/latest/leptos_router/fn.Form.html) component, which works like the HTML `<form>` element, but uses client-side navigations instead of full page reloads. `<Form/>` works with both `GET` and `POST` requests. With `method="GET"`, it will navigate to the URL encoded in the form data. With `method="POST"` it will make a `POST` request and handle the server’s response.
+
+`<Form/>` provides the basis for some components like `<ActionForm/>` and `<MultiActionForm/>` that we’ll see in later chapters. But it also enables some powerful patterns of its own.
+
+For example, imagine that you want to create a search field that updates search results in real time as the user searches, without a page reload, but that also stores the search in the URL so a user can copy and paste it to share results with someone else.
+
+It turns out that the patterns we’ve learned so far make this easy to implement.
+
+```rust
+async fn fetch_results() {
+	// some async function to fetch our search results
+}
+
+#[component]
+pub fn Search(cx: Scope) -> impl IntoView {
+#[component]
+pub fn FormExample(cx: Scope) -> impl IntoView {
+    // reactive access to URL query strings
+    let query = use_query_map(cx);
+	// search stored as ?q=
+    let search = move || query().get("q").cloned().unwrap_or_default();
+	// a resource driven by the search string
+	let search_results = create_resource(cx, search, fetch_results);
+
+	view! { cx,
+		<Form method="GET" action="">
+			<input type="search" name="search" value=search/>
+			<input type="submit"/>
+		</Form>
+		<Transition fallback=move || ()>
+			/* render search results */
+		</Transition>
+	}
+}
+```
+
+Whenever you click `Submit`, the `<Form/>` will “navigate” to `?q={search}`. But because this navigation is done on the client side, there’s no page flicker or reload. The URL query string changes, which triggers `search` to update. Because `search` is the source signal for the `search_results` resource, this triggers `search_results` to reload its resource. The `<Transition/>` continues displaying the current search results until the new ones have loaded. When they are complete, it switches to displaying the new result.
+
+This is a great pattern. The data flow is extremely clear: all data flows from the URL to the resource into the UI. The current state of the application is stored in the URL, which means you can refresh the page or text the link to a friend and it will show exactly what you’re expecting. And once we introduce server rendering, this pattern will prove to be really fault-tolerant, too: because it uses a `<form>` element and URLs under the hood, it actually works really well without even loading your WASM on the client.
+
+We can actually take it a step further and do something kind of clever:
+
+```rust
+view! { cx,
+	<Form method="GET" action="">
+		<input type="search" name="search" value=search
+			oninput="this.form.requestSubmit()"
+		/>
+	</Form>
+}
+```
+
+You’ll notice that this version drops the `Submit` button. Instead, we add an `oninput` attribute to the input. Note that this is _not_ `on:input`, which would listen for the `input` event and run some Rust code. Without the colon, `oninput` is the plain HTML attribute. So the string is actually a JavaScript string. `this.form` gives us the form the input is attached to. `requestSubmit()` fires the `submit` event on the `<form>`, which is caught by `<Form/>` just as if we had clicked a `Submit` button. Now the form will “navigate” on every keystroke or input to keep the URL (and therefore the search) perfectly in sync with the user’s input as they type.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-forked-hrrt3h?file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-forked-hrrt3h?file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/router/README.md

@@ -0,0 +1,23 @@
+# Routing
+
+## The Basics
+
+Routing drives most websites. A router is the answer to the question, “Given this URL, what should appear on the page?”
+
+A URL consists of many parts. For example, the URL `https://leptos.dev/blog/search?q=Search#results` consists of
+
+- a _scheme_: `https`
+- a _domain_: `leptos.dev`
+- a **path**: `/blog/search`
+- a **query** (or **search**): `?q=Search`
+- a _hash_: `#results`
+
+The Leptos Router works with the path and query (`/blog/search?q=Search`). Given this piece of the URL, what should the app render on the page?
+
+## The Philosophy
+
+In most cases, the path should drive what is displayed on the page. From the user’s perspective, for most applications, most major changes in the state of the app should be reflected in the URL. If you copy and paste the URL and open it in another tab, you should find yourself more or less in the same place.
+
+In this sense, the router is really at the heart of the global state management for your application. More than anything else, it drives what is displayed on the page.
+
+The router handles most of this work for you by mapping the current location to particular components.

docs/book/src/ssr/21_life_cycle.md

@@ -0,0 +1,43 @@
+# The Life of a Page Load
+
+Before we get into the weeds it might be helpful to have a higher-level overview. What exactly happens between the moment you type in the URL of a server-rendered Leptos app, and the moment you click a button and a counter increases?
+
+I’m assuming some basic knowledge of how the Internet works here, and won’t get into the weeds about HTTP or whatever. Instead, I’ll try to show how different parts of the Leptos APIs map onto each part of the process.
+
+This description also starts from the premise that your app is being compiled for two separate targets:
+
+1. A server version, often running on Actix or Axum, compiled with the Leptos `ssr` feature
+2. A browser version, compiled to WebAssembly (WASM) with the Leptos `hydrate` feature
+
+The [`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) build tool exists to coordinate the process of compiling your app for these two different targets.
+
+## On the Server
+
+- Your browser makes a `GET` request for that URL to your server. At this point, the browser knows almost nothing about the page that’s going to be rendered. (The question “How does the browser know where to ask for the page?” is an interesting one, but out of the scope of this tutorial!)
+- The server receives that request, and checks whether it has a way to handle a `GET` request at that path. This is what the `.leptos_routes()` methods in [`leptos_axum`](https://docs.rs/leptos_axum/0.2.5/leptos_axum/trait.LeptosRoutes.html) and [`leptos_actix`](https://docs.rs/leptos_actix/0.2.5/leptos_actix/trait.LeptosRoutes.html) are for. When the server starts up, these methods walk over the routing structure you provide in `<Routes/>`, generating a list of all possible routes your app can handle and telling the server’s router “for each of these routes, if you get a request... hand it off to Leptos.”
+- The server sees that this route can be handled by Leptos. So it renders your root component (often called something like `<App/>`), providing it with the URL that’s being requested and some other data like the HTTP headers and request metadata.
+- Your application runs once on the server, building up an HTML version of the component tree that will be rendered at that route. (There’s more to be said here about resources and `<Suspense/>` in the next chapter.)
+- The server returns this HTML page, also injecting information on how to load the version of your app that has been compiled to WASM so that it can run in the browser.
+
+> The HTML page that’s returned is essentially your app, “dehydrated” or “freeze-dried”: it is HTML without any of the reactivity or event listeners you’ve added. The browser will “rehydrate” this HTML page by adding the reactive system and attaching event listeners to that server-rendered HTML. Hence the two feature flags that apply to the two halves of this process: `ssr` on the server for “server-side rendering”, and `hydrate` in the browser for that process of rehydration.
+
+## In the Browser
+
+- The browser receives this HTML page from the server. It immediately goes back to the server to begin loading the JS and WASM necessary to run the interactive, client side version of the app.
+- In the meantime, it renders the HTML version.
+- When the WASM version has reloaded, it does the same route-matching process that the server did. Because the `<Routes/>` component is identical on the server and in the client, the browser version will read the URL and render the same page that was already returned by the server.
+- During this initial “hydration” phase, the WASM version of your app doesn’t re-create the DOM nodes that make up your application. Instead, it walks over the existing HTML tree, “picking up” existing elements and adding the necessary interactivity.
+
+> Note that there are some trade-offs here. Before this hydration process is complete, the page will _appear_ interactive but won’t actually respond to interactions. For example, if you have a counter button and click it before WASM has loaded, the count will not increment, because the necessary event listeners and reactivity have not been added yet. We’ll look at some ways to build in “graceful degradation” in future chapters.
+
+## Client-Side Navigation
+
+The next step is very important. Imagine that the user now clicks a link to navigate to another page in your application.
+
+The browser will _not_ make another round trip to the server, reloading the full page as it would for navigating between plain HTML pages or an application that uses server rendering (for example with PHP) but without a client-side half.
+
+Instead, the WASM version of your app will load the new page, right there in the browser, without requesting another page from the server. Essentially, your app upgrades itself from a server-loaded “multi-page app” into a browser-rendered “single-page app.” This yields the best of both worlds: a fast initial load time due to the server-rendered HTML, and fast secondary navigations because of the client-side routing.
+
+Some of what will be described in the following chapters—like the interactions between server functions, resources, and `<Suspense/>`—may seem overly complicated. You might find yourself asking, “If my page is being rendered to HTML on the server, why can’t I just `.await` this on the server? If I can just call library X in a server function, why can’t I call it in my component?” The reason is pretty simple: to enable the upgrade from server rendering to client rendering, everything in your application must be able to run either on the server or in the browser.
+
+This is not the only way to create a website or web framework, of course. But it’s the most common way, and we happen to think it’s quite a good way, to create the smoothest possible experience for your users.

docs/book/src/ssr/22_ssr_modes.md

@@ -0,0 +1,122 @@
+# Async Rendering and SSR “Modes”
+
+Server-rendering a page that uses only synchronous data is pretty simple: You just walk down the component tree, rendering each element to an HTML string. But this is a pretty big caveat: it doesn’t answer the question of what we should do with pages that includes asynchronous data, i.e., the sort of stuff that would be rendered under a `<Suspense/>` node on the client.
+
+When a page loads async data that it needs to render, what should we do? Should we wait for all the async data to load, and then render everything at once? (Let’s call this “async” rendering) Should we go all the way in the opposite direction, just sending the HTML we have immediately down to the client and letting the client load the resources and fill them in? (Let’s call this “synchronous” rendering) Or is there some middle-ground solution that somehow beats them both? (Hint: There is.)
+
+If you’ve ever listened to streaming music or watched a video online, I’m sure you realize that HTTP supports streaming, allowing a single connection to send chunks of data one after another without waiting for the full content to load. You may not realize that browsers are also really good at rendering partial HTML pages. Taken together, this means that you can actually enhance your users’ experience by **streaming HTML**: and this is something that Leptos supports out of the box, with no configuration at all. And there’s actually more than one way to stream HTML: you can stream the chunks of HTML that make up your page in order, like frames of a video, or you can stream them... well, out of order.
+
+Let me say a little more about what I mean.
+
+Leptos supports all four different of these different ways to render HTML that includes asynchronous data.
+
+## Synchronous Rendering
+
+1. **Synchronous**: Serve an HTML shell that includes `fallback` for any `<Suspense/>`. Load data on the client using `create_local_resource`, replacing `fallback` once resources are loaded.
+
+- _Pros_: App shell appears very quickly: great TTFB (time to first byte).
+- _Cons_
+  - Resources load relatively slowly; you need to wait for JS + WASM to load before even making a request.
+  - No ability to include data from async resources in the `<title>` or other `<meta>` tags, hurting SEO and things like social media link previews.
+
+If you’re using server-side rendering, the synchronous mode is almost never what you actually want, from a performance perspective. This is because it misses out on an important optimization. If you’re loading async resources during server rendering, you can actually begin loading the data on the server. Rather than waiting for the client to receive the HTML response, then loading its JS + WASM, _then_ realize it needs the resources and begin loading them, server rendering can actually begin loading the resources when the client first makes the response. In this sense, during server rendering an async resource is like a `Future` that begins loading on the server and resolves on the client. As long as the resources are actually serializable, this will always lead to a faster total load time.
+
+> This is why [`create_resource`](https://docs.rs/leptos/latest/leptos/fn.create_resource.html) requires resources data to be serializable by default, and why you need to explicitly use [`create_local_resource`](https://docs.rs/leptos/latest/leptos/fn.create_local_resource.html) for any async data that is not serializable and should therefore only be loaded in the browser itself. Creating a local resource when you could create a serializable resource is always a deoptimization.
+
+## Async Rendering
+
+<video controls>
+	<source src="https://github.com/leptos-rs/leptos/blob/main/docs/video/async.mov?raw=true" type="video/mp4">
+</video>
+
+2. **`async`**: Load all resources on the server. Wait until all data are loaded, and render HTML in one sweep.
+
+- _Pros_: Better handling for meta tags (because you know async data even before you render the `<head>`). Faster complete load than **synchronous** because async resources begin loading on server.
+- _Cons_: Slower load time/TTFB: you need to wait for all async resources to load before displaying anything on the client. The page is totally blank until everything is loaded.
+
+## In-Order Streaming
+
+<video controls>
+	<source src="https://github.com/leptos-rs/leptos/blob/main/docs/video/in-order.mov?raw=true" type="video/mp4">
+</video>
+
+3. **In-order streaming**: Walk through the component tree, rendering HTML until you hit a `<Suspense/>`. Send down all the HTML you’ve got so far as a chunk in the stream, wait for all the resources accessed under the `<Suspense/>` to load, then render it to HTML and keep walking until you hit another `<Suspense/>` or the end of the page.
+
+- _Pros_: Rather than a blank screen, shows at least _something_ before the data are ready.
+- _Cons_
+  - Loads the shell more slowly than synchronous rendering (or out-of-order streaming) because it needs to pause at every `<Suspense/>`.
+  - Unable to show fallback states for `<Suspense/>`.
+  - Can’t begin hydration until the entire page has loaded, so earlier pieces of the page will not be interactive until the suspended chunks have loaded.
+
+## Out-of-Order Streaming
+
+<video controls>
+	<source src="https://github.com/leptos-rs/leptos/blob/main/docs/video/out-of-order.mov?raw=true" type="video/mp4">
+</video>
+
+4. **Out-of-order streaming**: Like synchronous rendering, serve an HTML shell that includes `fallback` for any `<Suspense/>`. But load data on the **server**, streaming it down to the client as it resolves, and streaming down HTML for `<Suspense/>` nodes, which is swapped in to replace the fallback.
+
+- _Pros_: Combines the best of **synchronous** and **`async`**.
+  - Fast initial response/TTFB because it immediately sends the whole synchronous shell
+  - Fast total time because resources begin loading on the server.
+  - Able to show the fallback loading state and dynamically replace it, instead of showing blank sections for un-loaded data.
+- _Cons_: Requires JavaScript to be enabled for suspended fragments to appear in correct order. (This small chunk of JS streamed down in a `<script>` tag alongside the `<template>` tag that contains the rendered `<Suspense/>` fragment, so it does not need to load any additional JS files.)
+
+## Using SSR Modes
+
+Because it offers the best blend of performance characteristics, Leptos defaults to out-of-order streaming. But it’s really simple to opt into these different modes. You do it by adding an `ssr` property onto one or more of your `<Route/>` components, like in the [`ssr_modes` example](https://github.com/leptos-rs/leptos/blob/main/examples/ssr_modes/src/app.rs).
+
+```rust
+<Routes>
+	// We’ll load the home page with out-of-order streaming and <Suspense/>
+	<Route path="" view=|cx| view! { cx, <HomePage/> }/>
+
+	// We'll load the posts with async rendering, so they can set
+	// the title and metadata *after* loading the data
+	<Route
+		path="/post/:id"
+		view=|cx| view! { cx, <Post/> }
+		ssr=SsrMode::Async
+	/>
+</Routes>
+```
+
+For a path that includes multiple nested routes, the most restrictive mode will be used: i.e., if even a single nested route asks for `async` rendering, the whole initial request will be rendered `async`. `async` is the most restricted requirement, followed by in-order, and then out-of-order. (This probably makes sense if you think about it for a few minutes.)
+
+## Blocking Resources
+
+Any Leptos versions later than `0.2.5` (i.e., git main and `0.3.x` or later) introduce a new resource primitive with `create_blocking_resource`. A blocking resource still loads asynchronously like any other `async`/`.await` in Rust; it doesn’t block a server thread or anything. Instead, reading from a blocking resource under a `<Suspense/>` blocks the HTML _stream_ from returning anything, including its initial synchronous shell, until that `<Suspense/>` has resolved.
+
+Now from a performance perspective, this is not ideal. None of the synchronous shell for your page will load until that resource is ready. However, rendering nothing means that you can do things like set the `<title>` or `<meta>` tags in your `<head>` in actual HTML. This sounds a lot like `async` rendering, but there’s one big difference: if you have multiple `<Suspense/>` sections, you can block on _one_ of them but still render a placeholder and then stream in the other.
+
+For example, think about a blog post. For SEO and for social sharing, I definitely want my blog post’s title and metadata in the initial HTML `<head>`. But I really don’t care whether comments have loaded yet or not; I’d like to load those as lazily as possible.
+
+With blocking resources, I can do something like this:
+
+```rust
+#[component]
+pub fn BlogPost(cx: Scope) -> impl IntoView {
+	let post_data = create_blocking_resource(cx, /* load blog post */);
+	let comment_data = create_resource(cx, /* load blog post */);
+	view! { cx,
+		<Suspense fallback=|| ()>
+			{move || {
+				post_data.with(cx, |data| {
+					view! { cx,
+						<Title text=data.title/>
+						<Meta name="description" content=data.excerpt/>
+						<article>
+							/* render the post content */
+						</article>
+					}
+				})
+			}}
+		</Suspense>
+		<Suspense fallback=|| "Loading comments...">
+			/* render comment data here */
+		</Suspense>
+	}
+}
+```
+
+The first `<Suspense/>`, with the body of the blog post, will block my HTML stream, because it reads from a blocking resource. The second `<Suspense/>`, with the comments, will not block the stream. Blocking resources gave me exactly the power and granularity I needed to optimize my page for SEO and user experience.

docs/book/src/ssr/README.md

@@ -0,0 +1,21 @@
+# Server Side Rendering
+
+So far, everything we’ve written has been rendered almost entirely in the browser. When we create an app using Trunk, it’s served using a local development server. If you build it for production and deploy it, it’s served by whatever server or CDN you’re using. In either case, what’s served is an HTML page with
+
+1. the URL of your Leptos app, which has been compiled to WebAssembly (WASM)
+2. the URL of the JavaScript used to initialized this WASM blob
+3. an empty `<body>` element
+
+When the JS and WASM have loaded, Leptos will render your app into the `<body>`. This means that nothing appears on the screen until JS/WASM have loaded and run. This has some drawbacks:
+
+1. It increases load time, as your user’s screen is blank until additional resources have been downloaded.
+2. It’s bad for SEO, as load times are longer and the HTML you serve has no meaningful content.
+3. It’s broken for users for whom JS/WASM don’t load for some reason (e.g., they’re on a train and just went into a tunnel before WASM finished loading; they’re using an older device that doesn’t support WASM; they have JavaScript or WASM turned off for some reason; etc.)
+
+These downsides apply across the web ecosystem, but especially to WASM apps.
+
+So what do you do if you want to return more than just an empty `<body>` tag? Use “server-side rendering.”
+
+Whole books could be (and probably have been) written about this topic, but at its core, it’s really simple: rather than returning an empty `<body>` tag, return an initial HTML page that reflects the actual starting state of your app or site, so that while JS/WASM are loading, and until they load, the user can access the plain HTML version.
+
+The rest of this section will cover this topic in some detail!

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 num_remaining = 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 num_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 num_remaining = move || todos.with(Todos::num_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,152 @@
+# 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 reruns 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`, reruns,
+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!
+
+[Click to open CodeSandbox.](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)
+
+<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" style="max-height: 100vh"></iframe>

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

@@ -0,0 +1,118 @@
+# `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);
+            }
+        >
+            "Click me: "
+            {move || count()}
+        </button>
+    }
+}
+```
+
+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() % 2 == 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.
+
+[Click to open CodeSandbox.](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)
+
+<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" style="max-height: 100vh"></iframe>

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

@@ -0,0 +1,323 @@
+# 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=count
+    />
+    <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};`
+>
+> **Note**: This is still true as of `0.2.5`, but the requirement has been removed on `main`
+> and will not apply to later versions.
+
+### 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 + 'static,
+{
+    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 + 'static,`, 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 props,
+which allows you to easily pass props with different values.
+
+In this case, it’s helpful to know about the
+[`Signal`](https://docs.rs/leptos/latest/leptos/struct.Signal.html) type. `Signal`
+is an 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.
+
+[Click to open CodeSandbox.](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)
+
+<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" style="max-height: 100vh"></iframe>

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

@@ -0,0 +1,92 @@
+# 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 words, 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.
+
+[Click to open CodeSandbox.](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)
+
+<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="1000px" style="max-height: 100vh"></iframe>

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

@@ -0,0 +1,114 @@
+# 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<Input> = create_node_ref(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.)
+
+[Click to open CodeSandbox.](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)
+
+<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" style="max-height: 100vh"></iframe>

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

@@ -0,0 +1,287 @@
+# 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 rerun
+   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>
+}
+```
+
+[Click to open CodeSandbox.](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)
+
+<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" style="max-height: 100vh"></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.get()
+                                .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.
+
+[Click to open CodeSandbox.](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)
+
+<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" style="max-height: 100vh"></iframe>

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

@@ -0,0 +1,290 @@
+# 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/enum.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>
+        </header>
+        <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>
+        </header>
+        <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.
+
+[Click to open CodeSandbox.](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)
+
+<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" style="max-height: 100vh"></iframe>

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

@@ -0,0 +1,128 @@
+# 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>
+}
+```
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/9-component-children-2wrdfd?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A12%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A12%2C%22startLineNumber%22%3A19%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/9-component-children-2wrdfd?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A12%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A12%2C%22startLineNumber%22%3A19%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

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.

docs/logos/Leptos_logo_RGB.svg

@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 27.1.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 437.4294 209.6185" style="enable-background:new 0 0 437.4294 209.6185;" xml:space="preserve">
+<path style="fill:none;" d="M130.0327,79.3931c-11.4854-0.23-22.52,9.3486-24.5034,21.0117l49.1157,0.0293
+	c-2.1729-10.418-11.1821-21.0449-24.1987-21.0449C130.3081,79.3892,130.1714,79.3907,130.0327,79.3931z"/>
+<path style="fill:#181139;" d="M95.1109,128.1089H58.6797V65.6861c0-1.5234-0.8169-2.4331-2.1855-2.4331h-3.1187
+	c-1.3159,0-2.2349,1.0005-2.2349,2.4331v67.4297c0,1.4521,0.8145,2.2852,2.2349,2.2852h41.7353c1.4844,0,2.4819-0.9375,2.4819-2.333
+	v-2.7744C97.5928,128.9253,96.6651,128.1089,95.1109,128.1089z"/>
+<path style="fill:#181139;" d="M146.4561,77.1739c-4.8252-3.001-10.3037-4.5249-16.2837-4.5288c-0.0068,0-0.0137,0-0.0205,0
+	c-5.7349,0-11.1377,1.4639-16.0566,4.3511c-4.916,2.8853-8.8721,6.8364-11.7593,11.7456
+	c-2.8975,4.9248-4.3687,10.332-4.3721,16.0713c-0.0034,5.7188,1.4966,11.0654,4.4565,15.8887
+	c2.9893,4.9209,6.8789,8.7334,11.8887,11.6514c4.8657,2.8633,10.2397,4.3174,15.9717,4.3203c0.0073,0,0.0146,0,0.022,0
+	c8.123,0,14.7441-2.5869,21.4683-8.3906c0.5493-0.4805,0.8516-1.1201,0.8516-1.8008c0.001-0.6074-0.1743-1.1035-0.5205-1.4756
+	l-1.3569-1.8428l-0.0732-0.0859c-0.2637-0.2637-0.6929-0.6152-1.3716-0.6152c-0.6421,0-1.2549,0.2217-1.7124,0.6143
+	c-1.9346,1.585-3.5459,2.8008-4.7969,3.6182c-1.7979,1.208-5.8218,3.2314-12.5986,3.2314c-0.0073,0-0.0142,0-0.021,0
+	c-0.1357,0.0029-0.269,0.0039-0.4043,0.0039c-12.2642,0-23.4736-10.3262-24.5088-22.4814l53.0127,0.0322c0.0015,0,0.0024,0,0.0034,0
+	c2.2373,0,3.4697-1.1621,3.4712-3.2715c0.0034-5.2588-1.3574-10.3945-4.0464-15.2705
+	C155.0015,84.0953,151.2188,80.1363,146.4561,77.1739z M154.6451,100.4341l-49.1157-0.0293
+	c1.9834-11.6631,13.0181-21.2417,24.5034-21.0117c0.1387-0.0024,0.2754-0.0039,0.4136-0.0039
+	C143.4629,79.3892,152.4722,90.0162,154.6451,100.4341z"/>
+<path style="fill:#181139;" d="M204.0386,136.6382c5.7319,0,11.1069-1.4502,15.9746-4.3115
+	c4.938-2.9014,8.75-6.7129,11.6533-11.6533c2.8608-4.8672,4.311-10.2578,4.311-16.0244c0-5.7324-1.4502-11.1064-4.311-15.9746
+	c-2.9019-4.9385-6.7134-8.75-11.6533-11.6533c-4.8687-2.8618-10.2437-4.3125-15.9746-4.3125
+	c-9.938,0-19.2021,4.7583-24.3516,12.3174v-9.438c0-0.5946-0.1465-1.0788-0.411-1.4511c-0.3815-0.5369-1.0157-0.834-1.8727-0.834
+	h-2.6738c-1.4521,0-2.2852,0.833-2.2852,2.2852v5.6964v46.4791v23.9676c0,1.2568,0.7808,2.0371,2.0371,2.0371h3.3667
+	c0.9209,0,1.6421-0.6992,1.6421-1.5908v-17.098v-10.984C185.0884,131.8892,194.2749,136.6382,204.0386,136.6382z M186.6358,122.5591
+	c-4.9346-4.9346-7.6831-11.4932-7.542-18.0254c-0.1367-6.3506,2.5439-12.751,7.3545-17.5605
+	c4.8521-4.8521,11.3037-7.5547,17.7383-7.417c4.3691,0,8.4863,1.1465,12.2314,3.4043c3.7344,2.2979,6.7456,5.4053,8.9492,9.2354
+	c2.1699,3.9072,3.2695,8.0967,3.2695,12.4697c0.1396,6.4619-2.5967,12.9844-7.5083,17.8955
+	c-4.7617,4.7617-11.0469,7.3857-17.2544,7.2803C197.6856,129.9712,191.396,127.3208,186.6358,122.5591z"/>
+<path style="fill:#181139;" d="M241.8955,80.3975h7.5669v42.0259c0,6.8174,4.5674,12.1309,11.0825,12.9189
+	c0.6836,0.1055,1.8379,0.1572,3.5303,0.1572c2.0078,0,3.0273-0.3535,3.0273-2.2842v-2.377c0-1.7891-1.334-2.0371-2.7568-2.0371
+	c0,0-0.001,0-0.002,0l-1.7871-0.0488c-2.0117-0.0439-3.4883-0.7627-4.3896-2.1367c-0.9697-1.4805-1.4619-3.1738-1.4619-5.0352
+	V80.3975h10.0928c1.3076,0,2.2852-1.3628,2.2852-2.5815v-1.9312c0-1.3999-0.8359-2.2354-2.2354-2.2354h-10.1426V60.6861
+	c0-1.4619-0.7969-2.4829-1.9375-2.4829c-0.1865,0-0.4121,0-0.6392,0.0884l-2.6489,0.6865
+	c-1.2109,0.3682-2.0171,0.9263-2.0171,2.4507v12.2207h-7.5669c-1.4185,0-2.335,0.897-2.335,2.2852v1.8813
+	C239.5606,79.2393,240.6079,80.3975,241.8955,80.3975z"/>
+<path style="fill:#181139;" d="M379.1182,106.2691c-4.0488-2.9219-8.8545-5.0293-14.291-6.2646
+	c-6.5049-1.3975-13.4473-5.2129-13.3203-10.3066c0-7.5225,6.6367-10.1914,12.3203-10.1914c5.3574,0,10.2207,3.002,13.001,8.0146
+	c0.6729,1.2861,1.4785,1.9375,2.3955,1.9375c0.3311,0,0.7061-0.1113,0.9922-0.2832l2.2021-1.1523
+	c0.5947-0.3408,0.9229-0.9414,0.9229-1.6924c0-0.5205-0.0908-0.9541-0.2617-1.292c-3.6367-8.2466-10.0967-12.4282-19.2021-12.4282
+	c-11.7305,0-19.6123,6.9263-19.6123,17.2349c0,4.3125,1.8438,7.9746,5.4756,10.8809c3.4482,2.7979,7.9121,4.8623,13.2705,6.1377
+	c4.5859,1.085,8.3193,2.5654,11.0977,4.4023c1.4159,0.9354,2.4412,2.0535,3.106,3.3672c0.6053,1.1962,0.9135,2.5535,0.9135,4.1005
+	c0.0742,2.3857-0.79,4.5176-2.5684,6.3389c-3.1445,3.2178-8.4053,4.6689-12.0205,4.6689c-0.0361,0-0.0723,0-0.1074,0
+	c-3.4268,0-6.4893-0.8438-9.1035-2.5068c-2.5918-1.6484-4.2363-3.8076-5.0293-6.6064c-0.3203-1.0996-0.751-2.1738-2.1553-2.1738
+	c-0.0742,0-0.2109,0.0146-0.4062,0.0449c-0.1133,0.0166-0.2559,0.0381-0.5088,0.0742l-1.8818,0.4463l-0.1045,0.0332
+	c-1.0244,0.4082-1.6113,1.1846-1.6113,2.1309c0,0.2285,0.0625,0.6592,0.2178,1.1094c1.9707,8.5801,10.2432,14.3447,20.5732,14.3447
+	c0.125,0.002,0.249,0.002,0.374,0.002c6.5947,0,12.6748-2.3193,16.7275-6.3945c3.1895-3.208,4.8311-7.2363,4.748-11.6357
+	c0-2.8187-0.6185-5.3109-1.8062-7.481C382.4437,109.2624,381.0062,107.631,379.1182,106.2691z"/>
+<path style="fill:#EF3939;" d="M348.9043,45.7325c0-6.3157-3.2826-11.8699-8.2238-15.0756
+	c-2.811-1.8237-6.1537-2.8947-9.7469-2.8947c-9.9092,0-17.9707,8.0615-17.9707,17.9702c0,4.7659,1.8775,9.0925,4.9157,12.3123
+	c-3.6619,4.3709-6.6334,9.3336-8.7663,14.7186c-1.5873-0.2422-3.2123-0.3683-4.8662-0.3683
+	c-17.7158,0-32.1289,14.4131-32.1289,32.1289c0,14.6854,9.9077,27.0922,23.3869,30.9101
+	c-6.7762,17.3461-23.6572,29.6719-43.3742,29.6719c-16.8195,0-31.583-8.9662-39.7656-22.369
+	c-2.4778,0.5446-5.0429,0.8519-7.6721,0.9023c9.0226,16.99,26.8969,28.5917,47.4377,28.5917
+	c23.2646,0,43.1121-14.8788,50.5461-35.6179c0.5204,0.0251,1.0435,0.0398,1.5701,0.0398c17.7158,0,32.1289-14.4131,32.1289-32.1289
+	c0-13.557-8.4446-25.1712-20.3465-29.8811c1.9001-4.5678,4.5115-8.7646,7.6888-12.4641c0.9996,0.4404,2.0479,0.785,3.1324,1.0384
+	c1.3144,0.3071,2.6773,0.486,4.0839,0.486C340.8428,63.7032,348.9043,55.6416,348.9043,45.7325z M304.2461,129.5279
+	c-13.7871,0-25.0039-11.2168-25.0039-25.0039s11.2168-25.0039,25.0039-25.0039S329.25,90.7369,329.25,104.524
+	S318.0332,129.5279,304.2461,129.5279z M330.9336,34.8872c0.645,0,1.2737,0.0671,1.8881,0.1755
+	c5.0818,0.8974,8.9576,5.3347,8.9576,10.6697c0,5.9805-4.8652,10.8457-10.8457,10.8457s-10.8457-4.8652-10.8457-10.8457
+	c0-1.3967,0.2746-2.7282,0.7576-3.9555C322.4306,37.7496,326.35,34.8872,330.9336,34.8872z"/>
+</svg>

docs/logos/Leptos_logo_Solid_Black.svg

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 27.1.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 437.4294 209.6185" style="enable-background:new 0 0 437.4294 209.6185;" xml:space="preserve">
+<path d="M95.1109,128.1089H58.6797V65.6861c0-1.5234-0.8169-2.4331-2.1855-2.4331h-3.1187c-1.3159,0-2.2349,1.0005-2.2349,2.4331
+	v67.4297c0,1.4521,0.8145,2.2852,2.2349,2.2852h41.7353c1.4844,0,2.4819-0.9375,2.4819-2.333v-2.7744
+	C97.5928,128.9253,96.6651,128.1089,95.1109,128.1089z"/>
+<path d="M146.4561,77.1739c-4.8252-3.001-10.3037-4.5249-16.2837-4.5288c-0.0068,0-0.0137,0-0.0205,0
+	c-5.7349,0-11.1377,1.4639-16.0566,4.3511c-4.916,2.8853-8.8721,6.8364-11.7593,11.7456
+	c-2.8975,4.9248-4.3687,10.332-4.3721,16.0713c-0.0034,5.7188,1.4966,11.0654,4.4565,15.8887
+	c2.9893,4.9209,6.8789,8.7334,11.8887,11.6514c4.8657,2.8633,10.2397,4.3174,15.9717,4.3203c0.0073,0,0.0146,0,0.022,0
+	c8.123,0,14.7441-2.5869,21.4683-8.3906c0.5493-0.4805,0.8516-1.1201,0.8516-1.8008c0.001-0.6074-0.1743-1.1035-0.5205-1.4756
+	l-1.3569-1.8428l-0.0732-0.0859c-0.2637-0.2637-0.6929-0.6152-1.3716-0.6152c-0.6421,0-1.2549,0.2217-1.7124,0.6143
+	c-1.9346,1.585-3.5459,2.8008-4.7969,3.6182c-1.7979,1.208-5.8218,3.2314-12.5986,3.2314c-0.0073,0-0.0142,0-0.021,0
+	c-0.1357,0.0029-0.269,0.0039-0.4043,0.0039c-12.2642,0-23.4736-10.3262-24.5088-22.4814l53.0127,0.0322c0.0015,0,0.0024,0,0.0034,0
+	c2.2373,0,3.4697-1.1621,3.4712-3.2715c0.0034-5.2588-1.3574-10.3945-4.0464-15.2705
+	C155.0015,84.0953,151.2188,80.1363,146.4561,77.1739z M154.6451,100.4341l-49.1157-0.0293
+	c1.9834-11.6631,13.0181-21.2417,24.5034-21.0117c0.1387-0.0024,0.2754-0.0039,0.4136-0.0039
+	C143.4629,79.3892,152.4722,90.0162,154.6451,100.4341z"/>
+<path d="M204.0386,136.6382c5.7319,0,11.1069-1.4502,15.9746-4.3115c4.938-2.9014,8.75-6.7129,11.6533-11.6533
+	c2.8608-4.8672,4.311-10.2578,4.311-16.0244c0-5.7324-1.4502-11.1064-4.311-15.9746c-2.9019-4.9385-6.7134-8.75-11.6533-11.6533
+	c-4.8687-2.8618-10.2437-4.3125-15.9746-4.3125c-9.938,0-19.2021,4.7583-24.3516,12.3174v-9.438
+	c0-0.5946-0.1465-1.0788-0.411-1.4511c-0.3815-0.5369-1.0157-0.834-1.8727-0.834h-2.6738c-1.4521,0-2.2852,0.833-2.2852,2.2852
+	v5.6964v46.4791v23.9676c0,1.2568,0.7808,2.0371,2.0371,2.0371h3.3667c0.9209,0,1.6421-0.6992,1.6421-1.5908v-17.098v-10.984
+	C185.0884,131.8892,194.2749,136.6382,204.0386,136.6382z M186.6358,122.5591c-4.9346-4.9346-7.6831-11.4932-7.542-18.0254
+	c-0.1367-6.3506,2.5439-12.751,7.3545-17.5605c4.8521-4.8521,11.3037-7.5547,17.7383-7.417c4.3691,0,8.4863,1.1465,12.2314,3.4043
+	c3.7344,2.2979,6.7456,5.4053,8.9492,9.2354c2.1699,3.9072,3.2695,8.0967,3.2695,12.4697
+	c0.1396,6.4619-2.5967,12.9844-7.5083,17.8955c-4.7617,4.7617-11.0469,7.3857-17.2544,7.2803
+	C197.6856,129.9712,191.396,127.3208,186.6358,122.5591z"/>
+<path d="M241.8955,80.3975h7.5669v42.0259c0,6.8174,4.5674,12.1309,11.0825,12.9189c0.6836,0.1055,1.8379,0.1572,3.5303,0.1572
+	c2.0078,0,3.0273-0.3535,3.0273-2.2842v-2.377c0-1.7891-1.334-2.0371-2.7568-2.0371c0,0-0.001,0-0.002,0l-1.7871-0.0488
+	c-2.0117-0.0439-3.4883-0.7627-4.3896-2.1367c-0.9697-1.4805-1.4619-3.1738-1.4619-5.0352V80.3975h10.0928
+	c1.3076,0,2.2852-1.3628,2.2852-2.5815v-1.9312c0-1.3999-0.8359-2.2354-2.2354-2.2354h-10.1426V60.6861
+	c0-1.4619-0.7969-2.4829-1.9375-2.4829c-0.1865,0-0.4121,0-0.6392,0.0884l-2.6489,0.6865
+	c-1.2109,0.3682-2.0171,0.9263-2.0171,2.4507v12.2207h-7.5669c-1.4185,0-2.335,0.897-2.335,2.2852v1.8813
+	C239.5606,79.2393,240.6079,80.3975,241.8955,80.3975z"/>
+<path d="M379.1182,106.2691c-4.0488-2.9219-8.8545-5.0293-14.291-6.2646c-6.5049-1.3975-13.4473-5.2129-13.3203-10.3066
+	c0-7.5225,6.6367-10.1914,12.3203-10.1914c5.3574,0,10.2207,3.002,13.001,8.0146c0.6729,1.2861,1.4785,1.9375,2.3955,1.9375
+	c0.3311,0,0.7061-0.1113,0.9922-0.2832l2.2021-1.1523c0.5947-0.3408,0.9229-0.9414,0.9229-1.6924
+	c0-0.5205-0.0908-0.9541-0.2617-1.292c-3.6367-8.2466-10.0967-12.4282-19.2021-12.4282c-11.7305,0-19.6123,6.9263-19.6123,17.2349
+	c0,4.3125,1.8438,7.9746,5.4756,10.8809c3.4482,2.7979,7.9121,4.8623,13.2705,6.1377c4.5859,1.085,8.3193,2.5654,11.0977,4.4023
+	c1.4159,0.9354,2.4412,2.0535,3.106,3.3672c0.6053,1.1962,0.9135,2.5535,0.9135,4.1005c0.0742,2.3857-0.79,4.5176-2.5684,6.3389
+	c-3.1445,3.2178-8.4053,4.6689-12.0205,4.6689c-0.0361,0-0.0723,0-0.1074,0c-3.4268,0-6.4893-0.8438-9.1035-2.5068
+	c-2.5918-1.6484-4.2363-3.8076-5.0293-6.6064c-0.3203-1.0996-0.751-2.1738-2.1553-2.1738c-0.0742,0-0.2109,0.0146-0.4062,0.0449
+	c-0.1133,0.0166-0.2559,0.0381-0.5088,0.0742l-1.8818,0.4463l-0.1045,0.0332c-1.0244,0.4082-1.6113,1.1846-1.6113,2.1309
+	c0,0.2285,0.0625,0.6592,0.2178,1.1094c1.9707,8.5801,10.2432,14.3447,20.5732,14.3447c0.125,0.002,0.249,0.002,0.374,0.002
+	c6.5947,0,12.6748-2.3193,16.7275-6.3945c3.1895-3.208,4.8311-7.2363,4.748-11.6357c0-2.8187-0.6185-5.3109-1.8062-7.481
+	C382.4437,109.2624,381.0062,107.631,379.1182,106.2691z"/>
+<path d="M348.9043,45.7325c0-6.3157-3.2826-11.8699-8.2238-15.0756c-2.811-1.8237-6.1537-2.8947-9.7469-2.8947
+	c-9.9092,0-17.9707,8.0615-17.9707,17.9702c0,4.7659,1.8775,9.0925,4.9157,12.3123c-3.6619,4.3709-6.6334,9.3336-8.7663,14.7186
+	c-1.5873-0.2422-3.2123-0.3683-4.8662-0.3683c-17.7158,0-32.1289,14.4131-32.1289,32.1289c0,14.6854,9.9077,27.0922,23.3869,30.9101
+	c-6.7762,17.3461-23.6572,29.6719-43.3742,29.6719c-16.8195,0-31.583-8.9662-39.7656-22.369
+	c-2.4778,0.5446-5.0429,0.8519-7.6721,0.9023c9.0226,16.99,26.8969,28.5917,47.4377,28.5917
+	c23.2646,0,43.1121-14.8788,50.5461-35.6179c0.5204,0.0251,1.0435,0.0398,1.5701,0.0398c17.7158,0,32.1289-14.4131,32.1289-32.1289
+	c0-13.557-8.4446-25.1712-20.3465-29.8811c1.9001-4.5678,4.5115-8.7646,7.6888-12.4641c0.9996,0.4404,2.0479,0.785,3.1324,1.0384
+	c1.3144,0.3071,2.6773,0.486,4.0839,0.486C340.8428,63.7032,348.9043,55.6416,348.9043,45.7325z M304.2461,129.5279
+	c-13.7871,0-25.0039-11.2168-25.0039-25.0039s11.2168-25.0039,25.0039-25.0039S329.25,90.7369,329.25,104.524
+	S318.0332,129.5279,304.2461,129.5279z M330.9336,34.8872c0.645,0,1.2737,0.0671,1.8881,0.1755
+	c5.0818,0.8974,8.9576,5.3347,8.9576,10.6697c0,5.9805-4.8652,10.8457-10.8457,10.8457s-10.8457-4.8652-10.8457-10.8457
+	c0-1.3967,0.2746-2.7282,0.7576-3.9555C322.4306,37.7496,326.35,34.8872,330.9336,34.8872z"/>
+</svg>

docs/logos/Leptos_logo_Solid_White.svg

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 27.1.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 437.4294 209.6185" style="enable-background:new 0 0 437.4294 209.6185;" xml:space="preserve">
+<path style="fill:#FFFFFF;" d="M95.1109,128.1089H58.6797V65.6861c0-1.5234-0.8169-2.4331-2.1855-2.4331h-3.1187
+	c-1.3159,0-2.2349,1.0005-2.2349,2.4331v67.4297c0,1.4521,0.8145,2.2852,2.2349,2.2852h41.7353c1.4844,0,2.4819-0.9375,2.4819-2.333
+	v-2.7744C97.5928,128.9253,96.6651,128.1089,95.1109,128.1089z"/>
+<path style="fill:#FFFFFF;" d="M146.4561,77.1739c-4.8252-3.001-10.3037-4.5249-16.2837-4.5288c-0.0068,0-0.0137,0-0.0205,0
+	c-5.7349,0-11.1377,1.4639-16.0566,4.3511c-4.916,2.8853-8.8721,6.8364-11.7593,11.7456
+	c-2.8975,4.9248-4.3687,10.332-4.3721,16.0713c-0.0034,5.7188,1.4966,11.0654,4.4565,15.8887
+	c2.9893,4.9209,6.8789,8.7334,11.8887,11.6514c4.8657,2.8633,10.2397,4.3174,15.9717,4.3203c0.0073,0,0.0146,0,0.022,0
+	c8.123,0,14.7441-2.5869,21.4683-8.3906c0.5493-0.4805,0.8516-1.1201,0.8516-1.8008c0.001-0.6074-0.1743-1.1035-0.5205-1.4756
+	l-1.3569-1.8428l-0.0732-0.0859c-0.2637-0.2637-0.6929-0.6152-1.3716-0.6152c-0.6421,0-1.2549,0.2217-1.7124,0.6143
+	c-1.9346,1.585-3.5459,2.8008-4.7969,3.6182c-1.7979,1.208-5.8218,3.2314-12.5986,3.2314c-0.0073,0-0.0142,0-0.021,0
+	c-0.1357,0.0029-0.269,0.0039-0.4043,0.0039c-12.2642,0-23.4736-10.3262-24.5088-22.4814l53.0127,0.0322c0.0015,0,0.0024,0,0.0034,0
+	c2.2373,0,3.4697-1.1621,3.4712-3.2715c0.0034-5.2588-1.3574-10.3945-4.0464-15.2705
+	C155.0015,84.0953,151.2188,80.1363,146.4561,77.1739z M154.6451,100.4341l-49.1157-0.0293
+	c1.9834-11.6631,13.0181-21.2417,24.5034-21.0117c0.1387-0.0024,0.2754-0.0039,0.4136-0.0039
+	C143.4629,79.3892,152.4722,90.0162,154.6451,100.4341z"/>
+<path style="fill:#FFFFFF;" d="M204.0386,136.6382c5.7319,0,11.1069-1.4502,15.9746-4.3115
+	c4.938-2.9014,8.75-6.7129,11.6533-11.6533c2.8608-4.8672,4.311-10.2578,4.311-16.0244c0-5.7324-1.4502-11.1064-4.311-15.9746
+	c-2.9019-4.9385-6.7134-8.75-11.6533-11.6533c-4.8687-2.8618-10.2437-4.3125-15.9746-4.3125
+	c-9.938,0-19.2021,4.7583-24.3516,12.3174v-9.438c0-0.5946-0.1465-1.0788-0.411-1.4511c-0.3815-0.5369-1.0157-0.834-1.8727-0.834
+	h-2.6738c-1.4521,0-2.2852,0.833-2.2852,2.2852v5.6964v46.4791v23.9676c0,1.2568,0.7808,2.0371,2.0371,2.0371h3.3667
+	c0.9209,0,1.6421-0.6992,1.6421-1.5908v-17.098v-10.984C185.0884,131.8892,194.2749,136.6382,204.0386,136.6382z M186.6358,122.5591
+	c-4.9346-4.9346-7.6831-11.4932-7.542-18.0254c-0.1367-6.3506,2.5439-12.751,7.3545-17.5605
+	c4.8521-4.8521,11.3037-7.5547,17.7383-7.417c4.3691,0,8.4863,1.1465,12.2314,3.4043c3.7344,2.2979,6.7456,5.4053,8.9492,9.2354
+	c2.1699,3.9072,3.2695,8.0967,3.2695,12.4697c0.1396,6.4619-2.5967,12.9844-7.5083,17.8955
+	c-4.7617,4.7617-11.0469,7.3857-17.2544,7.2803C197.6856,129.9712,191.396,127.3208,186.6358,122.5591z"/>
+<path style="fill:#FFFFFF;" d="M241.8955,80.3975h7.5669v42.0259c0,6.8174,4.5674,12.1309,11.0825,12.9189
+	c0.6836,0.1055,1.8379,0.1572,3.5303,0.1572c2.0078,0,3.0273-0.3535,3.0273-2.2842v-2.377c0-1.7891-1.334-2.0371-2.7568-2.0371
+	c0,0-0.001,0-0.002,0l-1.7871-0.0488c-2.0117-0.0439-3.4883-0.7627-4.3896-2.1367c-0.9697-1.4805-1.4619-3.1738-1.4619-5.0352
+	V80.3975h10.0928c1.3076,0,2.2852-1.3628,2.2852-2.5815v-1.9312c0-1.3999-0.8359-2.2354-2.2354-2.2354h-10.1426V60.6861
+	c0-1.4619-0.7969-2.4829-1.9375-2.4829c-0.1865,0-0.4121,0-0.6392,0.0884l-2.6489,0.6865
+	c-1.2109,0.3682-2.0171,0.9263-2.0171,2.4507v12.2207h-7.5669c-1.4185,0-2.335,0.897-2.335,2.2852v1.8813
+	C239.5606,79.2393,240.6079,80.3975,241.8955,80.3975z"/>
+<path style="fill:#FFFFFF;" d="M379.1182,106.2691c-4.0488-2.9219-8.8545-5.0293-14.291-6.2646
+	c-6.5049-1.3975-13.4473-5.2129-13.3203-10.3066c0-7.5225,6.6367-10.1914,12.3203-10.1914c5.3574,0,10.2207,3.002,13.001,8.0146
+	c0.6729,1.2861,1.4785,1.9375,2.3955,1.9375c0.3311,0,0.7061-0.1113,0.9922-0.2832l2.2021-1.1523
+	c0.5947-0.3408,0.9229-0.9414,0.9229-1.6924c0-0.5205-0.0908-0.9541-0.2617-1.292c-3.6367-8.2466-10.0967-12.4282-19.2021-12.4282
+	c-11.7305,0-19.6123,6.9263-19.6123,17.2349c0,4.3125,1.8438,7.9746,5.4756,10.8809c3.4482,2.7979,7.9121,4.8623,13.2705,6.1377
+	c4.5859,1.085,8.3193,2.5654,11.0977,4.4023c1.4159,0.9354,2.4412,2.0535,3.106,3.3672c0.6053,1.1962,0.9135,2.5535,0.9135,4.1005
+	c0.0742,2.3857-0.79,4.5176-2.5684,6.3389c-3.1445,3.2178-8.4053,4.6689-12.0205,4.6689c-0.0361,0-0.0723,0-0.1074,0
+	c-3.4268,0-6.4893-0.8438-9.1035-2.5068c-2.5918-1.6484-4.2363-3.8076-5.0293-6.6064c-0.3203-1.0996-0.751-2.1738-2.1553-2.1738
+	c-0.0742,0-0.2109,0.0146-0.4062,0.0449c-0.1133,0.0166-0.2559,0.0381-0.5088,0.0742l-1.8818,0.4463l-0.1045,0.0332
+	c-1.0244,0.4082-1.6113,1.1846-1.6113,2.1309c0,0.2285,0.0625,0.6592,0.2178,1.1094c1.9707,8.5801,10.2432,14.3447,20.5732,14.3447
+	c0.125,0.002,0.249,0.002,0.374,0.002c6.5947,0,12.6748-2.3193,16.7275-6.3945c3.1895-3.208,4.8311-7.2363,4.748-11.6357
+	c0-2.8187-0.6185-5.3109-1.8062-7.481C382.4437,109.2624,381.0062,107.631,379.1182,106.2691z"/>
+<path style="fill:#FFFFFF;" d="M348.9043,45.7325c0-6.3157-3.2826-11.8699-8.2238-15.0756
+	c-2.811-1.8237-6.1537-2.8947-9.7469-2.8947c-9.9092,0-17.9707,8.0615-17.9707,17.9702c0,4.7659,1.8775,9.0925,4.9157,12.3123
+	c-3.6619,4.3709-6.6334,9.3336-8.7663,14.7186c-1.5873-0.2422-3.2123-0.3683-4.8662-0.3683
+	c-17.7158,0-32.1289,14.4131-32.1289,32.1289c0,14.6854,9.9077,27.0922,23.3869,30.9101
+	c-6.7762,17.3461-23.6572,29.6719-43.3742,29.6719c-16.8195,0-31.583-8.9662-39.7656-22.369
+	c-2.4778,0.5446-5.0429,0.8519-7.6721,0.9023c9.0226,16.99,26.8969,28.5917,47.4377,28.5917
+	c23.2646,0,43.1121-14.8788,50.5461-35.6179c0.5204,0.0251,1.0435,0.0398,1.5701,0.0398c17.7158,0,32.1289-14.4131,32.1289-32.1289
+	c0-13.557-8.4446-25.1712-20.3465-29.8811c1.9001-4.5678,4.5115-8.7646,7.6888-12.4641c0.9996,0.4404,2.0479,0.785,3.1324,1.0384
+	c1.3144,0.3071,2.6773,0.486,4.0839,0.486C340.8428,63.7032,348.9043,55.6416,348.9043,45.7325z M304.2461,129.5279
+	c-13.7871,0-25.0039-11.2168-25.0039-25.0039s11.2168-25.0039,25.0039-25.0039S329.25,90.7369,329.25,104.524
+	S318.0332,129.5279,304.2461,129.5279z M330.9336,34.8872c0.645,0,1.2737,0.0671,1.8881,0.1755
+	c5.0818,0.8974,8.9576,5.3347,8.9576,10.6697c0,5.9805-4.8652,10.8457-10.8457,10.8457s-10.8457-4.8652-10.8457-10.8457
+	c0-1.3967,0.2746-2.7282,0.7576-3.9555C322.4306,37.7496,326.35,34.8872,330.9336,34.8872z"/>
+</svg>

docs/logos/Leptos_logo_abbreviation__circle_RGB.svg

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 27.1.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 115.9988 115.9988" style="enable-background:new 0 0 115.9988 115.9988;" xml:space="preserve">
+<g>
+	<g>
+		<g>
+			<path style="fill:#180D38;" d="M29.1281,108.2941c9.5736-4.5548,17.1531-12.6456,21.0335-22.5787
+				c-12.0865-3.4232-20.9707-14.548-20.9707-27.7159c0-15.8849,12.9236-28.8085,28.8085-28.8085
+				c1.4832,0,2.9404,0.113,4.3639,0.3303c1.9125-4.8287,4.5771-9.2786,7.8607-13.1979c-2.7243-2.8871-4.4077-6.7665-4.4077-11.0399
+				c0-1.6191,0.2457-3.1808,0.6921-4.6562C63.7305,0.2186,60.8908,0,57.9995,0C25.9672,0,0,25.9672,0,57.9994
+				C0,79.5165,11.7263,98.2828,29.1281,108.2941z"/>
+			<path style="fill:#EF3939;" d="M81.9297,15.0082c3.6788,0,6.886-2.0536,8.5379-5.0742
+				c-5.3185-3.5997-11.2684-6.3339-17.646-8.0151c-0.3903,1.0504-0.6168,2.1798-0.6168,3.3644
+				C72.2049,10.6458,76.5673,15.0082,81.9297,15.0082z"/>
+			<path style="fill:#180D38;" d="M95.5663,13.828c-2.8537,4.5375-7.8918,7.5688-13.6366,7.5688
+				c-1.2614,0-2.4835-0.1604-3.6622-0.4359c-0.9722-0.2272-1.9121-0.5362-2.8083-0.931c-2.8492,3.3173-5.1907,7.0806-6.8945,11.1766
+				c10.6715,4.2233,18.2432,14.6371,18.2432,26.7928c0,15.8849-12.9235,28.8085-28.8085,28.8085
+				c-0.4718,0-0.9406-0.0131-1.4069-0.0357c-3.7532,10.4704-11.0354,19.2744-20.406,24.9696
+				c6.7355,2.7367,14.0948,4.257,21.8129,4.257c32.0322,0,57.9994-25.9672,57.9994-57.9995
+				C115.9988,40.3018,108.0628,24.4664,95.5663,13.828z"/>
+			<circle style="fill:#EF3939;" cx="57.9994" cy="57.9994" r="22.4198"/>
+		</g>
+		<path style="fill:#FFFFFF;" d="M78.2676,20.961c1.1786,0.2755,2.4008,0.4359,3.6622,0.4359
+			c5.7448,0,10.7829-3.0313,13.6366-7.5688c-1.6275-1.3855-3.3236-2.6925-5.0987-3.894c-1.6519,3.0206-4.8591,5.0742-8.5379,5.0742
+			c-5.3624,0-9.7249-4.3624-9.7249-9.7249c0-1.1846,0.2264-2.3141,0.6168-3.3644c-2.062-0.5436-4.1682-0.9763-6.3133-1.2917
+			c-0.4464,1.4753-0.6921,3.0371-0.6921,4.6562c0,4.2734,1.6834,8.1528,4.4077,11.0399c-3.2836,3.9193-5.9482,8.3692-7.8607,13.1979
+			c-1.4235-0.2172-2.8807-0.3303-4.3639-0.3303c-15.8849,0-28.8085,12.9235-28.8085,28.8085
+			c0,13.168,8.8842,24.2928,20.9707,27.7159c-3.8804,9.9332-11.4599,18.0239-21.0335,22.5787
+			c2.2621,1.3013,4.6175,2.456,7.0584,3.4478c9.3706-5.6952,16.6528-14.4992,20.406-24.9696
+			c0.4663,0.0226,0.9351,0.0357,1.4069,0.0357c15.8849,0,28.8085-12.9236,28.8085-28.8085c0-12.1557-7.5717-22.5695-18.2432-26.7928
+			c1.7038-4.0959,4.0453-7.8593,6.8945-11.1766C76.3555,20.4248,77.2953,20.7338,78.2676,20.961z M80.4193,57.9994
+			c0,12.3623-10.0576,22.4199-22.4198,22.4199c-12.3623,0-22.4199-10.0576-22.4199-22.4199
+			c0-12.3622,10.0576-22.4199,22.4199-22.4199C70.3617,35.5795,80.4193,45.6371,80.4193,57.9994z"/>
+	</g>
+</g>
+</svg>

docs/logos/Leptos_logo_abbreviation__square_RGB.svg

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 27.1.1, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 115.5026 115.5026" style="enable-background:new 0 0 115.5026 115.5026;" xml:space="preserve">
+<path style="fill:#181139;" d="M115.5026,0h-13.957c0.0002,0.0315,0.0031,0.0623,0.0031,0.0938
+	c0,9.718-7.9059,17.6239-17.6239,17.6239c-1.3796,0-2.7163-0.1754-4.0055-0.4767c-1.0634-0.2485-2.0913-0.5864-3.0715-1.0182
+	c-3.1162,3.6283-5.6772,7.7443-7.5408,12.2242c11.6719,4.6192,19.9532,16.0091,19.9532,29.3043
+	c0,17.374-14.1349,31.5089-31.5089,31.5089c-0.5161,0-1.0288-0.0143-1.5388-0.039c-3.8856,10.8397-11.2302,20.0454-20.6959,26.2814
+	h79.986V0z"/>
+<circle style="fill:#EF3939;" cx="57.7513" cy="57.7513" r="24.5214"/>
+<path style="fill:#181139;" d="M49.1788,88.0652c-13.2195-3.744-22.9364-15.9116-22.9364-30.3139
+	c0-17.374,14.1349-31.5089,31.5089-31.5089c1.6223,0,3.2161,0.1237,4.7729,0.3612c2.0918-5.2813,5.0061-10.1484,8.5975-14.4351
+	c-2.9796-3.1577-4.8209-7.4008-4.8209-12.0747c0-0.0317,0.0046-0.0622,0.0048-0.0938H0v115.5026h18.8623
+	C32.7495,111.6378,43.9877,101.3537,49.1788,88.0652z"/>
+<path style="fill:#EF3939;" d="M83.9248,10.7302c5.8651,0,10.6364-4.7714,10.6364-10.6364c0-0.0316-0.004-0.0623-0.0043-0.0938
+	H73.293c-0.0003,0.0316-0.0046,0.0621-0.0046,0.0938C73.2884,5.9589,78.0598,10.7302,83.9248,10.7302z"/>
+<path style="fill:#FFFFFF;" d="M56.2125,89.2212c0.51,0.0247,1.0228,0.039,1.5388,0.039c17.374,0,31.5089-14.1349,31.5089-31.5089
+	c0-13.2952-8.2814-24.6851-19.9532-29.3043c1.8635-4.4799,4.4246-8.5959,7.5408-12.2242c0.9802,0.4318,2.0082,0.7698,3.0715,1.0182
+	c1.2892,0.3013,2.6259,0.4767,4.0055,0.4767c9.718,0,17.6239-7.9059,17.6239-17.6239c0-0.0315-0.0029-0.0623-0.0031-0.0938h-6.9887
+	c0.0003,0.0316,0.0043,0.0622,0.0043,0.0938c0,5.8651-4.7714,10.6364-10.6364,10.6364S73.2884,5.9589,73.2884,0.0938
+	c0-0.0317,0.0043-0.0622,0.0046-0.0938h-6.9874c-0.0002,0.0316-0.0048,0.0621-0.0048,0.0938c0,4.674,1.8413,8.9171,4.8209,12.0747
+	c-3.5914,4.2867-6.5057,9.1537-8.5975,14.4351c-1.5569-0.2375-3.1507-0.3612-4.7729-0.3612
+	c-17.374,0-31.5089,14.1349-31.5089,31.5089c0,14.4023,9.7169,26.5699,22.9364,30.3139
+	c-5.1912,13.2885-16.4293,23.5726-30.3165,27.4374h16.6543C44.9824,109.2666,52.327,100.0609,56.2125,89.2212z M33.2299,57.7513
+	c0-13.5211,11.0004-24.5214,24.5214-24.5214s24.5214,11.0004,24.5214,24.5214S71.2724,82.2727,57.7513,82.2727
+	S33.2299,71.2723,33.2299,57.7513z"/>
+</svg>

docs/logos/Leptos_logo_pref_dark_RGB.svg

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" id="Layer_1" x="0px" y="0px" viewBox="0 0 437.4 209.6" style="enable-background:new 0 0 437.4 209.6;" xmlns="http://www.w3.org/2000/svg">
+  <style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#EF3939;}
+</style>
+  <path class="st0" d="M95.1,128.1H58.7V65.7c0-1.5-0.8-2.4-2.2-2.4h-3.1c-1.3,0-2.2,1-2.2,2.4v67.4c0,1.5,0.8,2.3,2.2,2.3h41.7 c1.5,0,2.5-0.9,2.5-2.3v-2.8C97.6,128.9,96.7,128.1,95.1,128.1z"/>
+  <path class="st0" d="M146.5,77.2c-4.8-3-10.3-4.5-16.3-4.5c0,0,0,0,0,0c-5.7,0-11.1,1.5-16.1,4.4c-4.9,2.9-8.9,6.8-11.8,11.7 c-2.9,4.9-4.4,10.3-4.4,16.1c0,5.7,1.5,11.1,4.5,15.9c3,4.9,6.9,8.7,11.9,11.7c4.9,2.9,10.2,4.3,16,4.3c0,0,0,0,0,0 c8.1,0,14.7-2.6,21.5-8.4c0.5-0.5,0.9-1.1,0.9-1.8c0-0.6-0.2-1.1-0.5-1.5l-1.4-1.8l-0.1-0.1c-0.3-0.3-0.7-0.6-1.4-0.6 c-0.6,0-1.3,0.2-1.7,0.6c-1.9,1.6-3.5,2.8-4.8,3.6c-1.8,1.2-5.8,3.2-12.6,3.2c0,0,0,0,0,0c-0.1,0-0.3,0-0.4,0 c-12.3,0-23.5-10.3-24.5-22.5l53,0c0,0,0,0,0,0c2.2,0,3.5-1.2,3.5-3.3c0-5.3-1.4-10.4-4-15.3C155,84.1,151.2,80.1,146.5,77.2z M154.6,100.4l-49.1,0c2-11.7,13-21.2,24.5-21c0.1,0,0.3,0,0.4,0C143.5,79.4,152.5,90,154.6,100.4z"/>
+  <path class="st0" d="M204,136.6c5.7,0,11.1-1.5,16-4.3c4.9-2.9,8.8-6.7,11.7-11.7c2.9-4.9,4.3-10.3,4.3-16c0-5.7-1.5-11.1-4.3-16 c-2.9-4.9-6.7-8.8-11.7-11.7c-4.9-2.9-10.2-4.3-16-4.3c-9.9,0-19.2,4.8-24.4,12.3v-9.4c0-0.6-0.1-1.1-0.4-1.5 c-0.4-0.5-1-0.8-1.9-0.8h-2.7c-1.5,0-2.3,0.8-2.3,2.3v5.7v46.5v24c0,1.3,0.8,2,2,2h3.4c0.9,0,1.6-0.7,1.6-1.6v-17.1v-11 C185.1,131.9,194.3,136.6,204,136.6z M186.6,122.6c-4.9-4.9-7.7-11.5-7.5-18c-0.1-6.4,2.5-12.8,7.4-17.6c4.9-4.9,11.3-7.6,17.7-7.4 c4.4,0,8.5,1.1,12.2,3.4c3.7,2.3,6.7,5.4,8.9,9.2c2.2,3.9,3.3,8.1,3.3,12.5c0.1,6.5-2.6,13-7.5,17.9c-4.8,4.8-11,7.4-17.3,7.3 C197.7,130,191.4,127.3,186.6,122.6z"/>
+  <path class="st0" d="M241.9,80.4h7.6v42c0,6.8,4.6,12.1,11.1,12.9c0.7,0.1,1.8,0.2,3.5,0.2c2,0,3-0.4,3-2.3v-2.4c0-1.8-1.3-2-2.8-2 c0,0,0,0,0,0l-1.8,0c-2,0-3.5-0.8-4.4-2.1c-1-1.5-1.5-3.2-1.5-5V80.4h10.1c1.3,0,2.3-1.4,2.3-2.6v-1.9c0-1.4-0.8-2.2-2.2-2.2h-10.1 v-13c0-1.5-0.8-2.5-1.9-2.5c-0.2,0-0.4,0-0.6,0.1l-2.6,0.7c-1.2,0.4-2,0.9-2,2.5v12.2h-7.6c-1.4,0-2.3,0.9-2.3,2.3v1.9 C239.6,79.2,240.6,80.4,241.9,80.4z"/>
+  <path class="st0" d="M379.1,106.3c-4-2.9-8.9-5-14.3-6.3c-6.5-1.4-13.4-5.2-13.3-10.3c0-7.5,6.6-10.2,12.3-10.2c5.4,0,10.2,3,13,8 c0.7,1.3,1.5,1.9,2.4,1.9c0.3,0,0.7-0.1,1-0.3l2.2-1.2c0.6-0.3,0.9-0.9,0.9-1.7c0-0.5-0.1-1-0.3-1.3c-3.6-8.2-10.1-12.4-19.2-12.4 c-11.7,0-19.6,6.9-19.6,17.2c0,4.3,1.8,8,5.5,10.9c3.4,2.8,7.9,4.9,13.3,6.1c4.6,1.1,8.3,2.6,11.1,4.4c1.4,0.9,2.4,2.1,3.1,3.4 c0.6,1.2,0.9,2.6,0.9,4.1c0.1,2.4-0.8,4.5-2.6,6.3c-3.1,3.2-8.4,4.7-12,4.7c0,0-0.1,0-0.1,0c-3.4,0-6.5-0.8-9.1-2.5 c-2.6-1.6-4.2-3.8-5-6.6c-0.3-1.1-0.8-2.2-2.2-2.2c-0.1,0-0.2,0-0.4,0c-0.1,0-0.3,0-0.5,0.1l-1.9,0.4l-0.1,0c-1,0.4-1.6,1.2-1.6,2.1 c0,0.2,0.1,0.7,0.2,1.1c2,8.6,10.2,14.3,20.6,14.3c0.1,0,0.2,0,0.4,0c6.6,0,12.7-2.3,16.7-6.4c3.2-3.2,4.8-7.2,4.7-11.6 c0-2.8-0.6-5.3-1.8-7.5C382.4,109.3,381,107.6,379.1,106.3z"/>
+  <path class="st1" d="M348.9,45.7c0-6.3-3.3-11.9-8.2-15.1c-2.8-1.8-6.2-2.9-9.7-2.9c-9.9,0-18,8.1-18,18c0,4.8,1.9,9.1,4.9,12.3 c-3.7,4.4-6.6,9.3-8.8,14.7c-1.6-0.2-3.2-0.4-4.9-0.4c-17.7,0-32.1,14.4-32.1,32.1c0,14.7,9.9,27.1,23.4,30.9 c-6.8,17.3-23.7,29.7-43.4,29.7c-16.8,0-31.6-9-39.8-22.4c-2.5,0.5-5,0.9-7.7,0.9c9,17,26.9,28.6,47.4,28.6 c23.3,0,43.1-14.9,50.5-35.6c0.5,0,1,0,1.6,0c17.7,0,32.1-14.4,32.1-32.1c0-13.6-8.4-25.2-20.3-29.9c1.9-4.6,4.5-8.8,7.7-12.5 c1,0.4,2,0.8,3.1,1c1.3,0.3,2.7,0.5,4.1,0.5C340.8,63.7,348.9,55.6,348.9,45.7z M304.2,129.5c-13.8,0-25-11.2-25-25s11.2-25,25-25 s25,11.2,25,25S318,129.5,304.2,129.5z M330.9,34.9c0.6,0,1.3,0.1,1.9,0.2c5.1,0.9,9,5.3,9,10.7c0,6-4.9,10.8-10.8,10.8 s-10.8-4.9-10.8-10.8c0-1.4,0.3-2.7,0.8-4C322.4,37.7,326.4,34.9,330.9,34.9z"/>
+</svg>

examples/Makefile.toml

@@ -0,0 +1,60 @@
+[env]
+CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true
+
+# Emulate workspace
+CARGO_MAKE_WORKSPACE_EMULATION = true
+
+CARGO_MAKE_CRATE_WORKSPACE_MEMBERS = [
+    "counter",
+    "counter_isomorphic",
+    #"counters", - FIXME: test compile errors
+    "counters_stable",
+    "counter_without_macros",
+    "error_boundary",
+    "errors_axum",
+    "fetch",
+    "hackernews",
+    "hackernews_axum",
+    "login_with_token_csr_only",
+    "parent_child",
+    "router",
+    "session_auth_axum",
+    "ssr_modes",
+    "ssr_modes_axum",
+    "tailwind",
+    "tailwind_csr_trunk",
+    "todo_app_sqlite",
+    "todo_app_sqlite_axum",
+    "todo_app_sqlite_viz",
+    "todomvc",
+]
+
+[tasks.verify-flow]
+description = "Provides pre and post hooks for verify"
+dependencies = ["pre-verify-flow", "verify", "post-verify-flow"]
+
+[tasks.verify]
+description = "Run all quality checks and tests"
+dependencies = ["check-style", "test-unit-and-web"]
+
+[tasks.test-unit-and-web]
+description = "Run all unit and web tests"
+dependencies = ["test-flow", "web-test-flow"]
+
+[tasks.check-style]
+description = "Check for style violations"
+dependencies = ["check-format-flow", "clippy-flow"]
+
+[tasks.pre-verify-flow]
+
+[tasks.post-verify-flow]
+
+[tasks.web-test-flow]
+description = "Provides pre and post hooks for web-test"
+dependencies = ["pre-web-test-flow", "web-test", "post-web-test-flow"]
+
+[tasks.pre-web-test-flow]
+
+[tasks.web-test]
+
+[tasks.post-web-test-flow]

examples/counter/Cargo.toml

@@ -3,12 +3,17 @@ name = "counter"
 version = "0.1.0"
 edition = "2021"
 
+[profile.release]
+codegen-units = 1
+lto = true
+
 [dependencies]
 leptos = { path = "../../leptos" }
-console_log = "0.2"
+console_log = "1"
 log = "0.4"
 console_error_panic_hook = "0.1.7"
 
 [dev-dependencies]
+wasm-bindgen = "0.2"
 wasm-bindgen-test = "0.3.0"
-
+web-sys = "0.3"

examples/counter/Makefile.toml

@@ -2,3 +2,8 @@
 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/counter/README.md

@@ -3,3 +3,5 @@
 This example creates a simple counter in a client side rendered app with Rust and WASM!
 
 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/counter/index.html

@@ -2,6 +2,7 @@
 <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/counter/src/lib.rs

@@ -17,7 +17,7 @@ pub fn SimpleCounter(
         <div>
             <button on:click=move |_| set_value(0)>"Clear"</button>
             <button on:click=move |_| set_value.update(|value| *value -= step)>"-1"</button>
-            <span>"Value: " {move || value().to_string()} "!"</span>
+            <span>"Value: " {value} "!"</span>
             <button on:click=move |_| set_value.update(|value| *value += step)>"+1"</button>
         </div>
     }

examples/counter/src/main.rs

@@ -1,4 +1,4 @@
-use counter::*;
+use counter::SimpleCounter;
 use leptos::*;
 
 pub fn main() {

examples/counter/tests/mod.rs

@@ -1,35 +1,105 @@
+use counter::*;
+use leptos::*;
+use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 
 wasm_bindgen_test_configure!(run_in_browser);
-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()
-        .dyn_into::<HtmlElement>()
+        .dyn_into::<web_sys::HtmlElement>()
         .unwrap();
     let dec = clear
         .next_sibling()
         .unwrap()
-        .dyn_into::<HtmlElement>()
+        .dyn_into::<web_sys::HtmlElement>()
         .unwrap();
     let text = dec
         .next_sibling()
         .unwrap()
-        .dyn_into::<HtmlElement>()
+        .dyn_into::<web_sys::HtmlElement>()
         .unwrap();
     let inc = text
         .next_sibling()
         .unwrap()
-        .dyn_into::<HtmlElement>()
+        .dyn_into::<web_sys::HtmlElement>()
         .unwrap();
 
     inc.click();
@@ -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

@@ -6,13 +6,16 @@ edition = "2021"
 [lib]
 crate-type = ["cdylib", "rlib"]
 
+[profile.release]
+codegen-units = 1
+lto = true
+
 [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_log = "1"
 console_error_panic_hook = "0.1"
-serde = { version = "1", features = ["derive"] }
 futures = "0.3"
 cfg-if = "1"
 lazy_static = "1"
@@ -23,8 +26,9 @@ leptos_actix = { path = "../../integrations/actix", optional = true }
 leptos_meta = { path = "../../meta", default-features = false }
 leptos_router = { path = "../../router", default-features = false }
 log = "0.4"
-simple_logger = "2"
 gloo-net = { git = "https://github.com/rustwasm/gloo" }
+wasm-bindgen = "0.2"
+serde = { version = "1", features = ["derive"] }
 
 [features]
 default = []
@@ -47,6 +51,7 @@ skip_feature_sets = [["ssr", "hydrate"]]
 # The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
 output-name = "counter_isomorphic"
 # 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.
+# When NOT using cargo-leptos this must be updated to "." or the counters will not work. The above warning still applies if you do switch to cargo-leptos later.
 site-root = "target/site"
 # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
 # Defaults to pkg	
@@ -54,9 +59,9 @@ 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 = "src/styles/tailwind.css"
 # [Optional] Files in the asset-dir will be copied to the site-root directory
-# assets-dir = "static/assets"
+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-address = "127.0.0.1:3000"
+site-addr = "127.0.0.1:3000"
 # The port to use for automatic reload monitoring
 reload-port = 3001
 # [Optional] Command to use when running end2end tests. It will run in the end2end dir.

examples/counter_isomorphic/Makefile.toml

@@ -2,3 +2,8 @@
 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/counter_isomorphic/README.md

@@ -3,8 +3,8 @@
 This example demonstrates how to use a function isomorphically, to run a server side function from the browser and receive a result.
 
 ## Client Side Rendering
-To run it as a Client Side App, you can issue  `trunk serve --open` in the root. This will build the entire
-app into one CSR bundle. Make sure you have trunk installed with `cargo install trunk`.
+For this example the server must store the counter state since it can be modified by many users.
+This means it is not possible to produce a working CSR-only version as a non-static server is required.
 
 ## Server Side Rendering with cargo-leptos
 cargo-leptos is now the easiest and most featureful way to build server side rendered apps with hydration. It provides automatic recompilation of client and server code, wasm optimisation, CSS minification, and more! Check out more about it [here](https://github.com/akesson/cargo-leptos)
@@ -17,6 +17,9 @@ cargo install --locked cargo-leptos
 ```bash
 cargo leptos watch
 ```
+
+Open browser on [http://localhost:3000/](http://localhost:3000/)
+
 3. When ready to deploy, run
 ```bash
 cargo leptos build --release
@@ -25,7 +28,7 @@ cargo leptos build --release
 ## Server Side Rendering without cargo-leptos
 To run it as a server side app with hydration, you'll need to have wasm-pack installed.
 
-0. Edit the `[package.metadata.leptos]` section and set `site-root` to `"pkg"`. You'll also want to change the path of the `<StyleSheet / >` component in the root component to point towards the CSS file in the root. This tells leptos that the WASM/JS files generated by wasm-pack are available at `./pkg` and that the CSS files are no longer processed by cargo-leptos. Building to alternative folders is not supported at this time.
+0. Edit the `[package.metadata.leptos]` section and set `site-root` to `"."`. For examples with CSS you also want to change the path of the `<StyleSheet / >` component in the root component to point towards the CSS file in the root. This tells leptos that the WASM/JS files generated by wasm-pack are available at `./pkg` and that the CSS files are no longer processed by cargo-leptos. Building to alternative folders is not supported at this time. You'll also want to edit the call to `get_configuration()` to pass in `Some(Cargo.toml)`, so that Leptos will read the settings instead of cargo-leptos. If you do so, your file/folder names cannot include dashes.
 1. Install wasm-pack
 ```bash
 cargo install wasm-pack

examples/counter_isomorphic/src/counters.rs

@@ -1,5 +1,6 @@
 use leptos::*;
 use leptos_router::*;
+use leptos_meta::*;
 
 #[cfg(feature = "ssr")]
 use std::sync::atomic::{AtomicI32, Ordering};
@@ -44,6 +45,7 @@ pub async fn clear_server_count() -> Result<i32, ServerFnError> {
 }
 #[component]
 pub fn Counters(cx: Scope) -> impl IntoView {
+    provide_meta_context(cx);
     view! {
         cx,
         <Router>
@@ -59,6 +61,7 @@ pub fn Counters(cx: Scope) -> impl IntoView {
                     <li><A href="multi">"Multi-User"</A></li>
                 </ul>
             </nav>
+            <Link rel="shortcut icon" type_="image/ico" href="/favicon.ico"/>
             <main>
                 <Routes>
                     <Route path="" view=|cx| view! {
@@ -94,10 +97,10 @@ pub fn Counter(cx: Scope) -> impl IntoView {
         |_| get_server_count(),
     );
 
-    let value = move || counter.read().map(|count| count.unwrap_or(0)).unwrap_or(0);
+    let value = move || counter.read(cx).map(|count| count.unwrap_or(0)).unwrap_or(0);
     let error_msg = move || {
         counter
-            .read()
+            .read(cx)
             .map(|res| match res {
                 Ok(_) => None,
                 Err(e) => Some(e),
@@ -113,7 +116,7 @@ pub fn Counter(cx: Scope) -> impl IntoView {
             <div>
                 <button on:click=move |_| clear.dispatch(())>"Clear"</button>
                 <button on:click=move |_| dec.dispatch(())>"-1"</button>
-                <span>"Value: " {move || value().to_string()} "!"</span>
+                <span>"Value: " {value} "!"</span>
                 <button on:click=move |_| inc.dispatch(())>"+1"</button>
             </div>
             {move || error_msg().map(|msg| view! { cx, <p>"Error: " {msg.to_string()}</p>})}
@@ -140,7 +143,7 @@ pub fn FormCounter(cx: Scope) -> impl IntoView {
     let value = move || {
         log::debug!("FormCounter looking for value");
         counter
-            .read()
+            .read(cx)
             .map(|n| n.ok())
             .flatten()
             .map(|n| n)
@@ -191,17 +194,17 @@ 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")
-                    .1
-                    .data()
-                    .as_string()
-                    .expect_throw("expected string value")
-            }),
+                match value {
+                    Ok(value) => {
+                        value.1.data().as_string().expect("expected string value")
+                    },
+                    Err(_) => "0".to_string(),
+                }
+            })
         );
 
         on_cleanup(cx, move || source.close());
@@ -209,8 +212,8 @@ pub fn MultiuserCounter(cx: Scope) -> impl IntoView {
     };
 
     #[cfg(feature = "ssr")]
-    let multiplayer_value =
-        create_signal_from_stream(cx, futures::stream::once(Box::pin(async { 0.to_string() })));
+    let (multiplayer_value, _) =
+        create_signal(cx, None::<i32>);
 
     view! {
         cx,

examples/counter_isomorphic/src/lib.rs

@@ -10,7 +10,6 @@ cfg_if! {
 
         #[wasm_bindgen]
         pub fn hydrate() {
-            console_error_panic_hook::set_once();
             _ = console_log::init_with_level(log::Level::Debug);
             console_error_panic_hook::set_once();
 

examples/counter_isomorphic/src/main.rs

@@ -9,6 +9,7 @@ cfg_if! {
         use actix_files::{Files};
         use actix_web::*;
         use crate::counters::*;
+        use leptos_actix::{generate_route_list, LeptosRoutes};
 
         #[get("/api/events")]
         async fn counter_events() -> impl Responder {
@@ -29,23 +30,26 @@ cfg_if! {
 
         #[actix_web::main]
         async fn main() -> std::io::Result<()> {
+
             crate::counters::register_server_functions();
-            let conf = get_configuration(Some("Cargo.toml")).await.unwrap();
-            let leptos_options = &conf.leptos_options;
-            let site_root = &leptos_options.site_root;
-            let pkg_dir = &leptos_options.site_pkg_dir;
-            let bundle_path = format!("/{site_root}/{pkg_dir}");
-            let addr = conf.leptos_options.site_address.clone();
+
+            // Setting this to None means we'll be using cargo-leptos and its env vars.
+            // 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_addr.clone();
+            let routes = generate_route_list(|cx| view! { cx, <Counters/> });
 
             HttpServer::new(move || {
                 let leptos_options = &conf.leptos_options;
+                let site_root = &leptos_options.site_root;
+
                 App::new()
-                    .service(Files::new("/pkg", "./pkg")) // used by wasm-pack and cargo run. Can be removed if using cargo-leptos
-                    .service(Files::new(&bundle_path, format!("./{bundle_path}"))) // used by cargo-leptos. Can be removed if using wasm-pack and cargo run.
                     .service(counter_events)
                     .route("/api/{tail:.*}", leptos_actix::handle_server_fns())
-                    .route("/{tail:.*}", leptos_actix::render_app_to_stream(leptos_options.to_owned(), |cx| view! { cx, <Counters/> }))
-                //.wrap(middleware::Compress::default())
+                    .leptos_routes(leptos_options.to_owned(), routes.to_owned(), |cx| view! { cx, <Counters/> })
+                    .service(Files::new("/", &site_root))
+                    //.wrap(middleware::Compress::default())
             })
             .bind(&addr)?
             .run()
@@ -53,14 +57,11 @@ cfg_if! {
         }
         }
 
-    // client-only stuff for Trunk
+    // client-only main for Trunk
     else {
-        use counter_isomorphic::counters::*;
-
         pub fn main() {
-            _ = console_log::init_with_level(log::Level::Debug);
-            console_error_panic_hook::set_once();
-            mount_to_body(|cx| view! { cx, <Counter/> });
+            // isomorphic counters cannot work in a Client-Side-Rendered only
+            // app as a server is required to maintain state
         }
     }
 }

examples/counter_without_macros/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "counter_without_macros"
+version = "0.1.0"
+edition = "2021"
+
+[profile.release]
+codegen-units = 1
+lto = true
+
+[dependencies]
+leptos = { path = "../../leptos", features = ["stable"] }
+console_log = "1"
+log = "0.4"
+console_error_panic_hook = "0.1.7"
+
+[dev-dependencies]
+wasm-bindgen = "0.2.84"
+wasm-bindgen-test = "0.3.34"
+pretty_assertions = "1.3.0"
+
+[dev-dependencies.web-sys]
+features = ["HtmlElement", "XPathResult"]
+version = "0.3.61"

examples/counter_without_macros/Makefile.toml

@@ -0,0 +1,16 @@
+[env]
+CARGO_MAKE_WASM_TEST_ARGS = "--headless --chrome"
+
+[tasks.web-test]
+command = "cargo"
+args = ["make", "wasm-pack-test"]
+
+[tasks.build]
+command = "cargo"
+args = ["+stable", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+stable", "check-all-features"]
+install_crate = "cargo-all-features"

examples/counter_without_macros/README.md

@@ -0,0 +1,7 @@
+# Leptos Counter Example
+
+This example is the same like the `counter` but it's written without using macros and can be build with stable Rust.
+
+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.
+
+Issue the `cargo make test-flow` command to run unit and wasm tests.

examples/counter_without_macros/index.html

@@ -2,6 +2,7 @@
 <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>