fix: correctly handle external origins in redirect hook (closes #2269)

* fix(ci): empty directory vector error

* chore(ci): simulate example change

* chore(ci): remove simulated example change

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,39 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**Leptos Dependencies**
+
+Please copy and paste the Leptos dependencies and features from your `Cargo.toml`.
+
+For example:
+```toml
+leptos = { version = "0.3", features = ["serde"] }
+leptos_axum = { version = "0.3", optional = true }
+leptos_meta = { version = "0.3"}
+leptos_router = { version = "0.3"}
+```
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,7 @@
+contact_links:
+  - name: Support or Question
+    url: https://github.com/leptos-rs/leptos/discussions/new?category=q-a
+    about: Do you need help figuring out how to do something, or want some help troubleshooting a bug? You can ask in our Discussions section.
+  - name: Discord Discussions
+    url: https://discord.gg/YdRAhS7eQB
+    about: For more informal, real-time conversation and support, you can join our Discord server.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

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

@@ -0,0 +1,32 @@
+name: CI Changed Examples
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  get-example-changed:
+    uses: ./.github/workflows/get-example-changed.yml
+
+  get-matrix:
+    needs: [get-example-changed]
+    uses: ./.github/workflows/get-changed-examples-matrix.yml
+    with:
+      example_changed: ${{ fromJSON(needs.get-example-changed.outputs.example_changed) }}
+
+  test:
+    name: CI
+    needs: [get-example-changed, get-matrix]
+    if: needs.get-example-changed.outputs.example_changed == 'true'
+    strategy:
+      matrix: ${{ fromJSON(needs.get-matrix.outputs.matrix) }}
+      fail-fast: false
+    uses: ./.github/workflows/run-cargo-make-task.yml
+    with:
+      directory: ${{ matrix.directory }}
+      cargo_make_task: "ci"
+      toolchain: nightly-2024-01-29

.github/workflows/ci-examples.yml

@@ -0,0 +1,27 @@
+name: CI Examples
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  get-leptos-changed:
+    uses: ./.github/workflows/get-leptos-changed.yml
+  get-examples-matrix:
+    uses: ./.github/workflows/get-examples-matrix.yml
+  test:
+    name: CI
+    needs: [get-leptos-changed, get-examples-matrix]
+    if: needs.get-leptos-changed.outputs.leptos_changed == 'true'
+    strategy:
+      matrix: ${{ fromJSON(needs.get-examples-matrix.outputs.matrix) }}
+      fail-fast: false
+    uses: ./.github/workflows/run-cargo-make-task.yml
+    with:
+      directory: ${{ matrix.directory }}
+      cargo_make_task: "ci"
+      toolchain: nightly-2024-01-29

.github/workflows/ci-stable-examples.yml

@@ -0,0 +1,26 @@
+name: CI Stable Examples
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  get-leptos-changed:
+    uses: ./.github/workflows/get-leptos-changed.yml
+
+  test:
+    name: CI
+    needs: [get-leptos-changed]
+    if: needs.get-leptos-changed.outputs.leptos_changed == 'true'
+    strategy:
+      matrix:
+        directory: [examples/counters_stable, examples/counter_without_macros]
+    uses: ./.github/workflows/run-cargo-make-task.yml
+    with:
+      directory: ${{ matrix.directory }}
+      cargo_make_task: "ci"
+      toolchain: stable

.github/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  get-leptos-changed:
+    uses: ./.github/workflows/get-leptos-changed.yml
+
+  test:
+    name: CI
+    needs: [get-leptos-changed]
+    if: needs.get-leptos-changed.outputs.leptos_changed == 'true'
+    strategy:
+      matrix:
+        directory:
+          [
+            integrations/actix,
+            integrations/axum,
+            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"
+      toolchain: nightly-2024-01-29

.github/workflows/get-changed-examples-matrix.yml

@@ -0,0 +1,55 @@
+name: Changed Examples Matrix Call
+
+on:
+  workflow_call:
+    inputs:
+      example_changed:
+        description: "Example Changed"
+        required: true
+        type: boolean
+    outputs:
+      matrix:
+        description: "Matrix"
+        value: ${{ jobs.get-example-changed.outputs.matrix }}
+
+jobs:
+  get-example-changed:
+    name: Get Changed Example Matrix
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Get example project directories that changed
+        id: changed-dirs
+        uses: tj-actions/changed-files@v41
+        with:
+          dir_names: true
+          dir_names_max_depth: "2"
+          files: |
+            examples/**
+            !examples/cargo-make
+            !examples/gtk
+            !examples/hackernews_js_fetch
+            !examples/Makefile.toml
+            !examples/*.md
+          json: true
+          quotepath: false
+
+      - name: List example project directories that changed
+        run: echo '${{ steps.changed-dirs.outputs.all_changed_files }}'
+
+      - name: Set Matrix
+        id: set-matrix
+        run: |
+          if [ ${{ inputs.example_changed }} == 'true' ]; then
+            # Create matrix with changed directories
+            echo "matrix={\"directory\":${{ steps.changed-dirs.outputs.all_changed_files }}}" >> "$GITHUB_OUTPUT"
+          else
+            # Create matrix with one item to prevent an empty vector error
+            echo "matrix={\"directory\":[\"NO_CHANGE\"]}" >> "$GITHUB_OUTPUT"
+          fi

.github/workflows/get-example-changed.yml

@@ -0,0 +1,39 @@
+name: Examples Changed Call
+
+on:
+  workflow_call:
+    outputs:
+      example_changed:
+        description: "Example Changed"
+        value: ${{ jobs.get-example-changed.outputs.example_changed }}
+
+jobs:
+  get-example-changed:
+    name: Get Example Changed
+    runs-on: ubuntu-latest
+    outputs:
+      example_changed: ${{ steps.set-example-changed.outputs.example_changed }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Get example files that changed
+        id: changed-files
+        uses: tj-actions/changed-files@v41
+        with:
+          files: |
+            examples/**
+            !examples/cargo-make
+            !examples/gtk
+            !examples/Makefile.toml
+            !examples/*.md
+
+      - name: List example files that changed
+        run: echo '${{ steps.changed-files.outputs.all_changed_files }}'
+
+      - name: Set example_changed
+        id: set-example-changed
+        run: |
+          echo "example_changed=${{ steps.changed-files.outputs.any_changed }}" >> "$GITHUB_OUTPUT"

.github/workflows/get-examples-matrix.yml

@@ -0,0 +1,40 @@
+name: Get Examples Matrix Call
+
+on:
+  workflow_call:
+    outputs:
+      matrix:
+        description: "Matrix"
+        value: ${{ jobs.create.outputs.matrix }}
+
+jobs:
+  create:
+    name: Create Examples Matrix
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install JQ Tool
+        uses: mbround18/install-jq@v1
+
+      - name: Set Matrix
+        id: set-matrix
+        run: |
+          examples=$(ls examples |
+          awk '{print "examples/" $0}' |
+          grep -v .md |
+          grep -v examples/Makefile.toml |
+          grep -v examples/cargo-make |
+          grep -v examples/gtk |
+          jq -R -s -c 'split("\n")[:-1]')
+          echo "Example Directories: $examples"
+          echo "matrix={\"directory\":$examples}" >> "$GITHUB_OUTPUT"
+
+      - name: Print Location Info
+        run: |
+          echo "Workspace: ${{ github.workspace }}"
+          pwd
+          ls | sort -u

.github/workflows/get-leptos-changed.yml

@@ -0,0 +1,44 @@
+name: Get Leptos Changed Call
+
+on:
+  workflow_call:
+    outputs:
+      leptos_changed:
+        description: "Leptos Changed"
+        value: ${{ jobs.create.outputs.leptos_changed }}
+
+jobs:
+  create:
+    name: Detect Source Change
+    runs-on: ubuntu-latest
+    outputs:
+      leptos_changed: ${{ steps.set-source-changed.outputs.leptos_changed }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Get source files that changed
+        id: changed-source
+        uses: tj-actions/changed-files@v41
+        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 leptos_changed
+        id: set-source-changed
+        run: |
+          echo "leptos_changed=${{ steps.changed-source.outputs.any_changed }}" >> "$GITHUB_OUTPUT"

.github/workflows/publish-book.yml

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

.github/workflows/run-cargo-make-task.yml

@@ -0,0 +1,114 @@
+name: Run Task
+
+on:
+  workflow_call:
+    inputs:
+      directory:
+        required: true
+        type: string
+      cargo_make_task:
+        required: true
+        type: string
+      toolchain:
+        required: true
+        type: string
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
+
+jobs:
+  test:
+    name: Run ${{ inputs.cargo_make_task }} (${{ inputs.toolchain }})
+    runs-on: ubuntu-latest
+
+    steps:
+      # Setup environment
+      - uses: actions/checkout@v4
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ inputs.toolchain }}
+          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: Install Trunk
+        uses: jetli/trunk-action@v0.4.0
+        with:
+          version: "latest"
+
+      - name: Print Trunk Version
+        run: trunk --version
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+
+      - uses: pnpm/action-setup@v2
+        name: Install pnpm
+        id: pnpm-install
+        with:
+          version: 8
+          run_install: false
+
+      - name: Get pnpm store directory
+        id: pnpm-cache
+        run: |
+          echo "STORE_PATH=$(pnpm store path)" >> $GITHUB_OUTPUT
+
+      - uses: actions/cache@v3
+        name: Setup pnpm cache
+        with:
+          path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Maybe install chromedriver
+        run: |
+          project_makefile=${{inputs.directory}}/Makefile.toml
+          webdriver_count=$(cat $project_makefile | grep "cargo-make/webdriver.toml" | wc -l)
+          if [ $webdriver_count -eq 1 ]; then
+              if ! command -v chromedriver &>/dev/null; then
+                  echo chromedriver required
+                  sudo apt-get update
+                  sudo apt-get install chromium-chromedriver
+              else
+                  echo chromedriver is already installed
+              fi
+          else
+              echo chromedriver is not required
+          fi
+
+      - name: Maybe install playwright browser dependencies
+        run: |
+          for pw_path in $(find ${{inputs.directory}} -name playwright.config.ts)
+          do
+            pw_dir=$(dirname $pw_path)
+            if [ ! -v $pw_dir ]; then
+              echo "Playwright required in $pw_dir"
+              cd $pw_dir
+              pnpm dlx playwright install --with-deps
+            else
+              echo Playwright is not required
+            fi
+          done
+
+      # Run Cargo Make Task
+      - name: ${{ inputs.cargo_make_task }}
+        run: |
+          cd ${{ inputs.directory }}
+          cargo make --profile=github-actions ${{ inputs.cargo_make_task }}

.github/workflows/test.yml

@@ -1,48 +0,0 @@
-name: Test
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  test:
-    name: Test on ${{ 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
-
-      - name: Run Rustfmt
-        run: cargo fmt -- --check
-
-      - uses: Swatinem/rust-cache@v2
-
-      - name: Run tests with all features
-        run: cargo make ci

.gitignore

@@ -7,3 +7,8 @@ Cargo.lock
 **/*.rs.bk
 .DS_Store
 .idea
+.direnv
+.envrc
+
+.vscode
+vendor

ARCHITECTURE.md

@@ -0,0 +1,231 @@
+# Architecture
+
+The goal of this document is to make it easier for contributors (and anyone
+who’s interested!) to understand the architecture of the framework.
+
+The whole Leptos framework is built from a series of layers. Each of these layers
+depends on the one below it, but each can be used independently from the ones
+built on top of it. While running a command like `cargo leptos new --git 
+leptos-rs/start` pulls in the whole framework, it’s important to remember that
+none of this is magic: each layer of that onion can be stripped away and
+reimplemented, configured, or adapted as needed, incrementally.
+
+> Everything that follows will assume you have a good working understanding
+> of the framework. There will be explanations of how some parts of it work
+> or fit together, but these are not docs. They assume you know what I’m
+> talking about.
+
+## The Reactive System: `leptos_reactive`
+
+The reactive system allows you to define dynamic values (signals),
+the relationships between them (derived signals and memos), and the side effects
+that run in response to them (effects).
+
+These concepts are completely independent of the DOM and can be used to drive
+any kind of reactive updates. The reactive system is based on the assumption
+that data is relatively cheap, and side effects are relatively expensive. Its
+goal is to minimize those side effects (like updating the DOM or making a network
+requests) as infrequently as possible.
+
+The reactive system is implemented as a single data structure that exists at
+runtime. In exchange for giving ownership over a value to the reactive system
+(by creating a signal), you receive a `Copy + 'static` identifier for its
+location in the reactive system. This enables most of the ergonomics of storing
+and sharing state, the use of callback closures without lifetime issues, etc.
+This is implemented by storing signals in a slotmap arena. The signal, memo,
+and scope types that are exposed to users simply carry around an index into that
+slotmap.
+
+> Items owned by the reactive system are dropped when the corresponding reactive
+> scope is dropped, i.e., when the component or section of the UI they’re
+> created in is removed. In a sense, Leptos implements a “garbage collector”
+> in which the lifetime of data is tied to the lifetime of the UI, not Rust’s
+> lexical scopes.
+
+## The DOM Renderer: `leptos_dom`
+
+The reactive system can be used to drive any kinds of side effects. One very
+common side effect is calling an imperative method, for example to update the
+DOM.
+
+The entire DOM renderer is built on top of the reactive system. It provides
+a builder pattern that can be used to create DOM elements dynamically.
+
+The renderer assumes, as a convention, that dynamic attributes, classes,
+styles, and children are defined by being passed a `Fn() -> T`, where their
+static equivalents just receive `T`. There’s nothing about this that is
+divinely ordained, but it’s a useful convention because it allows us to use
+zero-overhead derived signals as one of several ways to indicate dynamic
+content.
+
+`leptos_dom` also contains code for server-side rendering of the same
+UI views to HTML, either for out-of-order streaming (`src/ssr.rs`) or
+in-order streaming/async rendering (`src/ssr_in_order.rs`).
+
+## The Macros: `leptos_macro`
+
+It’s entirely possible to write Leptos code with no macros at all. The
+`view` and `component` macros, the most common, can be replaced by
+the builder syntax and simple functions (see the `counter_without_macros`
+example). But the macros enable a JSX-like syntax for describing views.
+
+This package also contains the `Params` derive macro used for typed
+queries and route params in the router.
+
+### Macro-based Optimizations
+
+Leptos 0.0.x was built much more heavily on macros. Taking its cues  
+from SolidJS, the `view` macro emitted different code for CSR, SSR, and
+hydration, optimizing each. The CSR/hydrate versions worked by compiling
+the view to an HTML template string, cloning that `<template>`, and
+traversing the DOM to set up reactivity. The SSR version worked similarly
+by compiling the static parts of the view to strings at compile time,
+reducing the amount of work that needed to be done on each request.
+
+Proc macros are hard, and this system was brittle. 0.1 introduced a
+more robust renderer, including the builder syntax, and rebuilt the `view`
+macro to use that builder syntax instead. It moved the optimized-but-buggy
+CSR version of the macro to a more-limited `template` macro.
+
+The `view` macro now separately optimizes SSR to use the same static-string
+optimizations, which (by our benchmarks) makes Leptos about 3-4x faster
+than similar Rust frontend frameworks in its HTML rendering.
+
+> The optimization is pretty straightforward. Consider the following view:
+>
+> ```rust
+> view! { cx,
+>   <main class="text-center">
+>     <div class="flex-col">
+>       <button>"Click me."</button>
+>       <p class="italic">"Text."</p>
+>     </div>
+>   </main>
+> }
+> ```
+>
+> Internally, with the builder this is something like
+>
+> ```rust
+> Element {
+>   tag: "main",
+>   attrs: vec![("class", "text-center")],
+>   children: vec![
+> 	  Element {
+> 		tag: "div",
+> 		attrs: vec![("class", "flex-col")],
+>       children: vec![
+>         Element {
+> 	        tag: "button",
+> 			attrs: vec![],
+> 			children: vec!["Click me"]
+>         },
+>         Element {
+> 	        tag: "p",
+> 			attrs: vec![("class", "italic")],
+> 			children: vec!["Text"]
+>         }
+>       ]
+> 	  }
+>   ]
+> }
+> ```
+>
+> This is a _bunch_ of small allocations and separate strings,
+> and in early 0.1 versions we used a `SmallVec` for children and
+> attributes and actually caused some stack overflows.
+>
+> But if you look at the view itself you can see that none of this
+> will _ever_ change. So we can actually optimize it at compile
+> time to a single `&'static str`:
+>
+> ```rust
+> r#"<main class="text-center">
+>     <div class="flex-col">
+>       <button>"Click me."</button>
+>       <p class="italic">"Text."</p>
+>     </div>
+>   </main>"#
+> ```
+
+## Server Functions (`leptos_server`, `server_fn`, and `server_fn_macro`)
+
+Server functions are a framework-agnostic shorthand for converting
+a function, whose body can only be run on the server, into an ad hoc
+REST API endpoint, and then generating code on the client to call that
+endpoint when you call the function.
+
+These are inspired by Solid/Bling’s `server$` functions, and there’s
+similar work being done in a number of other JavaScript frameworks.
+
+RPC is not a new idea, but these kinds of server functions may be.
+Specifically, by using web standards (defaulting to `POST`/`GET` requests
+with URL-encoded form data) they allow easy graceful degradation and the
+use of the `<form>` element.
+
+This function is split across three packages so that `server_fn` and
+`server_fn_macro` can be used by other frameworks. `leptos_server`
+includes some Leptos-specific reactive functionality (like actions).
+
+## `leptos`
+
+This package is built on and reexports most of the layers already
+mentioned, and implements a number of control-flow components (`<Show/>`,
+`<ErrorBoundary/>`, `<For/>`, `<Suspense/>`, `<Transition/>`) that use
+public APIs of the other packages.
+
+This is the main entrypoint for users, but is relatively light itself.
+
+## `leptos_meta`
+
+This package exists to allow you to work with tags normally found in
+the `<head>`, from within your components.
+
+It is implemented as a distinct package, rather than part of
+`leptos_dom`, on the principle that “what can be implemented in userland,
+should be.” The framework can be used without it, so it’s not in core.
+
+## `leptos_router`
+
+The router originates as a direct port of `solid-router`, which is the
+origin of most of its terminology, architecture, and route-matching logic.
+
+Subsequent developments (like animated routing, and managing route transitions
+given the lack of `useTransition` in Leptos) have caused it to diverge
+slightly from Solid’s exact code, but it is still very closely related.
+
+The core principle here is “nested routing,” dividing a single page
+into independently-rendered parts. This is described in some detail in the docs.
+
+Like `leptos_meta`, it is implemented as a distinct package, because it
+can be replaced with another router or with none. The framework can be used
+without it, so it’s not in core.
+
+## Server Integrations
+
+The server integrations are the most “frameworky” layer of the whole framework.
+These **do** assume the use of `leptos`, `leptos_router`, and `leptos_meta`.
+They specifically draw routing data from `leptos_router`, and inject the
+metadata from `leptos_meta` into the `<head>` appropriately.
+
+But of course, if you one day create `leptos-helmet` and `leptos-better-router`,
+you can create new server integrations that plug them into the SSR rendering
+methods from `leptos_dom` instead. Everything involved is quite modular.
+
+These packages essentially provide helpers that save the templates and user apps
+from including a huge amount of boilerplate to connect the various other packages
+correctly. Again, early versions of the framework examples are illustrative here
+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.
+
+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
+WASM for the browser, building the server version, pulling in SASS and
+Tailwind, etc. It is an extremely good build tool, not a magic formula. Each
+of the examples includes instructions for how to run the examples without
+`cargo-leptos`.

CODE_OF_CONDUCT.md

@@ -2,7 +2,7 @@
 
 _This Code of Conduct is based on the [Rust Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct)
 and the [Bevy Code of Conduct](https://raw.githubusercontent.com/bevyengine/bevy/main/CODE_OF_CONDUCT.md),
-which are adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling) 
+which are adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling)
 and the [Contributor Covenant](https://www.contributor-covenant.org)._
 
 ## Our Pledge

CONTRIBUTING.md

@@ -0,0 +1,94 @@
+# Contributing to Leptos
+
+Thanks for your interesting in contributing to Leptos! This is a truly
+community-driven framework, and while we have a central maintainer (@gbj)
+large parts of the renderer, reactive system, and server integrations have
+all been written by other contributors. Contributions are always welcome.
+
+Participation in this community is governed by a [Code of Conduct](./CODE_OF_CONDUCT.md).
+Some of the most active conversations around development take place on our
+[Discord server](https://discord.gg/YdRAhS7eQB).
+
+This guide seeks to
+
+- describe some of the framework’s values (in a technical, not an ethical, sense)
+- provide a high-level overview of how the pieces of the framework fit together
+- orient you to the organization of this repository
+
+## Values
+
+Leptos, as a framework, reflects certain technical values:
+
+- **Expose primitives rather than imposing patterns.** Provide building blocks
+  that users can combine together to build up more complex behavior, rather than
+  requiring users follow certain templates, file formats, etc. e.g., components
+  are defined as functions, rather than a bespoke single-file component format.
+  The reactive system feeds into the rendering system, rather than being defined
+  by it.
+- **Bottom-up over top-down.** If you envision a user’s application as a tree
+  (like an HTML document), push meaning toward the leaves of the tree. e.g., If data
+  needs to be loaded, load it in a granular primitive (resources) rather than a
+  route- or page-level data structure.
+- **Performance by default.** When possible, users should only pay for what they
+  use. e.g., we don’t make all component props reactive by default. This is
+  because doing so would force the overhead of a reactive prop onto props that don’t
+  need to be reactive.
+- **Full-stack performance.** Performance can’t be limited to a single metric,
+  whether that’s a DOM rendering benchmark, WASM binary size, or server response
+  time. Use methods like HTTP streaming and progressive enhancement to enable
+  applications to load, become interactive, and respond as quickly as possible.
+- **Use safe Rust.** There’s no need for `unsafe` Rust in the framework, and
+  avoiding it at all costs reduces the maintenance and testing burden significantly.
+- **Embrace Rust semantics.** Especially in things like UI templating, use Rust
+  semantics or extend them in a predictable way with control-flow components
+  rather than overloading the meaning of Rust terms like `if` or `for` in a
+  framework-specific way.
+- **Enhance ergonomics without obfuscating what’s happening.** This is by far
+  the hardest to achieve. It’s often the case that adding additional layers to
+  improve DX (like a custom build tool and starter templates) comes across as
+  “too magic” to some people who haven’t had to build the same things manually.
+  When possible, make it easier to see how the pieces fit together, without
+  sacrificing the improved DX.
+
+## Processes
+
+We do not have PR templates or formal processes for approving PRs. But there
+are a few guidelines that will make it a better experience for everyone:
+
+- Run `cargo fmt` before submitting your code.
+- Keep PRs limited to addressing one feature or one issue, in general. In some
+  cases (e.g., “reduce allocations in the reactive system”) this may touch a number
+  of different areas, but is still conceptually one thing.
+- If it’s an unsolicited PR not linked to an open issue, please include a
+  specific explanation for what it’s trying to achieve. For example: “When I
+  was trying to deploy my app under _circumstances X_, I found that the way
+  _function Y_ was implemented caused _issue Z_. This PR should fix that by
+  _solution._”
+- Our CI tests every PR against all the existing examples, sometimes requiring
+  compilation for both server and client side, etc. It’s thorough but slow. If
+  you want to run CI locally to reduce frustration, you can do that by installing
+  `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

@@ -1,16 +1,22 @@
 [workspace]
+resolver = "2"
 members = [
   # core
   "leptos",
   "leptos_dom",
   "leptos_config",
+  "leptos_hot_reload",
   "leptos_macro",
   "leptos_reactive",
   "leptos_server",
+  "server_fn",
+  "server_fn_macro",
+  "server_fn/server_fn_macro_default",
 
   # integrations
   "integrations/actix",
   "integrations/axum",
+  "integrations/utils",
 
   # libraries
   "meta",
@@ -19,17 +25,22 @@ members = [
 exclude = ["benchmarks", "examples"]
 
 [workspace.package]
-version = "0.2.0-alpha"
+version = "0.6.5"
 
 [workspace.dependencies]
-leptos = { path = "./leptos", default-features = false, version = "0.2.0-alpha" }
-leptos_dom = { path = "./leptos_dom", default-features = false, version = "0.2.0-alpha" }
-leptos_macro = { path = "./leptos_macro", default-features = false, version = "0.2.0-alpha" }
-leptos_reactive = { path = "./leptos_reactive", default-features = false, version = "0.2.0-alpha" }
-leptos_server = { path = "./leptos_server", default-features = false, version = "0.2.0-alpha" }
-leptos_config = { path = "./leptos_config", default-features = false, version = "0.2.0-alpha" }
-leptos_router = { path = "./router", version = "0.2.0-alpha" }
-leptos_meta = { path = "./meta", default-feature = false, version = "0.2.0-alpha" }
+leptos = { path = "./leptos", version = "0.6.5" }
+leptos_dom = { path = "./leptos_dom", version = "0.6.5" }
+leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.6.5" }
+leptos_macro = { path = "./leptos_macro", version = "0.6.5" }
+leptos_reactive = { path = "./leptos_reactive", version = "0.6.5" }
+leptos_server = { path = "./leptos_server", version = "0.6.5" }
+server_fn = { path = "./server_fn", version = "0.6.5" }
+server_fn_macro = { path = "./server_fn_macro", version = "0.6.5" }
+server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.6" }
+leptos_config = { path = "./leptos_config", version = "0.6.5" }
+leptos_router = { path = "./router", version = "0.6.5" }
+leptos_meta = { path = "./meta", version = "0.6.5" }
+leptos_integration_utils = { path = "./integrations/utils", version = "0.6.5" }
 
 [profile.release]
 codegen-units = 1

Makefile.toml

@@ -3,51 +3,37 @@
 #     cargo install --force cargo-make
 ############
 
-[config]
-# make tasks run at the workspace root
-default_to_workspace = false
+[env]
+CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true
 
-[tasks.ci]
-dependencies = ["build", "check-examples", "test"]
-
-[tasks.build]
-clear = true
-dependencies = ["build-all", "build-wasm"]
-
-[tasks.build-all]
-command = "cargo"
-args = ["+nightly", "build-all-features"]
-install_crate = "cargo-all-features"
-
-[tasks.build-wasm]
-clear = true
-dependencies = [{ name = "build-wasm", path = "leptos" }]
-
-[tasks.check-examples]
+[tasks.check-stable]
+workspace = false
 clear = true
 dependencies = [
-	{ name = "check", path = "examples/counter" },
-	{ name = "check", path = "examples/counter_isomorphic" },
 	{ name = "check", path = "examples/counter_without_macros" },
-	{ name = "check", path = "examples/counters" },
 	{ name = "check", path = "examples/counters_stable" },
-	{ 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/parent_child" },
-	{ name = "check", path = "examples/router" },
-	{ name = "check", path = "examples/tailwind" },
-	{ name = "check", path = "examples/todo_app_sqlite" },
-	{ name = "check", path = "examples/todo_app_sqlite_axum" },
-	{ name = "check", path = "examples/todomvc" },
 ]
 
-[tasks.test]
-clear = true
-dependencies = ["test-all"]
-
-[tasks.test-all]
+[tasks.ci-examples]
+workspace = false
+cwd = "examples"
 command = "cargo"
-args = ["+nightly", "test-all-features"]
-install_crate = "cargo-all-features"
+args = ["make", "ci-clean"]
+
+[tasks.check-examples]
+workspace = false
+cwd = "examples"
+command = "cargo"
+args = ["make", "check-clean"]
+
+[tasks.build-examples]
+workspace = false
+cwd = "examples"
+command = "cargo"
+args = ["make", "build-clean"]
+
+[tasks.clean-examples]
+workspace = false
+cwd = "examples"
+command = "cargo"
+args = ["make", "clean"]

README.md

@@ -6,6 +6,11 @@
 [![crates.io](https://img.shields.io/crates/v/leptos.svg)](https://crates.io/crates/leptos)
 [![docs.rs](https://docs.rs/leptos/badge.svg)](https://docs.rs/leptos)
 [![Discord](https://img.shields.io/discord/1031524867910148188?color=%237289DA&label=discord)](https://discord.gg/YdRAhS7eQB)
+[![Matrix](https://img.shields.io/badge/Matrix-leptos-grey?logo=matrix&labelColor=white&logoColor=black)](https://matrix.to/#/#leptos:matrix.org)
+
+[Website](https://leptos.dev) | [Book](https://leptos-rs.github.io/leptos/) | [Docs.rs](https://docs.rs/leptos/latest/leptos/) | [Playground](https://codesandbox.io/p/sandbox/leptos-rtfggt?file=%2Fsrc%2Fmain.rs%3A1%2C1) | [Discord](https://discord.gg/YdRAhS7eQB)
+
+You can find a list of useful libraries and example projects at [`awesome-leptos`](https://github.com/leptos-rs/awesome-leptos).
 
 # Leptos
 
@@ -13,9 +18,9 @@
 use leptos::*;
 
 #[component]
-pub fn SimpleCounter(cx: Scope, initial_value: i32) -> impl IntoView {
+pub fn SimpleCounter(initial_value: i32) -> impl IntoView {
     // create a reactive signal with the initial value
-    let (value, set_value) = create_signal(cx, initial_value);
+    let (value, set_value) = create_signal(initial_value);
 
     // create event handlers for our buttons
     // note that `value` and `set_value` are `Copy`, so it's super easy to move them into closures
@@ -25,21 +30,41 @@ pub fn SimpleCounter(cx: Scope, initial_value: i32) -> impl IntoView {
 
     // create user interfaces with the declarative `view!` macro
     view! {
-        cx,
         <div>
-            <button on:click=clear>"Clear"</button>
-            <button on:click=decrement>"-1"</button>
+            <button on:click=clear>Clear</button>
+            <button on:click=decrement>-1</button>
+            // text nodes can be quoted or unquoted
             <span>"Value: " {value} "!"</span>
-            <button on:click=increment>"+1"</button>
+            <button on:click=increment>+1</button>
         </div>
     }
 }
 
-// Easy to use with Trunk (trunkrs.dev) or with a simple wasm-bindgen setup
-pub fn main() {
-    mount_to_body(|cx| view! { cx,  <SimpleCounter initial_value=3 /> })
+// we also support a builder syntax rather than the JSX-like `view` macro
+#[component]
+pub fn SimpleCounterWithBuilder(initial_value: i32) -> impl IntoView {
+    use leptos::html::*;
+
+    let (value, set_value) = create_signal(initial_value);
+    let clear = move |_| set_value(0);
+    let decrement = move |_| set_value.update(|value| *value -= 1);
+    let increment = move |_| set_value.update(|value| *value += 1);
+
+    // the `view` macro above expands to this builder syntax
+    div().child((
+        button().on(ev::click, clear).child("Clear"),
+        button().on(ev::click, decrement).child("-1"),
+        span().child(("Value: ", value, "!")),
+        button().on(ev::click, increment).child("+1")
+    ))
 }
 
+// Easy to use with Trunk (trunkrs.dev) or with a simple wasm-bindgen setup
+pub fn main() {
+    mount_to_body(|| view! {
+        <SimpleCounter initial_value=3 />
+    })
+}
 ```
 
 ## About the Framework
@@ -48,27 +73,27 @@ Leptos is a full-stack, isomorphic Rust web framework leveraging fine-grained re
 
 ## What does that mean?
 
-- **Full-stack**: Leptos can be used to build apps that run in the browser (_client-side rendering_), on the server (_server-side rendering_), or by rendering HTML on the server and then adding interactivity in the browser (_hydration_). This includes support for _HTTP streaming_ of both data (`Resource`s) and HTML (out-of-order streaming of `<Suspense/>` components.)
-- **Isomorphic**: Leptos provides primitives to write isomorphic server functions, i.e., functions that can be called with the “same shape” on the client or server, but only run on the server. This means you can write your server-only logic (database requests, authentication etc.) alongside the client-side components that will consume it, and call server functions as if they were running in the browser.
-- **Web**: Leptos is built on the Web platform and Web standards. The router is designed to use Web fundamentals (like links and forms) and build on top of them rather than trying to replace them.
+- **Full-stack**: Leptos can be used to build apps that run in the browser (client-side rendering), on the server (server-side rendering), or by rendering HTML on the server and then adding interactivity in the browser (server-side rendering with hydration). This includes support for HTTP streaming of both data ([`Resource`s](https://docs.rs/leptos/latest/leptos/struct.Resource.html)) and HTML (out-of-order or in-order streaming of [`<Suspense/>`](https://docs.rs/leptos/latest/leptos/fn.Suspense.html) components.)
+- **Isomorphic**: Leptos provides primitives to write isomorphic [server functions](https://docs.rs/leptos_server/0.2.5/leptos_server/index.html), i.e., functions that can be called with the “same shape” on the client or server, but only run on the server. This means you can write your server-only logic (database requests, authentication etc.) alongside the client-side components that will consume it, and call server functions as if they were running in the browser, without needing to create and maintain a separate REST or other API.
+- **Web**: Leptos is built on the Web platform and Web standards. The [router](https://docs.rs/leptos_router/latest/leptos_router/) is designed to use Web fundamentals (like links and forms) and build on top of them rather than trying to replace them.
 - **Framework**: Leptos provides most of what you need to build a modern web app: a reactive system, templating library, and a router that works on both the server and client side.
-- **Fine-grained reactivity**: The entire framework is built from reactive primitives. This allows for extremely performant code with minimal overhead: when a reactive signal’s value changes, it can update a single text node, toggle a single class, or remove an element from the DOM without any other code running. (_So, no virtual DOM!_)
+- **Fine-grained reactivity**: The entire framework is built from reactive primitives. This allows for extremely performant code with minimal overhead: when a reactive signal’s value changes, it can update a single text node, toggle a single class, or remove an element from the DOM without any other code running. (So, no virtual DOM overhead!)
 - **Declarative**: Tell Leptos how you want the page to look, and let the framework tell the browser how to do it.
 
 ## Learn more
 
 Here are some resources for learning more about Leptos:
 
+- [Book](https://leptos-rs.github.io/leptos/) (work in progress)
 - [Examples](https://github.com/leptos-rs/leptos/tree/main/examples)
 - [API Documentation](https://docs.rs/leptos/latest/leptos/)
 - [Common Bugs](https://github.com/leptos-rs/leptos/tree/main/docs/COMMON_BUGS.md) (and how to fix them!)
-- Leptos Guide (in progress)
 
 ## `nightly` Note
 
-Most of the examples assume you’re using `nightly` Rust.
+Most of the examples assume you’re using `nightly` version of Rust and the `nightly` feature of Leptos. To use `nightly` Rust, you can either set your toolchain globally or on per-project basis.
 
-To set up your Rust toolchain using `nightly` (and add the ability to compile Rust to WebAssembly, if you haven’t already)
+To set `nightly` as a default toolchain for all projects (and add the ability to compile Rust to WebAssembly, if you haven’t already):
 
 ```
 rustup toolchain install nightly
@@ -76,17 +101,19 @@ rustup default nightly
 rustup target add wasm32-unknown-unknown
 ```
 
-If you’re on `stable`, note the following:
+If you'd like to use `nightly` only in your Leptos project however, add [`rust-toolchain.toml`](https://rust-lang.github.io/rustup/overrides.html#the-toolchain-file) file with the following content:
 
-1. You need to enable the `"stable"` flag in `Cargo.toml`: `leptos = { version = "0.1.0", features = ["stable"] }`
-2. `nightly` enables the function call syntax for accessing and setting signals. If you’re using `stable`,
-   you’ll just call `.get()`, `.set()`, or `.update()` manually. Check out the
-   [`counters_stable` example](https://github.com/leptos-rs/leptos/blob/main/examples/counters_stable/src/main.rs)
-   for examples of the correct API.
+```toml
+[toolchain]
+channel = "nightly"
+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.
 
 ## `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 template](https://github.com/leptos-rs/start).
+[`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) is a build tool that's designed to make it easy to build apps that run on both the client and the server, with seamless integration. The best way to get started with a real Leptos project right now is to use `cargo-leptos` and our starter templates for [Actix](https://github.com/leptos-rs/start) or [Axum](https://github.com/leptos-rs/start-axum).
 
 ```bash
 cargo install cargo-leptos
@@ -95,17 +122,21 @@ cd [your project name]
 cargo leptos watch
 ```
 
-Open browser on [http://localhost:3000/](http://localhost:3000/)
+Open browser to [http://localhost:3000/](http://localhost:3000/).
 
 ## FAQs
 
+### What’s up with the name?
+
+_Leptos_ (λεπτός) is an ancient Greek word meaning “thin, light, 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.
+
 ### Is it production ready?
 
 People usually mean one of three things by this question.
 
 1. **Are the APIs stable?** i.e., will I have to rewrite my whole app from Leptos 0.1 to 0.2 to 0.3 to 0.4, or can I write it now and benefit from new features and updates as new versions come?
 
-With 0.1 the APIs are basically settled. We’re adding new features, but we’re very happy with where the type system and patterns have landed. I would not expect major breaking changes to your code to adapt to, for example, a 0.2.0 release.
+The APIs are basically settled. We’re adding new features, but we’re very happy with where the type system and patterns have landed. I would not expect major breaking changes to your code to adapt to future releases, in terms of architecture.
 
 2. **Are there bugs?**
 
@@ -115,11 +146,11 @@ Yes, I’m sure there are. You can see from the state of our issue tracker over
 
 This may be the big one: “production ready” implies a certain orientation to a library: that you can basically use it, without any special knowledge of its internals or ability to contribute. Everyone has this at some level in their stack: for example I (@gbj) don’t have the capacity or knowledge to contribute to something like `wasm-bindgen` at this point: I simply rely on it to work.
 
-There are several people in this community using Leptos right now for internal apps at work, who have also become significant contributors. I think this is the right level of production use for now. There may be missing features that you need, and you may end up building them! But for internal apps, if you’re willing to build and contribute missing pieces along the way, the framework is definitely usable right now.
+There are several people in the community using Leptos right now for internal apps at work, who have also become significant contributors. I think this is the right level of production use for now. There may be missing features that you need, and you may end up building them! But for internal apps, if you’re willing to build and contribute missing pieces along the way, the framework is definitely usable right now.
 
 ### Can I use this for native GUI?
 
-Sure! Obviously the `view` macro is for generating DOM nodes but you can use the reactive system to drive native any GUI toolkit that uses the same kind of object-oriented, event-callback-based framework as the DOM pretty easily. The principles are the same:
+Sure! Obviously the `view` macro is for generating DOM nodes but you can use the reactive system to drive any native GUI toolkit that uses the same kind of object-oriented, event-callback-based framework as the DOM pretty easily. The principles are the same:
 
 - Use signals, derived signals, and memos to create your reactive system
 - Create GUI widgets
@@ -128,35 +159,27 @@ Sure! Obviously the `view` macro is for generating DOM nodes but you can use the
 
 I've put together a [very simple GTK example](https://github.com/leptos-rs/leptos/blob/main/examples/gtk/src/main.rs) so you can see what I mean.
 
-### How is this different from Yew/Dioxus?
+The new rendering approach being developed for 0.7 supports “universal rendering,” i.e., it can use any rendering library that supports a small set of 6-8 functions. (This is intended as a layer over typical retained-mode, OOP-style GUI toolkits like the DOM, GTK, etc.) That future rendering work will allow creating native UI in a way that is much more similar to the declarative approach used by the web framework.
 
-On the surface level, these libraries may seem similar. Yew is, of course, the most mature Rust library for web UI development and has a huge ecosystem. Dioxus is similar in many ways, being heavily inspired by React. Here are some conceptual differences between Leptos and these frameworks:
+### How is this different from Yew?
+
+Yew is the most-used library for Rust web UI development, but there are several differences between Yew and Leptos, in philosophy, approach, and performance. 
 
 - **VDOM vs. fine-grained:** Yew is built on the virtual DOM (VDOM) model: state changes cause components to re-render, generating a new virtual DOM tree. Yew diffs this against the previous VDOM, and applies those patches to the actual DOM. Component functions rerun whenever state changes. Leptos takes an entirely different approach. Components run once, creating (and returning) actual DOM nodes and setting up a reactive system to update those DOM nodes.
-- **Performance:** This has huge performance implications: Leptos is simply _much_ faster at both creating and updating the UI than Yew is.
-- **Mental model:** Adopting fine-grained reactivity also tends to simplify the mental model. There are no surprising component re-renders because there are no re-renders. Your app can be divided into components based on what makes sense for your app, because they have no performance implications.
+- **Performance:** This has huge performance implications: Leptos is simply much faster at both creating and updating the UI than Yew is.
+- **Server integration:** Yew was created in an era in which browser-rendered single-page apps (SPAs) were the dominant paradigm. While Leptos supports client-side rendering, it also focuses on integrating with the server side of your application via server functions and multiple modes of serving HTML, including out-of-order streaming.
 
-### How is this different from Sycamore?
+- ### How is this different from Dioxus?
 
-Conceptually, these two frameworks are very similar: because both are built on fine-grained reactivity, most apps will end up looking very similar between the two, and Sycamore or Leptos apps will both look a lot like SolidJS apps, in the same way that Yew or Dioxus can look a lot like React.
+Like Leptos, Dioxus is a framework for building UIs using web technologies. However, there are significant differences in approach and features.
 
-There are some practical differences that make a significant difference:
+- **VDOM vs. fine-grained:** While Dioxus has a performant virtual DOM (VDOM), it still uses coarse-grained/component-scoped reactivity: changing a stateful value reruns the component function and diffs the old UI against the new one. Leptos components use a different mental model, creating (and returning) actual DOM nodes and setting up a reactive system to update those DOM nodes.
+- **Web vs. desktop priorities:** Dioxus uses Leptos server functions in its fullstack mode, but does not have the same `<Suspense>`-based support for things like streaming HTML rendering, or share the same focus on holistic web performance. Leptos tends to prioritize holistic web performance (streaming HTML rendering, smaller WASM binary sizes, etc.), whereas Dioxus has an unparalleled experience when building desktop apps, because your application logic runs as a native Rust binary.
 
-- **Maturity:** Sycamore is obviously a much more mature and stable library with a larger ecosystem.
-- **Templating:** Leptos uses a JSX-like template format (built on [syn-rsx](https://github.com/stoically/syn-rsx)) for its `view` macro. Sycamore offers the choice of its own templating DSL or a builder syntax.
-- **Read-write segregation:** Leptos, like Solid, encourages read-write segregation between signal getters and setters, so you end up accessing signals with tuples like `let (count, set_count) = create_signal(cx, 0);` _(If you prefer or if it's more convenient for your API, you can use `create_rw_signal` to give a unified read/write signal.)_
-- **Signals are functions:** In Leptos, you can call a signal to access it rather than calling a specific method (so, `count()` instead of `count.get()`) This creates a more consistent mental model: accessing a reactive value is always a matter of calling a function. For example:
+- ### How is this different from Sycamore?
 
-  ```rust
-  let (count, set_count) = create_signal(cx, 0); // a signal
-  let double_count = move || count() * 2; // a derived signal
-  let memoized_count = create_memo(cx, move |_| count() * 3); // a memo
-  // all are accessed by calling them
-  assert_eq!(count(), 0);
-  assert_eq!(double_count(), 0);
-  assert_eq!(memoized_count(), 0);
-  // this function can accept any of those signals
-  fn do_work_on_signal(my_signal: impl Fn() -> i32) { ... }
-  ```
+Sycamore and Leptos are both heavily influenced by SolidJS. At this point, Leptos has a larger community and ecosystem and is more actively developed. Other differences:
 
-- **Signals and scopes are `'static`:** Both Leptos and Sycamore ease the pain of moving signals in closures (in particular, event listeners) by making them `Copy`, to avoid the `{ let count = count.clone(); move |_| ... }` that's very familiar in Rust UI code. Sycamore does this by using bump allocation to tie the lifetimes of its signals to its scopes: since references are `Copy`, `&'a Signal<T>` can be moved into a closure. Leptos does this by using arena allocation and passing around indices: types like `ReadSignal<T>`, `WriteSignal<T>`, and `Memo<T>` are actually wrappers for indices into an arena. This means that both scopes and signals are both `Copy` and `'static` in Leptos, which means that they can be moved easily into closures without adding lifetime complexity.
+- **Templating DSLs:** Sycamore uses a custom templating language for its views, while Leptos uses a JSX-like template format.
+- **`'static` signals:** One of Leptos’s main innovations was the creation of `Copy + 'static` signals, which have excellent ergonomics. Sycamore is in the process of adopting the same pattern, but this is not yet released.
+- **Perseus vs. server functions:** The Perseus metaframework provides an opinionated way to build Sycamore apps that include server functionality. Leptos instead provides primitives like server functions in the core of the framework. 

SECURITY.md

@@ -0,0 +1,13 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+To report a suspected security issue, please contact security@leptos.dev rather than opening
+a public issue.
+
+## Supported Versions
+
+The most-recently-released version of the library is supported with security updates.
+For example, if a security issue is discovered that affects 0.3.2 and all later releases,
+a 0.4.x patch will be released but a new 0.3.x patch release will not be made. You should 
+plan to update to the latest version to receive any new features or bugfixes of any kind.

benchmarks/Cargo.toml

@@ -4,9 +4,19 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-leptos = { path = "../leptos", default-features = false, features = ["ssr"] }
+l0410 = { package = "leptos", version = "0.4.10", features = [
+	"nightly",
+	"ssr",
+] }
+leptos = { path = "../leptos", features = ["ssr", "nightly"] }
+leptos_reactive = { path = "../leptos_reactive", features = ["ssr", "nightly"] }
+tachydom = { git = "https://github.com/gbj/tachys", features = [
+	"nightly",
+	"leptos",
+] }
+tachy_maccy = { git = "https://github.com/gbj/tachys", features = ["nightly"] }
 sycamore = { version = "0.8", features = ["ssr"] }
-yew = { git = "https://github.com/yewstack/yew", features = ["ssr"] }
+yew = { version = "0.20", features = ["ssr"] }
 tokio-test = "0.4"
 miniserde = "0.1"
 gloo = "0.8"
@@ -16,15 +26,10 @@ lazy_static = "1"
 log = "0.4"
 strum = "0.24"
 strum_macros = "0.24"
-serde = { version = "1", features = ["derive", "rc"]}
+serde = { version = "1", features = ["derive", "rc"] }
 serde_json = "1"
 tera = "1"
 
 [dependencies.web-sys]
 version = "0.3"
-features = [
-	"Window",
-	"Document",
-	"HtmlElement",
-	"HtmlInputElement"
-]
+features = ["Window", "Document", "HtmlElement", "HtmlInputElement"]

benchmarks/src/lib.rs

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

benchmarks/src/reactive.rs

@@ -1,40 +1,227 @@
+use std::{cell::Cell, rc::Rc};
 use test::Bencher;
 
-use std::{cell::Cell, rc::Rc};
-
 #[bench]
-fn leptos_create_1000_signals(b: &mut Bencher) {
-    use leptos::{create_isomorphic_effect, create_memo, create_scope, create_signal};
+fn leptos_deep_creation(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
 
     b.iter(|| {
-        create_scope(|cx| {
+        let signal = create_rw_signal(0);
+        let mut memos = Vec::<Memo<usize>>::new();
+        for _ in 0..1000usize {
+            let prev = memos.last().copied();
+            if let Some(prev) = prev {
+                memos.push(create_memo(move |_| prev.get() + 1));
+            } else {
+                memos.push(create_memo(move |_| signal.get() + 1));
+            }
+        }
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn leptos_deep_update(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        let signal = create_rw_signal(0);
+        let mut memos = Vec::<Memo<usize>>::new();
+        for _ in 0..1000usize {
+            if let Some(prev) = memos.last().copied() {
+                memos.push(create_memo(move |_| prev.get() + 1));
+            } else {
+                memos.push(create_memo(move |_| signal.get() + 1));
+            }
+        }
+        signal.set(1);
+        assert_eq!(memos[999].get(), 1001);
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn leptos_narrowing_down(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        let sigs = (0..1000).map(|n| create_signal(n)).collect::<Vec<_>>();
+        let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
+        let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
+        let memo =
+            create_memo(move |_| reads.iter().map(|r| r.get()).sum::<i32>());
+        assert_eq!(memo(), 499500);
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn leptos_fanning_out(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        let sig = create_rw_signal(0);
+        let memos = (0..1000)
+            .map(|_| create_memo(move |_| sig.get()))
+            .collect::<Vec<_>>();
+        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+        sig.set(1);
+        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn leptos_narrowing_update(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        let acc = Rc::new(Cell::new(0));
+        let sigs = (0..1000).map(|n| create_signal(n)).collect::<Vec<_>>();
+        let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
+        let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
+        let memo =
+            create_memo(move |_| reads.iter().map(|r| r.get()).sum::<i32>());
+        assert_eq!(memo(), 499500);
+        create_isomorphic_effect({
+            let acc = Rc::clone(&acc);
+            move |_| {
+                acc.set(memo());
+            }
+        });
+        assert_eq!(acc.get(), 499500);
+
+        writes[1].update(|n| *n += 1);
+        writes[10].update(|n| *n += 1);
+        writes[100].update(|n| *n += 1);
+
+        assert_eq!(acc.get(), 499503);
+        assert_eq!(memo(), 499503);
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn l0410_deep_creation(b: &mut Bencher) {
+    use l0410::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let signal = create_rw_signal(cx, 0);
+            let mut memos = Vec::<Memo<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move |_| prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move |_| signal.get() + 1));
+                }
+            }
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn l0410_deep_update(b: &mut Bencher) {
+    use l0410::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let signal = create_rw_signal(cx, 0);
+            let mut memos = Vec::<Memo<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move |_| prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move |_| signal.get() + 1));
+                }
+            }
+            signal.set(1);
+            assert_eq!(memos[999].get(), 1001);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn l0410_narrowing_down(b: &mut Bencher) {
+    use l0410::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
             let acc = Rc::new(Cell::new(0));
-            let sigs = (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
+            let sigs =
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
             let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
             let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
-            let memo = create_memo(cx, move |_| reads.iter().map(|r| r.get()).sum::<i32>());
+            let memo = create_memo(cx, move |_| {
+                reads.iter().map(|r| r.get()).sum::<i32>()
+            });
             assert_eq!(memo(), 499500);
         })
         .dispose()
     });
+
+    runtime.dispose();
 }
 
 #[bench]
-fn leptos_create_and_update_1000_signals(b: &mut Bencher) {
-    use leptos::{create_isomorphic_effect, create_memo, create_scope, create_signal};
+fn l0410_fanning_out(b: &mut Bencher) {
+    use l0410::*;
+    let runtime = create_runtime();
 
     b.iter(|| {
-        create_scope(|cx| {
+        create_scope(runtime, |cx| {
+            let sig = create_rw_signal(cx, 0);
+            let memos = (0..1000)
+                .map(|_| create_memo(cx, move |_| sig.get()))
+                .collect::<Vec<_>>();
+            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+            sig.set(1);
+            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+#[bench]
+fn l0410_narrowing_update(b: &mut Bencher) {
+    use l0410::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
             let acc = Rc::new(Cell::new(0));
-            let sigs = (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
+            let sigs =
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
             let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
             let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
-            let memo = create_memo(cx, move |_| reads.iter().map(|r| r.get()).sum::<i32>());
-            assert_eq!(memo(), 499500);
+            let memo = create_memo(cx, move |_| {
+                reads.iter().map(|r| r.get()).sum::<i32>()
+            });
+            assert_eq!(memo.get(), 499500);
             create_isomorphic_effect(cx, {
                 let acc = Rc::clone(&acc);
                 move |_| {
-                    acc.set(memo());
+                    acc.set(memo.get());
                 }
             });
             assert_eq!(acc.get(), 499500);
@@ -44,27 +231,30 @@ fn leptos_create_and_update_1000_signals(b: &mut Bencher) {
             writes[100].update(|n| *n += 1);
 
             assert_eq!(acc.get(), 499503);
-            assert_eq!(memo(), 499503);
+            assert_eq!(memo.get(), 499503);
         })
         .dispose()
     });
+
+    runtime.dispose();
 }
 
 #[bench]
-fn leptos_create_and_dispose_1000_scopes(b: &mut Bencher) {
-    use leptos::{create_isomorphic_effect, create_scope, create_signal};
+fn l0410_scope_creation_and_disposal(b: &mut Bencher) {
+    use l0410::*;
+    let runtime = create_runtime();
 
     b.iter(|| {
         let acc = Rc::new(Cell::new(0));
         let disposers = (0..1000)
             .map(|_| {
-                create_scope({
+                create_scope(runtime, {
                     let acc = Rc::clone(&acc);
                     move |cx| {
                         let (r, w) = create_signal(cx, 0);
                         create_isomorphic_effect(cx, {
                             move |_| {
-                                acc.set(r());
+                                acc.set(r.get());
                             }
                         });
                         w.update(|n| *n += 1);
@@ -76,16 +266,22 @@ fn leptos_create_and_dispose_1000_scopes(b: &mut Bencher) {
             disposer.dispose();
         }
     });
+
+    runtime.dispose();
 }
 
 #[bench]
-fn sycamore_create_1000_signals(b: &mut Bencher) {
-    use sycamore::reactive::{create_effect, create_memo, create_scope, create_signal};
+fn sycamore_narrowing_down(b: &mut Bencher) {
+    use sycamore::reactive::{
+        create_effect, create_memo, create_scope, create_signal,
+    };
 
     b.iter(|| {
         let d = create_scope(|cx| {
             let acc = Rc::new(Cell::new(0));
-            let sigs = Rc::new((0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>());
+            let sigs = Rc::new(
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>(),
+            );
             let memo = create_memo(cx, {
                 let sigs = Rc::clone(&sigs);
                 move || sigs.iter().map(|r| *r.get()).sum::<i32>()
@@ -97,13 +293,78 @@ fn sycamore_create_1000_signals(b: &mut Bencher) {
 }
 
 #[bench]
-fn sycamore_create_and_update_1000_signals(b: &mut Bencher) {
-    use sycamore::reactive::{create_effect, create_memo, create_scope, create_signal};
+fn sycamore_fanning_out(b: &mut Bencher) {
+    use sycamore::reactive::{
+        create_effect, create_memo, create_scope, create_signal,
+    };
+
+    b.iter(|| {
+        let d = create_scope(|cx| {
+            let sig = create_signal(cx, 0);
+            let memos = (0..1000)
+                .map(|_| create_memo(cx, move || sig.get()))
+                .collect::<Vec<_>>();
+            assert_eq!(memos.iter().map(|m| *(*m.get())).sum::<i32>(), 0);
+            sig.set(1);
+            assert_eq!(memos.iter().map(|m| *(*m.get())).sum::<i32>(), 1000);
+        });
+        unsafe { d.dispose() };
+    });
+}
+
+#[bench]
+fn sycamore_deep_creation(b: &mut Bencher) {
+    use sycamore::reactive::*;
+
+    b.iter(|| {
+        let d = create_scope(|cx| {
+            let signal = create_signal(cx, 0);
+            let mut memos = Vec::<&ReadSignal<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move || *prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move || *signal.get() + 1));
+                }
+            }
+        });
+        unsafe { d.dispose() };
+    });
+}
+
+#[bench]
+fn sycamore_deep_update(b: &mut Bencher) {
+    use sycamore::reactive::*;
+
+    b.iter(|| {
+        let d = create_scope(|cx| {
+            let signal = create_signal(cx, 0);
+            let mut memos = Vec::<&ReadSignal<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move || *prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move || *signal.get() + 1));
+                }
+            }
+            signal.set(1);
+            assert_eq!(*memos[999].get(), 1001);
+        });
+        unsafe { d.dispose() };
+    });
+}
+#[bench]
+fn sycamore_narrowing_update(b: &mut Bencher) {
+    use sycamore::reactive::{
+        create_effect, create_memo, create_scope, create_signal,
+    };
 
     b.iter(|| {
         let d = create_scope(|cx| {
             let acc = Rc::new(Cell::new(0));
-            let sigs = Rc::new((0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>());
+            let sigs = Rc::new(
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>(),
+            );
             let memo = create_memo(cx, {
                 let sigs = Rc::clone(&sigs);
                 move || sigs.iter().map(|r| *r.get()).sum::<i32>()
@@ -129,7 +390,7 @@ fn sycamore_create_and_update_1000_signals(b: &mut Bencher) {
 }
 
 #[bench]
-fn sycamore_create_and_dispose_1000_scopes(b: &mut Bencher) {
+fn sycamore_scope_creation_and_disposal(b: &mut Bencher) {
     use sycamore::reactive::{create_effect, create_scope, create_signal};
 
     b.iter(|| {

benchmarks/src/ssr.rs

@@ -2,15 +2,14 @@ use test::Bencher;
 
 #[bench]
 fn leptos_ssr_bench(b: &mut Bencher) {
+	use leptos::*;
+	let r = create_runtime();
     b.iter(|| {
-		use leptos::*;
-		HydrationCtx::reset_id();
-		_ = create_scope(create_runtime(), |cx| {
+			leptos::leptos_dom::HydrationCtx::reset_id();
 			#[component]
-			fn Counter(cx: Scope, initial: i32) -> impl IntoView {
-				let (value, set_value) = create_signal(cx, initial);
+			fn Counter(initial: i32) -> impl IntoView {
+				let (value, set_value) = create_signal(initial);
 				view! {
-					cx,
 					<div>
 						<button on:click=move |_| set_value.update(|value| *value -= 1)>"-1"</button>
 						<span>"Value: " {move || value().to_string()} "!"</span>
@@ -20,7 +19,6 @@ fn leptos_ssr_bench(b: &mut Bencher) {
 			}
 
 			let rendered = view! { 
-				cx,
 				<main>
 					<h1>"Welcome to our benchmark page."</h1>
 					<p>"Here's some introductory text."</p>
@@ -28,13 +26,53 @@ fn leptos_ssr_bench(b: &mut Bencher) {
 					<Counter initial=2/>
 					<Counter initial=3/>
 				</main>
-			}.into_view(cx).render_to_string(cx);
+			}.into_view().render_to_string();
 
 			assert_eq!(
 				rendered,
-				"<main id=\"_0-1\"><h1 id=\"_0-2\">Welcome to our benchmark page.</h1><p id=\"_0-3\">Here's some introductory text.</p><div id=\"_0-3-1\"><button id=\"_0-3-2\">-1</button><span id=\"_0-3-3\">Value: <!>1<!--hk=_0-3-4-->!</span><button id=\"_0-3-5\">+1</button></div><!--hk=_0-3-0--><div id=\"_0-3-5-1\"><button id=\"_0-3-5-2\">-1</button><span id=\"_0-3-5-3\">Value: <!>2<!--hk=_0-3-5-4-->!</span><button id=\"_0-3-5-5\">+1</button></div><!--hk=_0-3-5-0--><div id=\"_0-3-5-5-1\"><button id=\"_0-3-5-5-2\">-1</button><span id=\"_0-3-5-5-3\">Value: <!>3<!--hk=_0-3-5-5-4-->!</span><button id=\"_0-3-5-5-5\">+1</button></div><!--hk=_0-3-5-5-0--></main>"			);
-		});
+"<main data-hk=\"0-0-0-1\"><h1 data-hk=\"0-0-0-2\">Welcome to our benchmark page.</h1><p data-hk=\"0-0-0-3\">Here&#x27;s some introductory text.</p><div data-hk=\"0-0-0-5\"><button data-hk=\"0-0-0-6\">-1</button><span data-hk=\"0-0-0-7\">Value: <!>1<!--hk=0-0-0-8-->!</span><button data-hk=\"0-0-0-9\">+1</button></div><!--hk=0-0-0-4--><div data-hk=\"0-0-0-11\"><button data-hk=\"0-0-0-12\">-1</button><span data-hk=\"0-0-0-13\">Value: <!>2<!--hk=0-0-0-14-->!</span><button data-hk=\"0-0-0-15\">+1</button></div><!--hk=0-0-0-10--><div data-hk=\"0-0-0-17\"><button data-hk=\"0-0-0-18\">-1</button><span data-hk=\"0-0-0-19\">Value: <!>3<!--hk=0-0-0-20-->!</span><button data-hk=\"0-0-0-21\">+1</button></div><!--hk=0-0-0-16--></main>"			);
 	});
+	r.dispose();
+}
+
+#[bench]
+fn tachys_ssr_bench(b: &mut Bencher) {
+	use leptos::{create_runtime, create_signal, SignalGet, SignalUpdate};
+	use tachy_maccy::view;
+	use tachydom::view::{Render, RenderHtml};
+	use tachydom::html::element::ElementChild;
+	use tachydom::html::attribute::global::ClassAttribute;
+	use tachydom::html::attribute::global::GlobalAttributes;
+	use tachydom::html::attribute::global::OnAttribute;
+	use tachydom::renderer::dom::Dom;
+	let rt = create_runtime();
+    b.iter(|| {
+		fn counter(initial: i32) -> impl Render<Dom> + RenderHtml<Dom> {
+			let (value, set_value) = create_signal(initial);
+			view! {
+				<div>
+					<button on:click=move |_| set_value.update(|value| *value -= 1)>"-1"</button>
+					<span>"Value: " {move || value().to_string()} "!"</span>
+					<button on:click=move |_| set_value.update(|value| *value += 1)>"+1"</button>
+				</div>
+			}
+		}
+
+		let rendered = view! { 
+			<main>
+				<h1>"Welcome to our benchmark page."</h1>
+				<p>"Here's some introductory text."</p>
+				{counter(1)}
+				{counter(2)}
+				{counter(3)}
+			</main>
+		}.to_html();
+		assert_eq!(
+			rendered,
+			"<main><h1>Welcome to our benchmark page.</h1><p>Here's some introductory text.</p><div><button>-1</button><span>Value: <!>1<!>!</span><button>+1</button></div><div><button>-1</button><span>Value: <!>2<!>!</span><button>+1</button></div><div><button>-1</button><span>Value: <!>3<!>!</span><button>+1</button></div></main>"
+		);
+	});
+	rt.dispose();
 }
 
 #[bench]

benchmarks/src/todomvc/leptos.rs

@@ -1,5 +1,6 @@
 pub use leptos::*;
 use miniserde::*;
+use wasm_bindgen::JsCast;
 use web_sys::HtmlInputElement;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -8,13 +9,13 @@ pub struct Todos(pub Vec<Todo>);
 const STORAGE_KEY: &str = "todos-leptos";
 
 impl Todos {
-    pub fn new(cx: Scope) -> Self {
+    pub fn new() -> Self {
         Self(vec![])
     }
 
-    pub fn new_with_1000(cx: Scope) -> Self {
+    pub fn new_with_1000() -> Self {
         let todos = (0..1000)
-            .map(|id| Todo::new(cx, id, format!("Todo #{id}")))
+            .map(|id| Todo::new(id, format!("Todo #{id}")))
             .collect();
         Self(todos)
     }
@@ -71,13 +72,17 @@ pub struct Todo {
 }
 
 impl Todo {
-    pub fn new(cx: Scope, id: usize, title: String) -> Self {
-        Self::new_with_completed(cx, id, title, false)
+    pub fn new(id: usize, title: String) -> Self {
+        Self::new_with_completed(id, title, false)
     }
 
-    pub fn new_with_completed(cx: Scope, id: usize, title: String, completed: bool) -> Self {
-        let (title, set_title) = create_signal(cx, title);
-        let (completed, set_completed) = create_signal(cx, completed);
+    pub fn new_with_completed(
+        id: usize,
+        title: String,
+        completed: bool,
+    ) -> Self {
+        let (title, set_title) = create_signal(title);
+        let (completed, set_completed) = create_signal(completed);
         Self {
             id,
             title,
@@ -97,7 +102,7 @@ const ESCAPE_KEY: u32 = 27;
 const ENTER_KEY: u32 = 13;
 
 #[component]
-pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
+pub fn TodoMVC(todos: Todos) -> impl IntoView {
     let mut next_id = todos
         .0
         .iter()
@@ -106,14 +111,10 @@ pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
         .map(|last| last + 1)
         .unwrap_or(0);
 
-    let (todos, set_todos) = create_signal(cx, todos);
-    provide_context(cx, set_todos);
+    let (todos, set_todos) = create_signal(todos);
+    provide_context(set_todos);
 
-    let (mode, set_mode) = create_signal(cx, Mode::All);
-    window_event_listener("hashchange", move |_| {
-        let new_mode = location_hash().map(|hash| route(&hash)).unwrap_or_default();
-        set_mode(new_mode);
-    });
+    let (mode, set_mode) = create_signal(Mode::All);
 
     let add_todo = move |ev: web_sys::KeyboardEvent| {
         let target = event_target::<HtmlInputElement>(&ev);
@@ -123,7 +124,7 @@ pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
             let title = event_target_value(&ev);
             let title = title.trim();
             if !title.is_empty() {
-                let new = Todo::new(cx, next_id, title.to_string());
+                let new = Todo::new(next_id, title.to_string());
                 set_todos.update(|t| t.add(new));
                 next_id += 1;
                 target.set_value("");
@@ -131,7 +132,7 @@ pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
         }
     };
 
-    let filtered_todos = create_memo::<Vec<Todo>>(cx, move |_| {
+    let filtered_todos = create_memo::<Vec<Todo>>(move |_| {
         todos.with(|todos| match mode.get() {
             Mode::All => todos.0.to_vec(),
             Mode::Active => todos
@@ -151,7 +152,7 @@ pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
 
     // effect to serialize to JSON
     // this does reactive reads, so it will automatically serialize on any relevant change
-    create_effect(cx, move |_| {
+    create_effect(move |_| {
         if let Ok(Some(storage)) = window().local_storage() {
             let objs = todos
                 .get()
@@ -166,65 +167,87 @@ pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
         }
     });
 
-    view! { cx,
-      <main>
-          <section class="todoapp">
-              <header class="header">
-                  <h1>"todos"</h1>
-                  <input class="new-todo" placeholder="What needs to be done?" autofocus="" on:keydown=add_todo />
-              </header>
-              <section class="main" class:hidden={move || todos.with(|t| t.is_empty())}>
-                  <input id="toggle-all" class="toggle-all" type="checkbox"
-                      prop:checked={move || todos.with(|t| t.remaining() > 0)}
-                      on:input=move |_| set_todos.update(|t| t.toggle_all())
-                  />
-                  <label for="toggle-all">"Mark all as complete"</label>
-                  <ul class="todo-list">
-                      <For
-                        each=filtered_todos
-                        key=|todo| todo.id
-                        view=move |todo: Todo| view! { cx,  <Todo todo=todo.clone() /> }
-                      />
-                  </ul>
-              </section>
-              <footer class="footer" class:hidden={move || todos.with(|t| t.is_empty())}>
-                  <span class="todo-count">
-                      <strong>{move || todos.with(|t| t.remaining().to_string())}</strong>
-                      {move || if todos.with(|t| t.remaining()) == 1 {
-                          " item"
-                      } else {
-                          " items"
-                      }}
-                      " left"
-                  </span>
-                  <ul class="filters">
-                      <li><a href="#/" class="selected" class:selected={move || mode() == Mode::All}>"All"</a></li>
-                      <li><a href="#/active" class:selected={move || mode() == Mode::Active}>"Active"</a></li>
-                      <li><a href="#/completed" class:selected={move || mode() == Mode::Completed}>"Completed"</a></li>
-                  </ul>
-                  <button
-                      class="clear-completed hidden"
-                      class:hidden={move || todos.with(|t| t.completed() == 0)}
-                      on:click=move |_| set_todos.update(|t| t.clear_completed())
-                  >
-                      "Clear completed"
-                  </button>
-              </footer>
-          </section>
-          <footer class="info">
-              <p>"Double-click to edit a todo"</p>
-              <p>"Created by "<a href="http://todomvc.com">"Greg Johnston"</a></p>
-              <p>"Part of "<a href="http://todomvc.com">"TodoMVC"</a></p>
-          </footer>
-      </main>
-  }.into_view(cx)
+    view! { 
+        <main>
+            <section class="todoapp">
+                <header class="header">
+                    <h1>"todos"</h1>
+                    <input
+                        class="new-todo"
+                        placeholder="What needs to be done?"
+                        autofocus=""
+                        on:keydown=add_todo
+                    />
+                </header>
+                <section class="main" class:hidden=move || todos.with(|t| t.is_empty())>
+                    <input
+                        id="toggle-all"
+                        class="toggle-all"
+                        type="checkbox"
+                        prop:checked=move || todos.with(|t| t.remaining() > 0)
+                        on:input=move |_| set_todos.update(|t| t.toggle_all())
+                    />
+                    <label for="toggle-all">"Mark all as complete"</label>
+                    <ul class="todo-list">
+                        <For
+                            each=filtered_todos
+                            key=|todo| todo.id
+                            children=move |todo: Todo| {
+                                view! { <Todo todo=todo.clone()/> }
+                            }
+                        />
+                    </ul>
+                </section>
+                <footer class="footer" class:hidden=move || todos.with(|t| t.is_empty())>
+                    <span class="todo-count">
+                        <strong>{move || todos.with(|t| t.remaining().to_string())}</strong>
+                        {move || if todos.with(|t| t.remaining()) == 1 { " item" } else { " items" }}
+                        " left"
+                    </span>
+                    <ul class="filters">
+                        <li>
+                            <a
+                                href="#/"
+                                class="selected"
+                                class:selected=move || mode() == Mode::All
+                            >
+                                "All"
+                            </a>
+                        </li>
+                        <li>
+                            <a href="#/active" class:selected=move || mode() == Mode::Active>
+                                "Active"
+                            </a>
+                        </li>
+                        <li>
+                            <a href="#/completed" class:selected=move || mode() == Mode::Completed>
+                                "Completed"
+                            </a>
+                        </li>
+                    </ul>
+                    <button
+                        class="clear-completed hidden"
+                        class:hidden=move || todos.with(|t| t.completed() == 0)
+                        on:click=move |_| set_todos.update(|t| t.clear_completed())
+                    >
+                        "Clear completed"
+                    </button>
+                </footer>
+            </section>
+            <footer class="info">
+                <p>"Double-click to edit a todo"</p>
+                <p>"Created by " <a href="http://todomvc.com">"Greg Johnston"</a></p>
+                <p>"Part of " <a href="http://todomvc.com">"TodoMVC"</a></p>
+            </footer>
+        </main>
+    }.into_view()
 }
 
 #[component]
-pub fn Todo(cx: Scope, todo: Todo) -> impl IntoView {
-    let (editing, set_editing) = create_signal(cx, false);
-    let set_todos = use_context::<WriteSignal<Todos>>(cx).unwrap();
-    //let input = NodeRef::new(cx);
+pub fn Todo(todo: Todo) -> impl IntoView {
+    let (editing, set_editing) = create_signal(false);
+    let set_todos = use_context::<WriteSignal<Todos>>().unwrap();
+    //let input = NodeRef::new();
 
     let save = move |value: &str| {
         let value = value.trim();
@@ -236,42 +259,37 @@ pub fn Todo(cx: Scope, todo: Todo) -> impl IntoView {
         set_editing(false);
     };
 
-    view! { cx,
-        <li
-            class="todo"
-            class:editing={editing}
-            class:completed={move || (todo.completed)()}
-            //_ref=input
-        >
+    view! { 
+        <li class="todo" class:editing=editing class:completed=move || (todo.completed)()>
             <div class="view">
-                <input
-                    class="toggle"
-                    type="checkbox"
-                    prop:checked={move || (todo.completed)()}
-
-                />
-                <label on:dblclick=move |_| set_editing(true)>
-                    {move || todo.title.get()}
-                </label>
-                <button class="destroy" on:click=move |_| set_todos.update(|t| t.remove(todo.id))/>
+                <input class="toggle" type="checkbox" prop:checked=move || (todo.completed)()/>
+                <label on:dblclick=move |_| set_editing(true)>{move || todo.title.get()}</label>
+                <button
+                    class="destroy"
+                    on:click=move |_| set_todos.update(|t| t.remove(todo.id))
+                ></button>
             </div>
-            {move || editing().then(|| view! { cx,
-                <input
-                    class="edit"
-                    class:hidden={move || !(editing)()}
-                    prop:value={move || todo.title.get()}
-                    on:focusout=move |ev| save(&event_target_value(&ev))
-                    on:keyup={move |ev| {
-                        let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
-                        if key_code == ENTER_KEY {
-                            save(&event_target_value(&ev));
-                        } else if key_code == ESCAPE_KEY {
-                            set_editing(false);
+            {move || {
+                editing()
+                    .then(|| {
+                        view! { 
+                            <input
+                                class="edit"
+                                class:hidden=move || !(editing)()
+                                prop:value=move || todo.title.get()
+                                on:focusout=move |ev| save(&event_target_value(&ev))
+                                on:keyup=move |ev| {
+                                    let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
+                                    if key_code == ENTER_KEY {
+                                        save(&event_target_value(&ev));
+                                    } else if key_code == ESCAPE_KEY {
+                                        set_editing(false);
+                                    }
+                                }
+                            />
                         }
-                    }}
-                />
-            })
-        }
+                    })
+            }}
         </li>
     }
 }
@@ -305,8 +323,8 @@ pub struct TodoSerialized {
 }
 
 impl TodoSerialized {
-    pub fn into_todo(self, cx: Scope) -> Todo {
-        Todo::new_with_completed(cx, self.id, self.title, self.completed)
+    pub fn into_todo(self, ) -> Todo {
+        Todo::new_with_completed(self.id, self.title, self.completed)
     }
 }
 

benchmarks/src/todomvc/mod.rs

@@ -2,32 +2,45 @@ use test::Bencher;
 
 mod leptos;
 mod sycamore;
+mod tachys;
 mod tera;
 mod yew;
 
 #[bench]
 fn leptos_todomvc_ssr(b: &mut Bencher) {
+    use ::leptos::*;
+    let runtime = create_runtime();
     b.iter(|| {
         use crate::todomvc::leptos::*;
 
-        _ = create_scope(create_runtime(), |cx| {
-            let rendered = view! {
-                cx,
-                <TodoMVC todos=Todos::new(cx)/>
-            }
-            .into_view(cx)
-            .render_to_string(cx);
-
-            assert!(rendered.len() > 1);
+        let html = ::leptos::ssr::render_to_string(|| {
+            view! { <TodoMVC todos=Todos::new()/> }
         });
+        assert!(html.len() > 1);
     });
+    runtime.dispose();
+}
+
+#[bench]
+fn tachys_todomvc_ssr(b: &mut Bencher) {
+    use ::leptos::*;
+    let runtime = create_runtime();
+    b.iter(|| {
+        use crate::todomvc::tachys::*;
+        use tachydom::view::{Render, RenderHtml};
+
+        let rendered = TodoMVC(Todos::new()).to_html();
+        assert_eq!(
+            rendered,
+"<main><section class=\"todoapp\"><header class=\"header\"><h1>todos</h1><input placeholder=\"What needs to be done?\" autofocus class=\"new-todo\"></header><section class=\"main hidden\"><input id=\"toggle-all\" type=\"checkbox\" class=\"toggle-all\"><label for=\"toggle-all\">Mark all as complete</label><ul class=\"todo-list\"></ul></section><footer class=\"footer hidden\"><span class=\"todo-count\"><strong>0</strong><!> items<!> left</span><ul class=\"filters\"><li><a href=\"#/\" class=\"selected selected\">All</a></li><li><a href=\"#/active\" class=\"\">Active</a></li><li><a href=\"#/completed\" class=\"\">Completed</a></li></ul><button class=\"clear-completed hidden hidden\">Clear completed</button></footer></section><footer class=\"info\"><p>Double-click to edit a todo</p><p>Created by <a href=\"http://todomvc.com\">Greg Johnston</a></p><p>Part of <a href=\"http://todomvc.com\">TodoMVC</a></p></footer></main>"        );
+    });
+    runtime.dispose();
 }
 
 #[bench]
 fn sycamore_todomvc_ssr(b: &mut Bencher) {
     use self::sycamore::*;
-    use ::sycamore::prelude::*;
-    use ::sycamore::*;
+    use ::sycamore::{prelude::*, *};
 
     b.iter(|| {
         _ = create_scope(|cx| {
@@ -46,8 +59,7 @@ fn sycamore_todomvc_ssr(b: &mut Bencher) {
 #[bench]
 fn yew_todomvc_ssr(b: &mut Bencher) {
     use self::yew::*;
-    use ::yew::prelude::*;
-    use ::yew::ServerRenderer;
+    use ::yew::{prelude::*, ServerRenderer};
 
     b.iter(|| {
         tokio_test::block_on(async {
@@ -57,29 +69,40 @@ fn yew_todomvc_ssr(b: &mut Bencher) {
         });
     });
 }
-/*
+
 #[bench]
 fn leptos_todomvc_ssr_with_1000(b: &mut Bencher) {
     b.iter(|| {
         use self::leptos::*;
         use ::leptos::*;
 
-        _ = create_scope(create_runtime(), |cx| {
-            let rendered = view! {
-                cx,
-                <TodoMVC todos=Todos::new_with_1000(cx)/>
-            }.into_view(cx).render_to_string(cx);
-
-            assert!(rendered.len() > 1);
+        let html = ::leptos::ssr::render_to_string(|| {
+            view! {
+                <TodoMVC todos=Todos::new_with_1000()/>
+            }
         });
+        assert!(html.len() > 1);
     });
 }
 
+#[bench]
+fn tachys_todomvc_ssr_with_1000(b: &mut Bencher) {
+    use ::leptos::*;
+    let runtime = create_runtime();
+    b.iter(|| {
+        use crate::todomvc::tachys::*;
+        use tachydom::view::{Render, RenderHtml};
+
+        let rendered = TodoMVC(Todos::new_with_1000()).to_html();
+        assert!(rendered.len() > 20_000)
+    });
+    runtime.dispose();
+}
+
 #[bench]
 fn sycamore_todomvc_ssr_with_1000(b: &mut Bencher) {
     use self::sycamore::*;
-    use ::sycamore::prelude::*;
-    use ::sycamore::*;
+    use ::sycamore::{prelude::*, *};
 
     b.iter(|| {
         _ = create_scope(|cx| {
@@ -98,8 +121,7 @@ fn sycamore_todomvc_ssr_with_1000(b: &mut Bencher) {
 #[bench]
 fn yew_todomvc_ssr_with_1000(b: &mut Bencher) {
     use self::yew::*;
-    use ::yew::prelude::*;
-    use ::yew::ServerRenderer;
+    use ::yew::{prelude::*, ServerRenderer};
 
     b.iter(|| {
         tokio_test::block_on(async {
@@ -109,4 +131,18 @@ fn yew_todomvc_ssr_with_1000(b: &mut Bencher) {
         });
     });
 }
- */
+
+#[bench]
+fn tera_todomvc_ssr(b: &mut Bencher) {
+    use ::leptos::*;
+    let runtime = create_runtime();
+    b.iter(|| {
+        use crate::todomvc::leptos::*;
+
+        let html = ::leptos::ssr::render_to_string(|| {
+            view! { <TodoMVC todos=Todos::new()/> }
+        });
+        assert!(html.len() > 1);
+    });
+    runtime.dispose();
+}

benchmarks/src/todomvc/tachys.rs

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

benchmarks/src/todomvc/tera.rs

@@ -87,7 +87,7 @@ static TEMPLATE: &str = r#"<main>
         </main>"#;
 
 #[bench]
-fn tera_todomvc(b: &mut Bencher) {
+fn tera_todomvc_ssr(b: &mut Bencher) {
     use serde::{Deserialize, Serialize};
     use tera::*;
 
@@ -127,7 +127,7 @@ fn tera_todomvc(b: &mut Bencher) {
 }
 
 #[bench]
-fn tera_todomvc_1000(b: &mut Bencher) {
+fn tera_todomvc_ssr_1000(b: &mut Bencher) {
     use serde::{Deserialize, Serialize};
     use tera::*;
 

cargo-make/check.toml

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

cargo-make/lint.toml

@@ -0,0 +1,11 @@
+[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

@@ -0,0 +1,15 @@
+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

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

docs/COMMON_BUGS.md

@@ -9,10 +9,10 @@ This document is intended as a running list of common issues, with example code
 **Issue**: Sometimes you want to update a reactive signal in a way that depends on another signal.
 
 ```rust
-let (a, set_a) = create_signal(cx, 0);
-let (b, set_b) = create_signal(cx, false);
+let (a, set_a) = create_signal(0);
+let (b, set_b) = create_signal(false);
 
-create_effect(cx, move |_| {
+create_effect(move |_| {
 	if a() > 5 {
 		set_b(true);
 	}
@@ -24,10 +24,56 @@ This creates an inefficient chain of updates, and can easily lead to infinite lo
 **Solution**: Follow the rule, _What can be derived, should be derived._ In this case, this has the benefit of massively reducing the code size, too!
 
 ```rust
-let (a, set_a) = create_signal(cx, 0);
+let (a, set_a) = create_signal(0);
 let b = move || a () > 5;
 ```
 
+### Nested signal updates/reads triggering panic
+
+Sometimes you have nested signals: for example, hash-map that can change over time, each of whose values can also change over time:
+
+```rust
+#[component]
+pub fn App() -> impl IntoView {
+    let resources = create_rw_signal(HashMap::new());
+
+    let update = move |id: usize| {
+        resources.update(|resources| {
+            resources
+                .entry(id)
+                .or_insert_with(|| create_rw_signal(0))
+                .update(|amount| *amount += 1)
+        })
+    };
+
+    view! {
+        <div>
+            <pre>{move || format!("{:#?}", resources.get().into_iter().map(|(id, resource)| (id, resource.get())).collect::<Vec<_>>())}</pre>
+            <button on:click=move |_| update(1)>"+"</button>
+        </div>
+    }
+}
+```
+
+Clicking the button twice will cause a panic, because of the nested signal _read_. Calling the `update` function on `resources` immediately takes out a mutable borrow on `resources`, then updates the `resource` signal—which re-runs the effect that reads from the signals, which tries to immutably access `resources` and panics. It's the nested update here which causes a problem, because the inner update triggers and effect that tries to read both signals while the outer is still updating.
+
+You can fix this fairly easily by using the [`batch()`](https://docs.rs/leptos/latest/leptos/fn.batch.html) method:
+
+```rust
+    let update = move |id: usize| {
+        batch(move || {
+            resources.update(|resources| {
+                resources
+                    .entry(id)
+                    .or_insert_with(|| create_rw_signal(0))
+                    .update(|amount| *amount += 1)
+            })
+        });
+    };
+```
+
+This delays running any effects until after both updates are made, preventing the conflict entirely without requiring any other restructuring.
+
 ## Templates and the DOM
 
 ### `<input value=...>` doesn't update or stops updating
@@ -37,11 +83,11 @@ Many DOM attributes can be updated either by setting an attribute on the DOM nod
 This means that in practice, attributes like `value` or `checked` on an `<input/>` element only update the _default_ value for the `<input/>`. If you want to reactively update the value, you should use `prop:value` instead to set the `value` property.
 
 ```rust
-let (a, set_a) = create_signal(cx, "Starting value".to_string());
+let (a, set_a) = create_signal("Starting value".to_string());
 let on_input = move |ev| set_a(event_target_value(&ev));
 
 view! {
-	cx,
+
 	// ❌ reactivity doesn't work as expected: typing only updates the default
 	//    of each input, so if you start typing in the second input, it won't
 	//    update the first one
@@ -51,13 +97,29 @@ view! {
 ```
 
 ```rust
-let (a, set_a) = create_signal(cx, "Starting value".to_string());
+let (a, set_a) = create_signal("Starting value".to_string());
 let on_input = move |ev| set_a(event_target_value(&ev));
 
 view! {
-	cx,
+
 	// ✅ works as intended by setting the value *property*
 	<input prop:value=a on:input=on_input />
 	<input prop:value=a on:input=on_input />
 }
 ```
+
+## Build configuration
+
+### Cargo feature resolution in workspaces
+
+A new [version](https://doc.rust-lang.org/cargo/reference/resolver.html#resolver-versions) of Cargo's feature resolver was introduced for the 2021 edition of Rust.
+For single crate projects it will select a resolver version based on the Rust edition in `Cargo.toml`. As there is no Rust edition present for `Cargo.toml` in a workspace, Cargo will default to the pre 2021 edition resolver.
+This can cause issues resulting in non WASM compatible code being built for a WASM target. Seeing `mio` failing to build is often a sign that none WASM compatible code is being included in the build.
+
+The resolver version can be set in the workspace `Cargo.toml` to remedy this issue.
+
+```toml
+[workspace]
+members = ["member1", "member2"]
+resolver = "2"
+```

docs/book/README.md

@@ -1,14 +1,3 @@
-This project contains the core of a new introductory guide to Leptos.
+The Leptos book is now available at [https://book.leptos.dev](https://book.leptos.dev).
 
-It is built using `mdbook`. You can view a local copy by installing `mdbook`
-
-```bash
-cargo install mdbook
-```
-
-and run the book with
-```
-mdbook serve
-```
-
-It should be available at `http://localhost:3000`.
+The source code for the book has moved to [https://github.com/leptos-rs/book](https://github.com/leptos-rs/book). Please open issues or make PRs in that repository.

docs/book/book.toml

@@ -0,0 +1,10 @@
+[output.html]
+additional-css = ["./mdbook-admonish.css"]
+[output.html.playground]
+runnable = false
+
+[preprocessor]
+
+[preprocessor.admonish]
+command = "mdbook-admonish"
+assets_version = "3.0.1" # do not edit: managed by `mdbook-admonish install`

docs/book/mdbook-admonish.css

@@ -0,0 +1,345 @@
+@charset "UTF-8";
+:root {
+  --md-admonition-icon--admonish-note: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M20.71 7.04c.39-.39.39-1.04 0-1.41l-2.34-2.34c-.37-.39-1.02-.39-1.41 0l-1.84 1.83 3.75 3.75M3 17.25V21h3.75L17.81 9.93l-3.75-3.75L3 17.25z'/></svg>");
+  --md-admonition-icon--admonish-abstract: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M17 9H7V7h10m0 6H7v-2h10m-3 6H7v-2h7M12 3a1 1 0 0 1 1 1 1 1 0 0 1-1 1 1 1 0 0 1-1-1 1 1 0 0 1 1-1m7 0h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2z'/></svg>");
+  --md-admonition-icon--admonish-info: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M13 9h-2V7h2m0 10h-2v-6h2m-1-9A10 10 0 0 0 2 12a10 10 0 0 0 10 10 10 10 0 0 0 10-10A10 10 0 0 0 12 2z'/></svg>");
+  --md-admonition-icon--admonish-tip: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M17.66 11.2c-.23-.3-.51-.56-.77-.82-.67-.6-1.43-1.03-2.07-1.66C13.33 7.26 13 4.85 13.95 3c-.95.23-1.78.75-2.49 1.32-2.59 2.08-3.61 5.75-2.39 8.9.04.1.08.2.08.33 0 .22-.15.42-.35.5-.23.1-.47.04-.66-.12a.58.58 0 0 1-.14-.17c-1.13-1.43-1.31-3.48-.55-5.12C5.78 10 4.87 12.3 5 14.47c.06.5.12 1 .29 1.5.14.6.41 1.2.71 1.73 1.08 1.73 2.95 2.97 4.96 3.22 2.14.27 4.43-.12 6.07-1.6 1.83-1.66 2.47-4.32 1.53-6.6l-.13-.26c-.21-.46-.77-1.26-.77-1.26m-3.16 6.3c-.28.24-.74.5-1.1.6-1.12.4-2.24-.16-2.9-.82 1.19-.28 1.9-1.16 2.11-2.05.17-.8-.15-1.46-.28-2.23-.12-.74-.1-1.37.17-2.06.19.38.39.76.63 1.06.77 1 1.98 1.44 2.24 2.8.04.14.06.28.06.43.03.82-.33 1.72-.93 2.27z'/></svg>");
+  --md-admonition-icon--admonish-success: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='m9 20.42-6.21-6.21 2.83-2.83L9 14.77l9.88-9.89 2.83 2.83L9 20.42z'/></svg>");
+  --md-admonition-icon--admonish-question: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='m15.07 11.25-.9.92C13.45 12.89 13 13.5 13 15h-2v-.5c0-1.11.45-2.11 1.17-2.83l1.24-1.26c.37-.36.59-.86.59-1.41a2 2 0 0 0-2-2 2 2 0 0 0-2 2H8a4 4 0 0 1 4-4 4 4 0 0 1 4 4 3.2 3.2 0 0 1-.93 2.25M13 19h-2v-2h2M12 2A10 10 0 0 0 2 12a10 10 0 0 0 10 10 10 10 0 0 0 10-10c0-5.53-4.5-10-10-10z'/></svg>");
+  --md-admonition-icon--admonish-warning: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M13 14h-2V9h2m0 9h-2v-2h2M1 21h22L12 2 1 21z'/></svg>");
+  --md-admonition-icon--admonish-failure: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M20 6.91 17.09 4 12 9.09 6.91 4 4 6.91 9.09 12 4 17.09 6.91 20 12 14.91 17.09 20 20 17.09 14.91 12 20 6.91z'/></svg>");
+  --md-admonition-icon--admonish-danger: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M11 15H6l7-14v8h5l-7 14v-8z'/></svg>");
+  --md-admonition-icon--admonish-bug: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M14 12h-4v-2h4m0 6h-4v-2h4m6-6h-2.81a5.985 5.985 0 0 0-1.82-1.96L17 4.41 15.59 3l-2.17 2.17a6.002 6.002 0 0 0-2.83 0L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8z'/></svg>");
+  --md-admonition-icon--admonish-example: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M7 13v-2h14v2H7m0 6v-2h14v2H7M7 7V5h14v2H7M3 8V5H2V4h2v4H3m-1 9v-1h3v4H2v-1h2v-.5H3v-1h1V17H2m2.25-7a.75.75 0 0 1 .75.75c0 .2-.08.39-.21.52L3.12 13H5v1H2v-.92L4 11H2v-1h2.25z'/></svg>");
+  --md-admonition-icon--admonish-quote: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M14 17h3l2-4V7h-6v6h3M6 17h3l2-4V7H5v6h3l-2 4z'/></svg>");
+  --md-details-icon: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M8.59 16.58 13.17 12 8.59 7.41 10 6l6 6-6 6-1.41-1.42Z'/></svg>");
+}
+
+:is(.admonition) {
+  display: flow-root;
+  margin: 1.5625em 0;
+  padding: 0 1.2rem;
+  color: var(--fg);
+  page-break-inside: avoid;
+  background-color: var(--bg);
+  border: 0 solid black;
+  border-inline-start-width: 0.4rem;
+  border-radius: 0.2rem;
+  box-shadow: 0 0.2rem 1rem rgba(0, 0, 0, 0.05), 0 0 0.1rem rgba(0, 0, 0, 0.1);
+}
+@media print {
+  :is(.admonition) {
+    box-shadow: none;
+  }
+}
+:is(.admonition) > * {
+  box-sizing: border-box;
+}
+:is(.admonition) :is(.admonition) {
+  margin-top: 1em;
+  margin-bottom: 1em;
+}
+:is(.admonition) > .tabbed-set:only-child {
+  margin-top: 0;
+}
+html :is(.admonition) > :last-child {
+  margin-bottom: 1.2rem;
+}
+
+a.admonition-anchor-link {
+  display: none;
+  position: absolute;
+  left: -1.2rem;
+  padding-right: 1rem;
+}
+a.admonition-anchor-link:link, a.admonition-anchor-link:visited {
+  color: var(--fg);
+}
+a.admonition-anchor-link:link:hover, a.admonition-anchor-link:visited:hover {
+  text-decoration: none;
+}
+a.admonition-anchor-link::before {
+  content: "§";
+}
+
+:is(.admonition-title, summary.admonition-title) {
+  position: relative;
+  min-height: 4rem;
+  margin-block: 0;
+  margin-inline: -1.6rem -1.2rem;
+  padding-block: 0.8rem;
+  padding-inline: 4.4rem 1.2rem;
+  font-weight: 700;
+  background-color: rgba(68, 138, 255, 0.1);
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+  display: flex;
+}
+:is(.admonition-title, summary.admonition-title) p {
+  margin: 0;
+}
+html :is(.admonition-title, summary.admonition-title):last-child {
+  margin-bottom: 0;
+}
+:is(.admonition-title, summary.admonition-title)::before {
+  position: absolute;
+  top: 0.625em;
+  inset-inline-start: 1.6rem;
+  width: 2rem;
+  height: 2rem;
+  background-color: #448aff;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+  mask-image: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"></svg>');
+  -webkit-mask-image: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"></svg>');
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-size: contain;
+  content: "";
+}
+:is(.admonition-title, summary.admonition-title):hover a.admonition-anchor-link {
+  display: initial;
+}
+
+details.admonition > summary.admonition-title::after {
+  position: absolute;
+  top: 0.625em;
+  inset-inline-end: 1.6rem;
+  height: 2rem;
+  width: 2rem;
+  background-color: currentcolor;
+  mask-image: var(--md-details-icon);
+  -webkit-mask-image: var(--md-details-icon);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-size: contain;
+  content: "";
+  transform: rotate(0deg);
+  transition: transform 0.25s;
+}
+details[open].admonition > summary.admonition-title::after {
+  transform: rotate(90deg);
+}
+
+:is(.admonition):is(.admonish-note) {
+  border-color: #448aff;
+}
+
+:is(.admonish-note) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(68, 138, 255, 0.1);
+}
+:is(.admonish-note) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #448aff;
+  mask-image: var(--md-admonition-icon--admonish-note);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-note);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-abstract, .admonish-summary, .admonish-tldr) {
+  border-color: #00b0ff;
+}
+
+:is(.admonish-abstract, .admonish-summary, .admonish-tldr) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(0, 176, 255, 0.1);
+}
+:is(.admonish-abstract, .admonish-summary, .admonish-tldr) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #00b0ff;
+  mask-image: var(--md-admonition-icon--admonish-abstract);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-abstract);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-info, .admonish-todo) {
+  border-color: #00b8d4;
+}
+
+:is(.admonish-info, .admonish-todo) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(0, 184, 212, 0.1);
+}
+:is(.admonish-info, .admonish-todo) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #00b8d4;
+  mask-image: var(--md-admonition-icon--admonish-info);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-info);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-tip, .admonish-hint, .admonish-important) {
+  border-color: #00bfa5;
+}
+
+:is(.admonish-tip, .admonish-hint, .admonish-important) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(0, 191, 165, 0.1);
+}
+:is(.admonish-tip, .admonish-hint, .admonish-important) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #00bfa5;
+  mask-image: var(--md-admonition-icon--admonish-tip);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-tip);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-success, .admonish-check, .admonish-done) {
+  border-color: #00c853;
+}
+
+:is(.admonish-success, .admonish-check, .admonish-done) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(0, 200, 83, 0.1);
+}
+:is(.admonish-success, .admonish-check, .admonish-done) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #00c853;
+  mask-image: var(--md-admonition-icon--admonish-success);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-success);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-question, .admonish-help, .admonish-faq) {
+  border-color: #64dd17;
+}
+
+:is(.admonish-question, .admonish-help, .admonish-faq) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(100, 221, 23, 0.1);
+}
+:is(.admonish-question, .admonish-help, .admonish-faq) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #64dd17;
+  mask-image: var(--md-admonition-icon--admonish-question);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-question);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-warning, .admonish-caution, .admonish-attention) {
+  border-color: #ff9100;
+}
+
+:is(.admonish-warning, .admonish-caution, .admonish-attention) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(255, 145, 0, 0.1);
+}
+:is(.admonish-warning, .admonish-caution, .admonish-attention) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #ff9100;
+  mask-image: var(--md-admonition-icon--admonish-warning);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-warning);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-failure, .admonish-fail, .admonish-missing) {
+  border-color: #ff5252;
+}
+
+:is(.admonish-failure, .admonish-fail, .admonish-missing) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(255, 82, 82, 0.1);
+}
+:is(.admonish-failure, .admonish-fail, .admonish-missing) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #ff5252;
+  mask-image: var(--md-admonition-icon--admonish-failure);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-failure);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-danger, .admonish-error) {
+  border-color: #ff1744;
+}
+
+:is(.admonish-danger, .admonish-error) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(255, 23, 68, 0.1);
+}
+:is(.admonish-danger, .admonish-error) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #ff1744;
+  mask-image: var(--md-admonition-icon--admonish-danger);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-danger);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-bug) {
+  border-color: #f50057;
+}
+
+:is(.admonish-bug) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(245, 0, 87, 0.1);
+}
+:is(.admonish-bug) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #f50057;
+  mask-image: var(--md-admonition-icon--admonish-bug);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-bug);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-example) {
+  border-color: #7c4dff;
+}
+
+:is(.admonish-example) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(124, 77, 255, 0.1);
+}
+:is(.admonish-example) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #7c4dff;
+  mask-image: var(--md-admonition-icon--admonish-example);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-example);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+:is(.admonition):is(.admonish-quote, .admonish-cite) {
+  border-color: #9e9e9e;
+}
+
+:is(.admonish-quote, .admonish-cite) > :is(.admonition-title, summary.admonition-title) {
+  background-color: rgba(158, 158, 158, 0.1);
+}
+:is(.admonish-quote, .admonish-cite) > :is(.admonition-title, summary.admonition-title)::before {
+  background-color: #9e9e9e;
+  mask-image: var(--md-admonition-icon--admonish-quote);
+  -webkit-mask-image: var(--md-admonition-icon--admonish-quote);
+  mask-repeat: no-repeat;
+  -webkit-mask-repeat: no-repeat;
+  mask-size: contain;
+  -webkit-mask-repeat: no-repeat;
+}
+
+.navy :is(.admonition) {
+  background-color: var(--sidebar-bg);
+}
+
+.ayu :is(.admonition),
+.coal :is(.admonition) {
+  background-color: var(--theme-hover);
+}
+
+.rust :is(.admonition) {
+  background-color: var(--sidebar-bg);
+  color: var(--sidebar-fg);
+}
+.rust .admonition-anchor-link:link, .rust .admonition-anchor-link:visited {
+  color: var(--sidebar-fg);
+}

docs/book/src/01_introduction.md

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

docs/book/src/02_getting_started.md

@@ -1,48 +0,0 @@
-# Getting Started
-
-There are two basic paths to getting started with Leptos:
-1. Client-side rendering with [Trunk](https://trunkrs.dev/)
-2. Full-stack rendering with [`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos)
-
-For the early examples, it will be easiest to begin with Trunk. We’ll introduce
-`cargo-leptos` a little later in this series.
-
-
-If you don’t already have it installed, you can install Trunk by running
-
-```bash
-cargo install trunk
-```
-
-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
-```
-
-Create a simple `index.html` in the root of the `leptos-tutorial` directory
-```html
-<!DOCTYPE html>
-<html>
-  <head></head>
-  <body></body>
-</html>
-```
-
-And add a simple “Hello, world!” to your `main.rs`
-```rust 
-use leptos::*;
-
-fn main() {
-    mount_to_body(|_cx| view! { cx,  <p>"Hello, world!"</p> })
-}
-```
-
-Now run `trunk serve --open`. Trunk should automatically compile your app and 
-open it in your default browser. If you make edits to `main.rs`, Trunk will 
-recompile your source code and live-reload the page.

docs/book/src/15_global_state.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/15_global_state.html">
+<link rel="canonical" href="https://book.leptos.dev/15_global_state.html">

docs/book/src/SUMMARY.md

@@ -1,41 +1,56 @@
 # Summary
 
 - [Introduction](./01_introduction.md)
-- [Getting Started](./02_getting_started.md)
-- [Building User Interfaces](./view/README.md)
+- [Getting Started](./getting_started/README.md)
+  - [Leptos DX](./getting_started/leptos_dx.md)
+  - [The Leptos Community and leptos-* Crates](./getting_started/community_crates.md)
+- [Part 1: Building User Interfaces](./view/README.md)
   - [A Basic Component](./view/01_basic_component.md)
   - [Dynamic Attributes](./view/02_dynamic_attributes.md)
   - [Components and Props](./view/03_components.md)
   - [Iteration](./view/04_iteration.md)
+  - [Iterating over More Complex Data](./view/04b_iteration.md)
   - [Forms and Inputs](./view/05_forms.md)
   - [Control Flow](./view/06_control_flow.md)
   - [Error Handling](./view/07_errors.md)
   - [Parent-Child Communication](./view/08_parent_child.md)
   - [Passing Children to Components](./view/09_component_children.md)
-- [Interlude: Reactivity and Functions](./interlude_functions.md)
+  - [No Macros: The View Builder Syntax](./view/builder.md)
+- [Reactivity](./reactivity/README.md)
+  - [Working with Signals](./reactivity/working_with_signals.md)
+  - [Responding to Changes with `create_effect`](./reactivity/14_create_effect.md)
+  - [Interlude: Reactivity and Functions](./reactivity/interlude_functions.md)
 - [Testing](./testing.md)
-- [Interlude: Styling — CSS, Tailwind, Style.rs, and more]()
-- [Async]()
-  - [Resource]()
-  - [Suspense]()
-  - [Transition]()
-- [State Management]()
-- [Interlude: Advanced Reactivity]()
-- [Router]()
-  - [Fundamentals]()
-  - [defining `<Routes/>`]()
-  - [`<A/>`]()
-  - [`<Form/>`]()
-- [Metadata]()
-- [SSR]()
-  - [Models of SSR]()
-  - [`cargo-leptos`]()
-  - [Hydration Footguns]()
-- [Request/Response]()
-  - [Headers]()
-  - [Cookies]()
-- [Server Functions]()
-  - [Actions]()
-  - [Forms]()
-  - [`<ActionForm/>`s]()
-  - [Turning off WebAssembly]()
+- [Async](./async/README.md)
+  - [Loading Data with Resources](./async/10_resources.md)
+  - [Suspense](./async/11_suspense.md)
+  - [Transition](./async/12_transition.md)
+  - [Actions](./async/13_actions.md)
+- [Interlude: Projecting Children](./interlude_projecting_children.md)
+- [Global State Management](./15_global_state.md)
+- [Router](./router/README.md)
+  - [Defining `<Routes/>`](./router/16_routes.md)
+  - [Nested Routing](./router/17_nested_routing.md)
+  - [Params and Queries](./router/18_params_and_queries.md)
+  - [`<A/>`](./router/19_a.md)
+  - [`<Form/>`](./router/20_form.md)
+- [Interlude: Styling](./interlude_styling.md)
+- [Metadata](./metadata.md)
+- [Client-Side Rendering: Wrapping Up](./csr_wrapping_up.md)
+- [Part 2: Server Side Rendering](./ssr/README.md)
+  - [`cargo-leptos`](./ssr/21_cargo_leptos.md)
+  - [The Life of a Page Load](./ssr/22_life_cycle.md)
+  - [Async Rendering and SSR “Modes”](./ssr/23_ssr_modes.md)
+  - [Hydration Bugs](./ssr/24_hydration_bugs.md)
+- [Working with the Server](./server/README.md)
+  - [Server Functions](./server/25_server_functions.md)
+  - [Extractors](./server/26_extractors.md)
+  - [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/README.md)
+  - [Optimizing WASM Binary Size](./deployment/binary_size.md)
+- [Guide: Islands](./islands.md)
+
+- [Appendix: How Does the Reactive System Work?](./appendix_reactive_graph.md)
+

docs/book/src/appendix_reactive_graph.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/appendix_reactive_graph.html">
+<link rel="canonical" href="https://book.leptos.dev/appendix_reactive_graph.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/async/10_resources.html">
+<link rel="canonical" href="https://book.leptos.dev/async/10_resources.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/async/11_suspense.html">
+<link rel="canonical" href="https://book.leptos.dev/async/11_suspense.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/async/12_transition.html">
+<link rel="canonical" href="https://book.leptos.dev/async/12_transition.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/async/13_action.html">
+<link rel="canonical" href="https://book.leptos.dev/async/13_action.html">

docs/book/src/async/README.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/async/index.html">
+<link rel="canonical" href="https://book.leptos.dev/async/index.html">

docs/book/src/csr_wrapping_up.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/csr_wrapping_up.html">
+<link rel="canonical" href="https://book.leptos.dev/csr_wrapping_up.html">

docs/book/src/deployment/README.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/deployment/index.html">
+<link rel="canonical" href="https://book.leptos.dev/deployment/index.html">

docs/book/src/deployment/binary_size.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/deployment/binary_size.html">
+<link rel="canonical" href="https://book.leptos.dev/deployment/binary_size.html">

docs/book/src/getting_started/README.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/getting_started/index.html">
+<link rel="canonical" href="https://book.leptos.dev/getting_started/index.html">

docs/book/src/getting_started/community_crates.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/getting_started/community_crates.html">
+<link rel="canonical" href="https://book.leptos.dev/getting_started/community_crates.html">

docs/book/src/getting_started/leptos_dx.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/getting_started/leptos_dx.html">
+<link rel="canonical" href="https://book.leptos.dev/getting_started/leptos_dx.html">

docs/book/src/interlude_functions.md

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

docs/book/src/interlude_projecting_children.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/interlude_projecting_children.html">
+<link rel="canonical" href="https://book.leptos.dev/interlude_projecting_children.html">

docs/book/src/interlude_styling.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/interlude_styling.html">
+<link rel="canonical" href="https://book.leptos.dev/interlude_styling.html">

docs/book/src/islands.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/islands.html">
+<link rel="canonical" href="https://book.leptos.dev/islands.html">

docs/book/src/metadata.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/metadata.html">
+<link rel="canonical" href="https://book.leptos.dev/metadata.html">

docs/book/src/progressive_enhancement/README.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/progressive_enhancement/index.html">
+<link rel="canonical" href="https://book.leptos.dev/progressive_enhancement/index.html">

docs/book/src/progressive_enhancement/action_form.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/progressive_enhancement/action_form.html">
+<link rel="canonical" href="https://book.leptos.dev/progressive_enhancement/action_form.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/reactivity/14_create_effect.html">
+<link rel="canonical" href="https://book.leptos.dev/reactivity/14_create_effect.html">

docs/book/src/reactivity/README.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/reactivity/index.html">
+<link rel="canonical" href="https://book.leptos.dev/reactivity/index.html">

docs/book/src/reactivity/interlude_functions.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/reactivity/interlude_functions.html">
+<link rel="canonical" href="https://book.leptos.dev/reactivity/interlude_functions.html">

docs/book/src/reactivity/working_with_signals.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/reactivity/working_with_signals.html">
+<link rel="canonical" href="https://book.leptos.dev/reactivity/working_with_signals.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/router/16_routes.html">
+<link rel="canonical" href="https://book.leptos.dev/router/16_routes.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/router/17_nested_routing.html">
+<link rel="canonical" href="https://book.leptos.dev/router/17_nested_routing.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/router/18_params_and_queries.html">
+<link rel="canonical" href="https://book.leptos.dev/router/18_params_and_queries.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/router/19_a.html">
+<link rel="canonical" href="https://book.leptos.dev/router/19_a.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/router/20_form.html">
+<link rel="canonical" href="https://book.leptos.dev/router/20_form.html">

docs/book/src/router/README.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/router/index.html">
+<link rel="canonical" href="https://book.leptos.dev/router/index.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/server/25_server_functions.html">
+<link rel="canonical" href="https://book.leptos.dev/server/25_server_functions.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/server/26_extractors.html">
+<link rel="canonical" href="https://book.leptos.dev/server/26_extractors.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/server/27_response.html">
+<link rel="canonical" href="https://book.leptos.dev/server/27_response.html">

docs/book/src/server/README.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/server/index.html">
+<link rel="canonical" href="https://book.leptos.dev/server/index.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/ssr/21_cargo_leptos.html">
+<link rel="canonical" href="https://book.leptos.dev/ssr/21_cargo_leptos.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/ssr/22_life_cycle.html">
+<link rel="canonical" href="https://book.leptos.dev/ssr/22_life_cycle.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/ssr/23_ssr_modes.html">
+<link rel="canonical" href="https://book.leptos.dev/ssr/23_ssr_modes.html">

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/ssr/24_hydration_bugs.html">
+<link rel="canonical" href="https://book.leptos.dev/ssr/24_hydration_bugs.html">

docs/book/src/ssr/README.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/ssr/index.html">
+<link rel="canonical" href="https://book.leptos.dev/ssr/index.html">

docs/book/src/testing.md

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/view/04b_iteration.html">
+<link rel="canonical" href="https://book.leptos.dev/view/04b_iteration.html">

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

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

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

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

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

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

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

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

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

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

docs/book/src/view/README.md

@@ -1,5 +1,2 @@
-# Building User Interfaces
-
-This first section will introduce you to the basic tools you need to build a reactive
-user interface using Leptos. By the end of this section, you should be able to 
-build a simple, synchronous application that is rendered in the browser.
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/view/index.html">
+<link rel="canonical" href="https://book.leptos.dev/view/index.html">

docs/book/src/view/builder.md

@@ -0,0 +1,2 @@
+<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/view/builder.html">
+<link rel="canonical" href="https://book.leptos.dev/view/builder.html">

examples/Makefile.toml

@@ -0,0 +1,55 @@
+extend = [{ path = "./cargo-make/main.toml" }]
+
+[env]
+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",
+  "login_with_token_csr_only",
+  "parent_child",
+  "router",
+  "server_fns_axum",
+  "session_auth_axum",
+  "slots",
+  "ssr_modes",
+  "ssr_modes_axum",
+  "suspense_tests",
+  "tailwind_actix",
+  "tailwind_csr",
+  "tailwind_axum",
+  "timer",
+  "todo_app_sqlite",
+  "todo_app_sqlite_axum",
+  "todomvc",
+]
+
+[tasks.gen-members]
+workspace = false
+description = "Generate the list of workspace members"
+script = '''
+examples=$(ls | 
+grep -v .md | 
+grep -v Makefile.toml | 
+grep -v cargo-make | 
+grep -v gtk | 
+jq -R -s -c 'split("\n")[:-1]')
+echo "CARGO_MAKE_CRATE_WORKSPACE_MEMBERS = $examples"
+'''
+
+[tasks.test-report]
+workspace = false
+description = "show the cargo-make configuration for web examples"
+script = { file = "./cargo-make/scripts/web-report.sh" }

examples/README.md

@@ -0,0 +1,48 @@
+# Examples README
+
+## Main Branch
+
+The examples in this directory are all built and tested against the current `main` branch.
+
+To the extent that new features have been released or breaking changes have been made since the previous release, the examples are compatible with the `main` branch and not the current release.
+
+## Getting Started
+
+The simplest way to get started with any example is to use the “quick start” command found in the README for each example. Most of the examples use either [`trunk`](https://trunkrs.dev/) (a simple build system and dev server for client-side-rendered apps) or [`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) (a build system for server-rendered and client-hydrated apps). 
+
+## Using Cargo Make
+
+You can also run any of the examples using [`cargo-make`](https://github.com/sagiegurari/cargo-make). Note that this is completely optional. We use it for CI, and it can be convenient for running the examples, but is not required.
+
+Follow these steps to get any example up and running.
+
+1. `cd` to the example root directory
+2. Run `cargo make ci` to setup and test the example
+3. Run `cargo make start` to run the example
+4. Open the client URL in the console output (<http://127.0.0.1:8080> or <http://127.0.0.1:3000> by default)
+5. Run `cargo make stop` to end any processes started by `cargo make start`. 
+
+Here are a few additional notes:
+
+- Extendable custom task files are located in the [cargo-make](./cargo-make/) directory
+- Running a task will automatically install `cargo` dependencies 
+- Each `Makefile.toml` file must extend the [cargo-make/main.toml](./cargo-make/main.toml) file
+- [cargo-make](./cargo-make/) files that end in `*-test.toml` configure web testing strategies
+- Run `cargo make test-report` to learn which examples have web tests
+
+## Prerequisites
+
+Example projects depend on the following tools. Please install them as needed.
+
+- [Rust](https://www.rust-lang.org/)
+- Nightly Rust
+  - Run `rustup toolchain install nightly`
+  - Run `rustup target add wasm32-unknown-unknown`
+- [Cargo Make](https://sagiegurari.github.io/cargo-make/)
+  - Run `cargo install --force cargo-make`
+  - Setup a command alias like `alias cm='cargo make'` to reduce typing (**_Optional_**)
+- [Trunk](https://github.com/thedodd/trunk)
+  - Run `cargo install trunk`
+- [Node Version Manager](https://github.com/nvm-sh/nvm/) (**_Optional_**)
+- [Node.js](https://nodejs.org/)
+- [pnpm](https://pnpm.io/) (**_Optional_**)

examples/SSR_NOTES.md

@@ -0,0 +1,68 @@
+# Server Side Rendering
+
+## Cargo Leptos
+
+cargo-leptos is now the easiest and most featureful way to build server side rendered apps with hydration. It provides automatic recompilation of client and server code, wasm optimisation, CSS minification, and more! Check out more about it [here](https://github.com/akesson/cargo-leptos)
+
+1. Install cargo-leptos
+
+```bash
+cargo install --locked cargo-leptos
+```
+
+2. Build the site in watch mode, recompiling on file changes
+
+```bash
+cargo leptos watch
+```
+
+Open browser on [http://localhost:3000/](http://localhost:3000/)
+
+3. When ready to deploy, run
+
+```bash
+cargo leptos build --release
+```
+
+## WASM Pack
+
+To run it as a server side app with hydration, you'll need to have wasm-pack installed.
+
+0. Edit the `[package.metadata.leptos]` section and set `site-root` to `"."`. For examples with CSS you also want to change the path of the `<StyleSheet / >` component in the root component to point towards the CSS file in the root. This tells leptos that the WASM/JS files generated by wasm-pack are available at `./pkg` and that the CSS files are no longer processed by cargo-leptos. Building to alternative folders is not supported at this time. You'll also want to edit the call to `get_configuration()` to pass in `Some(Cargo.toml)`, so that Leptos will read the settings instead of cargo-leptos. If you do so, your file/folder names cannot include dashes.
+
+1. Install wasm-pack
+
+```bash
+cargo install wasm-pack
+```
+
+2. Build the Webassembly used to hydrate the HTML from the server
+
+```bash
+wasm-pack build --target=web --debug --no-default-features --features=hydrate
+```
+
+3. Run the server to serve the Webassembly, JS, and HTML
+
+```bash
+cargo run --no-default-features --features=ssr
+```
+
+### Server Side Rendering With Hydration
+
+To run it as a server side app with hydration, first you should run
+
+```bash
+wasm-pack build --target=web --debug --no-default-features --features=hydrate
+```
+
+to generate the WebAssembly to hydrate the HTML delivered from the server.
+
+Then run the server with `cargo run` to serve the server side rendered HTML and the WASM bundle for hydration.
+
+```bash
+cargo run --no-default-features --features=ssr
+```
+
+> Note that if your hydration code changes, you will have to rerun the wasm-pack command above before running
+> `cargo run`

examples/action-form-error-handling/Cargo.toml

@@ -0,0 +1,90 @@
+[package]
+name = "action-form-error-handling"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+actix-files = { version = "0.6", optional = true }
+actix-web = { version = "4", optional = true, features = ["macros"] }
+console_error_panic_hook = "0.1"
+cfg-if = "1"
+http = { version = "0.2", optional = true }
+leptos = { path = "../../leptos" }
+leptos_meta = { path = "../../meta" }
+leptos_actix = { path = "../../integrations/actix", optional = true }
+leptos_router = { path = "../../router" }
+wasm-bindgen = "0.2"
+serde = { version = "1", features = ["derive"] }
+
+[features]
+csr = ["leptos/csr", "leptos_meta/csr", "leptos_router/csr"]
+hydrate = ["leptos/hydrate", "leptos_meta/hydrate", "leptos_router/hydrate"]
+ssr = [
+  "dep:actix-files",
+  "dep:actix-web",
+  "dep:leptos_actix",
+  "leptos/ssr",
+  "leptos_meta/ssr",
+  "leptos_router/ssr",
+]
+
+# Defines a size-optimized profile for the WASM bundle in release mode
+[profile.wasm-release]
+inherits = "release"
+opt-level = 'z'
+lto = true
+codegen-units = 1
+panic = "abort"
+
+[package.metadata.leptos]
+# The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
+output-name = "leptos_start"
+# The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
+site-root = "target/site"
+# The site-root relative folder where all compiled output (JS, WASM and CSS) is written
+# Defaults to pkg	
+site-pkg-dir = "pkg"
+# [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
+style-file = "style/main.scss"
+# The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
+site-addr = "127.0.0.1:3000"
+# The port to use for automatic reload monitoring
+reload-port = 3001
+# [Optional] Command to use when running end2end tests. It will run in the end2end dir.
+#   [Windows] for non-WSL use "npx.cmd playwright test"
+#   This binary name can be checked in Powershell with Get-Command npx
+end2end-cmd = "npx playwright test"
+end2end-dir = "end2end"
+#  The browserlist query used for optimizing the CSS.
+browserquery = "defaults"
+# Set by cargo-leptos watch when building with that tool. Controls whether autoreload JS will be included in the head
+watch = false
+# The environment Leptos will run in, usually either "DEV" or "PROD"
+env = "DEV"
+# The features to use when compiling the bin target
+#
+# Optional. Can be over-ridden with the command line parameter --bin-features
+bin-features = ["ssr"]
+
+# If the --no-default-features flag should be used when compiling the bin target
+#
+# Optional. Defaults to false.
+bin-default-features = false
+
+# The features to use when compiling the lib target
+#
+# Optional. Can be over-ridden with the command line parameter --lib-features
+lib-features = ["hydrate"]
+
+# If the --no-default-features flag should be used when compiling the lib target
+#
+# Optional. Defaults to false.
+lib-default-features = false
+
+# The profile to use for the lib target when compiling for release
+#
+# Optional. Defaults to "release".
+lib-profile-release = "wasm-release"