fix Suspense to use the old, Effect-like scheduling after fixing RenderEffect

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

@@ -1,21 +1,23 @@
 name: CI Changed Examples
+
 on:
   push:
     branches:
       - main
-      - leptos_0.6
   pull_request:
     branches:
       - main
-      - leptos_0.6
+
 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,13 @@
 name: CI Examples
+
 on:
   push:
     branches:
       - main
-      - leptos_0.6
   pull_request:
     branches:
       - main
-      - leptos_0.6
+
 jobs:
   get-leptos-changed:
     uses: ./.github/workflows/get-leptos-changed.yml

.github/workflows/ci-semver.yml

@@ -1,24 +1,27 @@
 name: CI semver
+
 on:
   push:
     branches:
       - main
-      - leptos_0.6
   pull_request:
     branches:
       - main
-      - leptos_0.6
+
 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'
     name: Run semver check (nightly-2024-08-01)
     runs-on: ubuntu-latest
+
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+
       - name: Semver Checks
         uses: obi1kenobi/cargo-semver-checks-action@v2
         with:

.github/workflows/ci.yml

@@ -1,25 +1,50 @@
 name: CI
+
 on:
   push:
     branches:
       - main
-      - leptos_0.6
   pull_request:
     branches:
       - main
-      - leptos_0.6
+
 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, get-leptos-matrix]
+    needs: [get-leptos-changed]
     if: needs.get-leptos-changed.outputs.leptos_changed == 'true'
     strategy:
-      matrix: ${{ fromJSON(needs.get-leptos-matrix.outputs.matrix) }}
-      fail-fast: false
+      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,
+          ]
     uses: ./.github/workflows/run-cargo-make-task.yml
     with:
       directory: ${{ matrix.directory }}

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

@@ -1,10 +1,12 @@
 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
@@ -16,6 +18,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+
       - name: Get example files that changed
         id: changed-files
         uses: tj-actions/changed-files@v45
@@ -23,10 +26,13 @@ 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,34 +1,38 @@
 name: Get Examples Matrix Call
+
 on:
   workflow_call:
     outputs:
       matrix:
         description: "Matrix"
         value: ${{ jobs.create.outputs.matrix }}
+
 jobs:
   create:
     name: Create Examples Matrix
     runs-on: ubuntu-latest
     outputs:
       matrix: ${{ steps.set-matrix.outputs.matrix }}
-    env:
-      # separate examples using "|" (vertical bar) char like "a|b|c".
-      # cargo-make should be excluded by default.
-      EXCLUDED_EXAMPLES: cargo-make
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+
       - name: Install jq
         run: sudo apt-get install jq
+
       - name: Set Matrix
         id: set-matrix
         run: |
-          examples=$(ls -1d examples/*/ |
-          grep -vE "($EXCLUDED_EXAMPLES)" |
-          sed 's/\/$//' |
+          examples=$(ls examples |
+          awk '{print "examples/" $0}' |
+          grep -v .md |
+          grep -v examples/Makefile.toml |
+          grep -v examples/cargo-make |
+          grep -v examples/gtk |
           jq -R -s -c 'split("\n")[:-1]')
           echo "Example Directories: $examples"
           echo "matrix={\"directory\":$examples}" >> "$GITHUB_OUTPUT"
+
       - name: Print Location Info
         run: |
           echo "Workspace: ${{ github.workspace }}"

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

@@ -1,10 +1,12 @@
 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
@@ -16,19 +18,40 @@ 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_ignore: |
-            .*/**/*
-            cargo-make/**/*
-            examples/**/*
-            projects/**/*
-            benchmarks/**/*
-            docs/**/*
+          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/**
+
       - 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

@@ -1,32 +0,0 @@
-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,4 +1,5 @@
 name: Run Task
+
 on:
   workflow_call:
     inputs:
@@ -11,53 +12,70 @@ on:
       toolchain:
         required: true
         type: string
+
 env:
   CARGO_TERM_COLOR: always
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
+
 jobs:
   test:
     name: Run ${{ inputs.cargo_make_task }} (${{ inputs.toolchain }})
     runs-on: ubuntu-latest
+
     steps:
       # Setup environment
       - uses: actions/checkout@v4
+
       - name: Setup Rust
         uses: 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
+
       - 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:
@@ -65,6 +83,7 @@ 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
@@ -80,6 +99,7 @@ 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)
@@ -93,16 +113,12 @@ jobs:
               echo Playwright is not required
             fi
           done
+
       - name: Install Deno
         uses: denoland/setup-deno@v1
         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: |

Cargo.toml

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

any_error/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "throw_error"
-version = "0.2.0-beta6"
+version = "0.2.0-beta2"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"

benchmarks/Cargo.toml

@@ -2,8 +2,7 @@
 name = "benchmarks"
 version = "0.1.0"
 edition = "2021"
-# std::sync::LazyLock is stabilized in Rust version 1.80.0
-rust-version = "1.80.0"
+rust-version.workspace = true
 
 [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>"#;
 
-
-    static  LazyCell<TERA>: Tera = LazyLock::new(|| {
-        let mut tera = Tera::default();
-        tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
-        tera
-    });
-
+    lazy_static::lazy_static! {
+        static ref TERA: Tera = {
+            let mut tera = Tera::default();
+            tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
+            tera
+        };
+    }
 
     #[derive(Serialize, Deserialize)]
     struct Counter {

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::*;
 
-
-        static LazyLock<TERA>: Tera = LazyLock( || {
+    lazy_static::lazy_static! {
+        static ref TERA: Tera = {
             let mut tera = Tera::default();
             tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
             tera
-        });
-
+        };
+    }
 
     #[derive(Serialize, Deserialize)]
     struct Todo {
@@ -131,13 +131,13 @@ fn tera_todomvc_ssr_1000(b: &mut Bencher) {
     use serde::{Deserialize, Serialize};
     use tera::*;
 
-
-    static  TERA: LazyLock<Tera> = LazyLock::new(|| {
-        let mut tera = Tera::default();
-        tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
-        tera
-    });
-
+    lazy_static::lazy_static! {
+        static ref TERA: Tera = {
+            let mut tera = Tera::default();
+            tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
+            tera
+        };
+    }
 
     #[derive(Serialize, Deserialize)]
     struct Todo {

either_of/src/lib.rs

@@ -133,104 +133,3 @@ tuples!(EitherOf13 + EitherOf13Future + EitherOf13FutureProj => A, B, C, D, E, F
 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);
-
-/// Matches over the first expression and returns an either ([`Either`], [`EitherOf3`], ... [`EitherOf6`])
-/// 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),
-        }
-    }; // if you need more eithers feel free to open a PR ;-)
-}
-
-// 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,
-    );
-}

examples/axum_js_ssr/Cargo.toml

@@ -1,111 +0,0 @@
-[package]
-name = "axum_js_ssr"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-crate-type = ["cdylib", "rlib"]
-
-[dependencies]
-axum = { version = "0.7.5", optional = true }
-console_error_panic_hook = "0.1.7"
-console_log = "1.0"
-gloo-utils = "0.2.0"
-html-escape = "0.2.13"
-http-body-util = { version = "0.1.0", optional = true }
-js-sys = { version = "0.3.69", optional = true }
-leptos = { path = "../../leptos", features = ["tracing"] }
-leptos_meta = { path = "../../meta" }
-leptos_axum = { path = "../../integrations/axum", optional = true }
-leptos_router = { path = "../../router" }
-serde = { version = "1.0", features = ["derive"] }
-thiserror = "1.0"
-tokio = { version = "1.39", features = [ "rt-multi-thread", "macros", "time" ], optional = true }
-tower = { version = "0.4.13", optional = true }
-tower-http = { version = "0.5.2", features = ["fs"], optional = true }
-wasm-bindgen = "0.2.92"
-web-sys = { version = "0.3.69", features = [ "AddEventListenerOptions", "Document", "Element", "Event", "EventListener", "EventTarget", "Performance", "Window" ], optional = true }
-
-[features]
-hydrate = [
-  "leptos/hydrate",
-  "dep:js-sys",
-  "dep:web-sys",
-]
-ssr = [
-  "dep:axum",
-  "dep:http-body-util",
-  "dep:tower",
-  "dep:tower-http",
-  "dep:tokio",
-  "leptos/ssr",
-  "leptos_meta/ssr",
-  "dep:leptos_axum",
-  "leptos_router/ssr",
-]
-
-[profile.release]
-panic = "abort"
-
-[profile.wasm-release]
-inherits = "release"
-opt-level = 'z'
-lto = true
-codegen-units = 1
-panic = "abort"
-
-[package.metadata.cargo-all-features]
-denylist = ["axum", "tower", "tower-http", "tokio", "sqlx", "leptos_axum"]
-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
-output-name = "axum_js_ssr"
-# The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
-site-root = "target/site"
-# The site-root relative folder where all compiled output (JS, WASM and CSS) is written
-# Defaults to pkg
-site-pkg-dir = "pkg"
-# [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
-style-file = "style/main.scss"
-# Assets source dir. All files found here will be copied and synchronized to site-root.
-# The assets-dir cannot have a sub directory with the same name/path as site-pkg-dir.
-#
-# Optional. Env: LEPTOS_ASSETS_DIR.
-assets-dir = "assets"
-# The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
-site-addr = "127.0.0.1:3000"
-# The port to use for automatic reload monitoring
-reload-port = 3001
-# [Optional] Command to use when running end2end tests. It will run in the end2end dir.
-#   [Windows] for non-WSL use "npx.cmd playwright test"
-#   This binary name can be checked in Powershell with Get-Command npx
-end2end-cmd = "npx playwright test"
-end2end-dir = "end2end"
-#  The browserlist query used for optimizing the CSS.
-browserquery = "defaults"
-# Set by cargo-leptos watch when building with that tool. Controls whether autoreload JS will be included in the head
-watch = false
-# The environment Leptos will run in, usually either "DEV" or "PROD"
-env = "DEV"
-# The features to use when compiling the bin target
-#
-# Optional. Can be over-ridden with the command line parameter --bin-features
-bin-features = ["ssr"]
-
-# If the --no-default-features flag should be used when compiling the bin target
-#
-# Optional. Defaults to false.
-bin-default-features = false
-
-# The features to use when compiling the lib target
-#
-# Optional. Can be over-ridden with the command line parameter --lib-features
-lib-features = ["hydrate"]
-
-# If the --no-default-features flag should be used when compiling the lib target
-#
-# Optional. Defaults to false.
-lib-default-features = false
-
-lib-profile-release = "wasm-release"

examples/axum_js_ssr/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Tommy Yu
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

examples/axum_js_ssr/Makefile.toml

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

examples/axum_js_ssr/README.md

@@ -1,10 +0,0 @@
-# Leptos Axum JS SSR Example
-
-This example shows the various ways that JavaScript may be included into
-a Leptos application.  The intent is to demonstrate how this may be done
-and how it may cause the application to fail in an unexpected manner if
-done incorrectly.
-
-## Quick Start
-
-Run `cargo leptos watch` to run this example.

examples/axum_js_ssr/node_modules/@highlightjs/cdn-assets/LICENSE

@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2006, Ivan Sagalaev.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of the copyright holder nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

examples/axum_js_ssr/node_modules/@highlightjs/cdn-assets/README.md

@@ -1,47 +0,0 @@
-# Highlight.js CDN Assets
-
-**Note: this contains only a subset of files from the full package from NPM.**
-
-[![install size](https://packagephobia.now.sh/badge?p=highlight.js)](https://packagephobia.now.sh/result?p=highlight.js)
-
-**This package contains only the CDN build assets of highlight.js.**
-
-This may be what you want if you'd like to install the pre-built distributable highlight.js client-side assets via NPM. If you're wanting to use highlight.js mainly on the server-side you likely want the [highlight.js][1] package instead.
-
-To access these files via CDN:<br>
-https://cdn.jsdelivr.net/gh/highlightjs/cdn-release@latest/build/
-
-**If you just want a single .js file with the common languages built-in:
-<https://cdn.jsdelivr.net/gh/highlightjs/cdn-release@latest/build/highlight.min.js>**
-
----
-
-## Highlight.js
-
-Highlight.js is a syntax highlighter written in JavaScript. It works in
-the browser as well as on the server. It works with pretty much any
-markup, doesn’t depend on any framework, and has automatic language
-detection.
-
-If you'd like to read the full README:<br>
-<https://github.com/highlightjs/highlight.js/blob/main/README.md>
-
-## License
-
-Highlight.js is released under the BSD License. See [LICENSE][7] file
-for details.
-
-## Links
-
-The official site for the library is at <https://highlightjs.org/>.
-
-The Github project may be found at: <https://github.com/highlightjs/highlight.js>
-
-Further in-depth documentation for the API and other topics is at
-<http://highlightjs.readthedocs.io/>.
-
-A list of the Core Team and contributors can be found in the [CONTRIBUTORS.md][8] file.
-
-[1]: https://www.npmjs.com/package/highlight.js
-[7]: https://github.com/highlightjs/highlight.js/blob/main/LICENSE
-[8]: https://github.com/highlightjs/highlight.js/blob/main/CONTRIBUTORS.md

examples/axum_js_ssr/node_modules/@highlightjs/cdn-assets/package.json

@@ -1,93 +0,0 @@
-{
-  "name": "@highlightjs/cdn-assets",
-  "description": "Syntax highlighting with language autodetection. (pre-compiled CDN assets)",
-  "keywords": [
-    "highlight",
-    "syntax"
-  ],
-  "homepage": "https://highlightjs.org/",
-  "version": "11.10.0",
-  "author": "Josh Goebel <hello@joshgoebel.com>",
-  "contributors": [
-    "Josh Goebel <hello@joshgoebel.com>",
-    "Egor Rogov <e.rogov@postgrespro.ru>",
-    "Vladimir Jimenez <me@allejo.io>",
-    "Ivan Sagalaev <maniac@softwaremaniacs.org>",
-    "Jeremy Hull <sourdrums@gmail.com>",
-    "Oleg Efimov <efimovov@gmail.com>",
-    "Gidi Meir Morris <gidi@gidi.io>",
-    "Jan T. Sott <git@idleberg.com>",
-    "Li Xuanji <xuanji@gmail.com>",
-    "Marcos Cáceres <marcos@marcosc.com>",
-    "Sang Dang <sang.dang@polku.io>"
-  ],
-  "bugs": {
-    "url": "https://github.com/highlightjs/highlight.js/issues"
-  },
-  "license": "BSD-3-Clause",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/highlightjs/highlight.js.git"
-  },
-  "sideEffects": [
-    "./es/common.js",
-    "./lib/common.js",
-    "*.css",
-    "*.scss"
-  ],
-  "scripts": {
-    "mocha": "mocha",
-    "lint": "eslint src/*.js src/lib/*.js demo/*.js tools/**/*.js --ignore-pattern vendor",
-    "lint-languages": "eslint --no-eslintrc -c .eslintrc.lang.js src/languages/**/*.js",
-    "build_and_test": "npm run build && npm run test",
-    "build_and_test_browser": "npm run build-browser && npm run test-browser",
-    "build": "node ./tools/build.js -t node",
-    "build-cdn": "node ./tools/build.js -t cdn",
-    "build-browser": "node ./tools/build.js -t browser :common",
-    "devtool": "npx http-server",
-    "test": "mocha test",
-    "test-markup": "mocha test/markup",
-    "test-detect": "mocha test/detect",
-    "test-browser": "mocha test/browser",
-    "test-parser": "mocha test/parser"
-  },
-  "engines": {
-    "node": ">=12.0.0"
-  },
-  "devDependencies": {
-    "@colors/colors": "^1.6.0",
-    "@rollup/plugin-commonjs": "^26.0.1",
-    "@rollup/plugin-json": "^6.0.1",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@types/mocha": "^10.0.2",
-    "@typescript-eslint/eslint-plugin": "^7.15.0",
-    "@typescript-eslint/parser": "^7.15.0",
-    "clean-css": "^5.3.2",
-    "cli-table": "^0.3.1",
-    "commander": "^12.1.0",
-    "css": "^3.0.0",
-    "css-color-names": "^1.0.1",
-    "deep-freeze-es6": "^3.0.2",
-    "del": "^7.1.0",
-    "dependency-resolver": "^2.0.1",
-    "eslint": "^8.57.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.28.1",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^6.1.1",
-    "glob": "^8.1.0",
-    "glob-promise": "^6.0.5",
-    "handlebars": "^4.7.8",
-    "http-server": "^14.1.1",
-    "jsdom": "^24.1.0",
-    "lodash": "^4.17.20",
-    "mocha": "^10.2.0",
-    "refa": "^0.4.1",
-    "rollup": "^4.0.2",
-    "should": "^13.2.3",
-    "terser": "^5.21.0",
-    "tiny-worker": "^2.3.0",
-    "typescript": "^5.2.2",
-    "wcag-contrast": "^3.0.0"
-  }
-}

examples/axum_js_ssr/node_modules/@highlightjs/cdn-assets/styles/github-dark.min.css

@@ -1,10 +0,0 @@
-pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}/*!
-  Theme: GitHub Dark
-  Description: Dark theme as seen on github.com
-  Author: github.com
-  Maintainer: @Hirse
-  Updated: 2021-05-15
-
-  Outdated base version: https://github.com/primer/github-syntax-dark
-  Current colors taken from GitHub's CSS
-*/.hljs{color:#c9d1d9;background:#0d1117}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#ff7b72}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#d2a8ff}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-variable{color:#79c0ff}.hljs-meta .hljs-string,.hljs-regexp,.hljs-string{color:#a5d6ff}.hljs-built_in,.hljs-symbol{color:#ffa657}.hljs-code,.hljs-comment,.hljs-formula{color:#8b949e}.hljs-name,.hljs-quote,.hljs-selector-pseudo,.hljs-selector-tag{color:#7ee787}.hljs-subst{color:#c9d1d9}.hljs-section{color:#1f6feb;font-weight:700}.hljs-bullet{color:#f2cc60}.hljs-emphasis{color:#c9d1d9;font-style:italic}.hljs-strong{color:#c9d1d9;font-weight:700}.hljs-addition{color:#aff5b4;background-color:#033a16}.hljs-deletion{color:#ffdcd7;background-color:#67060c}

examples/axum_js_ssr/node_modules/@highlightjs/cdn-assets/styles/github.min.css

@@ -1,10 +0,0 @@
-pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}/*!
-  Theme: GitHub
-  Description: Light theme as seen on github.com
-  Author: github.com
-  Maintainer: @Hirse
-  Updated: 2021-05-15
-
-  Outdated base version: https://github.com/primer/github-syntax-light
-  Current colors taken from GitHub's CSS
-*/.hljs{color:#24292e;background:#fff}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#d73a49}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#6f42c1}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-variable{color:#005cc5}.hljs-meta .hljs-string,.hljs-regexp,.hljs-string{color:#032f62}.hljs-built_in,.hljs-symbol{color:#e36209}.hljs-code,.hljs-comment,.hljs-formula{color:#6a737d}.hljs-name,.hljs-quote,.hljs-selector-pseudo,.hljs-selector-tag{color:#22863a}.hljs-subst{color:#24292e}.hljs-section{color:#005cc5;font-weight:700}.hljs-bullet{color:#735c0f}.hljs-emphasis{color:#24292e;font-style:italic}.hljs-strong{color:#24292e;font-weight:700}.hljs-addition{color:#22863a;background-color:#f0fff4}.hljs-deletion{color:#b31d28;background-color:#ffeef0}

examples/axum_js_ssr/package.json

@@ -1,6 +0,0 @@
-{
-  "name": "axum_js_ssr",
-  "dependencies": {
-    "@highlightjs/cdn-assets": "^11.10.0"
-  }
-}

examples/axum_js_ssr/rust-toolchain.toml

@@ -1,2 +0,0 @@
-[toolchain]
-channel = "stable" # test change

examples/axum_js_ssr/src/api.rs

@@ -1,8 +0,0 @@
-use leptos::{prelude::ServerFnError, server};
-
-#[server]
-pub async fn fetch_code() -> Result<String, ServerFnError> {
-    // emulate loading of code from a database/version control/etc
-    tokio::time::sleep(std::time::Duration::from_millis(50)).await;
-    Ok(crate::consts::CH05_02A.to_string())
-}

examples/axum_js_ssr/src/consts.rs

@@ -1,39 +0,0 @@
-// Example programs from the Rust Programming Language Book
-
-pub const CH03_05A: &str = r#"fn main() {
-    let number = 3;
-
-    if number < 5 {
-        println!("condition was true");
-    } else {
-        println!("condition was false");
-    }
-}
-
-
-
-
-"#;
-
-// For some reason, swapping the code examples "fixes" example 6.  It
-// might have something to do with the lower complexity of highlighting
-// a shorter example.  Anyway, including extra newlines for the shorter
-// example to match with the longer in order to avoid reflowing the
-// table during the async resource loading for CSR.
-
-pub const CH05_02A: &str = r#"fn main() {
-    let width1 = 30;
-    let height1 = 50;
-
-    println!(
-        "The area of the rectangle is {} square pixels.",
-        area(width1, height1)
-    );
-}
-
-fn area(width: u32, height: u32) -> u32 {
-    width * height
-}
-"#;
-
-pub const LEPTOS_HYDRATED: &str = "_leptos_hydrated";

examples/axum_js_ssr/src/hljs.rs

@@ -1,59 +0,0 @@
-#[cfg(not(feature = "ssr"))]
-mod csr {
-    use gloo_utils::format::JsValueSerdeExt;
-    use js_sys::{
-        Object,
-        Reflect::{get, set},
-    };
-    use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
-
-    #[wasm_bindgen(
-        module = "/node_modules/@highlightjs/cdn-assets/es/highlight.min.js"
-    )]
-    extern "C" {
-        type HighlightOptions;
-
-        #[wasm_bindgen(catch, js_namespace = default, js_name = highlight)]
-        fn highlight_lang(
-            code: String,
-            options: Object,
-        ) -> Result<Object, JsValue>;
-
-        #[wasm_bindgen(js_namespace = default, js_name = highlightAll)]
-        pub fn highlight_all();
-    }
-
-    // Keeping the `ignoreIllegals` argument out of the default case, and since there is no optional arguments
-    // in Rust, this will have to be provided in a separate function (e.g. `highlight_ignore_illegals`), much
-    // like how `web_sys` does it for the browser APIs.  For simplicity, only the highlighted HTML code is
-    // returned on success, and None on error.
-    pub fn highlight(code: String, lang: String) -> Option<String> {
-        let options = js_sys::Object::new();
-        set(&options, &"language".into(), &lang.into())
-            .expect("failed to assign lang to options");
-        highlight_lang(code, options)
-            .map(|result| {
-                let value = get(&result, &"value".into())
-                    .expect("HighlightResult failed to contain the value key");
-                value.into_serde().expect("Value should have been a string")
-            })
-            .ok()
-    }
-}
-
-#[cfg(feature = "ssr")]
-mod ssr {
-    // noop under ssr
-    pub fn highlight_all() {}
-
-    // TODO see if there is a Rust-based solution that will enable isomorphic rendering for this feature.
-    // the current (disabled) implementation simply calls html_escape.
-    // pub fn highlight(code: String, _lang: String) -> Option<String> {
-    //     Some(html_escape::encode_text(&code).into_owned())
-    // }
-}
-
-#[cfg(not(feature = "ssr"))]
-pub use csr::*;
-#[cfg(feature = "ssr")]
-pub use ssr::*;

examples/axum_js_ssr/src/lib.rs

@@ -1,51 +0,0 @@
-pub mod api;
-pub mod app;
-pub mod consts;
-pub mod hljs;
-
-#[cfg(feature = "hydrate")]
-#[wasm_bindgen::prelude::wasm_bindgen]
-pub fn hydrate() {
-    use app::*;
-    use consts::LEPTOS_HYDRATED;
-    use std::panic;
-    panic::set_hook(Box::new(|info| {
-        // this custom hook will call out to show the usual error log at
-        // the console while also attempt to update the UI to indicate
-        // a restart of the application is required to continue.
-        console_error_panic_hook::hook(info);
-        let window = leptos::prelude::window();
-        if !matches!(
-            js_sys::Reflect::get(&window, &wasm_bindgen::JsValue::from_str(LEPTOS_HYDRATED)),
-            Ok(t) if t == true
-        ) {
-            let document = leptos::prelude::document();
-            let _ = document.query_selector("#reset").map(|el| {
-                el.map(|el| {
-                    el.set_class_name("panicked");
-                })
-            });
-            let _ = document.query_selector("#notice").map(|el| {
-                el.map(|el| {
-                    el.set_class_name("panicked");
-                })
-            });
-        }
-    }));
-    leptos::mount::hydrate_body(App);
-
-    let window = leptos::prelude::window();
-    js_sys::Reflect::set(
-        &window,
-        &wasm_bindgen::JsValue::from_str(LEPTOS_HYDRATED),
-        &wasm_bindgen::JsValue::TRUE,
-    )
-    .expect("error setting hydrated status");
-    let event = web_sys::Event::new(LEPTOS_HYDRATED)
-        .expect("error creating hydrated event");
-    let document = leptos::prelude::document();
-    document
-        .dispatch_event(&event)
-        .expect("error dispatching hydrated event");
-    leptos::logging::log!("dispatched hydrated event");
-}

examples/axum_js_ssr/src/main.rs

@@ -1,152 +0,0 @@
-#[cfg(feature = "ssr")]
-mod latency {
-    use std::sync::{Mutex, OnceLock};
-    pub static LATENCY: OnceLock<
-        Mutex<std::iter::Cycle<std::slice::Iter<'_, u64>>>,
-    > = OnceLock::new();
-    pub static ES_LATENCY: OnceLock<
-        Mutex<std::iter::Cycle<std::slice::Iter<'_, u64>>>,
-    > = OnceLock::new();
-}
-
-#[cfg(feature = "ssr")]
-#[tokio::main]
-async fn main() {
-    use axum::{
-        body::Body,
-        extract::Request,
-        http::{
-            header::{self, HeaderValue},
-            StatusCode,
-        },
-        middleware::{self, Next},
-        response::{IntoResponse, Response},
-        routing::get,
-        Router,
-    };
-    use axum_js_ssr::app::*;
-    use http_body_util::BodyExt;
-    use leptos::prelude::*;
-    use leptos_axum::{generate_route_list, LeptosRoutes};
-
-    latency::LATENCY.get_or_init(|| [0, 4, 40, 400].iter().cycle().into());
-    latency::ES_LATENCY.get_or_init(|| [0].iter().cycle().into());
-    // Having the ES_LATENCY (a cycle of latency for the loading of the es
-    // module) in an identical cycle as LATENCY (for the standard version)
-    // adversely influences the intended demo, as this ultimately delays
-    // hydration when set too high which can cause panic under every case.
-    // If you want to test the effects of the delay just modify the list of
-    // values for the desired cycle of delays.
-
-    let conf = get_configuration(None).unwrap();
-    let addr = conf.leptos_options.site_addr;
-    let leptos_options = conf.leptos_options;
-    // Generate the list of routes in your Leptos App
-    let routes = generate_route_list(App);
-
-    async fn highlight_js() -> impl IntoResponse {
-        (
-            [(header::CONTENT_TYPE, "text/javascript")],
-            include_str!(
-                "../node_modules/@highlightjs/cdn-assets/highlight.min.js"
-            ),
-        )
-    }
-
-    async fn latency_for_highlight_js(
-        req: Request,
-        next: Next,
-    ) -> Result<impl IntoResponse, (StatusCode, String)> {
-        let uri_parts = &mut req.uri().path().rsplit('/');
-
-        let is_highlightjs = uri_parts.next() == Some("highlight.min.js");
-        let es = uri_parts.next() == Some("es");
-        let module_type = if es { "es module " } else { "standard " };
-        let res = next.run(req).await;
-        if is_highlightjs {
-            // additional processing if the filename is the test subject
-            let (mut parts, body) = res.into_parts();
-            let bytes = body
-                .collect()
-                .await
-                .map_err(|err| {
-                    (
-                        StatusCode::BAD_REQUEST,
-                        format!("error reading body: {err}"),
-                    )
-                })?
-                .to_bytes();
-            let latency = if es {
-                &latency::ES_LATENCY
-            } else {
-                &latency::LATENCY
-            };
-
-            let delay = match latency
-                .get()
-                .expect("latency cycle wasn't set up")
-                .try_lock()
-            {
-                Ok(ref mut mutex) => {
-                    *mutex.next().expect("cycle always has next")
-                }
-                Err(_) => 0,
-            };
-
-            // inject the logging of the delay used into the target script
-            log!(
-                "loading {module_type}highlight.min.js with latency of \
-                 {delay} ms"
-            );
-            let js_log = format!(
-                "\nconsole.log('loaded {module_type}highlight.js with a \
-                 minimum latency of {delay} ms');"
-            );
-            tokio::time::sleep(std::time::Duration::from_millis(delay)).await;
-
-            let bytes = [bytes, js_log.into()].concat();
-            let length = bytes.len();
-            let body = Body::from(bytes);
-
-            // Provide the bare minimum set of headers to avoid browser cache.
-            parts.headers = header::HeaderMap::from_iter(
-                [
-                    (
-                        header::CONTENT_TYPE,
-                        HeaderValue::from_static("text/javascript"),
-                    ),
-                    (header::CONTENT_LENGTH, HeaderValue::from(length)),
-                ]
-                .into_iter(),
-            );
-            Ok(Response::from_parts(parts, body))
-        } else {
-            Ok(res)
-        }
-    }
-
-    let app = Router::new()
-        .route("/highlight.min.js", get(highlight_js))
-        .leptos_routes(&leptos_options, routes, {
-            let leptos_options = leptos_options.clone();
-            move || shell(leptos_options.clone())
-        })
-        .fallback(leptos_axum::file_and_error_handler(shell))
-        .layer(middleware::from_fn(latency_for_highlight_js))
-        .with_state(leptos_options);
-
-    // run our app with hyper
-    // `axum::Server` is a re-export of `hyper::Server`
-    log!("listening on http://{}", &addr);
-    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
-    axum::serve(listener, app.into_make_service())
-        .await
-        .unwrap();
-}
-
-#[cfg(not(feature = "ssr"))]
-pub fn main() {
-    // no client-side main function
-    // unless we want this to work with e.g., Trunk for pure client-side testing
-    // see lib.rs for hydration function instead
-}

examples/axum_js_ssr/style/main.scss

@@ -1,171 +0,0 @@
-html, body {
-    margin: 0;
-    padding: 0;
-    font-family: sans-serif;
-    height: 100vh;
-    overflow: hidden;
-}
-
-body {
-    display: flex;
-    flex-flow: row nowrap;
-}
-
-nav {
-    min-width: 17em;
-    height: 100vh;
-    counter-reset: example-counter 0;
-    list-style-type: none;
-    list-style-position: outside;
-    overflow: auto;
-}
-
-nav a {
-    display: block;
-    padding: 0.5em 2em;
-    text-decoration: none;
-}
-
-nav a small {
-    display: block;
-}
-
-nav a.example::before {
-    counter-reset: subexample-counter 0;
-    counter-increment: example-counter 1;
-    content: counter(example-counter) ". ";
-}
-
-nav a.subexample::before {
-    counter-increment: subexample-counter 1;
-    content: counter(example-counter) "." counter(subexample-counter) " ";
-}
-
-div#notice {
-    display: none;
-}
-
-main div#notice.panicked {
-    position: sticky;
-    top: 0;
-    padding: 0.5em 2em;
-    display: block;
-}
-
-main {
-    width: 100%;
-    overflow: auto;
-}
-
-main article {
-    max-width: 60em;
-    margin: 0 1em;
-    padding: 0 1em;
-}
-
-main p, main li {
-    line-height: 1.3em;
-}
-
-main li pre code, main div pre code {
-    display: block;
-    line-height: normal;
-}
-
-main ol, main ul {
-    padding-left: 2em;
-}
-
-h2>code, p>code, li>code {
-    border-radius: 3px;
-    padding: 2px;
-}
-
-li pre code, div pre code {
-    margin: 0 !important;
-    padding: 0 !important;
-}
-
-#code-demo {
-    overflow-x: auto;
-}
-
-#code-demo table {
-    width: 50em;
-    margin: auto;
-}
-
-#code-demo table td {
-    vertical-align: top;
-}
-
-#code-demo table code {
-    display: block;
-    padding: 1em;
-}
-
-@media (prefers-color-scheme: light) {
-    nav {
-        background: #f7f7f7;
-    }
-
-    nav a {
-        color: #000;
-    }
-
-    nav a[aria-current="page"] {
-        background-color: #e0e0e0;
-    }
-
-    nav a:hover, h2>code, p>code, li>code  {
-        background-color: #e7e7e7;
-    }
-
-    nav a.panicked, main div#notice.panicked {
-        background: #fdd;
-    }
-
-    main div#notice.panicked a {
-        color: #000;
-    }
-
-    nav a.section {
-        border-bottom: 1px solid #777;
-    }
-}
-
-@media (prefers-color-scheme: dark) {
-    nav {
-        background: #080808;
-    }
-
-    nav a {
-        color: #fff;
-    }
-
-    nav a[aria-current="page"] {
-        background-color: #3f3f3f;
-    }
-
-    nav a:hover, h2>code, p>code, li>code  {
-        background-color: #383838;
-    }
-
-    nav a.panicked, main div#notice.panicked {
-        background: #733;
-    }
-
-    main div#notice.panicked a {
-        color: #fff;
-    }
-
-    nav a.section {
-        border-bottom: 1px solid #888;
-    }
-}
-
-// Just include the raw style as-is because I can't find a quick and easy way to import them just for the
-// appropriate media type...
-pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}
-@media (prefers-color-scheme: light){.hljs{color:#24292e;background:#fff}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#d73a49}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#6f42c1}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-variable{color:#005cc5}.hljs-meta .hljs-string,.hljs-regexp,.hljs-string{color:#032f62}.hljs-built_in,.hljs-symbol{color:#e36209}.hljs-code,.hljs-comment,.hljs-formula{color:#6a737d}.hljs-name,.hljs-quote,.hljs-selector-pseudo,.hljs-selector-tag{color:#22863a}.hljs-subst{color:#24292e}.hljs-section{color:#005cc5;font-weight:700}.hljs-bullet{color:#735c0f}.hljs-emphasis{color:#24292e;font-style:italic}.hljs-strong{color:#24292e;font-weight:700}.hljs-addition{color:#22863a;background-color:#f0fff4}.hljs-deletion{color:#b31d28;background-color:#ffeef0}}
-@media (prefers-color-scheme: dark){.hljs{color:#c9d1d9;background:#0d1117}.hljs-doctag,.hljs-keyword,.hljs-meta .hljs-keyword,.hljs-template-tag,.hljs-template-variable,.hljs-type,.hljs-variable.language_{color:#ff7b72}.hljs-title,.hljs-title.class_,.hljs-title.class_.inherited__,.hljs-title.function_{color:#d2a8ff}.hljs-attr,.hljs-attribute,.hljs-literal,.hljs-meta,.hljs-number,.hljs-operator,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-variable{color:#79c0ff}.hljs-meta .hljs-string,.hljs-regexp,.hljs-string{color:#a5d6ff}.hljs-built_in,.hljs-symbol{color:#ffa657}.hljs-code,.hljs-comment,.hljs-formula{color:#8b949e}.hljs-name,.hljs-quote,.hljs-selector-pseudo,.hljs-selector-tag{color:#7ee787}.hljs-subst{color:#c9d1d9}.hljs-section{color:#1f6feb;font-weight:700}.hljs-bullet{color:#f2cc60}.hljs-emphasis{color:#c9d1d9;font-style:italic}.hljs-strong{color:#c9d1d9;font-weight:700}.hljs-addition{color:#aff5b4;background-color:#033a16}.hljs-deletion{color:#ffdcd7;background-color:#67060c}}

examples/counter_isomorphic/Cargo.toml

@@ -2,8 +2,6 @@
 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"]
@@ -19,6 +17,7 @@ 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" }
@@ -47,13 +46,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

@@ -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);
 
-    pub static COUNT_CHANNEL: LazyLock<BroadcastChannel<i32>> =
-        LazyLock::new(BroadcastChannel::<i32>::new);
+    lazy_static::lazy_static! {
+        pub static ref COUNT_CHANNEL: BroadcastChannel<i32> = BroadcastChannel::new();
+    }
 }
 
 #[server]

examples/counters/src/lib.rs

@@ -1,4 +1,4 @@
-use leptos::prelude::*;
+use leptos::prelude::{signal::*, *};
 
 const MANY_COUNTERS: usize = 1000;
 

examples/gtk/Makefile.toml

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

examples/gtk/src/leptos_gtk.rs

@@ -1,5 +1,6 @@
 use self::properties::Connect;
 use gtk::{
+    ffi::GtkWidget,
     glib::{
         object::{IsA, IsClass, ObjectExt},
         Object, Value,
@@ -15,7 +16,7 @@ use leptos::{
     },
 };
 use next_tuple::NextTuple;
-use std::marker::PhantomData;
+use std::{borrow::Cow, marker::PhantomData};
 
 #[derive(Debug)]
 pub struct LeptosGtk;
@@ -156,13 +157,13 @@ impl Renderer for LeptosGtk {
     }
 
     fn remove_node(
-        _parent: &Self::Element,
-        _child: &Self::Node,
+        parent: &Self::Element,
+        child: &Self::Node,
     ) -> Option<Self::Node> {
         todo!()
     }
 
-    fn remove(_node: &Self::Node) {
+    fn remove(node: &Self::Node) {
         todo!()
     }
 
@@ -170,19 +171,19 @@ impl Renderer for LeptosGtk {
         node.0.parent().map(Element::from)
     }
 
-    fn first_child(_node: &Self::Node) -> Option<Self::Node> {
+    fn first_child(node: &Self::Node) -> Option<Self::Node> {
         todo!()
     }
 
-    fn next_sibling(_node: &Self::Node) -> Option<Self::Node> {
+    fn next_sibling(node: &Self::Node) -> Option<Self::Node> {
         todo!()
     }
 
     fn log_node(node: &Self::Node) {
-        println!("{node:?}");
+        todo!()
     }
 
-    fn clear_children(_parent: &Self::Element) {
+    fn clear_children(parent: &Self::Element) {
         todo!()
     }
 }
@@ -367,22 +368,7 @@ where
         })
     }
 
-    fn rebuild(self, widget: &Element, state: &mut Self::State) {
-        let prev_value = state.take_value();
-        let widget = widget.to_owned();
-        *state = RenderEffect::new_with_value(
-            move |prev| {
-                let value = self();
-                if let Some(mut state) = prev {
-                    value.rebuild(&widget, &mut state);
-                    state
-                } else {
-                    unreachable!()
-                }
-            },
-            prev_value,
-        );
-    }
+    fn rebuild(self, widget: &Element, state: &mut Self::State) {}
 }
 
 pub fn button() -> LGtkWidget<gtk::Button, (), ()> {
@@ -414,9 +400,9 @@ mod widgets {
 }
 
 pub mod properties {
-    #![allow(dead_code)]
-
-    use super::{Element, LGtkWidget, LeptosGtk, Property, WidgetClass};
+    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;
@@ -439,9 +425,7 @@ pub mod properties {
             element.0.connect(self.signal_name, false, self.callback);
         }
 
-        fn rebuild(self, _element: &Element, _state: &mut Self::State) {
-            // TODO we want to *remove* the previous listener, and reconnect with this new one
-        }
+        fn rebuild(self, element: &Element, state: &mut Self::State) {}
     }
 
     /* examples for macro */
@@ -544,7 +528,7 @@ pub mod properties {
     }
 
     /* end examples for properties macro */
-    #[derive(Debug)]
+
     pub struct Label {
         value: String,
     }
@@ -570,9 +554,7 @@ pub mod properties {
         }
 
         fn rebuild(self, element: &Element, state: &mut Self::State) {
-            if self.value != state.value {
-                LeptosGtk::set_attribute(element, "label", &self.value);
-            }
+            todo!()
         }
     }
 

examples/hackernews_islands_axum/Cargo.toml

@@ -31,6 +31,7 @@ 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/js-framework-benchmark/src/lib.rs

@@ -162,24 +162,22 @@ 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();
-                            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 >
-                            }
+                            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>
+                            })
                         }
                     />
-
                 </tbody>
             </table>
             <span class="preloadicon glyphicon glyphicon-remove" aria-hidden="true"></span>

examples/ssr_modes/Cargo.toml

@@ -2,8 +2,6 @@
 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"]
@@ -13,6 +11,7 @@ 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 }
@@ -39,12 +38,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,5 +1,4 @@
-use std::sync::LazyLock;
-
+use lazy_static::lazy_static;
 use leptos::prelude::*;
 use leptos_meta::*;
 use leptos_router::{
@@ -147,9 +146,8 @@ fn Post() -> impl IntoView {
 }
 
 // Dummy API
-
-static POSTS: LazyLock<[Post; 3]> = LazyLock::new(|| {
-    [
+lazy_static! {
+    static ref POSTS: Vec<Post> = vec![
         Post {
             id: 0,
             title: "My first post".to_string(),
@@ -165,8 +163,8 @@ static POSTS: LazyLock<[Post; 3]> = LazyLock::new(|| {
             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/Cargo.toml

@@ -2,8 +2,6 @@
 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"]
@@ -11,6 +9,7 @@ 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,5 +1,4 @@
-use std::sync::LazyLock;
-
+use lazy_static::lazy_static;
 use leptos::prelude::*;
 use leptos_meta::MetaTags;
 use leptos_meta::*;
@@ -262,9 +261,8 @@ pub fn Admin() -> impl IntoView {
 }
 
 // Dummy API
-
-static POSTS: LazyLock<[Post; 3]> = LazyLock::new(|| {
-    [
+lazy_static! {
+    static ref POSTS: Vec<Post> = vec![
         Post {
             id: 0,
             title: "My first post".to_string(),
@@ -280,8 +278,8 @@ static POSTS: LazyLock<[Post; 3]> = LazyLock::new(|| {
             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/static_routing/.gitignore

@@ -1,13 +0,0 @@
-# Generated by Cargo
-# will have compiled files and executables
-/target/
-pkg
-
-# These are backup files generated by rustfmt
-**/*.rs.bk
-
-# node e2e test tools and outputs
-node_modules/
-test-results/
-end2end/playwright-report/
-playwright/.cache/

examples/static_routing/Cargo.toml

@@ -1,115 +0,0 @@
-[package]
-name = "static_routing"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-crate-type = ["cdylib", "rlib"]
-
-[dependencies]
-console_error_panic_hook = "0.1.7"
-console_log = "1.0"
-leptos = { path = "../../leptos", features = [
-  "hydration",
-] } #"nightly", "hydration"] }
-leptos_meta = { path = "../../meta" }
-leptos_axum = { path = "../../integrations/axum", optional = true }
-leptos_router = { path = "../../router" }
-log = "0.4.22"
-serde = { version = "1.0", features = ["derive"] }
-thiserror = "1.0"
-axum = { version = "0.7.5", optional = true }
-tower = { version = "0.4.13", optional = true }
-tower-http = { version = "0.5.2", features = ["fs"], optional = true }
-tokio = { version = "1.39", features = [
-  "fs",
-  "rt-multi-thread",
-  "macros",
-], optional = true }
-tokio-stream = { version = "0.1", features = ["fs"], optional = true }
-futures = "0.3"
-wasm-bindgen = "0.2.93"
-notify = { version = "6", optional = true }
-http = { version = "1", optional = true }
-
-[features]
-hydrate = ["leptos/hydrate"]
-ssr = [
-  "dep:axum",
-  "dep:tower",
-  "dep:tower-http",
-  "dep:tokio",
-  "dep:tokio-stream",
-  "leptos/ssr",
-  "leptos_meta/ssr",
-  "dep:leptos_axum",
-  "leptos_router/ssr",
-  "dep:notify",
-  "dep:http"
-]
-
-[profile.release]
-panic = "abort"
-
-[profile.wasm-release]
-inherits = "release"
-opt-level = 'z'
-lto = true
-codegen-units = 1
-panic = "abort"
-
-[package.metadata.cargo-all-features]
-denylist = ["axum", "tower", "tower-http", "tokio", "sqlx", "leptos_axum"]
-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
-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
-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"
-# Assets source dir. All files found here will be copied and synchronized to site-root.
-# The assets-dir cannot have a sub directory with the same name/path as site-pkg-dir.
-#
-# Optional. Env: LEPTOS_ASSETS_DIR.
-assets-dir = "assets"
-# The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
-site-addr = "127.0.0.1:3007"
-# The port to use for automatic reload monitoring
-reload-port = 3001
-# [Optional] Command to use when running end2end tests. It will run in the end2end dir.
-#   [Windows] for non-WSL use "npx.cmd playwright test"
-#   This binary name can be checked in Powershell with Get-Command npx
-end2end-cmd = "npx playwright test"
-end2end-dir = "end2end"
-#  The browserlist query used for optimizing the CSS.
-browserquery = "defaults"
-# Set by cargo-leptos watch when building with that tool. Controls whether autoreload JS will be included in the head
-watch = false
-# The environment Leptos will run in, usually either "DEV" or "PROD"
-env = "DEV"
-# The features to use when compiling the bin target
-#
-# Optional. Can be over-ridden with the command line parameter --bin-features
-bin-features = ["ssr"]
-
-# If the --no-default-features flag should be used when compiling the bin target
-#
-# Optional. Defaults to false.
-bin-default-features = false
-
-# The features to use when compiling the lib target
-#
-# Optional. Can be over-ridden with the command line parameter --lib-features
-lib-features = ["hydrate"]
-
-# If the --no-default-features flag should be used when compiling the lib target
-#
-# Optional. Defaults to false.
-lib-default-features = false
-
-lib-profile-release = "wasm-release"

examples/static_routing/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 henrik
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

examples/static_routing/Makefile.toml

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

examples/static_routing/README.md

@@ -1,11 +0,0 @@
-# Static Routing Example
-
-This example shows the static routing features, which can be used to generate the HTML content for some routes before a request.
-
-## Getting Started
-
-See the [Examples README](../README.md) for setup and run instructions.
-
-## Quick Start
-
-Run `cargo leptos watch` to run this example.

examples/static_routing/posts/post1.md

@@ -1,3 +0,0 @@
-# My first blog post
-
-Having a blog is *fun*.

examples/static_routing/posts/post2.md

@@ -1,3 +0,0 @@
-# My second blog post
-
-Coming up with content is hard.

examples/static_routing/posts/post3.md

@@ -1,3 +0,0 @@
-# My third blog post
-
-Could I just have AI write this for me instead?

examples/static_routing/posts/post4.md

@@ -1,3 +0,0 @@
-# My fourth post
-
-Here is some content. It should regenerate the static page.

examples/static_routing/rust-toolchain.toml

@@ -1,2 +0,0 @@
-[toolchain]
-channel = "stable" # test change

examples/static_routing/src/app.rs

@@ -1,323 +0,0 @@
-use std::path::Path;
-
-use futures::{channel::mpsc, Stream};
-use leptos::prelude::*;
-use leptos_meta::MetaTags;
-use leptos_meta::*;
-use leptos_router::{
-    components::{FlatRoutes, Redirect, Route, Router},
-    hooks::use_params,
-    params::Params,
-    path,
-    static_routes::StaticRoute,
-    SsrMode,
-};
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-pub fn shell(options: LeptosOptions) -> impl IntoView {
-    view! {
-        <!DOCTYPE html>
-        <html lang="en">
-            <head>
-                <meta charset="utf-8"/>
-                <meta name="viewport" content="width=device-width, initial-scale=1"/>
-                <AutoReload options=options.clone()/>
-                <HydrationScripts options/>
-                <MetaTags/>
-            </head>
-            <body>
-                <App/>
-            </body>
-        </html>
-    }
-}
-
-#[component]
-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();
-
-    view! {
-        <Stylesheet id="leptos" href="/pkg/ssr_modes.css"/>
-        <Title text="Welcome to Leptos"/>
-        <Meta name="color-scheme" content="dark light"/>
-        <Router>
-            <nav>
-                <a href="/">"Home"</a>
-            </nav>
-            <main>
-                <FlatRoutes fallback>
-                    <Route
-                        path=path!("/")
-                        view=HomePage
-                        ssr=SsrMode::Static(
-                            StaticRoute::new().regenerate(|_| watch_path(Path::new("./posts"))),
-                        )
-                    />
-
-                    <Route
-                        path=path!("/about")
-                        view=move || view! { <Redirect path="/"/> }
-                        ssr=SsrMode::Static(StaticRoute::new())
-                    />
-
-                    <Route
-                        path=path!("/post/:slug/")
-                        view=Post
-                        ssr=SsrMode::Static(
-                            StaticRoute::new()
-                                .prerender_params(|| async move {
-                                    [("slug".into(), list_slugs().await.unwrap_or_default())]
-                                        .into_iter()
-                                        .collect()
-                                })
-                                .regenerate(|params| {
-                                    let slug = params.get("slug").unwrap();
-                                    watch_path(Path::new(&format!("./posts/{slug}.md")))
-                                }),
-                        )
-                    />
-
-                </FlatRoutes>
-            </main>
-        </Router>
-    }
-}
-
-#[component]
-fn HomePage() -> impl IntoView {
-    // load the posts
-    let posts = Resource::new(|| (), |_| list_posts());
-    let posts = move || {
-        posts
-            .get()
-            .map(|n| n.unwrap_or_default())
-            .unwrap_or_default()
-    };
-
-    view! {
-        <h1>"My Great Blog"</h1>
-        <Suspense fallback=move || view! { <p>"Loading posts..."</p> }>
-            <ul>
-                <For each=posts key=|post| post.slug.clone() let:post>
-                    <li>
-                        <a href=format!("/post/{}/", post.slug)>{post.title.clone()}</a>
-                    </li>
-                </For>
-            </ul>
-        </Suspense>
-    }
-}
-
-#[derive(Params, Clone, Debug, PartialEq, Eq)]
-pub struct PostParams {
-    slug: Option<String>,
-}
-
-#[component]
-fn Post() -> impl IntoView {
-    let query = use_params::<PostParams>();
-    let slug = move || {
-        query
-            .get()
-            .map(|q| q.slug.unwrap_or_default())
-            .map_err(|_| PostError::InvalidId)
-    };
-    let post_resource = Resource::new_blocking(slug, |slug| async move {
-        match slug {
-            Err(e) => Err(e),
-            Ok(slug) => get_post(slug)
-                .await
-                .map(|data| data.ok_or(PostError::PostNotFound))
-                .map_err(|e| PostError::ServerError(e.to_string())),
-        }
-    });
-
-    let post_view = move || {
-        Suspend::new(async move {
-            match post_resource.await {
-                Ok(Ok(post)) => {
-                    Ok(view! {
-                        <h1>{post.title.clone()}</h1>
-                        <p>{post.content.clone()}</p>
-
-                        // since we're using async rendering for this page,
-                        // this metadata should be included in the actual HTML <head>
-                        // when it's first served
-                        <Title text=post.title/>
-                        <Meta name="description" content=post.content/>
-                    })
-                }
-                Ok(Err(e)) | Err(e) => {
-                    Err(PostError::ServerError(e.to_string()))
-                }
-            }
-        })
-    };
-
-    view! {
-        <em>"The world's best content."</em>
-        <Suspense fallback=move || view! { <p>"Loading post..."</p> }>
-            <ErrorBoundary fallback=|errors| {
-                #[cfg(feature = "ssr")]
-                expect_context::<leptos_axum::ResponseOptions>()
-                    .set_status(http::StatusCode::NOT_FOUND);
-                view! {
-                    <div class="error">
-                        <h1>"Something went wrong."</h1>
-                        <ul>
-                            {move || {
-                                errors
-                                    .get()
-                                    .into_iter()
-                                    .map(|(_, error)| view! { <li>{error.to_string()}</li> })
-                                    .collect::<Vec<_>>()
-                            }}
-
-                        </ul>
-                    </div>
-                }
-            }>{post_view}</ErrorBoundary>
-        </Suspense>
-    }
-}
-
-#[derive(Error, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub enum PostError {
-    #[error("Invalid post ID.")]
-    InvalidId,
-    #[error("Post not found.")]
-    PostNotFound,
-    #[error("Server error: {0}.")]
-    ServerError(String),
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Post {
-    slug: String,
-    title: String,
-    content: String,
-}
-
-#[server]
-pub async fn list_slugs() -> Result<Vec<String>, ServerFnError> {
-    use tokio::fs;
-    use tokio_stream::wrappers::ReadDirStream;
-    use tokio_stream::StreamExt;
-
-    let files = ReadDirStream::new(fs::read_dir("./posts").await?);
-    Ok(files
-        .filter_map(|entry| {
-            let entry = entry.ok()?;
-            let path = entry.path();
-            if !path.is_file() {
-                return None;
-            }
-            let extension = path.extension()?;
-            if extension != "md" {
-                return None;
-            }
-
-            let slug = path
-                .file_name()
-                .and_then(|n| n.to_str())
-                .unwrap_or_default()
-                .replace(".md", "");
-            Some(slug)
-        })
-        .collect()
-        .await)
-}
-
-#[server]
-pub async fn list_posts() -> Result<Vec<Post>, ServerFnError> {
-    println!("calling list_posts");
-
-    use futures::TryStreamExt;
-    use tokio::fs;
-    use tokio_stream::wrappers::ReadDirStream;
-
-    let files = ReadDirStream::new(fs::read_dir("./posts").await?);
-    files
-        .try_filter_map(|entry| async move {
-            let path = entry.path();
-            if !path.is_file() {
-                return Ok(None);
-            }
-            let Some(extension) = path.extension() else {
-                return Ok(None);
-            };
-            if extension != "md" {
-                return Ok(None);
-            }
-
-            let slug = path
-                .file_name()
-                .and_then(|n| n.to_str())
-                .unwrap_or_default()
-                .replace(".md", "");
-            let content = fs::read_to_string(path).await?;
-            // world's worst Markdown frontmatter parser
-            let title = content.lines().next().unwrap().replace("# ", "");
-
-            Ok(Some(Post {
-                slug,
-                title,
-                content,
-            }))
-        })
-        .try_collect()
-        .await
-        .map_err(ServerFnError::from)
-}
-
-#[server]
-pub async fn get_post(slug: String) -> Result<Option<Post>, ServerFnError> {
-    println!("reading ./posts/{slug}.md");
-    let content =
-        tokio::fs::read_to_string(&format!("./posts/{slug}.md")).await?;
-    // world's worst Markdown frontmatter parser
-    let title = content.lines().next().unwrap().replace("# ", "");
-
-    Ok(Some(Post {
-        slug,
-        title,
-        content,
-    }))
-}
-
-#[allow(unused)] // path is not used in non-SSR
-fn watch_path(path: &Path) -> impl Stream<Item = ()> {
-    #[allow(unused)]
-    let (mut tx, rx) = mpsc::channel(0);
-
-    #[cfg(feature = "ssr")]
-    {
-        use notify::RecursiveMode;
-        use notify::Watcher;
-
-        let mut watcher =
-            notify::recommended_watcher(move |res: Result<_, _>| {
-                if res.is_ok() {
-                    // if this fails, it's because the buffer is full
-                    // this means we've already notified before it's regenerated,
-                    // so this page will be queued for regeneration already
-                    _ = tx.try_send(());
-                }
-            })
-            .expect("could not create watcher");
-
-        // Add a path to be watched. All files and directories at that path and
-        // below will be monitored for changes.
-        watcher
-            .watch(path, RecursiveMode::NonRecursive)
-            .expect("could not watch path");
-
-        // we want this to run as long as the server is alive
-        std::mem::forget(watcher);
-    }
-
-    rx
-}

examples/static_routing/src/lib.rs

@@ -1,9 +0,0 @@
-pub mod app;
-
-#[cfg(feature = "hydrate")]
-#[wasm_bindgen::prelude::wasm_bindgen]
-pub fn hydrate() {
-    use app::*;
-    console_error_panic_hook::set_once();
-    leptos::mount::hydrate_body(App);
-}

examples/static_routing/src/main.rs

@@ -1,42 +0,0 @@
-#[cfg(feature = "ssr")]
-#[tokio::main]
-async fn main() {
-    use axum::Router;
-    use leptos::prelude::*;
-    use leptos_axum::{generate_route_list_with_ssg, LeptosRoutes};
-    use static_routing::app::*;
-
-    let conf = get_configuration(None).unwrap();
-    let addr = conf.leptos_options.site_addr;
-    let leptos_options = conf.leptos_options;
-    // Generate the list of routes in your Leptos App
-    let (routes, static_routes) = generate_route_list_with_ssg({
-        let leptos_options = leptos_options.clone();
-        move || shell(leptos_options.clone())
-    });
-
-    static_routes.generate(&leptos_options).await;
-
-    let app = Router::new()
-        .leptos_routes(&leptos_options, routes, {
-            let leptos_options = leptos_options.clone();
-            move || shell(leptos_options.clone())
-        })
-        .fallback(leptos_axum::file_and_error_handler(shell))
-        .with_state(leptos_options);
-
-    // run our app with hyper
-    // `axum::Server` is a re-export of `hyper::Server`
-    log!("listening on http://{}", &addr);
-    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
-    axum::serve(listener, app.into_make_service())
-        .await
-        .unwrap();
-}
-
-#[cfg(not(feature = "ssr"))]
-pub fn main() {
-    // no client-side main function
-    // unless we want this to work with e.g., Trunk for pure client-side testing
-    // see lib.rs for hydration function instead
-}

examples/static_routing/style/main.scss

@@ -1,3 +0,0 @@
-body {
-	font-family: sans-serif;
-}

examples/stores/Cargo.toml

@@ -13,9 +13,6 @@ 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,11 +3,6 @@
 	<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,88 +1,43 @@
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-use chrono::{Local, NaiveDate};
 use leptos::prelude::*;
-use reactive_stores::{Field, Patch, Store};
-use reactive_stores_macro::{Patch, Store};
-use serde::{Deserialize, Serialize};
+use reactive_stores::{Field, Store, StoreFieldIterator};
+use reactive_stores_macro::Store;
 
-// 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)]
+#[derive(Debug, Store)]
 struct Todos {
-    user: User,
-    #[store(key: usize = |todo| todo.id)]
+    user: String,
     todos: Vec<Todo>,
 }
 
-#[derive(Debug, Store, Patch, Serialize, Deserialize)]
-struct User {
-    name: String,
-    email: String,
-}
-
-#[derive(Debug, Store, Serialize, Deserialize)]
+#[derive(Debug, Store)]
 struct Todo {
-    id: usize,
     label: String,
-    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,
-        };
-    }
+    completed: bool,
 }
 
 impl Todo {
     pub fn new(label: impl ToString) -> Self {
         Self {
-            id: NEXT_ID.fetch_add(1, Ordering::Relaxed),
             label: label.to_string(),
-            status: Status::Pending,
+            completed: false,
         }
     }
 }
 
 fn data() -> Todos {
     Todos {
-        user: User {
-            name: "Bob".to_string(),
-            email: "lawblog@bobloblaw.com".into(),
-        },
+        user: "Bob".to_string(),
         todos: vec![
             Todo {
-                id: 0,
                 label: "Create reactive store".to_string(),
-                status: Status::Pending,
+                completed: true,
             },
             Todo {
-                id: 1,
                 label: "???".to_string(),
-                status: Status::Pending,
+                completed: false,
             },
             Todo {
-                id: 2,
                 label: "Profit".to_string(),
-                status: Status::Pending,
+                completed: false,
             },
         ],
     }
@@ -94,10 +49,17 @@ 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().name().get()}</p>
-        <UserForm user=store.user()/>
-        <hr/>
+        <p>"Hello, " {move || store.user().get()}</p>
         <form on:submit=move |ev| {
             ev.prevent_default();
             store.todos().write().push(Todo::new(input_ref.get().unwrap().value()));
@@ -105,69 +67,30 @@ pub fn App() -> impl IntoView {
             <label>"Add a Todo" <input type="text" node_ref=input_ref/></label>
             <input type="submit"/>
         </form>
-        <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 || {
-                    leptos::logging::log!("RERUNNING FOR CALCULATION");
-                    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>
+        <ol>{rows}</ol>
+        <div style="display: flex"></div>
     }
 }
 
 #[component]
 fn TodoRow(
     store: Store<Todos>,
+    idx: usize,
     #[prop(into)] todo: Field<Todo>,
 ) -> impl IntoView {
-    let status = todo.status();
+    let completed = todo.completed();
     let title = todo.label();
 
-    let editing = RwSignal::new(true);
+    let editing = RwSignal::new(false);
 
     view! {
-        <li style:text-decoration=move || {
-            status.done().then_some("line-through").unwrap_or_default()
-        }>
+        <li
+            style:text-decoration=move || {
+                completed.get().then_some("line-through").unwrap_or_default()
+            }
 
+            class:foo=move || completed.get()
+        >
             <p
                 class:hidden=move || editing.get()
                 on:click=move |_| {
@@ -183,48 +106,25 @@ 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
             />
-
-            <button on:click=move |_| {
-                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}"),
-                        }
-                    }
-                }
+                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);
+                    });
+            }>"X"</button>
         </li>
     }
 }

examples/suspense_tests/src/app.rs

@@ -147,13 +147,14 @@ fn Nested() -> impl IntoView {
                 "Loading 1..."
             }>
                 {move || {
-                    one_second.map(|_| view! { <p id="loaded-1">"One Second: Loaded 1!"</p> })
+                    one_second.get().map(|_| view! { <p id="loaded-1">"One Second: Loaded 1!"</p> })
                 }}
                 <Suspense fallback=|| {
                     "Loading 2..."
                 }>
                     {move || {
                         two_second
+                            .get()
                             .map(|_| {
                                 view! {
                                     <p id="loaded-2">"Two Second: Loaded 2!"</p>
@@ -216,6 +217,7 @@ fn Parallel() -> impl IntoView {
             }>
                 {move || {
                     one_second
+                        .get()
                         .map(move |_| {
                             view! {
                                 <p id="loaded-1">"One Second: Loaded 1!"</p>
@@ -232,6 +234,7 @@ fn Parallel() -> impl IntoView {
             }>
                 {move || {
                     two_second
+                        .get()
                         .map(move |_| {
                             view! {
                                 <p id="loaded-2">"Two Second: Loaded 2!"</p>
@@ -261,7 +264,7 @@ fn Single() -> impl IntoView {
                 "Loading 1..."
             }>
                 {move || {
-                    one_second.map(|_| view! { <p id="loaded-1">"One Second: Loaded 1!"</p> })
+                    one_second.get().map(|_| view! { <p id="loaded-1">"One Second: Loaded 1!"</p> })
                 }}
 
             </Suspense>
@@ -297,7 +300,7 @@ fn InsideComponentChild() -> impl IntoView {
             "Loading 1..."
         }>
             {move || {
-                one_second.map(|_| view! { <p id="loaded-1">"One Second: Loaded 1!"</p> })
+                one_second.get().map(|_| view! { <p id="loaded-1">"One Second: Loaded 1!"</p> })
             }}
 
         </Suspense>
@@ -316,7 +319,7 @@ fn LocalResource() -> impl IntoView {
                 "Loading 1..."
             }>
                 {move || {
-                    one_second.map(|_| view! { <p id="loaded-1">"One Second: Loaded 1!"</p> })
+                    one_second.get().map(|_| view! { <p id="loaded-1">"One Second: Loaded 1!"</p> })
                 }}
                 {move || {
                     Suspend::new(async move {

hydration_context/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hydration_context"
-version = "0.2.0-beta6"
+version = "0.2.0-beta2"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"

hydration_context/src/ssr.rs

@@ -27,7 +27,6 @@ type SealedErrors = Arc<RwLock<HashSet<SerializedDataId>>>;
 /// The shared context that should be used on the server side.
 pub struct SsrSharedContext {
     id: AtomicUsize,
-    non_hydration_id: AtomicUsize,
     is_hydrating: AtomicBool,
     sync_buf: RwLock<Vec<ResolvedData>>,
     async_buf: AsyncDataBuf,
@@ -42,7 +41,6 @@ impl SsrSharedContext {
     pub fn new() -> Self {
         Self {
             is_hydrating: AtomicBool::new(true),
-            non_hydration_id: AtomicUsize::new(usize::MAX),
             ..Default::default()
         }
     }
@@ -54,7 +52,6 @@ impl SsrSharedContext {
     pub fn new_islands() -> Self {
         Self {
             is_hydrating: AtomicBool::new(false),
-            non_hydration_id: AtomicUsize::new(usize::MAX),
             ..Default::default()
         }
     }
@@ -76,13 +73,8 @@ impl SharedContext for SsrSharedContext {
         false
     }
 
-    #[track_caller]
     fn next_id(&self) -> SerializedDataId {
-        let id = if self.get_is_hydrating() {
-            self.id.fetch_add(1, Ordering::Relaxed)
-        } else {
-            self.non_hydration_id.fetch_sub(1, Ordering::Relaxed)
-        };
+        let id = self.id.fetch_add(1, Ordering::Relaxed);
         SerializedDataId(id)
     }
 

integrations/actix/Cargo.toml

@@ -10,7 +10,6 @@ edition.workspace = true
 
 [dependencies]
 actix-http = "3.8"
-actix-files = "0.6"
 actix-web = "4.8"
 futures = "0.3.30"
 any_spawner = { workspace = true, features = ["tokio"] }
@@ -26,8 +25,6 @@ parking_lot = "0.12.3"
 tracing = { version = "0.1", optional = true }
 tokio = { version = "1.39", features = ["rt", "fs"] }
 send_wrapper = "0.6.0"
-dashmap = "6"
-once_cell = "1"
 
 [package.metadata.docs.rs]
 rustdoc-args = ["--generate-link-to-definition"]

integrations/actix/src/lib.rs

@@ -6,38 +6,30 @@
 //! [`examples`](https://github.com/leptos-rs/leptos/tree/main/examples)
 //! directory in the Leptos repository.
 
-use actix_files::NamedFile;
 use actix_http::header::{HeaderName, HeaderValue, ACCEPT, LOCATION, REFERER};
 use actix_web::{
     body::BoxBody,
     dev::{ServiceFactory, ServiceRequest},
     http::header,
-    test,
-    web::{Data, Payload, ServiceConfig},
+    web::{Payload, ServiceConfig},
     *,
 };
-use dashmap::DashMap;
 use futures::{stream::once, Stream, StreamExt};
 use http::StatusCode;
 use hydration_context::SsrSharedContext;
 use leptos::{
-    config::LeptosOptions,
     context::{provide_context, use_context},
-    prelude::expect_context,
     reactive_graph::{computed::ScopedFuture, owner::Owner},
-    IntoView,
+    IntoView, *,
 };
 use leptos_integration_utils::{
     BoxedFnOnce, ExtendResponse, PinnedFuture, PinnedStream,
 };
 use leptos_meta::ServerMetaContext;
 use leptos_router::{
-    components::provide_server_redirect,
-    location::RequestUrl,
-    static_routes::{RegenerationFn, ResolvedStaticPath},
-    Method, PathSegment, RouteList, RouteListing, SsrMode,
+    components::provide_server_redirect, location::RequestUrl, PathSegment,
+    RouteList, RouteListing, SsrMode, StaticDataMap, StaticMode, *,
 };
-use once_cell::sync::Lazy;
 use parking_lot::RwLock;
 use send_wrapper::SendWrapper;
 use server_fn::{
@@ -45,9 +37,7 @@ use server_fn::{
 };
 use std::{
     fmt::{Debug, Display},
-    future::Future,
     ops::{Deref, DerefMut},
-    path::Path,
     sync::Arc,
 };
 
@@ -738,25 +728,13 @@ pub fn render_app_async_with_context<IV>(
 where
     IV: IntoView + 'static,
 {
-    handle_response(method, additional_context, app_fn, async_stream_builder)
-}
-
-fn async_stream_builder<IV>(
-    app: IV,
-    chunks: BoxedFnOnce<PinnedStream<String>>,
-) -> PinnedFuture<PinnedStream<String>>
-where
-    IV: IntoView + 'static,
-{
-    Box::pin(async move {
-        let app = if cfg!(feature = "islands-router") {
-            app.to_html_stream_in_order_branching()
-        } else {
-            app.to_html_stream_in_order()
-        };
-        let app = app.collect::<String>().await;
-        let chunks = chunks();
-        Box::pin(once(async move { app }).chain(chunks)) as PinnedStream<String>
+    handle_response(method, additional_context, app_fn, |app, chunks| {
+        Box::pin(async move {
+            let app = app.to_html_stream_in_order().collect::<String>().await;
+            let chunks = chunks();
+            Box::pin(once(async move { app }).chain(chunks))
+                as PinnedStream<String>
+        })
     })
 }
 
@@ -844,7 +822,7 @@ where
 /// create routes in Actix's App without having to use wildcard matching or fallbacks. Takes in your root app Element
 /// as an argument so it can walk you app tree. This version is tailored to generated Actix compatible paths.
 pub fn generate_route_list<IV>(
-    app_fn: impl Fn() -> IV + 'static + Send + Clone,
+    app_fn: impl Fn() -> IV + 'static + Clone,
 ) -> Vec<ActixRouteListing>
 where
     IV: IntoView + 'static,
@@ -856,8 +834,8 @@ where
 /// create routes in Actix's App without having to use wildcard matching or fallbacks. Takes in your root app Element
 /// as an argument so it can walk you app tree. This version is tailored to generated Actix compatible paths.
 pub fn generate_route_list_with_ssg<IV>(
-    app_fn: impl Fn() -> IV + 'static + Send + Clone,
-) -> (Vec<ActixRouteListing>, StaticRouteGenerator)
+    app_fn: impl Fn() -> IV + 'static + Clone,
+) -> (Vec<ActixRouteListing>, StaticDataMap)
 where
     IV: IntoView + 'static,
 {
@@ -869,7 +847,7 @@ where
 /// as an argument so it can walk you app tree. This version is tailored to generated Actix compatible paths. Adding excluded_routes
 /// to this function will stop `.leptos_routes()` from generating a route for it, allowing a custom handler. These need to be in Actix path format
 pub fn generate_route_list_with_exclusions<IV>(
-    app_fn: impl Fn() -> IV + 'static + Send + Clone,
+    app_fn: impl Fn() -> IV + 'static + Clone,
     excluded_routes: Option<Vec<String>>,
 ) -> Vec<ActixRouteListing>
 where
@@ -883,9 +861,9 @@ where
 /// as an argument so it can walk you app tree. This version is tailored to generated Actix compatible paths. Adding excluded_routes
 /// to this function will stop `.leptos_routes()` from generating a route for it, allowing a custom handler. These need to be in Actix path format
 pub fn generate_route_list_with_exclusions_and_ssg<IV>(
-    app_fn: impl Fn() -> IV + 'static + Send + Clone,
+    app_fn: impl Fn() -> IV + 'static + Clone,
     excluded_routes: Option<Vec<String>>,
-) -> (Vec<ActixRouteListing>, StaticRouteGenerator)
+) -> (Vec<ActixRouteListing>, StaticDataMap)
 where
     IV: IntoView + 'static,
 {
@@ -934,7 +912,7 @@ pub struct ActixRouteListing {
     path: String,
     mode: SsrMode,
     methods: Vec<leptos_router::Method>,
-    regenerate: Vec<RegenerationFn>,
+    static_mode: Option<(StaticMode, StaticDataMap)>,
 }
 
 impl From<RouteListing> for ActixRouteListing {
@@ -947,12 +925,12 @@ impl From<RouteListing> for ActixRouteListing {
         };
         let mode = value.mode();
         let methods = value.methods().collect();
-        let regenerate = value.regenerate().into();
+        let static_mode = value.into_static_parts();
         Self {
             path,
-            mode: mode.clone(),
+            mode,
             methods,
-            regenerate,
+            static_mode,
         }
     }
 }
@@ -963,13 +941,13 @@ impl ActixRouteListing {
         path: String,
         mode: SsrMode,
         methods: impl IntoIterator<Item = leptos_router::Method>,
-        regenerate: impl Into<Vec<RegenerationFn>>,
+        static_mode: Option<(StaticMode, StaticDataMap)>,
     ) -> Self {
         Self {
             path,
             mode,
             methods: methods.into_iter().collect(),
-            regenerate: regenerate.into(),
+            static_mode,
         }
     }
 
@@ -980,13 +958,19 @@ impl ActixRouteListing {
 
     /// The rendering mode for this path.
     pub fn mode(&self) -> SsrMode {
-        self.mode.clone()
+        self.mode
     }
 
     /// The HTTP request methods this path can handle.
     pub fn methods(&self) -> impl Iterator<Item = leptos_router::Method> + '_ {
         self.methods.iter().copied()
     }
+
+    /// Whether this route is statically rendered.
+    #[inline(always)]
+    pub fn static_mode(&self) -> Option<StaticMode> {
+        self.static_mode.as_ref().map(|n| n.0)
+    }
 }
 
 /// Generates a list of all routes defined in Leptos's Router in your app. We can then use this to automatically
@@ -995,10 +979,10 @@ impl ActixRouteListing {
 /// to this function will stop `.leptos_routes()` from generating a route for it, allowing a custom handler. These need to be in Actix path format.
 /// Additional context will be provided to the app Element.
 pub fn generate_route_list_with_exclusions_and_ssg_and_context<IV>(
-    app_fn: impl Fn() -> IV + 'static + Send + Clone,
+    app_fn: impl Fn() -> IV + 'static + Clone,
     excluded_routes: Option<Vec<String>>,
-    additional_context: impl Fn() + 'static + Send + Clone,
-) -> (Vec<ActixRouteListing>, StaticRouteGenerator)
+    additional_context: impl Fn() + 'static + Clone,
+) -> (Vec<ActixRouteListing>, StaticDataMap)
 where
     IV: IntoView + 'static,
 {
@@ -1017,12 +1001,6 @@ where
         })
         .unwrap_or_default();
 
-    let generator = StaticRouteGenerator::new(
-        &routes,
-        app_fn.clone(),
-        additional_context.clone(),
-    );
-
     // Axum's Router defines Root routes as "/" not ""
     let mut routes = routes
         .into_inner()
@@ -1036,7 +1014,7 @@ where
                 "/".to_string(),
                 Default::default(),
                 [leptos_router::Method::Get],
-                vec![],
+                None,
             )]
         } else {
             // Routes to exclude from auto generation
@@ -1046,251 +1024,192 @@ where
             }
             routes
         },
-        generator,
+        StaticDataMap::new(), // TODO
+                              //static_data_map,
     )
 }
 
-/// Allows generating any prerendered routes.
-#[allow(clippy::type_complexity)]
-pub struct StaticRouteGenerator(
-    Box<dyn FnOnce(&LeptosOptions) -> PinnedFuture<()> + Send>,
-);
-
-impl StaticRouteGenerator {
-    fn render_route<IV: IntoView + 'static>(
-        path: String,
-        app_fn: impl Fn() -> IV + Clone + Send + 'static,
-        additional_context: impl Fn() + Clone + Send + 'static,
-    ) -> impl Future<Output = (Owner, String)> {
-        let (meta_context, meta_output) = ServerMetaContext::new();
-        let additional_context = {
-            let add_context = additional_context.clone();
-            move || {
-                let mock_req = test::TestRequest::with_uri(&path)
-                    .insert_header(("Accept", "text/html"))
-                    .to_http_request();
-                let res_options = ResponseOptions::default();
-                provide_contexts(
-                    Request::new(&mock_req),
-                    &meta_context,
-                    &res_options,
-                );
-                add_context();
-            }
-        };
-
-        let (owner, stream) = leptos_integration_utils::build_response(
-            app_fn.clone(),
-            additional_context,
-            async_stream_builder,
-        );
-
-        let sc = owner.shared_context().unwrap();
-
-        async move {
-            let stream = stream.await;
-            while let Some(pending) = sc.await_deferred() {
-                pending.await;
-            }
-
-            let html = meta_output
-                .inject_meta_context(stream)
-                .await
-                .collect::<String>()
-                .await;
-            (owner, html)
-        }
-    }
-
-    /// Creates a new static route generator from the given list of route definitions.
-    pub fn new<IV>(
-        routes: &RouteList,
-        app_fn: impl Fn() -> IV + Clone + Send + 'static,
-        additional_context: impl Fn() + Clone + Send + 'static,
-    ) -> Self
-    where
-        IV: IntoView + 'static,
-    {
-        Self({
-            let routes = routes.clone();
-            Box::new(move |options| {
-                let options = options.clone();
-                let app_fn = app_fn.clone();
-                let additional_context = additional_context.clone();
-
-                Box::pin(routes.generate_static_files(
-                    move |path: &ResolvedStaticPath| {
-                        Self::render_route(
-                            path.to_string(),
-                            app_fn.clone(),
-                            additional_context.clone(),
-                        )
-                    },
-                    move |path: &ResolvedStaticPath,
-                          owner: &Owner,
-                          html: String| {
-                        let options = options.clone();
-                        let path = path.to_owned();
-                        let response_options = owner.with(use_context);
-                        async move {
-                            write_static_route(
-                                &options,
-                                response_options,
-                                path.as_ref(),
-                                &html,
-                            )
-                            .await
-                        }
-                    },
-                    was_404,
-                ))
-            })
-        })
-    }
-
-    /// Generates the routes.
-    pub async fn generate(self, options: &LeptosOptions) {
-        (self.0)(options).await
-    }
-}
-
-static STATIC_HEADERS: Lazy<DashMap<String, ResponseOptions>> =
-    Lazy::new(DashMap::new);
-
-fn was_404(owner: &Owner) -> bool {
-    let resp = owner.with(|| expect_context::<ResponseOptions>());
-    let status = resp.0.read().status;
-
-    if let Some(status) = status {
-        return status == StatusCode::NOT_FOUND;
-    }
-
-    false
-}
-
-fn static_path(options: &LeptosOptions, path: &str) -> String {
-    use leptos_integration_utils::static_file_path;
-
-    // If the path ends with a trailing slash, we generate the path
-    // as a directory with a index.html file inside.
-    if path != "/" && path.ends_with("/") {
-        static_file_path(options, &format!("{}index", path))
-    } else {
-        static_file_path(options, path)
-    }
-}
-
-async fn write_static_route(
-    options: &LeptosOptions,
-    response_options: Option<ResponseOptions>,
-    path: &str,
-    html: &str,
-) -> Result<(), std::io::Error> {
-    if let Some(options) = response_options {
-        STATIC_HEADERS.insert(path.to_string(), options);
-    }
-
-    let path = static_path(options, path);
-    let path = Path::new(&path);
-    if let Some(path) = path.parent() {
-        tokio::fs::create_dir_all(path).await?;
-    }
-    tokio::fs::write(path, &html).await?;
-
-    Ok(())
-}
-
-fn handle_static_route<IV>(
-    additional_context: impl Fn() + 'static + Clone + Send,
-    app_fn: impl Fn() -> IV + Clone + Send + 'static,
-    regenerate: Vec<RegenerationFn>,
-) -> Route
-where
-    IV: IntoView + 'static,
-{
-    let handler = move |req: HttpRequest, data: Data<LeptosOptions>| {
-        Box::pin({
-            let app_fn = app_fn.clone();
-            let additional_context = additional_context.clone();
-            let regenerate = regenerate.clone();
-            async move {
-                let options = data.into_inner();
-                let orig_path = req.uri().path();
-                let path = static_path(&options, orig_path);
-                let path = Path::new(&path);
-                let exists = tokio::fs::try_exists(path).await.unwrap_or(false);
-
-                let (response_options, html) = if !exists {
-                    let path = ResolvedStaticPath::new(orig_path);
-
-                    let (owner, html) = path
-                        .build(
-                            move |path: &ResolvedStaticPath| {
-                                StaticRouteGenerator::render_route(
-                                    path.to_string(),
-                                    app_fn.clone(),
-                                    additional_context.clone(),
-                                )
-                            },
-                            move |path: &ResolvedStaticPath,
-                                  owner: &Owner,
-                                  html: String| {
-                                let options = options.clone();
-                                let path = path.to_owned();
-                                let response_options = owner.with(use_context);
-                                async move {
-                                    write_static_route(
-                                        &options,
-                                        response_options,
-                                        path.as_ref(),
-                                        &html,
-                                    )
-                                    .await
-                                }
-                            },
-                            was_404,
-                            regenerate,
-                        )
-                        .await;
-                    (owner.with(use_context::<ResponseOptions>), html)
-                } else {
-                    let headers =
-                        STATIC_HEADERS.get(orig_path).map(|v| v.clone());
-                    (headers, None)
-                };
-
-                // if html is Some(_), it means that `was_error_response` is true and we're not
-                // actually going to cache this route, just return it as HTML
-                //
-                // this if for thing like 404s, where we do not want to cache an endless series of
-                // typos (or malicious requests)
-                let mut res = ActixResponse(match html {
-                    Some(html) => {
-                        HttpResponse::Ok().content_type("text/html").body(html)
-                    }
-                    None => match NamedFile::open(path) {
-                        Ok(res) => res.into_response(&req),
-                        Err(err) => HttpResponse::InternalServerError()
-                            .body(err.to_string()),
-                    },
-                });
-
-                if let Some(options) = response_options {
-                    res.extend_response(&options);
-                }
-
-                res.0
-            }
-        })
-    };
-    web::get().to(handler)
-}
-
 pub enum DataResponse<T> {
     Data(T),
     Response(actix_web::dev::Response<BoxBody>),
 }
 
+// TODO static response
+/*
+fn handle_static_response<'a, IV>(
+    path: &'a str,
+    options: &'a LeptosOptions,
+    app_fn: &'a (impl Fn() -> IV + Clone + Send + 'static),
+    additional_context: &'a (impl Fn() + 'static + Clone + Send),
+    res: StaticResponse,
+) -> Pin<Box<dyn Future<Output = HttpResponse<String>> + 'a>>
+where
+    IV: IntoView + 'static,
+{
+    Box::pin(async move {
+        match res {
+            StaticResponse::ReturnResponse {
+                body,
+                status,
+                content_type,
+            } => {
+                let mut res = HttpResponse::new(match status {
+                    StaticStatusCode::Ok => StatusCode::OK,
+                    StaticStatusCode::NotFound => StatusCode::NOT_FOUND,
+                    StaticStatusCode::InternalServerError => {
+                        StatusCode::INTERNAL_SERVER_ERROR
+                    }
+                });
+                if let Some(v) = content_type {
+                    res.headers_mut().insert(
+                        HeaderName::from_static("content-type"),
+                        HeaderValue::from_static(v),
+                    );
+                }
+                res.set_body(body)
+            }
+            StaticResponse::RenderDynamic => {
+                handle_static_response(
+                    path,
+                    options,
+                    app_fn,
+                    additional_context,
+                    render_dynamic(
+                        path,
+                        options,
+                        app_fn.clone(),
+                        additional_context.clone(),
+                    )
+                    .await,
+                )
+                .await
+            }
+            StaticResponse::RenderNotFound => {
+                handle_static_response(
+                    path,
+                    options,
+                    app_fn,
+                    additional_context,
+                    not_found_page(
+                        tokio::fs::read_to_string(not_found_path(options))
+                            .await,
+                    ),
+                )
+                .await
+            }
+            StaticResponse::WriteFile { body, path } => {
+                if let Some(path) = path.parent() {
+                    if let Err(e) = std::fs::create_dir_all(path) {
+                        tracing::error!(
+                            "encountered error {} writing directories {}",
+                            e,
+                            path.display()
+                        );
+                    }
+                }
+                if let Err(e) = std::fs::write(&path, &body) {
+                    tracing::error!(
+                        "encountered error {} writing file {}",
+                        e,
+                        path.display()
+                    );
+                }
+                handle_static_response(
+                    path.to_str().unwrap(),
+                    options,
+                    app_fn,
+                    additional_context,
+                    StaticResponse::ReturnResponse {
+                        body,
+                        status: StaticStatusCode::Ok,
+                        content_type: Some("text/html"),
+                    },
+                )
+                .await
+            }
+        }
+    })
+}
+
+fn static_route<IV>(
+    options: LeptosOptions,
+    app_fn: impl Fn() -> IV + Clone + Send + 'static,
+    additional_context: impl Fn() + 'static + Clone + Send,
+    method: Method,
+    mode: StaticMode,
+) -> Route
+where
+    IV: IntoView + 'static,
+{
+    match mode {
+        StaticMode::Incremental => {
+            let handler = move |req: HttpRequest| {
+                Box::pin({
+                    let options = options.clone();
+                    let app_fn = app_fn.clone();
+                    let additional_context = additional_context.clone();
+                    async move {
+                        handle_static_response(
+                            req.path(),
+                            &options,
+                            &app_fn,
+                            &additional_context,
+                            incremental_static_route(
+                                tokio::fs::read_to_string(static_file_path(
+                                    &options,
+                                    req.path(),
+                                ))
+                                .await,
+                            ),
+                        )
+                        .await
+                    }
+                })
+            };
+            match method {
+                Method::Get => web::get().to(handler),
+                Method::Post => web::post().to(handler),
+                Method::Put => web::put().to(handler),
+                Method::Delete => web::delete().to(handler),
+                Method::Patch => web::patch().to(handler),
+            }
+        }
+        StaticMode::Upfront => {
+            let handler = move |req: HttpRequest| {
+                Box::pin({
+                    let options = options.clone();
+                    let app_fn = app_fn.clone();
+                    let additional_context = additional_context.clone();
+                    async move {
+                        handle_static_response(
+                            req.path(),
+                            &options,
+                            &app_fn,
+                            &additional_context,
+                            upfront_static_route(
+                                tokio::fs::read_to_string(static_file_path(
+                                    &options,
+                                    req.path(),
+                                ))
+                                .await,
+                            ),
+                        )
+                        .await
+                    }
+                })
+            };
+            match method {
+                Method::Get => web::get().to(handler),
+                Method::Post => web::post().to(handler),
+                Method::Put => web::put().to(handler),
+                Method::Delete => web::delete().to(handler),
+                Method::Patch => web::patch().to(handler),
+            }
+        }
+    }
+}
+*/
+
 /// This trait allows one to pass a list of routes and a render function to Actix's router, letting us avoid
 /// having to use wildcards or manually define all routes in multiple places.
 pub trait LeptosRoutes {
@@ -1371,15 +1290,19 @@ where
                     provide_context(method);
                     additional_context();
                 };
-                router = if matches!(listing.mode(), SsrMode::Static(_)) {
-                    router.route(
-                        path,
-                        handle_static_route(
-                            additional_context_and_method.clone(),
-                            app_fn.clone(),
-                            listing.regenerate.clone(),
-                        ),
-                    )
+                router = if let Some(static_mode) = listing.static_mode() {
+                    _ = static_mode;
+                    todo!() /*
+                            router.route(
+                                path,
+                                static_route(
+                                    app_fn.clone(),
+                                    additional_context_and_method.clone(),
+                                    method,
+                                    static_mode,
+                                ),
+                            )
+                            */
                 } else {
                     router.route(
                     path,
@@ -1411,7 +1334,6 @@ where
                             app_fn.clone(),
                             method,
                         ),
-                        _ => unreachable!()
                     },
                 )
                 };
@@ -1468,17 +1390,7 @@ impl LeptosRoutes for &mut ServiceConfig {
             let mode = listing.mode();
 
             for method in listing.methods() {
-                if matches!(listing.mode(), SsrMode::Static(_)) {
-                    router = router.route(
-                        path,
-                        handle_static_route(
-                            additional_context.clone(),
-                            app_fn.clone(),
-                            listing.regenerate.clone(),
-                        ),
-                    )
-                } else {
-                    router = router.route(
+                router = router.route(
                             path,
                             match mode {
                                 SsrMode::OutOfOrder => {
@@ -1508,10 +1420,8 @@ impl LeptosRoutes for &mut ServiceConfig {
                                     app_fn.clone(),
                                     method,
                                 ),
-                                _ => unreachable!()
                             },
                         );
-                }
             }
         }
 

integrations/axum/Cargo.toml

@@ -14,7 +14,6 @@ hydration_context = { workspace = true }
 axum = { version = "0.7.5", default-features = false, features = [
   "matched-path",
 ] }
-dashmap = "6"
 futures = "0.3.30"
 http = "1.1"
 http-body-util = "0.1.2"
@@ -24,7 +23,6 @@ leptos_macro = { workspace = true, features = ["axum"] }
 leptos_meta = { workspace = true, features = ["ssr"] }
 leptos_router = { workspace = true, features = ["ssr"] }
 leptos_integration_utils = { workspace = true }
-once_cell = "1"
 parking_lot = "0.12.3"
 serde_json = "1.0"
 tokio = { version = "1.39", default-features = false }
@@ -38,7 +36,7 @@ tokio = { version = "1.39", features = ["net", "rt-multi-thread"] }
 
 [features]
 wasm = []
-default = ["tokio/fs", "tokio/sync", "tower-http/fs", "tower/util"]
+default = ["tokio/fs", "tokio/sync", "tower-http/fs"]
 islands-router = []
 tracing = ["dep:tracing"]
 

integrations/axum/src/lib.rs

@@ -32,11 +32,9 @@
 //! [`examples`](https://github.com/leptos-rs/leptos/tree/main/examples)
 //! directory in the Leptos repository.
 
-#[cfg(feature = "default")]
-use axum::http::Uri;
 use axum::{
     body::{Body, Bytes},
-    extract::{FromRef, FromRequestParts, MatchedPath, State},
+    extract::{FromRequestParts, MatchedPath},
     http::{
         header::{self, HeaderName, HeaderValue, ACCEPT, LOCATION, REFERER},
         request::Parts,
@@ -46,7 +44,10 @@ use axum::{
     routing::{delete, get, patch, post, put},
 };
 #[cfg(feature = "default")]
-use dashmap::DashMap;
+use axum::{
+    extract::{FromRef, State},
+    http::Uri,
+};
 use futures::{stream::once, Future, Stream, StreamExt};
 use hydration_context::SsrSharedContext;
 use leptos::{
@@ -60,20 +61,12 @@ use leptos_integration_utils::{
     BoxedFnOnce, ExtendResponse, PinnedFuture, PinnedStream,
 };
 use leptos_meta::ServerMetaContext;
-#[cfg(feature = "default")]
-use leptos_router::static_routes::ResolvedStaticPath;
 use leptos_router::{
-    components::provide_server_redirect,
-    location::RequestUrl,
-    static_routes::{RegenerationFn, StaticParamsMap},
-    PathSegment, RouteList, RouteListing, SsrMode,
+    components::provide_server_redirect, location::RequestUrl, PathSegment,
+    RouteList, RouteListing, SsrMode, StaticDataMap, StaticMode,
 };
-#[cfg(feature = "default")]
-use once_cell::sync::Lazy;
 use parking_lot::RwLock;
 use server_fn::{redirect::REDIRECT_HEADER, ServerFnError};
-#[cfg(feature = "default")]
-use std::path::Path;
 use std::{fmt::Debug, io, pin::Pin, sync::Arc};
 #[cfg(feature = "default")]
 use tower::ServiceExt;
@@ -243,20 +236,14 @@ pub fn redirect(path: &str) {
             );
         }
     } else {
+        let msg = "Couldn't retrieve either Parts or ResponseOptions while \
+                   trying to redirect().";
+
         #[cfg(feature = "tracing")]
-        {
-            tracing::warn!(
-                "Couldn't retrieve either Parts or ResponseOptions while \
-                 trying to redirect()."
-            );
-        }
+        tracing::warn!("{}", &msg);
+
         #[cfg(not(feature = "tracing"))]
-        {
-            eprintln!(
-                "Couldn't retrieve either Parts or ResponseOptions while \
-                 trying to redirect()."
-            );
-        }
+        eprintln!("{}", &msg);
     }
 }
 
@@ -510,11 +497,10 @@ where
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
 )]
-pub fn render_route<S, IV>(
+pub fn render_route<IV>(
     paths: Vec<AxumRouteListing>,
     app_fn: impl Fn() -> IV + Clone + Send + 'static,
 ) -> impl Fn(
-    State<S>,
     Request<Body>,
 ) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'static>>
        + Clone
@@ -522,8 +508,6 @@ pub fn render_route<S, IV>(
        + 'static
 where
     IV: IntoView + 'static,
-    LeptosOptions: FromRef<S>,
-    S: Send + 'static,
 {
     render_route_with_context(paths, || {}, app_fn)
 }
@@ -664,12 +648,11 @@ where
     feature = "tracing",
     tracing::instrument(level = "trace", fields(error), skip_all)
 )]
-pub fn render_route_with_context<S, IV>(
+pub fn render_route_with_context<IV>(
     paths: Vec<AxumRouteListing>,
     additional_context: impl Fn() + 'static + Clone + Send,
     app_fn: impl Fn() -> IV + Clone + Send + 'static,
 ) -> impl Fn(
-    State<S>,
     Request<Body>,
 ) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'static>>
        + Clone
@@ -677,8 +660,6 @@ pub fn render_route_with_context<S, IV>(
        + 'static
 where
     IV: IntoView + 'static,
-    LeptosOptions: FromRef<S>,
-    S: Send + 'static,
 {
     let ooo = render_app_to_stream_with_context(
         additional_context.clone(),
@@ -698,7 +679,7 @@ where
         app_fn.clone(),
     );
 
-    move |state, req| {
+    move |req| {
         // 1. Process route to match the values in routeListing
         let path = req
             .extensions()
@@ -721,25 +702,6 @@ where
             SsrMode::PartiallyBlocked => pb(req),
             SsrMode::InOrder => io(req),
             SsrMode::Async => asyn(req),
-            SsrMode::Static(_) => {
-                #[cfg(feature = "default")]
-                {
-                    let regenerate = listing.regenerate.clone();
-                    handle_static_route(
-                        additional_context.clone(),
-                        app_fn.clone(),
-                        regenerate,
-                    )(state, req)
-                }
-                #[cfg(not(feature = "default"))]
-                {
-                    _ = state;
-                    panic!(
-                        "Static routes are not currently supported on WASM32 \
-                         server targets."
-                    );
-                }
-            }
         }
     }
 }
@@ -1135,25 +1097,18 @@ pub fn render_app_async_with_context<IV>(
 where
     IV: IntoView + 'static,
 {
-    handle_response(additional_context, app_fn, async_stream_builder)
-}
-
-fn async_stream_builder<IV>(
-    app: IV,
-    chunks: BoxedFnOnce<PinnedStream<String>>,
-) -> PinnedFuture<PinnedStream<String>>
-where
-    IV: IntoView + 'static,
-{
-    Box::pin(async move {
-        let app = if cfg!(feature = "islands-router") {
-            app.to_html_stream_in_order_branching()
-        } else {
-            app.to_html_stream_in_order()
-        };
-        let app = app.collect::<String>().await;
-        let chunks = chunks();
-        Box::pin(once(async move { app }).chain(chunks)) as PinnedStream<String>
+    handle_response(additional_context, app_fn, |app, chunks| {
+        Box::pin(async move {
+            let app = if cfg!(feature = "islands-router") {
+                app.to_html_stream_in_order_branching()
+            } else {
+                app.to_html_stream_in_order()
+            };
+            let app = app.collect::<String>().await;
+            let chunks = chunks();
+            Box::pin(once(async move { app }).chain(chunks))
+                as PinnedStream<String>
+        })
     })
 }
 
@@ -1165,7 +1120,7 @@ where
     tracing::instrument(level = "trace", fields(error), skip_all)
 )]
 pub fn generate_route_list<IV>(
-    app_fn: impl Fn() -> IV + 'static + Clone + Send,
+    app_fn: impl Fn() -> IV + 'static + Clone,
 ) -> Vec<AxumRouteListing>
 where
     IV: IntoView + 'static,
@@ -1173,7 +1128,7 @@ where
     generate_route_list_with_exclusions_and_ssg(app_fn, None).0
 }
 
-/// Generates a list of all routes defined in Leptos's Router in your app. We can then use t.clone()his to automatically
+/// Generates a list of all routes defined in Leptos's Router in your app. We can then use this to automatically
 /// create routes in Axum's Router without having to use wildcard matching or fallbacks. Takes in your root app Element
 /// as an argument so it can walk you app tree. This version is tailored to generate Axum compatible paths.
 #[cfg_attr(
@@ -1181,8 +1136,8 @@ where
     tracing::instrument(level = "trace", fields(error), skip_all)
 )]
 pub fn generate_route_list_with_ssg<IV>(
-    app_fn: impl Fn() -> IV + 'static + Clone + Send,
-) -> (Vec<AxumRouteListing>, StaticRouteGenerator)
+    app_fn: impl Fn() -> IV + 'static + Clone,
+) -> (Vec<AxumRouteListing>, StaticDataMap)
 where
     IV: IntoView + 'static,
 {
@@ -1198,7 +1153,7 @@ where
     tracing::instrument(level = "trace", fields(error), skip_all)
 )]
 pub fn generate_route_list_with_exclusions<IV>(
-    app_fn: impl Fn() -> IV + 'static + Clone + Send,
+    app_fn: impl Fn() -> IV + 'static + Clone,
     excluded_routes: Option<Vec<String>>,
 ) -> Vec<AxumRouteListing>
 where
@@ -1207,13 +1162,13 @@ where
     generate_route_list_with_exclusions_and_ssg(app_fn, excluded_routes).0
 }
 
-/// Builds all routes that have been defined using [`StaticRoute`].
+/// TODO docs
 #[allow(unused)]
 pub async fn build_static_routes<IV>(
     options: &LeptosOptions,
     app_fn: impl Fn() -> IV + 'static + Send + Clone,
     routes: &[RouteListing],
-    static_data_map: StaticParamsMap,
+    static_data_map: StaticDataMap,
 ) where
     IV: IntoView + 'static,
 {
@@ -1242,9 +1197,9 @@ pub async fn build_static_routes<IV>(
     tracing::instrument(level = "trace", fields(error), skip_all)
 )]
 pub fn generate_route_list_with_exclusions_and_ssg<IV>(
-    app_fn: impl Fn() -> IV + 'static + Clone + Send,
+    app_fn: impl Fn() -> IV + 'static + Clone,
     excluded_routes: Option<Vec<String>>,
-) -> (Vec<AxumRouteListing>, StaticRouteGenerator)
+) -> (Vec<AxumRouteListing>, StaticDataMap)
 where
     IV: IntoView + 'static,
 {
@@ -1261,8 +1216,7 @@ pub struct AxumRouteListing {
     path: String,
     mode: SsrMode,
     methods: Vec<leptos_router::Method>,
-    #[allow(unused)]
-    regenerate: Vec<RegenerationFn>,
+    static_mode: Option<(StaticMode, StaticDataMap)>,
 }
 
 impl From<RouteListing> for AxumRouteListing {
@@ -1275,12 +1229,12 @@ impl From<RouteListing> for AxumRouteListing {
         };
         let mode = value.mode();
         let methods = value.methods().collect();
-        let regenerate = value.regenerate().into();
+        let static_mode = value.into_static_parts();
         Self {
             path,
-            mode: mode.clone(),
+            mode,
             methods,
-            regenerate,
+            static_mode,
         }
     }
 }
@@ -1291,13 +1245,13 @@ impl AxumRouteListing {
         path: String,
         mode: SsrMode,
         methods: impl IntoIterator<Item = leptos_router::Method>,
-        regenerate: impl Into<Vec<RegenerationFn>>,
+        static_mode: Option<(StaticMode, StaticDataMap)>,
     ) -> Self {
         Self {
             path,
             mode,
             methods: methods.into_iter().collect(),
-            regenerate: regenerate.into(),
+            static_mode,
         }
     }
 
@@ -1307,14 +1261,20 @@ impl AxumRouteListing {
     }
 
     /// The rendering mode for this path.
-    pub fn mode(&self) -> &SsrMode {
-        &self.mode
+    pub fn mode(&self) -> SsrMode {
+        self.mode
     }
 
     /// The HTTP request methods this path can handle.
     pub fn methods(&self) -> impl Iterator<Item = leptos_router::Method> + '_ {
         self.methods.iter().copied()
     }
+
+    /// Whether this route is statically rendered.
+    #[inline(always)]
+    pub fn static_mode(&self) -> Option<StaticMode> {
+        self.static_mode.as_ref().map(|n| n.0)
+    }
 }
 
 /// Generates a list of all routes defined in Leptos's Router in your app. We can then use this to automatically
@@ -1327,17 +1287,16 @@ impl AxumRouteListing {
     tracing::instrument(level = "trace", fields(error), skip_all)
 )]
 pub fn generate_route_list_with_exclusions_and_ssg_and_context<IV>(
-    app_fn: impl Fn() -> IV + Clone + Send + 'static,
+    app_fn: impl Fn() -> IV + 'static + Clone,
     excluded_routes: Option<Vec<String>>,
-    additional_context: impl Fn() + Clone + Send + 'static,
-) -> (Vec<AxumRouteListing>, StaticRouteGenerator)
+    additional_context: impl Fn() + 'static + Clone,
+) -> (Vec<AxumRouteListing>, StaticDataMap)
 where
     IV: IntoView + 'static,
 {
-    // do some basic reactive setup
     init_executor();
-    let owner = Owner::new_root(Some(Arc::new(SsrSharedContext::new())));
 
+    let owner = Owner::new_root(Some(Arc::new(SsrSharedContext::new())));
     let routes = owner
         .with(|| {
             // stub out a path for now
@@ -1351,12 +1310,6 @@ where
         })
         .unwrap_or_default();
 
-    let generator = StaticRouteGenerator::new(
-        &routes,
-        app_fn.clone(),
-        additional_context.clone(),
-    );
-
     // Axum's Router defines Root routes as "/" not ""
     let mut routes = routes
         .into_inner()
@@ -1370,7 +1323,7 @@ where
                 "/".to_string(),
                 Default::default(),
                 [leptos_router::Method::Get],
-                vec![],
+                None,
             )]
         } else {
             // Routes to exclude from auto generation
@@ -1380,284 +1333,16 @@ where
             }
             routes
         },
-        generator,
+        StaticDataMap::new(), // TODO
+                              //static_data_map,
     )
 }
 
-/// Allows generating any prerendered routes.
-#[allow(clippy::type_complexity)]
-pub struct StaticRouteGenerator(
-    Box<dyn FnOnce(&LeptosOptions) -> PinnedFuture<()> + Send>,
-);
-
-impl StaticRouteGenerator {
-    #[cfg(feature = "default")]
-    fn render_route<IV: IntoView + 'static>(
-        path: String,
-        app_fn: impl Fn() -> IV + Clone + Send + 'static,
-        additional_context: impl Fn() + Clone + Send + 'static,
-    ) -> impl Future<Output = (Owner, String)> {
-        let (meta_context, meta_output) = ServerMetaContext::new();
-        let additional_context = {
-            let add_context = additional_context.clone();
-            move || {
-                let full_path = format!("http://leptos.dev{path}");
-                let mock_req = http::Request::builder()
-                    .method(http::Method::GET)
-                    .header("Accept", "text/html")
-                    .body(Body::empty())
-                    .unwrap();
-                let (mock_parts, _) = mock_req.into_parts();
-                let res_options = ResponseOptions::default();
-                provide_contexts(
-                    &full_path,
-                    &meta_context,
-                    mock_parts,
-                    res_options,
-                );
-                add_context();
-            }
-        };
-
-        let (owner, stream) = leptos_integration_utils::build_response(
-            app_fn.clone(),
-            additional_context,
-            async_stream_builder,
-        );
-
-        let sc = owner.shared_context().unwrap();
-
-        async move {
-            let stream = stream.await;
-            while let Some(pending) = sc.await_deferred() {
-                pending.await;
-            }
-
-            let html = meta_output
-                .inject_meta_context(stream)
-                .await
-                .collect::<String>()
-                .await;
-            (owner, html)
-        }
-    }
-
-    /// Creates a new static route generator from the given list of route definitions.
-    pub fn new<IV>(
-        routes: &RouteList,
-        app_fn: impl Fn() -> IV + Clone + Send + 'static,
-        additional_context: impl Fn() + Clone + Send + 'static,
-    ) -> Self
-    where
-        IV: IntoView + 'static,
-    {
-        #[cfg(feature = "default")]
-        {
-            Self({
-                let routes = routes.clone();
-                Box::new(move |options| {
-                    let options = options.clone();
-                    let app_fn = app_fn.clone();
-                    let additional_context = additional_context.clone();
-
-                    Box::pin(routes.generate_static_files(
-                        move |path: &ResolvedStaticPath| {
-                            Self::render_route(
-                                path.to_string(),
-                                app_fn.clone(),
-                                additional_context.clone(),
-                            )
-                        },
-                        move |path: &ResolvedStaticPath,
-                              owner: &Owner,
-                              html: String| {
-                            let options = options.clone();
-                            let path = path.to_owned();
-                            let response_options = owner.with(use_context);
-                            async move {
-                                write_static_route(
-                                    &options,
-                                    response_options,
-                                    path.as_ref(),
-                                    &html,
-                                )
-                                .await
-                            }
-                        },
-                        was_404,
-                    ))
-                })
-            })
-        }
-
-        #[cfg(not(feature = "default"))]
-        {
-            _ = routes;
-            _ = app_fn;
-            _ = additional_context;
-            panic!(
-                "Static routes are not currently supported on WASM32 server \
-                 targets."
-            );
-        }
-    }
-
-    /// Generates the routes.
-    pub async fn generate(self, options: &LeptosOptions) {
-        (self.0)(options).await
-    }
-}
-
-#[cfg(feature = "default")]
-static STATIC_HEADERS: Lazy<DashMap<String, ResponseOptions>> =
-    Lazy::new(DashMap::new);
-
-#[cfg(feature = "default")]
-fn was_404(owner: &Owner) -> bool {
-    let resp = owner.with(|| expect_context::<ResponseOptions>());
-    let status = resp.0.read().status;
-
-    if let Some(status) = status {
-        return status == StatusCode::NOT_FOUND;
-    }
-
-    false
-}
-
-#[cfg(feature = "default")]
-fn static_path(options: &LeptosOptions, path: &str) -> String {
-    use leptos_integration_utils::static_file_path;
-
-    // If the path ends with a trailing slash, we generate the path
-    // as a directory with a index.html file inside.
-    if path != "/" && path.ends_with("/") {
-        static_file_path(options, &format!("{}index", path))
-    } else {
-        static_file_path(options, path)
-    }
-}
-
-#[cfg(feature = "default")]
-async fn write_static_route(
-    options: &LeptosOptions,
-    response_options: Option<ResponseOptions>,
-    path: &str,
-    html: &str,
-) -> Result<(), std::io::Error> {
-    if let Some(options) = response_options {
-        STATIC_HEADERS.insert(path.to_string(), options);
-    }
-
-    let path = static_path(options, path);
-    let path = Path::new(&path);
-    if let Some(path) = path.parent() {
-        tokio::fs::create_dir_all(path).await?;
-    }
-    tokio::fs::write(path, &html).await?;
-
-    Ok(())
-}
-
-#[cfg(feature = "default")]
-fn handle_static_route<S, IV>(
-    additional_context: impl Fn() + 'static + Clone + Send,
-    app_fn: impl Fn() -> IV + Clone + Send + 'static,
-    regenerate: Vec<RegenerationFn>,
-) -> impl Fn(
-    State<S>,
-    Request<Body>,
-) -> Pin<Box<dyn Future<Output = Response<Body>> + Send + 'static>>
-       + Clone
-       + Send
-       + 'static
-where
-    LeptosOptions: FromRef<S>,
-    S: Send + 'static,
-    IV: IntoView + 'static,
-{
-    use tower_http::services::ServeFile;
-
-    move |state, req| {
-        let app_fn = app_fn.clone();
-        let additional_context = additional_context.clone();
-        let regenerate = regenerate.clone();
-        Box::pin(async move {
-            let options = LeptosOptions::from_ref(&state);
-            let orig_path = req.uri().path();
-            let path = static_path(&options, orig_path);
-            let path = Path::new(&path);
-            let exists = tokio::fs::try_exists(path).await.unwrap_or(false);
-
-            let (response_options, html) = if !exists {
-                let path = ResolvedStaticPath::new(orig_path);
-
-                let (owner, html) = path
-                    .build(
-                        move |path: &ResolvedStaticPath| {
-                            StaticRouteGenerator::render_route(
-                                path.to_string(),
-                                app_fn.clone(),
-                                additional_context.clone(),
-                            )
-                        },
-                        move |path: &ResolvedStaticPath,
-                              owner: &Owner,
-                              html: String| {
-                            let options = options.clone();
-                            let path = path.to_owned();
-                            let response_options = owner.with(use_context);
-                            async move {
-                                write_static_route(
-                                    &options,
-                                    response_options,
-                                    path.as_ref(),
-                                    &html,
-                                )
-                                .await
-                            }
-                        },
-                        was_404,
-                        regenerate,
-                    )
-                    .await;
-                (owner.with(use_context::<ResponseOptions>), html)
-            } else {
-                let headers = STATIC_HEADERS.get(orig_path).map(|v| v.clone());
-                (headers, None)
-            };
-
-            // if html is Some(_), it means that `was_error_response` is true and we're not
-            // actually going to cache this route, just return it as HTML
-            //
-            // this if for thing like 404s, where we do not want to cache an endless series of
-            // typos (or malicious requests)
-            let mut res = AxumResponse(match html {
-                Some(html) => axum::response::Html(html).into_response(),
-                None => match ServeFile::new(path).oneshot(req).await {
-                    Ok(res) => res.into_response(),
-                    Err(err) => (
-                        StatusCode::INTERNAL_SERVER_ERROR,
-                        format!("Something went wrong: {err}"),
-                    )
-                        .into_response(),
-                },
-            });
-
-            if let Some(options) = response_options {
-                res.extend_response(&options);
-            }
-
-            res.0
-        })
-    }
-}
-
 /// This trait allows one to pass a list of routes and a render function to Axum's router, letting us avoid
 /// having to use wildcards or manually define all routes in multiple places.
 pub trait LeptosRoutes<S>
 where
     S: Clone + Send + Sync + 'static,
-    LeptosOptions: FromRef<S>,
 {
     fn leptos_routes<IV>(
         self,
@@ -1687,6 +1372,209 @@ where
         H: axum::handler::Handler<T, S>,
         T: 'static;
 }
+/*
+#[cfg(feature = "default")]
+fn handle_static_response<IV>(
+    path: String,
+    options: LeptosOptions,
+    app_fn: impl Fn() -> IV + Clone + Send + 'static,
+    additional_context: impl Fn() + Clone + Send + 'static,
+    res: StaticResponse,
+) -> Pin<Box<dyn Future<Output = Response<String>> + 'static>>
+where
+    IV: IntoView + 'static,
+{
+    Box::pin(async move {
+        match res {
+            StaticResponse::ReturnResponse {
+                body,
+                status,
+                content_type,
+            } => {
+                let mut res = Response::new(body);
+                if let Some(v) = content_type {
+                    res.headers_mut().insert(
+                        HeaderName::from_static("content-type"),
+                        HeaderValue::from_static(v),
+                    );
+                }
+                *res.status_mut() = match status {
+                    StaticStatusCode::Ok => StatusCode::OK,
+                    StaticStatusCode::NotFound => StatusCode::NOT_FOUND,
+                    StaticStatusCode::InternalServerError => {
+                        StatusCode::INTERNAL_SERVER_ERROR
+                    }
+                };
+                res
+            }
+            StaticResponse::RenderDynamic => {
+                let res = render_dynamic(
+                    &path,
+                    &options,
+                    app_fn.clone(),
+                    additional_context.clone(),
+                )
+                .await;
+                handle_static_response(
+                    path,
+                    options,
+                    app_fn,
+                    additional_context,
+                    res,
+                )
+                .await
+            }
+            StaticResponse::RenderNotFound => {
+                let res = not_found_page(
+                    tokio::fs::read_to_string(not_found_path(&options)).await,
+                );
+                handle_static_response(
+                    path,
+                    options,
+                    app_fn,
+                    additional_context,
+                    res,
+                )
+                .await
+            }
+            StaticResponse::WriteFile { body, path } => {
+                if let Some(path) = path.parent() {
+                    if let Err(e) = std::fs::create_dir_all(path) {
+                        tracing::error!(
+                            "encountered error {} writing directories {}",
+                            e,
+                            path.display()
+                        );
+                    }
+                }
+                if let Err(e) = std::fs::write(&path, &body) {
+                    tracing::error!(
+                        "encountered error {} writing file {}",
+                        e,
+                        path.display()
+                    );
+                }
+                handle_static_response(
+                    path.to_str().unwrap().to_string(),
+                    options,
+                    app_fn,
+                    additional_context,
+                    StaticResponse::ReturnResponse {
+                        body,
+                        status: StaticStatusCode::Ok,
+                        content_type: Some("text/html"),
+                    },
+                )
+                .await
+            }
+        }
+    })
+}*/
+
+#[allow(unused)] // TODO
+#[cfg(feature = "default")]
+fn static_route<IV, S>(
+    router: axum::Router<S>,
+    path: &str,
+    app_fn: impl Fn() -> IV + Clone + Send + 'static,
+    additional_context: impl Fn() + Clone + Send + 'static,
+    method: leptos_router::Method,
+    mode: StaticMode,
+) -> axum::Router<S>
+where
+    IV: IntoView + 'static,
+    S: Clone + Send + Sync + 'static,
+{
+    todo!()
+    /*match mode {
+        StaticMode::Incremental => {
+            let handler = move |req: Request<Body>| {
+                Box::pin({
+                    let path = req.uri().path().to_string();
+                    let options = options.clone();
+                    let app_fn = app_fn.clone();
+                    let additional_context = additional_context.clone();
+
+                    async move {
+                        let (tx, rx) = futures::channel::oneshot::channel();
+                        spawn_task!(async move {
+                            let res = incremental_static_route(
+                                tokio::fs::read_to_string(static_file_path(
+                                    &options, &path,
+                                ))
+                                .await,
+                            );
+                            let res = handle_static_response(
+                                path.clone(),
+                                options,
+                                app_fn,
+                                additional_context,
+                                res,
+                            )
+                            .await;
+
+                            let _ = tx.send(res);
+                        });
+                        rx.await.expect("to complete HTML rendering")
+                    }
+                })
+            };
+            router.route(
+                path,
+                match method {
+                    leptos_router::Method::Get => get(handler),
+                    leptos_router::Method::Post => post(handler),
+                    leptos_router::Method::Put => put(handler),
+                    leptos_router::Method::Delete => delete(handler),
+                    leptos_router::Method::Patch => patch(handler),
+                },
+            )
+        }
+        StaticMode::Upfront => {
+            let handler = move |req: Request<Body>| {
+                Box::pin({
+                    let path = req.uri().path().to_string();
+                    let options = options.clone();
+                    let app_fn = app_fn.clone();
+                    let additional_context = additional_context.clone();
+
+                    async move {
+                        let (tx, rx) = futures::channel::oneshot::channel();
+                        spawn_task!(async move {
+                            let res = upfront_static_route(
+                                tokio::fs::read_to_string(static_file_path(
+                                    &options, &path,
+                                ))
+                                .await,
+                            );
+                            let res = handle_static_response(
+                                path.clone(),
+                                options,
+                                app_fn,
+                                additional_context,
+                                res,
+                            )
+                            .await;
+
+                            let _ = tx.send(res);
+                        });
+                        rx.await.expect("to complete HTML rendering")
+                    }
+                })
+            };
+            router.route(
+                path,
+                match method {
+                    leptos_router::Method::Get => get(handler),
+                    leptos_router::Method::Post => post(handler),
+                    leptos_router::Method::Put => put(handler),
+                    leptos_router::Method::Delete => delete(handler),
+                    leptos_router::Method::Patch => patch(handler),
+                },
+            )
+        }
+    }*/
+}
 
 trait AxumPath {
     fn to_axum_path(&self) -> String;
@@ -1723,7 +1611,6 @@ impl AxumPath for &[PathSegment] {
 impl<S> LeptosRoutes<S> for axum::Router<S>
 where
     S: Clone + Send + Sync + 'static,
-    LeptosOptions: FromRef<S>,
 {
     #[cfg_attr(
         feature = "tracing",
@@ -1801,24 +1688,25 @@ where
                     provide_context(method);
                     cx_with_state();
                 };
-                router = if matches!(listing.mode(), SsrMode::Static(_)) {
+                router = if let Some(static_mode) = listing.static_mode() {
                     #[cfg(feature = "default")]
                     {
-                        router.route(
+                        static_route(
+                            router,
                             path,
-                            get(handle_static_route(
-                                cx_with_state_and_method.clone(),
-                                app_fn.clone(),
-                                listing.regenerate.clone(),
-                            )),
+                            app_fn.clone(),
+                            cx_with_state_and_method.clone(),
+                            method,
+                            static_mode,
                         )
                     }
                     #[cfg(not(feature = "default"))]
                     {
+                        _ = static_mode;
                         panic!(
-                            "Static routes are not currently supported on \
-                             WASM32 server targets."
-                        );
+                            "Static site generation is not currently \
+                             supported on WASM32 server targets."
+                        )
                     }
                 } else {
                     router.route(
@@ -1877,7 +1765,6 @@ where
                                 leptos_router::Method::Patch => patch(s),
                             }
                         }
-                        _ => unreachable!()
                     },
                 )
                 };

integrations/utils/src/lib.rs

@@ -5,7 +5,6 @@ use leptos::{
     reactive_graph::owner::{Owner, Sandboxed},
     IntoView,
 };
-use leptos_config::LeptosOptions;
 use leptos_meta::ServerMetaContextOutput;
 use std::{future::Future, pin::Pin, sync::Arc};
 
@@ -59,7 +58,7 @@ pub trait ExtendResponse: Sized {
                     // drop the owner, cleaning up the reactive runtime,
                     // once the stream is over
                     .chain(once(async move {
-                        owner.unset();
+                        drop(owner);
                         Default::default()
                     })),
             ));
@@ -133,13 +132,3 @@ where
     }));
     (owner, stream)
 }
-
-pub fn static_file_path(options: &LeptosOptions, path: &str) -> String {
-    let trimmed_path = path.trim_start_matches('/');
-    let path = if trimmed_path.is_empty() {
-        "index"
-    } else {
-        trimmed_path
-    };
-    format!("{}/{}.html", options.site_root, path)
-}

leptos/Cargo.toml

@@ -56,7 +56,6 @@ hydration = [
   "reactive_graph/hydration",
   "leptos_server/hydration",
   "hydration_context/browser",
-  "leptos_dom/hydration"
 ]
 csr = ["leptos_macro/csr", "reactive_graph/effects"]
 hydrate = [

leptos/src/error_boundary.rs

@@ -4,7 +4,7 @@ use leptos_macro::component;
 use reactive_graph::{
     computed::ArcMemo,
     effect::RenderEffect,
-    owner::{provide_context, Owner},
+    owner::Owner,
     signal::ArcRwSignal,
     traits::{Get, Update, With, WithUntracked},
 };
@@ -13,7 +13,6 @@ use std::{fmt::Debug, marker::PhantomData, sync::Arc};
 use tachys::{
     html::attribute::Attribute,
     hydration::Cursor,
-    reactive_graph::OwnedView,
     renderer::Renderer,
     ssr::StreamBuilder,
     view::{
@@ -97,25 +96,17 @@ where
     let hook = hook as Arc<dyn ErrorHook>;
 
     let _guard = throw_error::set_error_hook(Arc::clone(&hook));
+    let children = children.into_inner()();
 
-    let owner = Owner::new();
-    let children = owner.with(|| {
-        provide_context(Arc::clone(&hook));
-        children.into_inner()()
-    });
-
-    OwnedView::new_with_owner(
-        ErrorBoundaryView {
-            hook,
-            boundary_id,
-            errors_empty,
-            children,
-            errors,
-            fallback,
-            rndr: PhantomData,
-        },
-        owner,
-    )
+    ErrorBoundaryView {
+        hook,
+        boundary_id,
+        errors_empty,
+        children,
+        errors,
+        fallback,
+        rndr: PhantomData,
+    }
 }
 
 struct ErrorBoundaryView<Chil, FalFn, Rndr> {

leptos/src/hydration/hydration_script.js

@@ -1,5 +1,5 @@
-(function (root, pkg_path, output_name, wasm_output_name) {
-	import(`${root}/${pkg_path}/${output_name}.js`)
+(function (pkg_path, output_name, wasm_output_name) {
+	import(`/${pkg_path}/${output_name}.js`)
 		.then(mod => {
 			mod.default(`/${pkg_path}/${wasm_output_name}.wasm`).then(() => {
 				mod.hydrate();

leptos/src/hydration/island_script.js

@@ -1,4 +1,4 @@
-((root, pkg_path, output_name, wasm_output_name) => {
+((pkg_path, output_name, wasm_output_name) => {
 	function idle(c) {
 		if ("requestIdleCallback" in window) {
 			window.requestIdleCallback(c);
@@ -34,7 +34,7 @@
 		return { el: null, id: null, children: tree };
 	}
 	function hydrateIsland(el, id, mod) {
-		const islandFn = mod[id];
+		const islandFn = mod[`_island_${id}`];
 		if (islandFn) {
 			islandFn(el);
 		} else {
@@ -50,9 +50,9 @@
 		}
 	}
 	idle(() => {
-		import(`${root}/${pkg_path}/${output_name}.js`)
+		import(`/${pkg_path}/${output_name}.js`)
 			.then(mod => {
-				mod.default(`${root}/${pkg_path}/${wasm_output_name}.wasm`).then(() => {
+				mod.default(`/${pkg_path}/${wasm_output_name}.wasm`).then(() => {
 					mod.hydrate();
 					hydrateIslands(islandTree(document.body, null), mod);
 				});

leptos/src/hydration/mod.rs

@@ -38,41 +38,13 @@ pub fn AutoReload(
 pub fn HydrationScripts(
     options: LeptosOptions,
     #[prop(optional)] islands: bool,
-    /// A base url, not including a trailing slash
-    #[prop(optional, into)]
-    root: Option<String>,
 ) -> impl IntoView {
-    let mut js_file_name = options.output_name.to_string();
-    let mut wasm_file_name = options.output_name.to_string();
-    if options.hash_files {
-        let hash_path = std::env::current_exe()
-            .map(|path| {
-                path.parent().map(|p| p.to_path_buf()).unwrap_or_default()
-            })
-            .unwrap_or_default()
-            .join(&options.hash_file);
-        if hash_path.exists() {
-            let hashes = std::fs::read_to_string(&hash_path)
-                .expect("failed to read hash file");
-            for line in hashes.lines() {
-                let line = line.trim();
-                if !line.is_empty() {
-                    if let Some((file, hash)) = line.split_once(':') {
-                        if file == "js" {
-                            js_file_name.push_str(&format!(".{}", hash.trim()));
-                        } else if file == "wasm" {
-                            wasm_file_name
-                                .push_str(&format!(".{}", hash.trim()));
-                        }
-                    }
-                }
-            }
-        }
-    } else if std::option_env!("LEPTOS_OUTPUT_NAME").is_none() {
-        wasm_file_name.push_str("_bg");
-    }
-
     let pkg_path = &options.site_pkg_dir;
+    let output_name = &options.output_name;
+    let mut wasm_output_name = output_name.clone();
+    if std::option_env!("LEPTOS_OUTPUT_NAME").is_none() {
+        wasm_output_name.push_str("_bg");
+    }
     #[cfg(feature = "nonce")]
     let nonce = crate::nonce::use_nonce();
     #[cfg(not(feature = "nonce"))]
@@ -86,18 +58,17 @@ pub fn HydrationScripts(
         include_str!("./hydration_script.js")
     };
 
-    let root = root.unwrap_or_default();
     view! {
-        <link rel="modulepreload" href=format!("{root}/{pkg_path}/{js_file_name}.js") nonce=nonce.clone()/>
+        <link rel="modulepreload" href=format!("/{pkg_path}/{output_name}.js") nonce=nonce.clone()/>
         <link
             rel="preload"
-            href=format!("{root}/{pkg_path}/{wasm_file_name}.wasm")
+            href=format!("/{pkg_path}/{wasm_output_name}.wasm")
             r#as="fetch"
             r#type="application/wasm"
             crossorigin=nonce.clone().unwrap_or_default()
         />
         <script type="module" nonce=nonce>
-            {format!("{script}({root:?}, {pkg_path:?}, {js_file_name:?}, {wasm_file_name:?})")}
+            {format!("{script}({pkg_path:?}, {output_name:?}, {wasm_output_name:?})")}
         </script>
     }
 }

leptos/src/lib.rs

@@ -4,13 +4,13 @@
 //!
 //! Leptos is a full-stack framework for building web applications in Rust. You can use it to build
 //! - single-page apps (SPAs) rendered entirely in the browser, using client-side routing and loading
-//!   or mutating data via async requests to the server.
+//!   or mutating data via async requests to the server
 //! - multi-page apps (MPAs) rendered on the server, managing navigation, data, and mutations via
-//!   web-standard `<a>` and `<form>` tags.
+//!   web-standard `<a>` and `<form>` tags
 //! - progressively-enhanced single-page apps that are rendered on the server and then hydrated on the client,
 //!   enhancing your `<a>` and `<form>` navigations and mutations seamlessly when WASM is available.
 //!
-//! And you can do all three of these **using the same Leptos code**.
+//! And you can do all three of these **using the same Leptos code.**
 //!
 //! Take a look at the [Leptos Book](https://leptos-rs.github.io/leptos/) for a walkthrough of the framework.
 //! Join us on our [Discord Channel](https://discord.gg/v38Eef6sWG) to see what the community is building.
@@ -20,76 +20,76 @@
 //!
 //! If you want to see what Leptos is capable of, check out
 //! the [examples](https://github.com/leptos-rs/leptos/tree/main/examples):
-//!
-//! - **[`counter`]** is the classic counter example, showing the basics of client-side rendering and reactive DOM updates.
-//! - **[`counter_without_macros`]** adapts the counter example to use the builder pattern for the UI and avoids other macros,
-//!   instead showing the code that Leptos generates.
-//! - **[`counters`]** introduces parent-child communication via contexts, and the [`<For/>`](leptos::prelude::For) component
-//!   for efficient keyed list updates.
-//! - **[`error_boundary`]** shows how to use [`Result`] types to handle errors.
-//! - **[`parent_child`]** shows four different ways a parent component can communicate with a child, including passing a closure,
-//!   context, and more.
-//! - **[`fetch`]** introduces [`Resource`](leptos::prelude::Resource)s, which allow you to integrate arbitrary `async` code like an
+//! - [`counter`](https://github.com/leptos-rs/leptos/tree/main/examples/counter) is the classic
+//!   counter example, showing the basics of client-side rendering and reactive DOM updates
+//! - [`counter_without_macros`](https://github.com/leptos-rs/leptos/tree/main/examples/counter_without_macros)
+//!   adapts the counter example to use the builder pattern for the UI and avoids other macros, instead showing
+//!   the code that Leptos generates.
+//! - [`counters`](https://github.com/leptos-rs/leptos/tree/main/examples/counters) introduces parent-child
+//!   communication via contexts, and the `<For/>` component for efficient keyed list updates.
+//! - [`error_boundary`](https://github.com/leptos-rs/leptos/tree/main/examples/error_boundary) shows how to use
+//!   `Result` types to handle errors.
+//! - [`parent_child`](https://github.com/leptos-rs/leptos/tree/main/examples/parent_child) shows four different
+//!   ways a parent component can communicate with a child, including passing a closure, context, and more
+//! - [`fetch`](https://github.com/leptos-rs/leptos/tree/main/examples/fetch) introduces
+//!   [Resource]s, which allow you to integrate arbitrary `async` code like an
 //!   HTTP request within your reactive code.
-//! - **[`router`]** shows how to use Leptos’s nested router to enable client-side navigation and route-specific, reactive data loading.
-//! - **[`slots`]** shows how to use slots on components.
-//! - **[`spread`]** shows how the spread syntax can be used to spread data and/or event handlers onto elements.
-//! - **[`counter_isomorphic`]** shows different methods of interaction with a stateful server, including server functions,
-//!   server actions, forms, and server-sent events (SSE).
-//! - **[`todomvc`]** shows the basics of building an isomorphic web app. Both the server and the client import the same app code.
+//! - [`router`](https://github.com/leptos-rs/leptos/tree/main/examples/router) shows how to use Leptos’s nested router
+//!   to enable client-side navigation and route-specific, reactive data loading.
+//! - [`slots`](https://github.com/leptos-rs/leptos/tree/main/examples/slots) shows how to use slots on components.
+//! - [`spread`](https://github.com/leptos-rs/leptos/tree/main/examples/spread) shows how the spread syntax can be used to spread data and/or event handlers onto elements.
+//! - [`counter_isomorphic`](https://github.com/leptos-rs/leptos/tree/main/examples/counter_isomorphic) shows
+//!   different methods of interaction with a stateful server, including server functions, server actions, forms,
+//!   and server-sent events (SSE).
+//! - [`todomvc`](https://github.com/leptos-rs/leptos/tree/main/examples/todomvc) shows the basics of building an
+//!   isomorphic web app. Both the server and the client import the same app code from the `todomvc` example.
 //!   The server renders the app directly to an HTML string, and the client hydrates that HTML to make it interactive.
-//!   You might also want to see how we use [`Effect::new`](leptos::prelude::Effect::new) to
-//!   [serialize JSON to `localStorage`](https://github.com/leptos-rs/leptos/blob/20af4928b2fffe017408d3f4e7330db22cf68277/examples/todomvc/src/lib.rs#L191-L209)
-//!   and [reactively call DOM methods](https://github.com/leptos-rs/leptos/blob/16f084a71268ac325fbc4a5e50c260df185eadb6/examples/todomvc/src/lib.rs#L292-L296)
-//!   on [references to elements](https://github.com/leptos-rs/leptos/blob/20af4928b2fffe017408d3f4e7330db22cf68277/examples/todomvc/src/lib.rs#L228).
-//! - **[`hackernews`]** and **[`hackernews_axum`]** integrate calls to a real external REST API, routing, server-side rendering and
-//!   hydration to create a fully-functional application that works as intended even before WASM has loaded and begun to run.
-//! - **[`todo_app_sqlite`]** and **[`todo_app_sqlite_axum`]** show how to build a full-stack app using server functions and
-//!   database connections.
-//! - **[`tailwind`]** shows how to integrate TailwindCSS with `trunk` for CSR.
-//!
-//! [`counter`]: https://github.com/leptos-rs/leptos/tree/main/examples/counter
-//! [`counter_without_macros`]: https://github.com/leptos-rs/leptos/tree/main/examples/counter_without_macros
-//! [`counters`]: https://github.com/leptos-rs/leptos/tree/main/examples/counters
-//! [`error_boundary`]: https://github.com/leptos-rs/leptos/tree/main/examples/error_boundary
-//! [`parent_child`]: https://github.com/leptos-rs/leptos/tree/main/examples/parent_child
-//! [`fetch`]: https://github.com/leptos-rs/leptos/tree/main/examples/fetch
-//! [`router`]: https://github.com/leptos-rs/leptos/tree/main/examples/router
-//! [`slots`]: https://github.com/leptos-rs/leptos/tree/main/examples/slots
-//! [`spread`]: https://github.com/leptos-rs/leptos/tree/main/examples/spread
-//! [`counter_isomorphic`]: https://github.com/leptos-rs/leptos/tree/main/examples/counter_isomorphic
-//! [`todomvc`]: https://github.com/leptos-rs/leptos/tree/main/examples/todomvc
-//! [`hackernews`]: https://github.com/leptos-rs/leptos/tree/main/examples/hackernews
-//! [`hackernews_axum`]: https://github.com/leptos-rs/leptos/tree/main/examples/hackernews_axum
-//! [`todo_app_sqlite`]: https://github.com/leptos-rs/leptos/tree/main/examples/todo_app_sqlite
-//! [`todo_app_sqlite_axum`]: https://github.com/leptos-rs/leptos/tree/main/examples/todo_app_sqlite_axum
-//! [`tailwind`]: https://github.com/leptos-rs/leptos/tree/main/examples/tailwind_csr
+//!   You might also want to
+//!   see how we use [`create_effect`] to [serialize JSON to `localStorage`](https://github.com/leptos-rs/leptos/blob/16f084a71268ac325fbc4a5e50c260df185eadb6/examples/todomvc/src/lib.rs#L164)
+//!   and [reactively call DOM methods](https://github.com/leptos-rs/leptos/blob/6d7c36655c9e7dcc3a3ad33d2b846a3f00e4ae74/examples/todomvc/src/lib.rs#L291)
+//!   on [references to elements](https://github.com/leptos-rs/leptos/blob/6d7c36655c9e7dcc3a3ad33d2b846a3f00e4ae74/examples/todomvc/src/lib.rs#L254).
+//! - [`hackernews`](https://github.com/leptos-rs/leptos/tree/main/examples/hackernews)
+//!   and [`hackernews_axum`](https://github.com/leptos-rs/leptos/tree/main/examples/hackernews_axum)
+//!   integrate calls to a real external REST API, routing, server-side rendering and hydration to create
+//!   a fully-functional application that works as intended even before WASM has loaded and begun to run.
+//! - [`todo_app_sqlite`](https://github.com/leptos-rs/leptos/tree/main/examples/todo_app_sqlite) and
+//!   [`todo_app_sqlite_axum`](https://github.com/leptos-rs/leptos/tree/main/examples/todo_app_sqlite_axum)
+//!   show how to build a full-stack app using server functions and database connections.
+//! - [`tailwind`](https://github.com/leptos-rs/leptos/tree/main/examples/tailwind_csr) shows how to integrate
+//!   TailwindCSS with `trunk` for CSR.
 //!
 //! Details on how to run each example can be found in its README.
 //!
 //! # Quick Links
 //!
 //! Here are links to the most important sections of the docs:
-//! - **Reactivity**: the [`reactive_graph`] overview, and more details in
-//!   + signals: [`signal`](leptos::prelude::signal), [`ReadSignal`](leptos::prelude::ReadSignal),
-//!     [`WriteSignal`](leptos::prelude::WriteSignal) and [`RwSignal`](leptos::prelude::RwSignal).
-//!   + computations: [`Memo`](leptos::prelude::Memo).
-//!   + `async` interop: [`Resource`](leptos::prelude::Resource) for loading data using `async` functions
-//!     and [`Action`](leptos::prelude::Action) to mutate data or imperatively call `async` functions.
-//!   + reactions: [`Effect`](leptos::prelude::Effect) and [`RenderEffect`](leptos::prelude::RenderEffect).
-//! - **Templating/Views**: the [`view`] macro and [`IntoView`](leptos::IntoView) trait.
+//! - **Reactivity**: the [`leptos_reactive`] overview, and more details in
+//!   - signals: [`create_signal`], [`ReadSignal`], and [`WriteSignal`] (and [`create_rw_signal`] and [`RwSignal`])
+//!   - computations: [`create_memo`] and [`Memo`]
+//!   - `async` interop: [`create_resource`] and [`Resource`] for loading data using `async` functions,
+//!     and [`create_action`] and [`Action`] to mutate data or imperatively call `async` functions.
+//!   - reactions: [`create_effect`]
+//! - **Templating/Views**: the [`view`] macro
 //! - **Routing**: the [`leptos_router`](https://docs.rs/leptos_router/latest/leptos_router/) crate
-//! - **Server Functions**: the [`server`](macro@leptos::prelude::server) macro and [`ServerAction`](leptos::prelude::ServerAction).
+//! - **Server Functions**: the [`server`](crate::leptos_server) macro, [`create_action`], and [`create_server_action`]
 //!
 //! # Feature Flags
-//!
-//! - **`nightly`**: On `nightly` Rust, enables the function-call syntax for signal getters and setters.
-//! - **`csr`** Client-side rendering: Generate DOM nodes in the browser.
-//! - **`ssr`** Server-side rendering: Generate an HTML string (typically on the server).
-//! - **`hydrate`** Hydration: use this to add interactivity to an SSRed Leptos app.
-//! - **`rkyv`** In SSR/hydrate mode, uses [`rkyv`](https://docs.rs/rkyv/latest/rkyv/) to serialize resources and send them
+//! - `nightly`: On `nightly` Rust, enables the function-call syntax for signal getters and setters.
+//! - `csr` Client-side rendering: Generate DOM nodes in the browser
+//! - `ssr` Server-side rendering: Generate an HTML string (typically on the server)
+//! - `hydrate` Hydration: use this to add interactivity to an SSRed Leptos app
+//! - `serde` (*Default*) In SSR/hydrate mode, uses [`serde`](https://docs.rs/serde/latest/serde/) to serialize resources and send them
 //!   from the server to the client.
-//! - **`tracing`** Adds support for [`tracing`](https://docs.rs/tracing/latest/tracing/).
+//! - `serde-lite` In SSR/hydrate mode, uses [`serde-lite`](https://docs.rs/serde-lite/latest/serde_lite/) to serialize resources and send them
+//!   from the server to the client.
+//! - `rkyv` In SSR/hydrate mode, uses [`rkyv`](https://docs.rs/rkyv/latest/rkyv/) to serialize resources and send them
+//!   from the server to the client.
+//! - `miniserde` In SSR/hydrate mode, uses [`miniserde`](https://docs.rs/miniserde/latest/miniserde/) to serialize resources and send them
+//!   from the server to the client.
+//! - `tracing` Adds additional support for [`tracing`](https://docs.rs/tracing/latest/tracing/) to components.
+//! - `default-tls` Use default native TLS support. (Only applies when using server functions with a non-WASM client like a desktop app.)
+//! - `rustls` Use `rustls`. (Only applies when using server functions with a non-WASM client like a desktop app.)
+//! - `template_macro` Enables the [`template!`](leptos_macro::template) macro, which offers faster DOM node creation for some use cases in `csr`.
 //!
 //! **Important Note:** You must enable one of `csr`, `hydrate`, or `ssr` to tell Leptos
 //! which mode your app is operating in. You should only enable one of these per build target,
@@ -103,7 +103,7 @@
 //! #[component]
 //! pub fn SimpleCounter(initial_value: i32) -> impl IntoView {
 //!     // create a reactive signal with the initial value
-//!     let (value, set_value) = signal(initial_value);
+//!     let (value, set_value) = signal( initial_value);
 //!
 //!     // create event handlers for our buttons
 //!     // note that `value` and `set_value` are `Copy`, so it's super easy to move them into closures
@@ -112,6 +112,7 @@
 //!     let increment = move |_| *set_value.write() += 1;
 //!
 //!     view! {
+//!
 //!         <div>
 //!             <button on:click=clear>"Clear"</button>
 //!             <button on:click=decrement>"-1"</button>
@@ -123,8 +124,7 @@
 //! ```
 //!
 //! Leptos is easy to use with [Trunk](https://trunkrs.dev/) (or with a simple wasm-bindgen setup):
-//!
-//! ```rust
+//! ```
 //! use leptos::{mount::mount_to_body, prelude::*};
 //!
 //! #[component]
@@ -168,8 +168,8 @@ pub mod prelude {
         pub use leptos_server::*;
         pub use oco_ref::*;
         pub use reactive_graph::{
-            actions::*, computed::*, effect::*, owner::*, signal::*, untrack,
-            wrappers::read::*,
+            actions::*, computed::*, effect::*, owner::*, signal::*,
+            wrappers::read::*, *,
         };
         pub use server_fn::{self, ServerFnError};
         pub use tachys::{

leptos/src/suspense_component.rs

@@ -264,6 +264,7 @@ where
     {
         buf.next_id();
         let suspense_context = use_context::<SuspenseContext>().unwrap();
+
         let owner = Owner::current().unwrap();
 
         // we need to wait for one of two things: either
@@ -276,16 +277,6 @@ where
             futures::channel::oneshot::channel::<()>();
 
         let mut tasks_tx = Some(tasks_tx);
-
-        // now, create listener for local resources
-        let (local_tx, mut local_rx) =
-            futures::channel::oneshot::channel::<()>();
-        provide_context(LocalResourceNotifier::from(local_tx));
-
-        // walk over the tree of children once to make sure that all resource loads are registered
-        self.children.dry_resolve();
-
-        // check the set of tasks to see if it is empty, now or later
         let eff = reactive_graph::effect::Effect::new_isomorphic({
             move |_| {
                 tasks.track();
@@ -299,6 +290,14 @@ where
             }
         });
 
+        // now, create listener for local resources
+        let (local_tx, mut local_rx) =
+            futures::channel::oneshot::channel::<()>();
+        provide_context(LocalResourceNotifier::from(local_tx));
+
+        // walk over the tree of children once to make sure that all resource loads are registered
+        self.children.dry_resolve();
+
         let mut fut = Box::pin(ScopedFuture::new(ErrorHookFuture::new(
             async move {
                 // race the local resource notifier against the set of tasks

leptos_dom/Cargo.toml

@@ -30,7 +30,6 @@ features = ["Location"]
 default = []
 tracing = ["dep:tracing"]
 trace-component-props = ["dep:serde", "dep:serde_json"]
-hydration = ["reactive_graph/hydration"]
 
 [package.metadata.docs.rs]
 rustdoc-args = ["--generate-link-to-definition"]

leptos_dom/src/helpers.rs

@@ -64,17 +64,18 @@ pub fn location() -> web_sys::Location {
 /// Current [`window.location.hash`](https://developer.mozilla.org/en-US/docs/Web/API/Window/location)
 /// without the beginning #.
 pub fn location_hash() -> Option<String> {
-    if is_server() {
+    // TODO use shared context for is_server
+    /*if is_server() {
         None
-    } else {
-        location()
-            .hash()
-            .ok()
-            .map(|hash| match hash.chars().next() {
-                Some('#') => hash[1..].to_string(),
-                _ => hash,
-            })
-    }
+    } else {*/
+    location()
+        .hash()
+        .ok()
+        .map(|hash| match hash.chars().next() {
+            Some('#') => hash[1..].to_string(),
+            _ => hash,
+        })
+    //}
 }
 
 /// Current [`window.location.pathname`](https://developer.mozilla.org/en-US/docs/Web/API/Window/location).
@@ -474,7 +475,9 @@ pub fn window_event_listener_untyped(
         cb(e);
     };
 
-    if !is_server() {
+    // TODO use shared context for is_server
+    if true {
+        // !is_server() {
         #[inline(never)]
         fn wel(
             cb: Box<dyn FnMut(web_sys::Event)>,
@@ -547,16 +550,3 @@ impl WindowListenerHandle {
         (self.0)()
     }
 }
-
-fn is_server() -> bool {
-    #[cfg(feature = "hydration")]
-    {
-        Owner::current_shared_context()
-            .map(|sc| !sc.is_browser())
-            .unwrap_or(false)
-    }
-    #[cfg(not(feature = "hydration"))]
-    {
-        false
-    }
-}

leptos_hot_reload/Cargo.toml

@@ -20,7 +20,7 @@ syn = { version = "2.0", features = [
   "printing",
 ] }
 quote = "1.0"
-rstml = "0.12.0"
+rstml = "0.11.2"
 proc-macro2 = { version = "1.0", features = ["span-locations", "nightly"] }
 parking_lot = "0.12.3"
 walkdir = "2.5"

leptos_hot_reload/src/parsing.rs

@@ -1,4 +1,4 @@
-use rstml::node::{CustomNode, NodeElement, NodeName};
+use rstml::node::{NodeElement, NodeName};
 
 /// Converts `syn::Block` to simple expression
 ///
@@ -65,6 +65,6 @@ pub fn is_component_tag_name(name: &NodeName) -> bool {
 }
 
 #[must_use]
-pub fn is_component_node(node: &NodeElement<impl CustomNode>) -> bool {
+pub fn is_component_node(node: &NodeElement) -> bool {
     is_component_tag_name(node.name())
 }

leptos_macro/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos_macro"
-version = "0.7.0-beta6"
+version = "0.7.0-beta2"
 authors = ["Greg Johnston"]
 license = "MIT"
 repository = "https://github.com/leptos-rs/leptos"
@@ -18,11 +18,11 @@ cfg-if = "1.0"
 html-escape = "0.2.13"
 itertools = "0.13.0"
 prettyplease = "0.2.20"
-proc-macro-error2 = { version = "2.0", default-features = false }
+proc-macro-error = { version = "1.0", default-features = false }
 proc-macro2 = "1.0"
 quote = "1.0"
 syn = { version = "2.0", features = ["full"] }
-rstml = "0.12.0"
+rstml = "0.11.2"
 leptos_hot_reload = { workspace = true }
 server_fn_macro = { workspace = true }
 convert_case = "0.6.0"

leptos_macro/src/component.rs

@@ -6,9 +6,8 @@ use convert_case::{
 use itertools::Itertools;
 use leptos_hot_reload::parsing::value_to_string;
 use proc_macro2::{Ident, Span, TokenStream};
-use proc_macro_error2::abort;
+use proc_macro_error::abort;
 use quote::{format_ident, quote, quote_spanned, ToTokens, TokenStreamExt};
-use std::hash::DefaultHasher;
 use syn::{
     parse::Parse, parse_quote, spanned::Spanned, token::Colon,
     visit_mut::VisitMut, AngleBracketedGenericArguments, Attribute, FnArg,
@@ -18,7 +17,7 @@ use syn::{
 };
 
 pub struct Model {
-    island: Option<String>,
+    is_island: bool,
     docs: Docs,
     unknown_attrs: UnknownAttrs,
     vis: Visibility,
@@ -62,7 +61,7 @@ impl Parse for Model {
         });
 
         Ok(Self {
-            island: None,
+            is_island: false,
             docs,
             unknown_attrs,
             vis: item.vis.clone(),
@@ -102,7 +101,7 @@ pub fn convert_from_snake_case(name: &Ident) -> Ident {
 impl ToTokens for Model {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let Self {
-            island,
+            is_island,
             docs,
             unknown_attrs,
             vis,
@@ -111,7 +110,6 @@ impl ToTokens for Model {
             body,
             ret,
         } = self;
-        let is_island = island.is_some();
 
         let no_props = props.is_empty();
 
@@ -122,7 +120,7 @@ impl ToTokens for Model {
                 _ => None,
             });
         if let Some(semi) = ends_semi {
-            proc_macro_error2::emit_error!(
+            proc_macro_error::emit_error!(
                 semi.span(),
                 "A component that ends with a `view!` macro followed by a \
                  semicolon will return (), an empty view. This is usually an \
@@ -147,9 +145,9 @@ impl ToTokens for Model {
         #[cfg(feature = "tracing")]
         let trace_name = format!("<{name} />");
 
-        let is_island_with_children =
-            is_island && props.iter().any(|prop| prop.name.ident == "children");
-        let is_island_with_other_props = is_island
+        let is_island_with_children = *is_island
+            && props.iter().any(|prop| prop.name.ident == "children");
+        let is_island_with_other_props = *is_island
             && ((is_island_with_children && props.len() > 1)
                 || (!is_island_with_children && !props.is_empty()));
 
@@ -205,11 +203,11 @@ impl ToTokens for Model {
                         )]
                     },
                     quote! {
-                        let __span = ::leptos::tracing::Span::current();
+                        let span = ::leptos::tracing::Span::current();
                     },
                     quote! {
                         #[cfg(debug_assertions)]
-                        let _guard = __span.entered();
+                        let _guard = span.entered();
                     },
                     if no_props || !cfg!(feature = "trace-component-props") {
                         quote!()
@@ -228,14 +226,8 @@ impl ToTokens for Model {
         };
 
         let component_id = name.to_string();
-        let hydrate_fn_name = is_island.then(|| {
-            use std::hash::{Hash, Hasher};
-
-            let mut hasher = DefaultHasher::new();
-            island.hash(&mut hasher);
-            let caller = hasher.finish() as usize;
-            Ident::new(&format!("{component_id}_{caller:?}"), name.span())
-        });
+        let hydrate_fn_name =
+            Ident::new(&format!("_island_{component_id}"), name.span());
 
         let island_serialize_props = if is_island_with_other_props {
             quote! {
@@ -253,7 +245,7 @@ impl ToTokens for Model {
         };
 
         let body_name = unmodified_fn_name_from_fn_name(&body_name);
-        let body_expr = if is_island {
+        let body_expr = if *is_island {
             quote! {
                 ::leptos::reactive_graph::owner::Owner::with_hydration(move || {
                     #body_name(#prop_names)
@@ -276,8 +268,7 @@ impl ToTokens for Model {
         };
 
         // add island wrapper if island
-        let component = if is_island {
-            let hydrate_fn_name = hydrate_fn_name.as_ref().unwrap();
+        let component = if *is_island {
             quote! {
                 {
                     if ::leptos::reactive_graph::owner::Owner::current_shared_context()
@@ -289,7 +280,7 @@ impl ToTokens for Model {
                     } else {
                         ::leptos::either::Either::Right(
                             ::leptos::tachys::html::islands::Island::new(
-                                stringify!(#hydrate_fn_name),
+                                #component_id,
                                 #component
                             )
                              #island_serialized_props
@@ -343,64 +334,45 @@ impl ToTokens for Model {
             #component
         };
 
-        let binding = if is_island {
+        let binding = if *is_island {
             let island_props = if is_island_with_children
                 || is_island_with_other_props
             {
-                let (destructure, prop_builders, optional_props) =
-                    if is_island_with_other_props {
-                        let prop_names = props
-                            .iter()
-                            .filter_map(|prop| {
-                                if prop.name.ident == "children" {
-                                    None
-                                } else {
-                                    let name = &prop.name.ident;
-                                    Some(quote! { #name, })
-                                }
-                            })
-                            .collect::<TokenStream>();
-                        let destructure = quote! {
-                            let #props_serialized_name {
-                                #prop_names
-                            } = props;
-                        };
-                        let prop_builders = props
-                            .iter()
-                            .filter_map(|prop| {
-                                if prop.name.ident == "children"
-                                    || prop.prop_opts.optional
-                                {
-                                    None
-                                } else {
-                                    let name = &prop.name.ident;
-                                    Some(quote! {
-                                        .#name(#name)
-                                    })
-                                }
-                            })
-                            .collect::<TokenStream>();
-                        let optional_props = props
-                            .iter()
-                            .filter_map(|prop| {
-                                if prop.name.ident == "children"
-                                    || !prop.prop_opts.optional
-                                {
-                                    None
-                                } else {
-                                    let name = &prop.name.ident;
-                                    Some(quote! {
-                                        if let Some(#name) = #name {
-                                            props.#name = Some(#name)
-                                        }
-                                    })
-                                }
-                            })
-                            .collect::<TokenStream>();
-                        (destructure, prop_builders, optional_props)
-                    } else {
-                        (quote! {}, quote! {}, quote! {})
+                let (destructure, prop_builders) = if is_island_with_other_props
+                {
+                    let prop_names = props
+                        .iter()
+                        .filter_map(|prop| {
+                            if prop.name.ident == "children" {
+                                None
+                            } else {
+                                let name = &prop.name.ident;
+                                Some(quote! { #name, })
+                            }
+                        })
+                        .collect::<TokenStream>();
+                    let destructure = quote! {
+                        let #props_serialized_name {
+                            #prop_names
+                        } = props;
                     };
+                    let prop_builders = props
+                        .iter()
+                        .filter_map(|prop| {
+                            if prop.name.ident == "children" {
+                                None
+                            } else {
+                                let name = &prop.name.ident;
+                                Some(quote! {
+                                    .#name(#name)
+                                })
+                            }
+                        })
+                        .collect::<TokenStream>();
+                    (destructure, prop_builders)
+                } else {
+                    (quote! {}, quote! {})
+                };
                 let children = if is_island_with_children {
                     quote! {
                         .children({Box::new(|| {
@@ -424,14 +396,10 @@ impl ToTokens for Model {
 
                 quote! {{
                     #destructure
-                    let mut props = #props_name::builder()
+                    #props_name::builder()
                         #prop_builders
                         #children
-                        .build();
-
-                    #optional_props
-
-                    props
+                        .build()
                 }}
             } else {
                 quote! {}
@@ -446,7 +414,6 @@ impl ToTokens for Model {
                 quote! {}
             };
 
-            let hydrate_fn_name = hydrate_fn_name.as_ref().unwrap();
             quote! {
                 #[::leptos::wasm_bindgen::prelude::wasm_bindgen(wasm_bindgen = ::leptos::wasm_bindgen)]
                 #[allow(non_snake_case)]
@@ -521,8 +488,8 @@ impl ToTokens for Model {
 
 impl Model {
     #[allow(clippy::wrong_self_convention)]
-    pub fn with_island(mut self, island: Option<String>) -> Self {
-        self.island = island;
+    pub fn is_island(mut self, is_island: bool) -> Self {
+        self.is_island = is_island;
 
         self
     }

leptos_macro/src/lib.rs

@@ -7,7 +7,7 @@
 #![allow(private_macro_use)]
 
 #[macro_use]
-extern crate proc_macro_error2;
+extern crate proc_macro_error;
 
 use component::DummyModel;
 use proc_macro::TokenStream;
@@ -74,9 +74,6 @@ mod slot;
 ///    Attributes can take a wide variety of primitive types that can be converted to strings. They can also
 ///    take an `Option`, in which case `Some` sets the attribute and `None` removes the attribute.
 ///
-///    Note that in some cases, rust-analyzer support may be better if attribute values are surrounded with braces (`{}`).
-///    Unlike in JSX, attribute values are not required to be in braces, but braces can be used and may improve this LSP support.
-///
 /// ```rust,ignore
 /// # use leptos::prelude::*;
 ///
@@ -262,25 +259,10 @@ mod slot;
 ///     }
 /// }
 /// ```
-#[proc_macro_error2::proc_macro_error]
+#[proc_macro_error::proc_macro_error]
 #[proc_macro]
 #[cfg_attr(feature = "tracing", tracing::instrument(level = "trace", skip_all))]
 pub fn view(tokens: TokenStream) -> TokenStream {
-    view_macro_impl(tokens, false)
-}
-
-/// The `template` macro behaves like [`view`], except that it wraps the entire tree in a
-/// [`ViewTemplate`](leptos::prelude::ViewTemplate). This optimizes creation speed by rendering
-/// most of the view into a `<template>` tag with HTML rendered at compile time, then hydrating it.
-/// In exchange, there is a small binary size overhead.
-#[proc_macro_error2::proc_macro_error]
-#[proc_macro]
-#[cfg_attr(feature = "tracing", tracing::instrument(level = "trace", skip_all))]
-pub fn template(tokens: TokenStream) -> TokenStream {
-    view_macro_impl(tokens, true)
-}
-
-fn view_macro_impl(tokens: TokenStream, template: bool) -> TokenStream {
     let tokens: proc_macro2::TokenStream = tokens.into();
     let mut tokens = tokens.into_iter();
 
@@ -317,34 +299,18 @@ fn view_macro_impl(tokens: TokenStream, template: bool) -> TokenStream {
     };
     let config = rstml::ParserConfig::default().recover_block(true);
     let parser = rstml::Parser::new(config);
-    let (mut nodes, errors) = parser.parse_recoverable(tokens).split_vec();
+    let (nodes, errors) = parser.parse_recoverable(tokens).split_vec();
     let errors = errors.into_iter().map(|e| e.emit_as_expr_tokens());
     let nodes_output = view::render_view(
-        &mut nodes,
+        &nodes,
         global_class.as_ref(),
         normalized_call_site(proc_macro::Span::call_site()),
-        template,
     );
-
-    // The allow lint needs to be put here instead of at the expansion of
-    // view::attribute_value(). Adding this next to the expanded expression
-    // seems to break rust-analyzer, but it works when the allow is put here.
-    let output = quote! {
+    quote! {
         {
-            #[allow(unused_braces)]
-            {
-                #(#errors;)*
-                #nodes_output
-            }
+            #(#errors;)*
+            #nodes_output
         }
-    };
-
-    if template {
-        quote! {
-            ::leptos::prelude::ViewTemplate::new(#output)
-        }
-    } else {
-        output
     }
     .into()
 }
@@ -370,7 +336,7 @@ fn normalized_call_site(site: proc_macro::Span) -> Option<String> {
 ///
 /// The file is loaded and parsed during proc-macro execution, and its path is resolved relative to
 /// the crate root rather than relative to the file from which it is called.
-#[proc_macro_error2::proc_macro_error]
+#[proc_macro_error::proc_macro_error]
 #[proc_macro]
 pub fn include_view(tokens: TokenStream) -> TokenStream {
     let file_name = syn::parse::<syn::LitStr>(tokens).unwrap_or_else(|_| {
@@ -533,13 +499,13 @@ pub fn include_view(tokens: TokenStream) -> TokenStream {
 ///     }
 /// }
 /// ```
-#[proc_macro_error2::proc_macro_error]
+#[proc_macro_error::proc_macro_error]
 #[proc_macro_attribute]
 pub fn component(
     _args: proc_macro::TokenStream,
     s: TokenStream,
 ) -> TokenStream {
-    component_macro(s, None)
+    component_macro(s, false)
 }
 
 /// Defines a component as an interactive island when you are using the
@@ -613,19 +579,18 @@ pub fn component(
 ///     }
 /// }
 /// ```
-#[proc_macro_error2::proc_macro_error]
+#[proc_macro_error::proc_macro_error]
 #[proc_macro_attribute]
 pub fn island(_args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
-    let island_src = s.to_string();
-    component_macro(s, Some(island_src))
+    component_macro(s, true)
 }
 
-fn component_macro(s: TokenStream, island: Option<String>) -> TokenStream {
+fn component_macro(s: TokenStream, island: bool) -> TokenStream {
     let mut dummy = syn::parse::<DummyModel>(s.clone());
     let parse_result = syn::parse::<component::Model>(s);
 
     if let (Ok(ref mut unexpanded), Ok(model)) = (&mut dummy, parse_result) {
-        let expanded = model.with_island(island).into_token_stream();
+        let expanded = model.is_island(island).into_token_stream();
         if !matches!(unexpanded.vis, Visibility::Public(_)) {
             unexpanded.vis = Visibility::Public(Pub {
                 span: unexpanded.vis.span(),
@@ -753,7 +718,7 @@ fn component_macro(s: TokenStream, island: Option<String>) -> TokenStream {
 ///     }
 /// }
 /// ```
-#[proc_macro_error2::proc_macro_error]
+#[proc_macro_error::proc_macro_error]
 #[proc_macro_attribute]
 pub fn slot(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
     if !args.is_empty() {

leptos_macro/src/view/component_builder.rs

@@ -3,17 +3,17 @@ use crate::view::attribute_absolute;
 use proc_macro2::{Ident, TokenStream, TokenTree};
 use quote::{format_ident, quote, quote_spanned};
 use rstml::node::{
-    CustomNode, KeyedAttributeValue, NodeAttribute, NodeBlock, NodeElement,
-    NodeName,
+    KeyedAttributeValue, NodeAttribute, NodeBlock, NodeElement, NodeName,
 };
 use std::collections::HashMap;
 use syn::{spanned::Spanned, Expr, ExprPath, ExprRange, RangeLimits, Stmt};
 
 pub(crate) fn component_to_tokens(
-    node: &mut NodeElement<impl CustomNode>,
+    node: &NodeElement,
     global_class: Option<&TokenTree>,
-    disable_inert_html: bool,
 ) -> TokenStream {
+    let name = node.name();
+
     #[allow(unused)] // TODO this is used by hot-reloading
     #[cfg(debug_assertions)]
     let component_name = super::ident_from_tag_name(node.name());
@@ -44,21 +44,16 @@ pub(crate) fn component_to_tokens(
         })
         .unwrap_or_else(|| node.attributes().len());
 
-    let attrs = node
-        .attributes()
-        .iter()
-        .filter_map(|node| {
-            if let NodeAttribute::Attribute(node) = node {
-                Some(node)
-            } else {
-                None
-            }
-        })
-        .cloned()
-        .collect::<Vec<_>>();
+    let attrs = node.attributes().iter().filter_map(|node| {
+        if let NodeAttribute::Attribute(node) = node {
+            Some(node)
+        } else {
+            None
+        }
+    });
 
     let props = attrs
-        .iter()
+        .clone()
         .enumerate()
         .filter(|(idx, attr)| {
             idx < &spread_marker && {
@@ -89,7 +84,7 @@ pub(crate) fn component_to_tokens(
         });
 
     let items_to_bind = attrs
-        .iter()
+        .clone()
         .filter_map(|attr| {
             if !is_attr_let(&attr.key) {
                 return None;
@@ -111,7 +106,7 @@ pub(crate) fn component_to_tokens(
         .collect::<Vec<_>>();
 
     let items_to_clone = attrs
-        .iter()
+        .clone()
         .filter_map(|attr| {
             attr.key
                 .to_string()
@@ -187,12 +182,11 @@ pub(crate) fn component_to_tokens(
         quote! {}
     } else {
         let children = fragment_to_tokens(
-            &mut node.children,
+            &node.children,
             TagType::Unknown,
             Some(&mut slots),
             global_class,
             None,
-            disable_inert_html,
         );
 
         // TODO view marker for hot-reloading
@@ -266,7 +260,6 @@ pub(crate) fn component_to_tokens(
         quote! {}
     };
 
-    let name = node.name();
     #[allow(unused_mut)] // used in debug
     let mut component = quote! {
         {

leptos_macro/src/view/mod.rs

@@ -7,16 +7,13 @@ use self::{
 use convert_case::{Case::Snake, Casing};
 use leptos_hot_reload::parsing::{is_component_node, value_to_string};
 use proc_macro2::{Ident, Span, TokenStream, TokenTree};
-use proc_macro_error2::abort;
+use proc_macro_error::abort;
 use quote::{quote, quote_spanned, ToTokens};
 use rstml::node::{
-    CustomNode, KVAttributeValue, KeyedAttribute, Node, NodeAttribute,
-    NodeBlock, NodeElement, NodeName, NodeNameFragment,
-};
-use std::{
-    cmp::Ordering,
-    collections::{HashMap, HashSet, VecDeque},
+    KeyedAttribute, Node, NodeAttribute, NodeBlock, NodeElement, NodeName,
+    NodeNameFragment,
 };
+use std::collections::{HashMap, HashSet};
 use syn::{
     spanned::Spanned, Expr, Expr::Tuple, ExprLit, ExprRange, Lit, LitStr,
     RangeLimits, Stmt,
@@ -31,10 +28,9 @@ pub(crate) enum TagType {
 }
 
 pub fn render_view(
-    nodes: &mut [Node],
+    nodes: &[Node],
     global_class: Option<&TokenTree>,
     view_marker: Option<String>,
-    disable_inert_html: bool,
 ) -> Option<TokenStream> {
     let (base, should_add_view) = match nodes.len() {
         0 => {
@@ -48,13 +44,11 @@ pub fn render_view(
         }
         1 => (
             node_to_tokens(
-                &mut nodes[0],
+                &nodes[0],
                 TagType::Unknown,
                 None,
                 global_class,
                 view_marker.as_deref(),
-                true,
-                disable_inert_html,
             ),
             // only add View wrapper and view marker to a regular HTML
             // element or component, not to a <{..} /> attribute list
@@ -70,7 +64,6 @@ pub fn render_view(
                 None,
                 global_class,
                 view_marker.as_deref(),
-                disable_inert_html,
             ),
             true,
         ),
@@ -95,287 +88,12 @@ pub fn render_view(
     })
 }
 
-fn is_inert_element(orig_node: &Node<impl CustomNode>) -> bool {
-    // do not use this if the top-level node is not an Element,
-    // or if it's an element with no children and no attrs
-    match orig_node {
-        Node::Element(el) => {
-            if el.attributes().is_empty() && el.children.is_empty() {
-                return false;
-            }
-
-            // also doesn't work if the top-level element is an SVG/MathML element
-            let el_name = el.name().to_string();
-            if is_svg_element(&el_name) || is_math_ml_element(&el_name) {
-                return false;
-            }
-        }
-        _ => return false,
-    }
-
-    // otherwise, walk over all the nodes to make sure everything is inert
-    let mut nodes = VecDeque::from([orig_node]);
-
-    while let Some(current_element) = nodes.pop_front() {
-        match current_element {
-            Node::Text(_) | Node::RawText(_) => {}
-            Node::Element(node) => {
-                if is_component_node(node) {
-                    return false;
-                }
-                if is_spread_marker(node) {
-                    return false;
-                }
-
-                match node.name() {
-                    NodeName::Block(_) => return false,
-                    _ => {
-                        // check all attributes
-                        for attr in node.attributes() {
-                            match attr {
-                                NodeAttribute::Block(_) => return false,
-                                NodeAttribute::Attribute(attr) => {
-                                    let static_key =
-                                        !matches!(attr.key, NodeName::Block(_));
-
-                                    let static_value = match attr
-                                        .possible_value
-                                        .to_value()
-                                    {
-                                        None => true,
-                                        Some(value) => {
-                                            matches!(&value.value, KVAttributeValue::Expr(expr) if {
-                                                if let Expr::Lit(lit) = expr {
-                                                    matches!(&lit.lit, Lit::Str(_))
-                                                } else {
-                                                    false
-                                                }
-                                            })
-                                        }
-                                    };
-
-                                    if !static_key || !static_value {
-                                        return false;
-                                    }
-                                }
-                            }
-                        }
-
-                        // check all children
-                        nodes.extend(&node.children);
-                    }
-                }
-            }
-            _ => return false,
-        }
-    }
-
-    true
-}
-
-enum Item<'a, T> {
-    Node(&'a Node<T>),
-    ClosingTag(String),
-}
-
-enum InertElementBuilder<'a> {
-    GlobalClass {
-        global_class: &'a TokenTree,
-        strs: Vec<GlobalClassItem<'a>>,
-        buffer: String,
-    },
-    NoGlobalClass {
-        buffer: String,
-    },
-}
-
-impl<'a> ToTokens for InertElementBuilder<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        match self {
-            InertElementBuilder::GlobalClass { strs, .. } => {
-                tokens.extend(quote! {
-                    [#(#strs),*].join("")
-                });
-            }
-            InertElementBuilder::NoGlobalClass { buffer } => {
-                tokens.extend(quote! {
-                    #buffer
-                })
-            }
-        }
-    }
-}
-
-enum GlobalClassItem<'a> {
-    Global(&'a TokenTree),
-    String(String),
-}
-
-impl<'a> ToTokens for GlobalClassItem<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let addl_tokens = match self {
-            GlobalClassItem::Global(v) => v.to_token_stream(),
-            GlobalClassItem::String(v) => v.to_token_stream(),
-        };
-        tokens.extend(addl_tokens);
-    }
-}
-
-impl<'a> InertElementBuilder<'a> {
-    fn new(global_class: Option<&'a TokenTree>) -> Self {
-        match global_class {
-            None => Self::NoGlobalClass {
-                buffer: String::new(),
-            },
-            Some(global_class) => Self::GlobalClass {
-                global_class,
-                strs: Vec::new(),
-                buffer: String::new(),
-            },
-        }
-    }
-
-    fn push(&mut self, c: char) {
-        match self {
-            InertElementBuilder::GlobalClass { buffer, .. } => buffer.push(c),
-            InertElementBuilder::NoGlobalClass { buffer } => buffer.push(c),
-        }
-    }
-
-    fn push_str(&mut self, s: &str) {
-        match self {
-            InertElementBuilder::GlobalClass { buffer, .. } => {
-                buffer.push_str(s)
-            }
-            InertElementBuilder::NoGlobalClass { buffer } => buffer.push_str(s),
-        }
-    }
-
-    fn push_class(&mut self, class: &str) {
-        match self {
-            InertElementBuilder::GlobalClass {
-                global_class,
-                strs,
-                buffer,
-            } => {
-                buffer.push_str(" class=\"");
-                strs.push(GlobalClassItem::String(std::mem::take(buffer)));
-                strs.push(GlobalClassItem::Global(global_class));
-                buffer.push(' ');
-                buffer.push_str(class);
-                buffer.push('"');
-            }
-            InertElementBuilder::NoGlobalClass { buffer } => {
-                buffer.push_str(" class=\"");
-                buffer.push_str(class);
-                buffer.push('"');
-            }
-        }
-    }
-
-    fn finish(&mut self) {
-        match self {
-            InertElementBuilder::GlobalClass { strs, buffer, .. } => {
-                strs.push(GlobalClassItem::String(std::mem::take(buffer)));
-            }
-            InertElementBuilder::NoGlobalClass { .. } => {}
-        }
-    }
-}
-
-fn inert_element_to_tokens(
-    node: &Node<impl CustomNode>,
-    global_class: Option<&TokenTree>,
-) -> Option<TokenStream> {
-    let mut html = InertElementBuilder::new(global_class);
-    let mut nodes = VecDeque::from([Item::Node(node)]);
-
-    while let Some(current) = nodes.pop_front() {
-        match current {
-            Item::ClosingTag(tag) => {
-                // closing tag
-                html.push_str("</");
-                html.push_str(&tag);
-                html.push('>');
-            }
-            Item::Node(current) => {
-                match current {
-                    Node::RawText(raw) => {
-                        let text = raw.to_string_best();
-                        html.push_str(&text);
-                    }
-                    Node::Text(text) => {
-                        let text = text.value_string();
-                        html.push_str(&text);
-                    }
-                    Node::Element(node) => {
-                        let self_closing = is_self_closing(node);
-                        let el_name = node.name().to_string();
-
-                        // opening tag
-                        html.push('<');
-                        html.push_str(&el_name);
-
-                        for attr in node.attributes() {
-                            if let NodeAttribute::Attribute(attr) = attr {
-                                let attr_name = attr.key.to_string();
-                                if attr_name != "class" {
-                                    html.push(' ');
-                                    html.push_str(&attr_name);
-                                }
-
-                                if let Some(value) =
-                                    attr.possible_value.to_value()
-                                {
-                                    if let KVAttributeValue::Expr(Expr::Lit(
-                                        lit,
-                                    )) = &value.value
-                                    {
-                                        if let Lit::Str(txt) = &lit.lit {
-                                            if attr_name == "class" {
-                                                html.push_class(&txt.value());
-                                            } else {
-                                                html.push_str("=\"");
-                                                html.push_str(&txt.value());
-                                                html.push('"');
-                                            }
-                                        }
-                                    }
-                                };
-                            }
-                        }
-
-                        html.push('>');
-
-                        // render all children
-                        if !self_closing {
-                            nodes.push_front(Item::ClosingTag(el_name));
-                            let children = node.children.iter().rev();
-                            for child in children {
-                                nodes.push_front(Item::Node(child));
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    html.finish();
-
-    Some(quote! {
-        ::leptos::tachys::html::InertElement::new(#html)
-    })
-}
-
 fn element_children_to_tokens(
-    nodes: &mut [Node<impl CustomNode>],
+    nodes: &[Node],
     parent_type: TagType,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
     view_marker: Option<&str>,
-    disable_inert_html: bool,
 ) -> Option<TokenStream> {
     let children = children_to_tokens(
         nodes,
@@ -383,50 +101,27 @@ fn element_children_to_tokens(
         parent_slots,
         global_class,
         view_marker,
-        false,
-        disable_inert_html,
-    );
-    if children.is_empty() {
-        None
-    } else if children.len() == 1 {
-        let child = &children[0];
-        Some(quote! {
+    )
+    .into_iter()
+    .map(|child| {
+        quote! {
             .child(
                 #[allow(unused_braces)]
                 { #child }
             )
-        })
-    } else if children.len() > 16 {
-        // implementations of various traits used in routing and rendering are implemented for
-        // tuples of sizes 0, 1, 2, 3, ... N. N varies but is > 16. The traits are also implemented
-        // for tuples of tuples, so if we have more than 16 items, we can split them out into
-        // multiple tuples.
-        let chunks = children.chunks(16).map(|children| {
-            quote! {
-                (#(#children),*)
-            }
-        });
-        Some(quote! {
-            .child(
-                (#(#chunks),*)
-            )
-        })
-    } else {
-        Some(quote! {
-            .child(
-                (#(#children),*)
-            )
-        })
-    }
+        }
+    });
+    Some(quote! {
+        #(#children)*
+    })
 }
 
 fn fragment_to_tokens(
-    nodes: &mut [Node<impl CustomNode>],
+    nodes: &[Node],
     parent_type: TagType,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
     view_marker: Option<&str>,
-    disable_inert_html: bool,
 ) -> Option<TokenStream> {
     let children = children_to_tokens(
         nodes,
@@ -434,26 +129,11 @@ fn fragment_to_tokens(
         parent_slots,
         global_class,
         view_marker,
-        true,
-        disable_inert_html,
     );
     if children.is_empty() {
         None
     } else if children.len() == 1 {
         children.into_iter().next()
-    } else if children.len() > 16 {
-        // implementations of various traits used in routing and rendering are implemented for
-        // tuples of sizes 0, 1, 2, 3, ... N. N varies but is > 16. The traits are also implemented
-        // for tuples of tuples, so if we have more than 16 items, we can split them out into
-        // multiple tuples.
-        let chunks = children.chunks(16).map(|children| {
-            quote! {
-                (#(#children),*)
-            }
-        });
-        Some(quote! {
-             (#(#chunks),*)
-        })
     } else {
         Some(quote! {
             (#(#children),*)
@@ -462,23 +142,19 @@ fn fragment_to_tokens(
 }
 
 fn children_to_tokens(
-    nodes: &mut [Node<impl CustomNode>],
+    nodes: &[Node],
     parent_type: TagType,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
     view_marker: Option<&str>,
-    top_level: bool,
-    disable_inert_html: bool,
 ) -> Vec<TokenStream> {
     if nodes.len() == 1 {
         match node_to_tokens(
-            &mut nodes[0],
+            &nodes[0],
             parent_type,
             parent_slots,
             global_class,
             view_marker,
-            top_level,
-            disable_inert_html,
         ) {
             Some(tokens) => vec![tokens],
             None => vec![],
@@ -486,7 +162,7 @@ fn children_to_tokens(
     } else {
         let mut slots = HashMap::new();
         let nodes = nodes
-            .iter_mut()
+            .iter()
             .filter_map(|node| {
                 node_to_tokens(
                     node,
@@ -494,8 +170,6 @@ fn children_to_tokens(
                     Some(&mut slots),
                     global_class,
                     view_marker,
-                    top_level,
-                    disable_inert_html,
                 )
             })
             .collect();
@@ -512,16 +186,12 @@ fn children_to_tokens(
 }
 
 fn node_to_tokens(
-    node: &mut Node<impl CustomNode>,
+    node: &Node,
     parent_type: TagType,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
     view_marker: Option<&str>,
-    top_level: bool,
-    disable_inert_html: bool,
 ) -> Option<TokenStream> {
-    let is_inert = !disable_inert_html && is_inert_element(node);
-
     match node {
         Node::Comment(_) => None,
         Node::Doctype(node) => {
@@ -529,12 +199,11 @@ fn node_to_tokens(
             Some(quote! { ::leptos::tachys::html::doctype(#value) })
         }
         Node::Fragment(fragment) => fragment_to_tokens(
-            &mut fragment.children,
+            &fragment.children,
             parent_type,
             parent_slots,
             global_class,
             view_marker,
-            disable_inert_html,
         ),
         Node::Block(block) => Some(quote! { #block }),
         Node::Text(text) => Some(text_to_tokens(&text.value)),
@@ -543,21 +212,13 @@ fn node_to_tokens(
             let text = syn::LitStr::new(&text, raw.span());
             Some(text_to_tokens(&text))
         }
-        Node::Element(el_node) => {
-            if !top_level && is_inert {
-                inert_element_to_tokens(node, global_class)
-            } else {
-                element_to_tokens(
-                    el_node,
-                    parent_type,
-                    parent_slots,
-                    global_class,
-                    view_marker,
-                    disable_inert_html,
-                )
-            }
-        }
-        Node::Custom(node) => Some(node.to_token_stream()),
+        Node::Element(node) => element_to_tokens(
+            node,
+            parent_type,
+            parent_slots,
+            global_class,
+            view_marker,
+        ),
     }
 }
 
@@ -575,57 +236,12 @@ fn text_to_tokens(text: &LitStr) -> TokenStream {
 }
 
 pub(crate) fn element_to_tokens(
-    node: &mut NodeElement<impl CustomNode>,
+    node: &NodeElement,
     mut parent_type: TagType,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
     view_marker: Option<&str>,
-    disable_inert_html: bool,
 ) -> Option<TokenStream> {
-    // attribute sorting:
-    //
-    // the `class` and `style` attributes overwrite individual `class:` and `style:` attributes
-    // when they are set. as a result, we're going to sort the attributes so that `class` and
-    // `style` always come before all other attributes.
-
-    // if there's a spread marker, we don't want to move `class` or `style` before it
-    // so let's only sort attributes that come *before* a spread marker
-    let spread_position = node
-        .attributes()
-        .iter()
-        .position(|n| match n {
-            NodeAttribute::Block(node) => as_spread_attr(node).is_some(),
-            _ => false,
-        })
-        .unwrap_or_else(|| node.attributes().len());
-
-    // now, sort the attributes
-    node.attributes_mut()[0..spread_position].sort_by(|a, b| {
-        let key_a = match a {
-            NodeAttribute::Attribute(attr) => match &attr.key {
-                NodeName::Path(attr) => {
-                    attr.path.segments.first().map(|n| n.ident.to_string())
-                }
-                _ => None,
-            },
-            _ => None,
-        };
-        let key_b = match b {
-            NodeAttribute::Attribute(attr) => match &attr.key {
-                NodeName::Path(attr) => {
-                    attr.path.segments.first().map(|n| n.ident.to_string())
-                }
-                _ => None,
-            },
-            _ => None,
-        };
-        match (key_a.as_deref(), key_b.as_deref()) {
-            (Some("class"), _) | (Some("style"), _) => Ordering::Less,
-            (_, Some("class")) | (_, Some("style")) => Ordering::Greater,
-            _ => Ordering::Equal,
-        }
-    });
-
     // check for duplicate attribute names and emit an error for all subsequent ones
     let mut names = HashSet::new();
     for attr in node.attributes() {
@@ -636,7 +252,7 @@ pub(crate) fn element_to_tokens(
                 name.push_str(&tuple_name);
             }
             if names.contains(&name) {
-                proc_macro_error2::emit_error!(
+                proc_macro_error::emit_error!(
                     attr.span(),
                     format!("This element already has a `{name}` attribute.")
                 );
@@ -649,17 +265,10 @@ pub(crate) fn element_to_tokens(
     let name = node.name();
     if is_component_node(node) {
         if let Some(slot) = get_slot(node) {
-            let slot = slot.clone();
-            slot_to_tokens(
-                node,
-                &slot,
-                parent_slots,
-                global_class,
-                disable_inert_html,
-            );
+            slot_to_tokens(node, slot, parent_slots, global_class);
             None
         } else {
-            Some(component_to_tokens(node, global_class, disable_inert_html))
+            Some(component_to_tokens(node, global_class))
         }
     } else if is_spread_marker(node) {
         let mut attributes = Vec::new();
@@ -721,7 +330,7 @@ pub(crate) fn element_to_tokens(
             match parent_type {
                 TagType::Unknown => {
                     // We decided this warning was too aggressive, but I'll leave it here in case we want it later
-                    /* proc_macro_error2::emit_warning!(name.span(), "The view macro is assuming this is an HTML element, \
+                    /* proc_macro_error::emit_warning!(name.span(), "The view macro is assuming this is an HTML element, \
                     but it is ambiguous; if it is an SVG or MathML element, prefix with svg:: or math::"); */
                     quote! {
                         ::leptos::tachys::html::element::#name()
@@ -771,17 +380,16 @@ pub(crate) fn element_to_tokens(
         let self_closing = is_self_closing(node);
         let children = if !self_closing {
             element_children_to_tokens(
-                &mut node.children,
+                &node.children,
                 parent_type,
                 parent_slots,
                 global_class,
                 view_marker,
-                disable_inert_html,
             )
         } else {
             if !node.children.is_empty() {
                 let name = node.name();
-                proc_macro_error2::emit_error!(
+                proc_macro_error::emit_error!(
                     name.span(),
                     format!(
                         "Self-closing elements like <{name}> cannot have \
@@ -803,7 +411,7 @@ pub(crate) fn element_to_tokens(
     }
 }
 
-fn is_spread_marker(node: &NodeElement<impl CustomNode>) -> bool {
+fn is_spread_marker(node: &NodeElement) -> bool {
     match node.name() {
         NodeName::Block(block) => matches!(
             block.stmts.first(),
@@ -821,25 +429,6 @@ fn is_spread_marker(node: &NodeElement<impl CustomNode>) -> bool {
     }
 }
 
-fn as_spread_attr(node: &NodeBlock) -> Option<Option<&Expr>> {
-    if let NodeBlock::ValidBlock(block) = node {
-        match block.stmts.first() {
-            Some(Stmt::Expr(
-                Expr::Range(ExprRange {
-                    start: None,
-                    limits: RangeLimits::HalfOpen(_),
-                    end,
-                    ..
-                }),
-                _,
-            )) => Some(end.as_deref()),
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
 fn attribute_to_tokens(
     tag_type: TagType,
     node: &NodeAttribute,
@@ -847,18 +436,29 @@ fn attribute_to_tokens(
     is_custom: bool,
 ) -> TokenStream {
     match node {
-        NodeAttribute::Block(node) => as_spread_attr(node)
-            .flatten()
-            .map(|end| {
-                quote! {
-                    .add_any_attr(#end)
+        NodeAttribute::Block(node) => {
+            let dotted = if let NodeBlock::ValidBlock(block) = node {
+                match block.stmts.first() {
+                    Some(Stmt::Expr(
+                        Expr::Range(ExprRange {
+                            start: None,
+                            limits: RangeLimits::HalfOpen(_),
+                            end: Some(end),
+                            ..
+                        }),
+                        _,
+                    )) => Some(quote! { .add_any_attr(#end) }),
+                    _ => None,
                 }
-            })
-            .unwrap_or_else(|| {
+            } else {
+                None
+            };
+            dotted.unwrap_or_else(|| {
                 quote! {
                     .add_any_attr(#[allow(unused_braces)] { #node })
                 }
-            }),
+            })
+        }
         NodeAttribute::Attribute(node) => {
             let name = node.key.to_string();
             if name == "node_ref" {
@@ -928,7 +528,7 @@ fn attribute_to_tokens(
                     && node.value().and_then(value_to_string).is_none()
                 {
                     let span = node.key.span();
-                    proc_macro_error2::emit_error!(span, "Combining a global class (view! { class = ... }) \
+                    proc_macro_error::emit_error!(span, "Combining a global class (view! { class = ... }) \
             and a dynamic `class=` attribute on an element causes runtime inconsistencies. You can \
             toggle individual classes dynamically with the `class:name=value` syntax. \n\nSee this issue \
             for more information and an example: https://github.com/leptos-rs/leptos/issues/773")
@@ -947,19 +547,17 @@ pub(crate) fn attribute_absolute(
     node: &KeyedAttribute,
     after_spread: bool,
 ) -> Option<TokenStream> {
-    let key = node.key.to_string();
-    let contains_dash = key.contains('-');
-    let attr_aira = key.starts_with("attr:aria-");
+    let contains_dash = node.key.to_string().contains('-');
     // anything that follows the x:y pattern
     match &node.key {
-        NodeName::Punctuated(parts) if !contains_dash || attr_aira => {
+        NodeName::Punctuated(parts) if !contains_dash => {
             if parts.len() >= 2 {
                 let id = &parts[0];
                 match id {
                     NodeNameFragment::Ident(id) => {
                         let value = attribute_value(node);
-                        // ignore `let:` and `clone:`
-                        if id == "let" || id == "clone" {
+                        // ignore `let:`
+                        if id == "let" {
                             None
                         } else if id == "attr" {
                             let key = &parts[1];
@@ -968,14 +566,6 @@ pub(crate) fn attribute_absolute(
                                 Some(
                                     quote! { ::leptos::tachys::html::#key::#key(#value) },
                                 )
-                            } else if key_name == "aria" {
-                                let mut parts_iter = parts.iter();
-                                parts_iter.next();
-                                let fn_name = parts_iter.map(|p| p.to_string()).collect::<Vec<String>>().join("_");
-                                let key = Ident::new(&fn_name, key.span());
-                                Some(
-                                    quote! { ::leptos::tachys::html::attribute::#key(#value) },
-                                )
                             } else {
                                 Some(
                                     quote! { ::leptos::tachys::html::attribute::#key(#value) },
@@ -1019,7 +609,7 @@ pub(crate) fn attribute_absolute(
                                 quote! { ::leptos::tachys::html::event::#on(#ty, #handler) },
                             )
                         } else {
-                            proc_macro_error2::abort!(
+                            proc_macro_error::abort!(
                                 id.span(),
                                 &format!(
                                     "`{id}:` syntax is not supported on \
@@ -1173,7 +763,7 @@ fn is_custom_element(tag: &str) -> bool {
     tag.contains('-')
 }
 
-fn is_self_closing(node: &NodeElement<impl CustomNode>) -> bool {
+fn is_self_closing(node: &NodeElement) -> bool {
     // self-closing tags
     // https://developer.mozilla.org/en-US/docs/Glossary/Empty_element
     [
@@ -1321,31 +911,20 @@ fn attribute_name(name: &NodeName) -> TokenStream {
 }
 
 fn attribute_value(attr: &KeyedAttribute) -> TokenStream {
-    match attr.possible_value.to_value() {
-        None => quote! { true },
-        Some(value) => match &value.value {
-            KVAttributeValue::Expr(expr) => {
-                if let Expr::Lit(lit) = expr {
-                    if cfg!(feature = "nightly") {
-                        if let Lit::Str(str) = &lit.lit {
-                            return quote! {
-                                ::leptos::tachys::view::static_types::Static::<#str>
-                            };
-                        }
+    match attr.value() {
+        Some(value) => {
+            if let Expr::Lit(lit) = value {
+                if cfg!(feature = "nightly") {
+                    if let Lit::Str(str) = &lit.lit {
+                        return quote! {
+                            ::leptos::tachys::view::static_types::Static::<#str>
+                        };
                     }
                 }
-
-                quote! {
-                    {#expr}
-                }
             }
-            // any value in braces: expand as-is to give proper r-a support
-            KVAttributeValue::InvalidBraced(block) => {
-                quote! {
-                    #block
-                }
-            }
-        },
+            quote! { #value }
+        }
+        None => quote! { true },
     }
 }
 
@@ -1520,7 +1099,7 @@ pub(crate) fn ident_from_tag_name(tag_name: &NodeName) -> Ident {
             .expect("element needs to have a name"),
         NodeName::Block(_) => {
             let span = tag_name.span();
-            proc_macro_error2::emit_error!(
+            proc_macro_error::emit_error!(
                 span,
                 "blocks not allowed in tag-name position"
             );

leptos_macro/src/view/slot_helper.rs

@@ -2,16 +2,15 @@ use super::{convert_to_snake_case, ident_from_tag_name};
 use crate::view::{fragment_to_tokens, TagType};
 use proc_macro2::{Ident, TokenStream, TokenTree};
 use quote::{format_ident, quote, quote_spanned};
-use rstml::node::{CustomNode, KeyedAttribute, NodeAttribute, NodeElement};
+use rstml::node::{KeyedAttribute, NodeAttribute, NodeElement};
 use std::collections::HashMap;
 use syn::spanned::Spanned;
 
 pub(crate) fn slot_to_tokens(
-    node: &mut NodeElement<impl CustomNode>,
+    node: &NodeElement,
     slot: &KeyedAttribute,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
-    disable_inert_html: bool,
 ) {
     let name = slot.key.to_string();
     let name = name.trim();
@@ -24,32 +23,27 @@ pub(crate) fn slot_to_tokens(
     let component_name = ident_from_tag_name(node.name());
 
     let Some(parent_slots) = parent_slots else {
-        proc_macro_error2::emit_error!(
+        proc_macro_error::emit_error!(
             node.name().span(),
             "slots cannot be used inside HTML elements"
         );
         return;
     };
 
-    let attrs = node
-        .attributes()
-        .iter()
-        .filter_map(|node| {
-            if let NodeAttribute::Attribute(node) = node {
-                if is_slot(node) {
-                    None
-                } else {
-                    Some(node)
-                }
-            } else {
+    let attrs = node.attributes().iter().filter_map(|node| {
+        if let NodeAttribute::Attribute(node) = node {
+            if is_slot(node) {
                 None
+            } else {
+                Some(node)
             }
-        })
-        .cloned()
-        .collect::<Vec<_>>();
+        } else {
+            None
+        }
+    });
 
     let props = attrs
-        .iter()
+        .clone()
         .filter(|attr| {
             !attr.key.to_string().starts_with("let:")
                 && !attr.key.to_string().starts_with("clone:")
@@ -71,7 +65,7 @@ pub(crate) fn slot_to_tokens(
         });
 
     let items_to_bind = attrs
-        .iter()
+        .clone()
         .filter_map(|attr| {
             attr.key
                 .to_string()
@@ -81,7 +75,7 @@ pub(crate) fn slot_to_tokens(
         .collect::<Vec<_>>();
 
     let items_to_clone = attrs
-        .iter()
+        .clone()
         .filter_map(|attr| {
             attr.key
                 .to_string()
@@ -91,7 +85,6 @@ pub(crate) fn slot_to_tokens(
         .collect::<Vec<_>>();
 
     let dyn_attrs = attrs
-        .iter()
         .filter(|attr| attr.key.to_string().starts_with("attr:"))
         .filter_map(|attr| {
             let name = &attr.key.to_string();
@@ -114,12 +107,11 @@ pub(crate) fn slot_to_tokens(
         quote! {}
     } else {
         let children = fragment_to_tokens(
-            &mut node.children,
+            &node.children,
             TagType::Unknown,
             Some(&mut slots),
             global_class,
             None,
-            disable_inert_html,
         );
 
         // TODO view markers for hot-reloading
@@ -221,9 +213,7 @@ pub(crate) fn is_slot(node: &KeyedAttribute) -> bool {
     key == "slot" || key.starts_with("slot:")
 }
 
-pub(crate) fn get_slot(
-    node: &NodeElement<impl CustomNode>,
-) -> Option<&KeyedAttribute> {
+pub(crate) fn get_slot(node: &NodeElement) -> Option<&KeyedAttribute> {
     node.attributes().iter().find_map(|node| {
         if let NodeAttribute::Attribute(node) = node {
             if is_slot(node) {

leptos_server/Cargo.toml

@@ -20,7 +20,6 @@ futures = "0.3.30"
 
 any_spawner = { workspace = true }
 tachys = { workspace = true, optional = true, features = ["reactive_graph"] }
-send_wrapper = "0.6"
 
 # serialization formats
 serde = { version = "1.0" }

leptos_server/src/local_resource.rs

@@ -7,11 +7,10 @@ use reactive_graph::{
         AnySource, AnySubscriber, ReactiveNode, Source, Subscriber,
         ToAnySource, ToAnySubscriber,
     },
-    owner::use_context,
+    owner::{use_context, LocalStorage},
     signal::guards::{AsyncPlain, ReadGuard},
-    traits::{DefinedAt, IsDisposed, ReadUntracked},
+    traits::{DefinedAt, ReadUntracked},
 };
-use send_wrapper::SendWrapper;
 use std::{
     future::{pending, Future, IntoFuture},
     panic::Location,
@@ -121,13 +120,6 @@ where
     }
 }
 
-impl<T: 'static> IsDisposed for ArcLocalResource<T> {
-    #[inline(always)]
-    fn is_disposed(&self) -> bool {
-        false
-    }
-}
-
 impl<T: 'static> ToAnySource for ArcLocalResource<T> {
     fn to_any_source(&self) -> AnySource {
         self.data.to_any_source()
@@ -183,7 +175,7 @@ impl<T> Subscriber for ArcLocalResource<T> {
 }
 
 pub struct LocalResource<T> {
-    data: AsyncDerived<SendWrapper<T>>,
+    data: AsyncDerived<T, LocalStorage>,
     #[cfg(debug_assertions)]
     defined_at: &'static Location<'static>,
 }
@@ -225,13 +217,9 @@ impl<T> LocalResource<T> {
 
         Self {
             data: if cfg!(feature = "ssr") {
-                AsyncDerived::new_mock(fetcher)
+                AsyncDerived::new_mock_unsync(fetcher)
             } else {
-                let fetcher = SendWrapper::new(fetcher);
-                AsyncDerived::new(move || {
-                    let fut = fetcher();
-                    async move { SendWrapper::new(fut.await) }
-                })
+                AsyncDerived::new_unsync(fetcher)
             },
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
@@ -244,14 +232,9 @@ where
     T: Clone + 'static,
 {
     type Output = T;
-    type IntoFuture = futures::future::Map<
-        AsyncDerivedFuture<SendWrapper<T>>,
-        fn(SendWrapper<T>) -> T,
-    >;
+    type IntoFuture = AsyncDerivedFuture<T>;
 
     fn into_future(self) -> Self::IntoFuture {
-        use futures::FutureExt;
-
         if let Some(mut notifier) = use_context::<LocalResourceNotifier>() {
             notifier.notify();
         } else if cfg!(feature = "ssr") {
@@ -261,7 +244,7 @@ where
                  always pending on the server."
             );
         }
-        self.data.into_future().map(|value| (*value).clone())
+        self.data.into_future()
     }
 }
 
@@ -282,8 +265,7 @@ impl<T> ReadUntracked for LocalResource<T>
 where
     T: Send + Sync + 'static,
 {
-    type Value =
-        ReadGuard<Option<SendWrapper<T>>, AsyncPlain<Option<SendWrapper<T>>>>;
+    type Value = ReadGuard<Option<T>, AsyncPlain<Option<T>>>;
 
     fn try_read_untracked(&self) -> Option<Self::Value> {
         if let Some(mut notifier) = use_context::<LocalResourceNotifier>() {
@@ -299,12 +281,6 @@ where
     }
 }
 
-impl<T: 'static> IsDisposed for LocalResource<T> {
-    fn is_disposed(&self) -> bool {
-        self.data.is_disposed()
-    }
-}
-
 impl<T: 'static> ToAnySource for LocalResource<T>
 where
     T: Send + Sync + 'static,

leptos_server/src/resource.rs

@@ -24,37 +24,12 @@ use reactive_graph::{
     prelude::*,
     signal::{ArcRwSignal, RwSignal},
 };
-use std::{future::IntoFuture, ops::Deref, panic::Location};
+use std::{future::IntoFuture, ops::Deref};
 
 pub struct ArcResource<T, Ser = JsonSerdeCodec> {
     ser: PhantomData<Ser>,
     refetch: ArcRwSignal<usize>,
     data: ArcAsyncDerived<T>,
-    #[cfg(debug_assertions)]
-    defined_at: &'static Location<'static>,
-}
-
-impl<T, Ser> Debug for ArcResource<T, Ser> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut d = f.debug_struct("ArcResource");
-        d.field("ser", &self.ser).field("data", &self.data);
-        #[cfg(debug_assertions)]
-        d.field("defined_at", self.defined_at);
-        d.finish_non_exhaustive()
-    }
-}
-
-impl<T, Ser> DefinedAt for ArcResource<T, Ser> {
-    fn defined_at(&self) -> Option<&'static Location<'static>> {
-        #[cfg(debug_assertions)]
-        {
-            Some(self.defined_at)
-        }
-        #[cfg(not(debug_assertions))]
-        {
-            None
-        }
-    }
 }
 
 impl<T, Ser> Clone for ArcResource<T, Ser> {
@@ -63,8 +38,6 @@ impl<T, Ser> Clone for ArcResource<T, Ser> {
             ser: self.ser,
             refetch: self.refetch.clone(),
             data: self.data.clone(),
-            #[cfg(debug_assertions)]
-            defined_at: self.defined_at,
         }
     }
 }
@@ -108,23 +81,20 @@ where
         let is_ready = initial.is_some();
 
         let refetch = ArcRwSignal::new(0);
-        let source = ArcMemo::new({
-            let refetch = refetch.clone();
-            move |_| (refetch.get(), source())
-        });
+        let source = ArcMemo::new(move |_| source());
         let fun = {
             let source = source.clone();
+            let refetch = refetch.clone();
             move || {
-                let (_, source) = source.get();
-                fetcher(source)
+                refetch.track();
+                fetcher(source.get())
             }
         };
 
-        let data = ArcAsyncDerived::new_with_manual_dependencies(
-            initial, fun, &source,
-        );
+        let data =
+            ArcAsyncDerived::new_with_initial_without_spawning(initial, fun);
         if is_ready {
-            source.with_untracked(|_| ());
+            source.with(|_| ());
             source.add_subscriber(data.to_any_subscriber());
         }
 
@@ -137,29 +107,25 @@ where
                 shared_context.defer_stream(Box::pin(data.ready()));
             }
 
-            if shared_context.get_is_hydrating() {
-                shared_context.write_async(
-                    id,
-                    Box::pin(async move {
-                        ready_fut.await;
-                        value.with_untracked(|data| match &data {
-                            // TODO handle serialization errors
-                            Some(val) => {
-                                Ser::encode(val).unwrap().into_encoded_string()
-                            }
-                            _ => unreachable!(),
-                        })
-                    }),
-                );
-            }
+            shared_context.write_async(
+                id,
+                Box::pin(async move {
+                    ready_fut.await;
+                    value.with_untracked(|data| match &data {
+                        // TODO handle serialization errors
+                        Some(val) => {
+                            Ser::encode(val).unwrap().into_encoded_string()
+                        }
+                        _ => unreachable!(),
+                    })
+                }),
+            );
         }
 
         ArcResource {
             ser: PhantomData,
             data,
             refetch,
-            #[cfg(debug_assertions)]
-            defined_at: Location::caller(),
         }
     }
 
@@ -477,37 +443,6 @@ where
     ser: PhantomData<Ser>,
     data: AsyncDerived<T>,
     refetch: RwSignal<usize>,
-    #[cfg(debug_assertions)]
-    defined_at: &'static Location<'static>,
-}
-
-impl<T, Ser> Debug for Resource<T, Ser>
-where
-    T: Send + Sync + 'static,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut d = f.debug_struct("ArcResource");
-        d.field("ser", &self.ser).field("data", &self.data);
-        #[cfg(debug_assertions)]
-        d.field("defined_at", self.defined_at);
-        d.finish_non_exhaustive()
-    }
-}
-
-impl<T, Ser> DefinedAt for Resource<T, Ser>
-where
-    T: Send + Sync + 'static,
-{
-    fn defined_at(&self) -> Option<&'static Location<'static>> {
-        #[cfg(debug_assertions)]
-        {
-            Some(self.defined_at)
-        }
-        #[cfg(not(debug_assertions))]
-        {
-            None
-        }
-    }
 }
 
 impl<T: Send + Sync + 'static, Ser> Copy for Resource<T, Ser> {}
@@ -763,8 +698,6 @@ where
             ser: PhantomData,
             data: data.into(),
             refetch: refetch.into(),
-            #[cfg(debug_assertions)]
-            defined_at: Location::caller(),
         }
     }
 

leptos_server/src/shared.rs

@@ -191,19 +191,16 @@ where
                 let init = initial();
                 #[cfg(feature = "ssr")]
                 if let Some(sc) = sc {
-                    if sc.get_is_hydrating() {
-                        match Ser::encode(&init)
-                            .map(IntoEncodedString::into_encoded_string)
-                        {
-                            Ok(value) => sc.write_async(
-                                id,
-                                Box::pin(async move { value }),
-                            ),
-                            #[allow(unused_variables)] // used in tracing
-                            Err(e) => {
-                                #[cfg(feature = "tracing")]
-                                tracing::error!("couldn't serialize: {e:?}");
-                            }
+                    match Ser::encode(&init)
+                        .map(IntoEncodedString::into_encoded_string)
+                    {
+                        Ok(value) => {
+                            sc.write_async(id, Box::pin(async move { value }))
+                        }
+                        #[allow(unused_variables)] // used in tracing
+                        Err(e) => {
+                            #[cfg(feature = "tracing")]
+                            tracing::error!("couldn't serialize: {e:?}");
                         }
                     }
                 }

meta/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos_meta"
-version = "0.7.0-beta6"
+version = "0.7.0-beta3"
 authors = ["Greg Johnston"]
 license = "MIT"
 repository = "https://github.com/leptos-rs/leptos"

meta/src/body.rs

@@ -29,7 +29,7 @@ use leptos::{
 /// #[component]
 /// fn MyApp() -> impl IntoView {
 ///     provide_meta_context();
-///     let (prefers_dark, set_prefers_dark) = signal(false);
+///     let (prefers_dark, set_prefers_dark) = create_signal(false);
 ///     let body_class = move || {
 ///         if prefers_dark.get() {
 ///             "dark".to_string()

meta/src/stylesheet.rs

@@ -1,7 +1,7 @@
 use crate::register;
 use leptos::{
-    attr::global::GlobalAttributes, component, prelude::LeptosOptions,
-    tachys::html::element::link, IntoView,
+    attr::global::GlobalAttributes, component, tachys::html::element::link,
+    IntoView,
 };
 
 /// Injects an [`HTMLLinkElement`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement) into the document
@@ -34,51 +34,3 @@ pub fn Stylesheet(
     // TODO additional attributes
     register(link().id(id).rel("stylesheet").href(href))
 }
-
-/// Injects an [`HTMLLinkElement`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement) into the document head that loads a `cargo-leptos`-hashed stylesheet.
-#[component]
-pub fn HashedStylesheet(
-    /// Leptos options
-    options: LeptosOptions,
-    /// An ID for the stylesheet.
-    #[prop(optional, into)]
-    id: Option<String>,
-    /// A base url, not including a trailing slash
-    #[prop(optional, into)]
-    root: Option<String>,
-) -> impl IntoView {
-    let mut css_file_name = options.output_name.to_string();
-    if options.hash_files {
-        let hash_path = std::env::current_exe()
-            .map(|path| {
-                path.parent().map(|p| p.to_path_buf()).unwrap_or_default()
-            })
-            .unwrap_or_default()
-            .join(&options.hash_file);
-        if hash_path.exists() {
-            let hashes = std::fs::read_to_string(&hash_path)
-                .expect("failed to read hash file");
-            for line in hashes.lines() {
-                let line = line.trim();
-                if !line.is_empty() {
-                    if let Some((file, hash)) = line.split_once(':') {
-                        if file == "css" {
-                            css_file_name
-                                .push_str(&format!(".{}", hash.trim()));
-                        }
-                    }
-                }
-            }
-        }
-    }
-    css_file_name.push_str(".css");
-    let pkg_path = &options.site_pkg_dir;
-    let root = root.unwrap_or_default();
-    // TODO additional attributes
-    register(
-        link()
-            .id(id)
-            .rel("stylesheet")
-            .href(format!("{root}/{pkg_path}/{css_file_name}")),
-    )
-}

next_tuple/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "next_tuple"
-version = "0.1.0-beta6"
+version = "0.1.0-beta2"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"

reactive_graph/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reactive_graph"
-version = "0.1.0-beta6"
+version = "0.1.0-beta2"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"

reactive_graph/src/actions/action.rs

@@ -1,7 +1,7 @@
 use crate::{
     computed::{ArcMemo, Memo},
     diagnostics::is_suppressing_resource_load,
-    owner::{ArenaItem, FromLocal, LocalStorage, Storage, SyncStorage},
+    owner::{FromLocal, LocalStorage, Storage, StoredValue, SyncStorage},
     signal::{ArcRwSignal, RwSignal},
     traits::{DefinedAt, Dispose, Get, GetUntracked, Update},
     unwrap_signal,
@@ -235,7 +235,7 @@ where
             self.input.try_update(|inp| *inp = Some(input));
 
             // Spawn the task
-            crate::spawn({
+            Executor::spawn({
                 let input = self.input.clone();
                 let version = self.version.clone();
                 let value = self.value.clone();
@@ -575,7 +575,7 @@ where
 /// let action3 = Action::new(|input: &(usize, String)| async { todo!() });
 /// ```
 pub struct Action<I, O, S = SyncStorage> {
-    inner: ArenaItem<ArcAction<I, O>, S>,
+    inner: StoredValue<ArcAction<I, O>, S>,
     #[cfg(debug_assertions)]
     defined_at: &'static Location<'static>,
 }
@@ -639,7 +639,7 @@ where
         Fu: Future<Output = O> + Send + 'static,
     {
         Self {
-            inner: ArenaItem::new(ArcAction::new(action_fn)),
+            inner: StoredValue::new(ArcAction::new(action_fn)),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
         }
@@ -664,7 +664,9 @@ where
         Fu: Future<Output = O> + Send + 'static,
     {
         Self {
-            inner: ArenaItem::new(ArcAction::new_with_value(value, action_fn)),
+            inner: StoredValue::new(ArcAction::new_with_value(
+                value, action_fn,
+            )),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
         }
@@ -686,7 +688,7 @@ where
         Fu: Future<Output = O> + Send + 'static,
     {
         Self {
-            inner: ArenaItem::new_local(ArcAction::new_unsync(action_fn)),
+            inner: StoredValue::new_local(ArcAction::new_unsync(action_fn)),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
         }
@@ -702,7 +704,7 @@ where
         Fu: Future<Output = O> + Send + 'static,
     {
         Self {
-            inner: ArenaItem::new_local(ArcAction::new_unsync_with_value(
+            inner: StoredValue::new_local(ArcAction::new_unsync_with_value(
                 value, action_fn,
             )),
             #[cfg(debug_assertions)]
@@ -906,9 +908,7 @@ where
     /// Calls the `async` function with a reference to the input type as its argument.
     #[track_caller]
     pub fn dispatch(&self, input: I) -> ActionAbortHandle {
-        self.inner
-            .try_with_value(|inner| inner.dispatch(input))
-            .unwrap_or_else(unwrap_signal!(self))
+        self.inner.with_value(|inner| inner.dispatch(input))
     }
 }
 
@@ -921,9 +921,7 @@ where
     /// Calls the `async` function with a reference to the input type as its argument.
     #[track_caller]
     pub fn dispatch_local(&self, input: I) -> ActionAbortHandle {
-        self.inner
-            .try_with_value(|inner| inner.dispatch_local(input))
-            .unwrap_or_else(unwrap_signal!(self))
+        self.inner.with_value(|inner| inner.dispatch_local(input))
     }
 }
 
@@ -944,7 +942,7 @@ where
         Fu: Future<Output = O> + 'static,
     {
         Self {
-            inner: ArenaItem::new_with_storage(ArcAction::new_unsync(
+            inner: StoredValue::new_with_storage(ArcAction::new_unsync(
                 action_fn,
             )),
             #[cfg(debug_assertions)]
@@ -963,7 +961,7 @@ where
         Fu: Future<Output = O> + 'static,
     {
         Self {
-            inner: ArenaItem::new_with_storage(
+            inner: StoredValue::new_with_storage(
                 ArcAction::new_unsync_with_value(value, action_fn),
             ),
             #[cfg(debug_assertions)]