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/dependabot.yml

@@ -1,13 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "cargo"
-    directories:
-      - "/"
-      - "/examples/*"
-      - "/benchmarks"
-    schedule:
-      interval: "daily"

.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/ci-changed-examples.yml

@@ -1,23 +1,23 @@
 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]

.github/workflows/ci-examples.yml

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

.github/workflows/ci-semver.yml

@@ -1,27 +1,32 @@
 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: github.event.pull_request.labels[0].name == 'semver' # needs.get-leptos-changed.outputs.leptos_changed == 'true' && github.event.pull_request.labels[0].name != 'breaking'
+    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:

.github/workflows/ci.yml

@@ -1,50 +1,27 @@
 name: CI
-
 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-leptos-matrix:
+    uses: ./.github/workflows/get-leptos-matrix.yml
   test:
     name: CI
-    needs: [get-leptos-changed]
+    needs: [get-leptos-changed, get-leptos-matrix]
     if: needs.get-leptos-changed.outputs.leptos_changed == 'true'
     strategy:
-      matrix:
-        directory:
-          [
-            any_error,
-            any_spawner,
-            const_str_slice_concat,
-            either_of,
-            hydration_context,
-            integrations/actix,
-            integrations/axum,
-            integrations/utils,
-            leptos,
-            leptos_config,
-            leptos_dom,
-            leptos_hot_reload,
-            leptos_macro,
-            leptos_server,
-            meta,
-            next_tuple,
-            oco,
-            or_poisoned,
-            reactive_graph,
-            router,
-            router_macro,
-            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 }}

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

@@ -1,12 +1,10 @@
 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
@@ -18,7 +16,6 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-
       - name: Get example files that changed
         id: changed-files
         uses: tj-actions/changed-files@v45
@@ -26,13 +23,10 @@ jobs:
           files: |
             examples/**
             !examples/cargo-make/**
-            !examples/gtk/**
             !examples/Makefile.toml
             !examples/*.md
-
       - name: List example files that changed
         run: echo '${{ steps.changed-files.outputs.all_changed_files }}'
-
       - name: Set example_changed
         id: set-example-changed
         run: |

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

@@ -1,38 +1,34 @@
 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 examples |
-          awk '{print "examples/" $0}' |
-          grep -v .md |
-          grep -v examples/Makefile.toml |
-          grep -v examples/cargo-make |
-          grep -v examples/gtk |
+          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 }}"

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

@@ -1,12 +1,10 @@
 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
@@ -18,40 +16,19 @@ jobs:
         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: |
-            any_error/**
-            any_spawner/**
-            const_str_slice_concat/**
-            either_of/**
-            hydration_context/**
-            integrations/actix/**
-            integrations/axum/**
-            integrations/utils/**
-            leptos/**
-            leptos_config/**
-            leptos_dom/**
-            leptos_hot_reload/**
-            leptos_macro/**
-            leptos_server/**
-            meta/**
-            next_tuple/**
-            oco/**
-            or_poisoned/**
-            reactive_graph/**
-            router/**
-            router_macro/**
-            server_fn/**
-            server_fn/server_fn_macro_default/**
-            server_fn_macro/**
-
+          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: |

.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/run-cargo-make-task.yml

@@ -1,5 +1,4 @@
 name: Run Task
-
 on:
   workflow_call:
     inputs:
@@ -12,70 +11,71 @@ on:
       toolchain:
         required: true
         type: string
-
 env:
   CARGO_TERM_COLOR: always
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
-
+  DEBIAN_FRONTEND: noninteractive
 jobs:
   test:
     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 Glib
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libglib2.0-dev
       - uses: actions/checkout@v4
-
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@master
         with:
           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 --no-confirm
-
+        run: cargo binstall cargo-leptos --locked --no-confirm
       - name: Install Trunk
         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@v4
         with:
           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@v4
         name: Setup pnpm cache
         with:
@@ -83,7 +83,6 @@ jobs:
           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
@@ -99,7 +98,6 @@ jobs:
           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)
@@ -113,12 +111,16 @@ jobs:
               echo Playwright is not required
             fi
           done
-
       - name: Install Deno
-        uses: denoland/setup-deno@v1
+        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: |

.gitignore

@@ -3,7 +3,9 @@ dist
 pkg
 comparisons
 blob.rs
-Cargo.lock
+**/projects/**/Cargo.lock
+**/examples/**/Cargo.lock
+**/benchmarks/**/Cargo.lock
 **/*.rs.bk
 .DS_Store
 .idea
@@ -11,4 +13,5 @@ Cargo.lock
 .envrc
 
 .vscode
-vendor
+vendor
+hash.txt

Cargo.toml

@@ -40,36 +40,36 @@ members = [
 exclude = ["benchmarks", "examples", "projects"]
 
 [workspace.package]
-version = "0.7.0-beta4"
+version = "0.7.7"
 edition = "2021"
 rust-version = "1.76"
 
 [workspace.dependencies]
-throw_error = { path = "./any_error/", version = "0.2.0-beta4" }
-any_spawner = { path = "./any_spawner/", version = "0.1.0" }
-const_str_slice_concat = { path = "./const_str_slice_concat", version = "0.1.0" }
+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-beta4" }
-leptos = { path = "./leptos", version = "0.7.0-beta4" }
-leptos_config = { path = "./leptos_config", version = "0.7.0-beta4" }
-leptos_dom = { path = "./leptos_dom", version = "0.7.0-beta4" }
-leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.7.0-beta4" }
-leptos_integration_utils = { path = "./integrations/utils", version = "0.7.0-beta4" }
-leptos_macro = { path = "./leptos_macro", version = "0.7.0-beta4" }
-leptos_router = { path = "./router", version = "0.7.0-beta4" }
-leptos_router_macro = { path = "./router_macro", version = "0.7.0-beta4" }
-leptos_server = { path = "./leptos_server", version = "0.7.0-beta4" }
-leptos_meta = { path = "./meta", version = "0.7.0-beta4" }
-next_tuple = { path = "./next_tuple", version = "0.1.0-beta4" }
+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.0-beta4" }
-reactive_stores = { path = "./reactive_stores", version = "0.1.0-beta4" }
-reactive_stores_macro = { path = "./reactive_stores_macro", version = "0.1.0-beta4" }
-server_fn = { path = "./server_fn", version = "0.7.0-beta4" }
-server_fn_macro = { path = "./server_fn_macro", version = "0.7.0-beta4" }
-server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.7.0-beta4" }
-tachys = { path = "./tachys", version = "0.1.0-beta4" }
+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
@@ -78,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)',
+] }

README.md

@@ -5,6 +5,7 @@
 
 [![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)
 
@@ -12,8 +13,6 @@
 
 You can find a list of useful libraries and example projects at [`awesome-leptos`](https://github.com/leptos-rs/awesome-leptos).
 
-# The `main` branch is currently undergoing major changes in preparation for the [0.7](https://github.com/leptos-rs/leptos/milestone/4) release. For a stable version, please use the [v0.6.13 tag](https://github.com/leptos-rs/leptos/tree/v0.6.13)
-
 # Leptos
 
 ```rust
@@ -159,9 +158,7 @@ Sure! Obviously the `view` macro is for generating DOM nodes but you can use the
 - Use event listeners to update signals
 - Create effects to update the UI
 
-I've put together a [very simple GTK example](https://github.com/leptos-rs/leptos/blob/main/examples/gtk/src/main.rs) so you can see what I mean.
-
-The new rendering approach being developed for 0.7 supports “universal rendering,” i.e., it can use any rendering library that supports a small set of 6-8 functions. (This is intended as a layer over typical retained-mode, OOP-style GUI toolkits like the DOM, GTK, etc.) That future rendering work will allow creating native UI in a way that is much more similar to the declarative approach used by the web framework.
+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?
 
@@ -171,14 +168,14 @@ Yew is the most-used library for Rust web UI development, but there are several
 - **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?
+### 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?
+### How is this different from Sycamore?
 
 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:
 

any_error/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "throw_error"
-version = "0.2.0-beta4"
+version = "0.2.0"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"
@@ -10,4 +10,4 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-pin-project-lite = "0.2.14"
+pin-project-lite = "0.2.15"

any_spawner/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "any_spawner"
-version = "0.1.1"
+version = "0.2.1"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"
@@ -9,22 +9,25 @@ description = "Spawn asynchronous tasks in an executor-independent way."
 edition.workspace = true
 
 [dependencies]
-futures = "0.3.30"
-glib = { version = "0.20.0", optional = true }
-thiserror = "1.0"
-tokio = { version = "1.39", optional = true, default-features = false, features = [
+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.40", optional = true }
-wasm-bindgen-futures = { version = "0.4.42", optional = true }
+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"]

any_spawner/src/lib.rs

@@ -32,11 +32,14 @@
 use std::{future::Future, pin::Pin, sync::OnceLock};
 use thiserror::Error;
 
-pub(crate) type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
-pub(crate) type PinnedLocalFuture<T> = Pin<Box<dyn Future<Output = T>>>;
+/// 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)]
@@ -115,6 +118,14 @@ impl Executor {
         });
         _ = 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 {
@@ -193,13 +204,15 @@ impl Executor {
     #[cfg_attr(docsrs, doc(cfg(feature = "futures-executor")))]
     pub fn init_futures_executor() -> Result<(), ExecutorError> {
         use futures::{
-            executor::{LocalPool, ThreadPool},
+            executor::{LocalPool, LocalSpawner, ThreadPool},
             task::{LocalSpawnExt, SpawnExt},
         };
+        use std::cell::RefCell;
 
         static THREAD_POOL: OnceLock<ThreadPool> = OnceLock::new();
         thread_local! {
-            static LOCAL_POOL: LocalPool = LocalPool::new();
+            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 {
@@ -218,28 +231,131 @@ impl Executor {
             .map_err(|_| ExecutorError::AlreadySet)?;
         SPAWN_LOCAL
             .set(|fut| {
-                LOCAL_POOL.with(|pool| {
-                    let spawner = pool.spawner();
+                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(())
     }
 }
 
-#[cfg(test)]
-mod tests {
-    #[cfg(feature = "futures-executor")]
-    #[test]
-    fn can_spawn_local_future() {
-        use crate::Executor;
-        use std::rc::Rc;
-        Executor::init_futures_executor().expect("couldn't set executor");
-        let rc = Rc::new(());
-        Executor::spawn_local(async {
-            _ = rc;
-        });
-        Executor::spawn(async {});
-    }
+/// 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,7 +2,8 @@
 name = "benchmarks"
 version = "0.1.0"
 edition = "2021"
-rust-version.workspace = true
+# std::sync::LazyLock is stabilized in Rust version 1.80.0
+rust-version = "1.80.0"
 
 [dependencies]
 l0410 = { package = "leptos", version = "0.4.10", features = [

benchmarks/src/ssr.rs

@@ -18,7 +18,7 @@ fn leptos_ssr_bench(b: &mut Bencher) {
 				}
 			}
 
-			let rendered = view! { 
+			let rendered = view! {
 				<main>
 					<h1>"Welcome to our benchmark page."</h1>
 					<p>"Here's some introductory text."</p>
@@ -58,7 +58,7 @@ fn tachys_ssr_bench(b: &mut Bencher) {
 			}
 		}
 
-		let rendered = view! { 
+		let rendered = view! {
 			<main>
 				<h1>"Welcome to our benchmark page."</h1>
 				<p>"Here's some introductory text."</p>
@@ -92,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/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 %}
@@ -91,13 +91,13 @@ 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 {
@@ -131,13 +131,13 @@ 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 {

either_of/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "either_of"
-version = "0.1.0"
+version = "0.1.5"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"
@@ -10,4 +10,9 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-pin-project-lite = "0.2.14"
+pin-project-lite = "0.2.16"
+paste = "1.0.15"
+
+[features]
+default = ["no_std"]
+no_std = []

either_of/src/lib.rs

@@ -1,135 +1,907 @@
-#![no_std]
+#![cfg_attr(feature = "no_std", no_std)]
 #![forbid(unsafe_code)]
 
 //! Utilities for working with enumerated types that contain one of `2..n` other types.
 
 use core::{
+    cmp::Ordering,
     fmt::Display,
     future::Future,
+    iter::{Product, Sum},
     pin::Pin,
     task::{Context, Poll},
 };
+use paste::paste;
 use pin_project_lite::pin_project;
-
-#[derive(Debug, Clone, Copy)]
-pub enum Either<A, B> {
-    Left(A),
-    Right(B),
-}
-
-impl<Item, A, B> Iterator for Either<A, B>
-where
-    A: Iterator<Item = Item>,
-    B: Iterator<Item = Item>,
-{
-    type Item = Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self {
-            Either::Left(i) => i.next(),
-            Either::Right(i) => i.next(),
-        }
-    }
-}
-
-pin_project! {
-    #[project = EitherFutureProj]
-    pub enum EitherFuture<A, B> {
-        Left { #[pin] inner: A },
-        Right { #[pin] inner: B },
-    }
-}
-
-impl<A, B> Future for EitherFuture<A, B>
-where
-    A: Future,
-    B: Future,
-{
-    type Output = Either<A::Output, B::Output>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-        match this {
-            EitherFutureProj::Left { inner } => match inner.poll(cx) {
-                Poll::Pending => Poll::Pending,
-                Poll::Ready(inner) => Poll::Ready(Either::Left(inner)),
-            },
-            EitherFutureProj::Right { inner } => match inner.poll(cx) {
-                Poll::Pending => Poll::Pending,
-                Poll::Ready(inner) => Poll::Ready(Either::Right(inner)),
-            },
-        }
-    }
-}
+#[cfg(not(feature = "no_std"))]
+use std::error::Error; // TODO: replace with core::error::Error once MSRV is >= 1.81.0
 
 macro_rules! tuples {
-    ($name:ident + $fut_name:ident + $fut_proj:ident => $($ty:ident),*) => {
+    ($name:ident + $fut_name:ident + $fut_proj:ident {
+        $($ty:ident => ($($rest_variant:ident),*) + <$($mapped_ty:ident),+>),+$(,)?
+    }) => {
+        tuples!($name + $fut_name + $fut_proj {
+            $($ty($ty) => ($($rest_variant),*) + <$($mapped_ty),+>),+
+        });
+    };
+    ($name:ident + $fut_name:ident + $fut_proj:ident {
+        $($variant:ident($ty:ident) => ($($rest_variant:ident),*) + <$($mapped_ty:ident),+>),+$(,)?
+    }) => {
         #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
-        pub enum $name<$($ty,)*> {
-            $($ty ($ty),)*
+        pub enum $name<$($ty),+> {
+            $($variant ($ty),)+
         }
 
-        impl<$($ty,)*> Display for $name<$($ty,)*>
+        impl<$($ty),+> $name<$($ty),+> {
+            paste! {
+                #[allow(clippy::too_many_arguments)]
+                pub fn map<$([<F $ty>]),+, $([<$ty 1>]),+>(self, $([<$variant:lower>]: [<F $ty>]),+) -> $name<$([<$ty 1>]),+>
+                where
+                    $([<F $ty>]: FnOnce($ty) -> [<$ty 1>],)+
+                {
+                    match self {
+                        $($name::$variant(inner) => $name::$variant([<$variant:lower>](inner)),)+
+                    }
+                }
+
+                $(
+                    pub fn [<map_ $variant:lower>]<Fun, [<$ty 1>]>(self, f: Fun) -> $name<$($mapped_ty),+>
+                    where
+                        Fun: FnOnce($ty) -> [<$ty 1>],
+                    {
+                        match self {
+                            $name::$variant(inner) => $name::$variant(f(inner)),
+                            $($name::$rest_variant(inner) => $name::$rest_variant(inner),)*
+                        }
+                    }
+
+                    pub fn [<inspect_ $variant:lower>]<Fun, [<$ty 1>]>(self, f: Fun) -> Self
+                    where
+                        Fun: FnOnce(&$ty),
+                    {
+                        if let $name::$variant(inner) = &self {
+                            f(inner);
+                        }
+                        self
+                    }
+
+                    pub fn [<is_ $variant:lower>](&self) -> bool {
+                        matches!(self, $name::$variant(_))
+                    }
+
+                    pub fn [<as_ $variant:lower>](&self) -> Option<&$ty> {
+                        match self {
+                            $name::$variant(inner) => Some(inner),
+                            _ => None,
+                        }
+                    }
+
+                    pub fn [<as_ $variant:lower _mut>](&mut self) -> Option<&mut $ty> {
+                        match self {
+                            $name::$variant(inner) => Some(inner),
+                            _ => None,
+                        }
+                    }
+
+                    pub fn [<unwrap_ $variant:lower>](self) -> $ty {
+                        match self {
+                            $name::$variant(inner) => inner,
+                            _ => panic!(concat!(
+                                "called `unwrap_", stringify!([<$variant:lower>]), "()` on a non-`", stringify!($variant), "` variant of `", stringify!($name), "`"
+                            )),
+                        }
+                    }
+
+                    pub fn [<into_ $variant:lower>](self) -> Result<$ty, Self> {
+                        match self {
+                            $name::$variant(inner) => Ok(inner),
+                            _ => Err(self),
+                        }
+                    }
+                )+
+            }
+        }
+
+        impl<$($ty),+> Display for $name<$($ty),+>
         where
-            $($ty: Display,)*
+            $($ty: Display,)+
         {
             fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                 match self {
-                    $($name::$ty(this) => this.fmt(f),)*
+                    $($name::$variant(this) => this.fmt(f),)+
                 }
             }
         }
 
-        impl<Item, $($ty,)*> Iterator for $name<$($ty,)*>
+        #[cfg(not(feature = "no_std"))]
+        impl<$($ty),+> Error for $name<$($ty),+>
         where
-            $($ty: Iterator<Item = Item>,)*
+            $($ty: Error,)+
+        {
+            fn source(&self) -> Option<&(dyn Error + 'static)> {
+                match self {
+                    $($name::$variant(this) => this.source(),)+
+                }
+            }
+        }
+
+        impl<Item, $($ty),+> Iterator for $name<$($ty),+>
+        where
+            $($ty: Iterator<Item = Item>,)+
         {
             type Item = Item;
 
             fn next(&mut self) -> Option<Self::Item> {
                 match self {
-                    $($name::$ty(i) => i.next(),)*
+                    $($name::$variant(i) => i.next(),)+
+                }
+            }
+
+            fn size_hint(&self) -> (usize, Option<usize>) {
+                match self {
+                    $($name::$variant(i) => i.size_hint(),)+
+                }
+            }
+
+            fn count(self) -> usize
+            where
+                Self: Sized,
+            {
+                match self {
+                    $($name::$variant(i) => i.count(),)+
+                }
+            }
+
+            fn last(self) -> Option<Self::Item>
+            where
+                Self: Sized,
+            {
+                match self {
+                    $($name::$variant(i) => i.last(),)+
+                }
+            }
+
+            fn nth(&mut self, n: usize) -> Option<Self::Item> {
+                match self {
+                    $($name::$variant(i) => i.nth(n),)+
+                }
+            }
+
+            fn for_each<Fun>(self, f: Fun)
+            where
+                Self: Sized,
+                Fun: FnMut(Self::Item),
+            {
+                match self {
+                    $($name::$variant(i) => i.for_each(f),)+
+                }
+            }
+
+            fn collect<Col: FromIterator<Self::Item>>(self) -> Col
+            where
+                Self: Sized,
+            {
+                match self {
+                    $($name::$variant(i) => i.collect(),)+
+                }
+            }
+
+            fn partition<Col, Fun>(self, f: Fun) -> (Col, Col)
+            where
+                Self: Sized,
+                Col: Default + Extend<Self::Item>,
+                Fun: FnMut(&Self::Item) -> bool,
+            {
+                match self {
+                    $($name::$variant(i) => i.partition(f),)+
+                }
+            }
+
+            fn fold<Acc, Fun>(self, init: Acc, f: Fun) -> Acc
+            where
+                Self: Sized,
+                Fun: FnMut(Acc, Self::Item) -> Acc,
+            {
+                match self {
+                    $($name::$variant(i) => i.fold(init, f),)+
+                }
+            }
+
+            fn reduce<Fun>(self, f: Fun) -> Option<Self::Item>
+            where
+                Self: Sized,
+                Fun: FnMut(Self::Item, Self::Item) -> Self::Item,
+            {
+                match self {
+                    $($name::$variant(i) => i.reduce(f),)+
+                }
+            }
+
+            fn all<Fun>(&mut self, f: Fun) -> bool
+            where
+                Self: Sized,
+                Fun: FnMut(Self::Item) -> bool,
+            {
+                match self {
+                    $($name::$variant(i) => i.all(f),)+
+                }
+            }
+
+            fn any<Fun>(&mut self, f: Fun) -> bool
+            where
+                Self: Sized,
+                Fun: FnMut(Self::Item) -> bool,
+            {
+                match self {
+                    $($name::$variant(i) => i.any(f),)+
+                }
+            }
+
+            fn find<Pre>(&mut self, predicate: Pre) -> Option<Self::Item>
+            where
+                Self: Sized,
+                Pre: FnMut(&Self::Item) -> bool,
+            {
+                match self {
+                    $($name::$variant(i) => i.find(predicate),)+
+                }
+            }
+
+            fn find_map<Out, Fun>(&mut self, f: Fun) -> Option<Out>
+            where
+                Self: Sized,
+                Fun: FnMut(Self::Item) -> Option<Out>,
+            {
+                match self {
+                    $($name::$variant(i) => i.find_map(f),)+
+                }
+            }
+
+            fn position<Pre>(&mut self, predicate: Pre) -> Option<usize>
+            where
+                Self: Sized,
+                Pre: FnMut(Self::Item) -> bool,
+            {
+                match self {
+                    $($name::$variant(i) => i.position(predicate),)+
+                }
+            }
+
+            fn max(self) -> Option<Self::Item>
+            where
+                Self: Sized,
+                Self::Item: Ord,
+            {
+                match self {
+                    $($name::$variant(i) => i.max(),)+
+                }
+            }
+
+            fn min(self) -> Option<Self::Item>
+            where
+                Self: Sized,
+                Self::Item: Ord,
+            {
+                match self {
+                    $($name::$variant(i) => i.min(),)+
+                }
+            }
+
+            fn max_by_key<Key: Ord, Fun>(self, f: Fun) -> Option<Self::Item>
+            where
+                Self: Sized,
+                Fun: FnMut(&Self::Item) -> Key,
+            {
+                match self {
+                    $($name::$variant(i) => i.max_by_key(f),)+
+                }
+            }
+
+            fn max_by<Cmp>(self, compare: Cmp) -> Option<Self::Item>
+            where
+                Self: Sized,
+                Cmp: FnMut(&Self::Item, &Self::Item) -> Ordering,
+            {
+                match self {
+                    $($name::$variant(i) => i.max_by(compare),)+
+                }
+            }
+
+            fn min_by_key<Key: Ord, Fun>(self, f: Fun) -> Option<Self::Item>
+            where
+                Self: Sized,
+                Fun: FnMut(&Self::Item) -> Key,
+            {
+                match self {
+                    $($name::$variant(i) => i.min_by_key(f),)+
+                }
+            }
+
+            fn min_by<Cmp>(self, compare: Cmp) -> Option<Self::Item>
+            where
+                Self: Sized,
+                Cmp: FnMut(&Self::Item, &Self::Item) -> Ordering,
+            {
+                match self {
+                    $($name::$variant(i) => i.min_by(compare),)+
+                }
+            }
+
+            fn sum<Out>(self) -> Out
+            where
+                Self: Sized,
+                Out: Sum<Self::Item>,
+            {
+                match self {
+                    $($name::$variant(i) => i.sum(),)+
+                }
+            }
+
+            fn product<Out>(self) -> Out
+            where
+                Self: Sized,
+                Out: Product<Self::Item>,
+            {
+                match self {
+                    $($name::$variant(i) => i.product(),)+
+                }
+            }
+
+            fn cmp<Other>(self, other: Other) -> Ordering
+            where
+                Other: IntoIterator<Item = Self::Item>,
+                Self::Item: Ord,
+                Self: Sized,
+            {
+                match self {
+                    $($name::$variant(i) => i.cmp(other),)+
+                }
+            }
+
+            fn partial_cmp<Other>(self, other: Other) -> Option<Ordering>
+            where
+                Other: IntoIterator,
+                Self::Item: PartialOrd<Other::Item>,
+                Self: Sized,
+            {
+                match self {
+                    $($name::$variant(i) => i.partial_cmp(other),)+
+                }
+            }
+
+            // TODO: uncomment once MSRV is >= 1.82.0
+            // fn is_sorted(self) -> bool
+            // where
+            //     Self: Sized,
+            //     Self::Item: PartialOrd,
+            // {
+            //     match self {
+            //         $($name::$variant(i) => i.is_sorted(),)+
+            //     }
+            // }
+            //
+            // fn is_sorted_by<Cmp>(self, compare: Cmp) -> bool
+            // where
+            //     Self: Sized,
+            //     Cmp: FnMut(&Self::Item, &Self::Item) -> bool,
+            // {
+            //     match self {
+            //         $($name::$variant(i) => i.is_sorted_by(compare),)+
+            //     }
+            // }
+            //
+            // fn is_sorted_by_key<Fun, Key>(self, f: Fun) -> bool
+            // where
+            //     Self: Sized,
+            //     Fun: FnMut(Self::Item) -> Key,
+            //     Key: PartialOrd,
+            // {
+            //     match self {
+            //         $($name::$variant(i) => i.is_sorted_by_key(f),)+
+            //     }
+            // }
+        }
+
+        impl<Item, $($ty),+> ExactSizeIterator for $name<$($ty),+>
+        where
+            $($ty: ExactSizeIterator<Item = Item>,)+
+        {
+            fn len(&self) -> usize {
+                match self {
+                    $($name::$variant(i) => i.len(),)+
+                }
+            }
+        }
+
+        impl<Item, $($ty),+> DoubleEndedIterator for $name<$($ty),+>
+        where
+            $($ty: DoubleEndedIterator<Item = Item>,)+
+        {
+            fn next_back(&mut self) -> Option<Self::Item> {
+                match self {
+                    $($name::$variant(i) => i.next_back(),)+
+                }
+            }
+
+            fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+                match self {
+                    $($name::$variant(i) => i.nth_back(n),)+
+                }
+            }
+
+            fn rfind<Pre>(&mut self, predicate: Pre) -> Option<Self::Item>
+            where
+                Pre: FnMut(&Self::Item) -> bool,
+            {
+                match self {
+                    $($name::$variant(i) => i.rfind(predicate),)+
                 }
             }
         }
 
         pin_project! {
             #[project = $fut_proj]
-            pub enum $fut_name<$($ty,)*> {
-                $($ty { #[pin] inner: $ty },)*
+            pub enum $fut_name<$($ty),+> {
+                $($variant { #[pin] inner: $ty },)+
             }
         }
 
-        impl<$($ty,)*> Future for $fut_name<$($ty,)*>
+        impl<$($ty),+> Future for $fut_name<$($ty),+>
         where
-            $($ty: Future,)*
+            $($ty: Future,)+
         {
-            type Output = $name<$($ty::Output,)*>;
+            type Output = $name<$($ty::Output),+>;
 
             fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
                 let this = self.project();
                 match this {
-                    $($fut_proj::$ty { inner } => match inner.poll(cx) {
+                    $($fut_proj::$variant { inner } => match inner.poll(cx) {
                         Poll::Pending => Poll::Pending,
-                        Poll::Ready(inner) => Poll::Ready($name::$ty(inner)),
-                    },)*
+                        Poll::Ready(inner) => Poll::Ready($name::$variant(inner)),
+                    },)+
                 }
             }
         }
     }
 }
 
-tuples!(EitherOf3 + EitherOf3Future + EitherOf3FutureProj => A, B, C);
-tuples!(EitherOf4 + EitherOf4Future + EitherOf4FutureProj => A, B, C, D);
-tuples!(EitherOf5 + EitherOf5Future + EitherOf5FutureProj => A, B, C, D, E);
-tuples!(EitherOf6 + EitherOf6Future + EitherOf6FutureProj => A, B, C, D, E, F);
-tuples!(EitherOf7 + EitherOf7Future + EitherOf7FutureProj => A, B, C, D, E, F, G);
-tuples!(EitherOf8 + EitherOf8Future + EitherOf8FutureProj => A, B, C, D, E, F, G, H);
-tuples!(EitherOf9 + EitherOf9Future + EitherOf9FutureProj => A, B, C, D, E, F, G, H, I);
-tuples!(EitherOf10 + EitherOf10Future + EitherOf10FutureProj => A, B, C, D, E, F, G, H, I, J);
-tuples!(EitherOf11 + EitherOf11Future + EitherOf11FutureProj => A, B, C, D, E, F, G, H, I, J, K);
-tuples!(EitherOf12 + EitherOf12Future + EitherOf12FutureProj => A, B, C, D, E, F, G, H, I, J, K, L);
-tuples!(EitherOf13 + EitherOf13Future + EitherOf13FutureProj => A, B, C, D, E, F, G, H, I, J, K, L, M);
-tuples!(EitherOf14 + EitherOf14Future + EitherOf14FutureProj => A, B, C, D, E, F, G, H, I, J, K, L, M, N);
-tuples!(EitherOf15 + EitherOf15Future + EitherOf15FutureProj => A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
-tuples!(EitherOf16 + EitherOf16Future + EitherOf16FutureProj => A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
+tuples!(Either + EitherFuture + EitherFutureProj {
+    Left(A) => (Right) + <A1, B>,
+    Right(B) => (Left) + <A, B1>,
+});
+
+impl<A, B> Either<A, B> {
+    pub fn swap(self) -> Either<B, A> {
+        match self {
+            Either::Left(a) => Either::Right(a),
+            Either::Right(b) => Either::Left(b),
+        }
+    }
+}
+
+impl<A, B> From<Result<A, B>> for Either<A, B> {
+    fn from(value: Result<A, B>) -> Self {
+        match value {
+            Ok(left) => Either::Left(left),
+            Err(right) => Either::Right(right),
+        }
+    }
+}
+
+pub trait EitherOr {
+    type Left;
+    type Right;
+    fn either_or<FA, A, FB, B>(self, a: FA, b: FB) -> Either<A, B>
+    where
+        FA: FnOnce(Self::Left) -> A,
+        FB: FnOnce(Self::Right) -> B;
+}
+
+impl EitherOr for bool {
+    type Left = ();
+    type Right = ();
+
+    fn either_or<FA, A, FB, B>(self, a: FA, b: FB) -> Either<A, B>
+    where
+        FA: FnOnce(Self::Left) -> A,
+        FB: FnOnce(Self::Right) -> B,
+    {
+        if self {
+            Either::Left(a(()))
+        } else {
+            Either::Right(b(()))
+        }
+    }
+}
+
+impl<T> EitherOr for Option<T> {
+    type Left = T;
+    type Right = ();
+
+    fn either_or<FA, A, FB, B>(self, a: FA, b: FB) -> Either<A, B>
+    where
+        FA: FnOnce(Self::Left) -> A,
+        FB: FnOnce(Self::Right) -> B,
+    {
+        match self {
+            Some(t) => Either::Left(a(t)),
+            None => Either::Right(b(())),
+        }
+    }
+}
+
+impl<T, E> EitherOr for Result<T, E> {
+    type Left = T;
+    type Right = E;
+
+    fn either_or<FA, A, FB, B>(self, a: FA, b: FB) -> Either<A, B>
+    where
+        FA: FnOnce(Self::Left) -> A,
+        FB: FnOnce(Self::Right) -> B,
+    {
+        match self {
+            Ok(t) => Either::Left(a(t)),
+            Err(err) => Either::Right(b(err)),
+        }
+    }
+}
+
+impl<A, B> EitherOr for Either<A, B> {
+    type Left = A;
+    type Right = B;
+
+    #[inline]
+    fn either_or<FA, A1, FB, B1>(self, a: FA, b: FB) -> Either<A1, B1>
+    where
+        FA: FnOnce(<Self as EitherOr>::Left) -> A1,
+        FB: FnOnce(<Self as EitherOr>::Right) -> B1,
+    {
+        self.map(a, b)
+    }
+}
+
+#[test]
+fn test_either_or() {
+    let right = false.either_or(|_| 'a', |_| 12);
+    assert!(matches!(right, Either::Right(12)));
+
+    let left = true.either_or(|_| 'a', |_| 12);
+    assert!(matches!(left, Either::Left('a')));
+
+    let left = Some(12).either_or(|a| a, |_| 'a');
+    assert!(matches!(left, Either::Left(12)));
+    let right = None.either_or(|a: i32| a, |_| 'a');
+    assert!(matches!(right, Either::Right('a')));
+
+    let result: Result<_, ()> = Ok(1.2f32);
+    let left = result.either_or(|a| a * 2f32, |b| b);
+    assert!(matches!(left, Either::Left(2.4f32)));
+
+    let result: Result<i32, _> = Err("12");
+    let right = result.either_or(|a| a, |b| b.chars().next());
+    assert!(matches!(right, Either::Right(Some('1'))));
+
+    let either = Either::<i32, char>::Left(12);
+    let left = either.either_or(|a| a, |b| b);
+    assert!(matches!(left, Either::Left(12)));
+
+    let either = Either::<i32, char>::Right('a');
+    let right = either.either_or(|a| a, |b| b);
+    assert!(matches!(right, Either::Right('a')));
+}
+
+tuples!(EitherOf3 + EitherOf3Future + EitherOf3FutureProj {
+    A => (B, C) + <A1, B, C>,
+    B => (A, C) + <A, B1, C>,
+    C => (A, B) + <A, B, C1>,
+});
+tuples!(EitherOf4 + EitherOf4Future + EitherOf4FutureProj {
+    A => (B, C, D) + <A1, B, C, D>,
+    B => (A, C, D) + <A, B1, C, D>,
+    C => (A, B, D) + <A, B, C1, D>,
+    D => (A, B, C) + <A, B, C, D1>,
+});
+tuples!(EitherOf5 + EitherOf5Future + EitherOf5FutureProj {
+    A => (B, C, D, E) + <A1, B, C, D, E>,
+    B => (A, C, D, E) + <A, B1, C, D, E>,
+    C => (A, B, D, E) + <A, B, C1, D, E>,
+    D => (A, B, C, E) + <A, B, C, D1, E>,
+    E => (A, B, C, D) + <A, B, C, D, E1>,
+});
+tuples!(EitherOf6 + EitherOf6Future + EitherOf6FutureProj {
+    A => (B, C, D, E, F) + <A1, B, C, D, E, F>,
+    B => (A, C, D, E, F) + <A, B1, C, D, E, F>,
+    C => (A, B, D, E, F) + <A, B, C1, D, E, F>,
+    D => (A, B, C, E, F) + <A, B, C, D1, E, F>,
+    E => (A, B, C, D, F) + <A, B, C, D, E1, F>,
+    F => (A, B, C, D, E) + <A, B, C, D, E, F1>,
+});
+tuples!(EitherOf7 + EitherOf7Future + EitherOf7FutureProj {
+    A => (B, C, D, E, F, G) + <A1, B, C, D, E, F, G>,
+    B => (A, C, D, E, F, G) + <A, B1, C, D, E, F, G>,
+    C => (A, B, D, E, F, G) + <A, B, C1, D, E, F, G>,
+    D => (A, B, C, E, F, G) + <A, B, C, D1, E, F, G>,
+    E => (A, B, C, D, F, G) + <A, B, C, D, E1, F, G>,
+    F => (A, B, C, D, E, G) + <A, B, C, D, E, F1, G>,
+    G => (A, B, C, D, E, F) + <A, B, C, D, E, F, G1>,
+});
+tuples!(EitherOf8 + EitherOf8Future + EitherOf8FutureProj {
+    A => (B, C, D, E, F, G, H) + <A1, B, C, D, E, F, G, H>,
+    B => (A, C, D, E, F, G, H) + <A, B1, C, D, E, F, G, H>,
+    C => (A, B, D, E, F, G, H) + <A, B, C1, D, E, F, G, H>,
+    D => (A, B, C, E, F, G, H) + <A, B, C, D1, E, F, G, H>,
+    E => (A, B, C, D, F, G, H) + <A, B, C, D, E1, F, G, H>,
+    F => (A, B, C, D, E, G, H) + <A, B, C, D, E, F1, G, H>,
+    G => (A, B, C, D, E, F, H) + <A, B, C, D, E, F, G1, H>,
+    H => (A, B, C, D, E, F, G) + <A, B, C, D, E, F, G, H1>,
+});
+tuples!(EitherOf9 + EitherOf9Future + EitherOf9FutureProj {
+    A => (B, C, D, E, F, G, H, I) + <A1, B, C, D, E, F, G, H, I>,
+    B => (A, C, D, E, F, G, H, I) + <A, B1, C, D, E, F, G, H, I>,
+    C => (A, B, D, E, F, G, H, I) + <A, B, C1, D, E, F, G, H, I>,
+    D => (A, B, C, E, F, G, H, I) + <A, B, C, D1, E, F, G, H, I>,
+    E => (A, B, C, D, F, G, H, I) + <A, B, C, D, E1, F, G, H, I>,
+    F => (A, B, C, D, E, G, H, I) + <A, B, C, D, E, F1, G, H, I>,
+    G => (A, B, C, D, E, F, H, I) + <A, B, C, D, E, F, G1, H, I>,
+    H => (A, B, C, D, E, F, G, I) + <A, B, C, D, E, F, G, H1, I>,
+    I => (A, B, C, D, E, F, G, H) + <A, B, C, D, E, F, G, H, I1>,
+});
+tuples!(EitherOf10 + EitherOf10Future + EitherOf10FutureProj {
+    A => (B, C, D, E, F, G, H, I, J) + <A1, B, C, D, E, F, G, H, I, J>,
+    B => (A, C, D, E, F, G, H, I, J) + <A, B1, C, D, E, F, G, H, I, J>,
+    C => (A, B, D, E, F, G, H, I, J) + <A, B, C1, D, E, F, G, H, I, J>,
+    D => (A, B, C, E, F, G, H, I, J) + <A, B, C, D1, E, F, G, H, I, J>,
+    E => (A, B, C, D, F, G, H, I, J) + <A, B, C, D, E1, F, G, H, I, J>,
+    F => (A, B, C, D, E, G, H, I, J) + <A, B, C, D, E, F1, G, H, I, J>,
+    G => (A, B, C, D, E, F, H, I, J) + <A, B, C, D, E, F, G1, H, I, J>,
+    H => (A, B, C, D, E, F, G, I, J) + <A, B, C, D, E, F, G, H1, I, J>,
+    I => (A, B, C, D, E, F, G, H, J) + <A, B, C, D, E, F, G, H, I1, J>,
+    J => (A, B, C, D, E, F, G, H, I) + <A, B, C, D, E, F, G, H, I, J1>,
+});
+tuples!(EitherOf11 + EitherOf11Future + EitherOf11FutureProj {
+    A => (B, C, D, E, F, G, H, I, J, K) + <A1, B, C, D, E, F, G, H, I, J, K>,
+    B => (A, C, D, E, F, G, H, I, J, K) + <A, B1, C, D, E, F, G, H, I, J, K>,
+    C => (A, B, D, E, F, G, H, I, J, K) + <A, B, C1, D, E, F, G, H, I, J, K>,
+    D => (A, B, C, E, F, G, H, I, J, K) + <A, B, C, D1, E, F, G, H, I, J, K>,
+    E => (A, B, C, D, F, G, H, I, J, K) + <A, B, C, D, E1, F, G, H, I, J, K>,
+    F => (A, B, C, D, E, G, H, I, J, K) + <A, B, C, D, E, F1, G, H, I, J, K>,
+    G => (A, B, C, D, E, F, H, I, J, K) + <A, B, C, D, E, F, G1, H, I, J, K>,
+    H => (A, B, C, D, E, F, G, I, J, K) + <A, B, C, D, E, F, G, H1, I, J, K>,
+    I => (A, B, C, D, E, F, G, H, J, K) + <A, B, C, D, E, F, G, H, I1, J, K>,
+    J => (A, B, C, D, E, F, G, H, I, K) + <A, B, C, D, E, F, G, H, I, J1, K>,
+    K => (A, B, C, D, E, F, G, H, I, J) + <A, B, C, D, E, F, G, H, I, J, K1>,
+});
+tuples!(EitherOf12 + EitherOf12Future + EitherOf12FutureProj {
+    A => (B, C, D, E, F, G, H, I, J, K, L) + <A1, B, C, D, E, F, G, H, I, J, K, L>,
+    B => (A, C, D, E, F, G, H, I, J, K, L) + <A, B1, C, D, E, F, G, H, I, J, K, L>,
+    C => (A, B, D, E, F, G, H, I, J, K, L) + <A, B, C1, D, E, F, G, H, I, J, K, L>,
+    D => (A, B, C, E, F, G, H, I, J, K, L) + <A, B, C, D1, E, F, G, H, I, J, K, L>,
+    E => (A, B, C, D, F, G, H, I, J, K, L) + <A, B, C, D, E1, F, G, H, I, J, K, L>,
+    F => (A, B, C, D, E, G, H, I, J, K, L) + <A, B, C, D, E, F1, G, H, I, J, K, L>,
+    G => (A, B, C, D, E, F, H, I, J, K, L) + <A, B, C, D, E, F, G1, H, I, J, K, L>,
+    H => (A, B, C, D, E, F, G, I, J, K, L) + <A, B, C, D, E, F, G, H1, I, J, K, L>,
+    I => (A, B, C, D, E, F, G, H, J, K, L) + <A, B, C, D, E, F, G, H, I1, J, K, L>,
+    J => (A, B, C, D, E, F, G, H, I, K, L) + <A, B, C, D, E, F, G, H, I, J1, K, L>,
+    K => (A, B, C, D, E, F, G, H, I, J, L) + <A, B, C, D, E, F, G, H, I, J, K1, L>,
+    L => (A, B, C, D, E, F, G, H, I, J, K) + <A, B, C, D, E, F, G, H, I, J, K, L1>,
+});
+tuples!(EitherOf13 + EitherOf13Future + EitherOf13FutureProj {
+    A => (B, C, D, E, F, G, H, I, J, K, L, M) + <A1, B, C, D, E, F, G, H, I, J, K, L, M>,
+    B => (A, C, D, E, F, G, H, I, J, K, L, M) + <A, B1, C, D, E, F, G, H, I, J, K, L, M>,
+    C => (A, B, D, E, F, G, H, I, J, K, L, M) + <A, B, C1, D, E, F, G, H, I, J, K, L, M>,
+    D => (A, B, C, E, F, G, H, I, J, K, L, M) + <A, B, C, D1, E, F, G, H, I, J, K, L, M>,
+    E => (A, B, C, D, F, G, H, I, J, K, L, M) + <A, B, C, D, E1, F, G, H, I, J, K, L, M>,
+    F => (A, B, C, D, E, G, H, I, J, K, L, M) + <A, B, C, D, E, F1, G, H, I, J, K, L, M>,
+    G => (A, B, C, D, E, F, H, I, J, K, L, M) + <A, B, C, D, E, F, G1, H, I, J, K, L, M>,
+    H => (A, B, C, D, E, F, G, I, J, K, L, M) + <A, B, C, D, E, F, G, H1, I, J, K, L, M>,
+    I => (A, B, C, D, E, F, G, H, J, K, L, M) + <A, B, C, D, E, F, G, H, I1, J, K, L, M>,
+    J => (A, B, C, D, E, F, G, H, I, K, L, M) + <A, B, C, D, E, F, G, H, I, J1, K, L, M>,
+    K => (A, B, C, D, E, F, G, H, I, J, L, M) + <A, B, C, D, E, F, G, H, I, J, K1, L, M>,
+    L => (A, B, C, D, E, F, G, H, I, J, K, M) + <A, B, C, D, E, F, G, H, I, J, K, L1, M>,
+    M => (A, B, C, D, E, F, G, H, I, J, K, L) + <A, B, C, D, E, F, G, H, I, J, K, L, M1>,
+});
+tuples!(EitherOf14 + EitherOf14Future + EitherOf14FutureProj {
+    A => (B, C, D, E, F, G, H, I, J, K, L, M, N) + <A1, B, C, D, E, F, G, H, I, J, K, L, M, N>,
+    B => (A, C, D, E, F, G, H, I, J, K, L, M, N) + <A, B1, C, D, E, F, G, H, I, J, K, L, M, N>,
+    C => (A, B, D, E, F, G, H, I, J, K, L, M, N) + <A, B, C1, D, E, F, G, H, I, J, K, L, M, N>,
+    D => (A, B, C, E, F, G, H, I, J, K, L, M, N) + <A, B, C, D1, E, F, G, H, I, J, K, L, M, N>,
+    E => (A, B, C, D, F, G, H, I, J, K, L, M, N) + <A, B, C, D, E1, F, G, H, I, J, K, L, M, N>,
+    F => (A, B, C, D, E, G, H, I, J, K, L, M, N) + <A, B, C, D, E, F1, G, H, I, J, K, L, M, N>,
+    G => (A, B, C, D, E, F, H, I, J, K, L, M, N) + <A, B, C, D, E, F, G1, H, I, J, K, L, M, N>,
+    H => (A, B, C, D, E, F, G, I, J, K, L, M, N) + <A, B, C, D, E, F, G, H1, I, J, K, L, M, N>,
+    I => (A, B, C, D, E, F, G, H, J, K, L, M, N) + <A, B, C, D, E, F, G, H, I1, J, K, L, M, N>,
+    J => (A, B, C, D, E, F, G, H, I, K, L, M, N) + <A, B, C, D, E, F, G, H, I, J1, K, L, M, N>,
+    K => (A, B, C, D, E, F, G, H, I, J, L, M, N) + <A, B, C, D, E, F, G, H, I, J, K1, L, M, N>,
+    L => (A, B, C, D, E, F, G, H, I, J, K, M, N) + <A, B, C, D, E, F, G, H, I, J, K, L1, M, N>,
+    M => (A, B, C, D, E, F, G, H, I, J, K, L, N) + <A, B, C, D, E, F, G, H, I, J, K, L, M1, N>,
+    N => (A, B, C, D, E, F, G, H, I, J, K, L, M) + <A, B, C, D, E, F, G, H, I, J, K, L, M, N1>,
+});
+tuples!(EitherOf15 + EitherOf15Future + EitherOf15FutureProj {
+    A => (B, C, D, E, F, G, H, I, J, K, L, M, N, O) + <A1, B, C, D, E, F, G, H, I, J, K, L, M, N, O>,
+    B => (A, C, D, E, F, G, H, I, J, K, L, M, N, O) + <A, B1, C, D, E, F, G, H, I, J, K, L, M, N, O>,
+    C => (A, B, D, E, F, G, H, I, J, K, L, M, N, O) + <A, B, C1, D, E, F, G, H, I, J, K, L, M, N, O>,
+    D => (A, B, C, E, F, G, H, I, J, K, L, M, N, O) + <A, B, C, D1, E, F, G, H, I, J, K, L, M, N, O>,
+    E => (A, B, C, D, F, G, H, I, J, K, L, M, N, O) + <A, B, C, D, E1, F, G, H, I, J, K, L, M, N, O>,
+    F => (A, B, C, D, E, G, H, I, J, K, L, M, N, O) + <A, B, C, D, E, F1, G, H, I, J, K, L, M, N, O>,
+    G => (A, B, C, D, E, F, H, I, J, K, L, M, N, O) + <A, B, C, D, E, F, G1, H, I, J, K, L, M, N, O>,
+    H => (A, B, C, D, E, F, G, I, J, K, L, M, N, O) + <A, B, C, D, E, F, G, H1, I, J, K, L, M, N, O>,
+    I => (A, B, C, D, E, F, G, H, J, K, L, M, N, O) + <A, B, C, D, E, F, G, H, I1, J, K, L, M, N, O>,
+    J => (A, B, C, D, E, F, G, H, I, K, L, M, N, O) + <A, B, C, D, E, F, G, H, I, J1, K, L, M, N, O>,
+    K => (A, B, C, D, E, F, G, H, I, J, L, M, N, O) + <A, B, C, D, E, F, G, H, I, J, K1, L, M, N, O>,
+    L => (A, B, C, D, E, F, G, H, I, J, K, M, N, O) + <A, B, C, D, E, F, G, H, I, J, K, L1, M, N, O>,
+    M => (A, B, C, D, E, F, G, H, I, J, K, L, N, O) + <A, B, C, D, E, F, G, H, I, J, K, L, M1, N, O>,
+    N => (A, B, C, D, E, F, G, H, I, J, K, L, M, O) + <A, B, C, D, E, F, G, H, I, J, K, L, M, N1, O>,
+    O => (A, B, C, D, E, F, G, H, I, J, K, L, M, N) + <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O1>,
+});
+tuples!(EitherOf16 + EitherOf16Future + EitherOf16FutureProj {
+    A => (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) + <A1, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>,
+    B => (A, C, D, E, F, G, H, I, J, K, L, M, N, O, P) + <A, B1, C, D, E, F, G, H, I, J, K, L, M, N, O, P>,
+    C => (A, B, D, E, F, G, H, I, J, K, L, M, N, O, P) + <A, B, C1, D, E, F, G, H, I, J, K, L, M, N, O, P>,
+    D => (A, B, C, E, F, G, H, I, J, K, L, M, N, O, P) + <A, B, C, D1, E, F, G, H, I, J, K, L, M, N, O, P>,
+    E => (A, B, C, D, F, G, H, I, J, K, L, M, N, O, P) + <A, B, C, D, E1, F, G, H, I, J, K, L, M, N, O, P>,
+    F => (A, B, C, D, E, G, H, I, J, K, L, M, N, O, P) + <A, B, C, D, E, F1, G, H, I, J, K, L, M, N, O, P>,
+    G => (A, B, C, D, E, F, H, I, J, K, L, M, N, O, P) + <A, B, C, D, E, F, G1, H, I, J, K, L, M, N, O, P>,
+    H => (A, B, C, D, E, F, G, I, J, K, L, M, N, O, P) + <A, B, C, D, E, F, G, H1, I, J, K, L, M, N, O, P>,
+    I => (A, B, C, D, E, F, G, H, J, K, L, M, N, O, P) + <A, B, C, D, E, F, G, H, I1, J, K, L, M, N, O, P>,
+    J => (A, B, C, D, E, F, G, H, I, K, L, M, N, O, P) + <A, B, C, D, E, F, G, H, I, J1, K, L, M, N, O, P>,
+    K => (A, B, C, D, E, F, G, H, I, J, L, M, N, O, P) + <A, B, C, D, E, F, G, H, I, J, K1, L, M, N, O, P>,
+    L => (A, B, C, D, E, F, G, H, I, J, K, M, N, O, P) + <A, B, C, D, E, F, G, H, I, J, K, L1, M, N, O, P>,
+    M => (A, B, C, D, E, F, G, H, I, J, K, L, N, O, P) + <A, B, C, D, E, F, G, H, I, J, K, L, M1, N, O, P>,
+    N => (A, B, C, D, E, F, G, H, I, J, K, L, M, O, P) + <A, B, C, D, E, F, G, H, I, J, K, L, M, N1, O, P>,
+    O => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, P) + <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O1, P>,
+    P => (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) + <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P1>,
+});
+
+/// Matches over the first expression and returns an either ([`Either`], [`EitherOf3`], ... [`EitherOf8`])
+/// composed of the values returned by the match arms.
+///
+/// The pattern syntax is exactly the same as found in a match arm.
+///
+/// # Examples
+///
+/// ```
+/// # use either_of::*;
+/// let either2 = either!(Some("hello"),
+///     Some(s) => s.len(),
+///     None => 0.0,
+/// );
+/// assert!(matches!(either2, Either::<usize, f64>::Left(5)));
+///
+/// let either3 = either!(Some("admin"),
+///     Some("admin") => "hello admin",
+///     Some(_) => 'x',
+///     _ => 0,
+/// );
+/// assert!(matches!(either3, EitherOf3::<&str, char, i32>::A("hello admin")));
+/// ```
+#[macro_export]
+macro_rules! either {
+    ($match:expr, $left_pattern:pat => $left_expression:expr, $right_pattern:pat => $right_expression:expr,) => {
+        match $match {
+            $left_pattern => $crate::Either::Left($left_expression),
+            $right_pattern => $crate::Either::Right($right_expression),
+        }
+    };
+    ($match:expr, $a_pattern:pat => $a_expression:expr, $b_pattern:pat => $b_expression:expr, $c_pattern:pat => $c_expression:expr,) => {
+        match $match {
+            $a_pattern => $crate::EitherOf3::A($a_expression),
+            $b_pattern => $crate::EitherOf3::B($b_expression),
+            $c_pattern => $crate::EitherOf3::C($c_expression),
+        }
+    };
+    ($match:expr, $a_pattern:pat => $a_expression:expr, $b_pattern:pat => $b_expression:expr, $c_pattern:pat => $c_expression:expr, $d_pattern:pat => $d_expression:expr,) => {
+        match $match {
+            $a_pattern => $crate::EitherOf4::A($a_expression),
+            $b_pattern => $crate::EitherOf4::B($b_expression),
+            $c_pattern => $crate::EitherOf4::C($c_expression),
+            $d_pattern => $crate::EitherOf4::D($d_expression),
+        }
+    };
+    ($match:expr, $a_pattern:pat => $a_expression:expr, $b_pattern:pat => $b_expression:expr, $c_pattern:pat => $c_expression:expr, $d_pattern:pat => $d_expression:expr, $e_pattern:pat => $e_expression:expr,) => {
+        match $match {
+            $a_pattern => $crate::EitherOf5::A($a_expression),
+            $b_pattern => $crate::EitherOf5::B($b_expression),
+            $c_pattern => $crate::EitherOf5::C($c_expression),
+            $d_pattern => $crate::EitherOf5::D($d_expression),
+            $e_pattern => $crate::EitherOf5::E($e_expression),
+        }
+    };
+    ($match:expr, $a_pattern:pat => $a_expression:expr, $b_pattern:pat => $b_expression:expr, $c_pattern:pat => $c_expression:expr, $d_pattern:pat => $d_expression:expr, $e_pattern:pat => $e_expression:expr, $f_pattern:pat => $f_expression:expr,) => {
+        match $match {
+            $a_pattern => $crate::EitherOf6::A($a_expression),
+            $b_pattern => $crate::EitherOf6::B($b_expression),
+            $c_pattern => $crate::EitherOf6::C($c_expression),
+            $d_pattern => $crate::EitherOf6::D($d_expression),
+            $e_pattern => $crate::EitherOf6::E($e_expression),
+            $f_pattern => $crate::EitherOf6::F($f_expression),
+        }
+    };
+    ($match:expr, $a_pattern:pat => $a_expression:expr, $b_pattern:pat => $b_expression:expr, $c_pattern:pat => $c_expression:expr, $d_pattern:pat => $d_expression:expr, $e_pattern:pat => $e_expression:expr, $f_pattern:pat => $f_expression:expr, $g_pattern:pat => $g_expression:expr,) => {
+        match $match {
+            $a_pattern => $crate::EitherOf7::A($a_expression),
+            $b_pattern => $crate::EitherOf7::B($b_expression),
+            $c_pattern => $crate::EitherOf7::C($c_expression),
+            $d_pattern => $crate::EitherOf7::D($d_expression),
+            $e_pattern => $crate::EitherOf7::E($e_expression),
+            $f_pattern => $crate::EitherOf7::F($f_expression),
+            $g_pattern => $crate::EitherOf7::G($g_expression),
+        }
+    };
+    ($match:expr, $a_pattern:pat => $a_expression:expr, $b_pattern:pat => $b_expression:expr, $c_pattern:pat => $c_expression:expr, $d_pattern:pat => $d_expression:expr, $e_pattern:pat => $e_expression:expr, $f_pattern:pat => $f_expression:expr, $g_pattern:pat => $g_expression:expr, $h_pattern:pat => $h_expression:expr,) => {
+        match $match {
+            $a_pattern => $crate::EitherOf8::A($a_expression),
+            $b_pattern => $crate::EitherOf8::B($b_expression),
+            $c_pattern => $crate::EitherOf8::C($c_expression),
+            $d_pattern => $crate::EitherOf8::D($d_expression),
+            $e_pattern => $crate::EitherOf8::E($e_expression),
+            $f_pattern => $crate::EitherOf8::F($f_expression),
+            $g_pattern => $crate::EitherOf8::G($g_expression),
+            $h_pattern => $crate::EitherOf8::H($h_expression),
+        }
+    }; // if you need more eithers feel free to open a PR ;-)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // compile time test
+    #[test]
+    fn either_macro() {
+        let _: Either<&str, f64> = either!(12,
+            12 => "12",
+            _ => 0.0,
+        );
+        let _: EitherOf3<&str, f64, i32> = either!(12,
+            12 => "12",
+            13 => 0.0,
+            _ => 12,
+        );
+        let _: EitherOf4<&str, f64, char, i32> = either!(12,
+            12 => "12",
+            13 => 0.0,
+            14 => ' ',
+            _ => 12,
+        );
+        let _: EitherOf5<&str, f64, char, f32, i32> = either!(12,
+            12 => "12",
+            13 => 0.0,
+            14 => ' ',
+            15 => 0.0f32,
+            _ => 12,
+        );
+        let _: EitherOf6<&str, f64, char, f32, u8, i32> = either!(12,
+            12 => "12",
+            13 => 0.0,
+            14 => ' ',
+            15 => 0.0f32,
+            16 => 24u8,
+            _ => 12,
+        );
+        let _: EitherOf7<&str, f64, char, f32, u8, i8, i32> = either!(12,
+            12 => "12",
+            13 => 0.0,
+            14 => ' ',
+            15 => 0.0f32,
+            16 => 24u8,
+            17 => 2i8,
+            _ => 12,
+        );
+        let _: EitherOf8<&str, f64, char, f32, u8, i8, u32, i32> = either!(12,
+            12 => "12",
+            13 => 0.0,
+            14 => ' ',
+            15 => 0.0f32,
+            16 => 24u8,
+            17 => 2i8,
+            18 => 42u32,
+            _ => 12,
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn unwrap_wrong_either() {
+        Either::<i32, &str>::Left(0).unwrap_right();
+    }
+}

examples/axum_js_ssr/node_modules/@highlightjs/cdn-assets/es/highlight.min.js

@@ -1227,4 +1227,4 @@ begin:"\\b[0-9]{4}(-[0-9][0-9]){0,2}([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?(\\.[0
 ;return c.pop(),c.push(i),r.contains=c,{name:"YAML",case_insensitive:!0,
 aliases:["yml"],contains:l}}});const Ke=te;for(const e of Object.keys(Pe)){
 const n=e.replace("grmr_","").replace("_","-");Ke.registerLanguage(n,Pe[e])}
-export{Ke as default};
+export{Ke as defaultMod};

examples/axum_js_ssr/src/app.rs

@@ -32,7 +32,6 @@ pub fn App() -> impl IntoView {
     // Provides context that manages stylesheets, titles, meta tags, etc.
     provide_meta_context();
     let fallback = || view! { "Page not found." }.into_view();
-    let ssr = SsrMode::Async;
 
     view! {
         <Stylesheet id="leptos" href="/pkg/axum_js_ssr.css"/>
@@ -79,19 +78,19 @@ pub fn App() -> impl IntoView {
                     <h1>"Leptos JavaScript Integration Demo with SSR in Axum"</h1>
                     <FlatRoutes fallback>
                         <Route path=path!("") view=HomePage/>
-                        <Route path=path!("naive") view=Naive ssr/>
-                        <Route path=path!("naive-alt") view=|| view! { <NaiveEvent/> } ssr/>
-                        <Route path=path!("naive-hook") view=|| view! { <NaiveEvent hook=true/> } ssr/>
+                        <Route path=path!("naive") view=Naive ssr=SsrMode::Async/>
+                        <Route path=path!("naive-alt") view=|| view! { <NaiveEvent/> } ssr=SsrMode::Async/>
+                        <Route path=path!("naive-hook") view=|| view! { <NaiveEvent hook=true/> } ssr=SsrMode::Async/>
                         <Route path=path!("naive-fallback") view=|| view! {
                             <NaiveEvent hook=true fallback=true/>
-                        } ssr/>
-                        <Route path=path!("signal-effect-script") view=CodeDemoSignalEffect ssr/>
-                        <Route path=path!("custom-event") view=CustomEvent ssr/>
-                        <Route path=path!("wasm-bindgen-naive") view=WasmBindgenNaive ssr/>
-                        <Route path=path!("wasm-bindgen-event") view=WasmBindgenJSHookReadyEvent ssr/>
-                        <Route path=path!("wasm-bindgen-effect") view=WasmBindgenEffect ssr/>
-                        <Route path=path!("wasm-bindgen-direct") view=WasmBindgenDirect ssr/>
-                        <Route path=path!("wasm-bindgen-direct-fixed") view=WasmBindgenDirectFixed ssr/>
+                        } ssr=SsrMode::Async/>
+                        <Route path=path!("signal-effect-script") view=CodeDemoSignalEffect ssr=SsrMode::Async/>
+                        <Route path=path!("custom-event") view=CustomEvent ssr=SsrMode::Async/>
+                        <Route path=path!("wasm-bindgen-naive") view=WasmBindgenNaive ssr=SsrMode::Async/>
+                        <Route path=path!("wasm-bindgen-event") view=WasmBindgenJSHookReadyEvent ssr=SsrMode::Async/>
+                        <Route path=path!("wasm-bindgen-effect") view=WasmBindgenEffect ssr=SsrMode::Async/>
+                        <Route path=path!("wasm-bindgen-direct") view=WasmBindgenDirect ssr=SsrMode::Async/>
+                        <Route path=path!("wasm-bindgen-direct-fixed") view=WasmBindgenDirectFixed ssr=SsrMode::Async/>
                     </FlatRoutes>
                 </article>
             </main>

examples/axum_js_ssr/src/hljs.rs

@@ -13,13 +13,13 @@ mod csr {
     extern "C" {
         type HighlightOptions;
 
-        #[wasm_bindgen(catch, js_namespace = default, js_name = highlight)]
+        #[wasm_bindgen(catch, js_namespace = defaultMod, js_name = highlight)]
         fn highlight_lang(
             code: String,
             options: Object,
         ) -> Result<Object, JsValue>;
 
-        #[wasm_bindgen(js_namespace = default, js_name = highlightAll)]
+        #[wasm_bindgen(js_namespace = defaultMod, js_name = highlightAll)]
         pub fn highlight_all();
     }
 

examples/axum_js_ssr/src/main.rs

@@ -26,6 +26,7 @@ async fn main() {
     };
     use axum_js_ssr::app::*;
     use http_body_util::BodyExt;
+    use leptos::logging::log;
     use leptos::prelude::*;
     use leptos_axum::{generate_route_list, LeptosRoutes};
 

examples/cargo-make/cargo-leptos.toml

@@ -1,5 +1,6 @@
 [tasks.install-cargo-leptos]
 install_crate = { crate_name = "cargo-leptos", binary = "cargo-leptos", test_arg = "--help" }
+args = ["--locked"]
 
 [tasks.cargo-leptos-e2e]
 command = "cargo"

examples/counter/tests/web.rs

@@ -1,7 +1,9 @@
+#![allow(dead_code)]
+
 use counter::*;
 use leptos::mount::mount_to;
 use leptos::prelude::*;
-use leptos::spawn::tick;
+use leptos::task::tick;
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 

examples/counter_isomorphic/Cargo.toml

@@ -2,6 +2,8 @@
 name = "counter_isomorphic"
 version = "0.1.0"
 edition = "2021"
+# std::sync::LazyLock is stabilized in Rust version 1.80.0
+rust-version = "1.80.0"
 
 [lib]
 crate-type = ["cdylib", "rlib"]
@@ -17,7 +19,6 @@ broadcaster = "1.0"
 console_log = "1.0"
 console_error_panic_hook = "0.1.7"
 futures = "0.3.30"
-lazy_static = "1.5"
 leptos = { path = "../../leptos" }
 leptos_actix = { path = "../../integrations/actix", optional = true }
 leptos_router = { path = "../../router" }
@@ -46,13 +47,13 @@ denylist = ["actix-files", "actix-web", "leptos_actix"]
 skip_feature_sets = [["ssr", "hydrate"]]
 
 [package.metadata.leptos]
-# The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
+# The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name
 output-name = "counter_isomorphic"
 # The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
 # When NOT using cargo-leptos this must be updated to "." or the counters will not work. The above warning still applies if you do switch to cargo-leptos later.
 site-root = "target/site"
 # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
-# Defaults to pkg	
+# Defaults to pkg
 site-pkg-dir = "pkg"
 # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
 # style-file = "src/styles/tailwind.css"

examples/counter_isomorphic/src/counters.rs

@@ -1,4 +1,4 @@
-use leptos::{prelude::*, reactive_graph::actions::Action};
+use leptos::prelude::*;
 use leptos_router::{
     components::{FlatRoutes, Route, Router, A},
     StaticSegment,
@@ -10,12 +10,12 @@ use tracing::instrument;
 pub mod ssr_imports {
     pub use broadcaster::BroadcastChannel;
     pub use std::sync::atomic::{AtomicI32, Ordering};
+    use std::sync::LazyLock;
 
     pub static COUNT: AtomicI32 = AtomicI32::new(0);
 
-    lazy_static::lazy_static! {
-        pub static ref COUNT_CHANNEL: BroadcastChannel<i32> = BroadcastChannel::new();
-    }
+    pub static COUNT_CHANNEL: LazyLock<BroadcastChannel<i32>> =
+        LazyLock::new(BroadcastChannel::<i32>::new);
 }
 
 #[server]

examples/counter_isomorphic/src/main.rs

@@ -63,7 +63,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root))
+            .service(Files::new("/", site_root.as_ref()))
     })
     .bind(&addr)?
     .run()

examples/counter_without_macros/tests/web.rs

@@ -1,5 +1,7 @@
+#![allow(dead_code)]
+
 use counter_without_macros::counter;
-use leptos::{prelude::*, spawn::tick};
+use leptos::{prelude::*, task::tick};
 use pretty_assertions::assert_eq;
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;

examples/counters/tests/web.rs

@@ -1,10 +1,12 @@
+#![allow(dead_code)]
+
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 
 wasm_bindgen_test_configure!(run_in_browser);
 use counters::Counters;
 use leptos::prelude::*;
-use leptos::spawn::tick;
+use leptos::task::tick;
 use web_sys::HtmlElement;
 
 #[wasm_bindgen_test]

examples/directives/tests/web.rs

@@ -1,5 +1,7 @@
+#![allow(dead_code)]
+
 use directives::App;
-use leptos::{prelude::*, spawn::tick};
+use leptos::{prelude::*, task::tick};
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 use web_sys::HtmlElement;

examples/errors_axum/src/error_template.rs

@@ -6,9 +6,7 @@ use leptos_axum::ResponseOptions;
 // A basic function to display errors served by the error boundaries.
 // Feel free to do more complicated things here than just displaying them.
 #[component]
-pub fn ErrorTemplate(
-    #[prop(into)] errors: MaybeSignal<Errors>,
-) -> impl IntoView {
+pub fn ErrorTemplate(#[prop(into)] errors: Signal<Errors>) -> impl IntoView {
     // Get Errors from Signal
     // Downcast lets us take a type that implements `std::error::Error`
     let errors = Memo::new(move |_| {

examples/gtk/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "gtk"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-leptos = { path = "../../leptos" }
-throw_error = { path = "../../any_error/" }
-
-# these are used to build the integration
-gtk = { version = "0.9.0", package = "gtk4" }
-next_tuple = { path = "../../next_tuple/" }
-paste = "1.0"
-
-# we want to support using glib for the reactive runtime event loop
-any_spawner = { path = "../../any_spawner/", features = ["glib"] }
-# yes, we want effects to run: this is a "frontend," not a backend
-reactive_graph = { path = "../../reactive_graph", features = ["effects"] }

examples/gtk/index.html

@@ -1,8 +0,0 @@
-<!DOCTYPE html>
-<html>
-	<head>
-		<meta name="color-scheme" content="dark">
-		<link rel="css" href="style.css" data-trunk>
-	</head>
-	<body></body>
-</html>

examples/gtk/src/leptos_gtk.rs

@@ -1,627 +0,0 @@
-use self::properties::Connect;
-use gtk::{
-    ffi::GtkWidget,
-    glib::{
-        object::{IsA, IsClass, ObjectExt},
-        Object, Value,
-    },
-    prelude::{Cast, WidgetExt},
-    Label, Orientation, Widget,
-};
-use leptos::{
-    reactive_graph::effect::RenderEffect,
-    tachys::{
-        renderer::{CastFrom, Renderer},
-        view::{Mountable, Render},
-    },
-};
-use next_tuple::NextTuple;
-use std::{borrow::Cow, marker::PhantomData};
-
-#[derive(Debug)]
-pub struct LeptosGtk;
-
-#[derive(Debug, Clone)]
-pub struct Element(pub Widget);
-
-impl Element {
-    pub fn remove(&self) {
-        self.0.unparent();
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct Text(pub Element);
-
-impl<T> From<T> for Element
-where
-    T: Into<Widget>,
-{
-    fn from(value: T) -> Self {
-        Element(value.into())
-    }
-}
-
-impl Mountable<LeptosGtk> for Element {
-    fn unmount(&mut self) {
-        self.remove()
-    }
-
-    fn mount(
-        &mut self,
-        parent: &<LeptosGtk as Renderer>::Element,
-        marker: Option<&<LeptosGtk as Renderer>::Node>,
-    ) {
-        self.0
-            .insert_before(&parent.0, marker.as_ref().map(|m| &m.0));
-    }
-
-    fn insert_before_this(&self, child: &mut dyn Mountable<LeptosGtk>) -> bool {
-        if let Some(parent) = self.0.parent() {
-            child.mount(&Element(parent), Some(self));
-            return true;
-        }
-        false
-    }
-}
-
-impl Mountable<LeptosGtk> for Text {
-    fn unmount(&mut self) {
-        self.0.remove()
-    }
-
-    fn mount(
-        &mut self,
-        parent: &<LeptosGtk as Renderer>::Element,
-        marker: Option<&<LeptosGtk as Renderer>::Node>,
-    ) {
-        self.0
-             .0
-            .insert_before(&parent.0, marker.as_ref().map(|m| &m.0));
-    }
-
-    fn insert_before_this(&self, child: &mut dyn Mountable<LeptosGtk>) -> bool {
-        self.0.insert_before_this(child)
-    }
-}
-
-impl CastFrom<Element> for Element {
-    fn cast_from(source: Element) -> Option<Self> {
-        Some(source)
-    }
-}
-
-impl CastFrom<Element> for Text {
-    fn cast_from(source: Element) -> Option<Self> {
-        source
-            .0
-            .downcast::<Label>()
-            .ok()
-            .map(|n| Text(Element::from(n)))
-    }
-}
-
-impl AsRef<Element> for Element {
-    fn as_ref(&self) -> &Element {
-        self
-    }
-}
-
-impl AsRef<Element> for Text {
-    fn as_ref(&self) -> &Element {
-        &self.0
-    }
-}
-
-impl Renderer for LeptosGtk {
-    type Node = Element;
-    type Element = Element;
-    type Text = Text;
-    type Placeholder = Element;
-
-    fn intern(text: &str) -> &str {
-        text
-    }
-
-    fn create_text_node(text: &str) -> Self::Text {
-        Text(Element::from(Label::new(Some(text))))
-    }
-
-    fn create_placeholder() -> Self::Placeholder {
-        let label = Label::new(None);
-        label.set_visible(false);
-        Element::from(label)
-    }
-
-    fn set_text(node: &Self::Text, text: &str) {
-        let node_as_text = node.0 .0.downcast_ref::<Label>().unwrap();
-        node_as_text.set_label(text);
-    }
-
-    fn set_attribute(node: &Self::Element, name: &str, value: &str) {
-        node.0.set_property(name, value);
-    }
-
-    fn remove_attribute(node: &Self::Element, name: &str) {
-        node.0.set_property(name, None::<&str>);
-    }
-
-    fn insert_node(
-        parent: &Self::Element,
-        new_child: &Self::Node,
-        marker: Option<&Self::Node>,
-    ) {
-        new_child
-            .0
-            .insert_before(&parent.0, marker.as_ref().map(|n| &n.0));
-    }
-
-    fn remove_node(
-        parent: &Self::Element,
-        child: &Self::Node,
-    ) -> Option<Self::Node> {
-        todo!()
-    }
-
-    fn remove(node: &Self::Node) {
-        todo!()
-    }
-
-    fn get_parent(node: &Self::Node) -> Option<Self::Node> {
-        node.0.parent().map(Element::from)
-    }
-
-    fn first_child(node: &Self::Node) -> Option<Self::Node> {
-        todo!()
-    }
-
-    fn next_sibling(node: &Self::Node) -> Option<Self::Node> {
-        todo!()
-    }
-
-    fn log_node(node: &Self::Node) {
-        todo!()
-    }
-
-    fn clear_children(parent: &Self::Element) {
-        todo!()
-    }
-}
-
-pub fn root<Chil>(children: Chil) -> (Widget, impl Mountable<LeptosGtk>)
-where
-    Chil: Render<LeptosGtk>,
-{
-    let state = r#box()
-        .orientation(Orientation::Vertical)
-        .spacing(12)
-        .child(children)
-        .build();
-    (state.as_widget().clone(), state)
-}
-
-pub trait WidgetClass {
-    type Widget: Into<Widget> + IsA<Object> + IsClass;
-}
-
-pub struct LGtkWidget<Widg, Props, Chil> {
-    widget: PhantomData<Widg>,
-    properties: Props,
-    children: Chil,
-}
-
-impl<Widg, Props, Chil> LGtkWidget<Widg, Props, Chil>
-where
-    Widg: WidgetClass,
-    Chil: NextTuple,
-{
-    pub fn child<T>(
-        self,
-        child: T,
-    ) -> LGtkWidget<Widg, Props, Chil::Output<T>> {
-        let LGtkWidget {
-            widget,
-            properties,
-            children,
-        } = self;
-        LGtkWidget {
-            widget,
-            properties,
-            children: children.next_tuple(child),
-        }
-    }
-}
-impl<Widg, Props, Chil> LGtkWidget<Widg, Props, Chil>
-where
-    Widg: WidgetClass,
-    Props: NextTuple,
-    Chil: Render<LeptosGtk>,
-{
-    pub fn connect<F>(
-        self,
-        signal_name: &'static str,
-        callback: F,
-    ) -> LGtkWidget<Widg, Props::Output<Connect<F>>, Chil>
-    where
-        F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
-    {
-        let LGtkWidget {
-            widget,
-            properties,
-            children,
-        } = self;
-        LGtkWidget {
-            widget,
-            properties: properties.next_tuple(Connect {
-                signal_name,
-                callback,
-            }),
-            children,
-        }
-    }
-}
-
-pub struct LGtkWidgetState<Widg, Props, Chil>
-where
-    Chil: Render<LeptosGtk>,
-    Props: Property,
-    Widg: WidgetClass,
-{
-    ty: PhantomData<Widg>,
-    widget: Element,
-    properties: Props::State,
-    children: Chil::State,
-}
-
-impl<Widg, Props, Chil> LGtkWidgetState<Widg, Props, Chil>
-where
-    Chil: Render<LeptosGtk>,
-    Props: Property,
-    Widg: WidgetClass,
-{
-    pub fn as_widget(&self) -> &Widget {
-        &self.widget.0
-    }
-}
-
-impl<Widg, Props, Chil> Render<LeptosGtk> for LGtkWidget<Widg, Props, Chil>
-where
-    Widg: WidgetClass,
-    Props: Property,
-    Chil: Render<LeptosGtk>,
-{
-    type State = LGtkWidgetState<Widg, Props, Chil>;
-
-    fn build(self) -> Self::State {
-        let widget = Object::new::<Widg::Widget>();
-        let widget = Element::from(widget);
-        let properties = self.properties.build(&widget);
-        let mut children = self.children.build();
-        children.mount(&widget, None);
-        LGtkWidgetState {
-            ty: PhantomData,
-            widget,
-            properties,
-            children,
-        }
-    }
-
-    fn rebuild(self, state: &mut Self::State) {
-        self.properties
-            .rebuild(&state.widget, &mut state.properties);
-        self.children.rebuild(&mut state.children);
-    }
-}
-
-impl<Widg, Props, Chil> Mountable<LeptosGtk>
-    for LGtkWidgetState<Widg, Props, Chil>
-where
-    Widg: WidgetClass,
-    Props: Property,
-    Chil: Render<LeptosGtk>,
-{
-    fn unmount(&mut self) {
-        self.children.unmount();
-        self.widget.remove();
-    }
-
-    fn mount(
-        &mut self,
-        parent: &<LeptosGtk as Renderer>::Element,
-        marker: Option<&<LeptosGtk as Renderer>::Node>,
-    ) {
-        self.children.mount(&self.widget, None);
-        LeptosGtk::insert_node(parent, &self.widget, marker);
-    }
-
-    fn insert_before_this(&self, child: &mut dyn Mountable<LeptosGtk>) -> bool {
-        self.widget.insert_before_this(child)
-    }
-}
-
-pub trait Property {
-    type State;
-
-    fn build(self, element: &Element) -> Self::State;
-
-    fn rebuild(self, element: &Element, state: &mut Self::State);
-}
-
-impl<T, F> Property for F
-where
-    T: Property,
-    T::State: 'static,
-    F: Fn() -> T + 'static,
-{
-    type State = RenderEffect<T::State>;
-
-    fn build(self, widget: &Element) -> Self::State {
-        let widget = widget.clone();
-        RenderEffect::new(move |prev| {
-            let value = self();
-            if let Some(mut prev) = prev {
-                value.rebuild(&widget, &mut prev);
-                prev
-            } else {
-                value.build(&widget)
-            }
-        })
-    }
-
-    fn rebuild(self, widget: &Element, state: &mut Self::State) {}
-}
-
-pub fn button() -> LGtkWidget<gtk::Button, (), ()> {
-    LGtkWidget {
-        widget: PhantomData,
-        properties: (),
-        children: (),
-    }
-}
-
-pub fn r#box() -> LGtkWidget<gtk::Box, (), ()> {
-    LGtkWidget {
-        widget: PhantomData,
-        properties: (),
-        children: (),
-    }
-}
-
-mod widgets {
-    use super::WidgetClass;
-
-    impl WidgetClass for gtk::Button {
-        type Widget = Self;
-    }
-
-    impl WidgetClass for gtk::Box {
-        type Widget = Self;
-    }
-}
-
-pub mod properties {
-    use super::{
-        Element, LGtkWidget, LGtkWidgetState, LeptosGtk, Property, WidgetClass,
-    };
-    use gtk::glib::{object::ObjectExt, Value};
-    use leptos::tachys::{renderer::Renderer, view::Render};
-    use next_tuple::NextTuple;
-
-    pub struct Connect<F>
-    where
-        F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
-    {
-        pub signal_name: &'static str,
-        pub callback: F,
-    }
-
-    impl<F> Property for Connect<F>
-    where
-        F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
-    {
-        type State = ();
-
-        fn build(self, element: &Element) -> Self::State {
-            element.0.connect(self.signal_name, false, self.callback);
-        }
-
-        fn rebuild(self, element: &Element, state: &mut Self::State) {}
-    }
-
-    /* examples for macro */
-    pub struct Orientation {
-        value: gtk::Orientation,
-    }
-
-    pub struct OrientationState {
-        value: gtk::Orientation,
-    }
-
-    impl Property for Orientation {
-        type State = OrientationState;
-
-        fn build(self, element: &Element) -> Self::State {
-            element.0.set_property("orientation", self.value);
-            OrientationState { value: self.value }
-        }
-
-        fn rebuild(self, element: &Element, state: &mut Self::State) {
-            if self.value != state.value {
-                element.0.set_property("orientation", self.value);
-                state.value = self.value;
-            }
-        }
-    }
-
-    impl<Widg, Props, Chil> LGtkWidget<Widg, Props, Chil>
-    where
-        Widg: WidgetClass,
-        Props: NextTuple,
-        Chil: Render<LeptosGtk>,
-    {
-        pub fn orientation(
-            self,
-            value: impl Into<gtk::Orientation>,
-        ) -> LGtkWidget<Widg, Props::Output<Orientation>, Chil> {
-            let LGtkWidget {
-                widget,
-                properties,
-                children,
-            } = self;
-            LGtkWidget {
-                widget,
-                properties: properties.next_tuple(Orientation {
-                    value: value.into(),
-                }),
-                children,
-            }
-        }
-    }
-
-    pub struct Spacing {
-        value: i32,
-    }
-
-    pub struct SpacingState {
-        value: i32,
-    }
-
-    impl Property for Spacing {
-        type State = SpacingState;
-
-        fn build(self, element: &Element) -> Self::State {
-            element.0.set_property("spacing", self.value);
-            SpacingState { value: self.value }
-        }
-
-        fn rebuild(self, element: &Element, state: &mut Self::State) {
-            if self.value != state.value {
-                element.0.set_property("spacing", self.value);
-                state.value = self.value;
-            }
-        }
-    }
-
-    impl<Widg, Props, Chil> LGtkWidget<Widg, Props, Chil>
-    where
-        Widg: WidgetClass,
-        Props: NextTuple,
-        Chil: Render<LeptosGtk>,
-    {
-        pub fn spacing(
-            self,
-            value: impl Into<i32>,
-        ) -> LGtkWidget<Widg, Props::Output<Spacing>, Chil> {
-            let LGtkWidget {
-                widget,
-                properties,
-                children,
-            } = self;
-            LGtkWidget {
-                widget,
-                properties: properties.next_tuple(Spacing {
-                    value: value.into(),
-                }),
-                children,
-            }
-        }
-    }
-
-    /* end examples for properties macro */
-
-    pub struct Label {
-        value: String,
-    }
-
-    impl Label {
-        pub fn new(value: impl Into<String>) -> Self {
-            Self {
-                value: value.into(),
-            }
-        }
-    }
-
-    pub struct LabelState {
-        value: String,
-    }
-
-    impl Property for Label {
-        type State = LabelState;
-
-        fn build(self, element: &Element) -> Self::State {
-            LeptosGtk::set_attribute(element, "label", &self.value);
-            LabelState { value: self.value }
-        }
-
-        fn rebuild(self, element: &Element, state: &mut Self::State) {
-            todo!()
-        }
-    }
-
-    impl Property for () {
-        type State = ();
-
-        fn build(self, _element: &Element) -> Self::State {}
-
-        fn rebuild(self, _element: &Element, _state: &mut Self::State) {}
-    }
-
-    macro_rules! tuples {
-        ($($ty:ident),* $(,)?) => {
-            impl<$($ty,)*> Property for ($($ty,)*)
-                where $($ty: Property,)*
-            {
-                type State = ($($ty::State,)*);
-
-                fn build(self, element: &Element) -> Self::State {
-                    #[allow(non_snake_case)]
-                    let ($($ty,)*) = self;
-                    ($($ty.build(element),)*)
-                }
-
-                fn rebuild(self, element: &Element, state: &mut Self::State) {
-                    paste::paste! {
-                        #[allow(non_snake_case)]
-                        let ($($ty,)*) = self;
-                        #[allow(non_snake_case)]
-                        let ($([<state_ $ty:lower>],)*) = state;
-                        $($ty.rebuild(element, [<state_ $ty:lower>]));*
-                    }
-                }
-            }
-        }
-    }
-
-    tuples!(A);
-    tuples!(A, B);
-    tuples!(A, B, C);
-    tuples!(A, B, C, D);
-    tuples!(A, B, C, D, E);
-    tuples!(A, B, C, D, E, F);
-    tuples!(A, B, C, D, E, F, G);
-    tuples!(A, B, C, D, E, F, G, H);
-    tuples!(A, B, C, D, E, F, G, H, I);
-    tuples!(A, B, C, D, E, F, G, H, I, J);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U);
-    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V);
-    tuples!(
-        A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W
-    );
-    tuples!(
-        A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X
-    );
-    tuples!(
-        A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X,
-        Y
-    );
-}

examples/gtk/src/main.rs

@@ -1,107 +0,0 @@
-use any_spawner::Executor;
-use gtk::{prelude::*, Application, ApplicationWindow, Orientation};
-use leptos::prelude::*;
-use leptos_gtk::LeptosGtk;
-use std::{mem, thread, time::Duration};
-mod leptos_gtk;
-
-const APP_ID: &str = "dev.leptos.Counter";
-
-// Basic GTK app setup from https://gtk-rs.org/gtk4-rs/stable/latest/book/hello_world.html
-fn main() {
-    // use the glib event loop to power the reactive system
-    _ = Executor::init_glib();
-    let app = Application::builder().application_id(APP_ID).build();
-
-    app.connect_startup(|_| load_css());
-
-    app.connect_activate(|app| {
-        // Connect to "activate" signal of `app`
-        let owner = Owner::new();
-        let view = owner.with(ui);
-        let (root, state) = leptos_gtk::root(view);
-
-        let window = ApplicationWindow::builder()
-            .application(app)
-            .title("TachyGTK")
-            .child(&root)
-            .build();
-        // Present window
-        window.present();
-        mem::forget((owner, state));
-    });
-
-    app.run();
-}
-
-fn ui() -> impl Render<LeptosGtk> {
-    let value = RwSignal::new(0);
-    let rows = RwSignal::new(vec![1, 2, 3, 4, 5]);
-
-    Effect::new(move |_| {
-        println!("value = {}", value.get());
-    });
-
-    // just an example of multithreaded reactivity
-    thread::spawn(move || loop {
-        thread::sleep(Duration::from_millis(250));
-        value.update(|n| *n += 1);
-    });
-
-    vstack((
-        hstack((
-            button("-1", move || {
-                println!("clicked -1");
-                value.update(|n| *n -= 1);
-            }),
-            move || value.get().to_string(),
-            button("+1", move || value.update(|n| *n += 1)),
-        )),
-        button("Swap", move || {
-            rows.update(|items| {
-                items.swap(1, 3);
-            })
-        }),
-        hstack(rows),
-    ))
-}
-
-fn button(
-    label: impl Render<LeptosGtk>,
-    callback: impl Fn() + Send + Sync + 'static,
-) -> impl Render<LeptosGtk> {
-    leptos_gtk::button()
-        .child(label)
-        .connect("clicked", move |_| {
-            callback();
-            None
-        })
-}
-
-fn vstack(children: impl Render<LeptosGtk>) -> impl Render<LeptosGtk> {
-    leptos_gtk::r#box()
-        .orientation(Orientation::Vertical)
-        .spacing(12)
-        .child(children)
-}
-
-fn hstack(children: impl Render<LeptosGtk>) -> impl Render<LeptosGtk> {
-    leptos_gtk::r#box()
-        .orientation(Orientation::Horizontal)
-        .spacing(12)
-        .child(children)
-}
-
-fn load_css() {
-    use gtk::{gdk::Display, CssProvider};
-
-    let provider = CssProvider::new();
-    provider.load_from_path("style.css");
-
-    // Add the provider to the default screen
-    gtk::style_context_add_provider_for_display(
-        &Display::default().expect("Could not connect to a display."),
-        &provider,
-        gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
-    );
-}

examples/hackernews/src/lib.rs

@@ -4,7 +4,7 @@ mod routes;
 use leptos_meta::{provide_meta_context, Link, Meta, Stylesheet};
 use leptos_router::{
     components::{FlatRoutes, Route, Router, RoutingProgress},
-    ParamSegment, StaticSegment,
+    OptionalParamSegment, ParamSegment, StaticSegment,
 };
 use routes::{nav::*, stories::*, story::*, users::*};
 use std::time::Duration;
@@ -28,9 +28,7 @@ pub fn App() -> impl IntoView {
                 <FlatRoutes fallback=|| "Not found.">
                     <Route path=(StaticSegment("users"), ParamSegment("id")) view=User/>
                     <Route path=(StaticSegment("stories"), ParamSegment("id")) view=Story/>
-                    <Route path=ParamSegment("stories") view=Stories/>
-                    // TODO allow optional params without duplication
-                    <Route path=StaticSegment("") view=Stories/>
+                    <Route path=OptionalParamSegment("stories") view=Stories/>
                 </FlatRoutes>
             </main>
         </Router>

examples/hackernews/src/main.rs

@@ -56,7 +56,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root))
+            .service(Files::new("/", site_root.as_ref()))
         //.wrap(middleware::Compress::default())
     })
     .bind(&addr)?

examples/hackernews/src/routes/nav.rs

@@ -21,10 +21,16 @@ pub fn Nav() -> impl IntoView {
                 <A href="/job">
                     <strong>"Jobs"</strong>
                 </A>
-                <a class="github" href="http://github.com/leptos-rs/leptos" target="_blank" rel="noreferrer">
+                <a
+                    class="github"
+                    href="http://github.com/leptos-rs/leptos"
+                    target="_blank"
+                    rel="noreferrer"
+                >
                     "Built with Leptos"
                 </a>
             </nav>
         </header>
     }
+    .into_any()
 }

examples/hackernews/src/routes/stories.rs

@@ -50,30 +50,42 @@ pub fn Stories() -> impl IntoView {
         <div class="news-view">
             <div class="news-list-nav">
                 <span>
-                    {move || if page() > 1 {
-                        Either::Left(view! {
-                            <a class="page-link"
-                                href=move || format!("/{}?page={}", story_type(), page() - 1)
-                                aria-label="Previous Page"
-                            >
-                                "< prev"
-                            </a>
-                        })
-                    } else {
-                        Either::Right(view! {
-                            <span class="page-link disabled" aria-hidden="true">
-                                "< prev"
-                            </span>
-                        })
+                    {move || {
+                        if page() > 1 {
+                            Either::Left(
+                                view! {
+                                    <a
+                                        class="page-link"
+                                        href=move || {
+                                            format!("/{}?page={}", story_type(), page() - 1)
+                                        }
+                                        aria-label="Previous Page"
+                                    >
+                                        "< prev"
+                                    </a>
+                                },
+                            )
+                        } else {
+                            Either::Right(
+                                view! {
+                                    <span class="page-link disabled" aria-hidden="true">
+                                        "< prev"
+                                    </span>
+                                },
+                            )
+                        }
                     }}
+
                 </span>
                 <span>"page " {page}</span>
                 <Suspense>
-                    <span class="page-link"
+                    <span
+                        class="page-link"
                         class:disabled=hide_more_link
                         aria-hidden=hide_more_link
                     >
-                        <a href=move || format!("/{}?page={}", story_type(), page() + 1)
+                        <a
+                            href=move || format!("/{}?page={}", story_type(), page() + 1)
                             aria-label="Next Page"
                         >
                             "more >"
@@ -83,14 +95,10 @@ pub fn Stories() -> impl IntoView {
             </div>
             <main class="news-list">
                 <div>
-                    <Transition
-                        fallback=move || view! { <p>"Loading..."</p> }
-                        set_pending
-                    >
-                        <Show when=move || stories.read().as_ref().map(Option::is_none).unwrap_or(false)>
-                        >
-                            <p>"Error loading stories."</p>
-                        </Show>
+                    <Transition fallback=move || view! { <p>"Loading..."</p> } set_pending>
+                        <Show when=move || {
+                            stories.read().as_ref().map(Option::is_none).unwrap_or(false)
+                        }>> <p>"Error loading stories."</p></Show>
                         <ul>
                             <For
                                 each=move || stories.get().unwrap_or_default().unwrap_or_default()
@@ -105,54 +113,78 @@ pub fn Stories() -> impl IntoView {
             </main>
         </div>
     }
+    .into_any()
 }
 
 #[component]
 fn Story(story: api::Story) -> impl IntoView {
     view! {
-         <li class="news-item">
+        <li class="news-item">
             <span class="score">{story.points}</span>
             <span class="title">
                 {if !story.url.starts_with("item?id=") {
-                    Either::Left(view! {
-                        <span>
-                            <a href=story.url target="_blank" rel="noreferrer">
-                                {story.title.clone()}
-                            </a>
-                            <span class="host">"("{story.domain}")"</span>
-                        </span>
-                    })
+                    Either::Left(
+                        view! {
+                            <span>
+                                <a href=story.url target="_blank" rel="noreferrer">
+                                    {story.title.clone()}
+                                </a>
+                                <span class="host">"(" {story.domain} ")"</span>
+                            </span>
+                        },
+                    )
                 } else {
                     let title = story.title.clone();
                     Either::Right(view! { <A href=format!("/stories/{}", story.id)>{title}</A> })
                 }}
+
             </span>
-            <br />
+            <br/>
             <span class="meta">
                 {if story.story_type != "job" {
-                    Either::Left(view! {
-                        <span>
-                            {"by "}
-                            {story.user.map(|user| view ! {  <A href=format!("/users/{user}")>{user.clone()}</A>})}
-                            {format!(" {} | ", story.time_ago)}
-                            <A href=format!("/stories/{}", story.id)>
-                                {if story.comments_count.unwrap_or_default() > 0 {
-                                    format!("{} comments", story.comments_count.unwrap_or_default())
-                                } else {
-                                    "discuss".into()
-                                }}
-                            </A>
-                        </span>
-                    })
+                    Either::Left(
+                        view! {
+                            <span>
+                                {"by "}
+                                {story
+                                    .user
+                                    .map(|user| {
+                                        view! {
+                                            <A href=format!("/users/{user}")>{user.clone()}</A>
+                                        }
+                                    })} {format!(" {} | ", story.time_ago)}
+                                <A href=format!(
+                                    "/stories/{}",
+                                    story.id,
+                                )>
+                                    {if story.comments_count.unwrap_or_default() > 0 {
+                                        format!(
+                                            "{} comments",
+                                            story.comments_count.unwrap_or_default(),
+                                        )
+                                    } else {
+                                        "discuss".into()
+                                    }}
+
+                                </A>
+                            </span>
+                        },
+                    )
                 } else {
                     let title = story.title.clone();
                     Either::Right(view! { <A href=format!("/item/{}", story.id)>{title}</A> })
                 }}
+
             </span>
-            {(story.story_type != "link").then(|| view! {
-                " "
-                <span class="label">{story.story_type}</span>
-            })}
+            {(story.story_type != "link")
+                .then(|| {
+                    view! {
+                        " "
+                        <span class="label">{story.story_type}</span>
+                    }
+                })}
+
         </li>
     }
+    .into_any()
 }

examples/hackernews/src/routes/story.rs

@@ -28,18 +28,21 @@ pub fn Story() -> impl IntoView {
                     <Meta name="description" content=story.title.clone()/>
                     <div class="item-view">
                         <div class="item-view-header">
-                        <a href=story.url target="_blank">
-                            <h1>{story.title}</h1>
-                        </a>
-                        <span class="host">
-                            "("{story.domain}")"
-                        </span>
-                        {story.user.map(|user| view! {  <p class="meta">
-                            {story.points}
-                            " points | by "
-                            <A href=format!("/users/{user}")>{user.clone()}</A>
-                            {format!(" {}", story.time_ago)}
-                        </p>})}
+                            <a href=story.url target="_blank">
+                                <h1>{story.title}</h1>
+                            </a>
+                            <span class="host">"(" {story.domain} ")"</span>
+                            {story
+                                .user
+                                .map(|user| {
+                                    view! {
+                                        <p class="meta">
+                                            {story.points} " points | by "
+                                            <A href=format!("/users/{user}")>{user.clone()}</A>
+                                            {format!(" {}", story.time_ago)}
+                                        </p>
+                                    }
+                                })}
                         </div>
                         <div class="item-view-comments">
                             <p class="item-view-comments-header">
@@ -48,6 +51,7 @@ pub fn Story() -> impl IntoView {
                                 } else {
                                     "No comments yet.".into()
                                 }}
+
                             </p>
                             <ul class="comment-children">
                                 <For
@@ -55,7 +59,7 @@ pub fn Story() -> impl IntoView {
                                     key=|comment| comment.id
                                     let:comment
                                 >
-                                    <Comment comment />
+                                    <Comment comment/>
                                 </For>
                             </ul>
                         </div>
@@ -64,6 +68,7 @@ pub fn Story() -> impl IntoView {
             }
         }
     }))).build())
+    .into_any()
 }
 
 #[component]
@@ -72,43 +77,65 @@ pub fn Comment(comment: api::Comment) -> impl IntoView {
 
     view! {
         <li class="comment">
-        <div class="by">
-            <A href=format!("/users/{}", comment.user.clone().unwrap_or_default())>{comment.user.clone()}</A>
-            {format!(" {}", comment.time_ago)}
-        </div>
-        <div class="text" inner_html=comment.content></div>
-        {(!comment.comments.is_empty()).then(|| {
-            view! {
-                <div>
-                    <div class="toggle" class:open=open>
-                        <a on:click=move |_| set_open.update(|n| *n = !*n)>
-                            {
-                                let comments_len = comment.comments.len();
-                                move || if open.get() {
-                                    "[-]".into()
-                                } else {
-                                    format!("[+] {}{} collapsed", comments_len, pluralize(comments_len))
-                                }
-                            }
-                        </a>
-                    </div>
-                    {move || open.get().then({
-                        let comments = comment.comments.clone();
-                        move || view! {
-                            <ul class="comment-children">
-                                <For
-                                    each=move || comments.clone()
-                                    key=|comment| comment.id
-                                    let:comment
-                                >
-                                    <Comment comment />
-                                </For>
-                            </ul>
-                        }
-                    })}
-                </div>
-            }
-        })}
+            <div class="by">
+                <A href=format!(
+                    "/users/{}",
+                    comment.user.clone().unwrap_or_default(),
+                )>{comment.user.clone()}</A>
+                {format!(" {}", comment.time_ago)}
+            </div>
+            <div class="text" inner_html=comment.content></div>
+            {(!comment.comments.is_empty())
+                .then(|| {
+                    view! {
+                        <div>
+                            <div class="toggle" class:open=open>
+                                <a on:click=move |_| {
+                                    set_open.update(|n| *n = !*n)
+                                }>
+
+                                    {
+                                        let comments_len = comment.comments.len();
+                                        move || {
+                                            if open.get() {
+                                                "[-]".into()
+                                            } else {
+                                                format!(
+                                                    "[+] {}{} collapsed",
+                                                    comments_len,
+                                                    pluralize(comments_len),
+                                                )
+                                            }
+                                        }
+                                    }
+
+                                </a>
+                            </div>
+                            {move || {
+                                open
+                                    .get()
+                                    .then({
+                                        let comments = comment.comments.clone();
+                                        move || {
+                                            view! {
+                                                <ul class="comment-children">
+                                                    <For
+                                                        each=move || comments.clone()
+                                                        key=|comment| comment.id
+                                                        let:comment
+                                                    >
+                                                        <Comment comment/>
+                                                    </For>
+                                                </ul>
+                                            }
+                                        }
+                                    })
+                            }}
+
+                        </div>
+                    }
+                })}
+
         </li>
     }.into_any()
 }

examples/hackernews/src/routes/users.rs

@@ -18,30 +18,48 @@ pub fn User() -> impl IntoView {
     );
     view! {
         <div class="user-view">
-            <Suspense fallback=|| view! { "Loading..." }>
-                {move || Suspend::new(async move { match user.await.clone() {
-                    None => Either::Left(view! {  <h1>"User not found."</h1> }),
-                    Some(user) => Either::Right(view! {
-                        <div>
-                            <h1>"User: " {user.id.clone()}</h1>
-                            <ul class="meta">
-                                <li>
-                                    <span class="label">"Created: "</span> {user.created}
-                                </li>
-                                <li>
-                                <span class="label">"Karma: "</span> {user.karma}
-                                </li>
-                                <li inner_html={user.about} class="about"></li>
-                            </ul>
-                            <p class="links">
-                                <a href=format!("https://news.ycombinator.com/submitted?id={}", user.id)>"submissions"</a>
-                                " | "
-                                <a href=format!("https://news.ycombinator.com/threads?id={}", user.id)>"comments"</a>
-                            </p>
-                        </div>
-                    })
-                }})}
+            <Suspense fallback=|| {
+                view! { "Loading..." }
+            }>
+                {move || Suspend::new(async move {
+                    match user.await.clone() {
+                        None => Either::Left(view! { <h1>"User not found."</h1> }),
+                        Some(user) => {
+                            Either::Right(
+                                view! {
+                                    <div>
+                                        <h1>"User: " {user.id.clone()}</h1>
+                                        <ul class="meta">
+                                            <li>
+                                                <span class="label">"Created: "</span>
+                                                {user.created}
+                                            </li>
+                                            <li>
+                                                <span class="label">"Karma: "</span>
+                                                {user.karma}
+                                            </li>
+                                            <li inner_html=user.about class="about"></li>
+                                        </ul>
+                                        <p class="links">
+                                            <a href=format!(
+                                                "https://news.ycombinator.com/submitted?id={}",
+                                                user.id,
+                                            )>"submissions"</a>
+                                            " | "
+                                            <a href=format!(
+                                                "https://news.ycombinator.com/threads?id={}",
+                                                user.id,
+                                            )>"comments"</a>
+                                        </p>
+                                    </div>
+                                },
+                            )
+                        }
+                    }
+                })}
+
             </Suspense>
         </div>
     }
+    .into_any()
 }

examples/hackernews_axum/src/lib.rs

@@ -4,7 +4,7 @@ mod routes;
 use leptos_meta::{provide_meta_context, Link, Meta, MetaTags, Stylesheet};
 use leptos_router::{
     components::{FlatRoutes, Route, Router, RoutingProgress},
-    ParamSegment, StaticSegment,
+    OptionalParamSegment, ParamSegment, StaticSegment,
 };
 use routes::{nav::*, stories::*, story::*, users::*};
 use std::time::Duration;
@@ -46,9 +46,7 @@ pub fn App() -> impl IntoView {
                 <FlatRoutes fallback=|| "Not found.">
                     <Route path=(StaticSegment("users"), ParamSegment("id")) view=User/>
                     <Route path=(StaticSegment("stories"), ParamSegment("id")) view=Story/>
-                    <Route path=ParamSegment("stories") view=Stories/>
-                    // TODO allow optional params without duplication
-                    <Route path=StaticSegment("") view=Stories/>
+                    <Route path=OptionalParamSegment("stories") view=Stories/>
                 </FlatRoutes>
             </main>
         </Router>

examples/hackernews_islands_axum/Cargo.toml

@@ -12,7 +12,7 @@ lto = true
 
 [dependencies]
 console_error_panic_hook = "0.1.7"
-leptos = { path = "../../leptos", features = ["experimental-islands"] }
+leptos = { path = "../../leptos", features = ["islands"] }
 leptos_axum = { path = "../../integrations/axum", optional = true }
 leptos_meta = { path = "../../meta" }
 leptos_router = { path = "../../router" }
@@ -31,7 +31,6 @@ tokio = { version = "1.39", features = ["full"], optional = true }
 http = { version = "1.1", optional = true }
 web-sys = { version = "0.3.70", features = ["AbortController", "AbortSignal"] }
 wasm-bindgen = "0.2.93"
-lazy_static = "1.5"
 rust-embed = { version = "8.5", features = [
   "axum",
   "mime_guess",

examples/hackernews_islands_axum/src/lib.rs

@@ -4,7 +4,7 @@ mod routes;
 use leptos_meta::{provide_meta_context, Link, Meta, MetaTags, Stylesheet};
 use leptos_router::{
     components::{FlatRoutes, Route, Router},
-    ParamSegment, StaticSegment,
+    OptionalParamSegment, ParamSegment, StaticSegment,
 };
 use routes::{nav::*, stories::*, story::*, users::*};
 #[cfg(feature = "ssr")]
@@ -42,9 +42,7 @@ pub fn App() -> impl IntoView {
                 <FlatRoutes fallback=|| "Not found.">
                     <Route path=(StaticSegment("users"), ParamSegment("id")) view=User/>
                     <Route path=(StaticSegment("stories"), ParamSegment("id")) view=Story/>
-                    <Route path=ParamSegment("stories") view=Stories/>
-                    // TODO allow optional params without duplication
-                    <Route path=StaticSegment("") view=Stories/>
+                    <Route path=OptionalParamSegment("stories") view=Stories/>
                 </FlatRoutes>
             </main>
         </Router>

examples/hackernews_js_fetch/src/lib.rs

@@ -4,7 +4,7 @@ mod routes;
 use leptos_meta::{provide_meta_context, Link, Meta, MetaTags, Stylesheet};
 use leptos_router::{
     components::{FlatRoutes, Route, Router, RoutingProgress},
-    ParamSegment, StaticSegment,
+    OptionalParamSegment, ParamSegment, StaticSegment,
 };
 use routes::{nav::*, stories::*, story::*, users::*};
 use std::time::Duration;
@@ -46,9 +46,7 @@ pub fn App() -> impl IntoView {
                 <FlatRoutes fallback=|| "Not found.">
                     <Route path=(StaticSegment("users"), ParamSegment("id")) view=User/>
                     <Route path=(StaticSegment("stories"), ParamSegment("id")) view=Story/>
-                    <Route path=ParamSegment("stories") view=Stories/>
-                    // TODO allow optional params without duplication
-                    <Route path=StaticSegment("") view=Stories/>
+                    <Route path=OptionalParamSegment("stories") view=Stories/>
                 </FlatRoutes>
             </main>
         </Router>

examples/islands/Cargo.toml

@@ -12,7 +12,7 @@ futures = "0.3.30"
 http = "1.1"
 leptos = { path = "../../leptos", features = [
   "tracing",
-  "experimental-islands",
+  "islands",
 ] }
 server_fn = { path = "../../server_fn", features = ["serde-lite"] }
 leptos_axum = { path = "../../integrations/axum", optional = true }

examples/islands_router/Cargo.toml

@@ -12,12 +12,12 @@ futures = "0.3.30"
 http = "1.1"
 leptos = { path = "../../leptos", features = [
   "tracing",
-  "experimental-islands",
+  "islands",
 ] }
 leptos_router = { path = "../../router" }
 server_fn = { path = "../../server_fn", features = ["serde-lite"] }
 leptos_axum = { path = "../../integrations/axum", features = [
-  "islands-router",
+  "dont-use-islands-router",
 ], optional = true }
 log = "0.4.22"
 serde = { version = "1.0", features = ["derive"] }

examples/islands_router/README.md

@@ -1,19 +1,14 @@
-# Leptos Todo App Sqlite with Axum
+# Work in Progress
 
-This example creates a basic todo app with an Axum backend that uses Leptos' server functions to call sqlx from the client and seamlessly run it on the server.
+This example is something I wrote on a long layover in the Orlando airport in July. (It was really hot!)
 
-## Getting Started
+It is the culmination of a couple years of thinking and working toward being able to do this, which you can see 
+described pretty well in the pinned roadmap issue (#1830) and its discussion of different modes of client-side
+routing when you use islands.
 
-See the [Examples README](../README.md) for setup and run instructions.
+This uses *only* server rendering, with no actual islands, but still maintains client-side state across page navigations.
+It does this by building on the fact that we now have a statically-typed view tree to do pretty smart updates with 
+new HTML from the client, with extremely minimal diffing.
 
-## E2E Testing
-
-See the [E2E README](./e2e/README.md) for more information about the testing strategy.
-
-## Rendering
-
-See the [SSR Notes](../SSR_NOTES.md) for more information about Server Side Rendering.
-
-## Quick Start
-
-Run `cargo leptos watch` to run this example.
+The demo itself works, but the feature that supports it is incomplete. A couple people have accidentally
+used it and broken their applications in ways they don't understand, so I've renamed the feature to `dont-use-islands-router`.

examples/islands_router/public/routing.js

@@ -44,8 +44,8 @@ window.addEventListener("click", async (ev) => {
 	// TODO parse from the request stream instead?
     const doc = parser.parseFromString(htmlString, 'text/html');
 
-	// The 'doc' variable now contains the parsed DOM 
-	const transition = document.startViewTransition(async () => {
+	// The 'doc' variable now contains the parsed DOM
+	const transition = async () => {
 		const oldDocWalker = document.createTreeWalker(document);
 		const newDocWalker = doc.createTreeWalker(doc);
 		let oldNode = oldDocWalker.currentNode;
@@ -128,8 +128,13 @@ window.addEventListener("click", async (ev) => {
 					}
 				} 			}
 		}
-	});
-	await transition;
+	};
+	// Not all browsers support startViewTransition; see https://caniuse.com/?search=startViewTransition
+	if (document.startViewTransition) {
+		await document.startViewTransition(transition);
+	} else {
+		await transition()
+	}
 	window.history.pushState(undefined, null, url);
 });
 

examples/js-framework-benchmark/src/lib.rs

@@ -162,22 +162,24 @@ pub fn App() -> impl IntoView {
             <table class="table table-hover table-striped test-data">
                 <tbody>
                     <For
-                        each={move || data.get()}
-                        key={|row| row.id}
+                        each=move || data.get()
+                        key=|row| row.id
                         children=move |row: RowData| {
                             let row_id = row.id;
                             let label = row.label;
                             let is_selected = is_selected.clone();
-                            ViewTemplate::new(view! {
-                                <tr class:danger={move || is_selected.selected(Some(row_id))}>
-                                    <td class="col-md-1">{row_id.to_string()}</td>
-                                    <td class="col-md-4"><a on:click=move |_| set_selected.set(Some(row_id))>{move || label.get()}</a></td>
-                                    <td class="col-md-1"><a on:click=move |_| remove(row_id)><span class="glyphicon glyphicon-remove" aria-hidden="true"></span></a></td>
-                                    <td class="col-md-6"/>
-                                </tr>
-                            })
+                            template! {
+                                < tr class : danger = { move || is_selected.selected(Some(row_id)) }
+                                > < td class = "col-md-1" > { row_id.to_string() } </ td > < td
+                                class = "col-md-4" >< a on : click = move | _ | set_selected
+                                .set(Some(row_id)) > { move || label.get() } </ a ></ td > < td
+                                class = "col-md-1" >< a on : click = move | _ | remove(row_id) ><
+                                span class = "glyphicon glyphicon-remove" aria - hidden = "true" ></
+                                span ></ a ></ td > < td class = "col-md-6" /> </ tr >
+                            }
                         }
                     />
+
                 </tbody>
             </table>
             <span class="preloadicon glyphicon glyphicon-remove" aria-hidden="true"></span>

examples/js-framework-benchmark/tests/web.rs

@@ -1,5 +1,5 @@
 use js_framework_benchmark_leptos::*;
-use leptos::{prelude::*, spawn::tick};
+use leptos::{prelude::*, task::tick};
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 

examples/portal/src/main.rs

@@ -6,7 +6,7 @@ fn main() {
     _ = console_log::init_with_level(log::Level::Debug);
     console_error_panic_hook::set_once();
     let handle = mount_to(
-        helpers::document()
+        document()
             .get_element_by_id("app")
             .unwrap()
             .unchecked_into(),

examples/portal/tests/web.rs

@@ -1,9 +1,11 @@
+#![allow(dead_code)]
+
 use portal::App;
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 
 wasm_bindgen_test_configure!(run_in_browser);
-use leptos::spawn::tick;
+use leptos::task::tick;
 use leptos::{leptos_dom::helpers::document, mount::mount_to};
 use web_sys::HtmlButtonElement;
 

examples/router/index.html

@@ -3,7 +3,7 @@
 	<head>
 		<link data-trunk rel="rust" data-wasm-opt="z"/>
 		<link data-trunk rel="icon" type="image/ico" href="/public/favicon.ico"/>
-        <link data-trunk rel="css" href="style.css"/>
+		<link data-trunk rel="css" href="style.css"/>
 	</head>
 	<body></body>
 </html>

examples/router/src/lib.rs

@@ -5,13 +5,14 @@ use leptos::prelude::*;
 use leptos_router::{
     components::{
         Form, Outlet, ParentRoute, ProtectedRoute, Redirect, Route, Router,
-        Routes, A,
+        Routes, RoutingProgress, A,
     },
     hooks::{use_navigate, use_params, use_query_map},
     params::Params,
     MatchNestedRoutes,
 };
 use leptos_router_macro::path;
+use std::time::Duration;
 use tracing::info;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -26,9 +27,14 @@ pub fn RouterExample() -> impl IntoView {
 
     // this signal will be ued to set whether we are allowed to access a protected route
     let (logged_in, set_logged_in) = signal(true);
+    let (is_routing, set_is_routing) = signal(false);
 
     view! {
-        <Router>
+        <Router set_is_routing>
+            // shows a progress bar while async data are loading
+            <div class="routing-progress">
+                <RoutingProgress is_routing max_time=Duration::from_millis(250)/>
+            </div>
             <nav>
                 // ordinary <a> elements can be used for client-side navigation
                 // using <A> has two effects:
@@ -44,7 +50,7 @@ pub fn RouterExample() -> impl IntoView {
                 }>{move || if logged_in.get() { "Log Out" } else { "Log In" }}</button>
             </nav>
             <main>
-                <Routes fallback=|| "This page could not be found.">
+                <Routes transition=true fallback=|| "This page could not be found.">
                     // paths can be created using the path!() macro, or provided as types like
                     // StaticSegment("about")
                     <Route path=path!("about") view=About/>
@@ -64,8 +70,8 @@ pub fn RouterExample() -> impl IntoView {
 
 // You can define other routes in their own component.
 // Routes implement the MatchNestedRoutes
-#[component]
-pub fn ContactRoutes() -> impl MatchNestedRoutes<Dom> + Clone {
+#[component(transparent)]
+pub fn ContactRoutes() -> impl MatchNestedRoutes + Clone {
     view! {
         <ParentRoute path=path!("") view=ContactList>
             <Route path=path!("/") view=|| "Select a contact."/>

examples/router/style.css

@@ -1,3 +1,8 @@
+.routing-progress {
+	width: 100%;
+	height: 20px;
+}
+
 a[aria-current] {
     font-weight: bold;
 }
@@ -12,12 +17,8 @@ a[aria-current] {
     padding: 1rem;
 }
 
-.fadeIn {
-  animation: 0.5s fadeIn forwards;
-}
-
-.fadeOut {
-  animation: 0.5s fadeOut forwards;
+.contact {
+	view-transition-name: contact;
 }
 
 @keyframes fadeIn {
@@ -40,12 +41,44 @@ a[aria-current] {
   }
 }
 
-.slideIn {
-  animation: 0.25s slideIn forwards;
+.router-outlet-0 main {
+  view-transition-name: main;
 }
 
-.slideOut {
-  animation: 0.25s slideOut forwards;
+.router-back main {
+  view-transition-name: main-back;
+}
+
+.router-outlet-1 .contact-list {
+  view-transition-name: contact;
+}
+
+@media (prefers-reduced-motion: no-preference) {
+	::view-transition-old(contact) {
+	  animation: 0.5s fadeOut;
+	}
+
+	::view-transition-new(contact) {
+	  animation: 0.5s fadeIn;
+	}
+
+	::view-transition-old(main) {
+	  animation: 0.5s slideOut;
+	}
+
+	::view-transition-new(main) {
+	  animation: 0.5s slideIn;
+	}
+
+	::view-transition-old(main-back) {
+		color: red;
+		animation: 0.5s slideOutBack;
+	}
+
+	::view-transition-new(main-back) {
+		color: blue;
+		animation: 0.5s slideInBack;
+	}
 }
 
 @keyframes slideIn {
@@ -66,14 +99,6 @@ a[aria-current] {
   }
 }
 
-.slideInBack {
-  animation: 0.25s slideInBack forwards;
-}
-
-.slideOutBack {
-  animation: 0.25s slideOutBack forwards;
-}
-
 @keyframes slideInBack {
   from {
     transform: translate(-100vw, 0);

examples/server_fns_axum/Cargo.toml

@@ -40,6 +40,8 @@ pin-project-lite = "0.2.14"
 dashmap = { version = "6.0", optional = true }
 once_cell = { version = "1.19", optional = true }
 async-broadcast = { version = "0.7.1", optional = true }
+bytecheck = "0.8.0"
+rkyv = { version = "0.8.8" }
 
 [features]
 hydrate = ["leptos/hydrate"]

examples/server_fns_axum/src/app.rs

@@ -1,6 +1,6 @@
 use futures::StreamExt;
 use http::Method;
-use leptos::{html::Input, prelude::*, spawn::spawn_local};
+use leptos::{html::Input, prelude::*, task::spawn_local};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use server_fn::{
     client::{browser::BrowserClient, Client},
@@ -417,7 +417,6 @@ pub fn FileUploadWithProgress() -> impl IntoView {
     /// This requires us to store some global state of all the uploads. In a real app, you probably
     /// shouldn't do exactly what I'm doing here in the demo. For example, this map just
     /// distinguishes between files by filename, not by user.
-
     #[cfg(feature = "ssr")]
     mod progress {
         use async_broadcast::{broadcast, Receiver, Sender};

examples/server_fns_axum/src/main.rs

@@ -4,6 +4,8 @@ use leptos::{config::get_configuration, logging};
 use leptos_axum::{generate_route_list, LeptosRoutes};
 use server_fns_axum::*;
 
+// cargo make cli: error: unneeded `return` statement
+#[allow(clippy::needless_return)]
 #[tokio::main]
 async fn main() {
     simple_logger::init_with_level(log::Level::Error)

examples/slots/src/lib.rs

@@ -10,7 +10,7 @@ struct Then {
 // the type with Option<...> and marking the option as #[prop(optional)].
 #[slot]
 struct ElseIf {
-    cond: MaybeSignal<bool>,
+    cond: Signal<bool>,
     children: ChildrenFn,
 }
 
@@ -22,7 +22,7 @@ struct Fallback {
 // Slots are added to components like any other prop.
 #[component]
 fn SlotIf(
-    cond: MaybeSignal<bool>,
+    cond: Signal<bool>,
     then: Then,
     #[prop(default=vec![])] else_if: Vec<ElseIf>,
     #[prop(optional)] fallback: Option<Fallback>,
@@ -43,9 +43,9 @@ fn SlotIf(
 #[component]
 pub fn App() -> impl IntoView {
     let (count, set_count) = signal(0);
-    let is_even = MaybeSignal::derive(move || count.get() % 2 == 0);
-    let is_div5 = MaybeSignal::derive(move || count.get() % 5 == 0);
-    let is_div7 = MaybeSignal::derive(move || count.get() % 7 == 0);
+    let is_even = Signal::derive(move || count.get() % 2 == 0);
+    let is_div5 = Signal::derive(move || count.get() % 5 == 0);
+    let is_div7 = Signal::derive(move || count.get() % 7 == 0);
 
     view! {
         <button on:click=move |_| set_count.update(|value| *value += 1)>"+1"</button>

examples/ssr_modes/Cargo.toml

@@ -2,6 +2,8 @@
 name = "ssr_modes"
 version = "0.1.0"
 edition = "2021"
+# std::sync::LazyLock is stabilized in Rust version 1.80.0
+rust-version = "1.80.0"
 
 [lib]
 crate-type = ["cdylib", "rlib"]
@@ -11,7 +13,6 @@ actix-files = { version = "0.6.6", optional = true }
 actix-web = { version = "4.8", optional = true, features = ["macros"] }
 console_error_panic_hook = "0.1.7"
 console_log = "1.0"
-lazy_static = "1.5"
 leptos = { path = "../../leptos" }
 leptos_meta = { path = "../../meta" }
 leptos_actix = { path = "../../integrations/actix", optional = true }
@@ -38,12 +39,12 @@ denylist = ["actix-files", "actix-web", "leptos_actix"]
 skip_feature_sets = [["ssr", "hydrate"]]
 
 [package.metadata.leptos]
-# The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
+# The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name
 output-name = "ssr_modes"
 # The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
 site-root = "target/site"
 # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
-# Defaults to pkg	
+# Defaults to pkg
 site-pkg-dir = "pkg"
 # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
 style-file = "style/main.scss"

examples/ssr_modes/src/app.rs

@@ -1,4 +1,5 @@
-use lazy_static::lazy_static;
+use std::sync::LazyLock;
+
 use leptos::prelude::*;
 use leptos_meta::*;
 use leptos_router::{
@@ -146,8 +147,9 @@ fn Post() -> impl IntoView {
 }
 
 // Dummy API
-lazy_static! {
-    static ref POSTS: Vec<Post> = vec![
+
+static POSTS: LazyLock<[Post; 3]> = LazyLock::new(|| {
+    [
         Post {
             id: 0,
             title: "My first post".to_string(),
@@ -163,8 +165,8 @@ lazy_static! {
             title: "My third post".to_string(),
             content: "This is my third post".to_string(),
         },
-    ];
-}
+    ]
+});
 
 #[derive(Error, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum PostError {

examples/ssr_modes/src/main.rs

@@ -39,7 +39,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root))
+            .service(Files::new("/", site_root.as_ref()))
         //.wrap(middleware::Compress::default())
     })
     .bind(&addr)?

examples/ssr_modes_axum/Cargo.toml

@@ -2,6 +2,8 @@
 name = "ssr_modes_axum"
 version = "0.1.0"
 edition = "2021"
+# std::sync::LazyLock is stabilized in Rust version 1.80.0
+rust-version = "1.80.0"
 
 [lib]
 crate-type = ["cdylib", "rlib"]
@@ -9,7 +11,6 @@ crate-type = ["cdylib", "rlib"]
 [dependencies]
 console_error_panic_hook = "0.1.7"
 console_log = "1.0"
-lazy_static = "1.5"
 leptos = { path = "../../leptos", features = [
   "hydration",
 ] } #"nightly", "hydration"] }

examples/ssr_modes_axum/src/app.rs

@@ -1,4 +1,5 @@
-use lazy_static::lazy_static;
+use std::sync::LazyLock;
+
 use leptos::prelude::*;
 use leptos_meta::MetaTags;
 use leptos_meta::*;
@@ -261,8 +262,9 @@ pub fn Admin() -> impl IntoView {
 }
 
 // Dummy API
-lazy_static! {
-    static ref POSTS: Vec<Post> = vec![
+
+static POSTS: LazyLock<[Post; 3]> = LazyLock::new(|| {
+    [
         Post {
             id: 0,
             title: "My first post".to_string(),
@@ -278,8 +280,8 @@ lazy_static! {
             title: "My third post".to_string(),
             content: "This is my third post".to_string(),
         },
-    ];
-}
+    ]
+});
 
 #[derive(Error, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum PostError {

examples/ssr_modes_axum/src/main.rs

@@ -2,6 +2,7 @@
 #[tokio::main]
 async fn main() {
     use axum::Router;
+    use leptos::logging::log;
     use leptos::prelude::*;
     use leptos_axum::{generate_route_list, LeptosRoutes};
     use ssr_modes_axum::app::*;

examples/static_routing/src/main.rs

@@ -2,6 +2,7 @@
 #[tokio::main]
 async fn main() {
     use axum::Router;
+    use leptos::logging::log;
     use leptos::prelude::*;
     use leptos_axum::{generate_route_list_with_ssg, LeptosRoutes};
     use static_routing::app::*;

examples/stores/Cargo.toml

@@ -13,6 +13,9 @@ leptos = { path = "../../leptos", features = ["csr"] }
 reactive_stores = { path = "../../reactive_stores" }
 reactive_stores_macro = { path = "../../reactive_stores_macro" }
 console_error_panic_hook = "0.1.7"
+chrono = { version = "0.4.38", features = ["serde"] }
+serde = { version = "1.0.210", features = ["derive"] }
+serde_json = "1.0.128"
 
 [dev-dependencies]
 wasm-bindgen = "0.2.93"

examples/stores/index.html

@@ -3,6 +3,11 @@
 	<head>
 		<link data-trunk rel="rust" data-wasm-opt="z"/>
 		<link data-trunk rel="icon" type="image/ico" href="/public/favicon.ico"/>
+		<style>
+		.hidden {
+			display: none;
+		}
+		</style>
 	</head>
 	<body></body>
-</html>
+</html>

examples/stores/src/lib.rs

@@ -1,43 +1,88 @@
-use leptos::prelude::*;
-use reactive_stores::{Field, Store, StoreFieldIterator};
-use reactive_stores_macro::Store;
+use std::sync::atomic::{AtomicUsize, Ordering};
 
-#[derive(Debug, Store)]
+use chrono::{Local, NaiveDate};
+use leptos::logging::warn;
+use leptos::prelude::*;
+use reactive_stores::{Field, Patch, Store};
+use serde::{Deserialize, Serialize};
+
+// ID starts higher than 0 because we have a few starting todos by default
+static NEXT_ID: AtomicUsize = AtomicUsize::new(3);
+
+#[derive(Debug, Store, Serialize, Deserialize)]
 struct Todos {
-    user: String,
+    user: User,
+    #[store(key: usize = |todo| todo.id)]
     todos: Vec<Todo>,
 }
 
-#[derive(Debug, Store)]
+#[derive(Debug, Store, Patch, Serialize, Deserialize)]
+struct User {
+    name: String,
+    email: String,
+}
+
+#[derive(Debug, Store, Serialize, Deserialize)]
 struct Todo {
+    id: usize,
     label: String,
-    completed: bool,
+    status: Status,
+}
+
+#[derive(Debug, Default, Clone, Store, Serialize, Deserialize)]
+enum Status {
+    #[default]
+    Pending,
+    Scheduled,
+    ScheduledFor {
+        date: NaiveDate,
+    },
+    Done,
+}
+
+impl Status {
+    pub fn next_step(&mut self) {
+        *self = match self {
+            Status::Pending => Status::ScheduledFor {
+                date: Local::now().naive_local().into(),
+            },
+            Status::Scheduled | Status::ScheduledFor { .. } => Status::Done,
+            Status::Done => Status::Done,
+        };
+    }
 }
 
 impl Todo {
     pub fn new(label: impl ToString) -> Self {
         Self {
+            id: NEXT_ID.fetch_add(1, Ordering::Relaxed),
             label: label.to_string(),
-            completed: false,
+            status: Status::Pending,
         }
     }
 }
 
 fn data() -> Todos {
     Todos {
-        user: "Bob".to_string(),
+        user: User {
+            name: "Bob".to_string(),
+            email: "lawblog@bobloblaw.com".into(),
+        },
         todos: vec![
             Todo {
+                id: 0,
                 label: "Create reactive store".to_string(),
-                completed: true,
+                status: Status::Pending,
             },
             Todo {
+                id: 1,
                 label: "???".to_string(),
-                completed: false,
+                status: Status::Pending,
             },
             Todo {
+                id: 2,
                 label: "Profit".to_string(),
-                completed: false,
+                status: Status::Pending,
             },
         ],
     }
@@ -49,17 +94,10 @@ pub fn App() -> impl IntoView {
 
     let input_ref = NodeRef::new();
 
-    let rows = move || {
-        store
-            .todos()
-            .iter()
-            .enumerate()
-            .map(|(idx, todo)| view! { <TodoRow store idx todo/> })
-            .collect_view()
-    };
-
     view! {
-        <p>"Hello, " {move || store.user().get()}</p>
+        <p>"Hello, " {move || store.user().name().get()}</p>
+        <UserForm user=store.user()/>
+        <hr/>
         <form on:submit=move |ev| {
             ev.prevent_default();
             store.todos().write().push(Todo::new(input_ref.get().unwrap().value()));
@@ -67,30 +105,65 @@ pub fn App() -> impl IntoView {
             <label>"Add a Todo" <input type="text" node_ref=input_ref/></label>
             <input type="submit"/>
         </form>
-        <ol>{rows}</ol>
-        <div style="display: flex"></div>
+        <ol>
+            // because `todos` is a keyed field, `store.todos()` returns a struct that
+            // directly implements IntoIterator, so we can use it in <For/> and
+            // it will manage reactivity for the store fields correctly
+            <For
+                each=move || store.todos()
+                key=|row| row.id().get()
+                let:todo
+            >
+                <TodoRow store todo/>
+            </For>
+
+        </ol>
+        <pre>{move || serde_json::to_string_pretty(&*store.read())}</pre>
+    }
+}
+
+#[component]
+fn UserForm(#[prop(into)] user: Field<User>) -> impl IntoView {
+    let error = RwSignal::new(None);
+
+    view! {
+        {move || error.get().map(|n| view! { <p>{n}</p> })}
+        <form on:submit:target=move |ev| {
+            ev.prevent_default();
+            match User::from_event(&ev) {
+                Ok(new_user) => {
+                    error.set(None);
+                    user.patch(new_user);
+                }
+                Err(e) => error.set(Some(e.to_string())),
+            }
+        }>
+            <label>
+                "Name" <input type="text" name="name" prop:value=move || user.name().get()/>
+            </label>
+            <label>
+                "Email" <input type="email" name="email" prop:value=move || user.email().get()/>
+            </label>
+            <input type="submit"/>
+        </form>
     }
 }
 
 #[component]
 fn TodoRow(
     store: Store<Todos>,
-    idx: usize,
     #[prop(into)] todo: Field<Todo>,
 ) -> impl IntoView {
-    let completed = todo.completed();
+    let status = todo.status();
     let title = todo.label();
 
-    let editing = RwSignal::new(false);
+    let editing = RwSignal::new(true);
 
     view! {
-        <li
-            style:text-decoration=move || {
-                completed.get().then_some("line-through").unwrap_or_default()
-            }
+        <li style:text-decoration=move || {
+            status.done().then_some("line-through").unwrap_or_default()
+        }>
 
-            class:foo=move || completed.get()
-        >
             <p
                 class:hidden=move || editing.get()
                 on:click=move |_| {
@@ -106,25 +179,48 @@ fn TodoRow(
                 prop:value=move || title.get()
                 on:change=move |ev| {
                     title.set(event_target_value(&ev));
-                    editing.set(false);
                 }
-
-                on:blur=move |_| editing.set(false)
-                autofocus
-            />
-            <input
-                type="checkbox"
-                prop:checked=move || completed.get()
-                on:click=move |_| { completed.update(|n| *n = !*n) }
             />
 
             <button on:click=move |_| {
-                store
-                    .todos()
-                    .update(|todos| {
-                        todos.remove(idx);
-                    });
+                status.write().next_step()
+            }>
+                {move || {
+                    if todo.status().done() {
+                        "Done"
+                    } else if status.scheduled() || status.scheduled_for() {
+                        "Scheduled"
+                    } else {
+                        "Pending"
+                    }
+                }}
+
+            </button>
+
+            <button on:click=move |_| {
+                let id = todo.id().get();
+                store.todos().write().retain(|todo| todo.id != id);
             }>"X"</button>
+            <input
+                type="date"
+                prop:value=move || {
+                    todo.status().scheduled_for_date().map(|n| n.get().to_string())
+                }
+
+                class:hidden=move || !todo.status().scheduled_for()
+                on:change:target=move |ev| {
+                    if let Some(date) = todo.status().scheduled_for_date() {
+                        let value = ev.target().value();
+                        match NaiveDate::parse_from_str(&value, "%Y-%m-%d") {
+                            Ok(new_date) => {
+                                date.set(new_date);
+                            }
+                            Err(e) => warn!("{e}"),
+                        }
+                    }
+                }
+            />
+
         </li>
     }
 }

examples/suspense_tests/Cargo.toml

@@ -10,6 +10,7 @@ crate-type = ["cdylib", "rlib"]
 actix-files = { version = "0.6.6", optional = true }
 actix-web = { version = "4.8", optional = true, features = ["macros"] }
 console_error_panic_hook = "0.1.7"
+js-sys = { version = "0.3.72" }
 leptos = { path = "../../leptos" }
 leptos_actix = { path = "../../integrations/actix", optional = true }
 leptos_router = { path = "../../router" }
@@ -19,7 +20,10 @@ serde = "1.0"
 tokio = { version = "1.39", features = ["time", "rt"], optional = true }
 
 [features]
-hydrate = ["leptos/hydrate"]
+hydrate = [
+
+  "leptos/hydrate",
+]
 ssr = [
   "dep:actix-files",
   "dep:actix-web",

examples/suspense_tests/e2e/features/check_aria_current.feature

@@ -0,0 +1,121 @@
+@check_aria_current
+Feature: Check aria-current being applied to make links bolded
+
+    Background:
+
+        Given I see the app
+
+    Scenario: Should see the base case working
+        Then I see the Out-of-Order link being bolded
+        And I see the following links being bolded
+            | Out-of-Order |
+            | Nested       |
+        And I see the In-Order link not being bolded
+        And I see the following links not being bolded
+            | In-Order     |
+            | Single       |
+
+    Scenario: Should see client-side render the correct bolded links
+        When I select the link In-Order
+        And I select the link Single
+        Then I see the following links being bolded
+            | In-Order     |
+            | Single       |
+        And I see the following links not being bolded
+            | Out-of-Order |
+            | Nested       |
+
+    Scenario: Should see server-side render the correct bolded links
+        When I select the link In-Order
+        And I select the link Single
+        And I reload the page
+        Then I see the following links being bolded
+            | In-Order     |
+            | Single       |
+        And I see the following links not being bolded
+            | Out-of-Order |
+            | Nested       |
+
+    Scenario: Check that the base nested route links are working
+        When I select the link Instrumented
+        Then I see the Instrumented link being bolded
+        And I see the Item Listing link not being bolded
+
+    Scenario: Should see going deep down into nested routes bold links
+        When I select the link Instrumented
+        And I select the link Target 421
+        Then I see the following links being bolded
+            | Instrumented |
+            | Item Listing |
+            | Target 4##   |
+            | Target 42#   |
+            | Target 421   |
+            | field1       |
+
+    Scenario: Should see going deep down into nested routes in SSR bold links
+        When I select the link Instrumented
+        And I select the link Target 421
+        And I reload the page
+        Then I see the following links being bolded
+            | Instrumented |
+            | Item Listing |
+            | Target 4##   |
+            | Target 42#   |
+            | Target 421   |
+            | field1       |
+
+    Scenario: Going deep down navigate around nested links bold correctly
+        When I select the link Instrumented
+        And I select the link Target 421
+        And I select the link Inspect path2/field3
+        Then I see the following links being bolded
+            | Instrumented |
+            | Item Listing |
+            | Target 4##   |
+            | Target 42#   |
+            | field3       |
+        And I see the following links not being bolded
+            | Target 421   |
+            | field1       |
+
+    Scenario: Going deep down navigate around nested links bold correctly, SSR
+        When I select the link Instrumented
+        And I select the link Target 421
+        And I select the link Inspect path2/field3
+        And I reload the page
+        Then I see the following links being bolded
+            | Instrumented |
+            | Item Listing |
+            | Target 4##   |
+            | Target 42#   |
+            | field3       |
+        And I see the following links not being bolded
+            | Target 421   |
+            | field1       |
+
+    Scenario: Going deep down back out nested routes reset bolded states
+        When I select the link Instrumented
+        And I select the link Target 421
+        And I select the link Counters
+        Then I see the following links being bolded
+            | Instrumented |
+            | Counters     |
+        And I see the following links not being bolded
+            | Item Listing |
+            | Target 4##   |
+            | Target 42#   |
+            | Target 421   |
+
+    Scenario: Going deep down back out nested routes reset bolded states, SSR
+        When I select the link Instrumented
+        And I select the link Target 421
+        And I select the link Counters
+        And I reload the page
+        Then I see the following links being bolded
+            | Instrumented |
+            | Counters     |
+        And I see the following links not being bolded
+            | Item Listing |
+            | Target 4##   |
+            | Target 42#   |
+            | Target 421   |

examples/suspense_tests/e2e/features/check_instrumented.feature

@@ -0,0 +1,94 @@
+@check_instrumented
+Feature: Instrumented Counters showing the expected values
+
+    Scenario: I can fresh CSR instrumented counters
+        Given I see the app
+        When I access the instrumented counters via CSR
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 0 |
+            | item_overview      | 0 |
+            | item_inspect       | 0 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 0 |
+            | inspect_item_root  | 0 |
+            | inspect_item_field | 0 |
+
+    Scenario: I should see counter going up after viewing Item Listing
+        Given I see the app
+        When I select the following links
+            | Instrumented |
+            | Item Listing |
+            | Counters     |
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 1 |
+            | item_overview      | 0 |
+            | item_inspect       | 0 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 1 |
+            | get_item           | 0 |
+            | inspect_item_root  | 0 |
+            | inspect_item_field | 0 |
+
+    # the reload has happened in Item Listing, it follows a suspend
+    # will be called as hydration happens.
+    Scenario: Refreshing Item Listing should have only suspend counters
+        Given I see the app
+        When I access the instrumented counters via SSR
+        And I select the component Item Listing
+        And I reload the page
+        And I select the component Counters
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 1 |
+            | item_overview      | 0 |
+            | item_inspect       | 0 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 0 |
+            | inspect_item_root  | 0 |
+            | inspect_item_field | 0 |
+
+    Scenario: Reset CSR Counters work as expected.
+        Given I see the app
+        When I access the instrumented counters via SSR
+        And I select the component Item Listing
+        And I click on Reset CSR Counters
+        And I select the component Counters
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 0 |
+            | item_overview      | 0 |
+            | item_inspect       | 0 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 0 |
+            | inspect_item_root  | 0 |
+            | inspect_item_field | 0 |
+
+    Scenario: Standard usage of the instruments traversing down
+        Given I see the app
+        When I select the following links
+            | Instrumented         |
+            | Item Listing         |
+            | Item 2               |
+            | Inspect path3        |
+            | Inspect path3/field1 |
+        And I access the instrumented counters via CSR
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 1 |
+            | item_overview      | 1 |
+            | item_inspect       | 2 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 1 |
+            | get_item           | 1 |
+            | inspect_item_root  | 1 |
+            | inspect_item_field | 1 |

examples/suspense_tests/e2e/features/check_instrumented_suspense_resource.feature

@@ -0,0 +1,187 @@
+@check_instrumented_suspense_resource
+Feature: Using instrumented counters for real
+    Check that the suspend/suspense and the underlying resources are
+    called with the expected number of times for CSR rendering.
+
+    Background:
+
+        Given I see the app
+        And I select the mode Instrumented
+
+    Scenario: Emulate steps 1 to 5 of issue #2961
+        Given I select the link Target 3##
+        And I refresh the page
+        When I select the following links
+            | Item Listing |
+            | Target 4##   |
+        And I go check the Counters
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 1 |
+            | item_overview      | 2 |
+            | item_inspect       | 0 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 1 |
+            | inspect_item_root  | 0 |
+            | inspect_item_field | 0 |
+
+    Scenario: Emulate step 6 of issue #2961
+        Given I select the link Target 41#
+        And I refresh the page
+        When I select the following links
+            | Target 4##   |
+            | Target 42#   |
+        And I go check the Counters
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 0 |
+            | item_overview      | 1 |
+            | item_inspect       | 2 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 0 |
+            | inspect_item_root  | 1 |
+            | inspect_item_field | 0 |
+
+    Scenario: Emulate step 7 of issue #2961
+        Given I select the link Target 42#
+        And I refresh the page
+        When I select the following links
+            | Target 4##   |
+            | Target 42#   |
+            | Target 41#   |
+        And I go check the Counters
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 0 |
+            | item_overview      | 1 |
+            | item_inspect       | 3 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 0 |
+            | inspect_item_root  | 2 |
+            | inspect_item_field | 0 |
+
+    Scenario: Emulate step 8, "not trigger double fetch".
+        Given I select the link Target 3##
+        And I refresh the page
+        When I select the following links
+            | Item Listing |
+            | Target 4##   |
+            | Target 41#   |
+        And I go check the Counters
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 1 |
+            | item_overview      | 2 |
+            | item_inspect       | 1 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 1 |
+            | inspect_item_root  | 1 |
+            | inspect_item_field | 0 |
+
+    Scenario: Like above, for the "double fetch" which shouldn't happen
+        Given I select the link Target 3##
+        And I refresh the page
+        When I select the following links
+            | Item Listing |
+            | Target 4##   |
+            | Target 41#   |
+            | Target 3##   |
+        And I go check the Counters
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 1 |
+            | item_overview      | 3 |
+            | item_inspect       | 1 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 2 |
+            | inspect_item_root  | 1 |
+            | inspect_item_field | 0 |
+
+    Scenario: Like above, but using 4## instead
+        Given I select the link Target 3##
+        And I refresh the page
+        When I select the following links
+            | Item Listing |
+            | Target 4##   |
+            | Target 41#   |
+            | Target 4##   |
+        And I go check the Counters
+        Then I see the following counters under section
+            | Suspend Calls      |   |
+            | item_listing       | 1 |
+            | item_overview      | 3 |
+            | item_inspect       | 1 |
+        And the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 1 |
+            | inspect_item_root  | 1 |
+            | inspect_item_field | 0 |
+
+    # The following tests previously showed the clear difference between
+    # hydration and CSR, where hydration resulting in extra server API
+    # calls via the resource while CSR did not suffer from the issue.
+    # With #3182 merged the issue is corrected, going up to components
+    # specified by the parent route should no longer result in the
+    # superfluous fetches for resources needed by component about to be
+    # unmounted.
+    Scenario: Emulate part of step 8 of issue #2961
+        Given I select the link Target 3##
+        And I refresh the page
+        When I select the link Item Listing
+        And I go check the Counters
+        Then I see the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 0 |
+            | inspect_item_root  | 0 |
+            | inspect_item_field | 0 |
+
+    Scenario: Emulate above, instead of refresh page, reset csr counters
+        Given I select the link Target 3##
+        And I click on Reset CSR Counters
+        When I select the link Item Listing
+        And I go check the Counters
+        Then I see the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 0 |
+            | inspect_item_root  | 0 |
+            | inspect_item_field | 0 |
+
+    # Further two sets for good measure.
+    Scenario: Start with hydration from Target 41# and go up
+        Given I select the link Target 41#
+        And I refresh the page
+        When I select the link Target 4##
+        And I select the link Item Listing
+        And I go check the Counters
+        Then I see the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 0 |
+            | inspect_item_root  | 0 |
+            | inspect_item_field | 0 |
+
+    Scenario: Emulate the same csr counter reset, for Target 41#.
+        Given I select the link Target 41#
+        And I click on Reset CSR Counters
+        When I select the link Target 4##
+        And I select the link Item Listing
+        And I go check the Counters
+        Then I see the following counters under section
+            | Server Calls (CSR) |   |
+            | list_items         | 0 |
+            | get_item           | 0 |
+            | inspect_item_root  | 0 |
+            | inspect_item_field | 0 |

examples/suspense_tests/e2e/tests/fixtures/action.rs

@@ -37,3 +37,19 @@ pub async fn click_second_button(client: &Client) -> Result<()> {
 
     Ok(())
 }
+
+pub async fn click_reset_counters_button(client: &Client) -> Result<()> {
+    let reset_counter = find::reset_counter(client).await?;
+
+    reset_counter.click().await?;
+
+    Ok(())
+}
+
+pub async fn click_reset_csr_counters_button(client: &Client) -> Result<()> {
+    let reset_counter = find::reset_csr_counter(client).await?;
+
+    reset_counter.click().await?;
+
+    Ok(())
+}

examples/suspense_tests/e2e/tests/fixtures/check.rs

@@ -63,3 +63,38 @@ pub async fn second_count_is(client: &Client, expected: u32) -> Result<()> {
 
     Ok(())
 }
+
+pub async fn instrumented_counts(
+    client: &Client,
+    expected: &[(&str, u32)],
+) -> Result<()> {
+    let mut actual = Vec::<(&str, u32)>::new();
+
+    for (selector, _) in expected.iter() {
+        actual.push((
+            selector,
+            find::instrumented_count(client, selector).await?,
+        ))
+    }
+
+    assert_eq!(actual, expected);
+
+    Ok(())
+}
+
+pub async fn link_text_is_aria_current(client: &Client, text: &str) -> Result<()> {
+    let link = find::link_with_text(client, text).await?;
+
+    link.attr("aria-current").await?
+        .expect(format!("aria-current missing for {text}").as_str());
+
+    Ok(())
+}
+
+pub async fn link_text_is_not_aria_current(client: &Client, text: &str) -> Result<()> {
+    let link = find::link_with_text(client, text).await?;
+
+    link.attr("aria-current").await?
+        .map(|_| anyhow::bail!("aria-current mistakenly set for {text}"))
+        .unwrap_or(Ok(()))
+}

examples/suspense_tests/e2e/tests/fixtures/find.rs

@@ -77,6 +77,43 @@ pub async fn second_button(client: &Client) -> Result<Element> {
     Ok(counter_button)
 }
 
+pub async fn instrumented_count(
+    client: &Client,
+    selector: &str,
+) -> Result<u32> {
+    let element = client
+        .wait()
+        .for_element(Locator::Id(selector))
+        .await
+        .expect(format!("Element #{selector} not found.")
+            .as_str());
+    let text = element.text().await?;
+    let count = text.parse::<u32>()
+        .expect(format!("Element #{selector} does not contain a number.")
+            .as_str());
+    Ok(count)
+}
+
+pub async fn reset_counter(client: &Client) -> Result<Element> {
+    let reset_button = client
+        .wait()
+        .for_element(Locator::Id("reset-counters"))
+        .await
+        .expect("Reset counter input not found");
+
+    Ok(reset_button)
+}
+
+pub async fn reset_csr_counter(client: &Client) -> Result<Element> {
+    let reset_button = client
+        .wait()
+        .for_element(Locator::Id("reset-csr-counters"))
+        .await
+        .expect("Reset CSR counter input not found");
+
+    Ok(reset_button)
+}
+
 async fn component_message(client: &Client, id: &str) -> Result<String> {
     let element =
         client.wait().for_element(Locator::Id(id)).await.expect(
@@ -87,3 +124,12 @@ async fn component_message(client: &Client, id: &str) -> Result<String> {
 
     Ok(text)
 }
+
+pub async fn link_with_text(client: &Client, text: &str) -> Result<Element> {
+    let link = client
+        .wait()
+        .for_element(Locator::LinkText(text))
+        .await
+        .expect(format!("Link not found by `{}`", text).as_str());
+    Ok(link)
+}

examples/suspense_tests/e2e/tests/fixtures/world/action_steps.rs

@@ -1,6 +1,6 @@
 use crate::fixtures::{action, world::AppWorld};
 use anyhow::{Ok, Result};
-use cucumber::{given, when};
+use cucumber::{given, when, gherkin::Step};
 
 #[given("I see the app")]
 #[when("I open the app")]
@@ -12,19 +12,13 @@ async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
 }
 
 #[given(regex = r"^I select the mode (.*)$")]
-async fn i_select_the_mode(world: &mut AppWorld, text: String) -> Result<()> {
-    let client = &world.client;
-    action::click_link(client, &text).await?;
-
-    Ok(())
-}
-
 #[given(regex = r"^I select the component (.*)$")]
 #[when(regex = "^I select the component (.*)$")]
-async fn i_select_the_component(
-    world: &mut AppWorld,
-    text: String,
-) -> Result<()> {
+#[given(regex = "^I select the link (.*)$")]
+#[when(regex = "^I select the link (.*)$")]
+#[when(regex = "^I click on the link (.*)$")]
+#[when(regex = "^I go check the (.*)$")]
+async fn i_select_the_link(world: &mut AppWorld, text: String) -> Result<()> {
     let client = &world.client;
     action::click_link(client, &text).await?;
 
@@ -59,3 +53,69 @@ async fn i_click_the_second_button_n_times(
 
     Ok(())
 }
+
+#[given(regex = "^I (refresh|reload) the (browser|page)$")]
+#[when(regex = "^I (refresh|reload) the (browser|page)$")]
+async fn i_refresh_the_browser(world: &mut AppWorld) -> Result<()> {
+    let client = &world.client;
+    client.refresh().await?;
+
+    Ok(())
+}
+
+#[when(expr = "I click on Reset Counters")]
+async fn i_click_on_reset_counters(world: &mut AppWorld) -> Result<()> {
+    let client = &world.client;
+    action::click_reset_counters_button(client).await?;
+
+    Ok(())
+}
+
+#[given(expr = "I click on Reset CSR Counters")]
+#[when(expr = "I click on Reset CSR Counters")]
+async fn i_click_on_reset_csr_counters(world: &mut AppWorld) -> Result<()> {
+    let client = &world.client;
+    action::click_reset_csr_counters_button(client).await?;
+
+    Ok(())
+}
+
+#[when(expr = "I access the instrumented counters via SSR")]
+async fn i_access_the_instrumented_counters_page_via_ssr(
+    world: &mut AppWorld,
+) -> Result<()> {
+    let client = &world.client;
+    action::click_link(client, "Instrumented").await?;
+    action::click_link(client, "Counters").await?;
+    client.refresh().await?;
+
+    Ok(())
+}
+
+#[when(expr = "I access the instrumented counters via CSR")]
+async fn i_access_the_instrumented_counters_page_via_csr(
+    world: &mut AppWorld,
+) -> Result<()> {
+    let client = &world.client;
+    action::click_link(client, "Instrumented").await?;
+    action::click_link(client, "Counters").await?;
+
+    Ok(())
+}
+
+#[given(expr = "I select the following links")]
+#[when(expr = "I select the following links")]
+async fn i_select_the_following_links(
+    world: &mut AppWorld,
+    step: &Step,
+) -> Result<()> {
+    let client = &world.client;
+
+    if let Some(table) = step.table.as_ref() {
+        for row in table.rows.iter() {
+            action::click_link(client, &row[0]).await?;
+        }
+    }
+
+    Ok(())
+}

examples/suspense_tests/e2e/tests/fixtures/world/check_steps.rs

@@ -1,6 +1,6 @@
 use crate::fixtures::{check, world::AppWorld};
 use anyhow::{Ok, Result};
-use cucumber::then;
+use cucumber::{then, gherkin::Step};
 
 #[then(regex = r"^I see the page title is (.*)$")]
 async fn i_see_the_page_title_is(
@@ -79,3 +79,75 @@ async fn i_see_the_second_count_is(
 
     Ok(())
 }
+
+#[then(regex = r"^I see the (.*) link being bolded$")]
+async fn i_see_the_link_being_bolded(
+    world: &mut AppWorld,
+    text: String,
+) -> Result<()> {
+    let client = &world.client;
+    check::link_text_is_aria_current(client, &text).await?;
+
+    Ok(())
+}
+
+#[then(expr = "I see the following links being bolded")]
+async fn i_see_the_following_links_being_bolded(
+    world: &mut AppWorld,
+    step: &Step,
+) -> Result<()> {
+    let client = &world.client;
+    if let Some(table) = step.table.as_ref() {
+        for row in table.rows.iter() {
+            check::link_text_is_aria_current(client, &row[0]).await?;
+        }
+    }
+
+    Ok(())
+}
+
+#[then(regex = r"^I see the (.*) link not being bolded$")]
+async fn i_see_the_link_being_not_bolded(
+    world: &mut AppWorld,
+    text: String,
+) -> Result<()> {
+    let client = &world.client;
+    check::link_text_is_not_aria_current(client, &text).await?;
+
+    Ok(())
+}
+
+#[then(expr = "I see the following links not being bolded")]
+async fn i_see_the_following_links_not_being_bolded(
+    world: &mut AppWorld,
+    step: &Step,
+) -> Result<()> {
+    let client = &world.client;
+    if let Some(table) = step.table.as_ref() {
+        for row in table.rows.iter() {
+            check::link_text_is_not_aria_current(client, &row[0]).await?;
+        }
+    }
+
+    Ok(())
+}
+
+#[then(expr = "I see the following counters under section")]
+#[then(expr = "the following counters under section")]
+async fn i_see_the_following_counters_under_section(
+    world: &mut AppWorld,
+    step: &Step,
+) -> Result<()> {
+    // FIXME ideally check the mode; for now leave it because effort
+    let client = &world.client;
+    if let Some(table) = step.table.as_ref() {
+        let expected = table.rows
+            .iter()
+            .skip(1)
+            .map(|row| (row[0].as_str(), row[1].parse::<u32>().unwrap()))
+            .collect::<Vec<_>>();
+        check::instrumented_counts(client, &expected).await?;
+    }
+
+    Ok(())
+}

examples/suspense_tests/src/app.rs

@@ -1,3 +1,4 @@
+use crate::instrumented::InstrumentedRoutes;
 use leptos::prelude::*;
 use leptos_router::{
     components::{Outlet, ParentRoute, Redirect, Route, Router, Routes, A},
@@ -41,6 +42,7 @@ pub fn App() -> impl IntoView {
                 <A href="/out-of-order">"Out-of-Order"</A>
                 <A href="/in-order">"In-Order"</A>
                 <A href="/async">"Async"</A>
+                <A href="/instrumented/">"Instrumented"</A>
             </nav>
             <main>
                 <Routes fallback=|| "Page not found.">
@@ -110,6 +112,7 @@ pub fn App() -> impl IntoView {
                         <Route path=StaticSegment("local") view=LocalResource/>
                         <Route path=StaticSegment("none") view=None/>
                     </ParentRoute>
+                    <InstrumentedRoutes/>
                 </Routes>
             </main>
         </Router>

examples/suspense_tests/src/instrumented.rs

@@ -0,0 +1,667 @@
+use leptos::prelude::*;
+use leptos_router::{
+    components::{ParentRoute, Route, A},
+    hooks::use_params,
+    nested_router::Outlet,
+    params::Params,
+    MatchNestedRoutes, ParamSegment, SsrMode, StaticSegment, WildcardSegment,
+};
+
+#[cfg(feature = "ssr")]
+pub(super) mod counter {
+    use std::{
+        collections::HashMap,
+        sync::{
+            atomic::{AtomicU32, Ordering},
+            LazyLock, Mutex,
+        },
+    };
+
+    #[derive(Default)]
+    pub struct Counter(AtomicU32);
+
+    impl Counter {
+        pub const fn new() -> Self {
+            Self(AtomicU32::new(0))
+        }
+
+        pub fn get(&self) -> u32 {
+            self.0.load(Ordering::SeqCst)
+        }
+
+        pub fn inc(&self) -> u32 {
+            self.0.fetch_add(1, Ordering::SeqCst)
+        }
+
+        pub fn reset(&self) {
+            self.0.store(0, Ordering::SeqCst);
+        }
+    }
+
+    #[derive(Default)]
+    pub struct Counters {
+        pub list_items: Counter,
+        pub get_item: Counter,
+        pub inspect_item_root: Counter,
+        pub inspect_item_field: Counter,
+    }
+
+    impl From<&mut Counters> for super::Counters {
+        fn from(counter: &mut Counters) -> Self {
+            Self {
+                get_item: counter.get_item.get(),
+                inspect_item_root: counter.inspect_item_root.get(),
+                inspect_item_field: counter.inspect_item_field.get(),
+                list_items: counter.list_items.get(),
+            }
+        }
+    }
+
+    impl Counters {
+        pub fn reset(&self) {
+            self.get_item.reset();
+            self.inspect_item_root.reset();
+            self.inspect_item_field.reset();
+            self.list_items.reset();
+        }
+    }
+
+    pub static COUNTERS: LazyLock<Mutex<HashMap<u64, Counters>>> =
+        LazyLock::new(|| Mutex::new(HashMap::new()));
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
+pub struct Item {
+    id: i64,
+    name: Option<String>,
+    field: Option<String>,
+}
+
+#[server]
+async fn list_items(ticket: u64) -> Result<Vec<i64>, ServerFnError> {
+    // emulate database query overhead
+    tokio::time::sleep(std::time::Duration::from_millis(25)).await;
+    (*counter::COUNTERS)
+        .lock()
+        .expect("somehow panicked elsewhere")
+        .entry(ticket)
+        .or_default()
+        .list_items
+        .inc();
+    Ok(vec![1, 2, 3, 4])
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
+pub struct GetItemResult(pub Item, pub Vec<String>);
+
+#[server]
+async fn get_item(
+    ticket: u64,
+    id: i64,
+) -> Result<GetItemResult, ServerFnError> {
+    // emulate database query overhead
+    tokio::time::sleep(std::time::Duration::from_millis(25)).await;
+    (*counter::COUNTERS)
+        .lock()
+        .expect("somehow panicked elsewhere")
+        .entry(ticket)
+        .or_default()
+        .get_item
+        .inc();
+    let name = None::<String>;
+    let field = None::<String>;
+    Ok(GetItemResult(
+        Item { id, name, field },
+        ["path1", "path2", "path3"]
+            .into_iter()
+            .map(str::to_string)
+            .collect::<Vec<_>>(),
+    ))
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
+pub struct InspectItemResult(pub Item, pub String, pub Vec<String>);
+
+#[server]
+async fn inspect_item(
+    ticket: u64,
+    id: i64,
+    path: String,
+) -> Result<InspectItemResult, ServerFnError> {
+    // emulate database query overhead
+    tokio::time::sleep(std::time::Duration::from_millis(25)).await;
+    let mut split = path.split('/');
+    let name = split.next().map(str::to_string);
+    let path = name
+        .clone()
+        .expect("name should have been defined at this point");
+    let field = split
+        .next()
+        .and_then(|s| (!s.is_empty()).then(|| s.to_string()));
+    if field.is_none() {
+        (*counter::COUNTERS)
+            .lock()
+            .expect("somehow panicked elsewhere")
+            .entry(ticket)
+            .or_default()
+            .inspect_item_root
+            .inc();
+    } else {
+        (*counter::COUNTERS)
+            .lock()
+            .expect("somehow panicked elsewhere")
+            .entry(ticket)
+            .or_default()
+            .inspect_item_field
+            .inc();
+    }
+    Ok(InspectItemResult(
+        Item { id, name, field },
+        path,
+        ["field1", "field2", "field3"]
+            .into_iter()
+            .map(str::to_string)
+            .collect::<Vec<_>>(),
+    ))
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
+pub struct Counters {
+    pub get_item: u32,
+    pub inspect_item_root: u32,
+    pub inspect_item_field: u32,
+    pub list_items: u32,
+}
+
+#[server]
+async fn get_counters(ticket: u64) -> Result<Counters, ServerFnError> {
+    Ok((*counter::COUNTERS)
+        .lock()
+        .expect("somehow panicked elsewhere")
+        .entry(ticket)
+        .or_default()
+        .into())
+}
+
+#[server(ResetCounters)]
+async fn reset_counters(ticket: u64) -> Result<(), ServerFnError> {
+    (*counter::COUNTERS)
+        .lock()
+        .expect("somehow panicked elsewhere")
+        .entry(ticket)
+        .or_default()
+        .reset();
+    // leptos::logging::log!("counters for ticket {ticket} have been reset");
+    Ok(())
+}
+
+#[derive(Clone, Default)]
+pub struct SuspenseCounters {
+    item_overview: u32,
+    item_inspect: u32,
+    item_listing: u32,
+}
+
+#[component]
+pub fn InstrumentedRoutes() -> impl MatchNestedRoutes + Clone {
+    // TODO should make this mode configurable via feature flag?
+    let ssr = SsrMode::Async;
+    view! {
+        <ParentRoute path=StaticSegment("instrumented") view=InstrumentedRoot ssr>
+            <Route path=StaticSegment("/") view=InstrumentedTop/>
+            <ParentRoute path=StaticSegment("item") view=ItemRoot>
+                <Route path=StaticSegment("/") view=ItemListing/>
+                <ParentRoute path=ParamSegment("id") view=ItemTop>
+                    <Route path=StaticSegment("/") view=ItemOverview/>
+                    <Route path=WildcardSegment("path") view=ItemInspect/>
+                </ParentRoute>
+            </ParentRoute>
+            <Route path=StaticSegment("counters") view=ShowCounters/>
+        </ParentRoute>
+    }
+    .into_inner()
+}
+
+#[derive(Copy, Clone)]
+pub struct Ticket(pub u64);
+
+#[derive(Copy, Clone)]
+pub struct CSRTicket(pub u64);
+
+#[cfg(feature = "ssr")]
+fn inst_ticket() -> u64 {
+    // SSR will always use 0 for the ticket
+    0
+}
+
+#[cfg(not(feature = "ssr"))]
+fn inst_ticket() -> u64 {
+    // CSR will use a random number for the ticket
+    (js_sys::Math::random() * ((u64::MAX - 1) as f64) + 1f64) as u64
+}
+
+#[component]
+fn InstrumentedRoot() -> impl IntoView {
+    let counters = RwSignal::new(SuspenseCounters::default());
+    provide_context(counters);
+    provide_field_nav_portlet_context();
+
+    // Generate a ID directly on this component.  Rather than relying on
+    // additional server functions, doing it this way emulates more
+    // standard workflows better and to avoid having to add another
+    // thing to instrument/interfere with the typical use case.
+    // Downside is that randomness has a chance to conflict.
+    //
+    // Furthermore, this approach **will** result in unintuitive
+    // behavior when it isn't accounted for - specifically, the reason
+    // for this design is that when SSR it will guarantee usage of `0`
+    // as the ticket, while CSR it will be of some other value as the
+    // version it uses will be random.  However, when trying to get back
+    // the counters associated with the ticket, rendering using SSR will
+    // always produce the SSR version and this quirk will need to be
+    // accounted for.
+    let ticket = inst_ticket();
+    // leptos::logging::log!(
+    //     "Ticket for this InstrumentedRoot instance: {ticket}"
+    // );
+    provide_context(Ticket(ticket));
+
+    let csr_ticket = RwSignal::<Option<CSRTicket>>::new(None);
+
+    let reset_counters = ServerAction::<ResetCounters>::new();
+
+    Effect::new(move |_| {
+        let ticket = expect_context::<Ticket>().0;
+        csr_ticket.set(Some(CSRTicket(ticket)));
+    });
+
+    view! {
+        <section id="instrumented">
+            <nav>
+                <a href="/">"Site Root"</a>
+                <A href="./" exact=true>"Instrumented Root"</A>
+                <A href="item/" strict_trailing_slash=true>"Item Listing"</A>
+                <A href="counters" strict_trailing_slash=true>"Counters"</A>
+            </nav>
+            <FieldNavPortlet/>
+            <Outlet/>
+            <Suspense>{
+                move || Suspend::new(async move {
+                    let clear_suspense_counters = move |_| {
+                        counters.update(|c| *c = SuspenseCounters::default());
+                    };
+                    csr_ticket.get().map(|ticket| {
+                        let ticket = ticket.0;
+                        view! {
+                            <ActionForm action=reset_counters>
+                                <input type="hidden" name="ticket" value=format!("{ticket}") />
+                                <input
+                                    id="reset-csr-counters"
+                                    type="submit"
+                                    value="Reset CSR Counters"
+                                    on:click=clear_suspense_counters/>
+                            </ActionForm>
+                        }
+                    })
+                })
+            }</Suspense>
+            <footer>
+                <nav>
+                    <A href="item/3/">"Target 3##"</A>
+                    <A href="item/4/">"Target 4##"</A>
+                    <A href="item/4/path1/">"Target 41#"</A>
+                    <A href="item/4/path2/">"Target 42#"</A>
+                    <A href="item/4/path2/field1">"Target 421"</A>
+                    <A href="item/1/path2/field3">"Target 123"</A>
+                </nav>
+            </footer>
+        </section>
+    }
+}
+
+#[component]
+fn InstrumentedTop() -> impl IntoView {
+    view! {
+        <h1>"Instrumented Tests"</h1>
+        <p>"These tests validates the number of invocations of server functions and suspenses per access."</p>
+        <ul>
+            // not using `A` because currently some bugs with artix
+            <li><a href="item/">"Item Listing"</a></li>
+            <li><a href="item/4/path1/">"Target 41#"</a></li>
+        </ul>
+    }
+}
+
+#[component]
+fn ItemRoot() -> impl IntoView {
+    let ticket = expect_context::<Ticket>().0;
+    provide_context(Resource::new_blocking(
+        move || (),
+        move |_| async move { list_items(ticket).await },
+    ));
+
+    view! {
+        <h2>"<ItemRoot/>"</h2>
+        <Outlet/>
+    }
+}
+
+#[component]
+fn ItemListing() -> impl IntoView {
+    let suspense_counters = expect_context::<RwSignal<SuspenseCounters>>();
+    let resource =
+        expect_context::<Resource<Result<Vec<i64>, ServerFnError>>>();
+    let item_listing = move || {
+        Suspend::new(async move {
+            let result = resource.await.map(|items| items
+            .into_iter()
+            .map(move |item|
+                // FIXME seems like relative link isn't working, it is currently
+                // adding an extra `/` in artix; manually construct `a` instead.
+                // <li><A href=format!("./{item}/")>"Item "{item}</A></li>
+                view! {
+                    <li><a href=format!("/instrumented/item/{item}/")>"Item "{item}</a></li>
+                }
+            )
+            .collect_view()
+        );
+            suspense_counters.update_untracked(|c| c.item_listing += 1);
+            result
+        })
+    };
+
+    view! {
+        <h3>"<ItemListing/>"</h3>
+        <ul>
+        <Suspense>
+            {item_listing}
+        </Suspense>
+        </ul>
+    }
+}
+
+#[derive(Params, PartialEq, Clone, Debug)]
+struct ItemTopParams {
+    id: Option<i64>,
+}
+
+#[component]
+fn ItemTop() -> impl IntoView {
+    let ticket = expect_context::<Ticket>().0;
+    let params = use_params::<ItemTopParams>();
+    // map result to an option as the focus isn't error rendering
+    provide_context(Resource::new_blocking(
+        move || params.get().map(|p| p.id),
+        move |id| async move {
+            match id {
+                Err(_) => None,
+                Ok(Some(id)) => get_item(ticket, id).await.ok(),
+                _ => None,
+            }
+        },
+    ));
+    view! {
+        <h4>"<ItemTop/>"</h4>
+        <Outlet/>
+    }
+}
+
+#[component]
+fn ItemOverview() -> impl IntoView {
+    let suspense_counters = expect_context::<RwSignal<SuspenseCounters>>();
+    let resource = expect_context::<Resource<Option<GetItemResult>>>();
+    let item_view = move || {
+        Suspend::new(async move {
+            let result = resource.await.map(|GetItemResult(item, names)| view! {
+            <p>{format!("Viewing {item:?}")}</p>
+            <ul>{
+                names.into_iter()
+                    .map(|name| {
+                        // FIXME seems like relative link isn't working, it is currently
+                        // adding an extra `/` in artix; manually construct `a` instead.
+                        // <li><A href=format!("./{name}/")>{format!("Inspect {name}")}</A></li>
+                        let id = item.id;
+                        view! {
+                            <li><a href=format!("/instrumented/item/{id}/{name}/")>
+                                "Inspect "{name.clone()}
+                            </a></li>
+                        }
+                    })
+                    .collect_view()
+            }</ul>
+        });
+            suspense_counters.update_untracked(|c| c.item_overview += 1);
+            result
+        })
+    };
+
+    view! {
+        <h5>"<ItemOverview/>"</h5>
+        <Suspense>
+            {item_view}
+        </Suspense>
+    }
+}
+
+#[derive(Params, PartialEq, Clone, Debug)]
+struct ItemInspectParams {
+    path: Option<String>,
+}
+
+#[component]
+fn ItemInspect() -> impl IntoView {
+    let ticket = expect_context::<Ticket>().0;
+    let suspense_counters = expect_context::<RwSignal<SuspenseCounters>>();
+    let params = use_params::<ItemInspectParams>();
+    let res_overview = expect_context::<Resource<Option<GetItemResult>>>();
+    let res_inspect = Resource::new_blocking(
+        move || params.get().map(|p| p.path),
+        move |p| async move {
+            // leptos::logging::log!("res_inspect: res_overview.await");
+            let overview = res_overview.await;
+            // leptos::logging::log!("res_inspect: resolved res_overview.await");
+            // let result =
+            match (overview, p) {
+                (Some(item), Ok(Some(path))) => {
+                    // leptos::logging::log!("res_inspect: inspect_item().await");
+                    inspect_item(ticket, item.0.id, path.clone()).await.ok()
+                }
+                _ => None,
+            }
+            // ;
+            // leptos::logging::log!("res_inspect: resolved inspect_item().await");
+            // result
+        },
+    );
+    on_cleanup(|| {
+        if let Some(c) = use_context::<WriteSignal<Option<FieldNavCtx>>>() {
+            c.set(None);
+        }
+    });
+    let inspect_view = move || {
+        // leptos::logging::log!("inspect_view closure invoked");
+        Suspend::new(async move {
+            // leptos::logging::log!("inspect_view Suspend::new() called");
+            let result = res_inspect.await.map(|InspectItemResult(item, name, fields)| {
+                // leptos::logging::log!("inspect_view res_inspect awaited");
+                let id = item.id;
+                expect_context::<WriteSignal<Option<FieldNavCtx>>>().set(Some(
+                    fields.iter()
+                        .map(|field| FieldNavItem {
+                            href: format!("/instrumented/item/{id}/{name}/{field}"),
+                            text: field.to_string(),
+                        })
+                        .collect::<Vec<_>>()
+                        .into()
+                ));
+                view! {
+                    <p>{format!("Inspecting {item:?}")}</p>
+                    <ul>{
+                        fields.iter()
+                            .map(|field| {
+                                // FIXME seems like relative link to root for a wildcard isn't
+                                // working as expected, so manually construct `a` instead.
+                                // let text = format!("Inspect {name}/{field}");
+                                // view! {
+                                //     <li><A href=format!("{field}")>{text}</A></li>
+                                // }
+                                view! {
+                                    <li><a href=format!("/instrumented/item/{id}/{name}/{field}")>{
+                                        format!("Inspect {name}/{field}")
+                                    }</a></li>
+                                }
+                            })
+                            .collect_view()
+                    }</ul>
+                }
+            });
+            suspense_counters.update_untracked(|c| c.item_inspect += 1);
+            // leptos::logging::log!(
+            //     "returning result, result.is_some() = {}, count = {}",
+            //     result.is_some(),
+            //     suspense_counters.get().item_inspect,
+            // );
+            result
+        })
+    };
+
+    view! {
+        <h5>"<ItemInspect/>"</h5>
+        <Suspense>
+            {inspect_view}
+        </Suspense>
+    }
+}
+
+#[component]
+fn ShowCounters() -> impl IntoView {
+    // There is _weirdness_ in this view.  The `Server Calls` counters
+    // will be acquired via the expected mode and be rendered as such.
+    //
+    // However, upon `Reset Counters`, the mode from which the reset
+    // was issued will result in the rendering be reflected as such, so
+    // if the intial state was SSR, resetting under CSR will result in
+    // the CSR counters be rendered after.  However for the intents and
+    // purpose for the testing only the CSR is cared for.
+    //
+    // At the end of the day, it is possible to have both these be
+    // separated out, but for the purpose of this test the focus is not
+    // on the SSR side of things (at least until further regression is
+    // discovered that affects SSR directly).
+    let ticket = expect_context::<Ticket>().0;
+    let suspense_counters = expect_context::<RwSignal<SuspenseCounters>>();
+    let reset_counters = ServerAction::<ResetCounters>::new();
+    let res_counter = Resource::new(
+        move || reset_counters.version().get(),
+        move |_| async move {
+            (
+                get_counters(ticket).await,
+                if ticket == 0 { "SSR" } else { "CSR" }.to_string(),
+                ticket,
+            )
+        },
+    );
+    let counter_view = move || {
+        Suspend::new(async move {
+            // ensure current mode and ticket are both updated
+            let (counters, mode, ticket) = res_counter.await;
+            counters.map(|counters| {
+                let clear_suspense_counters = move |_| {
+                    suspense_counters.update(|c| {
+                        // leptos::logging::log!("resetting suspense counters");
+                        *c = SuspenseCounters::default();
+                    });
+                };
+                view! {
+                    <h3 id="server-calls">"Server Calls ("{mode}")"</h3>
+                    <dl>
+                        <dt>"list_items"</dt>
+                        <dd id="list_items">{counters.list_items}</dd>
+                        <dt>"get_item"</dt>
+                        <dd id="get_item">{counters.get_item}</dd>
+                        <dt>"inspect_item_root"</dt>
+                        <dd id="inspect_item_root">{counters.inspect_item_root}</dd>
+                        <dt>"inspect_item_field"</dt>
+                        <dd id="inspect_item_field">{counters.inspect_item_field}</dd>
+                    </dl>
+                    <ActionForm action=reset_counters>
+                        <input type="hidden" name="ticket" value=format!("{ticket}") />
+                        <input
+                            id="reset-counters"
+                            type="submit"
+                            value="Reset Counters"
+                            on:click=clear_suspense_counters/>
+                    </ActionForm>
+                }
+            })
+        })
+    };
+
+    view! {
+        <h2>"Counters"</h2>
+
+        <h3 id="suspend-calls">"Suspend Calls"</h3>
+        {move || suspense_counters.with(|c| view! {
+            <dl>
+                <dt>"item_listing"</dt>
+                <dd id="item_listing">{c.item_listing}</dd>
+                <dt>"item_overview"</dt>
+                <dd id="item_overview">{c.item_overview}</dd>
+                <dt>"item_inspect"</dt>
+                <dd id="item_inspect">{c.item_inspect}</dd>
+            </dl>
+        })}
+
+        <Suspense>
+            {counter_view}
+        </Suspense>
+    }
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Clone, Debug, PartialEq)]
+pub struct FieldNavItem {
+    pub href: String,
+    pub text: String,
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Clone, Debug, PartialEq)]
+pub struct FieldNavCtx(pub Option<Vec<FieldNavItem>>);
+
+impl From<Vec<FieldNavItem>> for FieldNavCtx {
+    fn from(item: Vec<FieldNavItem>) -> Self {
+        Self(Some(item))
+    }
+}
+
+#[component]
+pub fn FieldNavPortlet() -> impl IntoView {
+    let ctx = expect_context::<ReadSignal<Option<FieldNavCtx>>>();
+    move || {
+        let ctx = ctx.get();
+        ctx.map(|ctx| {
+            view! {
+                <div id="FieldNavPortlet">
+                    <span>"FieldNavPortlet:"</span>
+                    <nav>{
+                        ctx.0.map(|ctx| {
+                            ctx.into_iter()
+                                .map(|FieldNavItem { href, text }| {
+                                    view! {
+                                        <A href=href>{text}</A>
+                                    }
+                                })
+                                .collect_view()
+                        })
+                    }</nav>
+                </div>
+            }
+        })
+    }
+}
+
+pub fn provide_field_nav_portlet_context() {
+    // wrapping the Ctx in an Option allows better ergonomics whenever it isn't needed
+    let (ctx, set_ctx) = signal(None::<FieldNavCtx>);
+    provide_context(ctx);
+    provide_context(set_ctx);
+}

examples/suspense_tests/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod app;
+mod instrumented;
 
 #[cfg(feature = "hydrate")]
 #[wasm_bindgen::prelude::wasm_bindgen]

examples/suspense_tests/src/main.rs

@@ -41,7 +41,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root))
+            .service(Files::new("/", site_root.as_ref()))
     })
     .bind(addr)?
     .workers(1)

examples/tailwind_actix/end2end/tests/example.spec.ts

@@ -1,7 +1,7 @@
 import { test, expect } from "@playwright/test";
 
-test("should see the welcome message", async ({ page }) => {
+test("homepage has title 'Leptos + Tailwindcss'", async ({ page }) => {
   await page.goto("http://localhost:3000/");
 
-  await expect(page.locator("h2")).toHaveText("Welcome to Leptos with Tailwind");
+  await expect(page).toHaveTitle("Leptos + Tailwindcss");
 });

examples/tailwind_actix/src/app.rs

@@ -22,24 +22,29 @@ pub fn App() -> impl IntoView {
 
 #[component]
 fn Home() -> impl IntoView {
-    let (count, set_count) = signal(0);
+    let (value, set_value) = signal(0);
 
+    // thanks to https://tailwindcomponents.com/component/blue-buttons-example for the showcase layout
     view! {
-        <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-amber-600 hover:bg-sky-700 px-5 py-3 text-white rounded-lg"
-                on:click=move |_| set_count.update(|count| *count += 1)
-            >
-                "Something's here | "
-                {move || if count.get() == 0 {
-                    "Click me!".to_string()
-                } else {
-                    count.get().to_string()
-                }}
-                " | Some more text"
-            </button>
+        <Title text="Leptos + Tailwindcss"/>
+        <main>
+            <div class="bg-gradient-to-tl from-blue-800 to-blue-500 text-white font-mono flex flex-col min-h-screen">
+                <div class="flex flex-row-reverse flex-wrap m-auto">
+                    <button on:click=move |_| set_value.update(|value| *value += 1) class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white">
+                        "+"
+                    </button>
+                    <button class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-800 border-blue-900 text-white">
+                        {value}
+                    </button>
+                    <button
+                        on:click=move |_| set_value.update(|value| *value -= 1)
+                        class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white"
+                        class:invisible=move || {value.get() < 1}
+                    >
+                        "-"
+                    </button>
+                </div>
+            </div>
         </main>
     }
 }

examples/tailwind_actix/src/main.rs

@@ -40,7 +40,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root))
+            .service(Files::new("/", site_root.as_ref()))
             .wrap(middleware::Compress::default())
     })
     .bind(&addr)?

examples/tailwind_actix/tailwind.config.js

@@ -1,7 +1,10 @@
 /** @type {import('tailwindcss').Config} */
 module.exports = {
-  content: { 
+  content: {
     files: ["*.html", "./src/**/*.rs"],
+    transform: {
+      rs: (content) => content.replace(/(?:^|\s)class:/g, ' '),
+    },
   },
   theme: {
     extend: {},

examples/tailwind_axum/end2end/tests/example.spec.ts

@@ -1,9 +1,7 @@
 import { test, expect } from "@playwright/test";
 
-test("homepage has title and links to intro page", async ({ page }) => {
+test("homepage has title 'Leptos + Tailwindcss'", async ({ page }) => {
   await page.goto("http://localhost:3000/");
 
-  await expect(page).toHaveTitle("Welcome to Leptos");
-
-  await expect(page.locator("h1")).toHaveText("Welcome to Leptos!");
+  await expect(page).toHaveTitle("Leptos + Tailwindcss");
 });

examples/tailwind_axum/src/app.rs

@@ -54,7 +54,11 @@ fn Home() -> impl IntoView {
                     <button class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-800 border-blue-900 text-white">
                         {value}
                     </button>
-                    <button on:click=move |_| set_value.update(|value| *value -= 1) class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white">
+                    <button
+                        on:click=move |_| set_value.update(|value| *value -= 1)
+                        class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white"
+                        class:invisible=move || {value.get() < 1}
+                    >
                         "-"
                     </button>
                 </div>

examples/tailwind_axum/tailwind.config.js

@@ -1,9 +1,13 @@
 /** @type {import('tailwindcss').Config} */
 module.exports = {
-  content: ["*.html", "./src/**/*.rs",],
+  content: {
+    files: ["*.html", "./src/**/*.rs"],
+    transform: {
+      rs: (content) => content.replace(/(?:^|\s)class:/g, ' '),
+    },
+  },
   theme: {
     extend: {},
   },
   plugins: [],
 }
-

examples/tailwind_csr/end2end/tests/example.spec.ts

@@ -1,9 +1,7 @@
 import { test, expect } from "@playwright/test";
 
-test("homepage has title and links to intro page", async ({ page }) => {
+test("homepage has title 'Leptos + Tailwindcss'", async ({ page }) => {
   await page.goto("http://localhost:8080/");
 
-  await expect(page).toHaveTitle("Leptos • Counter with Tailwind");
-
-  await expect(page.locator("h2")).toHaveText("Welcome to Leptos with Tailwind");
+  await expect(page).toHaveTitle("Leptos + Tailwindcss");
 });

examples/tailwind_csr/src/app.rs

@@ -22,24 +22,29 @@ pub fn App() -> impl IntoView {
 
 #[component]
 fn Home() -> impl IntoView {
-    let (count, set_count) = signal(0);
+    let (value, set_value) = signal(0);
 
+    // thanks to https://tailwindcomponents.com/component/blue-buttons-example for the showcase layout
     view! {
-        <div 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-amber-600 hover:bg-sky-700 px-5 py-3 text-white rounded-lg"
-                on:click=move |_| set_count.update(|count| *count += 1)
-            >
-                "Something's here | "
-                {move || if count.get() == 0 {
-                    "Click me!".to_string()
-                } else {
-                    count.get().to_string()
-                }}
-                " | Some more text"
-            </button>
-        </div>
+        <Title text="Leptos + Tailwindcss"/>
+        <main>
+            <div class="bg-gradient-to-tl from-blue-800 to-blue-500 text-white font-mono flex flex-col min-h-screen">
+                <div class="flex flex-row-reverse flex-wrap m-auto">
+                    <button on:click=move |_| set_value.update(|value| *value += 1) class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white">
+                        "+"
+                    </button>
+                    <button class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-800 border-blue-900 text-white">
+                        {value}
+                    </button>
+                    <button
+                        on:click=move |_| set_value.update(|value| *value -= 1)
+                        class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white"
+                        class:invisible=move || {value.get() < 1}
+                    >
+                        "-"
+                    </button>
+                </div>
+            </div>
+        </main>
     }
 }