missed one

* feat: impl `From<ArcField<T>>` for `Field<T>`

* [autofix.ci] apply automated fixes

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

.github/workflows/autofix.yml

@@ -0,0 +1,54 @@
+name: autofix.ci
+on:
+  pull_request:
+  # Running this workflow on main branch pushes requires write permission to apply changes.
+  # Leave it alone for future uses.
+  # push:
+  #   branches: ["main"]
+permissions:
+  contents: read
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+env:
+  CARGO_TERM_COLOR: always
+  RUST_BACKTRACE: 1
+  DEBIAN_FRONTEND: noninteractive
+jobs:
+  autofix:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with: {toolchain: nightly, components: "rustfmt, clippy", target: "wasm32-unknown-unknown", rustflags: ""}
+      - name: Install Glib
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libglib2.0-dev
+      - name: Install jq
+        run: sudo apt-get install jq
+      - run: |
+          echo "Formatting the workspace"
+          cargo fmt --all
+
+          echo "Running Clippy against each member's features (default features included)"
+          for member in $(cargo metadata --no-deps --format-version 1 | jq -r '.packages[] | .name'); do
+              echo "Working on member $member":
+              echo -e "\tdefault-features/no-features:"
+              # this will also run on members with no features or default features
+              cargo clippy --allow-dirty --fix --lib --package "$member"
+
+              features=$(cargo metadata --no-deps --format-version 1 | jq -r ".packages[] | select(.name == \"$member\") | .features | keys[]")
+              for feature in $features; do
+                  if [ "$feature" = "default" ]; then
+                    continue
+                  fi
+                  echo -e "\tfeature $feature"
+                  cargo clippy --allow-dirty --fix --lib --package "$member" --features "$feature"
+              done
+          done
+      - uses: autofix-ci/action@v1.3.1
+        if: ${{ always() }}
+        with:
+          fail-fast: false

.github/workflows/check-examples.yml

@@ -1,46 +0,0 @@
-name: Check Examples
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  setup:
-    name: Get Examples
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - 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 examples/README.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"
-
-  matrix-job:
-    name: Check
-    needs: [setup]
-    strategy:
-      matrix: ${{ fromJSON(needs.setup.outputs.matrix) }}
-      fail-fast: false
-    uses: ./.github/workflows/run-cargo-make-task.yml
-    with:
-      directory: ${{ matrix.directory }}
-      cargo_make_task: "check"

.github/workflows/check-stable.yml

@@ -1,46 +0,0 @@
-name: Check stable
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-env:
-  CARGO_TERM_COLOR: always
-  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
-
-jobs:
-  test:
-    name: Check examples ${{ matrix.os }} (using rustc ${{ matrix.rust }})
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        rust:
-          - stable
-        os:
-          - ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Setup Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.rust }}
-          override: true
-          components: rustfmt
-
-      - name: Add wasm32-unknown-unknown
-        run: rustup target add wasm32-unknown-unknown
-
-      - name: Setup cargo-make
-        uses: davidB/rust-cargo-make@v1
-
-      - name: Cargo generate-lockfile
-        run: cargo generate-lockfile
-
-      - uses: Swatinem/rust-cache@v2
-
-      - name: Run cargo check on all examples
-        run: cargo make --profile=github-actions check-stable

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

@@ -0,0 +1,32 @@
+name: CI Changed Examples
+on:
+  push:
+    branches:
+      - main
+      - leptos_0.6
+      - leptos_0.8
+  pull_request:
+    branches:
+      - main
+      - leptos_0.6
+      - leptos_0.8
+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: stable

.github/workflows/ci-examples.yml

@@ -0,0 +1,29 @@
+name: CI Examples
+on:
+  push:
+    branches:
+      - main
+      - leptos_0.6
+      - leptos_0.8
+  pull_request:
+    branches:
+      - main
+      - leptos_0.6
+      - leptos_0.8
+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: stable

.github/workflows/ci-semver.yml

@@ -0,0 +1,33 @@
+name: CI semver
+on:
+  push:
+    branches:
+      - main
+      - leptos_0.6
+      - leptos_0.8
+  pull_request:
+    branches:
+      - main
+      - leptos_0.6
+      - leptos_0.8
+env:
+  DEBIAN_FRONTEND: noninteractive
+jobs:
+  get-leptos-changed:
+    uses: ./.github/workflows/get-leptos-changed.yml
+  test:
+    needs: [get-leptos-changed]
+    if: needs.get-leptos-changed.outputs.leptos_changed == 'true' && github.event.pull_request.labels[0].name != 'breaking'
+    name: Run semver check (nightly-2024-08-01)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install Glib
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libglib2.0-dev
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Semver Checks
+        uses: obi1kenobi/cargo-semver-checks-action@v2
+        with:
+          rust-toolchain: nightly-2024-08-01

.github/workflows/ci.yml

@@ -1,38 +1,29 @@
 name: CI
-
 on:
   push:
     branches:
       - main
+      - leptos_0.6
+      - leptos_0.8
   pull_request:
     branches:
       - main
-
+      - leptos_0.6
+      - leptos_0.8
 jobs:
-  matrix-job:
+  get-leptos-changed:
+    uses: ./.github/workflows/get-leptos-changed.yml
+  get-leptos-matrix:
+    uses: ./.github/workflows/get-leptos-matrix.yml
+  test:
     name: CI
+    needs: [get-leptos-changed, get-leptos-matrix]
+    if: needs.get-leptos-changed.outputs.leptos_changed == 'true'
     strategy:
-      matrix:
-        directory:
-          [
-            integrations/actix,
-            integrations/axum,
-            integrations/viz,
-            integrations/utils,
-            leptos,
-            leptos_config,
-            leptos_dom,
-            leptos_hot_reload,
-            leptos_macro,
-            leptos_reactive,
-            leptos_server,
-            meta,
-            router,
-            server_fn,
-            server_fn/server_fn_macro_default,
-            server_fn_macro,
-          ]
+      matrix: ${{ fromJSON(needs.get-leptos-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-08-01

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

@@ -0,0 +1,54 @@
+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@v45
+        with:
+          dir_names: true
+          dir_names_max_depth: "2"
+          files: |
+            examples/**
+            !examples/cargo-make/**
+            !examples/gtk/**
+            !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,33 @@
+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@v45
+        with:
+          files: |
+            examples/**
+            !examples/cargo-make/**
+            !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,36 @@
+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 }}
+    env:
+      # separate examples using "|" (vertical bar) char like "a|b|c".
+      # cargo-make should be excluded by default.
+      EXCLUDED_EXAMPLES: cargo-make
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install jq
+        run: sudo apt-get install jq
+      - name: Set Matrix
+        id: set-matrix
+        run: |
+          examples=$(ls -1d examples/*/ |
+          grep -vE "($EXCLUDED_EXAMPLES)" |
+          sed 's/\/$//' |
+          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,35 @@
+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
+        with:
+          fetch-depth: 0
+      - name: Get source files that changed
+        id: changed-source
+        uses: tj-actions/changed-files@v45
+        with:
+          files_ignore: |
+            .*/**/*
+            cargo-make/**/*
+            examples/**/*
+            projects/**/*
+            benchmarks/**/*
+            docs/**/*
+      - 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/get-leptos-matrix.yml

@@ -0,0 +1,32 @@
+name: Get Leptos Matrix Call
+on:
+  workflow_call:
+    outputs:
+      matrix:
+        description: "Matrix"
+        value: ${{ jobs.create.outputs.matrix }}
+jobs:
+  create:
+    name: Create Leptos Matrix
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install jq
+        run: sudo apt-get install jq
+      - name: Set Matrix
+        id: set-matrix
+        run: |
+          crates=$(cargo metadata --no-deps --quiet --format-version 1 |
+          jq -r '.packages[] | select(.name != "workspace") | .manifest_path| rtrimstr("/Cargo.toml")' |
+          sed "s|$(pwd)/||" |
+          jq -R -s -c 'split("\n")[:-1]')
+          echo "Leptos Directories: $crates"
+          echo "matrix={\"directory\":$crates}" >> "$GITHUB_OUTPUT"
+      - name: Print Location Info
+        run: |
+          echo "Workspace: ${{ github.workspace }}"
+          pwd
+          ls | sort -u

.github/workflows/publish-book.yml

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

@@ -1,5 +1,4 @@
 name: Run Task
-
 on:
   workflow_call:
     inputs:
@@ -9,87 +8,121 @@ on:
       cargo_make_task:
         required: true
         type: string
+      toolchain:
+        required: true
+        type: string
 env:
   CARGO_TERM_COLOR: always
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
-
+  DEBIAN_FRONTEND: noninteractive
 jobs:
   test:
-    name: Run ${{ matrix.os }} (using rustc ${{ matrix.rust }})
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        rust:
-          - nightly
-        os:
-          - ubuntu-latest
-
+    name: Run ${{ inputs.cargo_make_task }} (${{ inputs.toolchain }})
+    runs-on: ubuntu-latest
     steps:
+      - name: Free Disk Space
+        run: |
+          echo "Disk space before cleanup:"
+          df -h
+          sudo rm -rf /usr/local/.ghcup
+          sudo rm -rf /opt/hostedtoolcache/CodeQL
+          sudo rm -rf /usr/local/lib/android/sdk/ndk
+          sudo rm -rf /usr/share/dotnet
+          sudo rm -rf /opt/ghc
+          sudo rm -rf /usr/local/share/boost
+          sudo apt-get clean
+          echo "Disk space after cleanup:"
+          df -h
       # Setup environment
-      - name: Install playwright browser dependencies
+      - name: Install Glib
         run: |
           sudo apt-get update
-          sudo apt-get install libegl1 libvpx7 libevent-2.1-7 libopus0 libopengl0 libwoff1 libharfbuzz-icu0 libgstreamer-plugins-base1.0-0 libgstreamer-gl1.0-0 libhyphen0 libmanette-0.2-0 libgles2 gstreamer1.0-libav
-
-      - uses: actions/checkout@v3
-
+          sudo apt-get install -y libglib2.0-dev
+      - uses: actions/checkout@v4
       - name: Setup Rust
-        uses: actions-rs/toolchain@v1
+        uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: ${{ matrix.rust }}
-          override: true
-          components: rustfmt
-
+          toolchain: ${{ inputs.toolchain }}
       - 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 binstall
+        uses: cargo-bins/cargo-binstall@main
+      - name: Install wasm-bindgen
+        run: cargo binstall wasm-bindgen-cli --no-confirm
+      - name: Install cargo-leptos
+        run: cargo binstall cargo-leptos --locked --no-confirm
       - name: Install Trunk
-        uses: jetli/trunk-action@v0.4.0
+        uses: jetli/trunk-action@v0.5.0
         with:
           version: "latest"
-
       - name: Print Trunk Version
         run: trunk --version
-
       - name: Install Node.js
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
-          node-version: 18
-
-      - uses: pnpm/action-setup@v2
+          node-version: 20
+      - uses: pnpm/action-setup@v4
         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
+      - uses: actions/cache@v4
         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
+      - name: Install Deno
+        uses: denoland/setup-deno@v2
+        with:
+          deno-version: v1.x
+      - name: Maybe install gtk-rs dependencies
+        run: |
+          if [ ! -z $(echo ${{inputs.directory}} | grep gtk) ]; then
+            sudo apt-get update
+            sudo apt-get install -y libglib2.0-dev libgio2.0-cil-dev libgraphene-1.0-dev libcairo2-dev libpango1.0-dev libgtk-4-dev
+          fi
       # Run Cargo Make Task
       - name: ${{ inputs.cargo_make_task }}
         run: |
-          if [ "${{ inputs.directory }}" = "INTERNAL" ]; then
-            echo No verification required
-          else
-            cd ${{ inputs.directory }}
-            cargo make --profile=github-actions ${{ inputs.cargo_make_task }}
-          fi
+          cd ${{ inputs.directory }}
+          cargo make --profile=github-actions ${{ inputs.cargo_make_task }}

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

@@ -1,47 +0,0 @@
-name: Verify All Examples
-
-on:
-  workflow_dispatch:
-  push:
-    tags:
-      - v*
-  schedule:
-    # Run once a day at 3:00 AM EST
-    - cron: "0 8 * * *"
-
-jobs:
-  setup:
-    name: Get Examples
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - 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 examples/README.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"
-
-  matrix-job:
-    name: Verify
-    needs: [setup]
-    strategy:
-      matrix: ${{ fromJSON(needs.setup.outputs.matrix) }}
-      fail-fast: false
-    uses: ./.github/workflows/run-cargo-make-task.yml
-    with:
-      directory: ${{ matrix.directory }}
-      cargo_make_task: "verify-flow"

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

@@ -1,71 +0,0 @@
-name: Verify Changed Examples
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  setup:
-    name: Get Changes
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Get all example files that changed
-        id: changed-files
-        uses: tj-actions/changed-files@v36
-        with:
-          files: |
-            examples
-
-      - name: List all example files that changed
-        run: echo '${{ steps.changed-files.outputs.all_changed_files }}'
-
-      - name: Get example project directories that changed
-        id: changed-dirs
-        uses: tj-actions/changed-files@v36
-        with:
-          dir_names: true
-          dir_names_max_depth: "2"
-          files: |
-            examples
-            !examples/cargo-make
-            !examples/gtk
-            !examples/Makefile.toml
-            !examples/README.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 [ ${{ steps.changed-files.outputs.any_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\":[\"INTERNAL\"]}" >> "$GITHUB_OUTPUT"
-          fi
-
-  matrix-job:
-    name: Verify
-    needs: [setup]
-    strategy:
-      matrix: ${{ fromJSON(needs.setup.outputs.matrix) }}
-      fail-fast: false
-    uses: ./.github/workflows/run-cargo-make-task.yml
-    with:
-      directory: ${{ matrix.directory }}
-      cargo_make_task: "verify-flow"

.gitignore

@@ -3,9 +3,15 @@ dist
 pkg
 comparisons
 blob.rs
-Cargo.lock
+**/projects/**/Cargo.lock
+**/examples/**/Cargo.lock
+**/benchmarks/**/Cargo.lock
 **/*.rs.bk
 .DS_Store
 .idea
 .direnv
 .envrc
+
+.vscode
+vendor
+hash.txt

ARCHITECTURE.md

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

CONTRIBUTING.md

@@ -62,7 +62,7 @@ are a few guidelines that will make it a better experience for everyone:
 - 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 Z_ was implemented caused _issue Z_. This PR should fix that by
+  _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
@@ -70,6 +70,32 @@ are a few guidelines that will make it a better experience for everyone:
   `cargo-make` and using `cargo make check && cargo make test && cargo make
 check-examples`.
 
+## Before Submitting a PR
+
+We have a fairly extensive CI setup that runs both lints (like `rustfmt` and `clippy`)
+and tests on PRs. You can run most of these locally if you have `cargo-make` installed.
+
+Note that some of the `rustfmt` settings used require usage of the nightly compiler.
+Formatting the code using the stable toolchain may result in a wrong code format and
+subsequently CI errors.
+Run `cargo +nightly fmt` if you want to keep the stable toolchain active.
+You may want to let your IDE automatically use the `+nightly` parameter when a
+"format on save" action is used.
+
+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,47 +1,75 @@
 [workspace]
 resolver = "2"
 members = [
+  # utilities
+  "oco",
+  "any_spawner",
+  "const_str_slice_concat",
+  "either_of",
+  "next_tuple",
+  "oco",
+  "or_poisoned",
+
   # core
+  "hydration_context",
   "leptos",
   "leptos_dom",
   "leptos_config",
   "leptos_hot_reload",
   "leptos_macro",
-  "leptos_reactive",
   "leptos_server",
+  "reactive_graph",
+  "reactive_stores",
+  "reactive_stores_macro",
   "server_fn",
   "server_fn_macro",
   "server_fn/server_fn_macro_default",
+  "tachys",
 
   # integrations
   "integrations/actix",
   "integrations/axum",
-  "integrations/viz",
   "integrations/utils",
 
   # libraries
   "meta",
   "router",
+  "router_macro",
+  "any_error",
 ]
-exclude = ["benchmarks", "examples"]
+exclude = ["benchmarks", "examples", "projects"]
 
 [workspace.package]
-version = "0.4.3"
+version = "0.7.7"
+edition = "2021"
+rust-version = "1.76"
 
 [workspace.dependencies]
-leptos = { path = "./leptos", version = "0.4.3" }
-leptos_dom = { path = "./leptos_dom", version = "0.4.3" }
-leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.4.3" }
-leptos_macro = { path = "./leptos_macro", version = "0.4.3" }
-leptos_reactive = { path = "./leptos_reactive", version = "0.4.3" }
-leptos_server = { path = "./leptos_server", version = "0.4.3" }
-server_fn = { path = "./server_fn", version = "0.4.3" }
-server_fn_macro = { path = "./server_fn_macro", version = "0.4.3" }
-server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.4.3" }
-leptos_config = { path = "./leptos_config", version = "0.4.3" }
-leptos_router = { path = "./router", version = "0.4.3" }
-leptos_meta = { path = "./meta", version = "0.4.3" }
-leptos_integration_utils = { path = "./integrations/utils", version = "0.4.3" }
+throw_error = { path = "./any_error/", version = "0.2.0" }
+any_spawner = { path = "./any_spawner/", version = "0.2.0" }
+const_str_slice_concat = { path = "./const_str_slice_concat", version = "0.1" }
+either_of = { path = "./either_of/", version = "0.1.0" }
+hydration_context = { path = "./hydration_context", version = "0.2.0" }
+leptos = { path = "./leptos", version = "0.7.7" }
+leptos_config = { path = "./leptos_config", version = "0.7.7" }
+leptos_dom = { path = "./leptos_dom", version = "0.7.7" }
+leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.7.7" }
+leptos_integration_utils = { path = "./integrations/utils", version = "0.7.7" }
+leptos_macro = { path = "./leptos_macro", version = "0.7.7" }
+leptos_router = { path = "./router", version = "0.7.7" }
+leptos_router_macro = { path = "./router_macro", version = "0.7.7" }
+leptos_server = { path = "./leptos_server", version = "0.7.7" }
+leptos_meta = { path = "./meta", version = "0.7.7" }
+next_tuple = { path = "./next_tuple", version = "0.1.0" }
+oco_ref = { path = "./oco", version = "0.2.0" }
+or_poisoned = { path = "./or_poisoned", version = "0.1.0" }
+reactive_graph = { path = "./reactive_graph", version = "0.1.7" }
+reactive_stores = { path = "./reactive_stores", version = "0.1.7" }
+reactive_stores_macro = { path = "./reactive_stores_macro", version = "0.1.7" }
+server_fn = { path = "./server_fn", version = "0.7.7" }
+server_fn_macro = { path = "./server_fn_macro", version = "0.7.7" }
+server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.7.7" }
+tachys = { path = "./tachys", version = "0.1.7" }
 
 [profile.release]
 codegen-units = 1
@@ -50,3 +78,9 @@ opt-level = 'z'
 
 [workspace.metadata.cargo-all-features]
 skip_feature_sets = [["csr", "ssr"], ["csr", "hydrate"], ["ssr", "hydrate"]]
+
+[workspace.lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = [
+  'cfg(leptos_debuginfo)',
+  'cfg(erase_components)',
+] }

Makefile.toml

@@ -20,6 +20,18 @@ cwd = "examples"
 command = "cargo"
 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"

README.md

@@ -5,20 +5,23 @@
 
 [![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)
+![Crates.io MSRV](https://img.shields.io/crates/msrv/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
 
 ```rust
 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
@@ -27,21 +30,42 @@ pub fn SimpleCounter(cx: Scope, initial_value: i32) -> impl IntoView {
     let increment = move |_| set_value.update(|value| *value += 1);
 
     // create user interfaces with the declarative `view!` macro
-    view! { cx,
+    view! {
         <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
@@ -88,8 +112,6 @@ targets = ["wasm32-unknown-unknown"]
 
 The `nightly` feature enables the function call syntax for accessing and setting signals, as opposed to `.get()` and `.set()`. This leads to a consistent mental model in which accessing a reactive value of any kind (a signal, memo, or derived signal) is always represented as a function call. This is only possible with nightly Rust and the `nightly` feature.
 
-> Note: The `nightly` feature is present on the main branch version right now, but not in 0.3.x. For 0.3.x, nightly is the default and `stable` has a special feature.
-
 ## `cargo-leptos`
 
 [`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) is a build tool that's designed to make it easy to build apps that run on both the client and the server, with seamless integration. The best way to get started with a real Leptos project right now is to use `cargo-leptos` and our starter templates for [Actix](https://github.com/leptos-rs/start) or [Axum](https://github.com/leptos-rs/start-axum).
@@ -107,7 +129,7 @@ Open browser to [http://localhost:3000/](http://localhost:3000/).
 
 ### What’s up with the name?
 
-_Leptos_ (λεπτός) is an ancient Greek word meaning “thin, light, refine, fine-grained.” To me, a classicist and not a dog owner, it evokes the lightweight reactive system that powers the framework. I've since learned the same word is at the root of the medical term “leptospirosis,” a blood infection that affects humans and animals... My bad. No dogs were harmed in the creation of this framework.
+_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?
 
@@ -115,7 +137,7 @@ People usually mean one of three things by this question.
 
 1. **Are the APIs stable?** i.e., will I have to rewrite my whole app from Leptos 0.1 to 0.2 to 0.3 to 0.4, or can I write it now and benefit from new features and updates as new versions come?
 
-The APIs are basically settled. We’re adding new features, but we’re very happy with where the type system and patterns have landed. I would not expect major breaking changes to your code to adapt to future releases. The sorts of breaking changes that we discuss are things like “Oh yeah, that function should probably take `cx` as its argument...” not major changes to the way you write your application.
+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?**
 
@@ -129,44 +151,34 @@ There are several people in the community using Leptos right now for internal ap
 
 ### 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
 - Use event listeners to update signals
 - Create effects to update the UI
 
-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.
+The 0.7 update originally set out to create a "generic rendering" approach that would allow us to reuse most of the same view logic to do all of the above. Unfortunately, this has had to be shelved for now due to difficulties encountered by the Rust compiler when building larger-scale applications with the number of generics spread throughout the codebase that this required. It's an approach I'm looking forward to exploring again in the future; feel free to reach out if you're interested in this kind of work.
 
-### How is this different from Yew/Dioxus?
+### How is this different from Yew?
 
-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:
+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. (Dioxus has made huge advances in performance with its recent 0.3 release, and is now roughly on par with Leptos.)
-- **Mental model:** Adopting fine-grained reactivity also tends to simplify the mental model. There are no surprising component re-renders because there are no re-renders. You can call functions, create timeouts, etc. within the body of your component functions because they won’t be re-run. You don’t need to think about manual dependency tracking for effects; fine-grained reactivity tracks dependencies automatically.
+- **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 Dioxus?
+
+Like Leptos, Dioxus is a framework for building UIs using web technologies. However, there are significant differences in approach and features.
+
+- **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.
 
 ### How is this different from Sycamore?
 
-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.
+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:
 
-There are some practical differences that make a significant difference:
-
-- **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.
-- **Server integration:** Leptos provides primitives that encourage HTML streaming and allow for easy async integration and RPC calls, even without WASM enabled, making it easy to opt into integrations between your frontend and backend code without pushing you toward any particular metaframework patterns.
-- **Read-write segregation:** Leptos, like Solid, encourages read-write segregation between signal getters and setters, so you end up accessing signals with tuples like `let (count, set_count) = create_signal(cx, 0);` _(If you prefer or if it's more convenient for your API, you can use [`create_rw_signal`](https://docs.rs/leptos/latest/leptos/fn.create_rw_signal.html) to give a unified read/write signal.)_
-- **Signals are functions:** In Leptos, you can call a signal to access it rather than calling a specific method (so, `count()` instead of `count.get()`) This creates a more consistent mental model: accessing a reactive value is always a matter of calling a function. For example:
-
-  ```rust
-  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) { ... }
-  ```
-
-- **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.

TODO.md

@@ -0,0 +1,40 @@
+- core examples
+    - [x] counter
+    - [x] counters
+    - [x] fetch
+    - [x] todomvc 
+    - [x] error_boundary
+    - [x] parent\_child
+        - [x] on: on components
+    - [ ] router
+    - [ ] slots 
+    - [ ] hackernews
+    - [ ] counter\_isomorphic
+    - [ ] todo\_app\_sqlite
+- other ssr examples
+    - [ ] error boundary SSR
+- reactivity 
+    - Signal wrappers
+    - SignalDispose implementations on all Copy types
+    - untracked access warnings
+- ErrorBoundary
+    - [ ] RenderHtml implementation 
+    - [ ] Separate component?
+- Suspense/Transition components?
+- callbacks
+    - unsync StoredValue
+- SSR
+    - escaping HTML correctly (attributes + text nodes)
+- router
+    - nested routes
+    - trailing slashes
+- \_meta package (and use in hackernews)
+- integrations
+- update tests
+- hackernews example
+  - TODOs
+  - Suspense/Transition/Await components
+  - nicer routing components
+  - async routing (waiting for data to load before navigation)
+  - `<A>` component
+  - figure out rebuilding issues: list (needs new signal IDs) vs. regular rebuild

any_error/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "throw_error"
+version = "0.2.0"
+authors = ["Greg Johnston"]
+license = "MIT"
+readme = "../README.md"
+repository = "https://github.com/leptos-rs/leptos"
+description = "Utilities for wrapping, throwing, and catching errors."
+rust-version.workspace = true
+edition.workspace = true
+
+[dependencies]
+pin-project-lite = "0.2.15"

any_error/README.md

@@ -0,0 +1,2 @@
+A utility library for wrapping arbitrary errors, and for “throwing” errors in a way
+that can be caught by user-defined error hooks.

any_error/src/lib.rs

@@ -0,0 +1,165 @@
+#![forbid(unsafe_code)]
+#![deny(missing_docs)]
+
+//! A utility library for wrapping arbitrary errors, and for “throwing” errors in a way
+//! that can be caught by user-defined error hooks.
+
+use std::{
+    cell::RefCell,
+    error,
+    fmt::{self, Display},
+    future::Future,
+    mem, ops,
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+/* Wrapper Types */
+
+/// This is a result type into which any error can be converted.
+///
+/// Results are stored as [`Error`].
+pub type Result<T, E = Error> = core::result::Result<T, E>;
+
+/// A generic wrapper for any error.
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+pub struct Error(Arc<dyn error::Error + Send + Sync>);
+
+impl Error {
+    /// Converts the wrapper into the inner reference-counted error.
+    pub fn into_inner(self) -> Arc<dyn error::Error + Send + Sync> {
+        Arc::clone(&self.0)
+    }
+}
+
+impl ops::Deref for Error {
+    type Target = Arc<dyn error::Error + Send + Sync>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl<T> From<T> for Error
+where
+    T: error::Error + Send + Sync + 'static,
+{
+    fn from(value: T) -> Self {
+        Error(Arc::new(value))
+    }
+}
+
+/// Implements behavior that allows for global or scoped error handling.
+///
+/// This allows for both "throwing" errors to register them, and "clearing" errors when they are no
+/// longer valid. This is useful for something like a user interface, in which an error can be
+/// "thrown" on some invalid user input, and later "cleared" if the user corrects the input.
+/// Keeping a unique identifier for each error allows the UI to be updated accordingly.
+pub trait ErrorHook: Send + Sync {
+    /// Handles the given error, returning a unique identifier.
+    fn throw(&self, error: Error) -> ErrorId;
+
+    /// Clears the error associated with the given identifier.
+    fn clear(&self, id: &ErrorId);
+}
+
+/// A unique identifier for an error. This is returned when you call [`throw`], which calls a
+/// global error handler.
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Default)]
+pub struct ErrorId(usize);
+
+impl Display for ErrorId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl From<usize> for ErrorId {
+    fn from(value: usize) -> Self {
+        Self(value)
+    }
+}
+
+thread_local! {
+    static ERROR_HOOK: RefCell<Option<Arc<dyn ErrorHook>>> = RefCell::new(None);
+}
+
+/// Resets the error hook to its previous state when dropped.
+pub struct ResetErrorHookOnDrop(Option<Arc<dyn ErrorHook>>);
+
+impl Drop for ResetErrorHookOnDrop {
+    fn drop(&mut self) {
+        ERROR_HOOK.with_borrow_mut(|this| *this = self.0.take())
+    }
+}
+
+/// Returns the current error hook.
+pub fn get_error_hook() -> Option<Arc<dyn ErrorHook>> {
+    ERROR_HOOK.with_borrow(Clone::clone)
+}
+
+/// Sets the current thread-local error hook, which will be invoked when [`throw`] is called.
+pub fn set_error_hook(hook: Arc<dyn ErrorHook>) -> ResetErrorHookOnDrop {
+    ResetErrorHookOnDrop(
+        ERROR_HOOK.with_borrow_mut(|this| mem::replace(this, Some(hook))),
+    )
+}
+
+/// Invokes the error hook set by [`set_error_hook`] with the given error.
+pub fn throw(error: impl Into<Error>) -> ErrorId {
+    ERROR_HOOK
+        .with_borrow(|hook| hook.as_ref().map(|hook| hook.throw(error.into())))
+        .unwrap_or_default()
+}
+
+/// Clears the given error from the current error hook.
+pub fn clear(id: &ErrorId) {
+    ERROR_HOOK
+        .with_borrow(|hook| hook.as_ref().map(|hook| hook.clear(id)))
+        .unwrap_or_default()
+}
+
+pin_project_lite::pin_project! {
+    /// A [`Future`] that reads the error hook that is set when it is created, and sets this as the
+    /// current error hook whenever it is polled.
+    pub struct ErrorHookFuture<Fut> {
+        hook: Option<Arc<dyn ErrorHook>>,
+        #[pin]
+        inner: Fut
+    }
+}
+
+impl<Fut> ErrorHookFuture<Fut> {
+    /// Reads the current hook and wraps the given [`Future`], returning a new `Future` that will
+    /// set the error hook whenever it is polled.
+    pub fn new(inner: Fut) -> Self {
+        Self {
+            hook: ERROR_HOOK.with_borrow(Clone::clone),
+            inner,
+        }
+    }
+}
+
+impl<Fut> Future for ErrorHookFuture<Fut>
+where
+    Fut: Future,
+{
+    type Output = Fut::Output;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        let _hook = this
+            .hook
+            .as_ref()
+            .map(|hook| set_error_hook(Arc::clone(hook)));
+        this.inner.poll(cx)
+    }
+}

any_spawner/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "any_spawner"
+version = "0.2.1"
+authors = ["Greg Johnston"]
+license = "MIT"
+readme = "../README.md"
+repository = "https://github.com/leptos-rs/leptos"
+description = "Spawn asynchronous tasks in an executor-independent way."
+edition.workspace = true
+
+[dependencies]
+async-executor = { version = "1.13.1", optional = true }
+futures = "0.3.31"
+glib = { version = "0.20.6", optional = true }
+thiserror = "2.0"
+tokio = { version = "1.41", optional = true, default-features = false, features = [
+  "rt",
+] }
+tracing = { version = "0.1.41", optional = true }
+wasm-bindgen-futures = { version = "0.4.47", optional = true }
+
+[features]
+async-executor = ["dep:async-executor"]
+tracing = ["dep:tracing"]
+tokio = ["dep:tokio"]
+glib = ["dep:glib"]
+wasm-bindgen = ["dep:wasm-bindgen-futures"]
+futures-executor = ["futures/thread-pool", "futures/executor"]
+
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[package.metadata.cargo-all-features]
+denylist = ["tracing"]

any_spawner/Makefile.toml

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

any_spawner/README.md

@@ -0,0 +1,26 @@
+This crate makes it easier to write asynchronous code that is executor-agnostic, by providing a
+utility that can be used to spawn tasks in a variety of executors.
+
+It only supports single executor per program, but that executor can be set at runtime, anywhere
+in your crate (or an application that depends on it).
+
+This can be extended to support any executor or runtime that supports spawning [`Future`]s.
+
+This is a least common denominator implementation in many ways. Limitations include:
+
+- setting an executor is a one-time, global action
+- no "join handle" or other result is returned from the spawn
+- the `Future` must output `()`
+
+```rust
+use any_spawner::Executor;
+
+Executor::init_futures_executor()
+    .expect("executor should only be initialized once");
+
+// spawn a thread-safe Future
+Executor::spawn(async { /* ... */ });
+
+// spawn a Future that is !Send
+Executor::spawn_local(async { /* ... */ });
+```

any_spawner/src/lib.rs

@@ -0,0 +1,361 @@
+//! This crate makes it easier to write asynchronous code that is executor-agnostic, by providing a
+//! utility that can be used to spawn tasks in a variety of executors.
+//!
+//! It only supports single executor per program, but that executor can be set at runtime, anywhere
+//! in your crate (or an application that depends on it).
+//!
+//! This can be extended to support any executor or runtime that supports spawning [`Future`]s.
+//!
+//! This is a least common denominator implementation in many ways. Limitations include:
+//! - setting an executor is a one-time, global action
+//! - no "join handle" or other result is returned from the spawn
+//! - the `Future` must output `()`
+//!
+//! ```rust
+//! use any_spawner::Executor;
+//!
+//! // make sure an Executor has been initialized with one of the init_ functions
+//!
+//! # if false {
+//! // spawn a thread-safe Future
+//! Executor::spawn(async { /* ... */ });
+//!
+//! // spawn a Future that is !Send
+//! Executor::spawn_local(async { /* ... */ });
+//! # }
+//! ```
+
+#![forbid(unsafe_code)]
+#![deny(missing_docs)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+use std::{future::Future, pin::Pin, sync::OnceLock};
+use thiserror::Error;
+
+/// A future that has been pinned.
+pub type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
+/// A future that has been pinned.
+pub type PinnedLocalFuture<T> = Pin<Box<dyn Future<Output = T>>>;
+
+static SPAWN: OnceLock<fn(PinnedFuture<()>)> = OnceLock::new();
+static SPAWN_LOCAL: OnceLock<fn(PinnedLocalFuture<()>)> = OnceLock::new();
+static POLL_LOCAL: OnceLock<fn()> = OnceLock::new();
+
+/// Errors that can occur when using the executor.
+#[derive(Error, Debug)]
+pub enum ExecutorError {
+    /// The executor has already been set.
+    #[error("Executor has already been set.")]
+    AlreadySet,
+}
+
+/// A global async executor that can spawn tasks.
+pub struct Executor;
+
+impl Executor {
+    /// Spawns a thread-safe [`Future`].
+    /// ```rust
+    /// use any_spawner::Executor;
+    /// # if false {
+    /// // spawn a thread-safe Future
+    /// Executor::spawn(async { /* ... */ });
+    /// # }
+    /// ```
+    #[track_caller]
+    pub fn spawn(fut: impl Future<Output = ()> + Send + 'static) {
+        if let Some(spawner) = SPAWN.get() {
+            spawner(Box::pin(fut))
+        } else {
+            #[cfg(all(debug_assertions, feature = "tracing"))]
+            tracing::error!(
+                "At {}, tried to spawn a Future with Executor::spawn() before \
+                 the Executor had been set.",
+                std::panic::Location::caller()
+            );
+            #[cfg(all(debug_assertions, not(feature = "tracing")))]
+            panic!(
+                "At {}, tried to spawn a Future with Executor::spawn() before \
+                 the Executor had been set.",
+                std::panic::Location::caller()
+            );
+        }
+    }
+
+    /// Spawns a [`Future`] that cannot be sent across threads.
+    /// ```rust
+    /// use any_spawner::Executor;
+    ///
+    /// # if false {
+    /// // spawn a thread-safe Future
+    /// Executor::spawn_local(async { /* ... */ });
+    /// # }
+    /// ```
+    #[track_caller]
+    pub fn spawn_local(fut: impl Future<Output = ()> + 'static) {
+        if let Some(spawner) = SPAWN_LOCAL.get() {
+            spawner(Box::pin(fut))
+        } else {
+            #[cfg(all(debug_assertions, feature = "tracing"))]
+            tracing::error!(
+                "At {}, tried to spawn a Future with Executor::spawn_local() \
+                 before the Executor had been set.",
+                std::panic::Location::caller()
+            );
+            #[cfg(all(debug_assertions, not(feature = "tracing")))]
+            panic!(
+                "At {}, tried to spawn a Future with Executor::spawn_local() \
+                 before the Executor had been set.",
+                std::panic::Location::caller()
+            );
+        }
+    }
+
+    /// Waits until the next "tick" of the current async executor.
+    pub async fn tick() {
+        let (tx, rx) = futures::channel::oneshot::channel();
+        Executor::spawn(async move {
+            _ = tx.send(());
+        });
+        _ = rx.await;
+    }
+
+    /// Polls the current async executor.
+    /// Not all async executors support polling, so this function may not do anything.
+    pub fn poll_local() {
+        if let Some(poller) = POLL_LOCAL.get() {
+            poller()
+        }
+    }
+}
+
+impl Executor {
+    /// Globally sets the [`tokio`] runtime as the executor used to spawn tasks.
+    ///
+    /// Returns `Err(_)` if an executor has already been set.
+    ///
+    /// Requires the `tokio` feature to be activated on this crate.
+    #[cfg(feature = "tokio")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
+    pub fn init_tokio() -> Result<(), ExecutorError> {
+        SPAWN
+            .set(|fut| {
+                tokio::spawn(fut);
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        SPAWN_LOCAL
+            .set(|fut| {
+                tokio::task::spawn_local(fut);
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        Ok(())
+    }
+
+    /// Globally sets the [`wasm-bindgen-futures`] runtime as the executor used to spawn tasks.
+    ///
+    /// Returns `Err(_)` if an executor has already been set.
+    ///
+    /// Requires the `wasm-bindgen` feature to be activated on this crate.
+    #[cfg(feature = "wasm-bindgen")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "wasm-bindgen")))]
+    pub fn init_wasm_bindgen() -> Result<(), ExecutorError> {
+        SPAWN
+            .set(|fut| {
+                wasm_bindgen_futures::spawn_local(fut);
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        SPAWN_LOCAL
+            .set(|fut| {
+                wasm_bindgen_futures::spawn_local(fut);
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        Ok(())
+    }
+
+    /// Globally sets the [`glib`] runtime as the executor used to spawn tasks.
+    ///
+    /// Returns `Err(_)` if an executor has already been set.
+    ///
+    /// Requires the `glib` feature to be activated on this crate.
+    #[cfg(feature = "glib")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "glib")))]
+    pub fn init_glib() -> Result<(), ExecutorError> {
+        SPAWN
+            .set(|fut| {
+                let main_context = glib::MainContext::default();
+                main_context.spawn(fut);
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        SPAWN_LOCAL
+            .set(|fut| {
+                let main_context = glib::MainContext::default();
+                main_context.spawn_local(fut);
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        Ok(())
+    }
+
+    /// Globally sets the [`futures`] executor as the executor used to spawn tasks,
+    /// lazily creating a thread pool to spawn tasks into.
+    ///
+    /// Returns `Err(_)` if an executor has already been set.
+    ///
+    /// Requires the `futures-executor` feature to be activated on this crate.
+    #[cfg(feature = "futures-executor")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "futures-executor")))]
+    pub fn init_futures_executor() -> Result<(), ExecutorError> {
+        use futures::{
+            executor::{LocalPool, LocalSpawner, ThreadPool},
+            task::{LocalSpawnExt, SpawnExt},
+        };
+        use std::cell::RefCell;
+
+        static THREAD_POOL: OnceLock<ThreadPool> = OnceLock::new();
+        thread_local! {
+            static LOCAL_POOL: RefCell<LocalPool> = RefCell::new(LocalPool::new());
+            static SPAWNER: LocalSpawner = LOCAL_POOL.with(|pool| pool.borrow().spawner());
+        }
+
+        fn get_thread_pool() -> &'static ThreadPool {
+            THREAD_POOL.get_or_init(|| {
+                ThreadPool::new()
+                    .expect("could not create futures executor ThreadPool")
+            })
+        }
+
+        SPAWN
+            .set(|fut| {
+                get_thread_pool()
+                    .spawn(fut)
+                    .expect("failed to spawn future");
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        SPAWN_LOCAL
+            .set(|fut| {
+                SPAWNER.with(|spawner| {
+                    spawner.spawn_local(fut).expect("failed to spawn future");
+                });
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        POLL_LOCAL
+            .set(|| {
+                LOCAL_POOL.with(|pool| {
+                    if let Ok(mut pool) = pool.try_borrow_mut() {
+                        pool.run_until_stalled();
+                    }
+                    // If we couldn't borrow_mut, we're in a nested call to poll, so we don't need to do anything.
+                });
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        Ok(())
+    }
+
+    /// Globally sets the [`async_executor`] executor as the executor used to spawn tasks,
+    /// lazily creating a thread pool to spawn tasks into.
+    ///
+    /// Returns `Err(_)` if an executor has already been set.
+    ///
+    /// Requires the `async-executor` feature to be activated on this crate.
+    #[cfg(feature = "async-executor")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async-executor")))]
+    pub fn init_async_executor() -> Result<(), ExecutorError> {
+        use async_executor::{Executor, LocalExecutor};
+
+        static THREAD_POOL: OnceLock<Executor> = OnceLock::new();
+        thread_local! {
+            static LOCAL_POOL: LocalExecutor<'static> = const { LocalExecutor::new() };
+        }
+
+        fn get_thread_pool() -> &'static Executor<'static> {
+            THREAD_POOL.get_or_init(Executor::new)
+        }
+
+        SPAWN
+            .set(|fut| {
+                get_thread_pool().spawn(fut).detach();
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        SPAWN_LOCAL
+            .set(|fut| {
+                LOCAL_POOL.with(|pool| pool.spawn(fut).detach());
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        POLL_LOCAL
+            .set(|| {
+                LOCAL_POOL.with(|pool| pool.try_tick());
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        Ok(())
+    }
+
+    /// Globally sets a custom executor as the executor used to spawn tasks.
+    ///
+    /// Returns `Err(_)` if an executor has already been set.
+    pub fn init_custom_executor(
+        custom_executor: impl CustomExecutor + Send + Sync + 'static,
+    ) -> Result<(), ExecutorError> {
+        static EXECUTOR: OnceLock<Box<dyn CustomExecutor + Send + Sync>> =
+            OnceLock::new();
+        EXECUTOR
+            .set(Box::new(custom_executor))
+            .map_err(|_| ExecutorError::AlreadySet)?;
+
+        SPAWN
+            .set(|fut| {
+                EXECUTOR.get().unwrap().spawn(fut);
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        SPAWN_LOCAL
+            .set(|fut| EXECUTOR.get().unwrap().spawn_local(fut))
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        POLL_LOCAL
+            .set(|| EXECUTOR.get().unwrap().poll_local())
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        Ok(())
+    }
+
+    /// Locally sets a custom executor as the executor used to spawn tasks
+    /// in the current thread.
+    ///
+    /// Returns `Err(_)` if an executor has already been set.
+    pub fn init_local_custom_executor(
+        custom_executor: impl CustomExecutor + 'static,
+    ) -> Result<(), ExecutorError> {
+        thread_local! {
+            static EXECUTOR: OnceLock<Box<dyn CustomExecutor>> = OnceLock::new();
+        }
+        EXECUTOR.with(|this| {
+            this.set(Box::new(custom_executor))
+                .map_err(|_| ExecutorError::AlreadySet)
+        })?;
+
+        SPAWN
+            .set(|fut| {
+                EXECUTOR.with(|this| this.get().unwrap().spawn(fut));
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        SPAWN_LOCAL
+            .set(|fut| {
+                EXECUTOR.with(|this| this.get().unwrap().spawn_local(fut));
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        POLL_LOCAL
+            .set(|| {
+                EXECUTOR.with(|this| this.get().unwrap().poll_local());
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        Ok(())
+    }
+}
+
+/// A trait for custom executors.
+/// Custom executors can be used to integrate with any executor that supports spawning futures.
+///  
+/// All methods can be called recursively.
+pub trait CustomExecutor {
+    /// Spawns a future, usually on a thread pool.
+    fn spawn(&self, fut: PinnedFuture<()>);
+    /// Spawns a local future. May require calling `poll_local` to make progress.
+    fn spawn_local(&self, fut: PinnedLocalFuture<()>);
+    /// Polls the executor, if it supports polling.
+    fn poll_local(&self);
+}

any_spawner/tests/custom_runtime.rs

@@ -0,0 +1,55 @@
+#[cfg(feature = "futures-executor")]
+use any_spawner::{CustomExecutor, Executor, PinnedFuture, PinnedLocalFuture};
+#[cfg(feature = "futures-executor")]
+#[test]
+fn can_create_custom_executor() {
+    use futures::{
+        executor::{LocalPool, LocalSpawner},
+        task::LocalSpawnExt,
+    };
+    use std::{
+        cell::RefCell,
+        sync::{
+            atomic::{AtomicUsize, Ordering},
+            Arc,
+        },
+    };
+
+    thread_local! {
+        static LOCAL_POOL: RefCell<LocalPool> = RefCell::new(LocalPool::new());
+        static SPAWNER: LocalSpawner = LOCAL_POOL.with(|pool| pool.borrow().spawner());
+    }
+
+    struct CustomFutureExecutor;
+    impl CustomExecutor for CustomFutureExecutor {
+        fn spawn(&self, _fut: PinnedFuture<()>) {
+            panic!("not supported in this test");
+        }
+
+        fn spawn_local(&self, fut: PinnedLocalFuture<()>) {
+            SPAWNER.with(|spawner| {
+                spawner.spawn_local(fut).expect("failed to spawn future");
+            });
+        }
+
+        fn poll_local(&self) {
+            LOCAL_POOL.with(|pool| {
+                if let Ok(mut pool) = pool.try_borrow_mut() {
+                    pool.run_until_stalled();
+                }
+                // If we couldn't borrow_mut, we're in a nested call to poll, so we don't need to do anything.
+            });
+        }
+    }
+
+    Executor::init_custom_executor(CustomFutureExecutor)
+        .expect("couldn't set executor");
+
+    let counter = Arc::new(AtomicUsize::new(0));
+    let counter_clone = Arc::clone(&counter);
+    Executor::spawn_local(async move {
+        counter_clone.store(1, Ordering::Release);
+    });
+    Executor::poll_local();
+    assert_eq!(counter.load(Ordering::Acquire), 1);
+}

any_spawner/tests/futures_runtime.rs

@@ -0,0 +1,38 @@
+#[cfg(feature = "futures-executor")]
+use any_spawner::Executor;
+// All tests in this file use the same executor.
+
+#[cfg(feature = "futures-executor")]
+#[test]
+fn can_spawn_local_future() {
+    use std::rc::Rc;
+
+    let _ = Executor::init_futures_executor();
+    let rc = Rc::new(());
+    Executor::spawn_local(async {
+        _ = rc;
+    });
+    Executor::spawn(async {});
+}
+
+#[cfg(feature = "futures-executor")]
+#[test]
+fn can_make_local_progress() {
+    use std::sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    };
+    let _ = Executor::init_futures_executor();
+    let counter = Arc::new(AtomicUsize::new(0));
+    Executor::spawn_local({
+        let counter = Arc::clone(&counter);
+        async move {
+            assert_eq!(counter.fetch_add(1, Ordering::AcqRel), 0);
+            Executor::spawn_local(async {
+                // Should not crash
+            });
+        }
+    });
+    Executor::poll_local();
+    assert_eq!(counter.load(Ordering::Acquire), 1);
+}

benchmarks/Cargo.toml

@@ -2,26 +2,36 @@
 name = "benchmarks"
 version = "0.1.0"
 edition = "2021"
+# std::sync::LazyLock is stabilized in Rust version 1.80.0
+rust-version = "1.80.0"
 
 [dependencies]
-l021 = { package = "leptos", version = "0.2.1" }
-leptos = { path = "../leptos", features = ["ssr"] }
-sycamore = { version = "0.8", features = ["ssr"] }
-yew = { git = "https://github.com/yewstack/yew", features = ["ssr"] }
-tokio-test = "0.4"
-miniserde = "0.1"
-gloo = "0.8"
-uuid = { version = "1", features = ["serde", "v4", "wasm-bindgen"] }
-wasm-bindgen = "0.2"
-lazy_static = "1"
-log = "0.4"
-strum = "0.24"
-strum_macros = "0.24"
-serde = { version = "1", features = ["derive", "rc"] }
-serde_json = "1"
-tera = "1"
-reactive-signals = "0.1.0-alpha.4"
+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.0", features = ["ssr"] }
+yew = { version = "0.20.0", features = ["ssr"] }
+tokio-test = "0.4.0"
+miniserde = "0.1.0"
+gloo = "0.8.0"
+uuid = { version = "1.0", features = ["serde", "v4", "wasm-bindgen"] }
+wasm-bindgen = "0.2.0"
+lazy_static = "1.0"
+log = "0.4.0"
+strum = "0.24.0"
+strum_macros = "0.24.0"
+serde = { version = "1.0", features = ["derive", "rc"] }
+serde_json = "1.0"
+tera = "1.0"
 
 [dependencies.web-sys]
-version = "0.3"
+version = "0.3.0"
 features = ["Window", "Document", "HtmlElement", "HtmlInputElement"]

benchmarks/src/lib.rs

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

benchmarks/src/reactive.rs

@@ -7,19 +7,16 @@ fn leptos_deep_creation(b: &mut Bencher) {
     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 {
-                let prev = memos.last().copied();
-                if let Some(prev) = prev {
-                    memos.push(create_memo(cx, move |_| prev.get() + 1));
-                } else {
-                    memos.push(create_memo(cx, move |_| signal.get() + 1));
-                }
+        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));
             }
-        })
-        .dispose()
+        }
     });
 
     runtime.dispose();
@@ -31,20 +28,17 @@ fn leptos_deep_update(b: &mut Bencher) {
     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));
-                }
+        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);
-        })
-        .dispose()
+        }
+        signal.set(1);
+        assert_eq!(memos[999].get(), 1001);
     });
 
     runtime.dispose();
@@ -56,17 +50,12 @@ fn leptos_narrowing_down(b: &mut Bencher) {
     let runtime = create_runtime();
 
     b.iter(|| {
-        create_scope(runtime, |cx| {
-            let sigs =
-                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
-            let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
-            let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
-            let memo = create_memo(cx, move |_| {
-                reads.iter().map(|r| r.get()).sum::<i32>()
-            });
-            assert_eq!(memo(), 499500);
-        })
-        .dispose()
+        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();
@@ -78,16 +67,13 @@ fn leptos_fanning_out(b: &mut Bencher) {
     let runtime = create_runtime();
 
     b.iter(|| {
-        create_scope(runtime, |cx| {
-            let sig = create_rw_signal(cx, 0);
-            let memos = (0..1000)
-                .map(|_| create_memo(cx, move |_| sig.get()))
-                .collect::<Vec<_>>();
-            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
-            sig.set(1);
-            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
-        })
-        .dispose()
+        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();
@@ -98,143 +84,36 @@ fn leptos_narrowing_update(b: &mut Bencher) {
     use leptos::*;
     let runtime = create_runtime();
 
-    b.iter(|| {
-        create_scope(runtime, |cx| {
-            let acc = Rc::new(Cell::new(0));
-            let sigs =
-                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
-            let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
-            let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
-            let memo = create_memo(cx, move |_| {
-                reads.iter().map(|r| r.get()).sum::<i32>()
-            });
-            assert_eq!(memo(), 499500);
-            create_isomorphic_effect(cx, {
-                let acc = Rc::clone(&acc);
-                move |_| {
-                    acc.set(memo());
-                }
-            });
-            assert_eq!(acc.get(), 499500);
-
-            writes[1].update(|n| *n += 1);
-            writes[10].update(|n| *n += 1);
-            writes[100].update(|n| *n += 1);
-
-            assert_eq!(acc.get(), 499503);
-            assert_eq!(memo(), 499503);
-        })
-        .dispose()
-    });
-
-    runtime.dispose();
-}
-
-#[bench]
-fn leptos_scope_creation_and_disposal(b: &mut Bencher) {
-    use leptos::*;
-    let runtime = create_runtime();
-
     b.iter(|| {
         let acc = Rc::new(Cell::new(0));
-        let disposers = (0..1000)
-            .map(|_| {
-                create_scope(runtime, {
-                    let acc = Rc::clone(&acc);
-                    move |cx| {
-                        let (r, w) = create_signal(cx, 0);
-                        create_isomorphic_effect(cx, {
-                            move |_| {
-                                acc.set(r());
-                            }
-                        });
-                        w.update(|n| *n += 1);
-                    }
-                })
-            })
-            .collect::<Vec<_>>();
-        for disposer in disposers {
-            disposer.dispose();
-        }
-    });
-
-    runtime.dispose();
-}
-
-#[bench]
-fn rs_deep_update(b: &mut Bencher) {
-    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
-
-    let sc = ClientRuntime::new_root_scope();
-    b.iter(|| {
-        let signal = signal!(sc, 0);
-        let mut memos = Vec::<Signal<Func<i32>, ClientRuntime>>::new();
-        for i in 0..1000usize {
-            let prev = memos.get(i.saturating_sub(1)).copied();
-            if let Some(prev) = prev {
-                memos.push(signal!(sc, move || prev.get() + 1))
-            } else {
-                memos.push(signal!(sc, move || signal.get() + 1))
-            }
-        }
-        signal.set(1);
-        assert_eq!(memos[999].get(), 1001);
-    });
-}
-
-#[bench]
-fn rs_fanning_out(b: &mut Bencher) {
-    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
-    let cx = ClientRuntime::new_root_scope();
-
-    b.iter(|| {
-        let sig = signal!(cx, 0);
-        let memos = (0..1000)
-            .map(|_| signal!(cx, move || sig.get()))
-            .collect::<Vec<_>>();
-        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
-        sig.set(1);
-        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
-    });
-}
-
-#[bench]
-fn rs_narrowing_update(b: &mut Bencher) {
-    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
-    let cx = ClientRuntime::new_root_scope();
-
-    b.iter(|| {
-        let acc = Rc::new(Cell::new(0));
-        let sigs =
-            (0..1000).map(|n| signal!(cx, n)).collect::<Vec<_>>();
-        let memo = signal!(cx, {
-            let sigs = sigs.clone();
-            move || {
-                sigs.iter().map(|r| r.get()).sum::<i32>()
-            }
-        });
-        assert_eq!(memo.get(), 499500);
-        signal!(cx, {
+        let 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.get());
+            move |_| {
+                acc.set(memo());
             }
         });
-
         assert_eq!(acc.get(), 499500);
 
-        sigs[1].update(|n| *n += 1);
-        sigs[10].update(|n| *n += 1);
-        sigs[100].update(|n| *n += 1);
+        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.get(), 499503);
+        assert_eq!(memo(), 499503);
     });
+
+    runtime.dispose();
 }
 
 #[bench]
-fn l021_deep_creation(b: &mut Bencher) {
-    use l021::*;
+fn l0410_deep_creation(b: &mut Bencher) {
+    use l0410::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -256,8 +135,8 @@ fn l021_deep_creation(b: &mut Bencher) {
 }
 
 #[bench]
-fn l021_deep_update(b: &mut Bencher) {
-    use l021::*;
+fn l0410_deep_update(b: &mut Bencher) {
+    use l0410::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -281,8 +160,8 @@ fn l021_deep_update(b: &mut Bencher) {
 }
 
 #[bench]
-fn l021_narrowing_down(b: &mut Bencher) {
-    use l021::*;
+fn l0410_narrowing_down(b: &mut Bencher) {
+    use l0410::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -304,8 +183,8 @@ fn l021_narrowing_down(b: &mut Bencher) {
 }
 
 #[bench]
-fn l021_fanning_out(b: &mut Bencher) {
-    use leptos::*;
+fn l0410_fanning_out(b: &mut Bencher) {
+    use l0410::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -324,8 +203,8 @@ fn l021_fanning_out(b: &mut Bencher) {
     runtime.dispose();
 }
 #[bench]
-fn l021_narrowing_update(b: &mut Bencher) {
-    use l021::*;
+fn l0410_narrowing_update(b: &mut Bencher) {
+    use l0410::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -338,11 +217,11 @@ fn l021_narrowing_update(b: &mut Bencher) {
             let memo = create_memo(cx, move |_| {
                 reads.iter().map(|r| r.get()).sum::<i32>()
             });
-            assert_eq!(memo(), 499500);
+            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);
@@ -352,7 +231,7 @@ fn l021_narrowing_update(b: &mut Bencher) {
             writes[100].update(|n| *n += 1);
 
             assert_eq!(acc.get(), 499503);
-            assert_eq!(memo(), 499503);
+            assert_eq!(memo.get(), 499503);
         })
         .dispose()
     });
@@ -361,8 +240,8 @@ fn l021_narrowing_update(b: &mut Bencher) {
 }
 
 #[bench]
-fn l021_scope_creation_and_disposal(b: &mut Bencher) {
-    use l021::*;
+fn l0410_scope_creation_and_disposal(b: &mut Bencher) {
+    use l0410::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -375,7 +254,7 @@ fn l021_scope_creation_and_disposal(b: &mut Bencher) {
                         let (r, w) = create_signal(cx, 0);
                         create_isomorphic_effect(cx, {
                             move |_| {
-                                acc.set(r());
+                                acc.set(r.get());
                             }
                         });
                         w.update(|n| *n += 1);

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::*;
-		leptos_dom::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>
@@ -19,8 +18,7 @@ fn leptos_ssr_bench(b: &mut Bencher) {
 				}
 			}
 
-			let rendered = view! { 
-				cx,
+			let rendered = view! {
 				<main>
 					<h1>"Welcome to our benchmark page."</h1>
 					<p>"Here's some introductory text."</p>
@@ -28,14 +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&#x27;s some introductory text.</p><div id=\"_0-3-1\"><button id=\"_0-3-2\">-1</button><span id=\"_0-3-3\">Value: <!>1<!--hk=_0-3-4-->!</span><button id=\"_0-3-5\">+1</button></div><!--hk=_0-3-0--><div id=\"_0-3-5-1\"><button id=\"_0-3-5-2\">-1</button><span id=\"_0-3-5-3\">Value: <!>2<!--hk=_0-3-5-4-->!</span><button id=\"_0-3-5-5\">+1</button></div><!--hk=_0-3-5-0--><div id=\"_0-3-5-5-1\"><button id=\"_0-3-5-5-2\">-1</button><span id=\"_0-3-5-5-3\">Value: <!>3<!--hk=_0-3-5-5-4-->!</span><button id=\"_0-3-5-5-5\">+1</button></div><!--hk=_0-3-5-5-0--></main>"
-			);
-		});
+"<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]
@@ -55,13 +92,13 @@ fn tera_ssr_bench(b: &mut Bencher) {
 	{% endfor %}
 	</main>"#;
 
-    lazy_static::lazy_static! {
-        static ref TERA: Tera = {
-            let mut tera = Tera::default();
-            tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
-            tera
-        };
-    }
+
+    static  LazyCell<TERA>: Tera = LazyLock::new(|| {
+        let mut tera = Tera::default();
+        tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
+        tera
+    });
+
 
     #[derive(Serialize, Deserialize)]
     struct Counter {

benchmarks/src/todomvc/leptos.rs

@@ -1,7 +1,7 @@
 pub use leptos::*;
 use miniserde::*;
-use web_sys::HtmlInputElement;
 use wasm_bindgen::JsCast;
+use web_sys::HtmlInputElement;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Todos(pub Vec<Todo>);
@@ -9,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)
     }
@@ -72,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,
@@ -98,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()
@@ -107,10 +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);
+    let (mode, set_mode) = create_signal(Mode::All);
 
     let add_todo = move |ev: web_sys::KeyboardEvent| {
         let target = event_target::<HtmlInputElement>(&ev);
@@ -120,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("");
@@ -128,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
@@ -148,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()
@@ -163,7 +167,7 @@ pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
         }
     });
 
-    view! { cx,
+    view! { 
         <main>
             <section class="todoapp">
                 <header class="header">
@@ -188,8 +192,8 @@ pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
                         <For
                             each=filtered_todos
                             key=|todo| todo.id
-                            view=move |cx, todo: Todo| {
-                                view! { cx, <Todo todo=todo.clone()/> }
+                            children=move |todo: Todo| {
+                                view! { <Todo todo=todo.clone()/> }
                             }
                         />
                     </ul>
@@ -236,14 +240,14 @@ pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
                 <p>"Part of " <a href="http://todomvc.com">"TodoMVC"</a></p>
             </footer>
         </main>
-    }.into_view(cx)
+    }.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();
@@ -255,7 +259,7 @@ pub fn Todo(cx: Scope, todo: Todo) -> impl IntoView {
         set_editing(false);
     };
 
-    view! { cx,
+    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)()/>
@@ -268,7 +272,7 @@ pub fn Todo(cx: Scope, todo: Todo) -> impl IntoView {
             {move || {
                 editing()
                     .then(|| {
-                        view! { cx,
+                        view! { 
                             <input
                                 class="edit"
                                 class:hidden=move || !(editing)()
@@ -319,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,6 +2,7 @@ use test::Bencher;
 
 mod leptos;
 mod sycamore;
+mod tachys;
 mod tera;
 mod yew;
 
@@ -12,18 +13,34 @@ fn leptos_todomvc_ssr(b: &mut Bencher) {
     b.iter(|| {
         use crate::todomvc::leptos::*;
 
-        let html = ::leptos::ssr::render_to_string(|cx| {
-            view! { cx, <TodoMVC todos=Todos::new(cx)/> }
+        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| {
@@ -42,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 {
@@ -60,21 +76,33 @@ fn leptos_todomvc_ssr_with_1000(b: &mut Bencher) {
         use self::leptos::*;
         use ::leptos::*;
 
-        let html = ::leptos::ssr::render_to_string(|cx| {
+        let html = ::leptos::ssr::render_to_string(|| {
             view! {
-                cx,
-                <TodoMVC todos=Todos::new_with_1000(cx)/>
+                <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| {
@@ -93,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 {
@@ -103,4 +130,19 @@ fn yew_todomvc_ssr_with_1000(b: &mut Bencher) {
             assert!(rendered.len() > 1);
         });
     });
-}
+}
+
+#[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

@@ -55,7 +55,7 @@ static TEMPLATE: &str = r#"<main>
 						{% else %}
 						 <li><a href="/">All</a></li>
 						{% endif %}
-				
+
 						{% if mode_active %}
                         <li><a href="/active" class="selected">Active</a></li>
 						{% else %}
@@ -87,17 +87,17 @@ 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::*;
 
-    lazy_static::lazy_static! {
-        static ref TERA: Tera = {
+
+        static LazyLock<TERA>: Tera = LazyLock( || {
             let mut tera = Tera::default();
             tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
             tera
-        };
-    }
+        });
+
 
     #[derive(Serialize, Deserialize)]
     struct Todo {
@@ -127,17 +127,17 @@ 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::*;
 
-    lazy_static::lazy_static! {
-        static ref TERA: Tera = {
-            let mut tera = Tera::default();
-            tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
-            tera
-        };
-    }
+
+    static  TERA: LazyLock<Tera> = LazyLock::new(|| {
+        let mut tera = Tera::default();
+        tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
+        tera
+    });
+
 
     #[derive(Serialize, Deserialize)]
     struct Todo {
@@ -174,4 +174,4 @@ fn tera_todomvc_1000(b: &mut Bencher) {
 
         let _ = TERA.render("template.html", &ctx).unwrap();
     });
-}
+}

cargo-make/check.toml

@@ -3,5 +3,5 @@ alias = "check-all"
 
 [tasks.check-all]
 command = "cargo"
-args = ["+nightly", "check-all-features"]
+args = ["check-all-features"]
 install_crate = "cargo-all-features"

cargo-make/lint.toml

@@ -1,9 +1,18 @@
-[tasks.pre-clippy]
-env = { CARGO_MAKE_CLIPPY_ARGS = "--all-targets --all-features -- -D warnings" }
-
-[tasks.check-style]
-dependencies = ["check-format-flow", "clippy-flow"]
+[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 = [
+    "clippy",
+    "--all-features",
+    "--no-deps",
+    "--",
+    "-D",
+    "clippy::print_stdout",
+]

cargo-make/main.toml

@@ -13,6 +13,3 @@ RUSTFLAGS = "-D warnings"
 
 [tasks.ci]
 dependencies = ["lint", "test"]
-
-[tasks.lint]
-dependencies = ["check-format-flow"]

cargo-make/test.toml

@@ -3,5 +3,5 @@ alias = "test-all"
 
 [tasks.test-all]
 command = "cargo"
-args = ["+nightly", "test-all-features"]
+args = ["test-all-features"]
 install_crate = "cargo-all-features"

const_str_slice_concat/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "const_str_slice_concat"
+version = "0.1.0"
+authors = ["Greg Johnston"]
+license = "MIT"
+readme = "../README.md"
+repository = "https://github.com/leptos-rs/leptos"
+description = "Utilities for const concatenation of string slices."
+rust-version.workspace = true
+edition.workspace = true
+
+[dependencies]

const_str_slice_concat/Makefile.toml

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

const_str_slice_concat/src/lib.rs

@@ -0,0 +1,139 @@
+#![no_std]
+#![forbid(unsafe_code)]
+#![deny(missing_docs)]
+
+//! Utilities for const concatenation of string slices.
+
+pub(crate) const MAX_TEMPLATE_SIZE: usize = 4096;
+
+/// Converts a zero-terminated buffer of bytes into a UTF-8 string.
+pub const fn str_from_buffer(buf: &[u8; MAX_TEMPLATE_SIZE]) -> &str {
+    match core::ffi::CStr::from_bytes_until_nul(buf) {
+        Ok(cstr) => match cstr.to_str() {
+            Ok(str) => str,
+            Err(_) => panic!("TEMPLATE FAILURE"),
+        },
+        Err(_) => panic!("TEMPLATE FAILURE"),
+    }
+}
+
+/// Concatenates any number of static strings into a single array.
+// credit to Rainer Stropek, "Constant fun," Rust Linz, June 2022
+pub const fn const_concat(
+    strs: &'static [&'static str],
+) -> [u8; MAX_TEMPLATE_SIZE] {
+    let mut buffer = [0; MAX_TEMPLATE_SIZE];
+    let mut position = 0;
+    let mut remaining = strs;
+
+    while let [current, tail @ ..] = remaining {
+        let x = current.as_bytes();
+        let mut i = 0;
+
+        // have it iterate over bytes manually, because, again,
+        // no mutable refernces in const fns
+        while i < x.len() {
+            buffer[position] = x[i];
+            position += 1;
+            i += 1;
+        }
+
+        remaining = tail;
+    }
+
+    buffer
+}
+
+/// Converts a zero-terminated buffer of bytes into a UTF-8 string with the given prefix.
+pub const fn const_concat_with_prefix(
+    strs: &'static [&'static str],
+    prefix: &'static str,
+    suffix: &'static str,
+) -> [u8; MAX_TEMPLATE_SIZE] {
+    let mut buffer = [0; MAX_TEMPLATE_SIZE];
+    let mut position = 0;
+    let mut remaining = strs;
+
+    while let [current, tail @ ..] = remaining {
+        let x = current.as_bytes();
+        let mut i = 0;
+
+        // have it iterate over bytes manually, because, again,
+        // no mutable refernces in const fns
+        while i < x.len() {
+            buffer[position] = x[i];
+            position += 1;
+            i += 1;
+        }
+
+        remaining = tail;
+    }
+
+    if buffer[0] == 0 {
+        buffer
+    } else {
+        let mut new_buf = [0; MAX_TEMPLATE_SIZE];
+        let prefix = prefix.as_bytes();
+        let suffix = suffix.as_bytes();
+        let mut position = 0;
+        let mut i = 0;
+        while i < prefix.len() {
+            new_buf[position] = prefix[i];
+            position += 1;
+            i += 1;
+        }
+        i = 0;
+        while i < buffer.len() {
+            if buffer[i] == 0 {
+                break;
+            }
+            new_buf[position] = buffer[i];
+            position += 1;
+            i += 1;
+        }
+        i = 0;
+        while i < suffix.len() {
+            new_buf[position] = suffix[i];
+            position += 1;
+            i += 1;
+        }
+
+        new_buf
+    }
+}
+
+/// Converts any number of strings into a UTF-8 string, separated by the given string.
+pub const fn const_concat_with_separator(
+    strs: &[&str],
+    separator: &'static str,
+) -> [u8; MAX_TEMPLATE_SIZE] {
+    let mut buffer = [0; MAX_TEMPLATE_SIZE];
+    let mut position = 0;
+    let mut remaining = strs;
+
+    while let [current, tail @ ..] = remaining {
+        let x = current.as_bytes();
+        let mut i = 0;
+
+        // have it iterate over bytes manually, because, again,
+        // no mutable refernces in const fns
+        while i < x.len() {
+            buffer[position] = x[i];
+            position += 1;
+            i += 1;
+        }
+        if !x.is_empty() {
+            let mut position = 0;
+            let separator = separator.as_bytes();
+            while i < separator.len() {
+                buffer[position] = separator[i];
+                position += 1;
+                i += 1;
+            }
+        }
+
+        remaining = tail;
+    }
+
+    buffer
+}

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,7 +24,7 @@ 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;
 ```
 
@@ -34,19 +34,19 @@ Sometimes you have nested signals: for example, hash-map that can change over ti
 
 ```rust
 #[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    let resources = create_rw_signal(cx, HashMap::new());
+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(cx, 0))
+                .or_insert_with(|| create_rw_signal(0))
                 .update(|amount| *amount += 1)
         })
     };
 
-    view! { cx,
+    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>
@@ -55,17 +55,17 @@ pub fn App(cx: Scope) -> impl IntoView {
 }
 ```
 
-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.
+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 [`Scope::batch()`](https://docs.rs/leptos/latest/leptos/struct.Scope.html#method.batch) method:
+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| {
-        cx.batch(move || {
+        batch(move || {
             resources.update(|resources| {
                 resources
                     .entry(id)
-                    .or_insert_with(|| create_rw_signal(cx, 0))
+                    .or_insert_with(|| create_rw_signal(0))
                     .update(|amount| *amount += 1)
             })
         });
@@ -83,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
@@ -97,11 +97,11 @@ 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 />

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

@@ -1,2 +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,84 +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 project
-
-```bash
-cargo init leptos-tutorial
-```
-
-`cd` into your new `leptos-tutorial` project and add `leptos` as a dependency
-
-```bash
-cargo add leptos --features=csr,nightly
-```
-
-Or you can leave off `nighly` if you're using stable Rust
-```bash
-cargo add leptos --features=csr
-```
-
-> Using `nightly` Rust, and the `nightly` feature in Leptos enables the function-call syntax for signal getters and setters that is used in most of this book.
->
-> To use `nightly` Rust, you can run
->
-> ```bash
-> rustup toolchain install nightly
-> rustup default nightly
-> ```
->
-> If you’d rather use stable Rust with Leptos, you can do that too. In the guide and examples, you’ll just use the [`ReadSignal::get()`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html#impl-SignalGet%3CT%3E-for-ReadSignal%3CT%3E) and [`WriteSignal::set()`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html#impl-SignalGet%3CT%3E-for-ReadSignal%3CT%3E) methods instead of calling signal getters and setters as functions.
-
-Make sure you've added the `wasm32-unknown-unknown` target so that Rust can compile your code to WebAssembly to run in the browser.
-
-```bash
-rustup target add wasm32-unknown-unknown
-```
-
-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> })
-}
-```
-
-Your directory structure should now look something like this
-
-```
-leptos_tutorial
-├── src
-│   └── main.rs
-├── Cargo.toml
-├── index.html
-```
-
-Now run `trunk serve --open` from the root of the `leptos-tutorial` directory.
-Trunk should automatically compile your app and open it in your default browser.
-If you make edits to `main.rs`, Trunk will recompile your source code and
-live-reload the page.

docs/book/src/15_global_state.md

@@ -1,185 +1,2 @@
-# Global State Management
-
-So far, we've only been working with local state in components, and we’ve seen how to coordinate state between parent and child components. On occasion, there are times where people look for a more general solution for global state management that can work throughout an application.
-
-In general, **you do not need this chapter.** The typical pattern is to compose your application out of components, each of which manages its own local state, not to store all state in a global structure. However, there are some cases (like theming, saving user settings, or sharing data between components in different parts of your UI) in which you may want to use some kind of global state management.
-
-The three best approaches to global state are
-
-1. Using the router to drive global state via the URL
-2. Passing signals through context
-3. Creating a global state struct and creating lenses into it with `create_slice`
-
-## Option #1: URL as Global State
-
-In many ways, the URL is actually the best way to store global state. It can be accessed from any component, anywhere in your tree. There are native HTML elements like `<form>` and `<a>` that exist solely to update the URL. And it persists across page reloads and between devices; you can share a URL with a friend or send it from your phone to your laptop and any state stored in it will be replicated.
-
-The next few sections of the tutorial will be about the router, and we’ll get much more into these topics.
-
-But for now, we'll just look at options #2 and #3.
-
-## Option #2: Passing Signals through Context
-
-In the section on [parent-child communication](view/08_parent_child.md), we saw that you can use `provide_context` to pass signal from a parent component to a child, and `use_context` to read it in the child. But `provide_context` works across any distance. If you want to create a global signal that holds some piece of state, you can provide it and access it via context anywhere in the descendants of the component where you provide it.
-
-A signal provided via context only causes reactive updates where it is read, not in any of the components in between, so it maintains the power of fine-grained reactive updates, even at a distance.
-
-We start by creating a signal in the root of the app and providing it to
-all its children and descendants using `provide_context`.
-
-```rust
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    // here we create a signal in the root that can be consumed
-    // anywhere in the app.
-    let (count, set_count) = create_signal(cx, 0);
-    // we'll pass the setter to specific components,
-    // but provide the count itself to the whole app via context
-    provide_context(cx, count);
-
-    view! { cx,
-        // SetterButton is allowed to modify the count
-        <SetterButton set_count/>
-        // These consumers can only read from it
-        // But we could give them write access by passing `set_count` if we wanted
-        <FancyMath/>
-        <ListItems/>
-    }
-}
-```
-
-`<SetterButton/>` is the kind of counter we’ve written several times now.
-(See the sandbox below if you don’t understand what I mean.)
-
-`<FancyMath/>` and `<ListItems/>` both consume the signal we’re providing via
-`use_context` and do something with it.
-
-```rust
-/// A component that does some "fancy" math with the global count
-#[component]
-fn FancyMath(cx: Scope) -> impl IntoView {
-    // here we consume the global count signal with `use_context`
-    let count = use_context::<ReadSignal<u32>>(cx)
-        // we know we just provided this in the parent component
-        .expect("there to be a `count` signal provided");
-    let is_even = move || count() & 1 == 0;
-
-    view! { cx,
-        <div class="consumer blue">
-            "The number "
-            <strong>{count}</strong>
-            {move || if is_even() {
-                " is"
-            } else {
-                " is not"
-            }}
-            " even."
-        </div>
-    }
-}
-```
-
-Note that this same pattern can be applied to more complex state. If you have multiple fields you want to update independently, you can do that by providing some struct of signals:
-
-```rust
-#[derive(Copy, Clone, Debug)]
-struct GlobalState {
-    count: RwSignal<i32>,
-    name: RwSignal<String>
-}
-
-impl GlobalState {
-    pub fn new(cx: Scope) -> Self {
-        Self {
-            count: create_rw_signal(cx, 0),
-            name: create_rw_signal(cx, "Bob".to_string())
-        }
-    }
-}
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    provide_context(cx, GlobalState::new(cx));
-
-    // etc.
-}
-```
-
-## Option #3: Create a Global State Struct and Slices
-
-You may find it cumbersome to wrap each field of a structure in a separate signal like this. In some cases, it can be useful to create a plain struct with non-reactive fields, and then wrap that in a signal.
-
-```rust
-#[derive(Copy, Clone, Debug, Default)]
-struct GlobalState {
-    count: i32,
-    name: String
-}
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    provide_context(cx, create_rw_signal(GlobalState::default()));
-
-    // etc.
-}
-```
-
-But there’s a problem: because our whole state is wrapped in one signal, updating the value of one field will cause reactive updates in parts of the UI that only depend on the other.
-
-```rust
-let state = expect_context::<RwSignal<GlobalState>>(cx);
-view! { cx,
-    <button on:click=move |_| state.update(|n| *n += 1)>"+1"</button>
-    <p>{move || state.with(|state| state.name.clone())}</p>
-}
-```
-
-In this example, clicking the button will cause the text inside `<p>` to be updated, cloning `state.name` again! Because signals are the atomic unit of reactivity, updating any field of the signal triggers updates to everything that depends on the signal.
-
-There’s a better way. You can use take fine-grained, reactive slices by using [`create_memo`](https://docs.rs/leptos/latest/leptos/fn.create_memo.html) or [`create_slice`](https://docs.rs/leptos/latest/leptos/fn.create_slice.html) (which uses `create_memo` but also provides a setter). “Memoizing” a value means creating a new reactive value which will only update when it changes. “Memoizing a slice” means creating a new reactive value which will only update when some field of the state struct updates.
-
-Here, instead of reading from the state signal directly, we create “slices” of that state with fine-grained updates via `create_slice`. Each slice signal only updates when the particular piece of the larger struct it accesses updates. This means you can create a single root signal, and then take independent, fine-grained slices of it in different components, each of which can update without notifying the others of changes.
-
-```rust
-/// A component that updates the count in the global state.
-#[component]
-fn GlobalStateCounter(cx: Scope) -> impl IntoView {
-    let state = expect_context::<RwSignal<GlobalState>>(cx);
-
-    // `create_slice` lets us create a "lens" into the data
-    let (count, set_count) = create_slice(
-        cx,
-        // we take a slice *from* `state`
-        state,
-        // our getter returns a "slice" of the data
-        |state| state.count,
-        // our setter describes how to mutate that slice, given a new value
-        |state, n| state.count = n,
-    );
-
-    view! { cx,
-        <div class="consumer blue">
-            <button
-                on:click=move |_| {
-                    set_count(count() + 1);
-                }
-            >
-                "Increment Global Count"
-            </button>
-            <br/>
-            <span>"Count is: " {count}</span>
-        </div>
-    }
-}
-```
-
-Clicking this button only updates `state.count`, so if we create another slice
-somewhere else that only takes `state.name`, clicking the button won’t cause
-that other slice to update. This allows you to combine the benefits of a top-down
-data flow and of fine-grained reactive updates.
-
-> **Note**: There are some significant drawbacks to this approach. Both signals and memos need to own their values, so a memo will need to clone the field’s value on every change. The most natural way to manage state in a framework like Leptos is always to provide signals that are as locally-scoped and fine-grained as they can be, not to hoist everything up into global state. But when you _do_ need some kind of global state, `create_slice` can be a useful tool.
-
-[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/1-basic-component-forked-8bte19?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs)
-
-<iframe src="https://codesandbox.io/p/sandbox/1-basic-component-forked-8bte19?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>
+<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,17 +1,21 @@
 # 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)
+  - [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)
@@ -32,7 +36,8 @@
   - [`<Form/>`](./router/20_form.md)
 - [Interlude: Styling](./interlude_styling.md)
 - [Metadata](./metadata.md)
-- [Server Side Rendering](./ssr/README.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)
@@ -43,5 +48,9 @@
   - [Responses and Redirects](./server/27_response.md)
 - [Progressive Enhancement and Graceful Degradation](./progressive_enhancement/README.md)
   - [`<ActionForm/>`s](./progressive_enhancement/action_form.md)
-- [Deployment]()
-- [Appendix: Optimizing WASM Binary Size](./appendix_binary_size.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_binary_size.md

@@ -1,72 +0,0 @@
-# Appendix: Optimizing WASM Binary Size
-
-One of the primary downsides of deploying a Rust/WebAssembly frontend app is that splitting a WASM file into smaller chunks to be dynamically loaded is significantly more difficult than splitting a JavaScript bundle. There have been experiments like [`wasm-split`](https://emscripten.org/docs/optimizing/Module-Splitting.html) in the Emscripten ecosystem but at present there’s no way to split and dynamically load a Rust/`wasm-bindgen` binary. This means that the whole WASM binary needs to be loaded before your app becomes interactive. Because the WASM format is designed for streaming compilation, WASM files are much faster to compile per kilobyte than JavaScript files. (For a deeper look, you can [read this great article from the Mozilla team](https://hacks.mozilla.org/2018/01/making-webassembly-even-faster-firefoxs-new-streaming-and-tiering-compiler/) on streaming WASM compilation.)
-
-Still, it’s important to ship the smallest WASM binary to users that you can, as it will reduce their network usage and make your app interactive as quickly as possible.
-
-So what are some practical steps?
-
-## Things to Do
-
-1. Make sure you’re looking at a release build. (Debug builds are much, much larger.)
-2. Add a release profile for WASM that optimizes for size, not speed.
-
-For a `cargo-leptos` project, for example, you can add this to your `Cargo.toml`:
-
-```toml
-[profile.wasm-release]
-inherits = "release"
-opt-level = 'z'
-lto = true
-codegen-units = 1
-
-# ....
-
-[package.metadata.leptos]
-# ....
-lib-profile-release = "wasm-release"
-```
-
-This will hyper-optimize the WASM for your release build for size, while keeping your server build optimized for speed. (For a pure client-rendered app without server considerations, just use the `[profile.wasm-release]` block as your `[profile.release]`.)
-
-3. Always serve compressed WASM in production. WASM tends to compress very well, typically shrinking to less than 50% its uncompressed size, and it’s trivial to enable compression for static files being served from Actix or Axum.
-
-4. If you’re using nightly Rust, you can rebuild the standard library with this same profile rather than the prebuilt standard library that’s distributed with the `wasm32-unknown-unknown` target.
-
-To do this, create a file in your project at `.cargo/config.toml`
-
-```toml
-[unstable]
-build-std = ["std", "panic_abort", "core", "alloc"]
-build-std-features = ["panic_immediate_abort"]
-```
-
-Note that if you're using this with SSR too, the same Cargo profile will be applied. You'll need to explicitly specify your target:
-```toml
-[build]
-target = "x86_64-unknown-linux-gnu" # or whatever
-```
-
-Also note that in some cases, the cfg feature `has_std` will not be set, which may cause build errors with some dependencies which check for `has_std`. You may fix any build errors due to this by adding:
-```toml
-[build]
-rustflags = ["--cfg=has_std"]
-```
-
-And you'll need to add `panic = "abort"` to `[profile.release]` in `Cargo.toml`. Note that this applies the same `build-std` and panic settings to your server binary, which may not be desirable. Some further exploration is probably needed here.
-
-5. One of the sources of binary size in WASM binaries can be `serde` serialization/deserialization code. Leptos uses `serde` by default to serialize and deserialize resources created with `create_resource`. You might try experimenting with the `miniserde` and `serde-lite` features, which allow you to use those crates for serialization and deserialization instead; each only implements a subset of `serde`’s functionality, but typically optimizes for size over speed.
-
-## Things to Avoid
-
-There are certain crates that tend to inflate binary sizes. For example, the `regex` crate with its default features adds about 500kb to a WASM binary (largely because it has to pull in Unicode table data!) In a size-conscious setting, you might consider avoiding regexes in general, or even dropping down and calling browser APIs to use the built-in regex engine instead. (This is what `leptos_router` does on the few occasions it needs a regular expression.)
-
-In general, Rust’s commitment to runtime performance is sometimes at odds with a commitment to a small binary. For example, Rust monomorphizes generic functions, meaning it creates a distinct copy of the function for each generic type it’s called with. This is significantly faster than dynamic dispatch, but increases binary size. Leptos tries to balance runtime performance with binary size considerations pretty carefully; but you might find that writing code that uses many generics tends to increase binary size. For example, if you have a generic component with a lot of code in its body and call it with four different types, remember that the compiler could include four copies of that same code. Refactoring to use a concrete inner function or helper can often maintain performance and ergonomics while reducing binary size.
-
-## A Final Thought
-
-Remember that in a server-rendered app, JS bundle size/WASM binary size affects only _one_ thing: time to interactivity on the first load. This is very important to a good user experience—nobody wants to click a button three times and have it do nothing because the interactive code is still loading—but it is not the only important measure.
-
-It’s especially worth remembering that streaming in a single WASM binary means all subsequent navigations are nearly instantaneous, depending only on any additional data loading. Precisely because your WASM binary is _not_ bundle split, navigating to a new route does not require loading additional JS/WASM, as it does in nearly every JavaScript framework. Is this copium? Maybe. Or maybe it’s just an honest trade-off between the two approaches!
-
-Always take the opportunity to optimize the low-hanging fruit in your application. And always test your app under real circumstances with real user network speeds and devices before making any heroic efforts.

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

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

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

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

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

@@ -1,9 +1,2 @@
-# Working with `async`
-
-So far we’ve only been working with synchronous users interfaces: You provide some input,
-the app immediately processes it and updates the interface. This is great, but is a tiny
-subset of what web applications do. In particular, most web apps have to deal with some kind of asynchronous data loading, usually loading something from an API.
-
-Asynchronous data is notoriously hard to integrate with the synchronous parts of your code. Leptos provides a cross-platform [`spawn_local`](https://docs.rs/leptos/latest/leptos/fn.spawn_local.html) function that makes it easy to run a `Future`, but there’s much more to it than that.
-
-In this chapter, we’ll see how Leptos helps smooth out that process for you.
+<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_projecting_children.md

@@ -1,177 +1,2 @@
-# Projecting Children
-
-As you build components you may occasionally find yourself wanting to “project” children through multiple layers of components.
-
-## The Problem
-
-Consider the following:
-
-```rust
-pub fn LoggedIn<F, IV>(cx: Scope, fallback: F, children: ChildrenFn) -> impl IntoView
-where
-    F: Fn(Scope) -> IV + 'static,
-    IV: IntoView,
-{
-    view! { cx,
-        <Suspense
-            fallback=|| ()
-        >
-            <Show
-				// check whether user is verified
-				// by reading from the resource
-                when=move || todo!()
-                fallback=fallback
-            >
-				{children(cx)}
-			</Show>
-        </Suspense>
-    }
-}
-```
-
-This is pretty straightforward: when the user is logged in, we want to show `children`. If the user is not logged in, we want to show `fallback`. And while we’re waiting to find out, we just render `()`, i.e., nothing.
-
-In other words, we want to pass the children of `<LoggedIn/>` _through_ the `<Suspense/>` component to become the children of the `<Show/>`. This is what I mean by “projection.”
-
-This won’t compile.
-
-```
-error[E0507]: cannot move out of `fallback`, a captured variable in an `Fn` closure
-error[E0507]: cannot move out of `children`, a captured variable in an `Fn` closure
-```
-
-The problem here is that both `<Suspense/>` and `<Show/>` need to be able to construct their `children` multiple times. The first time you construct `<Suspense/>`’s children, it would take ownership of `fallback` and `children` to move them into the invocation of `<Show/>`, but then they're not available for future `<Suspense/>` children construction.
-
-## The Details
-
-> Feel free to skip ahead to the solution.
-
-If you want to really understand the issue here, it may help to look at the expanded `view` macro. Here’s a cleaned-up version:
-
-```rust
-Suspense(
-    cx,
-    ::leptos::component_props_builder(&Suspense)
-        .fallback(|| ())
-        .children({
-            // fallback and children are moved into this closure
-            Box::new(move |cx| {
-                {
-                    // fallback and children captured here
-                    leptos::Fragment::lazy(|| {
-                        vec![
-                            (Show(
-                                cx,
-                                ::leptos::component_props_builder(&Show)
-                                    .when(|| true)
-									// but fallback is moved into Show here
-                                    .fallback(fallback)
-									// and children is moved into Show here
-                                    .children(children)
-                                    .build(),
-                            )
-                            .into_view(cx)),
-                        ]
-                    })
-                }
-            })
-        })
-        .build(),
-)
-```
-
-All components own their props; so the `<Show/>` in this case can’t be called because it only has captured references to `fallback` and `children`.
-
-## Solution
-
-However, both `<Suspense/>` and `<Show/>` take `ChildrenFn`, i.e., their `children` should implement the `Fn` type so they can be called multiple times with only an immutable reference. This means we don’t need to own `children` or `fallback`; we just need to be able to pass `'static` references to them.
-
-We can solve this problem by using the [`store_value`](https://docs.rs/leptos/latest/leptos/fn.store_value.html) primitive. This essentially stores a value in the reactive system, handing ownership off to the framework in exchange for a reference that is, like signals, `Copy` and `'static`, which we can access or modify through certain methods.
-
-In this case, it’s really simple:
-
-```rust
-pub fn LoggedIn<F, IV>(cx: Scope, fallback: F, children: ChildrenFn) -> impl IntoView
-where
-    F: Fn(Scope) -> IV + 'static,
-    IV: IntoView,
-{
-    let fallback = store_value(cx, fallback);
-    let children = store_value(cx, children);
-    view! { cx,
-        <Suspense
-            fallback=|| ()
-        >
-            <Show
-                when=|| todo!()
-                fallback=move |cx| fallback.with_value(|fallback| fallback(cx))
-            >
-                {children.with_value(|children| children(cx))}
-            </Show>
-        </Suspense>
-    }
-}
-```
-
-At the top level, we store both `fallback` and `children` in the reactive scope owned by `LoggedIn`. Now we can simply move those references down through the other layers into the `<Show/>` component and call them there.
-
-## A Final Note
-
-Note that this works because `<Show/>` and `<Suspense/>` only need an immutable reference to their children (which `.with_value` can give it), not ownership.
-
-In other cases, you may need to project owned props through a function that takes `ChildrenFn` and therefore needs to be called more than once. In this case, you may find the `clone:` helper in the`view` macro helpful.
-
-Consider this example
-
-```rust
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    let name = "Alice".to_string();
-    view! { cx,
-        <Outer>
-            <Inner>
-                <Inmost name=name.clone()/>
-            </Inner>
-        </Outer>
-    }
-}
-
-#[component]
-pub fn Outer(cx: Scope, children: ChildrenFn) -> impl IntoView {
-    children(cx)
-}
-
-#[component]
-pub fn Inner(cx: Scope, children: ChildrenFn) -> impl IntoView {
-    children(cx)
-}
-
-#[component]
-pub fn Inmost(cx: Scope, name: String) -> impl IntoView {
-    view! { cx,
-        <p>{name}</p>
-    }
-}
-```
-
-Even with `name=name.clone()`, this gives the error
-
-```
-cannot move out of `name`, a captured variable in an `Fn` closure
-```
-
-It’s captured through multiple levels of children that need to run more than once, and there’s no obvious way to clone it _into_ the children.
-
-In this case, the `clone:` syntax comes in handy. Calling `clone:name` will clone `name` _before_ moving it into `<Inner/>`’s children, which solves our ownership issue.
-
-```rust
-view! { cx,
-	<Outer>
-		<Inner clone:name>
-			<Inmost name=name.clone()/>
-		</Inner>
-	</Outer>
-}
-```
-
-These issues can be a little tricky to understand or debug, because of the opacity of the `view` macro. But in general, they can always be solved.
+<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

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

@@ -1,49 +1,2 @@
-# Metadata
-
-So far, everything we’ve rendered has been inside the `<body>` of the HTML document. And this makes sense. After all, everything you can see on a web page lives inside the `<body>`.
-
-However, there are plenty of occasions where you might want to update something inside the `<head>` of the document using the same reactive primitives and component patterns you use for your UI.
-
-That’s where the [`leptos_meta`](https://docs.rs/leptos_meta/latest/leptos_meta/) package comes in.
-
-## Metadata Components
-
-`leptos_meta` provides special components that let you inject data from inside components anywhere in your application into the `<head>`:
-
-[`<Title/>`](https://docs.rs/leptos_meta/latest/leptos_meta/fn.Title.html) allows you to set the document’s title from any component. It also takes a `formatter` function that can be used to apply the same format to the title set by other pages. So, for example, if you put `<Title formatter=|text| format!("{text} — My Awesome Site")/>` in your `<App/>` component, and then `<Title text="Page 1"/>` and `<Title text="Page 2"/>` on your routes, you’ll get `Page 1 — My Awesome Site` and `Page 2 — My Awesome Site`.
-
-[`<Link/>`](https://docs.rs/leptos_meta/latest/leptos_meta/fn.Link.html) takes the standard attributes of the `<link>` element.
-
-[`<Stylesheet/>`](https://docs.rs/leptos_meta/latest/leptos_meta/fn.Stylesheet.html) creates a `<link rel="stylesheet">` with the `href` you give.
-
-[`<Style/>`](https://docs.rs/leptos_meta/latest/leptos_meta/fn.Style.html) creates a `<style>` with the children you pass in (usually a string). You can use this to import some custom CSS from another file at compile time `<Style>{include_str!("my_route.css")}</Style>`.
-
-[`<Meta/>`](https://docs.rs/leptos_meta/latest/leptos_meta/fn.Meta.html) lets you set `<meta>` tags with descriptions and other metadata.
-
-## `<Script/>` and `<script>`
-
-`leptos_meta` also provides a [`<Script/>`](https://docs.rs/leptos_meta/latest/leptos_meta/fn.Script.html) component, and it’s worth pausing here for a second. All of the other components we’ve considered inject `<head>`-only elements in the `<head>`. But a `<script>` can also be included in the body.
-
-There’s a very simple way to determine whether you should use a capital-S `<Script/>` component or a lowercase-s `<script>` element: the `<Script/>` component will be rendered in the `<head>`, and the `<script>` element will be rendered wherever in the `<body>` of your user interface you put it in, alongside other normal HTML elements. These cause JavaScript to load and run at different times, so use whichever is appropriate to your needs.
-
-## `<Body/>` and `<Html/>`
-
-There are even a couple elements designed to make semantic HTML and styling easier. [`<Html/>`](https://docs.rs/leptos_meta/latest/leptos_meta/fn.Html.html) lets you set the `lang` and `dir` on your `<html>` tag from your application code. `<Html/>` and [`<Body/>`](https://docs.rs/leptos_meta/latest/leptos_meta/fn.Html.html) both have `class` props that let you set their respective `class` attributes, which is sometimes needed by CSS frameworks for styling.
-
-`<Body/>` and `<Html/>` both also have `attributes` props which can be used to set any number of additional attributes on them via the [`AdditionalAttributes`](https://docs.rs/leptos/latest/leptos/struct.AdditionalAttributes.html) type:
-
-```rust
-<Html
-	lang="he"
-	dir="rtl"
-	attributes=AdditionalAttributes::from(vec![("data-theme", "dark")])
-/>
-```
-
-## Metadata and Server Rendering
-
-Now, some of this is useful in any scenario, but some of it is especially important for search-engine optimization (SEO). Making sure you have things like appropriate `<title>` and `<meta>` tags is crucial. Modern search engine crawlers do handle client-side rendering, i.e., apps that are shipped as an empty `index.html` and rendered entirely in JS/WASM. But they prefer to receive pages in which your app has been rendered to actual HTML, with metadata in the `<head>`.
-
-This is exactly what `leptos_meta` is for. And in fact, during server rendering, this is exactly what it does: collect all the `<head>` content you’ve declared by using its components throughout your application, and then inject it into the actual `<head>`.
-
-But I’m getting ahead of myself. We haven’t actually talked about server-side rendering yet. As a matter of fact... Let’s do that next!
+<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

@@ -1,36 +1,2 @@
-# Progressive Enhancement (and Graceful Degradation)
-
-I’ve been driving around Boston for about fifteen years. If you don’t know Boston, let me tell you: Massachusetts has some of the most aggressive drivers(and pedestrians!) in the world. I’ve learned to practice what’s sometimes called “defensive driving”: assuming that someone’s about to swerve in front of you at an intersection when you have the right of way, preparing for a pedestrian to cross into the street at any moment, and driving accordingly.
-
-“Progressive enhancement” is the “defensive driving” of web design. Or really, that’s “graceful degradation,” although they’re two sides of the same coin, or the same process, from two different directions.
-
-**Progressive enhancement**, in this context, means beginning with a simple HTML site or application that works for any user who arrives at your page, and gradually enhancing it with layers of additional features: CSS for styling, JavaScript for interactivity, WebAssembly for Rust-powered interactivity; using particular Web APIs for a richer experience if they’re available and as needed.
-
-**Graceful degradation** means handling failure gracefully when parts of that stack of enhancement *aren’t* available. Here are some sources of failure your users might encounter in your app:
-- Their browser doesn’t support WebAssembly because it needs to be updated.
-- Their browser can’t support WebAssembly because browser updates are limited to newer OS versions, which can’t be installed on the device. (Looking at you, Apple.)
-- They have WASM turned off for security or privacy reasons.
-- They have JavaScript turned off for security or privacy reasons.
-- JavaScript isn’t supported on their device (for example, some accessibility devices only support HTML browsing)
-- The JavaScript (or WASM) never arrived at their device because they walked outside and lost WiFi.
-- They stepped onto a subway car after loading the initial page and subsequent navigations can’t load data.
-- ... and so on.
-
-How much of your app still works if one of these holds true? Two of them? Three? 
-
-If the answer is something like “95%... okay, then 90%... okay, then 75%,” that’s graceful degradation. If the answer is “my app shows a blank screen unless everything works correctly,” that’s... rapid unscheduled disassembly.
-
-**Graceful degradation is especially important for WASM apps,** because WASM is the newest and least-likely-to-be-supported of the four languages that run in the browser (HTML, CSS, JS, WASM).
-
-Luckily, we’ve got some tools to help.
-
-## Defensive Design
-
-There are a few practices that can help your apps degrade more gracefully:
-1. **Server-side rendering.** Without SSR, your app simply doesn’t work without both JS and WASM loading. In some cases this may be appropriate (think internal apps gated behind a login) but in others it’s simply broken.
-2. **Native HTML elements.** Use HTML elements that do the things that you want, without additional code: `<a>` for navigation (including to hashes within the page), `<details>` for an accordion, `<form>` to persist information in the URL, etc.
-3. **URL-driven state.** The more of your global state is stored in the URL (as a route param or part of the query string), the more of the page can be generated during server rendering and updated by an `<a>` or a `<form>`, which means that not only navigations but state changes can work without JS/WASM.
-4. **[`SsrMode::PartiallyBlocked` or `SsrMode::InOrder`](https://docs.rs/leptos_router/latest/leptos_router/enum.SsrMode.html).** Out-of-order streaming requires a small amount of inline JS, but can fail if 1) the connection is broken halfway through the response or 2) the client’s device doesn’t support JS. Async streaming will give a complete HTML page, but only after all resources load. In-order streaming begins showing pieces of the page sooner, in top-down order. “Partially-blocked” SSR builds on out-of-order streaming by replacing `<Suspense/>` fragments that read from blocking resources on the server. This adds marginally to the initial response time (because of the `O(n)` string replacement work), in exchange for a more complete initial HTML response. This can be a good choice for situations in which there’s a clear distinction between “more important” and “less important” content, e.g., blog post vs. comments, or product info vs. reviews. If you choose to block on all the content, you’ve essentially recreated async rendering.
-5. **Leaning on `<form>`s.** There’s been a bit of a `<form>` renaissance recently, and it’s no surprise. The ability of a `<form>` to manage complicated `POST` or `GET` requests in an easily-enhanced way makes it a powerful tool for graceful degradation. The example in [the `<Form/>` chapter](../router/20_form.md), for example, would work fine with no JS/WASM: because it uses a `<form method="GET">` to persist state in the URL, it works with pure HTML by making normal HTTP requests and then progressively enhances to use client-side navigations instead.
-
-There’s one final feature of the framework that we haven’t seen yet, and which builds on this characteristic of forms to build powerful applications: the `<ActionForm/>`.
+<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

@@ -1,56 +1,2 @@
-# `<ActionForm/>`
-
-[`<ActionForm/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.ActionForm.html) is a specialized `<Form/>` that takes a server action, and automatically dispatches it on form submission. This allows you to call a server function directly from a `<form>`, even without JS/WASM.
-
-The process is simple:
-1. Define a server function using the [`#[server]` macro](https://docs.rs/leptos/latest/leptos/attr.server.html) (see [Server Functions](../server/25_server_functions.md).)
-2. Create an action using [`create_server_action`](https://docs.rs/leptos/latest/leptos/fn.create_server_action.html), specifying the type of the server function you’ve defined.
-3. Create an `<ActionForm/>`, providing the server action in the `action` prop.
-4. Pass the named arguments to the server function as form fields with the same names.
-
-> **Note:** `<ActionForm/>` only works with the default URL-encoded `POST` encoding for server functions, to ensure graceful degradation/correct behavior as an HTML form. 
-
-```rust
-#[server(AddTodo, "/api")]
-pub async fn add_todo(title: String) -> Result<(), ServerFnError> {
-    todo!()
-}
-
-#[component]
-fn AddTodo(cx: Scope) -> impl IntoView {
-	let add_todo = create_server_action::<AddTodo>(cx);
-	// holds the latest *returned* value from the server
-	let value = add_todo.value();
-	// check if the server has returned an error
-	let has_error = move || value.with(|val| matches!(val, Some(Err(_))));
-
-	view! { cx,
-		<ActionForm action=add_todo>
-			<label>
-				"Add a Todo"
-				// `title` matches the `title` argument to `add_todo`
-				<input type="text" name="title"/>
-			</label>
-			<input type="submit" value="Add"/>
-		</ActionForm>
-	}
-}
-```
-It’s really that easy. With JS/WASM, your form will submit without a page reload, storing its most recent submission in the `.input()` signal of the action, its pending status in `.pending()`, and so on. (See the [`Action`](https://docs.rs/leptos/latest/leptos/struct.Action.html) docs for a refresher, if you need.) Without JS/WASM, your form will submit with a page reload. If you call a `redirect` function (from `leptos_axum` or `leptos_actix`) it will redirect to the correct page. By default, it will redirect back to the page you’re currently on. The power of HTML, HTTP, and isomorphic rendering mean that your `<ActionForm/>` simply works, even with no JS/WASM.
-
-## Client-Side Validation
-
-Because the `<ActionForm/>` is just a `<form>`, it fires a `submit` event. You can use either HTML validation, or your own client-side validation logic in an `on:submit`. Just call `ev.prevent_default()` to prevent submission.
-
-The [`FromFormData`](https://docs.rs/leptos_router/latest/leptos_router/trait.FromFormData.html) trait can be helpful here, for attempting to parse your server function’s data type from the submitted form.
-
-```rust
-let on_submit = move |ev| {
-	let data = AddTodo::from_event(&ev);
-	// silly example of validation: if the todo is "nope!", nope it
-	if data.is_err() || data.unwrap().title == "nope!" {
-		// ev.prevent_default() will prevent form submission
-		ev.prevent_default();
-	}
-}
-```
+<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

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

@@ -1,5 +1,2 @@
-# Reactivity
-
-Leptos is built on top of a fine-grained reactive system, designed to run expensive side effects (like rendering something in a browser, or making a network request) as infrequently as possible in response to change, reactive values.
-
-So far we’ve seen signals in action. These chapters will go into a bit more depth, and look at effects, which are the other half of the story.
+<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

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

@@ -1,106 +1,2 @@
-# Working with Signals
-
-So far we’ve used some simple examples of [`create_signal`](https://docs.rs/leptos/latest/leptos/fn.create_signal.html), which returns a [`ReadSignal`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html) getter and a [`WriteSignal`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html) setter.
-
-## Getting and Setting
-
-There are four basic signal operations:
-
-1. [`.get()`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html#impl-SignalGet%3CT%3E-for-ReadSignal%3CT%3E) clones the current value of the signal and tracks any future changes to the value reactively.
-2. [`.with()`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html#impl-SignalWith%3CT%3E-for-ReadSignal%3CT%3E) takes a function, which receives the current value of the signal by reference (`&T`), and tracks any future changes.
-3. [`.set()`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html#impl-SignalSet%3CT%3E-for-WriteSignal%3CT%3E) replaces the current value of the signal and notifies any subscribers that they need to update.
-4. [`.update()`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html#impl-SignalUpdate%3CT%3E-for-WriteSignal%3CT%3E) takes a function, which receives a mutable reference to the current value of the signal (`&mut T`), and notifies any subscribers that they need to update. (`.update()` doesn’t return the value returned by the closure, but you can use [`.try_update()`](https://docs.rs/leptos/latest/leptos/trait.SignalUpdate.html#tymethod.try_update) if you need to; for example, if you’re removing an item from a `Vec<_>` and want the removed item.)
-
-Calling a `ReadSignal` as a function is syntax sugar for `.get()`. Calling a `WriteSignal` as a function is syntax sugar for `.set()`. So
-
-```rust
-let (count, set_count) = create_signal(cx, 0);
-set_count(1);
-log!(count());
-```
-
-is the same as
-
-```rust
-let (count, set_count) = create_signal(cx, 0);
-set_count.set(1);
-log!(count.get());
-```
-
-You might notice that `.get()` and `.set()` can be implemented in terms of `.with()` and `.update()`. In other words, `count.get()` is identical with `count.with(|n| n.clone())`, and `count.set(1)` is implemented by doing `count.update(|n| *n = 1)`.
-
-But of course, `.get()` and `.set()` (or the plain function-call forms!) are much nicer syntax.
-
-However, there are some very good use cases for `.with()` and `.update()`.
-
-For example, consider a signal that holds a `Vec<String>`.
-
-```rust
-let (names, set_names) = create_signal(cx, Vec::new());
-if names().is_empty() {
-	set_names(vec!["Alice".to_string()]);
-}
-```
-
-In terms of logic, this is simple enough, but it’s hiding some significant inefficiencies. Remember that `names().is_empty()` is sugar for `names.get().is_empty()`, which clones the value (it’s `names.with(|n| n.clone()).is_empty()`). This means we clone the whole `Vec<String>`, run `is_empty()`, and then immediately throw away the clone.
-
-Likewise, `set_names` replaces the value with a whole new `Vec<_>`. This is fine, but we might as well just mutate the original `Vec<_>` in place.
-
-```rust
-let (names, set_names) = create_signal(cx, Vec::new());
-if names.with(|names| names.is_empty()) {
-	set_names.update(|names| names.push("Alice".to_string()));
-}
-```
-
-Now our function simply takes `names` by reference to run `is_empty()`, avoiding that clone.
-
-And if you have Clippy on, or if you have sharp eyes, you may notice we can make this even neater:
-
-```rust
-if names.with(Vec::is_empty) {
-	// ...
-}
-```
-
-After all, `.with()` simply takes a function that takes the value by reference. Since `Vec::is_empty` takes `&self`, we can pass it in directly and avoid the unncessary closure.
-
-## Making signals depend on each other
-
-Often people ask about situations in which some signal needs to change based on some other signal’s value. There are three good ways to do this, and one that’s less than ideal but okay under controlled circumstances.
-
-### Good Options
-**1) B is a function of A.** Create a signal for A and a derived signal or memo for B.
-
-```rust
-let (count, set_count) = create_signal(cx, 1);
-let derived_signal_double_count = move || count() * 2;
-let memoized_double_count = create_memo(cx, move |_| count() * 2);
-```
-> For guidance on whether to use a derived signal or a memo, see the docs for [`create_memo`](https://docs.rs/leptos/latest/leptos/fn.create_memo.html)
-> 
-**2) C is a function of A and some other thing B.** Create signals for A and B and a derived signal or memo for C.
-
-```rust
-let (first_name, set_first_name) = create_signal(cx, "Bridget".to_string());
-let (last_name, set_last_name) = create_signal(cx, "Jones".to_string());
-let full_name = move || format!("{} {}", first_name(), last_name());
-```
-**3) A and B are independent signals, but sometimes updated at the same time.** When you make the call to update A, make a separate call to update B.
-```rust
-let (age, set_age) = create_signal(cx, 32);
-let (favorite_number, set_favorite_number) = create_signal(cx, 42);
-// use this to handle a click on a `Clear` button
-let clear_handler = move |_| {
-  set_age(0);
-  set_favorite_number(0);
-};
-```
-### If you really must...
-**4) Create an effect to write to B whenever A changes.** This is officially discouraged, for several reasons:
-a) It will always be less efficient, as it means every time A updates you do two full trips through the reactive process. (You set A, which causes the effect to run, as well as any other effects that depend on A. Then you set B, which causes any effects that depend on B to run.)
-b) It increases your chances of accidentally creating things like infinite loops or over-re-running effects. This is the kind of ping-ponging, reactive spaghetti code that was common in the early 2010s and that we try to avoid with things like read-write segregation and discouraging writing to signals from effects.
-
-In most situations, it’s best to rewrite things such that there’s a clear, top-down data flow based on derived signals or memos. But this isn’t the end of the world.
-
-> I’m intentionally not providing an example here. Read the [`create_effect`](https://docs.rs/leptos/latest/leptos/fn.create_effect.html) docs to figure out how this would work.
+<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

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

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

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

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

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

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

@@ -1,124 +1,2 @@
-# Server Functions
-
-If you’re creating anything beyond a toy app, you’ll need to run code on the server all the time: reading from or writing to a database that only runs on the server, running expensive computations using libraries you don’t want to ship down to the client, accessing APIs that need to be called from the server rather than the client for CORS reasons or because you need a secret API key that’s stored on the server and definitely shouldn’t be shipped down to a user’s browser.
-
-Traditionally, this is done by separating your server and client code, and by setting up something like a REST API or GraphQL API to allow your client to fetch and mutate data on the server. This is fine, but it requires you to write and maintain your code in multiple separate places (client-side code for fetching, server-side functions to run), as well as creating a third thing to manage, which is the API contract between the two.
-
-Leptos is one of a number of modern frameworks that introduce the concept of **server functions**. Server functions have two key characteristics:
-
-1. Server functions are **co-located** with your component code, so that you can organize your work by feature, not by technology. For example, you might have a “dark mode” feature that should persist a user’s dark/light mode preference across sessions, and be applied during server rendering so there’s no flicker. This requires a component that needs to be interactive on the client, and some work to be done on the server (setting a cookie, maybe even storing a user in a database.) Traditionally, this feature might end up being split between two different locations in your code, one in your “frontend” and one in your “backend.” With server functions, you’ll probably just write them both in one `dark_mode.rs` and forget about it.
-2. Server functions are **isomorphic**, i.e., they can be called either from the server or the browser. This is done by generating code differently for the two platforms. On the server, a server function simply runs. In the browser, the server function’s body is replaced with a stub that actually makes a fetch request to the server, serializing the arguments into the request and deserializing the return value from the response. But on either end, the function can simply be called: you can create an `add_todo` function that writes to your database, and simply call it from a click handler on a button in the browser!
-
-## Using Server Functions
-
-Actually, I kind of like that example. What would it look like? It’s pretty simple, actually.
-
-```rust
-// todo.rs
-
-#[server(AddTodo, "/api")]
-pub async fn add_todo(title: String) -> Result<(), ServerFnError> {
-    let mut conn = db().await?;
-
-    match sqlx::query("INSERT INTO todos (title, completed) VALUES ($1, false)")
-        .bind(title)
-        .execute(&mut conn)
-        .await
-    {
-        Ok(_row) => Ok(()),
-        Err(e) => Err(ServerFnError::ServerError(e.to_string())),
-    }
-}
-
-#[component]
-pub fn BusyButton(cx: Scope) -> impl IntoView {
-	view! {
-        cx,
-        <button on:click=move |_| {
-            spawn_local(async {
-                add_todo("So much to do!".to_string()).await;
-            });
-        }>
-            "Add Todo"
-        </button>
-	}
-}
-```
-
-You’ll notice a couple things here right away:
-
-- Server functions can use server-only dependencies, like `sqlx`, and can access server-only resources, like our database.
-- Server functions are `async`. Even if they only did synchronous work on the server, the function signature would still need to be `async`, because calling them from the browser _must_ be asynchronous.
-- Server functions return `Result<T, ServerFnError>`. Again, even if they only do infallible work on the server, this is true, because `ServerFnError`’s variants include the various things that can be wrong during the process of making a network request.
-- Server functions can be called from the client. Take a look at our click handler. This is code that will _only ever_ run on the client. But it can call the function `add_todo` (using `spawn_local` to run the `Future`) as if it were an ordinary async function:
-
-```rust
-move |_| {
-	spawn_local(async {
-		add_todo("So much to do!".to_string()).await;
-	});
-}
-```
-
-- Server functions are top-level functions defined with `fn`. Unlike event listeners, derived signals, and most everything else in Leptos, they are not closures! As `fn` calls, they have no access to the reactive state of your app or anything else that is not passed in as an argument. And again, this makes perfect sense: When you make a request to the server, the server doesn’t have access to client state unless you send it explicitly. (Otherwise we’d have to serialize the whole reactive system and send it across the wire with every request, which—while it served classic ASP for a while—is a really bad idea.)
-- Server function arguments and return values both need to be serializable with `serde`. Again, hopefully this makes sense: while function arguments in general don’t need to be serialized, calling a server function from the browser means serializing the arguments and sending them over HTTP.
-
-There are a few things to note about the way you define a server function, too.
-
-- Server functions are created by using the [`#[server]` macro](https://docs.rs/leptos_server/latest/leptos_server/index.html#server) to annotate a top-level function, which can be defined anywhere.
-- We provide the macro a type name. The type name is used internally as a container to hold, serialize, and deserialize the arguments.
-- We provide the macro a path. This is a prefix for the path at which we’ll mount a server function handler on our server. (See examples for [Actix](https://github.com/leptos-rs/leptos/blob/main/examples/todo_app_sqlite/src/main.rs#L44) and [Axum](https://github.com/leptos-rs/leptos/blob/598523cd9d0d775b017cb721e41ebae9349f01e2/examples/todo_app_sqlite_axum/src/main.rs#L51).)
-- You’ll need to have `serde` as a dependency with the `derive` featured enabled for the macro to work properly. You can easily add it to `Cargo.toml` with `cargo add serde --features=derive`.
-
-## Server Function Encodings
-
-By default, the server function call is a `POST` request that serializes the arguments as URL-encoded form data in the body of the request. (This means that server functions can be called from HTML forms, which we’ll see in a future chapter.) But there are a few other methods supported. Optionally, we can provide another argument to the `#[server]` macro to specify an alternate encoding:
-
-```rust
-#[server(AddTodo, "/api", "Url")]
-#[server(AddTodo, "/api", "GetJson")]
-#[server(AddTodo, "/api", "Cbor")]
-#[server(AddTodo, "/api", "GetCbor")]
-```
-
-The four options use different combinations of HTTP verbs and encoding methods:
-
-| Name              | Method | Request     | Response |
-| ----------------- | ------ | ----------- | -------- |
-| **Url** (default) | POST   | URL encoded | JSON     |
-| **GetJson**       | GET    | URL encoded | JSON     |
-| **Cbor**          | POST   | CBOR        | CBOR     |
-| **GetCbor**       | GET    | URL encoded | CBOR     |
-
-In other words, you have two choices:
-
-- `GET` or `POST`? This has implications for things like browser or CDN caching; while `POST` requests should not be cached, `GET` requests can be.
-- Plain text (arguments sent with URL/form encoding, results sent as JSON) or a binary format (CBOR, encoded as a base64 string)?
-
-**But remember**: Leptos will handle all the details of this encoding and decoding for you. When you use a server function, it looks just like calling any other asynchronous function!
-
-> **Why not `PUT` or `DELETE`? Why URL/form encoding, and not JSON?**
->
-> These are reasonable questions. Much of the web is built on REST API patterns that encourage the use of semantic HTTP methods like `DELETE` to delete an item from a database, and many devs are accustomed to sending data to APIs in the JSON format.
-> 
-> The reason we use `POST` or `GET` with URL-encoded data by default is the `<form>` support. For better or for worse, HTML forms don’t support `PUT` or `DELETE`, and they don’t support sending JSON. This means that if you use anything but a `GET` or `POST` request with URL-encoded data, it can only work once WASM has loaded. As we’ll see [in a later chapter](../progressive_enhancement), this isn’t always a great idea.
-> 
-> The CBOR encoding is suported for historical reasons; an earlier version of server functions used a URL encoding that didn’t support nested objects like structs or vectors as server function arguments, which CBOR did. But note that the CBOR forms encounter the same issue as `PUT`, `DELETE`, or JSON: they do not degrade gracefully if the WASM version of your app is not available.
-
-## An Important Note on Security
-
-Server functions are a cool technology, but it’s very important to remember. **Server functions are not magic; they’re syntax sugar for defining a public API.** The _body_ of a server function is never made public; it’s just part of your server binary. But the server function is a publicly accessible API endpoint, and it’s return value is just a JSON or similar blob. You should _never_ return something sensitive from a server function.
-
-## Integrating Server Functions with Leptos
-
-So far, everything I’ve said is actually framework agnostic. (And in fact, the Leptos server function crate has been integrated into Dioxus as well!) Server functions are simply a way of defining a function-like RPC call that leans on Web standards like HTTP requests and URL encoding.
-
-But in a way, they also provide the last missing primitive in our story so far. Because a server function is just a plain Rust async function, it integrates perfectly with the async Leptos primitives we discussed [earlier](../async/README.md). So you can easily integrate your server functions with the rest of your applications:
-
-- Create **resources** that call the server function to load data from the server
-- Read these resources under `<Suspense/>` or `<Transition/>` to enable streaming SSR and fallback states while data loads.
-- Create **actions** that call the server function to mutate data on the server
-
-The final section of this book will make this a little more concrete by introducing patterns that use progressively-enhanced HTML forms to run these server actions.
-
-But in the next few chapters, we’ll actually take a look at some of the details of what you might want to do with your server functions, including the best ways to integrate with the powerful extractors provided by the Actix and Axum server frameworks.
+<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

@@ -1,73 +1,2 @@
-# Extractors
-
-The server functions we looked at in the last chapter showed how to run code on the server, and integrate it with the user interface you’re rendering in the browser. But they didn’t show you much about how to actually use your server to its full potential.
-
-## Server Frameworks
-
-We call Leptos a “full-stack” framework, but “full-stack” is always a misnomer (after all, it never means everything from the browser to your power company.) For us, “full stack” means that your Leptos app can run in the browser, and can run on the server, and can integrate the two, drawing together the unique features available in each; as we’ve seen in the book so far, a button click on the browser can drive a database read on the server, both written in the same Rust module. But Leptos itself doesn’t provide the server (or the database, or the operating system, or the firmware, or the electrical cables...)
-
-Instead, Leptos provides integrations for the two most popular Rust web server frameworks, Actix Web ([`leptos_actix`](https://docs.rs/leptos_actix/latest/leptos_actix/)) and Axum ([`leptos_axum`](https://docs.rs/leptos_actix/latest/leptos_axum/)). We’ve built integrations with each server’s router so that you can simply plug your Leptos app into an existing server with `.leptos_routes()`, and easily handle server function calls.
-
-> If haven’t seen our [Actix](https://github.com/leptos-rs/start) and [Axum](https://github.com/leptos-rs/start-axum) templates, now’s a good time to check them out.
-
-## Using Extractors
-
-Both Actix and Axum handlers are built on the same powerful idea of **extractors**. Extractors “extract” typed data from an HTTP request, allowing you to access server-specific data easily.
-
-Leptos provides `extract` helper functions to let you use these extractors directly in your server functions, with a convenient syntax very similar to handlers for each framework.
-
-### Actix Extractors
-
-The [`extract` function in `leptos_actix`](https://docs.rs/leptos_actix/latest/leptos_actix/fn.extract.html) takes a handler function as its argument. The handler follows similar rules to an Actix handler: it is an async function that receives arguments that will be extracted from the request and returns some value. The handler function receives that extracted data as its arguments, and can do further `async` work on them inside the body of the `async move` block. It returns whatever value you return back out into the server function.
-
-```rust
-
-#[server(ActixExtract, "/api")]
-pub async fn actix_extract(cx: Scope) -> Result<String, ServerFnError> {
-	use leptos_actix::extract;
-    use actix_web::dev::ConnectionInfo;
-    use actix_web::web::{Data, Query};
-
-    extract(cx,
-        |search: Query<Search>, connection: ConnectionInfo| async move {
-            format!(
-                "search = {}\nconnection = {:?}",
-                search.q,
-                connection
-            )
-        },
-    )
-    .await
-}
-```
-
-## Axum Extractors
-
-The syntax for the `leptos_axum::extract` function is very similar. (**Note**: This is available on the git main branch, but has not been released as of writing.) Note that Axum extractors return a `Result`, so you’ll need to add something to handle the error case.
-
-```rust
-#[server(AxumExtract, "/api")]
-pub async fn axum_extract(cx: Scope) -> Result<String, ServerFnError> {
-    use axum::{extract::Query, http::Method};
-    use leptos_axum::extract;
-
-    extract(cx, |method: Method, res: Query<MyQuery>| async move {
-            format!("{method:?} and {}", res.q)
-        },
-    )
-    .await
-    .map_err(|e| ServerFnError::ServerError("Could not extract method and query...".to_string()))
-}
-```
-
-These are relatively simple examples accessing basic data from the server. But you can use extractors to access things like headers, cookies, database connection pools, and more, using the exact same `extract()` pattern.
-
-> Note: For now, the Axum `extract` function only supports extractors for which the state is `()`, i.e., you can't yet use it to extract `State(_)`. You can access `State(_)` by using a custom handler that extracts the state and then provides it via context. [Click here for an example](https://github.com/leptos-rs/leptos/blob/a5f73b441c079f9138102b3a7d8d4828f045448c/examples/session_auth_axum/src/main.rs#L91-L92).
-
-## A Note about Data-Loading Patterns
-
-Because Actix and (especially) Axum are built on the idea of a single round-trip HTTP request and response, you typically run extractors near the “top” of your application (i.e., before you start rendering) and use the extracted data to determine how that should be rendered. Before you render a `<button>`, you load all the data your app could need. And any given route handler needs to know all the data that will need to be extracted by that route.
-
-But Leptos integrates both the client and the server, and it’s important to be able to refresh small pieces of your UI with new data from the server without forcing a full reload of all the data. So Leptos likes to push data loading “down” in your application, as far towards the leaves of your user interface as possible. When you click a `<button>`, it can refresh just the data it needs. This is exactly what server functions are for: they give you granular access to data to be loaded and reloaded.
-
-The `extract()` functions let you combine both models by using extractors in your server functions. You get access to the full power of route extractors, while decentralizing knowledge of what needs to be extracted down to your individual components. This makes it easier to refactor and reorganize routes: you don’t need to specify all the data a route needs up front.
+<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

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

@@ -1,11 +1,2 @@
-# Working with the Server
-
-The previous section described the process of server-side rendering, using the server to generate an HTML version of the page that will become interactive in the browser. So far, everything has been “isomorphic” or “universal”; in other words, your app has had the “same (_iso_) shape (_morphe_)” on the client and the server.
-
-But a server can do a lot more than just render HTML! In fact, a server can do a whole bunch of things your browser _can’t,_ like reading from and writing to a SQL database.
-
-If you’re used to building JavaScript frontend apps, you’re probably used to calling out to some kind of REST API to do this sort of server work. If you’re used to building sites with PHP or Python or Ruby (or Java or C# or...), this server-side work is your bread and butter, and it’s the client-side interactivity that tends to be an afterthought.
-
-With Leptos, you can do both: not only in the same language, not only sharing the same types, but even in the same files!
-
-This section will talk about how to build the uniquely-server-side parts of your application.
+<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

@@ -1,37 +1,2 @@
-# Introducing `cargo-leptos`
-
-So far, we’ve just been running code in the browser and using Trunk to coordinate the build process and run a local development process. If we’re going to add server-side rendering, we’ll need to run our application code on the server as well. This means we’ll need to build two separate binaries, one compiled to native code and running the server, the other compiled to WebAssembly (WASM) and running in the user’s browser. Additionally, the server needs to know how to serve this WASM version (and the JavaScript required to initialize it) to the browser.
-
-This is not an insurmountable task but it adds some complication. For convenience and an easier developer experience, we built the [`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) build tool. `cargo-leptos` basically exists to coordinate the build process for your app, handling recompiling the server and client halves when you make changes, and adding some built-in support for things like Tailwind, SASS, and testing.
-
-Getting started is pretty easy. Just run
-
-```bash
-cargo install cargo-leptos
-```
-
-And then to create a new project, you can run either
-
-```bash
-# for an Actix template
-cargo leptos new --git leptos-rs/start
-```
-
-or
-
-```bash
-# for an Axum template
-cargo leptos new --git leptos-rs/start-axum
-```
-
-Now `cd` into the directory you’ve created and run
-
-```bash
-cargo leptos watch
-```
-
-Once your app has compiled you can open up your browser to [`http://localhost:3000`](http://localhost:3000) to see it.
-
-`cargo-leptos` has lots of additional features and built in tools. You can learn more [in its `README`](https://github.com/leptos-rs/cargo-leptos/blob/main/README.md).
-
-But what exactly is happening when you open our browser to `localhost:3000`? Well, read on to find out.
+<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

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

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

@@ -1,198 +1,2 @@
-# Hydration Bugs _(and how to avoid them)_
-
-## A Thought Experiment
-
-Let’s try an experiment to test your intuitions. Open up an app you’re server-rendering with `cargo-leptos`. (If you’ve just been using `trunk` so far to play with examples, go [clone a `cargo-leptos` template](./21_cargo_leptos.md) just for the sake of this exercise.)
-
-Put a log somewhere in your root component. (I usually call mine `<App/>`, but anything will do.)
-
-```rust
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-	leptos::log!("where do I run?");
-	// ... whatever
-}
-```
-
-And let’s fire it up
-
-```bash
-cargo leptos watch
-```
-
-Where do you expect `where do I run?` to log?
-
-- In the command line where you’re running the server?
-- In the browser console when you load the page?
-- Neither?
-- Both?
-
-Try it out.
-
-...
-
-...
-
-...
-
-Okay, consider the spoiler alerted.
-
-You’ll notice of course that it logs in both places, assuming everything goes according to plan. In fact on the server it logs twice—first during the initial server startup, when Leptos renders your app once to extract the route tree, then a second time when you make a request. Each time you reload the page, `where do I run?` should log once on the server and once on the client.
-
-If you think about the description in the last couple sections, hopefully this makes sense. Your application runs once on the server, where it builds up a tree of HTML which is sent to the client. During this initial render, `where do I run?` logs on the server.
-
-Once the WASM binary has loaded in the browser, your application runs a second time, walking over the same user interface tree and adding interactivity.
-
-> Does that sound like a waste? It is, in a sense. But reducing that waste is a genuinely hard problem. It’s what some JS frameworks like Qwik are intended to solve, although it’s probably too early to tell whether it’s a net performance gain as opposed to other approaches.
-
-## The Potential for Bugs
-
-Okay, hopefully all of that made sense. But what does it have to do with the title of this chapter, which is “Hydration bugs (and how to avoid them)”?
-
-Remember that the application needs to run on both the server and the client. This generates a few different sets of potential issues you need to know how to avoid.
-
-### Mismatches between server and client code
-
-One way to create a bug is by creating a mismatch between the HTML that’s sent down by the server and what’s rendered on the client. It’s actually fairly hard to do this unintentionally, I think (at least judging by the bug reports I get from people.) But imagine I do something like this
-
-```rust
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    let data = if cfg!(target_arch = "wasm32") {
-        vec![0, 1, 2]
-    } else {
-        vec![]
-    };
-    data.into_iter()
-        .map(|value| view! { cx, <span>{value}</span> })
-        .collect_view(cx)
-}
-```
-
-In other words, if this is being compiled to WASM, it has three items; otherwise it’s empty.
-
-When I load the page in the browser, I see nothing. If I open the console I see a bunch of warnings:
-
-```
-element with id 0-3 not found, ignoring it for hydration
-element with id 0-4 not found, ignoring it for hydration
-element with id 0-5 not found, ignoring it for hydration
-component with id _0-6c not found, ignoring it for hydration
-component with id _0-6o not found, ignoring it for hydration
-```
-
-The WASM version of your app, running in the browser, expects to find three items; but the HTML has none.
-
-#### Solution
-
-It’s pretty rare that you do this intentionally, but it could happen from somehow running different logic on the server and in the browser. If you’re seeing warnings like this and you don’t think it’s your fault, it’s much more likely that it’s a bug with `<Suspense/>` or something. Feel free to go ahead and open an [issue](https://github.com/leptos-rs/leptos/issues) or [discussion](https://github.com/leptos-rs/leptos/discussions) on GitHub for help.
-
-### Mutating the DOM during rendering
-
-This is a slightly more common way to create a client/server mismatch: updating a signal _during rendering_ in a way that mutates the view.
-
-```rust
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    let (loaded, set_loaded) = create_signal(cx, false);
-
-    // create_effect only runs on the client
-    create_effect(cx, move |_| {
-        // do something like reading from localStorage
-        set_loaded(true);
-    });
-
-    move || {
-        if loaded() {
-            view! { cx, <p>"Hello, world!"</p> }.into_any()
-        } else {
-            view! { cx, <div class="loading">"Loading..."</div> }.into_any()
-        }
-    }
-}
-```
-
-This one gives us the scary panic
-
-```
-panicked at 'assertion failed: `(left == right)`
-  left: `"DIV"`,
- right: `"P"`: SSR and CSR elements have the same hydration key but different node kinds.
-```
-
-And a handy link to this page!
-
-The problem here is that `create_effect` runs **immediately** and **synchronously**, but only in the browser. As a result, on the server, `loaded` is false, and a `<div>` is rendered. But on the browser, by the time the view is being rendered, `loaded` has already been set to `true`, and the browser is expecting to find a `<p>`.
-
-#### Solution
-
-You can simply tell the effect to wait a tick before updating the signal, by using something like `request_animation_frame`, which will set a short timeout and then update the signal before the next frame.
-
-```rust
-create_effect(cx, move |_| {
-    // do something like reading from localStorage
-    request_animation_frame(move || set_loaded(true));
-});
-```
-
-This allows the browser to hydrate with the correct, matching state (`loaded` is `false` when it reaches the view), then immediately update it to `true` once hydration is complete.
-
-### Not all client code can run on the server
-
-Imagine you happily import a dependency like `gloo-net` that you’ve been used to using to make requests in the browser, and use it in a `create_resource` in a server-rendered app.
-
-You’ll probably instantly see the dreaded message
-
-```
-panicked at 'cannot call wasm-bindgen imported functions on non-wasm targets'
-```
-
-Uh-oh.
-
-But of course this makes sense. We’ve just said that your app needs to run on the client and the server.
-
-#### Solution
-
-There are a few ways to avoid this:
-
-1. Only use libraries that can run on both the server and the client. `reqwest`, for example, works for making HTTP requests in both settings.
-2. Use different libraries on the server and the client, and gate them using the `#[cfg]` macro. ([Click here for an example](https://github.com/leptos-rs/leptos/blob/main/examples/hackernews/src/api.rs).)
-3. Wrap client-only code in `create_effect`. Because `create_effect` only runs on the client, this can be an effective way to access browser APIs that are not needed for initial rendering.
-
-For example, say that I want to store something in the browser’s `localStorage` whenever a signal changes.
-
-```rust
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    use gloo_storage::Storage;
-	let storage = gloo_storage::LocalStorage::raw();
-	leptos::log!("{storage:?}");
-}
-```
-
-This panics because I can’t access `LocalStorage` during server rendering.
-
-But if I wrap it in an effect...
-
-```rust
-#[component]
-pub fn App(cx: Scope) -> impl IntoView {
-    use gloo_storage::Storage;
-    create_effect(cx, move |_| {
-        let storage = gloo_storage::LocalStorage::raw();
-		leptos::log!("{storage:?}");
-    });
-}
-```
-
-It’s fine! This will render appropriately on the server, ignoring the client-only code, and then access the storage and log a message on the browser.
-
-### Not all server code can run on the client
-
-WebAssembly running in the browser is a pretty limited environment. You don’t have access to a file-system or to many of the other things the standard library may be used to having. Not every crate can even be compiled to WASM, let alone run in a WASM environment.
-
-In particular, you’ll sometimes see errors about the crate `mio` or missing things from `core`. This is generally a sign that you are trying to compile something to WASM that can’t be compiled to WASM. If you’re adding server-only dependencies, you’ll want to mark them `optional = true` in your `Cargo.toml` and then enable them in the `ssr` feature definition. (Check out one of the template `Cargo.toml` files to see more details.)
-
-You can use `create_effect` to specify that something should only run on the client, and not in the server. Is there a way to specify that something should run only on the server, and not the client?
-
-In fact, there is. The next chapter will cover the topic of server functions in some detail. (In the meantime, you can check out their docs [here](https://docs.rs/leptos_server/0.2.5/leptos_server/index.html).)
+<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

@@ -1,21 +1,2 @@
-# Server Side Rendering
-
-So far, everything we’ve written has been rendered almost entirely in the browser. When we create an app using Trunk, it’s served using a local development server. If you build it for production and deploy it, it’s served by whatever server or CDN you’re using. In either case, what’s served is an HTML page with
-
-1. the URL of your Leptos app, which has been compiled to WebAssembly (WASM)
-2. the URL of the JavaScript used to initialized this WASM blob
-3. an empty `<body>` element
-
-When the JS and WASM have loaded, Leptos will render your app into the `<body>`. This means that nothing appears on the screen until JS/WASM have loaded and run. This has some drawbacks:
-
-1. It increases load time, as your user’s screen is blank until additional resources have been downloaded.
-2. It’s bad for SEO, as load times are longer and the HTML you serve has no meaningful content.
-3. It’s broken for users for whom JS/WASM don’t load for some reason (e.g., they’re on a train and just went into a tunnel before WASM finished loading; they’re using an older device that doesn’t support WASM; they have JavaScript or WASM turned off for some reason; etc.)
-
-These downsides apply across the web ecosystem, but especially to WASM apps.
-
-So what do you do if you want to return more than just an empty `<body>` tag? Use “server-side rendering.”
-
-Whole books could be (and probably have been) written about this topic, but at its core, it’s really simple: rather than returning an empty `<body>` tag, return an initial HTML page that reflects the actual starting state of your app or site, so that while JS/WASM are loading, and until they load, the user can access the plain HTML version.
-
-The rest of this section will cover this topic in some detail!
+<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 num_remaining = move || todos.with(|todos| {
-        todos.iter().filter(|todo| !todo.completed).sum()
-    });
-}
-```
-
-You could pull that logic out into a separate data structure and test it:
-
-```rust
-pub struct Todos(Vec<Todo>);
-
-impl Todos {
-    pub fn num_remaining(&self) -> usize {
-        todos.iter().filter(|todo| !todo.completed).sum()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn test_remaining {
-        // ...
-    }
-}
-
-#[component]
-pub fn TodoApp(cx: Scope) -> impl IntoView {
-    let (todos, set_todos) = create_signal(cx, Todos(vec![Todo { /* ... */ }]));
-    // ✅ this has a test associated with it
-    let num_remaining = move || todos.with(Todos::num_remaining);
-}
-```
-
-In general, the less of your logic is wrapped into your components themselves, the
-more idiomatic your code will feel and the easier it will be to test.
-
-## 2. Test components with `wasm-bindgen-test`
-
-[`wasm-bindgen-test`](https://crates.io/crates/wasm-bindgen-test) is a great utility
-for integrating or end-to-end testing WebAssembly apps in a headless browser.
-
-To use this testing utility, you need to add `wasm-bindgen-test` to your `Cargo.toml`:
-
-```toml
-[dev-dependencies]
-wasm-bindgen-test = "0.3.0"
-```
-
-You should create tests in a separate `tests` directory. You can then run your tests in the browser of your choice:
-
-```bash
-wasm-pack test --firefox
-```
-
-> To see the full setup, check out the tests for the [`counter`](https://github.com/leptos-rs/leptos/tree/main/examples/counter) example.
-
-### Writing Your Tests
-
-Most tests will involve some combination of vanilla DOM manipulation and comparison to a `view`. For example, here’s a test [for the
-`counter` example](https://github.com/leptos-rs/leptos/blob/main/examples/counter/tests/mod.rs).
-
-First, we set up the testing environment.
-
-```rust
-use wasm_bindgen_test::*;
-use counter::*;
-use leptos::*;
-use web_sys::HtmlElement;
-
-// tell the test runner to run tests in the browser
-wasm_bindgen_test_configure!(run_in_browser);
-```
-
-I’m going to create a simpler wrapper for each test case, and mount it there.
-This makes it easy to encapsulate the test results.
-
-```rust
-// like marking a regular test with #[test]
-#[wasm_bindgen_test]
-fn clear() {
-    let document = leptos::document();
-    let test_wrapper = document.create_element("section").unwrap();
-    document.body().unwrap().append_child(&test_wrapper);
-
-    // start by rendering our counter and mounting it to the DOM
-    // note that we start at the initial value of 10
-    mount_to(
-        test_wrapper.clone().unchecked_into(),
-        |cx| view! { cx, <SimpleCounter initial_value=10 step=1/> },
-    );
-}
-```
-
-We’ll use some manual DOM operations to grab the `<div>` that wraps
-the whole component, as well as the `clear` button.
-
-```rust
-// now we extract the buttons by iterating over the DOM
-// this would be easier if they had IDs
-let div = test_wrapper.query_selector("div").unwrap().unwrap();
-let clear = test_wrapper
-    .query_selector("button")
-    .unwrap()
-    .unwrap()
-    .unchecked_into::<web_sys::HtmlElement>();
-```
-
-Now we can use ordinary DOM APIs to simulate user interaction.
-
-```rust
-// now let's click the `clear` button
-clear.click();
-```
-
-You can test individual DOM element attributes or text node values. Sometimes
-I like to test the whole view at once. We can do this by testing the element’s
-`outerHTML` against our expectations.
-
-```rust
-assert_eq!(
-    div.outer_html(),
-    // here we spawn a mini reactive system to render the test case
-    run_scope(create_runtime(), |cx| {
-        // it's as if we're creating it with a value of 0, right?
-        let (value, set_value) = create_signal(cx, 0);
-
-        // we can remove the event listeners because they're not rendered to HTML
-        view! { cx,
-            <div>
-                <button>"Clear"</button>
-                <button>"-1"</button>
-                <span>"Value: " {value} "!"</span>
-                <button>"+1"</button>
-            </div>
-        }
-        // the view returned an HtmlElement<Div>, which is a smart pointer for
-        // a DOM element. So we can still just call .outer_html()
-        .outer_html()
-    })
-);
-```
-
-That test involved us manually replicating the `view` that’s inside the component.
-There's actually an easier way to do this... We can just test against a `<SimpleCounter/>`
-with the initial value `0`. This is where our wrapping element comes in: I’ll just test
-the wrapper’s `innerHTML` against another comparison case.
-
-```rust
-assert_eq!(test_wrapper.inner_html(), {
-    let comparison_wrapper = document.create_element("section").unwrap();
-    leptos::mount_to(
-        comparison_wrapper.clone().unchecked_into(),
-        |cx| view! { cx, <SimpleCounter initial_value=0 step=1/>},
-    );
-    comparison_wrapper.inner_html()
-});
-```
-
-This is only a very limited introduction to testing. But I hope it’s useful as you begin to build applications.
-
-> For more, see [the testing section of the `wasm-bindgen` guide](https://rustwasm.github.io/wasm-bindgen/wasm-bindgen-test/index.html#testing-on-wasm32-unknown-unknown-with-wasm-bindgen-test).
+<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,162 +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(3);
-            }
-        >
-            "Click me: "
-            {move || count.get()}
-        </button>
-    }
-}
-```
-
-## The Component Signature
-
-```rust
-#[component]
-```
-
-Like all component definitions, this begins with the [`#[component]`](https://docs.rs/leptos/latest/leptos/attr.component.html) macro. `#[component]` annotates a function so it can be
-used as a component in your Leptos application. We’ll see some of the other features of
-this macro in a couple chapters.
-
-```rust
-fn App(cx: Scope) -> impl IntoView
-```
-
-Every component is a function with the following characteristics
-
-1. It takes a reactive [`Scope`](https://docs.rs/leptos/latest/leptos/struct.Scope.html)
-   as its first argument. This `Scope` is our entrypoint into the reactive system.
-   By convention, it’s usually named `cx`.
-2. You can include other arguments, which will be available as component “props.”
-3. Component functions return `impl IntoView`, which is an opaque type that includes
-   anything you could return from a Leptos `view`.
-
-## The Component Body
-
-The body of the component function is a set-up function that runs once, not a
-render function that reruns multiple times. You’ll typically use it to create a
-few reactive variables, define any side effects that run in response to those values
-changing, and describe the user interface.
-
-```rust
-let (count, set_count) = create_signal(cx, 0);
-```
-
-[`create_signal`](https://docs.rs/leptos/latest/leptos/fn.create_signal.html)
-creates a signal, the basic unit of reactive change and state management in Leptos.
-This returns a `(getter, setter)` tuple. To access the current value, you’ll
-use `count.get()` (or, on `nightly` Rust, the shorthand `count()`). To set the
-current value, you’ll call `set_count.set(...)` (or `set_count(...)`).
-
-> `.get()` clones the value and `.set()` overwrites it. In many cases, it’s more efficient to use `.with()` or `.update()`; check out the docs for [`ReadSignal`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html) and [`WriteSignal`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html) if you’d like to learn more about those trade-offs at this point.
-
-## The View
-
-Leptos defines user interfaces using a JSX-like format via the [`view`](https://docs.rs/leptos/latest/leptos/macro.view.html) macro.
-
-```rust
-view! { cx,
-    <button
-        // define an event listener with on:
-        on:click=move |_| {
-            // on stable, this is set_count.set(3);
-            set_count(3);
-        }
-    >
-        // text nodes are wrapped in quotation marks
-        "Click me: "
-        // blocks can include Rust code
-        {move || count.get()}
-    </button>
-}
-```
-
-This should mostly be easy to understand: it looks like HTML, with a special
-`on:click` to define a `click` event listener, a text node that’s formatted like
-a Rust string, and then...
-
-```rust
-{move || count.get()}
-```
-
-whatever that is.
-
-People sometimes joke that they use more closures in their first Leptos application
-than they’ve ever used in their lives. And fair enough. Basically, passing a function
-into the view tells the framework: “Hey, this is something that might change.”
-
-When we click the button and call `set_count`, the `count` signal is updated. This
-`move || count.get()` closure, whose value depends on the value of `count`, reruns,
-and the framework makes a targeted update to that one specific text node, touching
-nothing else in your application. This is what allows for extremely efficient updates
-to the DOM.
-
-Now, if you have Clippy on—or if you have a particularly sharp eye—you might notice
-that this closure is redundant, at least if you’re in `nightly` Rust. If you’re using
-Leptos with `nightly` Rust, signals are already functions, so the closure is unnecessary.
-As a result, you can write a simpler view:
-
-```rust
-view! { cx,
-    <button /* ... */>
-        "Click me: "
-        // identical to {move || count.get()}
-        {count}
-    </button>
-}
-```
-
-Remember—and this is _very important_—only functions are reactive. This means that
-`{count}` and `{count()}` do very different things in your view. `{count}` passes
-in a function, telling the framework to update the view every time `count` changes.
-`{count()}` access the value of `count` once, and passes an `i32` into the view,
-rendering it once, unreactively. You can see the difference in the CodeSandbox below!
-
-Let’s make one final change. `set_count(3)` is a pretty useless thing for a click handler to do. Let’s replace “set this value to 3” with “increment this value by 1”:
-
-```rust
-move |_| {
-    set_count.update(|n| *n += 1);
-}
-```
-
-You can see here that while `set_count` just sets the value, `set_count.update()` gives us a mutable reference and mutates the value in place. Either one will trigger a reactive update in our UI.
-
-> Throughout this tutorial, we’ll use CodeSandbox to show interactive examples. To
-> show the browser in the sandbox, you may need to click `Add DevTools >
-Other Previews > 8080.` Hover over any of the variables to show Rust-Analyzer details
-> and docs for what’s going on. Feel free to fork the examples to play with them yourself!
-
-[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/1-basic-component-3d74p3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A31%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A31%2C%22startLineNumber%22%3A19%7D%5D)
-
-<iframe src="https://codesandbox.io/p/sandbox/1-basic-component-3d74p3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A31%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A31%2C%22startLineNumber%22%3A19%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>
+<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,154 +1,2 @@
-# `view`: Dynamic Classes, Styles and Attributes
-
-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 classes, styles and attributes dynamically,
-and we’ll introduce the concept of a **derived signal**.
-
-Let’s start with a simple component that should be familiar: click a button to
-increment a counter.
-
-```rust
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    let (count, set_count) = create_signal(cx, 0);
-
-    view! { cx,
-        <button
-            on:click=move |_| {
-                set_count.update(|n| *n += 1);
-            }
-        >
-            "Click me: "
-            {move || count()}
-        </button>
-    }
-}
-```
-
-So far, this is just the example from the last chapter.
-
-## Dynamic Classes
-
-Now let’s say I’d like to update the list of CSS classes on this element dynamically.
-For example, let’s say I want to add the class `red` when the count is odd. I can
-do this using the `class:` syntax.
-
-```rust
-class:red=move || count() % 2 == 1
-```
-
-`class:` attributes take
-
-1. the class name, following the colon (`red`)
-2. a value, which can be a `bool` or a function that returns a `bool`
-
-When the value is `true`, the class is added. When the value is `false`, the class
-is removed. And if the value is a function that accesses a signal, the class will
-reactively update when the signal changes.
-
-Now every time I click the button, the text should toggle between red and black as
-the number switches between even and odd.
-
-Some CSS class names can’t be directly parsed by the `view` macro, especially if they include a mix of dashes and numbers or other characters. In that case, you can use a tuple syntax: `class=("name", value)` still directly updates a single class.
-
-```rust
-class=("button-20", move || count() % 2 == 1)
-```
-
-> If you’re following along, make sure you go into your `index.html` and add something like this:
->
-> ```html
-> <style>
->   .red {
->     color: red;
->   }
-> </style>
-> ```
-
-## Dynamic Styles
-
-Individual CSS properties can be directly updated with a similar `style:` syntax.
-
-```rust
-let (x, set_x) = create_signal(cx, 0);
-let (y, set_y) = create_signal(cx, 0);
-view! { cx,
-    <div
-        style="position: absolute"
-        style:left=move || format!("{}px", x() + 100)
-        style:top=move || format!("{}px", y() + 100)
-        style:background-color=move || format!("rgb({}, {}, 100)", x(), y())
-        style=("--columns", x)
-    >
-        "Moves when coordinates change"
-    </div>
-}
-```
-
-## Dynamic Attributes
-
-The same applies to plain attributes. Passing a plain string or primitive value to
-an attribute gives it a static value. Passing a function (including a signal) to
-an attribute causes it to update its value reactively. Let’s add another element
-to our view:
-
-```rust
-<progress
-    max="50"
-    // signals are functions, so this <=> `move || count.get()`
-    value=count
-/>
-```
-
-Now every time we set the count, not only will the `class` of the `<button>` be
-toggled, but the `value` of the `<progress>` bar will increase, which means that
-our progress bar will move forward.
-
-## Derived Signals
-
-Let’s go one layer deeper, just for fun.
-
-You already know that we create reactive interfaces just by passing functions into
-the `view`. This means that we can easily change our progress bar. For example,
-suppose we want it to move twice as fast:
-
-```rust
-<progress
-    max="50"
-    value=move || count() * 2
-/>
-```
-
-But imagine we want to reuse that calculation in more than one place. You can do this
-using a **derived signal**: a closure that accesses a signal.
-
-```rust
-let double_count = move || count() * 2;
-
-/* insert the rest of the view */
-<progress
-    max="50"
-    // we use it once here
-    value=double_count
-/>
-<p>
-    "Double Count: "
-    // and again here
-    {double_count}
-</p>
-```
-
-Derived signals let you create reactive computed values that can be used in multiple
-places in your application with minimal overhead.
-
-> Note: Using a derived signal like this means that the calculation runs once per
-> signal change per place we access `double_count`; in other words, twice. This is a
-> very cheap calculation, so that’s fine. We’ll look at memos in a later chapter, which
-> are designed to solve this problem for expensive calculations.
-
-[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/2-dynamic-attribute-pqyvzl?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D)
-
-<iframe src="https://codesandbox.io/p/sandbox/2-dynamic-attribute-pqyvzl?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>
+<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,311 +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! { cx,
-    <progress
-        max="50"
-        value=count
-    />
-    <progress
-        max="50"
-        value=double_count
-    />
-}
-```
-
-But of course, this doesn’t scale very well. If you want to add a third progress
-bar, you need to add this code another time. And if you want to edit anything
-about it, you need to edit it in triplicate.
-
-Instead, let’s create a `<ProgressBar/>` component.
-
-```rust
-#[component]
-fn ProgressBar(
-    cx: Scope
-) -> impl IntoView {
-    view! { cx,
-        <progress
-            max="50"
-            // hmm... where will we get this from?
-            value=progress
-        />
-    }
-}
-```
-
-There’s just one problem: `progress` is not defined. Where should it come from?
-When we were defining everything manually, we just used the local variable names.
-Now we need some way to pass an argument into the component.
-
-## Component Props
-
-We do this using component properties, or “props.” If you’ve used another frontend
-framework, this is probably a familiar idea. Basically, properties are to components
-as attributes are to HTML elements: they let you pass additional information into
-the component.
-
-In Leptos, you define props by giving additional arguments to the component function.
-
-```rust
-#[component]
-fn ProgressBar(
-    cx: Scope,
-    progress: ReadSignal<i32>
-) -> impl IntoView {
-    view! { cx,
-        <progress
-            max="50"
-            // now this works
-            value=progress
-        />
-    }
-}
-```
-
-Now we can use our component in the main `<App/>` component’s view.
-
-```rust
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    let (count, set_count) = create_signal(cx, 0);
-    view! { cx,
-        <button on:click=move |_| { set_count.update(|n| *n += 1); }>
-            "Click me"
-        </button>
-        // now we use our component!
-        <ProgressBar progress=count/>
-    }
-}
-```
-
-Using a component in the view looks a lot like using an HTML element. You’ll
-notice that you can easily tell the difference between an element and a component
-because components always have `PascalCase` names. You pass the `progress` prop
-in as if it were an HTML element attribute. Simple.
-
-### Reactive and Static Props
-
-You’ll notice that throughout this example, `progress` takes a reactive
-`ReadSignal<i32>`, and not a plain `i32`. This is **very important**.
-
-Component props have no special meaning attached to them. A component is simply
-a function that runs once to set up the user interface. The only way to tell the
-interface to respond to changing is to pass it a signal type. So if you have a
-component property that will change over time, like our `progress`, it should
-be a signal.
-
-### `optional` Props
-
-Right now the `max` setting is hard-coded. Let’s take that as a prop too. But
-let’s add a catch: let’s make this prop optional by annotating the particular
-argument to the component function with `#[prop(optional)]`.
-
-```rust
-#[component]
-fn ProgressBar(
-    cx: Scope,
-    // mark this prop optional
-    // you can specify it or not when you use <ProgressBar/>
-    #[prop(optional)]
-    max: u16,
-    progress: ReadSignal<i32>
-) -> impl IntoView {
-    view! { cx,
-        <progress
-            max=max
-            value=progress
-        />
-    }
-}
-```
-
-Now, we can use `<ProgressBar max=50 value=count/>`, or we can omit `max`
-to use the default value (i.e., `<ProgressBar value=count/>`). The default value
-on an `optional` is its `Default::default()` value, which for a `u16` is going to
-be `0`. In the case of a progress bar, a max value of `0` is not very useful.
-
-So let’s give it a particular default value instead.
-
-### `default` props
-
-You can specify a default value other than `Default::default()` pretty simply
-with `#[prop(default = ...)`.
-
-```rust
-#[component]
-fn ProgressBar(
-    cx: Scope,
-    #[prop(default = 100)]
-    max: u16,
-    progress: ReadSignal<i32>
-) -> impl IntoView {
-    view! { cx,
-        <progress
-            max=max
-            value=progress
-        />
-    }
-}
-```
-
-### Generic Props
-
-This is great. But we began with two counters, one driven by `count`, and one by
-the derived signal `double_count`. Let’s recreate that by using `double_count`
-as the `progress` prop on another `<ProgressBar/>`.
-
-```rust
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    let (count, set_count) = create_signal(cx, 0);
-    let double_count = move || count() * 2;
-
-    view! { cx,
-        <button on:click=move |_| { set_count.update(|n| *n += 1); }>
-            "Click me"
-        </button>
-        <ProgressBar progress=count/>
-        // add a second progress bar
-        <ProgressBar progress=double_count/>
-    }
-}
-```
-
-Hm... this won’t compile. It should be pretty easy to understand why: we’ve declared
-that the `progress` prop takes `ReadSignal<i32>`, and `double_count` is not
-`ReadSignal<i32>`. As rust-analyzer will tell you, its type is `|| -> i32`, i.e.,
-it’s a closure that returns an `i32`.
-
-There are a couple ways to handle this. One would be to say: “Well, I know that
-a `ReadSignal` is a function, and I know that a closure is a function; maybe I
-could just take any function?” If you’re savvy, you may know that both these
-implement the trait `Fn() -> i32`. So you could use a generic component:
-
-```rust
-#[component]
-fn ProgressBar<F>(
-    cx: Scope,
-    #[prop(default = 100)]
-    max: u16,
-    progress: F
-) -> impl IntoView
-where
-    F: Fn() -> i32 + 'static,
-{
-    view! { cx,
-        <progress
-            max=max
-            value=progress
-        />
-    }
-}
-```
-
-This is a perfectly reasonable way to write this component: `progress` now takes
-any value that implements this `Fn()` trait.
-
-> Note that generic component props _cannot_ be specified inline (as `<F: Fn() -> i32>`)
-> or as `progress: impl Fn() -> i32 + 'static,`, in part because they’re actually used to generate
-> a `struct ProgressBarProps`, and struct fields cannot be `impl` types.
-
-### `into` Props
-
-There’s one more way we could implement this, and it would be to use `#[prop(into)]`.
-This attribute automatically calls `.into()` on the values you pass as props,
-which allows you to easily pass props with different values.
-
-In this case, it’s helpful to know about the
-[`Signal`](https://docs.rs/leptos/latest/leptos/struct.Signal.html) type. `Signal`
-is an enumerated type that represents any kind of readable reactive signal. It can
-be useful when defining APIs for components you’ll want to reuse while passing
-different sorts of signals. The [`MaybeSignal`](https://docs.rs/leptos/latest/leptos/enum.MaybeSignal.html) type is useful when you want to be able to take either a static or
-reactive value.
-
-```rust
-#[component]
-fn ProgressBar(
-    cx: Scope,
-    #[prop(default = 100)]
-    max: u16,
-    #[prop(into)]
-    progress: Signal<i32>
-) -> impl IntoView
-{
-    view! { cx,
-        <progress
-            max=max
-            value=progress
-        />
-    }
-}
-
-#[component]
-fn App(cx: Scope) -> impl IntoView {
-    let (count, set_count) = create_signal(cx, 0);
-    let double_count = move || count() * 2;
-
-    view! { cx,
-        <button on:click=move |_| { set_count.update(|n| *n += 1); }>
-            "Click me"
-        </button>
-        // .into() converts `ReadSignal` to `Signal`
-        <ProgressBar progress=count/>
-        // use `Signal::derive()` to wrap a derived signal
-        <ProgressBar progress=Signal::derive(cx, double_count)/>
-    }
-}
-```
-
-## Documenting Components
-
-This is one of the least essential but most important sections of this book.
-It’s not strictly necessary to document your components and their props. It may
-be very important, depending on the size of your team and your app. But it’s very
-easy, and bears immediate fruit.
-
-To document a component and its props, you can simply add doc comments on the
-component function, and each one of the props:
-
-```rust
-/// Shows progress toward a goal.
-#[component]
-fn ProgressBar(
-    cx: Scope,
-    /// The maximum value of the progress bar.
-    #[prop(default = 100)]
-    max: u16,
-    /// How much progress should be displayed.
-    #[prop(into)]
-    progress: Signal<i32>,
-) -> impl IntoView {
-    /* ... */
-}
-```
-
-That’s all you need to do. These behave like ordinary Rust doc comments, except
-that you can document individual component props, which can’t be done with Rust
-function arguments.
-
-This will automatically generate documentation for your component, its `Props`
-type, and each of the fields used to add props. It can be a little hard to
-understand how powerful this is until you hover over the component name or props
-and see the power of the `#[component]` macro combined with rust-analyzer here.
-
-[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/3-components-50t2e7?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A7%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A7%7D%5D)
-
-<iframe src="https://codesandbox.io/p/sandbox/3-components-50t2e7?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A7%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A7%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>
+<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">