v0.4.0

.github/workflows/check-examples.yml

@@ -14,7 +14,6 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       matrix: ${{ steps.set-matrix.outputs.matrix }}
-      source_changed: ${{ steps.set-source-changed.outputs.source_changed }}
     steps:
       - name: Checkout
         uses: actions/checkout@v3
@@ -35,40 +34,13 @@ jobs:
           echo "Example Directories: $examples"
           echo "matrix={\"directory\":$examples}" >> "$GITHUB_OUTPUT"
 
-      - name: Get source files that changed
-        id: changed-source
-        uses: tj-actions/changed-files@v36
-        with:
-          files: |
-            integrations
-            leptos
-            leptos_config
-            leptos_dom
-            leptos_hot_reload
-            leptos_macro
-            leptos_reactive
-            leptos_server
-            meta
-            router
-            server_fn
-            server_fn_macro
-
-      - name: List source files that changed
-        run: echo '${{ steps.changed-source.outputs.all_changed_files }}'
-
-      - name: Set source_changed
-        id: set-source-changed
-        run: |
-          echo "source_changed=${{ steps.changed-source.outputs.any_changed }}" >> "$GITHUB_OUTPUT"
-
   matrix-job:
     name: Check
     needs: [setup]
-    if: needs.setup.outputs.source_changed == 'true'
     strategy:
       matrix: ${{ fromJSON(needs.setup.outputs.matrix) }}
       fail-fast: false
-    uses: ./.github/workflows/run-cargo-make-task.yml
+    uses: ./.github/workflows/run-example-task.yml
     with:
       directory: ${{ matrix.directory }}
       cargo_make_task: "check"

.github/workflows/check-stable.yml

@@ -11,45 +11,8 @@ env:
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
 
 jobs:
-  setup:
-    name: Detect Changes
-    runs-on: ubuntu-latest
-    outputs:
-      source_changed: ${{ steps.set-source-changed.outputs.source_changed }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Get source files that changed
-        id: changed-source
-        uses: tj-actions/changed-files@v36
-        with:
-          files: |
-            integrations
-            leptos
-            leptos_config
-            leptos_dom
-            leptos_hot_reload
-            leptos_macro
-            leptos_reactive
-            leptos_server
-            meta
-            router
-            server_fn
-            server_fn_macro
-
-      - name: List source files that changed
-        run: echo '${{ steps.changed-source.outputs.all_changed_files }}'
-
-      - name: Set source_changed
-        id: set-source-changed
-        run: |
-          echo "source_changed=${{ steps.changed-source.outputs.any_changed }}" >> "$GITHUB_OUTPUT"
-
   test:
     name: Check examples ${{ matrix.os }} (using rustc ${{ matrix.rust }})
-    needs: [setup]
-    if: needs.setup.outputs.source_changed == 'true'
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:

.github/workflows/check.yml

@@ -0,0 +1,46 @@
+name: Check
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
+
+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/ci.yml

@@ -1,75 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  setup:
-    name: Detect Changes
-    runs-on: ubuntu-latest
-    outputs:
-      source_changed: ${{ steps.set-source-changed.outputs.source_changed }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Get source files that changed
-        id: changed-source
-        uses: tj-actions/changed-files@v36
-        with:
-          files: |
-            integrations
-            leptos
-            leptos_config
-            leptos_dom
-            leptos_hot_reload
-            leptos_macro
-            leptos_reactive
-            leptos_server
-            meta
-            router
-            server_fn
-            server_fn_macro
-
-      - name: List source files that changed
-        run: echo '${{ steps.changed-source.outputs.all_changed_files }}'
-
-      - name: Set source_changed
-        id: set-source-changed
-        run: |
-          echo "source_changed=${{ steps.changed-source.outputs.any_changed }}" >> "$GITHUB_OUTPUT"
-
-  matrix-job:
-    name: CI
-    needs: [setup]
-    if: needs.setup.outputs.source_changed == 'true'
-    strategy:
-      matrix:
-        directory:
-          [
-            integrations/actix,
-            integrations/axum,
-            integrations/viz,
-            integrations/utils,
-            leptos,
-            leptos_config,
-            leptos_dom,
-            leptos_hot_reload,
-            leptos_macro,
-            leptos_reactive,
-            leptos_server,
-            meta,
-            router,
-            server_fn,
-            server_fn/server_fn_macro_default,
-            server_fn_macro,
-          ]
-    uses: ./.github/workflows/run-cargo-make-task.yml
-    with:
-      directory: ${{ matrix.directory }}
-      cargo_make_task: "ci"

.github/workflows/fmt.yml

@@ -0,0 +1,34 @@
+name: Format
+
+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

@@ -1,8 +1,9 @@
 name: Deploy book
 on:
   push:
-    tags:
-      - '*-?v[0-9]+*'
+    paths: ['docs/book/**']
+    branches:
+      - main
 
 jobs:
   deploy:
@@ -33,4 +34,4 @@ jobs:
         mv ../book/* .
         git add .
         git commit -m "Deploy book $GITHUB_SHA to gh-pages"
-        git push --force --set-upstream origin gh-pages
+        git push --force --set-upstream origin gh-pages

.github/workflows/run-example-task.yml

@@ -1,4 +1,4 @@
-name: Run Task
+name: Run Example Task
 
 on:
   workflow_call:
@@ -27,9 +27,9 @@ jobs:
     steps:
       # Setup environment
       - name: Install playwright browser dependencies
-        run: |
+        run: | 
           sudo apt-get update
-          sudo apt-get install libegl1 libvpx7 libevent-2.1-7 libopus0 libopengl0 libwoff1 libharfbuzz-icu0 libgstreamer-plugins-base1.0-0 libgstreamer-gl1.0-0 libhyphen0 libmanette-0.2-0 libgles2 gstreamer1.0-libav
+          sudo apt-get install libegl1 libvpx7 libevent-2.1-7 libopus0 libopengl0 libwoff1 libharfbuzz-icu0 libgstreamer-plugins-base1.0-0 libgstreamer-gl1.0-0 libhyphen0 libmanette-0.2-0 libgles2 gstreamer1.0-libav                   
 
       - uses: actions/checkout@v3
 
@@ -84,12 +84,7 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-pnpm-store-
 
-      - name: Install Chrome Webriver
-        run: |
-          sudo apt-get update
-          sudo apt-get install chromium-chromedriver
-
-      # Run Cargo Make Task
+      # Verify project
       - name: ${{ inputs.cargo_make_task }}
         run: |
           if [ "${{ inputs.directory }}" = "INTERNAL" ]; then

.github/workflows/test.yml

@@ -0,0 +1,46 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
+
+jobs:
+  test:
+    name: Run tests ${{ 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 tests with all features
+        run: cargo make --profile=github-actions test

.github/workflows/verify-all-examples.yml

@@ -41,7 +41,7 @@ jobs:
     strategy:
       matrix: ${{ fromJSON(needs.setup.outputs.matrix) }}
       fail-fast: false
-    uses: ./.github/workflows/run-cargo-make-task.yml
+    uses: ./.github/workflows/run-example-task.yml
     with:
       directory: ${{ matrix.directory }}
       cargo_make_task: "verify-flow"

.github/workflows/verify-changed-examples.yml

@@ -65,7 +65,7 @@ jobs:
     strategy:
       matrix: ${{ fromJSON(needs.setup.outputs.matrix) }}
       fail-fast: false
-    uses: ./.github/workflows/run-cargo-make-task.yml
+    uses: ./.github/workflows/run-example-task.yml
     with:
       directory: ${{ matrix.directory }}
       cargo_make_task: "verify-flow"

ARCHITECTURE.md

@@ -220,8 +220,8 @@ for reference: they include large amounts of manual SSR route handling, etc.
 ## `cargo-leptos` helpers
 
 `leptos_config` and `leptos_hot_reload` exist to support two different features
-of `cargo-leptos`, namely its configuration and its view-patching/hot-reloading 
-features.
+of `cargo-leptos`, namely its configuration and its view-patching/hot-
+reloading features.
 
 It’s important to say that the main feature `cargo-leptos` remains its ability
 to conveniently tie together different build tooling, compiling your app to

CONTRIBUTING.md

@@ -70,25 +70,6 @@ are a few guidelines that will make it a better experience for everyone:
   `cargo-make` and using `cargo make check && cargo make test && cargo make
 check-examples`.
 
-## Before Submitting a PR
-
-We have a fairly extensive CI setup that runs both lints (like `rustfmt` and `clippy`) 
-and tests on PRs. You can run most of these locally if you have `cargo-make` installed.
-
-If you added an example, make sure to add it to the list in `examples/Makefile.toml`.
-
-From the root directory of the repo, run 
-- `cargo +nightly fmt`
-- `cargo +nightly make check`
-- `cargo +nightly make test`
-- `cargo +nightly make check-examples`
-- `cargo +nightly make --profile=github-actions ci`
-
-If you modified an example:
-- `cd examples/your_example`
-- `cargo +nightly fmt -- --config-path ../..`
-- `cargo +nightly make --profile=github-actions verify-flow`
-
 ## Architecture
 
 See [ARCHITECTURE.md](./ARCHITECTURE.md).

Cargo.toml

@@ -26,22 +26,22 @@ members = [
 exclude = ["benchmarks", "examples"]
 
 [workspace.package]
-version = "0.4.9"
+version = "0.4.0"
 
 [workspace.dependencies]
-leptos = { path = "./leptos", version = "0.4.9" }
-leptos_dom = { path = "./leptos_dom", version = "0.4.9" }
-leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.4.9" }
-leptos_macro = { path = "./leptos_macro", version = "0.4.9" }
-leptos_reactive = { path = "./leptos_reactive", version = "0.4.9" }
-leptos_server = { path = "./leptos_server", version = "0.4.9" }
-server_fn = { path = "./server_fn", version = "0.4.9" }
-server_fn_macro = { path = "./server_fn_macro", version = "0.4.9" }
-server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.4.9" }
-leptos_config = { path = "./leptos_config", version = "0.4.9" }
-leptos_router = { path = "./router", version = "0.4.9" }
-leptos_meta = { path = "./meta", version = "0.4.9" }
-leptos_integration_utils = { path = "./integrations/utils", version = "0.4.9" }
+leptos = { path = "./leptos", version = "0.4.0" }
+leptos_dom = { path = "./leptos_dom", version = "0.4.0" }
+leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.4.0" }
+leptos_macro = { path = "./leptos_macro", version = "0.4.0" }
+leptos_reactive = { path = "./leptos_reactive", version = "0.4.0" }
+leptos_server = { path = "./leptos_server", version = "0.4.0" }
+server_fn = { path = "./server_fn", version = "0.4.0" }
+server_fn_macro = { path = "./server_fn_macro", version = "0.4.0" }
+server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.4.0" }
+leptos_config = { path = "./leptos_config", version = "0.4.0" }
+leptos_router = { path = "./router", version = "0.4.0" }
+leptos_meta = { path = "./meta", version = "0.4.0" }
+leptos_integration_utils = { path = "./integrations/utils", version = "0.4.0" }
 
 [profile.release]
 codegen-units = 1

Makefile.toml

@@ -3,37 +3,122 @@
 #     cargo install --force cargo-make
 ############
 
-[env]
-CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true
+[config]
+# make tasks run at the workspace root
+default_to_workspace = false
+
+[tasks.check]
+clear = true
+dependencies = [
+	"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/js-framework-benchmark" },
+	{ name = "check", path = "examples/leptos-tailwind-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/slots" },
+	{ 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/timer" },
+	{ 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]
-workspace = false
 clear = true
 dependencies = [
 	{ name = "check", path = "examples/counter_without_macros" },
 	{ name = "check", path = "examples/counters_stable" },
 ]
 
-[tasks.ci-examples]
-workspace = false
-cwd = "examples"
-command = "cargo"
-args = ["make", "ci-clean"]
+[tasks.test]
+clear = true
+dependencies = [
+	"test-all",
+	"test-leptos_macro-example",
+	"doc-leptos_macro-example",
+]
 
-[tasks.check-examples]
-workspace = false
-cwd = "examples"
+[tasks.test-all]
 command = "cargo"
-args = ["make", "check-clean"]
+args = ["+nightly", "test-all-features"]
+install_crate = "cargo-all-features"
 
-[tasks.build-examples]
-workspace = false
+[tasks.test-leptos_macro-example]
+description = "Tests the leptos_macro/example to check if macro handles doc comments correctly"
+command = "cargo"
+args = ["+nightly", "test", "--doc"]
+cwd = "leptos_macro/example"
+install_crate = false
+
+[tasks.doc-leptos_macro-example]
+description = "Docs the leptos_macro/example to check if macro handles doc comments correctly"
+command = "cargo"
+args = ["+nightly", "doc"]
+cwd = "leptos_macro/example"
+install_crate = false
+
+[tasks.test-examples]
+description = "Run all unit and web tests for examples"
 cwd = "examples"
 command = "cargo"
-args = ["make", "build-clean"]
+args = ["make", "test-unit-and-web"]
+
+[tasks.verify-examples]
+description = "Run all quality checks and tests for examples"
+env = { CLEAN_AFTER_VERIFY = "true" }
+cwd = "examples"
+command = "cargo"
+args = ["make", "verify-flow"]
 
 [tasks.clean-examples]
-workspace = false
+description = "Clean all example projects"
 cwd = "examples"
 command = "cargo"
-args = ["make", "clean"]
+args = ["make", "clean-all"]
+
+[env]
+RUSTFLAGS = ""
+LEPTOS_OUTPUT_NAME = "ci" # allows examples to check/build without cargo-leptos
+
+[env.github-actions]
+RUSTFLAGS = "-D warnings"

README.md

@@ -88,6 +88,8 @@ targets = ["wasm32-unknown-unknown"]
 
 The `nightly` feature enables the function call syntax for accessing and setting signals, as opposed to `.get()` and `.set()`. This leads to a consistent mental model in which accessing a reactive value of any kind (a signal, memo, or derived signal) is always represented as a function call. This is only possible with nightly Rust and the `nightly` feature.
 
+> Note: The `nightly` feature is present on the main branch version right now, but not in 0.3.x. For 0.3.x, nightly is the default and `stable` has a special feature.
+
 ## `cargo-leptos`
 
 [`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).
@@ -105,7 +107,7 @@ Open browser to [http://localhost:3000/](http://localhost:3000/).
 
 ### What’s up with the name?
 
-_Leptos_ (λεπτός) is an ancient Greek word meaning “thin, light, refined, 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.
+_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?
 

cargo-make/check.toml

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

cargo-make/lint.toml

@@ -1,11 +0,0 @@
-[tasks.lint]
-dependencies = ["check-format-flow", "clippy-each-feature"]
-
-[tasks.check-format]
-env = { LEPTOS_PROJECT_DIRECTORY = "../" }
-args = ["fmt", "--", "--check", "--config-path", "${LEPTOS_PROJECT_DIRECTORY}"]
-
-[tasks.clippy-each-feature]
-dependencies = ["install-clippy"]
-command = "cargo"
-args = ["hack", "clippy", "--all", "--each-feature", "--no-dev-deps"]

cargo-make/main.toml

@@ -1,15 +0,0 @@
-extend = [
-    { path = "./check.toml" },
-    { path = "./lint.toml" },
-    { path = "./test.toml" },
-]
-
-[env]
-RUSTFLAGS = ""
-LEPTOS_OUTPUT_NAME = "ci" # allows examples to check/build without cargo-leptos
-
-[env.github-actions]
-RUSTFLAGS = "-D warnings"
-
-[tasks.ci]
-dependencies = ["lint", "test"]

cargo-make/test.toml

@@ -1,7 +0,0 @@
-[tasks.test]
-alias = "test-all"
-
-[tasks.test-all]
-command = "cargo"
-args = ["+nightly", "test-all-features"]
-install_crate = "cargo-all-features"

docs/book/book.toml

@@ -1,2 +0,0 @@
-[output.html.playground]
-runnable = false

docs/book/src/01_introduction.md

@@ -17,4 +17,4 @@ understand Leptos.
 
 You can find more detailed docs for each part of the API at [Docs.rs](https://docs.rs/leptos/latest/leptos/).
 
-> The source code for the book is available [here](https://github.com/leptos-rs/leptos/tree/main/docs/book). PRs for typos or clarification are always welcome.
+**The guide is a work in progress.**

docs/book/src/02_getting_started.md

@@ -14,38 +14,24 @@ If you don’t already have it installed, you can install Trunk by running
 cargo install trunk
 ```
 
-Create a basic Rust project
+Create a basic Rust binary project
 
 ```bash
 cargo init leptos-tutorial
 ```
 
-`cd` into your new `leptos-tutorial` project and add `leptos` as a dependency
-
-```bash
-cargo add leptos --features=csr,nightly
-```
-
-Or you can leave off `nightly` if you're using stable Rust
-```bash
-cargo add leptos --features=csr
-```
-
-> Using `nightly` Rust, and the `nightly` feature in Leptos enables the function-call syntax for signal getters and setters that is used in most of this book.
->
-> To use `nightly` Rust, you can run
+> 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
 > ```
->
-> If you’d rather use stable Rust with Leptos, you can do that too. In the guide and examples, you’ll just use the [`ReadSignal::get()`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html#impl-SignalGet%3CT%3E-for-ReadSignal%3CT%3E) and [`WriteSignal::set()`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html#impl-SignalGet%3CT%3E-for-ReadSignal%3CT%3E) methods instead of calling signal getters and setters as functions.
 
-Make sure you've added the `wasm32-unknown-unknown` target so that Rust can compile your code to WebAssembly to run in the browser.
+`cd` into your new `leptos-tutorial` project and add `leptos` as a dependency
 
 ```bash
-rustup target add wasm32-unknown-unknown
+cargo add leptos
 ```
 
 Create a simple `index.html` in the root of the `leptos-tutorial` directory

docs/book/src/14_create_effect.md

@@ -0,0 +1 @@
+# Responding to Changes with create_effect

docs/book/src/15_global_state.md

@@ -136,7 +136,7 @@ view! { cx,
 
 In this example, clicking the button will cause the text inside `<p>` to be updated, cloning `state.name` again! Because signals are the atomic unit of reactivity, updating any field of the signal triggers updates to everything that depends on the signal.
 
-There’s a better way. You can take fine-grained, reactive slices by using [`create_memo`](https://docs.rs/leptos/latest/leptos/fn.create_memo.html) or [`create_slice`](https://docs.rs/leptos/latest/leptos/fn.create_slice.html) (which uses `create_memo` but also provides a setter). “Memoizing” a value means creating a new reactive value which will only update when it changes. “Memoizing a slice” means creating a new reactive value which will only update when some field of the state struct updates.
+There’s a better way. You can use take fine-grained, reactive slices by using [`create_memo`](https://docs.rs/leptos/latest/leptos/fn.create_memo.html) or [`create_slice`](https://docs.rs/leptos/latest/leptos/fn.create_slice.html) (which uses `create_memo` but also provides a setter). “Memoizing” a value means creating a new reactive value which will only update when it changes. “Memoizing a slice” means creating a new reactive value which will only update when some field of the state struct updates.
 
 Here, instead of reading from the state signal directly, we create “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.
 
@@ -183,222 +183,3 @@ 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"></iframe>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-
-// 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: Pass 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.
-#[component]
-fn Option2(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,
-        <h1>"Option 2: Passing Signals"</h1>
-        // 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
-        <div style="display: flex">
-            <FancyMath/>
-            <ListItems/>
-        </div>
-    }
-}
-
-/// A button that increments our global counter.
-#[component]
-fn SetterButton(cx: Scope, set_count: WriteSignal<u32>) -> impl IntoView {
-    view! { cx,
-        <div class="provider red">
-            <button on:click=move |_| set_count.update(|count| *count += 1)>
-                "Increment Global Count"
-            </button>
-        </div>
-    }
-}
-
-/// 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>
-    }
-}
-
-/// A component that shows a list of items generated from the global count.
-#[component]
-fn ListItems(cx: Scope) -> impl IntoView {
-    // again, consume the global count signal with `use_context`
-    let count = use_context::<ReadSignal<u32>>(cx).expect("there to be a `count` signal provided");
-
-    let squares = move || {
-        (0..count())
-            .map(|n| view! { cx, <li>{n}<sup>"2"</sup> " is " {n * n}</li> })
-            .collect::<Vec<_>>()
-    };
-
-    view! { cx,
-        <div class="consumer green">
-            <ul>{squares}</ul>
-        </div>
-    }
-}
-
-// 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` or `create_memo`,
-// 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.
-
-#[derive(Default, Clone, Debug)]
-struct GlobalState {
-    count: u32,
-    name: String,
-}
-
-#[component]
-fn Option3(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);
-
-    view! { cx,
-        <h1>"Option 3: Passing Signals"</h1>
-        <div class="red consumer" style="width: 100%">
-            <h2>"Current Global State"</h2>
-            <pre>
-                {move || {
-                    format!("{:#?}", state.get())
-                }}
-            </pre>
-        </div>
-        <div style="display: flex">
-            <GlobalStateCounter/>
-            <GlobalStateInput/>
-        </div>
-    }
-}
-
-/// 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>
-    }
-}
-
-/// A component that updates the count in the global state.
-#[component]
-fn GlobalStateInput(cx: Scope) -> impl IntoView {
-    let state = use_context::<RwSignal<GlobalState>>(cx).expect("state to have been provided");
-
-    // this slice is completely independent of the `count` slice
-    // that we created in the other component
-    // neither of them will cause the other to rerun
-    let (name, set_name) = create_slice(
-        cx,
-        // we take a slice *from* `state`
-        state,
-        // our getter returns a "slice" of the data
-        |state| state.name.clone(),
-        // our setter describes how to mutate that slice, given a new value
-        |state, n| state.name = n,
-    );
-
-    view! { cx,
-        <div class="consumer green">
-            <input
-                type="text"
-                prop:value=name
-                on:input=move |ev| {
-                    set_name(event_target_value(&ev));
-                }
-            />
-            <br/>
-            <span>"Name is: " {name}</span>
-        </div>
-    }
-}
-// This `main` function is the entry point into the app
-// It just mounts our component to the <body>
-// Because we defined it as `fn App`, we can now use it in a
-// template as <App/>
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <Option2/><Option3/> })
-}
-
-```
-
-</details>
-</preview>

docs/book/src/SUMMARY.md

@@ -23,6 +23,7 @@
   - [Transition](./async/12_transition.md)
   - [Actions](./async/13_actions.md)
 - [Interlude: Projecting Children](./interlude_projecting_children.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)
@@ -43,6 +44,5 @@
   - [Responses and Redirects](./server/27_response.md)
 - [Progressive Enhancement and Graceful Degradation](./progressive_enhancement/README.md)
   - [`<ActionForm/>`s](./progressive_enhancement/action_form.md)
-- [Deployment](./deployment.md)
-- [Appendix: How Does the Reactive System Work?](./appendix_reactive_graph.md)
+- [Deployment]()
 - [Appendix: Optimizing WASM Binary Size](./appendix_binary_size.md)

docs/book/src/appendix_reactive_graph.md

@@ -1,243 +0,0 @@
-# Appendix: How does the Reactive System Work?
-
-You don’t need to know very much about how the reactive system actually works in order to use the library successfully. But it’s always useful to understand what’s going on behind the scenes once you start working with the framework at an advanced level.
-
-The reactive primitives you use are divided into three sets:
-
-- **Signals** (`ReadSignal`/`WriteSignal`, `RwSignal`, `Resource`, `Trigger`) Values you can actively change to trigger reactive updates.
-- **Computations** (`Memo`s) Values that depend on signals (or other computations) and derive a new reactive value through some pure computation.
-- **Effects** Observers that listen to changes in some signals or computations and run a function, causing some side effect.
-
-Derived signals are a kind of non-primitve computation: as plain closures, they simply allow you to refactor some repeated signal-based computation into a reusable function that can be called in multiple places, but they are not represented in the reactive system itself.
-
-All the other primitives actually exist in the reactive system as nodes in a reactive graph.
-
-Most of the work of the reactive system consists of propagating changes from signals to effects, possibly through some intervening memos.
-
-The assumption of the reactive system is that effects (like rendering to the DOM or making a network request) are orders of magnitude more expensive than things like updating a Rust data structure inside your app.
-
-So the **primary goal** of the reactive system is to **run effects as infrequently as possible**.
-
-Leptos does this through the construction of a reactive graph.
-
-> Leptos’s current reactive system is based heavily on the [Reactively](https://github.com/modderme123/reactively) library for JavaScript. You can read Milo’s article “[Super-Charging Fine-Grained Reactivity](https://dev.to/modderme123/super-charging-fine-grained-reactive-performance-47ph)” for an excellent account of its algorithm, as well as fine-grained reactivity in general—including some beautiful diagrams!
-
-## The Reactive Graph
-
-Signals, memos, and effects all share three characteristics:
-
-- **Value** They have a current value: either the signal’s value, or (for memos and effects) the value returned by the previous run, if any.
-- **Sources** Any other reactive primitives they depend on. (For signals, this is an empty set.)
-- **Subscribers** Any other reactive primitives that depend on them. (For effects, this is an empty set.)
-
-In reality then, signals, memos, and effects are just conventional names for one generic concept of a “node” in a reactive graph. Signals are always “root nodes,” with no sources/parents. Effects are always “leaf nodes,” with no subscribers. Memos typically have both sources and subscribers.
-
-### Simple Dependencies
-
-So imagine the following code:
-
-```rust
-// A
-let (name, set_name) = create_signal(cx, "Alice");
-
-// B
-let name_upper = create_memo(cx, move |_| name.with(|n| n.to_uppercase()));
-
-// C
-create_effect(cx, move |_| {
-	log!("{}", name_upper());
-});
-
-set_name("Bob");
-```
-
-You can easily imagine the reactive graph here: `name` is the only signal/origin node, the `create_effect` is the only effect/terminal node, and there’s one intervening memo.
-
-```
-A   (name)
-|
-B   (name_upper)
-|
-C   (the effect)
-```
-
-### Splitting Branches
-
-Let’s make it a little more complex.
-
-```rust
-// A
-let (name, set_name) = create_signal(cx, "Alice");
-
-// B
-let name_upper = create_memo(cx, move |_| name.with(|n| n.to_uppercase()));
-
-// C
-let name_len = create_memo(cx, move |_| name.len());
-
-// D
-create_effect(cx, move |_| {
-	log!("len = {}", name_len());
-});
-
-// E
-create_effect(cx, move |_| {
-	log!("name = {}", name_upper());
-});
-```
-
-This is also pretty straightforward: a signal source signal (`name`/`A`) divides into two parallel tracks: `name_upper`/`B` and `name_len`/`C`, each of which has an effect that depends on it.
-
-```
- __A__
-|     |
-B     C
-|     |
-D     E
-```
-
-Now let’s update the signal.
-
-```rust
-set_name("Bob");
-```
-
-We immediately log
-
-```
-len = 3
-name = BOB
-```
-
-Let’s do it again.
-
-```rust
-set_name("Tim");
-```
-
-The log should shows
-
-```
-name = TIM
-```
-
-`len = 3` does not log again.
-
-Remember: the goal of the reactive system is to run effects as infrequently as possible. Changing `name` from `"Bob"` to `"Tim"` will cause each of the memos to re-run. But they will only notify their subscribers if their value has actually changed. `"BOB"` and `"TIM"` are different, so that effect runs again. But both names have the length `3`, so they do not run again.
-
-### Reuniting Branches
-
-One more example, of what’s sometimes called **the diamond problem**.
-
-```rust
-// A
-let (name, set_name) = create_signal(cx, "Alice");
-
-// B
-let name_upper = create_memo(cx, move |_| name.with(|n| n.to_uppercase()));
-
-// C
-let name_len = create_memo(cx, move |_| name.len());
-
-// D
-create_effect(cx, move |_| {
-	log!("{} is {} characters long", name_upper(), name_len());
-});
-```
-
-What does the graph look like for this?
-
-```
- __A__
-|     |
-B     C
-|     |
-|__D__|
-```
-
-You can see why it's called the “diamond problem.” If I’d connected the nodes with straight lines instead of bad ASCII art, it would form a diamond: two memos, each of which depend on a signal, which feed into the same effect.
-
-A naive, push-based reactive implementation would cause this effect to run twice, which would be bad. (Remember, our goal is to run effects as infrequently as we can.) For example, you could implement a reactive system such that signals and memos immediately propagate their changes all the way down the graph, through each dependency, essentially traversing the graph depth-first. In other words, updating `A` would notify `B`, which would notify `D`; then `A` would notify `C`, which would notify `D` again. This is both inefficient (`D` runs twice) and glitchy (`D` actually runs with the incorrect value for the second memo during its first run.)
-
-## Solving the Diamond Problem
-
-Any reactive implementation worth its salt is dedicated to solving this issue. There are a number of different approaches (again, [see Milo’s article](https://dev.to/modderme123/super-charging-fine-grained-reactive-performance-47ph) for an excellent overview).
-
-Here’s how ours works, in brief.
-
-A reactive node is always in one of three states:
-
-- `Clean`: it is known not to have changed
-- `Check`: it is possible it has changed
-- `Dirty`: it has definitely changed
-
-Updating a signal `Dirty` marks that signal `Dirty`, and marks all its descendants `Check`, recursively. Any of its descendants that are effects are added to a queue to be re-run.
-
-```
-    ____A (DIRTY)___
-   |               |
-B (CHECK)    C (CHECK)
-   |               |
-   |____D (CHECK)__|
-```
-
-Now those effects are run. (All of the effects will be marked `Check` at this point.) Before re-running its computation, the effect checks its parents to see if they are dirty. So
-
-- So `D` goes to `B` and checks if it is `Dirty`.
-- But `B` is also marked `Check`. So `B` does the same thing:
-  - `B` goes to `A`, and finds that it is `Dirty`.
-  - This means `B` needs to re-run, because one of its sources has changed.
-  - `B` re-runs, generating a new value, and marks itself `Clean`
-  - Because `B` is a memo, it then checks its prior value against the new value.
-  - If they are the same, `B` returns "no change." Otherwise, it returns "yes, I changed."
-- If `B` returned “yes, I changed,” `D` knows that it definitely needs to run and re-runs immediately before checking any other sources.
-- If `B` returned “no, I didn’t change,” `D` continues on to check `C` (see process above for `B`.)
-- If neither `B` nor `C` has changed, the effect does not need to re-run.
-- If either `B` or `C` did change, the effect now re-runs.
-
-Because the effect is only marked `Check` once and only queued once, it only runs once.
-
-If the naive version was a “push-based” reactive system, simply pushing reactive changes all the way down the graph and therefore running the effect twice, this version could be called “push-pull.” It pushes the `Check` status all the way down the graph, but then “pulls” its way back up. In fact, for large graphs it may end up bouncing back up and down and left and right on the graph as it tries to determine exactly which nodes need to re-run.
-
-**Note this important trade-off**: Push-based reactivity propagates signal changes more quickly, at the expense of over-re-running memos and effects. Remember: the reactive system is designed to minimize how often you re-run effects, on the (accurate) assumption that side effects are orders of magnitude more expensive than this kind of cache-friendly graph traversal happening entirely inside the library’s Rust code. The measurement of a good reactive system is not how quickly it propagates changes, but how quickly it propagates changes _without over-notifying_.
-
-## Memos vs. Signals
-
-Note that signals always notify their children; i.e., a signal is always marked `Dirty` when it updates, even if its new value is the same as the old value. Otherwise, we’d have to require `PartialEq` on signals, and this is actually quite an expensive check on some types. (For example, add an unnecessary equality check to something like `some_vec_signal.update(|n| n.pop())` when it’s clear that it has in fact changed.)
-
-Memos, on the other hand, check whether they change before notifying their children. They only run their calculation once, no matter how many times you `.get()` the result, but they run whenever their signal sources change. This means that if the memo’s computation is _very_ expensive, you may actually want to memoize its inputs as well, so that the memo only re-calculates when it is sure its inputs have changed.
-
-## Memos vs. Derived Signals
-
-All of this is cool, and memos are pretty great. But most actual applications have reactive graphs that are quite shallow and quite wide: you might have 100 source signals and 500 effects, but no memos or, in rare case, three or four memos between the signal and the effect. Memos are extremely good at what they do: limiting how often they notify their subscribers that they have changed. But as this description of the reactive system should show, they come with overhead in two forms:
-
-1. A `PartialEq` check, which may or may not be expensive.
-2. Added memory cost of storing another node in the reactive system.
-3. Added computational cost of reactive graph traversal.
-
-In cases in which the computation itself is cheaper than this reactive work, you should avoid “over-wrapping” with memos and simply use derived signals. Here’s a great example in which you should never use a memo:
-
-```rust
-let (a, set_a) = create_signal(cx, 1);
-// none of these make sense as memos
-let b = move || a() + 2;
-let c = move || b() % 2 == 0;
-let d = move || if c() { "even" } else { "odd" };
-
-set_a(2);
-set_a(3);
-set_a(5);
-```
-
-Even though memoizing would technically save an extra calculation of `d` between setting `a` to `3` and `5`, these calculations are themselves cheaper than the reactive algorithm.
-
-At the very most, you might consider memoizing the final node before running some expensive side effect:
-
-```rust
-let text = create_memo(cx, move |_| {
-  d()
-});
-create_effect(cx, move |_| {
-  engrave_text_into_bar_of_gold(&text());
-});
-```

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

@@ -53,89 +53,3 @@ Resources also provide a `refetch()` method that allows you to manually reload t
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use gloo_timers::future::TimeoutFuture;
-use leptos::*;
-
-// Here we define an async function
-// This could be anything: a network request, database read, etc.
-// Here, we just multiply a number by 10
-async fn load_data(value: i32) -> i32 {
-    // fake a one-second delay
-    TimeoutFuture::new(1_000).await;
-    value * 10
-}
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    // this count is our synchronous, local state
-    let (count, set_count) = create_signal(cx, 0);
-
-    // create_resource takes two arguments after its scope
-    let async_data = create_resource(
-        cx,
-        // the first is the "source signal"
-        count,
-        // the second is the loader
-        // it takes the source signal's value as its argument
-        // and does some async work
-        |value| async move { load_data(value).await },
-    );
-    // whenever the source signal changes, the loader reloads
-
-    // you can also create resources that only load once
-    // just return the unit type () from the source signal
-    // that doesn't depend on anything: we just load it once
-    let stable = create_resource(cx, || (), |_| async move { load_data(1).await });
-
-    // we can access the resource values with .read()
-    // this will reactively return None before the Future has resolved
-    // and update to Some(T) when it has resolved
-    let async_result = move || {
-        async_data
-            .read(cx)
-            .map(|value| format!("Server returned {value:?}"))
-            // This loading state will only show before the first load
-            .unwrap_or_else(|| "Loading...".into())
-    };
-
-    // the resource's loading() method gives us a
-    // signal to indicate whether it's currently loading
-    let loading = async_data.loading();
-    let is_loading = move || if loading() { "Loading..." } else { "Idle." };
-
-    view! { cx,
-        <button
-            on:click=move |_| {
-                set_count.update(|n| *n += 1);
-            }
-        >
-            "Click me"
-        </button>
-        <p>
-            <code>"stable"</code>": " {move || stable.read(cx)}
-        </p>
-        <p>
-            <code>"count"</code>": " {count}
-        </p>
-        <p>
-            <code>"async_value"</code>": "
-            {async_result}
-            <br/>
-            {is_loading}
-        </p>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -69,89 +69,6 @@ Every time one of the resources is reloading, the `"Loading..."` fallback will s
 
 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.
 
-## `<Await/>`
-
-In you’re simply trying to wait for some `Future` to resolve before rendering, you may find the `<Await/>` component helpful in reducing boilerplate. `<Await/>` essentially combines a resource with the source argument `|| ()` with a `<Suspense/>` with no fallback.
-
-In other words:
-
-1. It only polls the `Future` once, and does not respond to any reactive changes.
-2. It does not render anything until the `Future` resolves.
-3. After the `Future` resolves, its binds its data to whatever variable name you choose and then renders its children with that variable in scope.
-
-```rust
-async fn fetch_monkeys(monkey: i32) -> i32 {
-    // maybe this didn't need to be async
-    monkey * 2
-}
-view! { cx,
-    <Await
-        // `future` provides the `Future` to be resolved
-        future=|cx| fetch_monkeys(3)
-        // the data is bound to whatever variable name you provide
-        bind:data
-    >
-        // you receive the data by reference and can use it in your view here
-        <p>{*data} " little monkeys, jumping on the bed."</p>
-    </Await>
-}
-```
-
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use gloo_timers::future::TimeoutFuture;
-use leptos::*;
-
-async fn important_api_call(name: String) -> String {
-    TimeoutFuture::new(1_000).await;
-    name.to_ascii_uppercase()
-}
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    let (name, set_name) = create_signal(cx, "Bill".to_string());
-
-    // this will reload every time `name` changes
-    let async_data = create_resource(
-        cx,
-        name,
-        |name| async move { important_api_call(name).await },
-    );
-
-    view! { cx,
-        <input
-            on:input=move |ev| {
-                set_name(event_target_value(&ev));
-            }
-            prop:value=name
-        />
-        <p><code>"name:"</code> {name}</p>
-        <Suspense
-            // the fallback will show whenever a resource
-            // read "under" the suspense is loading
-            fallback=move || view! { cx, <p>"Loading..."</p> }
-        >
-            // the children will be rendered once initially,
-            // and then whenever any resources has been resolved
-            <p>
-                "Your shouting name is "
-                {move || async_data.read(cx)}
-            </p>
-        </Suspense>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -9,76 +9,3 @@ This example shows how you can create a simple tabbed contact list with `<Transi
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use gloo_timers::future::TimeoutFuture;
-use leptos::*;
-
-async fn important_api_call(id: usize) -> String {
-    TimeoutFuture::new(1_000).await;
-    match id {
-        0 => "Alice",
-        1 => "Bob",
-        2 => "Carol",
-        _ => "User not found",
-    }
-    .to_string()
-}
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    let (tab, set_tab) = create_signal(cx, 0);
-
-    // this will reload every time `tab` changes
-    let user_data = create_resource(cx, tab, |tab| async move { important_api_call(tab).await });
-
-    view! { cx,
-        <div class="buttons">
-            <button
-                on:click=move |_| set_tab(0)
-                class:selected=move || tab() == 0
-            >
-                "Tab A"
-            </button>
-            <button
-                on:click=move |_| set_tab(1)
-                class:selected=move || tab() == 1
-            >
-                "Tab B"
-            </button>
-            <button
-                on:click=move |_| set_tab(2)
-                class:selected=move || tab() == 2
-            >
-                "Tab C"
-            </button>
-            {move || if user_data.loading().get() {
-                "Loading..."
-            } else {
-                ""
-            }}
-        </div>
-        <Transition
-            // the fallback will show initially
-            // on subsequent reloads, the current child will
-            // continue showing
-            fallback=move || view! { cx, <p>"Loading..."</p> }
-        >
-            <p>
-                {move || user_data.read(cx)}
-            </p>
-        </Transition>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -94,83 +94,3 @@ Now, there’s a chance this all seems a little over-complicated, or maybe too r
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use gloo_timers::future::TimeoutFuture;
-use leptos::{html::Input, *};
-use uuid::Uuid;
-
-// Here we define an async function
-// This could be anything: a network request, database read, etc.
-// Think of it as a mutation: some imperative async action you run,
-// whereas a resource would be some async data you load
-async fn add_todo(text: &str) -> Uuid {
-    _ = text;
-    // fake a one-second delay
-    TimeoutFuture::new(1_000).await;
-    // pretend this is a post ID or something
-    Uuid::new_v4()
-}
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    // an action takes an async function with single argument
-    // it can be a simple type, a struct, or ()
-    let add_todo = create_action(cx, |input: &String| {
-        // the input is a reference, but we need the Future to own it
-        // this is important: we need to clone and move into the Future
-        // so it has a 'static lifetime
-        let input = input.to_owned();
-        async move { add_todo(&input).await }
-    });
-
-    // actions provide a bunch of synchronous, reactive variables
-    // that tell us different things about the state of the action
-    let submitted = add_todo.input();
-    let pending = add_todo.pending();
-    let todo_id = add_todo.value();
-
-    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>
-        <p>{move || pending().then(|| "Loading...")}</p>
-        <p>
-            "Submitted: "
-            <code>{move || format!("{:#?}", submitted())}</code>
-        </p>
-        <p>
-            "Pending: "
-            <code>{move || format!("{:#?}", pending())}</code>
-        </p>
-        <p>
-            "Todo ID: "
-            <code>{move || format!("{:#?}", todo_id())}</code>
-        </p>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-```
-
-</details>
-</preview>

docs/book/src/deployment.md

@@ -1,74 +0,0 @@
-# Deployment
-
-There are as many ways to deploy a web application as there are developers, let alone applications. But there are a couple useful tips to keep in mind when deploying an app.
-
-## General Advice
-
-1. Remember: Always deploy Rust apps built in `--release` mode, not debug mode. This has a huge effect on both performance and binary size.
-2. Test locally in release mode as well. The framework applies certain optimizations in release mode that it does not apply in debug mode, so it’s possible for bugs to surface at this point. (If your app behaves differently or you do encounter a bug, it’s likely a framework-level bug and you should open a GitHub issue with a reproduction.)
-
-> We asked users to submit their deployment setups to help with this chapter. I’ll quote from them below, but you can read the full thread [here](https://github.com/leptos-rs/leptos/issues/1152).
-
-## Deploying a Client-Side-Rendered App
-
-If you’ve been building an app that only uses client-side rendering, working with Trunk as a dev server and build tool, the process is quite easy.
-
-```bash
-trunk build --release
-```
-
-`trunk build` will create a number of build artifacts in a `dist/` directory. Publishing `dist` somewhere online should be all you need to deploy your app. This should work very similarly to deploying any JavaScript application.
-
-> Read more: [Deploying to Vercel with GitHub Actions](https://github.com/leptos-rs/leptos/issues/1152#issuecomment-1577861900).
-
-## Deploying a Full-Stack App
-
-The most popular way for people to deploy full-stack apps built with `cargo-leptos` is to use a cloud hosting service that supports deployment via a Docker build. Here’s a sample `Dockerfile`, which is based on the one we use to deploy the Leptos website.
-
-```dockerfile
-# Get started with a build env with Rust nightly
-FROM rustlang/rust:nightly-bullseye as builder
-
-# If you’re using stable, use this instead
-# FROM rust:1.70-bullseye as builder
-
-# Install cargo-binstall, which makes it easier to install other
-# cargo extensions like cargo-leptos
-RUN wget https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz
-RUN tar -xvf cargo-binstall-x86_64-unknown-linux-musl.tgz
-RUN cp cargo-binstall /usr/local/cargo/bin
-
-# Install cargo-leptos
-RUN cargo binstall cargo-leptos -y
-
-# Add the WASM target
-RUN rustup target add wasm32-unknown-unknown
-
-# Make an /app dir, which everything will eventually live in
-RUN mkdir -p /app
-WORKDIR /app
-COPY . .
-
-# Build the app
-RUN cargo leptos build --release -vv
-
-FROM rustlang/rust:nightly-bullseye as runner
-# Copy the server binary to the /app directory
-COPY --from=builder /app/target/server/release/leptos_website /app/
-# /target/site contains our JS/WASM/CSS, etc.
-COPY --from=builder /app/target/site /app/site
-# Copy Cargo.toml if it’s needed at runtime
-COPY --from=builder /app/Cargo.toml /app/
-WORKDIR /app
-
-# Set any required env variables and
-ENV RUST_LOG="info"
-ENV APP_ENVIRONMENT="production"
-ENV LEPTOS_SITE_ADDR="0.0.0.0:8080"
-ENV LEPTOS_SITE_ROOT="site"
-EXPOSE 8080
-# Run the server
-CMD ["/app/leptos_website"]
-```
-
-> Read more: [`gnu` and `musl` build files for Leptos apps](https://github.com/leptos-rs/leptos/issues/1152#issuecomment-1634916088).

docs/book/src/reactivity/14_create_effect.md

@@ -109,226 +109,6 @@ create_effect(cx, move |prev_value| {
 
 Every time `count` is updated, this effect wil rerun. This is what allows reactive, fine-grained updates to the DOM.
 
-## Explicit, Cancelable Tracking with `watch`
-
-In addition to `create_effect`, Leptos provides a [`watch`](https://docs.rs/leptos_reactive/latest/leptos_reactive/fn.watch.html) function, which can be used for two main purposes:
-
-1. Separating tracking and responding to changes by explicitly passing in a set of values to track.
-2. Canceling tracking by calling a stop function.
-
-Like `create_resource`, `watch` takes a first argument, which is reactively tracked, and a second, which is not. Whenever a reactive value in its `deps` argument is changed, the `callback` is run. `watch` returns a function that can be called to stop tracking the dependencies.
-
-```rust
-let (num, set_num) = create_signal(cx, 0);
-
-let stop = watch(
-    cx,
-    move || num.get(),
-    move |num, prev_num, _| {
-        log::debug!("Number: {}; Prev: {:?}", num, prev_num);
-    },
-    false,
-);
-
-set_num.set(1); // > "Number: 1; Prev: Some(0)"
-
-stop(); // stop watching
-
-set_num.set(2); // (nothing happens)
-```
-
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::html::Input;
-use leptos::*;
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    // Just making a visible log here
-    // You can ignore this...
-    let log = create_rw_signal::<Vec<String>>(cx, vec![]);
-    let logged = move || log().join("\n");
-    provide_context(cx, log);
-
-    view! { cx,
-        <CreateAnEffect/>
-        <pre>{logged}</pre>
-    }
-}
-
-#[component]
-fn CreateAnEffect(cx: Scope) -> impl IntoView {
-    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()
-            },
-        )
-    });
-
-    view! { cx,
-        <h1><code>"create_effect"</code> " Version"</h1>
-        <form>
-            <label>
-                "First Name"
-                <input type="text" name="first" prop:value=first
-                    on:change=move |ev| set_first(event_target_value(&ev))
-                />
-            </label>
-            <label>
-                "Last Name"
-                <input type="text" name="last" prop:value=last
-                    on:change=move |ev| set_last(event_target_value(&ev))
-                />
-            </label>
-            <label>
-                "Show Last Name"
-                <input type="checkbox" name="use_last" prop:checked=use_last
-                    on:change=move |ev| set_use_last(event_target_checked(&ev))
-                />
-            </label>
-        </form>
-    }
-}
-
-#[component]
-fn ManualVersion(cx: Scope) -> impl IntoView {
-    let first = create_node_ref::<Input>(cx);
-    let last = create_node_ref::<Input>(cx);
-    let use_last = create_node_ref::<Input>(cx);
-
-    let mut prev_name = String::new();
-    let on_change = move |_| {
-        log(cx, "      listener");
-        let first = first.get().unwrap();
-        let last = last.get().unwrap();
-        let use_last = use_last.get().unwrap();
-        let this_one = if use_last.checked() {
-            format!("{} {}", first.value(), last.value())
-        } else {
-            first.value()
-        };
-
-        if this_one != prev_name {
-            log(cx, &this_one);
-            prev_name = this_one;
-        }
-    };
-
-    view! { cx,
-        <h1>"Manual Version"</h1>
-        <form on:change=on_change>
-            <label>
-                "First Name"
-                <input type="text" name="first"
-                    node_ref=first
-                />
-            </label>
-            <label>
-                "Last Name"
-                <input type="text" name="last"
-                    node_ref=last
-                />
-            </label>
-            <label>
-                "Show Last Name"
-                <input type="checkbox" name="use_last"
-                    checked
-                    node_ref=use_last
-                />
-            </label>
-        </form>
-    }
-}
-
-#[component]
-fn EffectVsDerivedSignal(cx: Scope) -> impl IntoView {
-    let (my_value, set_my_value) = create_signal(cx, String::new());
-    // Don't do this.
-    /*let (my_optional_value, set_optional_my_value) = create_signal(cx, Option::<String>::None);
-
-    create_effect(cx, move |_| {
-        if !my_value.get().is_empty() {
-            set_optional_my_value(Some(my_value.get()));
-        } else {
-            set_optional_my_value(None);
-        }
-    });*/
-
-    // Do this
-    let my_optional_value =
-        move || (!my_value.with(String::is_empty)).then(|| Some(my_value.get()));
-
-    view! { cx,
-        <input
-            prop:value=my_value
-            on:input= move |ev| set_my_value(event_target_value(&ev))
-        />
-
-        <p>
-            <code>"my_optional_value"</code>
-            " is "
-            <code>
-                <Show
-                    when=move || my_optional_value().is_some()
-                    fallback=|cx| view! { cx, "None" }
-                >
-                    "Some(\"" {my_optional_value().unwrap()} "\")"
-                </Show>
-            </code>
-        </p>
-    }
-}
-
-/*#[component]
-pub fn Show<F, W, IV>(
-    /// The scope the component is running in
-    cx: Scope,
-    /// The components Show wraps
-    children: Box<dyn Fn(Scope) -> Fragment>,
-    /// A closure that returns a bool that determines whether this thing runs
-    when: W,
-    /// A closure that returns what gets rendered if the when statement is false
-    fallback: F,
-) -> impl IntoView
-where
-    W: Fn() -> bool + 'static,
-    F: Fn(Scope) -> IV + 'static,
-    IV: IntoView,
-{
-    let memoized_when = create_memo(cx, move |_| when());
-
-    move || match memoized_when.get() {
-        true => children(cx).into_view(cx),
-        false => fallback(cx).into_view(cx),
-    }
-}*/
-
-fn log(cx: Scope, msg: impl std::fmt::Display) {
-    let log = use_context::<RwSignal<Vec<String>>>(cx).unwrap();
-    log.update(|log| log.push(msg.to_string()));
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

docs/book/src/reactivity/interlude_functions.md

@@ -68,7 +68,7 @@ pub fn SimpleCounter(cx: Scope) -> impl IntoView {
 
 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 response to a change.
+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:
 

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

@@ -24,7 +24,7 @@ use leptos_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 one decides what to do when the URL changes?
+> 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:
 
@@ -87,17 +87,15 @@ The `view` is a function that takes a `Scope` and returns a view.
 
 ```rust
 <Routes>
-  <Route path="/" view=Home/>
-  <Route path="/users" view=Users/>
-  <Route path="/users/:id" view=UserProfile/>
-  <Route path="/*any" view=NotFound/>
+  <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>
 ```
 
-> `view` takes a `Fn(Scope) -> impl IntoView`. If a component has no props, it is a function that takes `Scope` and returns `impl IntoView`, so it can be passed directly into the `view`. In this case, `view=Home` is just a shorthand for `|cx| view! { cx, <Home/> }`.
+> 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.
 
-Note that you can define your routes in any order. The router scores each route to see how good a match it is, rather than simply trying to match them top to bottom.
-
 Simple enough?

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

@@ -4,10 +4,10 @@ We just defined the following set of routes:
 
 ```rust
 <Routes>
-  <Route path="/" view=Home/>
-  <Route path="/users" view=Users/>
-  <Route path="/users/:id" view=UserProfile/>
-  <Route path="/*any" view=NotFound/>
+  <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>
 ```
 
@@ -17,11 +17,11 @@ Well... you can!
 
 ```rust
 <Routes>
-  <Route path="/" view=Home/>
-  <Route path="/users" view=Users>
-    <Route path=":id" view=UserProfile/>
+  <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=NotFound/>
+  <Route path="/*any" view=|cx| view! { cx, <NotFound /> }/>
 </Routes>
 ```
 
@@ -39,8 +39,8 @@ Let’s look back at our practical example.
 
 ```rust
 <Routes>
-  <Route path="/users" view=Users/>
-  <Route path="/users/:id" view=UserProfile/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }/>
+  <Route path="/users/:id" view=|cx| view! { cx, <UserProfile /> }/>
 </Routes>
 ```
 
@@ -53,8 +53,8 @@ Let’s say I use nested routes instead:
 
 ```rust
 <Routes>
-  <Route path="/users" view=Users>
-    <Route path=":id" view=UserProfile/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }>
+    <Route path=":id" view=|cx| view! { cx, <UserProfile /> }/>
   </Route>
 </Routes>
 ```
@@ -68,9 +68,9 @@ I actually need to add a fallback route
 
 ```rust
 <Routes>
-  <Route path="/users" view=Users>
-    <Route path=":id" view=UserProfile/>
-    <Route path="" view=NoUser/>
+  <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>
 ```
@@ -94,8 +94,8 @@ You can easily define this with nested routes
 
 ```rust
 <Routes>
-  <Route path="/contacts" view=ContactList>
-    <Route path=":id" view=ContactInfo/>
+  <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>
     }/>
@@ -107,11 +107,11 @@ You can go even deeper. Say you want to have tabs for each contact’s address,
 
 ```rust
 <Routes>
-  <Route path="/contacts" view=ContactList>
-    <Route path=":id" view=ContactInfo>
-      <Route path="" view=EmailAndPhone/>
-      <Route path="address" view=Address/>
-      <Route path="messages" view=Messages/>
+  <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>
@@ -124,7 +124,7 @@ You can go even deeper. Say you want to have tabs for each contact’s address,
 
 ## `<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 it at the end of the parent component” is not a great answer.
+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:
 
@@ -170,118 +170,3 @@ In fact, in this case, we don’t even need to rerender the `<Contact/>` compone
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-use leptos_router::*;
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <Router>
-            <h1>"Contact App"</h1>
-            // this <nav> will show on every routes,
-            // because it's outside the <Routes/>
-            // note: we can just use normal <a> tags
-            // and the router will use client-side navigation
-            <nav>
-                <h2>"Navigation"</h2>
-                <a href="/">"Home"</a>
-                <a href="/contacts">"Contacts"</a>
-            </nav>
-            <main>
-                <Routes>
-                    // / just has an un-nested "Home"
-                    <Route path="/" view=|cx| view! { cx,
-                        <h3>"Home"</h3>
-                    }/>
-                    // /contacts has nested routes
-                    <Route
-                        path="/contacts"
-                        view=ContactList
-                        // if no id specified, fall back
-                        <Route path=":id" view=ContactInfo>
-                            <Route path="" view=|cx| view! { cx,
-                                <div class="tab">
-                                    "(Contact Info)"
-                                </div>
-                            }/>
-                            <Route path="conversations" view=|cx| view! { cx,
-                                <div class="tab">
-                                    "(Conversations)"
-                                </div>
-                            }/>
-                        </Route>
-                        // if no id specified, fall back
-                        <Route path="" view=|cx| view! { cx,
-                            <div class="select-user">
-                                "Select a user to view contact info."
-                            </div>
-                        }/>
-                    </Route>
-                </Routes>
-            </main>
-        </Router>
-    }
-}
-
-#[component]
-fn ContactList(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <div class="contact-list">
-            // here's our contact list component itself
-            <div class="contact-list-contacts">
-                <h3>"Contacts"</h3>
-                <A href="alice">"Alice"</A>
-                <A href="bob">"Bob"</A>
-                <A href="steve">"Steve"</A>
-            </div>
-
-            // <Outlet/> will show the nested child route
-            // we can position this outlet wherever we want
-            // within the layout
-            <Outlet/>
-        </div>
-    }
-}
-
-#[component]
-fn ContactInfo(cx: Scope) -> impl IntoView {
-    // we can access the :id param reactively with `use_params_map`
-    let params = use_params_map(cx);
-    let id = move || params.with(|params| params.get("id").cloned().unwrap_or_default());
-
-    // imagine we're loading data from an API here
-    let name = move || match id().as_str() {
-        "alice" => "Alice",
-        "bob" => "Bob",
-        "steve" => "Steve",
-        _ => "User not found.",
-    };
-
-    view! { cx,
-        <div class="contact-info">
-            <h4>{name}</h4>
-            <div class="tabs">
-                <A href="" exact=true>"Contact Info"</A>
-                <A href="conversations">"Conversations"</A>
-            </div>
-
-            // <Outlet/> here is the tabs that are nested
-            // underneath the /contacts/:id route
-            <Outlet/>
-        </div>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -36,14 +36,6 @@ struct ContactSearch {
 ```
 
 > 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.
->
-> If you are not using the `nightly` feature, you will get the error
->
-> ```
-> no function or associated item named `into_param` found for struct `std::string::String` in the current scope
-> ```
->
-> At the moment, supporting both `T: FromStr` and `Option<T>` for typed params requires a nightly feature. You can fix this by simply changing the struct to use `q: Option<String>` instead of `q: String`.
 
 Now we can use them in a component. Imagine a URL that has both params and a query, like `/contacts/:id?q=Search`.
 
@@ -78,126 +70,10 @@ let id = move || {
 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 replace or rerender the wrapping `<Contact/>`. This is what fine-grained reactivity is for.
+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 explained them all yet.
+> 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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-use leptos_router::*;
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <Router>
-            <h1>"Contact App"</h1>
-            // this <nav> will show on every routes,
-            // because it's outside the <Routes/>
-            // note: we can just use normal <a> tags
-            // and the router will use client-side navigation
-            <nav>
-                <h2>"Navigation"</h2>
-                <a href="/">"Home"</a>
-                <a href="/contacts">"Contacts"</a>
-            </nav>
-            <main>
-                <Routes>
-                    // / just has an un-nested "Home"
-                    <Route path="/" view=|cx| view! { cx,
-                        <h3>"Home"</h3>
-                    }/>
-                    // /contacts has nested routes
-                    <Route
-                        path="/contacts"
-                        view=ContactList
-                    >
-                        // if no id specified, fall back
-                        <Route path=":id" view=ContactInfo>
-                            <Route path="" view=|cx| view! { cx,
-                                <div class="tab">
-                                    "(Contact Info)"
-                                </div>
-                            }/>
-                            <Route path="conversations" view=|cx| view! { cx,
-                                <div class="tab">
-                                    "(Conversations)"
-                                </div>
-                            }/>
-                        </Route>
-                        // if no id specified, fall back
-                        <Route path="" view=|cx| view! { cx,
-                            <div class="select-user">
-                                "Select a user to view contact info."
-                            </div>
-                        }/>
-                    </Route>
-                </Routes>
-            </main>
-        </Router>
-    }
-}
-
-#[component]
-fn ContactList(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <div class="contact-list">
-            // here's our contact list component itself
-            <div class="contact-list-contacts">
-                <h3>"Contacts"</h3>
-                <A href="alice">"Alice"</A>
-                <A href="bob">"Bob"</A>
-                <A href="steve">"Steve"</A>
-            </div>
-
-            // <Outlet/> will show the nested child route
-            // we can position this outlet wherever we want
-            // within the layout
-            <Outlet/>
-        </div>
-    }
-}
-
-#[component]
-fn ContactInfo(cx: Scope) -> impl IntoView {
-    // we can access the :id param reactively with `use_params_map`
-    let params = use_params_map(cx);
-    let id = move || params.with(|params| params.get("id").cloned().unwrap_or_default());
-
-    // imagine we're loading data from an API here
-    let name = move || match id().as_str() {
-        "alice" => "Alice",
-        "bob" => "Bob",
-        "steve" => "Steve",
-        _ => "User not found.",
-    };
-
-    view! { cx,
-        <div class="contact-info">
-            <h4>{name}</h4>
-            <div class="tabs">
-                <A href="" exact=true>"Contact Info"</A>
-                <A href="conversations">"Conversations"</A>
-            </div>
-
-            // <Outlet/> here is the tabs that are nested
-            // underneath the /contacts/:id route
-            <Outlet/>
-        </div>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -11,145 +11,13 @@ The router will bail out of handling an `<a>` click under a number of situations
 
 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.
 
-> This also means that if you need to opt out of client-side routing, you can do so easily. For example, if you have a link to another page on the same domain, but which isn’t part of your Leptos app, you can just use `<a rel="external">` to tell the router it isn’t something it can handle.
-
 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.
 
-## Navigating Programmatically
-
-Your most-used methods of navigating between pages should be with `<a>` and `<form>` elements or with the enhanced `<A/>` and `<Form/>` components. Using links and forms to navigate is the best solution for accessibility and graceful degradation.
-
-On occasion, though, you’ll want to navigate programmatically, i.e., call a function that can navigate to a new page. In that case, you should use the [`use_navigate`](https://docs.rs/leptos_router/latest/leptos_router/fn.use_navigate.html) function.
-```rust
-let navigate = leptos_router::use_navigate(cx);
-navigate("/somewhere", Default::default());
-```
-
-> You should almost never do something like `<button on:click=move |_| navigate(/* ... */)>`. Any `on:click` that navigates should be an `<a>`, for reasons of accessibility.
-
-The second argument here is a set of [`NavigateOptions`](https://docs.rs/leptos_router/latest/leptos_router/struct.NavigateOptions.html), which includes options to resolve the navigation relative to the current route as the `<A/>` component does, replace it in the navigation stack, include some navigation state, and maintain the current scroll state on navigation.
-
 > 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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-use leptos_router::*;
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <Router>
-            <h1>"Contact App"</h1>
-            // this <nav> will show on every routes,
-            // because it's outside the <Routes/>
-            // note: we can just use normal <a> tags
-            // and the router will use client-side navigation
-            <nav>
-                <h2>"Navigation"</h2>
-                <a href="/">"Home"</a>
-                <a href="/contacts">"Contacts"</a>
-            </nav>
-            <main>
-                <Routes>
-                    // / just has an un-nested "Home"
-                    <Route path="/" view=|cx| view! { cx,
-                        <h3>"Home"</h3>
-                    }/>
-                    // /contacts has nested routes
-                    <Route
-                        path="/contacts"
-                        view=ContactList
-                    >
-                        // if no id specified, fall back
-                        <Route path=":id" view=ContactInfo>
-                            <Route path="" view=|cx| view! { cx,
-                                <div class="tab">
-                                    "(Contact Info)"
-                                </div>
-                            }/>
-                            <Route path="conversations" view=|cx| view! { cx,
-                                <div class="tab">
-                                    "(Conversations)"
-                                </div>
-                            }/>
-                        </Route>
-                        // if no id specified, fall back
-                        <Route path="" view=|cx| view! { cx,
-                            <div class="select-user">
-                                "Select a user to view contact info."
-                            </div>
-                        }/>
-                    </Route>
-                </Routes>
-            </main>
-        </Router>
-    }
-}
-
-#[component]
-fn ContactList(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <div class="contact-list">
-            // here's our contact list component itself
-            <div class="contact-list-contacts">
-                <h3>"Contacts"</h3>
-                <A href="alice">"Alice"</A>
-                <A href="bob">"Bob"</A>
-                <A href="steve">"Steve"</A>
-            </div>
-
-            // <Outlet/> will show the nested child route
-            // we can position this outlet wherever we want
-            // within the layout
-            <Outlet/>
-        </div>
-    }
-}
-
-#[component]
-fn ContactInfo(cx: Scope) -> impl IntoView {
-    // we can access the :id param reactively with `use_params_map`
-    let params = use_params_map(cx);
-    let id = move || params.with(|params| params.get("id").cloned().unwrap_or_default());
-
-    // imagine we're loading data from an API here
-    let name = move || match id().as_str() {
-        "alice" => "Alice",
-        "bob" => "Bob",
-        "steve" => "Steve",
-        _ => "User not found.",
-    };
-
-    view! { cx,
-        <div class="contact-info">
-            <h4>{name}</h4>
-            <div class="tabs">
-                <A href="" exact=true>"Contact Info"</A>
-                <A href="conversations">"Conversations"</A>
-            </div>
-
-            // <Outlet/> here is the tabs that are nested
-            // underneath the /contacts/:id route
-            <Outlet/>
-        </div>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -1,12 +1,12 @@
 # The `<Form/>` Component
 
-Links and forms sometimes seem completely unrelated. But, in fact, they work in very similar ways.
+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.
+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.
 
@@ -65,117 +65,3 @@ You’ll notice that this version drops the `Submit` button. Instead, we add an
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-use leptos_router::*;
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <Router>
-            <h1><code>"<Form/>"</code></h1>
-            <main>
-                <Routes>
-                    <Route path="" view=FormExample/>
-                </Routes>
-            </main>
-        </Router>
-    }
-}
-
-#[component]
-pub fn FormExample(cx: Scope) -> impl IntoView {
-    // reactive access to URL query
-    let query = use_query_map(cx);
-    let name = move || query().get("name").cloned().unwrap_or_default();
-    let number = move || query().get("number").cloned().unwrap_or_default();
-    let select = move || query().get("select").cloned().unwrap_or_default();
-
-    view! { cx,
-        // read out the URL query strings
-        <table>
-            <tr>
-                <td><code>"name"</code></td>
-                <td>{name}</td>
-            </tr>
-            <tr>
-                <td><code>"number"</code></td>
-                <td>{number}</td>
-            </tr>
-            <tr>
-                <td><code>"select"</code></td>
-                <td>{select}</td>
-            </tr>
-        </table>
-        // <Form/> will navigate whenever submitted
-        <h2>"Manual Submission"</h2>
-        <Form method="GET" action="">
-            // input names determine query string key
-            <input type="text" name="name" value=name/>
-            <input type="number" name="number" value=number/>
-            <select name="select">
-                // `selected` will set which starts as selected
-                <option selected=move || select() == "A">
-                    "A"
-                </option>
-                <option selected=move || select() == "B">
-                    "B"
-                </option>
-                <option selected=move || select() == "C">
-                    "C"
-                </option>
-            </select>
-            // submitting should cause a client-side
-            // navigation, not a full reload
-            <input type="submit"/>
-        </Form>
-        // This <Form/> uses some JavaScript to submit
-        // on every input
-        <h2>"Automatic Submission"</h2>
-        <Form method="GET" action="">
-            <input
-                type="text"
-                name="name"
-                value=name
-                // this oninput attribute will cause the
-                // form to submit on every input to the field
-                oninput="this.form.requestSubmit()"
-            />
-            <input
-                type="number"
-                name="number"
-                value=number
-                oninput="this.form.requestSubmit()"
-            />
-            <select name="select"
-                onchange="this.form.requestSubmit()"
-            >
-                <option selected=move || select() == "A">
-                    "A"
-                </option>
-                <option selected=move || select() == "B">
-                    "B"
-                </option>
-                <option selected=move || select() == "C">
-                    "C"
-                </option>
-            </select>
-            // submitting should cause a client-side
-            // navigation, not a full reload
-            <input type="submit"/>
-        </Form>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

docs/book/src/server/25_server_functions.md

@@ -113,7 +113,7 @@ Server functions are a cool technology, but it’s very important to remember. *
 
 So far, everything I’ve said is actually framework agnostic. (And in fact, the Leptos server function crate has been integrated into Dioxus as well!) Server functions are simply a way of defining a function-like RPC call that leans on Web standards like HTTP requests and URL encoding.
 
-But in a way, they also provide the last missing primitive in our story so far. Because a server function is just a plain Rust async function, it integrates perfectly with the async Leptos primitives we discussed [earlier](https://leptos-rs.github.io/leptos/async/index.html). So you can easily integrate your server functions with the rest of your applications:
+But in a way, they also provide the last missing primitive in our story so far. Because a server function is just a plain Rust async function, it integrates perfectly with the async Leptos primitives we discussed [earlier](../async/README.md). So you can easily integrate your server functions with the rest of your applications:
 
 - Create **resources** that call the server function to load data from the server
 - Read these resources under `<Suspense/>` or `<Transition/>` to enable streaming SSR and fallback states while data loads.

docs/book/src/server/26_extractors.md

@@ -6,9 +6,9 @@ The server functions we looked at in the last chapter showed how to run code on
 
 We call Leptos a “full-stack” framework, but “full-stack” is always a misnomer (after all, it never means everything from the browser to your power company.) For us, “full stack” means that your Leptos app can run in the browser, and can run on the server, and can integrate the two, drawing together the unique features available in each; as we’ve seen in the book so far, a button click on the browser can drive a database read on the server, both written in the same Rust module. But Leptos itself doesn’t provide the server (or the database, or the operating system, or the firmware, or the electrical cables...)
 
-Instead, Leptos provides integrations for the two most popular Rust web server frameworks, Actix Web ([`leptos_actix`](https://docs.rs/leptos_actix/latest/leptos_actix/)) and Axum ([`leptos_axum`](https://docs.rs/leptos_axum/latest/leptos_axum/)). We’ve built integrations with each server’s router so that you can simply plug your Leptos app into an existing server with `.leptos_routes()`, and easily handle server function calls.
+Instead, Leptos provides integrations for the two most popular Rust web server frameworks, Actix Web ([`leptos_actix`](https://docs.rs/leptos_actix/latest/leptos_actix/)) and Axum ([`leptos_axum`](https://docs.rs/leptos_actix/latest/leptos_axum/)). We’ve built integrations with each server’s router so that you can simply plug your Leptos app into an existing server with `.leptos_routes()`, and easily handle server function calls.
 
-> If you haven’t seen our [Actix](https://github.com/leptos-rs/start) and [Axum](https://github.com/leptos-rs/start-axum) templates, now’s a good time to check them out.
+> If haven’t seen our [Actix](https://github.com/leptos-rs/start) and [Axum](https://github.com/leptos-rs/start-axum) templates, now’s a good time to check them out.
 
 ## Using Extractors
 
@@ -43,7 +43,7 @@ pub async fn actix_extract(cx: Scope) -> Result<String, ServerFnError> {
 
 ## Axum Extractors
 
-The syntax for the [`leptos_axum::extract`](https://docs.rs/leptos_axum/latest/leptos_axum/fn.extract.html) function is very similar. (**Note**: This is available on the git main branch, but has not been released as of writing.) Note that Axum extractors return a `Result`, so you’ll need to add something to handle the error case.
+The syntax for the `leptos_axum::extract` function is very similar. (**Note**: This is available on the git main branch, but has not been released as of writing.) Note that Axum extractors return a `Result`, so you’ll need to add something to handle the error case.
 
 ```rust
 #[server(AxumExtract, "/api")]
@@ -62,22 +62,6 @@ pub async fn axum_extract(cx: Scope) -> Result<String, ServerFnError> {
 
 These are relatively simple examples accessing basic data from the server. But you can use extractors to access things like headers, cookies, database connection pools, and more, using the exact same `extract()` pattern.
 
-The Axum `extract` function only supports extractors for which the state is `()`. If you need an extractor that uses `State`, you should use [`extract_with_state`](https://docs.rs/leptos_axum/latest/leptos_axum/fn.extract_with_state.html). This requires you to provide the state. You can do this by extending the existing `LeptosOptions` state using the Axum `FromRef` pattern, which providing the state as context during render and server functions with custom handlers.
-
-```rust
-use axum::extract::FromRef;
-
-/// Derive FromRef to allow multiple items in state, using Axum’s
-/// SubStates pattern.
-#[derive(FromRef, Debug, Clone)]
-pub struct AppState{
-    pub leptos_options: LeptosOptions,
-    pub pool: SqlitePool
-}
-```
-
-[Click here for an example of providing context in custom handlers](https://github.com/leptos-rs/leptos/blob/19ea6fae6aec2a493d79cc86612622d219e6eebb/examples/session_auth_axum/src/main.rs#L24-L44).
-
 ## A Note about Data-Loading Patterns
 
 Because Actix and (especially) Axum are built on the idea of a single round-trip HTTP request and response, you typically run extractors near the “top” of your application (i.e., before you start rendering) and use the extracted data to determine how that should be rendered. Before you render a `<button>`, you load all the data your app could need. And any given route handler needs to know all the data that will need to be extracted by that route.

docs/book/src/server/27_response.md

@@ -1,74 +1 @@
 # Responses and Redirects
-
-Extractors provide an easy way to access request data inside server functions. Leptos also provides a way to modify the HTTP response, using the `ResponseOptions` type (see docs for [Actix](https://docs.rs/leptos_actix/latest/leptos_actix/struct.ResponseOptions.html) or [Axum](https://docs.rs/leptos_axum/latest/leptos_axum/struct.ResponseOptions.html)) types and the `redirect` helper function (see docs for [Actix](https://docs.rs/leptos_actix/latest/leptos_actix/fn.redirect.html) or [Axum](https://docs.rs/leptos_axum/latest/leptos_axum/fn.redirect.html)).
-
-## `ResponseOptions`
-
-`ResponseOptions` is provided via context during the initial server rendering response and during any subsequent server function call. It allows you to easily set the status code for the HTTP response, or to add headers to the HTTP response, e.g., to set cookies.
-
-```rust
-#[server(TeaAndCookies)]
-pub async fn tea_and_cookies(cx: Scope) -> Result<(), ServerFnError> {
-	use actix_web::{cookie::Cookie, http::header, http::header::HeaderValue};
-	use leptos_actix::ResponseOptions;
-
-	// pull ResponseOptions from context
-	let response = expect_context::<ResponseOptions>(cx);
-
-	// set the HTTP status code
-	response.set_status(StatusCode::IM_A_TEAPOT);
-
-	// set a cookie in the HTTP response
-	let mut cookie = Cookie::build("biscuits", "yes").finish();
-	if let Ok(cookie) = HeaderValue::from_str(&cookie.to_string()) {
-		res.insert_header(header::SET_COOKIE, cookie);
-	}
-}
-```
-
-## `redirect`
-
-One common modification to an HTTP response is to redirect to another page. The Actix and Axum integrations provide a `redirect` function to make this easy to do. `redirect` simply sets an HTTP status code of `302 Found` and sets the `Location` header.
-
-Here’s a simplified example from our [`session_auth_axum` example](https://github.com/leptos-rs/leptos/blob/a5f73b441c079f9138102b3a7d8d4828f045448c/examples/session_auth_axum/src/auth.rs#L154-L181).
-
-```rust
-#[server(Login, "/api")]
-pub async fn login(
-    cx: Scope,
-    username: String,
-    password: String,
-    remember: Option<String>,
-) -> Result<(), ServerFnError> {
-	// pull the DB pool and auth provider from context
-    let pool = pool(cx)?;
-    let auth = auth(cx)?;
-
-	// check whether the user exists
-    let user: User = User::get_from_username(username, &pool)
-        .await
-        .ok_or_else(|| {
-            ServerFnError::ServerError("User does not exist.".into())
-        })?;
-
-	// check whether the user has provided the correct password
-    match verify(password, &user.password)? {
-		// if the password is correct...
-        true => {
-			// log the user in
-            auth.login_user(user.id);
-            auth.remember_user(remember.is_some());
-
-			// and redirect to the home page
-            leptos_axum::redirect(cx, "/");
-            Ok(())
-        }
-		// if not, return an error
-        false => Err(ServerFnError::ServerError(
-            "Password does not match.".to_string(),
-        )),
-    }
-}
-```
-
-This server function can then be used from your application. This `redirect` works well with the progressively-enhanced `<ActionForm/>` component: without JS/WASM, the server response will redirect because of the status code and header. With JS/WASM, the `<ActionForm/>` will detect the redirect in the server function response, and use client-side navigation to redirect to the new page.

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

@@ -8,12 +8,7 @@ If you’ve ever listened to streaming music or watched a video online, I’m su
 
 Let me say a little more about what I mean.
 
-Leptos supports all four different modes of rendering HTML that includes asynchronous data:
-
-1. [Synchronous Rendering](#synchronous-rendering)
-1. [Async Rendering](#async-rendering)
-1. [In-Order streaming](#in-order-streaming)
-1. [Out-of-Order Streaming](#out-of-order-streaming)
+Leptos supports all four different of these different ways to render HTML that includes asynchronous data.
 
 ## Synchronous Rendering
 
@@ -69,7 +64,7 @@ If you’re using server-side rendering, the synchronous mode is almost never wh
 
 5. **Partially-blocked streaming**: “Partially-blocked” streaming is useful when you have multiple separate `<Suspense/>` components on the page. If one of them reads from one or more “blocking resources” (see below), the fallback will not be sent; rather, the server will wait until that `<Suspense/>` has resolved and then replace the fallback with the resolved fragment on the server, which means that it is included in the initial HTML response and appears even if JavaScript is disabled or not supported. Other `<Suspense/>` stream in out of order as usual.
 
-This is useful when you have multiple `<Suspense/>` on the page, and one is more important than the other: think of a blog post and comments, or product information and reviews. It is _not_ useful if there’s only one `<Suspense/>`, or if every `<Suspense/>` reads from blocking resources. In those cases it is a slower form of `async` rendering.
+This is useful when you have multiple `<Suspense/>` on the page, and one is more important than the other: think of a blog post and comments, or product information and reviews. It is *not* useful if there’s only one `<Suspense/>`, or if every `<Suspense/>` reads from blocking resources. In those cases it is a slower form of `async` rendering.
 
 - _Pros_: Works if JavaScript is disabled or not supported on the user’s device.
 - _Cons_
@@ -84,13 +79,13 @@ Because it offers the best blend of performance characteristics, Leptos defaults
 ```rust
 <Routes>
 	// We’ll load the home page with out-of-order streaming and <Suspense/>
-	<Route path="" view=HomePage/>
+	<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=Post
+		view=|cx| view! { cx, <Post/> }
 		ssr=SsrMode::Async
 	/>
 </Routes>

docs/book/src/ssr/24_hydration_bugs.md

@@ -74,11 +74,11 @@ In other words, if this is being compiled to WASM, it has three items; otherwise
 When I load the page in the browser, I see nothing. If I open the console I see a bunch of warnings:
 
 ```
-element with id 0-3 not found, ignoring it for hydration
-element with id 0-4 not found, ignoring it for hydration
-element with id 0-5 not found, ignoring it for hydration
-component with id _0-6c not found, ignoring it for hydration
-component with id _0-6o not found, ignoring it for hydration
+element with id 0-0-1 not found, ignoring it for hydration
+element with id 0-0-2 not found, ignoring it for hydration
+element with id 0-0-3 not found, ignoring it for hydration
+component with id _0-0-4c not found, ignoring it for hydration
+component with id _0-0-4o not found, ignoring it for hydration
 ```
 
 The WASM version of your app, running in the browser, expects to find three items; but the HTML has none.
@@ -87,56 +87,6 @@ The WASM version of your app, running in the browser, expects to find three item
 
 It’s pretty rare that you do this intentionally, but it could happen from somehow running different logic on the server and in the browser. If you’re seeing warnings like this and you don’t think it’s your fault, it’s much more likely that it’s a bug with `<Suspense/>` or something. Feel free to go ahead and open an [issue](https://github.com/leptos-rs/leptos/issues) or [discussion](https://github.com/leptos-rs/leptos/discussions) on GitHub for help.
 
-### Mutating the DOM during rendering
-
-This is a slightly more common way to create a client/server mismatch: updating a signal _during rendering_ in a way that mutates the view.
-
-```rust
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    let (loaded, set_loaded) = create_signal(cx, false);
-
-    // create_effect only runs on the client
-    create_effect(cx, move |_| {
-        // do something like reading from localStorage
-        set_loaded(true);
-    });
-
-    move || {
-        if loaded() {
-            view! { cx, <p>"Hello, world!"</p> }.into_any()
-        } else {
-            view! { cx, <div class="loading">"Loading..."</div> }.into_any()
-        }
-    }
-}
-```
-
-This one gives us the scary panic
-
-```
-panicked at 'assertion failed: `(left == right)`
-  left: `"DIV"`,
- right: `"P"`: SSR and CSR elements have the same hydration key but different node kinds.
-```
-
-And a handy link to this page!
-
-The problem here is that `create_effect` runs **immediately** and **synchronously**, but only in the browser. As a result, on the server, `loaded` is false, and a `<div>` is rendered. But on the browser, by the time the view is being rendered, `loaded` has already been set to `true`, and the browser is expecting to find a `<p>`.
-
-#### Solution
-
-You can simply tell the effect to wait a tick before updating the signal, by using something like `request_animation_frame`, which will set a short timeout and then update the signal before the next frame.
-
-```rust
-create_effect(cx, move |_| {
-    // do something like reading from localStorage
-    request_animation_frame(move || set_loaded(true));
-});
-```
-
-This allows the browser to hydrate with the correct, matching state (`loaded` is `false` when it reaches the view), then immediately update it to `true` once hydration is complete.
-
 ### Not all client code can run on the server
 
 Imagine you happily import a dependency like `gloo-net` that you’ve been used to using to make requests in the browser, and use it in a `create_resource` in a server-rendered app.

docs/book/src/testing.md

@@ -53,149 +53,128 @@ pub fn TodoApp(cx: Scope) -> impl IntoView {
 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 end-to-end (`e2e`) testing
+## 2. Test components with `wasm-bindgen-test`
 
-Our [`examples`](https://github.com/leptos-rs/leptos/tree/main/examples) directory has several examples with extensive end-to-end testing, using different testing tools.
+[`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.
 
-The easiest way to see how to use these is to take a look at the test examples themselves:
+To use this testing utility, you need to add `wasm-bindgen-test` to your `Cargo.toml`:
 
-### `wasm-bindgen-test` with [`counter`](https://github.com/leptos-rs/leptos/blob/main/examples/counter/tests/web.rs)
+```toml
+[dev-dependencies]
+wasm-bindgen-test = "0.3.0"
+```
 
-This is a fairly simple manual testing setup that uses the [`wasm-pack test`](https://rustwasm.github.io/wasm-pack/book/commands/test.html) command.
+You should create tests in a separate `tests` directory. You can then run your tests in the browser of your choice:
 
-#### Sample Test
+```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();
-    let _ = document.body().unwrap().append_child(&test_wrapper);
+    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/> },
     );
-
-    let div = test_wrapper.query_selector("div").unwrap().unwrap();
-    let clear = test_wrapper
-        .query_selector("button")
-        .unwrap()
-        .unwrap()
-        .unchecked_into::<web_sys::HtmlElement>();
-
-    clear.click();
-
-    assert_eq!(
-        div.outer_html(),
-        /* HTML expected */
-    );
-```
-
-### [`wasm-bindgen-test` with `counters_stable`](https://github.com/leptos-rs/leptos/tree/main/examples/counters_stable/tests/web)
-
-This more developed test suite uses a system of fixtures to refactor the manual DOM manipulation of the `counter` tests and easily test a wide range of cases.
-
-#### Sample Test
-
-```rust
-use super::*;
-use crate::counters_page as ui;
-use pretty_assertions::assert_eq;
-
-#[wasm_bindgen_test]
-fn should_increase_the_total_count() {
-    // Given
-    ui::view_counters();
-    ui::add_counter();
-
-    // When
-    ui::increment_counter(1);
-    ui::increment_counter(1);
-    ui::increment_counter(1);
-
-    // Then
-    assert_eq!(ui::total(), 3);
 }
 ```
 
-### [Playwright with `counters_stable`](https://github.com/leptos-rs/leptos/tree/main/examples/counters_stable/e2e)
+We’ll use some manual DOM operations to grab the `<div>` that wraps
+the whole component, as well as the `clear` button.
 
-These tests use the common JavaScript testing tool Playwright to run end-to-end tests on the same example, using a library and testing approach familiar to may who have done frontend development before.
+```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>();
+```
 
-#### Sample Test
+Now we can use ordinary DOM APIs to simulate user interaction.
 
-```js
-import { test, expect } from "@playwright/test";
-import { CountersPage } from "./fixtures/counters_page";
+```rust
+// now let's click the `clear` button
+clear.click();
+```
 
-test.describe("Increment Count", () => {
-  test("should increase the total count", async ({ page }) => {
-    const ui = new CountersPage(page);
-    await ui.goto();
-    await ui.addCounter();
+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.
 
-    await ui.incrementCount();
-    await ui.incrementCount();
-    await ui.incrementCount();
+```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);
 
-    await expect(ui.total).toHaveText("3");
-  });
+        // 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()
 });
 ```
 
-### [Gherkin/Cucumber Tests with `todo_app_sqlite`](https://github.com/leptos-rs/leptos/blob/main/examples/todo_app_sqlite/e2e/README.md)
+This is only a very limited introduction to testing. But I hope it’s useful as you begin to build applications.
 
-You can integrate any testing tool you’d like into this flow. This example uses Cucumber, a testing framework based on natural language.
-
-```
-@add_todo
-Feature: Add Todo
-
-    Background:
-        Given I see the app
-
-    @add_todo-see
-    Scenario: Should see the todo
-        Given I set the todo as Buy Bread
-        When I click the Add button
-        Then I see the todo named Buy Bread
-
-    # @allow.skipped
-    @add_todo-style
-    Scenario: Should see the pending todo
-        When I add a todo as Buy Oranges
-        Then I see the pending todo
-```
-
-The definitions for these actions are defined in Rust code.
-
-```rust
-use crate::fixtures::{action, world::AppWorld};
-use anyhow::{Ok, Result};
-use cucumber::{given, when};
-
-#[given("I see the app")]
-#[when("I open the app")]
-async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
-    let client = &world.client;
-    action::goto_path(client, "").await?;
-
-    Ok(())
-}
-
-#[given(regex = "^I add a todo as (.*)$")]
-#[when(regex = "^I add a todo as (.*)$")]
-async fn i_add_a_todo_titled(world: &mut AppWorld, text: String) -> Result<()> {
-    let client = &world.client;
-    action::add_todo(client, text.as_str()).await?;
-
-    Ok(())
-}
-
-// etc.
-```
-
-### Learning More
-
-Feel free to check out the CI setup in the Leptos repo to learn more about how to use these tools in your own application. All of these testing methods are run regularly against actual Leptos example apps.
+> 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

@@ -139,7 +139,7 @@ view! { cx,
 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()}` accesses the value of `count` once, and passes an `i32` into the view,
+`{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!
 
 Let’s make one final change. `set_count(3)` is a pretty useless thing for a click handler to do. Let’s replace “set this value to 3” with “increment this value by 1”:
@@ -160,67 +160,3 @@ Other Previews > 8080.` Hover over any of the variables to show Rust-Analyzer de
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-
-// The #[component] macro marks a function as a reusable component
-// Components are the building blocks of your user interface
-// They define a reusable unit of behavior
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    // here we create a reactive signal
-    // and get a (getter, setter) pair
-    // signals are the basic unit of change in the framework
-    // we'll talk more about them later
-    let (count, set_count) = create_signal(cx, 0);
-
-    // the `view` macro is how we define the user interface
-    // it uses an HTML-like format that can accept certain Rust values
-    view! { cx,
-        <button
-            // on:click will run whenever the `click` event fires
-            // every event handler is defined as `on:{eventname}`
-
-            // we're able to move `set_count` into the closure
-            // because signals are Copy and 'static
-            on:click=move |_| {
-                set_count.update(|n| *n += 1);
-            }
-        >
-            // text nodes in RSX should be wrapped in quotes,
-            // like a normal Rust string
-            "Click me"
-        </button>
-        <p>
-            <strong>"Reactive: "</strong>
-            // you can insert Rust expressions as values in the DOM
-            // by wrapping them in curly braces
-            // if you pass in a function, it will reactively update
-            {move || count.get()}
-        </p>
-        <p>
-            <strong>"Reactive shorthand: "</strong>
-            // signals are functions, so we can remove the wrapping closure
-            {count}
-        </p>
-        <p>
-            <strong>"Not reactive: "</strong>
-            // NOTE: if you write {count()}, this will *not* be reactive
-            // it simply gets the value of count once
-            {count()}
-        </p>
-    }
-}
-
-// This `main` function is the entry point into the app
-// It just mounts our component to the <body>
-// Because we defined it as `fn App`, we can now use it in a
-// template as <App/>
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-```

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

@@ -144,92 +144,11 @@ let double_count = move || count() * 2;
 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.
-
-> #### Advanced Topic: Injecting Raw HTML
->
-> The `view` macro provides support for an additional attribute, `inner_html`, which
-> can be used to directly set the HTML contents of any element, wiping out any other
-> children you’ve given it. Note that this does _not_ escape the HTML you provide. You
-> should make sure that it only contains trusted input or that any HTML entities are
-> escaped, to prevent cross-site scripting (XSS) attacks.
->
-> ```rust
-> let html = "<p>This HTML will be injected.</p>";
-> view! { cx,
->   <div inner_html=html/>
-> }
-> ```
->
-> [Click here for the full `view` macros docs](https://docs.rs/leptos/latest/leptos/macro.view.html).
+> 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>
-
-<details>
-<summary>Code Sandbox Source</summary>
-
-```rust
-use leptos::*;
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    let (count, set_count) = create_signal(cx, 0);
-
-    // a "derived signal" is a function that accesses other signals
-    // we can use this to create reactive values that depend on the
-    // values of one or more other signals
-    let double_count = move || count() * 2;
-
-    view! { cx,
-        <button
-            on:click=move |_| {
-                set_count.update(|n| *n += 1);
-            }
-            // the class: syntax reactively updates a single class
-            // here, we'll set the `red` class when `count` is odd
-            class:red=move || count() % 2 == 1
-        >
-            "Click me"
-        </button>
-        // NOTE: self-closing tags like <br> need an explicit /
-        <br/>
-
-        // We'll update this progress bar every time `count` changes
-        <progress
-            // static attributes work as in HTML
-            max="50"
-
-            // passing a function to an attribute
-            // reactively sets that attribute
-            // signals are functions, so this <=> `move || count.get()`
-            value=count
-        >
-        </progress>
-        <br/>
-
-        // This progress bar will use `double_count`
-        // so it should move twice as fast!
-        <progress
-            max="50"
-            // derived signals are functions, so they can also
-            // reactive update the DOM
-            value=double_count
-        >
-        </progress>
-        <p>"Count: " {count}</p>
-        <p>"Double Count: " {double_count}</p>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-```
-
-</details>
-</preview>

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

@@ -219,25 +219,9 @@ where
 This is a perfectly reasonable way to write this component: `progress` now takes
 any value that implements this `Fn()` trait.
 
-This generic can also be specified inline:
-
-```rust
-#[component]
-fn ProgressBar<F: Fn() -> i32 + 'static>(
-    cx: Scope,
-    #[prop(default = 100)] max: u16,
-    progress: F,
-) -> impl IntoView {
-    view! { cx,
-        <progress
-            max=max
-            value=progress
-        />
-    }
-}
-```
-
-> Note that generic component props _can’t_ be specified with an `impl` yet (`progress: impl Fn() -> i32 + 'static,`), in part because they’re actually used to generate a `struct ProgressBarProps`, and struct fields cannot be `impl` types. The `#[component]` macro may be further improved in the future to allow inline `impl` generic props.
+> 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
 
@@ -287,81 +271,6 @@ fn App(cx: Scope) -> impl IntoView {
 }
 ```
 
-### Optional Generic Props
-
-Note that you can’t specify optional generic props for a component. Let’s see what would happen if you try:
-
-```rust,compile_fail
-#[component]
-fn ProgressBar<F: Fn() -> i32 + 'static>(
-    cx: Scope,
-    #[prop(optional)] progress: Option<F>,
-) -> impl IntoView {
-    progress.map(|progress| {
-        view! { cx,
-            <progress
-                max=100
-                value=progress
-            />
-        }
-    })
-}
-
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <ProgressBar/>
-    }
-}
-```
-
-Rust helpfully gives the error
-
-```
-xx |         <ProgressBar/>
-   |          ^^^^^^^^^^^ cannot infer type of the type parameter `F` declared on the function `ProgressBar`
-   |
-help: consider specifying the generic argument
-   |
-xx |         <ProgressBar::<F>/>
-   |                     +++++
-```
-
-There are just two problems:
-
-1. Leptos’s view macro doesn’t support specifying a generic on a component with this turbofish syntax.
-2. Even if you could, specifying the correct type here is not possible; closures and functions in general are unnameable types. The compiler can display them with a shorthand, but you can’t specify them.
-
-However, you can get around this by providing a concrete type using `Box<dyn _>` or `&dyn _`:
-
-```rust
-#[component]
-fn ProgressBar(
-    cx: Scope,
-    #[prop(optional)] progress: Option<Box<dyn Fn() -> i32>>,
-) -> impl IntoView {
-    progress.map(|progress| {
-        view! { cx,
-            <progress
-                max=100
-                value=progress
-            />
-        }
-    })
-}
-
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <ProgressBar/>
-    }
-}
-```
-
-Because the Rust compiler now knows the concrete type of the prop, and therefore its size in memory even in the `None` case, this compiles fine.
-
-> In this particular case, `&dyn Fn() -> i32` will cause lifetime issues, but in other cases, it may be a possibility.
-
 ## Documenting Components
 
 This is one of the least essential but most important sections of this book.
@@ -397,98 +306,6 @@ 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.
 
-> #### Advanced Topic: `#[component(transparent)]`
->
-> All Leptos components return `-> impl IntoView`. Some, though, need to return
-> some data directly without any additional wrapping. These can be marked with
-> `#[component(transparent)]`, in which case they return exactly the value they
-> return, without the rendering system transforming them in any way.
->
-> This is mostly used in two situations:
->
-> 1. Creating wrappers around `<Suspense/>` or `<Transition/>`, which return a
->    transparent suspense structure to integrate with SSR and hydration properly.
-> 2. Refactoring `<Route/>` definitions for `leptos_router` out into separate
->    components, because `<Route/>` is a transparent component that returns a
->    `RouteDefinition` struct rather than a view.
->
-> In general, you should not need to use transparent components unless you are
-> creating custom wrapping components that fall into one of these two categories.
-
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-
-// Composing different components together is how we build
-// user interfaces. Here, we'll define a resuable <ProgressBar/>.
-// You'll see how doc comments can be used to document components
-// and their properties.
-
-/// Shows progress toward a goal.
-#[component]
-fn ProgressBar(
-    // All components take a reactive `Scope` as the first argument
-    cx: Scope,
-    // Marks this as an optional prop. It will default to the default
-    // value of its type, i.e., 0.
-    #[prop(default = 100)]
-    /// The maximum value of the progress bar.
-    max: u16,
-    // Will run `.into()` on the value passed into the prop.
-    #[prop(into)]
-    // `Signal<T>` is a wrapper for several reactive types.
-    // It can be helpful in component APIs like this, where we
-    // might want to take any kind of reactive value
-    /// How much progress should be displayed.
-    progress: Signal<i32>,
-) -> impl IntoView {
-    view! { cx,
-        <progress
-            max={max}
-            value=progress
-        />
-        <br/>
-    }
-}
-
-#[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>
-        <br/>
-        // If you have this open in CodeSandbox or an editor with
-        // rust-analyzer support, try hovering over `ProgressBar`,
-        // `max`, or `progress` to see the docs we defined above
-        <ProgressBar max=50 progress=count/>
-        // Let's use the default max value on this one
-        // the default is 100, so it should move half as fast
-        <ProgressBar progress=count/>
-        // Signal::derive creates a Signal wrapper from our derived signal
-        // using double_count means it should move twice as fast
-        <ProgressBar max=50 progress=Signal::derive(cx, double_count)/>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-```
-
-</details>
-</preview>

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

@@ -106,162 +106,3 @@ 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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-
-// Iteration is a very common task in most applications.
-// So how do you take a list of data and render it in the DOM?
-// This example will show you the two ways:
-// 1) for mostly-static lists, using Rust iterators
-// 2) for lists that grow, shrink, or move items, using <For/>
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <h1>"Iteration"</h1>
-        <h2>"Static List"</h2>
-        <p>"Use this pattern if the list itself is static."</p>
-        <StaticList length=5/>
-        <h2>"Dynamic List"</h2>
-        <p>"Use this pattern if the rows in your list will change."</p>
-        <DynamicList initial_length=5/>
-    }
-}
-
-/// A list of counters, without the ability
-/// to add or remove any.
-#[component]
-fn StaticList(
-    cx: Scope,
-    /// How many counters to include in this list.
-    length: usize,
-) -> impl IntoView {
-    // create counter signals that start at incrementing numbers
-    let counters = (1..=length).map(|idx| create_signal(cx, idx));
-
-    // when you have a list that doesn't change, you can
-    // manipulate it using ordinary Rust iterators
-    // and collect it into a Vec<_> to insert it into the DOM
-    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<_>>();
-
-    // Note that if `counter_buttons` were a reactive list
-    // and its value changed, this would be very inefficient:
-    // it would rerender every row every time the list changed.
-    view! { cx,
-        <ul>{counter_buttons}</ul>
-    }
-}
-
-/// A list of counters that allows you to add or
-/// remove counters.
-#[component]
-fn DynamicList(
-    cx: Scope,
-    /// The number of counters to begin with.
-    initial_length: usize,
-) -> impl IntoView {
-    // This dynamic list will use the <For/> component.
-    // <For/> is a keyed list. This means that each row
-    // has a defined key. If the key does not change, the row
-    // will not be re-rendered. When the list changes, only
-    // the minimum number of changes will be made to the DOM.
-
-    // `next_counter_id` will let us generate unique IDs
-    // we do this by simply incrementing the ID by one
-    // each time we create a counter
-    let mut next_counter_id = initial_length;
-
-    // we generate an initial list as in <StaticList/>
-    // but this time we include the ID along with the signal
-    let initial_counters = (0..initial_length)
-        .map(|id| (id, create_signal(cx, id + 1)))
-        .collect::<Vec<_>>();
-
-    // now we store that initial list in a signal
-    // this way, we'll be able to modify the list over time,
-    // adding and removing counters, and it will change reactively
-    let (counters, set_counters) = create_signal(cx, initial_counters);
-
-    let add_counter = move |_| {
-        // create a signal for the new counter
-        let sig = create_signal(cx, next_counter_id + 1);
-        // add this counter to the list of counters
-        set_counters.update(move |counters| {
-            // since `.update()` gives us `&mut T`
-            // we can just use normal Vec methods like `push`
-            counters.push((next_counter_id, sig))
-        });
-        // increment the ID so it's always unique
-        next_counter_id += 1;
-    };
-
-    view! { cx,
-        <div>
-            <button on:click=add_counter>
-                "Add Counter"
-            </button>
-            <ul>
-                // The <For/> component is central here
-                // This allows for efficient, key list rendering
-                <For
-                    // `each` takes any function that returns an iterator
-                    // this should usually be a signal or derived signal
-                    // if it's not reactive, just render a Vec<_> instead of <For/>
-                    each=counters
-                    // the key should be unique and stable for each row
-                    // using an index is usually a bad idea, unless your list
-                    // can only grow, because moving items around inside the list
-                    // means their indices will change and they will all rerender
-                    key=|counter| counter.0
-                    // the view function receives each item from your `each` iterator
-                    // and returns a view
-                    view=move |cx, (id, (count, set_count))| {
-                        view! { cx,
-                            <li>
-                                <button
-                                    on:click=move |_| set_count.update(|n| *n += 1)
-                                >
-                                    {count}
-                                </button>
-                                <button
-                                    on:click=move |_| {
-                                        set_counters.update(|counters| {
-                                            counters.retain(|(counter_id, _)| counter_id != &id)
-                                        });
-                                    }
-                                >
-                                    "Remove"
-                                </button>
-                            </li>
-                        }
-                    }
-                />
-            </ul>
-        </div>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -19,8 +19,7 @@ There are two important things to remember:
 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. (The same is true for `checked` and `prop:checked` 
-   on an `<input type="checkbox">`.)
+   `prop:value` for this reason.
 
 ```rust
 let (name, set_name) = create_signal(cx, "Controlled".to_string());
@@ -43,33 +42,6 @@ view! { cx,
 }
 ```
 
-> #### Why do you need `prop:value`?
-> 
-> Web browsers are the most ubiquitous and stable platform for rendering graphical user interfaces in existence. They have also maintained an incredible backwards compatibility over their three decades of existence. Inevitably, this means there are some quirks.
-> 
-> One odd quirk is that there is a distinction between HTML attributes and DOM element properties, i.e., between something called an “attribute” which is parsed from HTML and can be set on a DOM element with `.setAttribute()`, and something called a “property” which is a field of the JavaScript class representation of that parsed HTML element.
->
-> In the case of an `<input value=...>`, setting the `value` *attribute* is defined as setting the initial value for the input, and setting `value` *property* sets its current value. It maybe easiest to understand this by opening `about:blank` and running the following JavaScript in the browser console, line by line:
-> 
-> ```js
-> // create an input and append it to the DOM
-> const el = document.createElement("input")
-> document.body.appendChild(el)
-> 
-> el.setAttribute("value", "test") // updates the input
-> el.setAttribute("value", "another test") // updates the input again
-> 
-> // now go and type into the input: delete some characters, etc.
-> 
-> el.setAttribute("value", "one more time?") 
-> // nothing should have changed. setting the "initial value" does nothing now
-> 
-> // however...
-> el.value = "But this works"
-> ```
->
-> Many other frontend frameworks conflate attributes and properties, or create a special case for inputs that sets the value correctly. Maybe Leptos should do this too; but for now, I prefer giving users the maximum amount of control over whether they’re setting an attribute or a property, and doing my best to educate people about the actual underlying browser behavior rather than obscuring it.
-
 ## Uncontrolled Inputs
 
 In an "uncontrolled input," the browser controls the state of the input element.
@@ -140,112 +112,3 @@ The view should be pretty self-explanatory by now. Note two things:
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::{ev::SubmitEvent, *};
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    view! { cx,
-        <h2>"Controlled Component"</h2>
-        <ControlledComponent/>
-        <h2>"Uncontrolled Component"</h2>
-        <UncontrolledComponent/>
-    }
-}
-
-#[component]
-fn ControlledComponent(cx: Scope) -> impl IntoView {
-    // create a signal to hold the value
-    let (name, set_name) = create_signal(cx, "Controlled".to_string());
-
-    view! { cx,
-        <input type="text"
-            // fire an event whenever the input changes
-            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.
-            //
-            // IMPORTANT: the `value` *attribute* only sets the
-            // initial value, until you have made a change.
-            // The `value` *property* sets the current value.
-            // This is a quirk of the DOM; I didn't invent it.
-            // Other frameworks gloss this over; I think it's
-            // more important to give you access to the browser
-            // as it really works.
-            //
-            // tl;dr: use prop:value for form inputs
-            prop:value=name
-        />
-        <p>"Name is: " {name}</p>
-    }
-}
-
-#[component]
-fn UncontrolledComponent(cx: Scope) -> impl IntoView {
-    // import the type for <input>
-    use leptos::html::Input;
-
-    let (name, set_name) = create_signal(cx, "Uncontrolled".to_string());
-
-    // we'll use a NodeRef to store a reference to the input element
-    // this will be filled when the element is created
-    let input_element: NodeRef<Input> = create_node_ref(cx);
-
-    // fires when the form `submit` event happens
-    // this will store the value of the <input> in our signal
-    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);
-    };
-
-    view! { cx,
-        <form on:submit=on_submit>
-            <input type="text"
-                // here, we use the `value` *attribute* to set only
-                // the initial value, letting the browser maintain
-                // the state after that
-                value=name
-
-                // store a reference to this input in `input_element`
-                node_ref=input_element
-            />
-            <input type="submit" value="Submit"/>
-        </form>
-        <p>"Name is: " {name}</p>
-    }
-}
-
-// This `main` function is the entry point into the app
-// It just mounts our component to the <body>
-// Because we defined it as `fn App`, we can now use it in a
-// template as <App/>
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -198,7 +198,7 @@ let (value, set_value) = create_signal(cx, 0);
 
 view! { cx,
   <Show
-    when=move || { value() > 5 }
+    when=move || value() > 5
     fallback=|cx| view! { cx, <Small/> }
   >
     <Big/>
@@ -208,8 +208,7 @@ view! { cx,
 
 `<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 or until `value`
-goes below five and then renders `<Small/>` again.
+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
@@ -286,100 +285,3 @@ view! { cx,
 [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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    let (value, set_value) = create_signal(cx, 0);
-    let is_odd = move || value() & 1 == 1;
-    let odd_text = move || if is_odd() { Some("How odd!") } else { None };
-
-    view! { cx,
-        <h1>"Control Flow"</h1>
-
-        // Simple UI to update and show a value
-        <button on:click=move |_| set_value.update(|n| *n += 1)>
-            "+1"
-        </button>
-        <p>"Value is: " {value}</p>
-
-        <hr/>
-
-        <h2><code>"Option<T>"</code></h2>
-        // For any `T` that implements `IntoView`,
-        // so does `Option<T>`
-
-        <p>{odd_text}</p>
-        // This means you can use `Option` methods on it
-        <p>{move || odd_text().map(|text| text.len())}</p>
-
-        <h2>"Conditional Logic"</h2>
-        // You can do dynamic conditional if-then-else
-        // logic in several ways
-        //
-        // a. An "if" expression in a function
-        //    This will simply re-render every time the value
-        //    changes, which makes it good for lightweight UI
-        <p>
-            {move || if is_odd() {
-                "Odd"
-            } else {
-                "Even"
-            }}
-        </p>
-
-        // b. Toggling some kind of class
-        //    This is smart for an element that's going to
-        //    toggled often, because it doesn't destroy
-        //    it in between states
-        //    (you can find the `hidden` class in `index.html`)
-        <p class:hidden=is_odd>"Appears if even."</p>
-
-        // c. The <Show/> component
-        //    This only renders the fallback and the child
-        //    once, lazily, and toggles between them when
-        //    needed. This makes it more efficient in many cases
-        //    than a {move || if ...} block
-        <Show when=is_odd
-            fallback=|cx| view! { cx, <p>"Even steven"</p> }
-        >
-            <p>"Oddment"</p>
-        </Show>
-
-        // d. Because `bool::then()` converts a `bool` to
-        //    `Option`, you can use it to create a show/hide toggled
-        {move || is_odd().then(|| view! { cx, <p>"Oddity!"</p> })}
-
-        <h2>"Converting between Types"</h2>
-        // e. Note: if branches return different types,
-        //    you can convert between them with
-        //    `.into_any()` (for different HTML element types)
-        //    or `.into_view(cx)` (for all view types)
-        {move || match is_odd() {
-            true if value() == 1 => {
-                // <pre> returns HtmlElement<Pre>
-                view! { cx, <pre>"One"</pre> }.into_any()
-            },
-            false if value() == 2 => {
-                // <p> returns HtmlElement<P>
-                // so we convert into a more generic type
-                view! { cx, <p>"Two"</p> }.into_any()
-            }
-            _ => view! { cx, <textarea>{value()}</textarea> }.into_any()
-        }}
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -19,7 +19,7 @@ fn NumericInput(cx: Scope) -> impl IntoView {
     view! { cx,
         <label>
             "Type a number (or not!)"
-            <input on:input=on_input/>
+            <input type="number" on:input=on_input/>
             <p>
                 "You entered "
                 <strong>{value}</strong>
@@ -69,7 +69,7 @@ fn NumericInput(cx: Scope) -> impl IntoView {
         <h1>"Error Handling"</h1>
         <label>
             "Type a number (or something that's not a number!)"
-            <input on:input=on_input/>
+            <input type="number" on:input=on_input/>
             <ErrorBoundary
                 // the fallback receives a signal containing current errors
                 fallback=|cx, errors| view! { cx,
@@ -113,64 +113,3 @@ 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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    let (value, set_value) = create_signal(cx, Ok(0));
-
-    // when input changes, try to parse a number from the input
-    let on_input = move |ev| set_value(event_target_value(&ev).parse::<i32>());
-
-    view! { cx,
-        <h1>"Error Handling"</h1>
-        <label>
-            "Type a number (or something that's not a number!)"
-            <input type="number" on:input=on_input/>
-            // If an `Err(_) had been rendered inside the <ErrorBoundary/>,
-            // the fallback will be displayed. Otherwise, the children of the
-            // <ErrorBoundary/> will be displayed.
-            <ErrorBoundary
-                // the fallback receives a signal containing current errors
-                fallback=|cx, errors| view! { cx,
-                    <div class="error">
-                        <p>"Not a number! Errors: "</p>
-                        // we can render a list of errors
-                        // as strings, if we'd like
-                        <ul>
-                            {move || errors.get()
-                                .into_iter()
-                                .map(|(_, e)| view! { cx, <li>{e.to_string()}</li>})
-                                .collect::<Vec<_>>()
-                            }
-                        </ul>
-                    </div>
-                }
-            >
-                <p>
-                    "You entered "
-                    // because `value` is `Result<i32, _>`,
-                    // it will render the `i32` if it is `Ok`,
-                    // and render nothing and trigger the error boundary
-                    // if it is `Err`. It's a signal, so this will dynamically
-                    // update when `value` changes
-                    <strong>{value}</strong>
-                </p>
-            </ErrorBoundary>
-        </label>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -117,7 +117,7 @@ pub fn App(cx: Scope) -> impl IntoView {
 
 
 #[component]
-pub fn ButtonC(cx: Scope) -> impl IntoView {
+pub fn ButtonC<F>(cx: Scope) -> impl IntoView {
     view! { cx,
         <button>"Toggle"</button>
     }
@@ -288,150 +288,3 @@ 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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::{ev::MouseEvent, *};
-
-// This highlights four different ways that child components can communicate
-// with their parent:
-// 1) <ButtonA/>: passing a WriteSignal as one of the child component props,
-//    for the child component to write into and the parent to read
-// 2) <ButtonB/>: passing a closure as one of the child component props, for
-//    the child component to call
-// 3) <ButtonC/>: adding an `on:` event listener to a component
-// 4) <ButtonD/>: providing a context that is used in the component (rather than prop drilling)
-
-#[derive(Copy, Clone)]
-struct SmallcapsContext(WriteSignal<bool>);
-
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    // just some signals to toggle three classes on our <p>
-    let (red, set_red) = create_signal(cx, false);
-    let (right, set_right) = create_signal(cx, false);
-    let (italics, set_italics) = create_signal(cx, false);
-    let (smallcaps, set_smallcaps) = create_signal(cx, false);
-
-    // the newtype pattern isn't *necessary* here but is a good practice
-    // it avoids confusion with other possible future `WriteSignal<bool>` contexts
-    // and makes it easier to refer to it in ButtonC
-    provide_context(cx, SmallcapsContext(set_smallcaps));
-
-    view! {
-        cx,
-        <main>
-            <p
-                // class: attributes take F: Fn() => bool, and these signals all implement Fn()
-                class:red=red
-                class:right=right
-                class:italics=italics
-                class:smallcaps=smallcaps
-            >
-                "Lorem ipsum sit dolor amet."
-            </p>
-
-            // Button A: pass the signal setter
-            <ButtonA setter=set_red/>
-
-            // Button B: pass a closure
-            <ButtonB on_click=move |_| set_right.update(|value| *value = !*value)/>
-
-            // Button B: use a regular event listener
-            // setting an event listener on a component like this applies it
-            // to each of the top-level elements the component returns
-            <ButtonC on:click=move |_| set_italics.update(|value| *value = !*value)/>
-
-            // Button D gets its setter from context rather than props
-            <ButtonD/>
-        </main>
-    }
-}
-
-/// Button A receives a signal setter and updates the signal itself
-#[component]
-pub fn ButtonA(
-    cx: Scope,
-    /// Signal that will be toggled when the button is clicked.
-    setter: WriteSignal<bool>,
-) -> impl IntoView {
-    view! {
-        cx,
-        <button
-            on:click=move |_| setter.update(|value| *value = !*value)
-        >
-            "Toggle Red"
-        </button>
-    }
-}
-
-/// Button B receives a closure
-#[component]
-pub fn ButtonB<F>(
-    cx: Scope,
-    /// Callback that will be invoked when the button is clicked.
-    on_click: F,
-) -> impl IntoView
-where
-    F: Fn(MouseEvent) + 'static,
-{
-    view! {
-        cx,
-        <button
-            on:click=on_click
-        >
-            "Toggle Right"
-        </button>
-    }
-
-    // just a note: in an ordinary function ButtonB could take on_click: impl Fn(MouseEvent) + 'static
-    // and save you from typing out the generic
-    // the component macro actually expands to define a
-    //
-    // struct ButtonBProps<F> where F: Fn(MouseEvent) + 'static {
-    //   on_click: F
-    // }
-    //
-    // this is what allows us to have named props in our component invocation,
-    // instead of an ordered list of function arguments
-    // if Rust ever had named function arguments we could drop this requirement
-}
-
-/// Button C is a dummy: it renders a button but doesn't handle
-/// its click. Instead, the parent component adds an event listener.
-#[component]
-pub fn ButtonC(cx: Scope) -> impl IntoView {
-    view! {
-        cx,
-        <button>
-            "Toggle Italics"
-        </button>
-    }
-}
-
-/// Button D is very similar to Button A, but instead of passing the setter as a prop
-/// we get it from the context
-#[component]
-pub fn ButtonD(cx: Scope) -> impl IntoView {
-    let setter = use_context::<SmallcapsContext>(cx).unwrap().0;
-
-    view! {
-        cx,
-        <button
-            on:click=move |_| setter.update(|value| *value = !*value)
-        >
-            "Toggle Small Caps"
-        </button>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

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

@@ -115,118 +115,14 @@ Calling it like this will create a list:
 
 ```rust
 view! { cx,
-    <WrapsChildren>
+    <WrappedChildren>
         "A"
         "B"
         "C"
-    </WrapsChildren>
+    </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>
-
-<details>
-<summary>CodeSandbox Source</summary>
-
-```rust
-use leptos::*;
-
-// Often, you want to pass some kind of child view to another
-// component. There are two basic patterns for doing this:
-// - "render props": creating a component prop that takes a function
-//   that creates a view
-// - the `children` prop: a special property that contains content
-//   passed as the children of a component in your view, not as a
-//   property
-
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    let (items, set_items) = create_signal(cx, vec![0, 1, 2]);
-    let render_prop = move || {
-        // items.with(...) reacts to the value without cloning
-        // by applying a function. Here, we pass the `len` method
-        // on a `Vec<_>` directly
-        let len = move || items.with(Vec::len);
-        view! { cx,
-            <p>"Length: " {len}</p>
-        }
-    };
-
-    view! { cx,
-        // This component just displays the two kinds of children,
-        // embedding them in some other markup
-        <TakesChildren
-            // for component props, you can shorthand
-            // `render_prop=render_prop` => `render_prop`
-            // (this doesn't work for HTML element attributes)
-            render_prop
-        >
-            // these look just like the children of an HTML element
-            <p>"Here's a child."</p>
-            <p>"Here's another child."</p>
-        </TakesChildren>
-        <hr/>
-        // This component actually iterates over and wraps the children
-        <WrapsChildren>
-            <p>"Here's a child."</p>
-            <p>"Here's another child."</p>
-        </WrapsChildren>
-    }
-}
-
-/// Displays a `render_prop` and some children within markup.
-#[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
-    /// this is an alias for `Box<dyn FnOnce(Scope) -> Fragment>`
-    /// ... aren't you glad we named it `Children` instead?
-    children: Children,
-) -> impl IntoView
-where
-    F: Fn() -> IV,
-    IV: IntoView,
-{
-    view! { cx,
-        <h1><code>"<TakesChildren/>"</code></h1>
-        <h2>"Render Prop"</h2>
-        {render_prop()}
-        <hr/>
-        <h2>"Children"</h2>
-        {children(cx)}
-    }
-}
-
-/// Wraps each child in an `<li>` and embeds them in a `<ul>`.
-#[component]
-pub fn WrapsChildren(cx: Scope, children: Children) -> impl IntoView {
-    // children(cx) returns a `Fragment`, which has a
-    // `nodes` field that contains a Vec<View>
-    // this means we can iterate over the children
-    // to create something new!
-    let children = children(cx)
-        .nodes
-        .into_iter()
-        .map(|child| view! { cx, <li>{child}</li> })
-        .collect::<Vec<_>>();
-
-    view! { cx,
-        <h1><code>"<WrapsChildren/>"</code></h1>
-        // wrap our wrapped children in a UL
-        <ul>{children}</ul>
-    }
-}
-
-fn main() {
-    leptos::mount_to_body(|cx| view! { cx, <App/> })
-}
-
-```
-
-</details>
-</preview>

examples/Makefile.toml

@@ -5,35 +5,32 @@ CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true
 CARGO_MAKE_CARGO_BUILD_TEST_FLAGS = ""
 CARGO_MAKE_WORKSPACE_EMULATION = true
 CARGO_MAKE_CRATE_WORKSPACE_MEMBERS = [
-  "animated_show",
-  "counter",
-  "counter_isomorphic",
-  "counters",
-  "counters_stable",
-  "counter_url_query",
-  "counter_without_macros",
-  "error_boundary",
-  "errors_axum",
-  "fetch",
-  "hackernews",
-  "hackernews_axum",
-  "js-framework-benchmark",
-  "leptos-tailwind-axum",
-  "login_with_token_csr_only",
-  "parent_child",
-  "router",
-  "session_auth_axum",
-  "slots",
-  "ssr_modes",
-  "ssr_modes_axum",
-  "suspense_tests",
-  "tailwind",
-  "tailwind_csr_trunk",
-  "timer",
-  "todo_app_sqlite",
-  "todo_app_sqlite_axum",
-  "todo_app_sqlite_viz",
-  "todomvc",
+    "counter",
+    "counter_isomorphic",
+    "counters",
+    "counters_stable",
+    "counter_without_macros",
+    "error_boundary",
+    "errors_axum",
+    "fetch",
+    "hackernews",
+    "hackernews_axum",
+    "js-framework-benchmark",
+    "leptos-tailwind-axum",
+    "login_with_token_csr_only",
+    "parent_child",
+    "router",
+    "session_auth_axum",
+    "slots",
+    "ssr_modes",
+    "ssr_modes_axum",
+    "tailwind",
+    "tailwind_csr_trunk",
+    "timer",
+    "todo_app_sqlite",
+    "todo_app_sqlite_axum",
+    "todo_app_sqlite_viz",
+    "todomvc",
 ]
 
 [tasks.gen-members]
@@ -48,65 +45,3 @@ grep -v gtk |
 jq -R -s -c 'split("\n")[:-1]')
 echo "CARGO_MAKE_CRATE_WORKSPACE_MEMBERS = $examples"
 '''
-
-[tasks.test-runner-report]
-workspace = false
-description = "report ci test runners for each example - OPTION: [all]"
-script = '''
-BOLD="\e[1m"
-GREEN="\e[0;32m"
-ITALIC="\e[3m"
-YELLOW="\e[0;33m"
-RESET="\e[0m"
-
-echo
-echo "${YELLOW}Test Runner Report${RESET}"
-echo "${ITALIC}Pass the option \"all\" to show all the examples${RESET}"
-echo
-
-makefile_paths=$(find . -name Makefile.toml -not -path '*/target/*' |
-  sed 's%./%%' |
-  sed 's%/Makefile.toml%%' |
-  grep -v Makefile.toml |
-  sort -u)
-
-start_path=$(pwd)
-
-for path in $makefile_paths; do
-  cd $path
-
-  test_runner=
-
-  test_count=$(grep -rl -E "#\[(test|rstest)\]" | wc -l)
-  if [ $test_count -gt 0 ]; then
-    test_runner="-C"
-  fi
-
-  while read -r line; do
-    case $line in
-      *"wasm-test.toml"*)
-          test_runner=$test_runner"-W"
-        ;;
-      *"playwright-test.toml"*)
-          test_runner=$test_runner"-P"
-        ;;
-      *"cargo-leptos-test.toml"*)
-          test_runner=$test_runner"-L"
-        ;;
-    esac
-  done <"./Makefile.toml"
-
-  if [ ! -z "$1" ]; then
-    # Show all examples
-    echo "$path ${BOLD}${test_runner}${RESET}"
-  elif [ ! -z $test_runner ]; then
-    # Filter out examples that do not run tests in `ci`
-    echo "$path ${BOLD}${test_runner}${RESET}"
-  fi
-
-  cd ${start_path}
-done
-echo
-echo "${ITALIC}Runners: C = Cargo Test, L = Cargo Leptos Test, P = Playwright Test, W = WASM Test${RESET}"
-echo
-'''

examples/animated_show/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "animated-show"
-version = "0.1.0"
-edition = "2021"
-
-[profile.release]
-codegen-units = 1
-lto = true
-
-[dependencies]
-leptos = { path = "../../leptos", features = ["csr"] }
-console_log = "1"
-log = "0.4"
-console_error_panic_hook = "0.1.7"

examples/animated_show/Makefile.toml

@@ -1 +0,0 @@
-extend = [{ path = "../cargo-make/main.toml" }]

examples/animated_show/README.md

@@ -1,9 +0,0 @@
-# `<AnimatedShow>` combined with CSS animations
-
-This is a very simple example of the `<AnimatedShow>` component.
-
-This component is an extension for the `<Show>` component and it will not take in a fallback, but it will unmount the
-component from the DOM after a given duration. This makes it possible to have really easy unmount animations with just
-CSS.
-
-Just execute `trunk serve` to start the demo.

examples/animated_show/index.html

@@ -1,42 +0,0 @@
-<!DOCTYPE html>
-<html>
-	<head>
-		<link data-trunk rel="rust" data-wasm-opt="z"/>
-		<link data-trunk rel="icon" type="image/ico" href="/public/favicon.ico"/>
-		<style>
-			.hover-me {
-				width: 100px;
-				margin: 1rem;
-				padding: 1rem;
-				text-align: center;
-				cursor: pointer;
-				border: 1px solid grey;
-			}
-			.here-i-am {
-				width: 100px;
-				margin: 1rem;
-				padding: 1rem;
-				text-align: center;
-				color: white;
-				font-weight: bold;
-				background: black;
-			}
-
-			@keyframes fade-in {
-				from { opacity: 0; }
-				to { opacity: 1; }
-			}
-			@keyframes fade-out {
-				from { opacity: 1; }
-				to { opacity: 0; }
-			}
-			.fade-in-1000 {
-				animation: 1000ms fade-in forwards;
-			}
-			.fade-out-1000 {
-				animation: 1000ms fade-out forwards;
-			}
-		</style>
-	</head>
-	<body></body>
-</html>

examples/animated_show/src/lib.rs

@@ -1,34 +0,0 @@
-use core::time::Duration;
-use leptos::*;
-
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    let show = create_rw_signal(cx, false);
-
-    // the CSS classes in this example are just written directly inside the `index.html`
-    view! { cx,
-        <div
-            class="hover-me"
-            on:mouseenter=move |_| show.set(true)
-            on:mouseleave=move |_| show.set(false)
-        >
-            "Hover Me"
-        </div>
-
-        <AnimatedShow
-            when=show
-            // optional CSS class which will be applied if `when == true`
-            show_class="fade-in-1000"
-            // optional CSS class which will be applied if `when == false` and before the
-            // `hide_delay` starts -> makes CSS unmount animations really easy
-            hide_class="fade-out-1000"
-            // the given unmount delay which should match your unmount animation duration
-            hide_delay=Duration::from_millis(1000)
-        >
-            // provide any `Children` inside here
-            <div class="here-i-am">
-                "Here I Am!"
-            </div>
-        </AnimatedShow>
-    }
-}

examples/animated_show/src/main.rs

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

examples/cargo-make/cargo-leptos-test.toml

@@ -1,8 +1,5 @@
-extend = { path = "./cargo-leptos.toml" }
+[tasks.test-e2e]
+dependencies = ["setup-node", "cargo-leptos-e2e"]
 
-[tasks.integration-test]
-dependencies = ["install-cargo-leptos", "cargo-leptos-e2e"]
-
-[tasks.cargo-leptos-e2e]
-command = "cargo"
-args = ["leptos", "end-to-end"]
+[tasks.clean-all]
+dependencies = ["clean-cargo", "clean-node_modules", "clean-playwright"]

examples/cargo-make/cargo-leptos.toml

@@ -1,55 +0,0 @@
-[tasks.install-cargo-leptos]
-install_crate = { crate_name = "cargo-leptos", binary = "cargo-leptos", test_arg = "--help" }
-
-[tasks.build]
-clear = true
-command = "cargo"
-args = ["leptos", "build"]
-
-[tasks.check]
-clear = true
-dependencies = ["check-debug", "check-release"]
-
-[tasks.check-debug]
-toolchain = "nightly"
-command = "cargo"
-args = ["check-all-features"]
-install_crate = "cargo-all-features"
-
-[tasks.check-release]
-toolchain = "nightly"
-command = "cargo"
-args = ["check-all-features", "--release"]
-install_crate = "cargo-all-features"
-
-[tasks.start-client]
-command = "cargo"
-args = ["leptos", "watch"]
-
-[tasks.stop-client]
-condition = { env_set = ["APP_PROCESS_NAME"] }
-script = '''
-  if [ ! -z $(pidof ${APP_PROCESS_NAME}) ]; then
-    pkill -f todo_app_sqlite
-  fi
-
-  if [ ! -z $(pidof ${APP_PROCESS_NAME}) ]; then
-    pkill -f cargo-leptos
-  fi
-'''
-
-[tasks.client-status]
-condition = { env_set = ["APP_PROCESS_NAME"] }
-script = '''
-  if [ -z $(pidof ${APP_PROCESS_NAME}) ]; then
-    echo "  ${APP_PROCESS_NAME} is not running"
-  else
-    echo "  ${APP_PROCESS_NAME} is up"
-  fi
-
-  if [ -z $(pidof cargo-leptos) ]; then
-    echo "  cargo-leptos is not running"
-  else
-    echo "  cargo-leptos is up"
-  fi
-'''

examples/cargo-make/clean.toml

@@ -1,28 +0,0 @@
-[tasks.clean]
-dependencies = [
-    "clean-cargo",
-    "clean-trunk",
-    "clean-node_modules",
-    "clean-playwright",
-]
-
-[tasks.clean-cargo]
-command = "cargo"
-args = ["clean"]
-
-[tasks.clean-trunk]
-command = "trunk"
-args = ["clean"]
-
-[tasks.clean-node_modules]
-script = '''
-project_dir=${PWD##*/}
-if [ "$project_dir" != "todomvc" ]; then
-  find . -type d -name node_modules | xargs rm -rf
-fi
-'''
-
-[tasks.clean-playwright]
-script = '''
-find . -name playwright-report -name playwright -name test-results | xargs rm -rf
-'''

examples/cargo-make/common.toml

@@ -0,0 +1,98 @@
+[tasks.pre-clippy]
+env = { CARGO_MAKE_CLIPPY_ARGS = "--all-targets --all-features -- -D warnings" }
+
+[tasks.check-style]
+description = "Check for style violations"
+dependencies = ["check-format-flow", "clippy-flow"]
+
+[tasks.check-format]
+env = { LEPTOS_PROJECT_DIRECTORY = "../../" }
+args = ["fmt", "--", "--check", "--config-path", "${LEPTOS_PROJECT_DIRECTORY}"]
+
+[tasks.clean-cargo]
+description = "Runs the cargo clean command."
+category = "Cleanup"
+command = "cargo"
+args = ["clean"]
+
+[tasks.clean-trunk]
+description = "Runs the trunk clean command."
+category = "Cleanup"
+command = "trunk"
+args = ["clean"]
+
+[tasks.clean-node_modules]
+description = "Delete all node_modules directories"
+category = "Cleanup"
+script = '''
+find . -type d -name node_modules | xargs rm -rf
+'''
+
+[tasks.clean-playwright]
+description = "Delete playwright directories"
+category = "Cleanup"
+script = '''
+for pw_dir in $(find . -name playwright.config.ts | xargs dirname)
+do
+  rm -rf $pw_dir/playwright-report pw_dir/playwright pw_dir/test-results
+done
+'''
+
+[tasks.clean-all]
+description = "Delete all temporary directories"
+category = "Cleanup"
+dependencies = ["clean-cargo"]
+
+[tasks.test-wasm]
+env = { CARGO_MAKE_WASM_TEST_ARGS = "--headless --chrome" }
+command = "cargo"
+args = ["make", "wasm-pack-test"]
+
+[tasks.cargo-leptos-e2e]
+description = "Runs end to end tests with cargo leptos"
+command = "cargo"
+args = ["leptos", "end-to-end"]
+
+[tasks.setup-node]
+description = "Install node dependencies and playwright browsers"
+env = { PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD = "1" }
+script = '''
+BOLD="\e[1m"
+GREEN="\e[0;32m"
+RED="\e[0;31m"
+RESET="\e[0m"
+
+project_dir=$CARGO_MAKE_WORKING_DIRECTORY
+
+# Discover commands
+if command -v pnpm; then
+    NODE_CMD=pnpm
+    PLAYWRIGHT_CMD=pnpm
+elif command -v npm; then
+    NODE_CMD=npm
+    PLAYWRIGHT_CMD=npx
+else
+    echo "${RED}${BOLD}ERROR${RESET} - pnpm or npm is required by this task"
+    exit 1
+fi
+
+# Install node dependencies
+for node_path in $(find . -name package.json -not -path '*/node_modules/*')
+do
+  node_dir=$(dirname $node_path)
+  echo Install node dependencies for $node_dir
+  cd $node_dir
+  ${NODE_CMD} install
+  cd ${project_dir}
+done
+
+# Install playwright browsers
+for pw_path in $(find . -name playwright.config.ts)
+do
+  pw_dir=$(dirname $pw_path)
+  echo Install playwright browsers for $pw_dir
+  cd $pw_dir
+  ${PLAYWRIGHT_CMD} playwright install
+  cd $project_dir
+done
+'''

examples/cargo-make/compile.toml

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

examples/cargo-make/lint.toml

@@ -1,9 +0,0 @@
-[tasks.pre-clippy]
-env = { CARGO_MAKE_CLIPPY_ARGS = "--all-targets --all-features -- -D warnings" }
-
-[tasks.check-style]
-dependencies = ["check-format-flow", "clippy-flow"]
-
-[tasks.check-format]
-env = { LEPTOS_PROJECT_DIRECTORY = "../../" }
-args = ["fmt", "--", "--check", "--config-path", "${LEPTOS_PROJECT_DIRECTORY}"]

examples/cargo-make/main.toml

@@ -1,41 +1,35 @@
-extend = [
-    { path = "../cargo-make/compile.toml" },
-    { path = "../cargo-make/clean.toml" },
-    { path = "../cargo-make/lint.toml" },
-    { path = "../cargo-make/node.toml" },
-]
-
-# CI Stages
+extend = [{ path = "../cargo-make/common.toml" }]
 
 [tasks.ci]
-dependencies = ["prepare", "lint", "build", "test-flow", "integration-test"]
-
-[tasks.prepare]
-dependencies = ["setup-node"]
-
-[tasks.lint]
-dependencies = ["check-style"]
-
-[tasks.integration-test]
-
-# Support Local Runs
-
-[tasks.ci-clean]
-dependencies = ["ci", "clean"]
-
-[tasks.check-clean]
-dependencies = ["check", "clean"]
-
-[tasks.build-clean]
-dependencies = ["build", "clean"]
-
-# ALIASES
+alias = "verify-flow"
 
 [tasks.verify-flow]
-alias = "ci"
+description = "Provides pre and post hooks for verify"
+dependencies = ["pre-verify", "verify", "post-verify"]
 
-[tasks.t]
-dependencies = ["test-flow"]
+[tasks.verify]
+description = "Run all quality checks and tests"
+dependencies = ["check-style", "test-unit-and-e2e"]
 
-[tasks.it]
-alias = "integration-test"
+[tasks.test-unit-and-e2e]
+description = "Run all unit and e2e tests"
+dependencies = ["test-flow", "test-e2e-flow"]
+
+[tasks.pre-verify]
+
+[tasks.post-verify]
+dependencies = ["maybe-clean-all"]
+
+[tasks.maybe-clean-all]
+description = "Used to clean up locally after call to verify-examples"
+condition = { env_true = ["CLEAN_AFTER_VERIFY"] }
+
+[tasks.test-e2e-flow]
+description = "Provides pre and post hooks for test-e2e"
+dependencies = ["pre-test-e2e", "test-e2e", "post-test-e2e"]
+
+[tasks.pre-test-e2e]
+
+[tasks.test-e2e]
+
+[tasks.post-test-e2e]

examples/cargo-make/node.toml

@@ -1,43 +0,0 @@
-[tasks.setup-node]
-description = "Install node dependencies and playwright browsers"
-env = { PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD = "1" }
-script = '''
-BOLD="\e[1m"
-GREEN="\e[0;32m"
-RED="\e[0;31m"
-RESET="\e[0m"
-
-project_dir=$CARGO_MAKE_WORKING_DIRECTORY
-
-# Discover commands
-if command -v pnpm; then
-    NODE_CMD=pnpm
-    PLAYWRIGHT_CMD=pnpm
-elif command -v npm; then
-    NODE_CMD=npm
-    PLAYWRIGHT_CMD=npx
-else
-    echo "${RED}${BOLD}ERROR${RESET} - pnpm or npm is required by this task"
-    exit 1
-fi
-
-# Install node dependencies
-for node_path in $(find . -name package.json -not -path '*/node_modules/*')
-do
-  node_dir=$(dirname $node_path)
-  echo Install node dependencies for $node_dir
-  cd $node_dir
-  ${NODE_CMD} install
-  cd ${project_dir}
-done
-
-# Install playwright browsers
-for pw_path in $(find . -name playwright.config.ts)
-do
-  pw_dir=$(dirname $pw_path)
-  echo Install playwright browsers for $pw_dir
-  cd $pw_dir
-  ${PLAYWRIGHT_CMD} playwright install
-  cd $project_dir
-done
-'''

examples/cargo-make/playwright-test.toml

@@ -1,4 +1,7 @@
 extend = [{ path = "../cargo-make/playwright.toml" }]
 
-[tasks.integration-test]
-dependencies = ["test-playwright-autostart"]
+[tasks.test-e2e]
+dependencies = ["setup-node", "test-playwright-autostart"]
+
+[tasks.clean-all]
+dependencies = ["clean-cargo", "clean-node_modules", "clean-playwright"]

examples/cargo-make/playwright.toml

@@ -1,8 +1,22 @@
+[tasks.clean-playwright]
+description = "Delete playwright directories"
+category = "Cleanup"
+script = '''
+for pw_dir in $(find . -name playwright.config.ts | xargs dirname)
+do
+  rm -rf $pw_dir/playwright-report pw_dir/playwright pw_dir/test-results
+done
+'''
+
 [tasks.test-playwright-autostart]
+description = "Run playwright test with server autostart"
+category = "Test"
 command = "npm"
 args = ["run", "e2e:auto-start"]
 
 [tasks.test-playwright]
+description = "Run playwright test"
+category = "Test"
 script = '''
 BOLD="\e[1m"
 GREEN="\e[0;32m"
@@ -32,6 +46,8 @@ done
 '''
 
 [tasks.test-playwright-ui]
+description = "Run playwright test --ui"
+category = "Test"
 script = '''
 BOLD="\e[1m"
 GREEN="\e[0;32m"
@@ -61,6 +77,8 @@ done
 '''
 
 [tasks.test-playwright-report]
+description = "Run playwright show-report"
+category = "Test"
 script = '''
 BOLD="\e[1m"
 GREEN="\e[0;32m"

examples/cargo-make/trunk_server.toml

@@ -2,9 +2,13 @@
 command = "trunk"
 args = ["build"]
 
+[tasks.clean-trunk]
+command = "trunk"
+args = ["clean"]
+
 [tasks.start-trunk]
 command = "trunk"
-args = ["serve", "${@}"]
+args = ["serve", "--open"]
 
 [tasks.stop-trunk]
 script = '''

examples/cargo-make/wasm-test.toml

@@ -5,7 +5,5 @@ condition = { env_true = ["RUN_CARGO_TEST"] }
 [tasks.post-test]
 dependencies = ["test-wasm"]
 
-[tasks.test-wasm]
-env = { CARGO_MAKE_WASM_TEST_ARGS = "--headless --chrome" }
-command = "cargo"
-args = ["make", "wasm-pack-test"]
+[tasks.clean-all]
+dependencies = ["clean-cargo", "clean-trunk"]

examples/cargo-make/webdriver.toml

@@ -1,30 +0,0 @@
-[tasks.start-webdriver]
-script = '''
-  BOLD="\e[1m"
-  GREEN="\e[0;32m"
-  RED="\e[0;31m"
-  RESET="\e[0m"
-
-  if command -v chromedriver; then
-    if [ -z $(pidof chromedriver) ]; then
-      chromedriver --port=4444 &
-    fi
-  else
-    echo "${RED}${BOLD}ERROR${RESET} - chromedriver is required by this task"
-    exit 1
-  fi
-'''
-
-[tasks.stop-webdriver]
-script = '''
-  pkill -f "chromedriver"
-'''
-
-[tasks.webdriver-status]
-script = '''
-  if [ -z $(pidof chromedriver) ]; then
-    echo chromedriver is not running
-  else
-    echo chromedriver is up
-  fi
-'''

examples/counter/Makefile.toml

@@ -2,3 +2,13 @@ extend = [
     { path = "../cargo-make/main.toml" },
     { path = "../cargo-make/wasm-test.toml" },
 ]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/counter_isomorphic/Cargo.toml

@@ -25,7 +25,7 @@ leptos_meta = { path = "../../meta" }
 leptos_router = { path = "../../router" }
 log = "0.4"
 gloo-net = { git = "https://github.com/rustwasm/gloo" }
-wasm-bindgen = "=0.2.87"
+wasm-bindgen = "=0.2.86"
 serde = { version = "1", features = ["derive"] }
 
 [features]

examples/counter_isomorphic/Makefile.toml

@@ -1 +1,11 @@
 extend = [{ path = "../cargo-make/main.toml" }]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/counter_isomorphic/src/counters.rs

@@ -67,10 +67,24 @@ pub fn Counters(cx: Scope) -> impl IntoView {
             <Link rel="shortcut icon" type_="image/ico" href="/favicon.ico"/>
             <main>
                 <Routes>
-                    <Route path="" view=Counter/>
-                    <Route path="form" view=FormCounter/>
-                    <Route path="multi" view=MultiuserCounter/>
-                    <Route path="multi" view=NotFound/>
+                    <Route
+                        path=""
+                        view=|cx| {
+                            view! { cx, <Counter/> }
+                        }
+                    />
+                    <Route
+                        path="form"
+                        view=|cx| {
+                            view! { cx, <FormCounter/> }
+                        }
+                    />
+                    <Route
+                        path="multi"
+                        view=|cx| {
+                            view! { cx, <MultiuserCounter/> }
+                        }
+                    />
                 </Routes>
             </main>
         </Router>
@@ -161,9 +175,13 @@ pub fn FormCounter(cx: Scope) -> impl IntoView {
                 "This counter uses forms to set the value on the server. When progressively enhanced, it should behave identically to the “Simple Counter.”"
             </p>
             <div>
+                // calling a server function is the same as POSTing to its API URL
+                // so we can just do that with a form and button
                 <ActionForm action=clear>
                     <input type="submit" value="Clear"/>
                 </ActionForm>
+                // We can submit named arguments to the server functions
+                // by including them as input values with the same name
                 <ActionForm action=adjust>
                     <input type="hidden" name="delta" value="-1"/>
                     <input type="hidden" name="msg" value="form value down"/>
@@ -238,14 +256,3 @@ pub fn MultiuserCounter(cx: Scope) -> impl IntoView {
         </div>
     }
 }
-
-#[component]
-fn NotFound(cx: Scope) -> impl IntoView {
-    #[cfg(feature = "ssr")]
-    {
-        let resp = expect_context::<leptos_actix::ResponseOptions>(cx);
-        resp.set_status(actix_web::http::StatusCode::NOT_FOUND);
-    }
-
-    view! { cx, <h1>"Not Found"</h1> }
-}

examples/counter_isomorphic/src/main.rs

@@ -52,36 +52,15 @@ cfg_if! {
                 App::new()
                     .service(counter_events)
                     .route("/api/{tail:.*}", leptos_actix::handle_server_fns())
-                    // serve JS/WASM/CSS from `pkg`
-                    .service(Files::new("/pkg", format!("{site_root}/pkg")))
-                    // serve other assets from the `assets` directory
-                    .service(Files::new("/assets", site_root))
-                    // serve the favicon from /favicon.ico
-                    .service(favicon)
-                    .leptos_routes(
-                        leptos_options.to_owned(),
-                        routes.to_owned(),
-                        Counters,
-                    )
-                    .app_data(web::Data::new(leptos_options.to_owned()))
+                    .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()
             .await
         }
-
-        #[actix_web::get("favicon.ico")]
-        async fn favicon(
-            leptos_options: actix_web::web::Data<leptos::LeptosOptions>,
-        ) -> actix_web::Result<actix_files::NamedFile> {
-            let leptos_options = leptos_options.into_inner();
-            let site_root = &leptos_options.site_root;
-            Ok(actix_files::NamedFile::open(format!(
-                "{site_root}/favicon.ico"
-            ))?)
         }
-    }
 
     // client-only main for Trunk
     else {

examples/counter_url_query/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "counter_url_query"
-version = "0.1.0"
-edition = "2021"
-
-[profile.release]
-codegen-units = 1
-lto = true
-
-[dependencies]
-leptos = { path = "../../leptos", features = ["csr", "nightly"] }
-leptos_router = { path = "../../router", features = ["csr"] }
-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_url_query/Makefile.toml

@@ -1 +0,0 @@
-extend = [{ path = "../cargo-make/main.toml" }]

examples/counter_url_query/README.md

@@ -1,7 +0,0 @@
-# Leptos Query Counter Example
-
-This example creates a simple counter whose state is persisted and synced in the url with query params.
-
-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_url_query/index.html

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

examples/counter_url_query/src/lib.rs

@@ -1,39 +0,0 @@
-use leptos::*;
-use leptos_router::*;
-
-/// A simple counter component.
-///
-/// You can use doc comments like this to document your component.
-#[component]
-pub fn SimpleQueryCounter(cx: Scope) -> impl IntoView {
-    let (count, set_count) = create_query_signal::<i32>(cx, "count");
-    let clear = move |_| set_count(None);
-    let decrement = move |_| set_count(Some(count().unwrap_or(0) - 1));
-    let increment = move |_| set_count(Some(count().unwrap_or(0) + 1));
-
-    let (msg, set_msg) = create_query_signal::<String>(cx, "message");
-    let update_msg = move |ev| {
-        let new_msg = event_target_value(&ev);
-        if new_msg.is_empty() {
-            set_msg(None);
-        } else {
-            set_msg(Some(new_msg));
-        }
-    };
-
-    view! { cx,
-        <div>
-            <button on:click=clear>"Clear"</button>
-            <button on:click=decrement>"-1"</button>
-            <span>"Value: " {move || count().unwrap_or(0)} "!"</span>
-            <button on:click=increment>"+1"</button>
-
-            <br />
-
-            <input
-                prop:value=move || msg().unwrap_or_default()
-                on:input=update_msg
-            />
-        </div>
-    }
-}

examples/counter_url_query/src/main.rs

@@ -1,17 +0,0 @@
-use counter_url_query::SimpleQueryCounter;
-use leptos::*;
-use leptos_router::*;
-
-pub fn main() {
-    _ = console_log::init_with_level(log::Level::Debug);
-    console_error_panic_hook::set_once();
-    mount_to_body(|cx| {
-        view! { cx,
-            <Router>
-                <Routes>
-                    <Route path="" view=SimpleQueryCounter />
-                </Routes>
-            </Router>
-        }
-    })
-}

examples/counter_without_macros/Makefile.toml

@@ -4,13 +4,11 @@ extend = [
 ]
 
 [tasks.build]
-toolchain = "stable"
 command = "cargo"
-args = ["build-all-features"]
+args = ["+stable", "build-all-features"]
 install_crate = "cargo-all-features"
 
 [tasks.check]
-toolchain = "stable"
 command = "cargo"
-args = ["check-all-features"]
+args = ["+stable", "check-all-features"]
 install_crate = "cargo-all-features"

examples/counters/Makefile.toml

@@ -2,3 +2,13 @@ extend = [
     { path = "../cargo-make/main.toml" },
     { path = "../cargo-make/wasm-test.toml" },
 ]
+
+[tasks.build]
+command = "cargo"
+args = ["+nightly", "build-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"

examples/counters_stable/Cargo.toml

@@ -5,23 +5,10 @@ edition = "2021"
 
 [dependencies]
 leptos = { path = "../../leptos", features = ["csr"] }
-leptos_meta = { path = "../../meta", features = ["csr"] }
 log = "0.4"
 console_log = "1"
 console_error_panic_hook = "0.1.7"
 
 [dev-dependencies]
-wasm-bindgen = "0.2.87"
-wasm-bindgen-test = "0.3.37"
-pretty_assertions = "1.3.0"
+wasm-bindgen-test = "0.3.0"
 
-[dev-dependencies.web-sys]
-features = [
-    "Event",
-    "EventInit",
-    "EventTarget",
-    "HtmlElement",
-    "HtmlInputElement",
-    "XPathResult",
-]
-version = "0.3.64"

examples/counters_stable/Makefile.toml

@@ -1,18 +1,10 @@
 extend = [
     { path = "../cargo-make/main.toml" },
-    { path = "../cargo-make/wasm-test.toml" },
     { path = "../cargo-make/trunk_server.toml" },
     { path = "../cargo-make/playwright-test.toml" },
 ]
 
 [tasks.build]
-toolchain = "stable"
 command = "cargo"
-args = ["build-all-features"]
-install_crate = "cargo-all-features"
-
-[tasks.check]
-toolchain = "stable"
-command = "cargo"
-args = ["check-all-features"]
+args = ["+stable", "build-all-features"]
 install_crate = "cargo-all-features"

examples/counters_stable/e2e/tests/add_1k_counters.spec.ts

@@ -1,8 +1,8 @@
 import { test, expect } from "@playwright/test";
-import { CountersPage } from "./fixtures/counters_page";
+import { CountersPage } from "./counters_page";
 
 test.describe("Add 1000 Counters", () => {
-  test("should increase the number of counters", async ({ page }) => {
+  test("should increment the total count by 1K", async ({ page }) => {
     const ui = new CountersPage(page);
 
     await Promise.all([
@@ -14,6 +14,7 @@ test.describe("Add 1000 Counters", () => {
     await ui.addOneThousandCounters();
     await ui.addOneThousandCounters();
 
+    await expect(ui.total).toHaveText("0");
     await expect(ui.counters).toHaveText("3000");
   });
 });

examples/counters_stable/e2e/tests/add_counter.spec.ts

@@ -1,8 +1,8 @@
 import { test, expect } from "@playwright/test";
-import { CountersPage } from "./fixtures/counters_page";
+import { CountersPage } from "./counters_page";
 
 test.describe("Add Counter", () => {
-  test("should increase the number of counters", async ({ page }) => {
+  test("should increment the total count", async ({ page }) => {
     const ui = new CountersPage(page);
     await ui.goto();
 
@@ -10,6 +10,7 @@ test.describe("Add Counter", () => {
     await ui.addCounter();
     await ui.addCounter();
 
+    await expect(ui.total).toHaveText("0");
     await expect(ui.counters).toHaveText("3");
   });
 });

examples/counters_stable/e2e/tests/clear_counters.spec.ts

@@ -1,5 +1,5 @@
 import { test, expect } from "@playwright/test";
-import { CountersPage } from "./fixtures/counters_page";
+import { CountersPage } from "./counters_page";
 
 test.describe("Clear Counters", () => {
   test("should reset the counts", async ({ page }) => {

examples/counters_stable/e2e/tests/counters_page.ts

@@ -5,11 +5,8 @@ export class CountersPage {
   readonly addCounterButton: Locator;
   readonly addOneThousandCountersButton: Locator;
   readonly clearCountersButton: Locator;
-
-  readonly incrementCountButton: Locator;
-  readonly counterInput: Locator;
   readonly decrementCountButton: Locator;
-  readonly removeCountButton: Locator;
+  readonly incrementCountButton: Locator;
 
   readonly total: Locator;
   readonly counters: Locator;
@@ -35,15 +32,9 @@ export class CountersPage {
       hasText: "+1",
     });
 
-    this.removeCountButton = page.locator("button", {
-      hasText: "x",
-    });
-
     this.total = page.getByTestId("total");
 
     this.counters = page.getByTestId("counters");
-
-    this.counterInput = page.getByRole("textbox");
   }
 
   async goto() {
@@ -61,17 +52,17 @@ export class CountersPage {
     this.addOneThousandCountersButton.click();
   }
 
-  async decrementCount(index: number = 0) {
+  async decrementCount() {
     await Promise.all([
-      this.decrementCountButton.nth(index).waitFor(),
-      this.decrementCountButton.nth(index).click(),
+      this.decrementCountButton.waitFor(),
+      this.decrementCountButton.click(),
     ]);
   }
 
-  async incrementCount(index: number = 0) {
+  async incrementCount() {
     await Promise.all([
-      this.incrementCountButton.nth(index).waitFor(),
-      this.incrementCountButton.nth(index).click(),
+      this.incrementCountButton.waitFor(),
+      this.incrementCountButton.click(),
     ]);
   }
 
@@ -81,18 +72,4 @@ export class CountersPage {
       this.clearCountersButton.click(),
     ]);
   }
-
-  async enterCount(count: string, index: number = 0) {
-    await Promise.all([
-      this.counterInput.nth(index).waitFor(),
-      this.counterInput.nth(index).fill(count),
-    ]);
-  }
-
-  async removeCounter(index: number = 0) {
-    await Promise.all([
-      this.removeCountButton.nth(index).waitFor(),
-      this.removeCountButton.nth(index).click(),
-    ]);
-  }
 }

examples/counters_stable/e2e/tests/decrement_count.spec.ts

@@ -1,8 +1,8 @@
 import { test, expect } from "@playwright/test";
-import { CountersPage } from "./fixtures/counters_page";
+import { CountersPage } from "./counters_page";
 
 test.describe("Decrement Count", () => {
-  test("should decrease the total count", async ({ page }) => {
+  test("should decrement the total count", async ({ page }) => {
     const ui = new CountersPage(page);
     await ui.goto();
     await ui.addCounter();
@@ -12,5 +12,6 @@ test.describe("Decrement Count", () => {
     await ui.decrementCount();
 
     await expect(ui.total).toHaveText("-3");
+    await expect(ui.counters).toHaveText("1");
   });
 });

examples/counters_stable/e2e/tests/enter_count.spec.ts

@@ -1,30 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { CountersPage } from "./fixtures/counters_page";
-
-test.describe("Enter Count", () => {
-  test("should increase the total count", async ({ page }) => {
-    const ui = new CountersPage(page);
-    await ui.goto();
-    await ui.addCounter();
-
-    await ui.enterCount("5");
-
-    await expect(ui.total).toHaveText("5");
-    await expect(ui.counters).toHaveText("1");
-  });
-
-  test("should decrease the total count", async ({ page }) => {
-    const ui = new CountersPage(page);
-    await ui.goto();
-    await ui.addCounter();
-    await ui.addCounter();
-    await ui.addCounter();
-
-    await ui.enterCount("100");
-    await ui.enterCount("100", 1);
-    await ui.enterCount("100", 2);
-    await ui.enterCount("50", 1);
-
-    await expect(ui.total).toHaveText("250");
-  });
-});

examples/counters_stable/e2e/tests/increment_count.spec.ts

@@ -1,8 +1,8 @@
 import { test, expect } from "@playwright/test";
-import { CountersPage } from "./fixtures/counters_page";
+import { CountersPage } from "./counters_page";
 
 test.describe("Increment Count", () => {
-  test("should increase the total count", async ({ page }) => {
+  test("should increment the total count", async ({ page }) => {
     const ui = new CountersPage(page);
     await ui.goto();
     await ui.addCounter();
@@ -12,5 +12,6 @@ test.describe("Increment Count", () => {
     await ui.incrementCount();
 
     await expect(ui.total).toHaveText("3");
+    await expect(ui.counters).toHaveText("1");
   });
 });

examples/counters_stable/e2e/tests/remove_counter.spec.ts

@@ -1,17 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { CountersPage } from "./fixtures/counters_page";
-
-test.describe("Remove Counter", () => {
-  test("should decrement the number of counters", async ({ page }) => {
-    const ui = new CountersPage(page);
-    await ui.goto();
-
-    await ui.addCounter();
-    await ui.addCounter();
-    await ui.addCounter();
-
-    await ui.removeCounter(1);
-
-    await expect(ui.counters).toHaveText("2");
-  });
-});

examples/counters_stable/e2e/tests/view_counters.spec.ts

@@ -1,8 +1,8 @@
 import { test, expect } from "@playwright/test";
-import { CountersPage } from "./fixtures/counters_page";
+import { CountersPage } from "./counters_page";
 
 test.describe("View Counters", () => {
-  test("should see the title", async ({ page }) => {
+  test("should_see_the_title", async ({ page }) => {
     const ui = new CountersPage(page);
     await ui.goto();
 

examples/counters_stable/src/lib.rs

@@ -1,109 +0,0 @@
-use leptos::*;
-use leptos_meta::*;
-
-const MANY_COUNTERS: usize = 1000;
-
-type CounterHolder = Vec<(usize, (ReadSignal<i32>, WriteSignal<i32>))>;
-
-#[derive(Copy, Clone)]
-struct CounterUpdater {
-    set_counters: WriteSignal<CounterHolder>,
-}
-
-#[component]
-pub fn Counters(cx: Scope) -> impl IntoView {
-    let (next_counter_id, set_next_counter_id) = create_signal(cx, 0);
-    let (counters, set_counters) = create_signal::<CounterHolder>(cx, vec![]);
-    provide_context(cx, CounterUpdater { set_counters });
-    provide_meta_context(cx);
-
-    let add_counter = move |_| {
-        let id = next_counter_id.get();
-        let sig = create_signal(cx, 0);
-        set_counters.update(move |counters| counters.push((id, sig)));
-        set_next_counter_id.update(|id| *id += 1);
-    };
-
-    let add_many_counters = move |_| {
-        let next_id = next_counter_id.get();
-        let new_counters = (next_id..next_id + MANY_COUNTERS).map(|id| {
-            let signal = create_signal(cx, 0);
-            (id, signal)
-        });
-
-        set_counters.update(move |counters| counters.extend(new_counters));
-        set_next_counter_id.update(|id| *id += MANY_COUNTERS);
-    };
-
-    let clear_counters = move |_| {
-        set_counters.update(|counters| counters.clear());
-    };
-
-    view! { cx,
-        <Title text="Counters (Stable)" />
-        <div>
-            <button on:click=add_counter>
-                "Add Counter"
-            </button>
-            <button on:click=add_many_counters>
-                {format!("Add {MANY_COUNTERS} Counters")}
-            </button>
-            <button on:click=clear_counters>
-                "Clear Counters"
-            </button>
-            <p>
-                "Total: "
-                <span data-testid="total">{move ||
-                    counters.get()
-                        .iter()
-                        .map(|(_, (count, _))| count.get())
-                        .sum::<i32>()
-                        .to_string()
-                }</span>
-                " from "
-                <span data-testid="counters">{move || counters.with(|counters| counters.len()).to_string()}</span>
-                " counters."
-            </p>
-            <ul>
-                <For
-                    each={move || counters.get()}
-                    key={|counter| counter.0}
-                    view=move |cx, (id, (value, set_value))| {
-                        view! {
-                            cx,
-                            <Counter id value set_value/>
-                        }
-                    }
-                />
-            </ul>
-        </div>
-    }
-}
-
-#[component]
-fn Counter(
-    cx: Scope,
-    id: usize,
-    value: ReadSignal<i32>,
-    set_value: WriteSignal<i32>,
-) -> impl IntoView {
-    let CounterUpdater { set_counters } = use_context(cx).unwrap();
-
-    let input = move |ev| {
-        set_value
-            .set(event_target_value(&ev).parse::<i32>().unwrap_or_default())
-    };
-
-    view! { cx,
-        <li>
-            <button data-testid="decrement_count" on:click=move |_| set_value.update(move |value| *value -= 1)>"-1"</button>
-            <input data-testid="counter_input" type="text"
-                prop:value={move || value.get().to_string()}
-                on:input=input
-            />
-            <span>{value}</span>
-            <button data-testid="increment_count" on:click=move |_| set_value.update(move |value| *value += 1)>"+1"</button>
-            <button data-testid="remove_counter" on:click=move |_| set_counters.update(move |counters| counters.retain(|(counter_id, _)| counter_id != &id))>"x"</button>
-        </li>
-    }
-}