0.7.0-rc0

See 1966 for original PR on older version

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

@@ -94,7 +94,7 @@ jobs:
             fi
           done
       - name: Install Deno
-        uses: denoland/setup-deno@v1
+        uses: denoland/setup-deno@v2
         with:
           deno-version: v1.x
       - name: Maybe install gtk-rs dependencies

Cargo.toml

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

any_error/Cargo.toml

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

any_spawner/Cargo.toml

@@ -9,6 +9,7 @@ description = "Spawn asynchronous tasks in an executor-independent way."
 edition.workspace = true
 
 [dependencies]
+async-executor = { version = "1.13.1", optional = true }
 futures = "0.3.30"
 glib = { version = "0.20.0", optional = true }
 thiserror = "1.0"
@@ -19,12 +20,14 @@ tracing = { version = "0.1.40", optional = true }
 wasm-bindgen-futures = { version = "0.4.42", optional = true }
 
 [features]
+async-executor = ["dep:async-executor"]
 tracing = ["dep:tracing"]
 tokio = ["dep:tokio"]
 glib = ["dep:glib"]
 wasm-bindgen = ["dep:wasm-bindgen-futures"]
 futures-executor = ["futures/thread-pool", "futures/executor"]
 
+
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

any_spawner/src/lib.rs

@@ -32,11 +32,14 @@
 use std::{future::Future, pin::Pin, sync::OnceLock};
 use thiserror::Error;
 
-pub(crate) type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
-pub(crate) type PinnedLocalFuture<T> = Pin<Box<dyn Future<Output = T>>>;
+/// A future that has been pinned.
+pub type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
+/// A future that has been pinned.
+pub type PinnedLocalFuture<T> = Pin<Box<dyn Future<Output = T>>>;
 
 static SPAWN: OnceLock<fn(PinnedFuture<()>)> = OnceLock::new();
 static SPAWN_LOCAL: OnceLock<fn(PinnedLocalFuture<()>)> = OnceLock::new();
+static POLL_LOCAL: OnceLock<fn()> = OnceLock::new();
 
 /// Errors that can occur when using the executor.
 #[derive(Error, Debug)]
@@ -115,6 +118,14 @@ impl Executor {
         });
         _ = rx.await;
     }
+
+    /// Polls the current async executor.
+    /// Not all async executors support polling, so this function may not do anything.
+    pub fn poll_local() {
+        if let Some(poller) = POLL_LOCAL.get() {
+            poller()
+        }
+    }
 }
 
 impl Executor {
@@ -193,13 +204,15 @@ impl Executor {
     #[cfg_attr(docsrs, doc(cfg(feature = "futures-executor")))]
     pub fn init_futures_executor() -> Result<(), ExecutorError> {
         use futures::{
-            executor::{LocalPool, ThreadPool},
+            executor::{LocalPool, LocalSpawner, ThreadPool},
             task::{LocalSpawnExt, SpawnExt},
         };
+        use std::cell::RefCell;
 
         static THREAD_POOL: OnceLock<ThreadPool> = OnceLock::new();
         thread_local! {
-            static LOCAL_POOL: LocalPool = LocalPool::new();
+            static LOCAL_POOL: RefCell<LocalPool> = RefCell::new(LocalPool::new());
+            static SPAWNER: LocalSpawner = LOCAL_POOL.with(|pool| pool.borrow().spawner());
         }
 
         fn get_thread_pool() -> &'static ThreadPool {
@@ -218,28 +231,97 @@ impl Executor {
             .map_err(|_| ExecutorError::AlreadySet)?;
         SPAWN_LOCAL
             .set(|fut| {
-                LOCAL_POOL.with(|pool| {
-                    let spawner = pool.spawner();
+                SPAWNER.with(|spawner| {
                     spawner.spawn_local(fut).expect("failed to spawn future");
                 });
             })
             .map_err(|_| ExecutorError::AlreadySet)?;
+        POLL_LOCAL
+            .set(|| {
+                LOCAL_POOL.with(|pool| {
+                    if let Ok(mut pool) = pool.try_borrow_mut() {
+                        pool.run_until_stalled();
+                    }
+                    // If we couldn't borrow_mut, we're in a nested call to poll, so we don't need to do anything.
+                });
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
         Ok(())
     }
-}
 
-#[cfg(test)]
-mod tests {
-    #[cfg(feature = "futures-executor")]
-    #[test]
-    fn can_spawn_local_future() {
-        use crate::Executor;
-        use std::rc::Rc;
-        Executor::init_futures_executor().expect("couldn't set executor");
-        let rc = Rc::new(());
-        Executor::spawn_local(async {
-            _ = rc;
-        });
-        Executor::spawn(async {});
+    /// Globally sets the [`async_executor`] executor as the executor used to spawn tasks,
+    /// lazily creating a thread pool to spawn tasks into.
+    ///
+    /// Returns `Err(_)` if an executor has already been set.
+    ///
+    /// Requires the `async-executor` feature to be activated on this crate.
+    #[cfg(feature = "async-executor")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async-executor")))]
+    pub fn init_async_executor() -> Result<(), ExecutorError> {
+        use async_executor::{Executor, LocalExecutor};
+
+        static THREAD_POOL: OnceLock<Executor> = OnceLock::new();
+        thread_local! {
+            static LOCAL_POOL: LocalExecutor<'static> = const { LocalExecutor::new() };
+        }
+
+        fn get_thread_pool() -> &'static Executor<'static> {
+            THREAD_POOL.get_or_init(Executor::new)
+        }
+
+        SPAWN
+            .set(|fut| {
+                get_thread_pool().spawn(fut).detach();
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        SPAWN_LOCAL
+            .set(|fut| {
+                LOCAL_POOL.with(|pool| pool.spawn(fut).detach());
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        POLL_LOCAL
+            .set(|| {
+                LOCAL_POOL.with(|pool| pool.try_tick());
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        Ok(())
+    }
+
+    /// Globally sets a custom executor as the executor used to spawn tasks.
+    ///
+    /// Returns `Err(_)` if an executor has already been set.
+    pub fn init_custom_executor(
+        custom_executor: impl CustomExecutor + 'static,
+    ) -> Result<(), ExecutorError> {
+        static EXECUTOR: OnceLock<Box<dyn CustomExecutor>> = OnceLock::new();
+        EXECUTOR
+            .set(Box::new(custom_executor))
+            .map_err(|_| ExecutorError::AlreadySet)?;
+
+        SPAWN
+            .set(|fut| {
+                EXECUTOR.get().unwrap().spawn(fut);
+            })
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        SPAWN_LOCAL
+            .set(|fut| EXECUTOR.get().unwrap().spawn_local(fut))
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        POLL_LOCAL
+            .set(|| EXECUTOR.get().unwrap().poll_local())
+            .map_err(|_| ExecutorError::AlreadySet)?;
+        Ok(())
     }
 }
+
+/// A trait for custom executors.
+/// Custom executors can be used to integrate with any executor that supports spawning futures.
+///  
+/// All methods can be called recursively.
+pub trait CustomExecutor: Send + Sync {
+    /// Spawns a future, usually on a thread pool.
+    fn spawn(&self, fut: PinnedFuture<()>);
+    /// Spawns a local future. May require calling `poll_local` to make progress.
+    fn spawn_local(&self, fut: PinnedLocalFuture<()>);
+    /// Polls the executor, if it supports polling.
+    fn poll_local(&self);
+}

any_spawner/tests/custom_runtime.rs

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

any_spawner/tests/futures_runtime.rs

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

examples/counter/tests/web.rs

@@ -1,7 +1,7 @@
 use counter::*;
 use leptos::mount::mount_to;
 use leptos::prelude::*;
-use leptos::spawn::tick;
+use leptos::task::tick;
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 

examples/counter_isomorphic/src/counters.rs

@@ -1,4 +1,4 @@
-use leptos::{prelude::*, reactive_graph::actions::Action};
+use leptos::prelude::*;
 use leptos_router::{
     components::{FlatRoutes, Route, Router, A},
     StaticSegment,

examples/counter_isomorphic/src/main.rs

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

examples/counter_without_macros/tests/web.rs

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

examples/counters/tests/web.rs

@@ -4,7 +4,7 @@ use wasm_bindgen_test::*;
 wasm_bindgen_test_configure!(run_in_browser);
 use counters::Counters;
 use leptos::prelude::*;
-use leptos::spawn::tick;
+use leptos::task::tick;
 use web_sys::HtmlElement;
 
 #[wasm_bindgen_test]

examples/directives/tests/web.rs

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

examples/hackernews/src/lib.rs

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

examples/hackernews/src/main.rs

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

examples/hackernews/src/routes/nav.rs

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

examples/hackernews/src/routes/stories.rs

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

examples/hackernews/src/routes/story.rs

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

examples/hackernews/src/routes/users.rs

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

examples/hackernews_axum/src/lib.rs

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

examples/hackernews_islands_axum/src/lib.rs

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

examples/hackernews_js_fetch/src/lib.rs

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

examples/islands_router/Cargo.toml

@@ -17,7 +17,7 @@ leptos = { path = "../../leptos", features = [
 leptos_router = { path = "../../router" }
 server_fn = { path = "../../server_fn", features = ["serde-lite"] }
 leptos_axum = { path = "../../integrations/axum", features = [
-  "islands-router",
+  "dont-use-islands-router",
 ], optional = true }
 log = "0.4.22"
 serde = { version = "1.0", features = ["derive"] }

examples/islands_router/README.md

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

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

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

examples/portal/tests/web.rs

@@ -3,7 +3,7 @@ use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 
 wasm_bindgen_test_configure!(run_in_browser);
-use leptos::spawn::tick;
+use leptos::task::tick;
 use leptos::{leptos_dom::helpers::document, mount::mount_to};
 use web_sys::HtmlButtonElement;
 

examples/router/index.html

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

examples/router/src/lib.rs

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

examples/router/style.css

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

examples/server_fns_axum/Cargo.toml

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

examples/server_fns_axum/src/app.rs

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

examples/server_fns_axum/src/main.rs

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

examples/ssr_modes/src/main.rs

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

examples/stores/src/lib.rs

@@ -3,7 +3,6 @@ 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};
 
 // ID starts higher than 0 because we have a few starting todos by default

examples/suspense_tests/src/main.rs

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

examples/tailwind_actix/src/main.rs

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

examples/todo_app_sqlite/src/main.rs

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

flake.lock

@@ -5,29 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1701680307,
-        "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=",
+        "lastModified": 1726560853,
+        "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "4022d587cbbfd70fe950c1e2083a02621806a725",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "flake-utils_2": {
-      "inputs": {
-        "systems": "systems_2"
-      },
-      "locked": {
-        "lastModified": 1681202837,
-        "narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "cfacdce06f30d2b68473a46042957675eebb3401",
+        "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
         "type": "github"
       },
       "original": {
@@ -38,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1703961334,
-        "narHash": "sha256-M1mV/Cq+pgjk0rt6VxoyyD+O8cOUiai8t9Q6Yyq4noY=",
+        "lastModified": 1727634051,
+        "narHash": "sha256-S5kVU7U82LfpEukbn/ihcyNt2+EvG7Z5unsKW9H/yFA=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "b0d36bd0a420ecee3bc916c91886caca87c894e9",
+        "rev": "06cf0e1da4208d3766d898b7fdab6513366d45b9",
         "type": "github"
       },
       "original": {
@@ -54,11 +36,11 @@
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1681358109,
-        "narHash": "sha256-eKyxW4OohHQx9Urxi7TQlFBTDWII+F+x2hklDOQPB50=",
+        "lastModified": 1718428119,
+        "narHash": "sha256-WdWDpNaq6u1IPtxtYHHWpl5BmabtpmLnMAx0RdJ/vo8=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "96ba1c52e54e74c3197f4d43026b3f3d92e83ff9",
+        "rev": "e6cea36f83499eb4e9cd184c8a8e823296b50ad5",
         "type": "github"
       },
       "original": {
@@ -77,15 +59,14 @@
     },
     "rust-overlay": {
       "inputs": {
-        "flake-utils": "flake-utils_2",
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1704075545,
-        "narHash": "sha256-L3zgOuVKhPjKsVLc3yTm2YJ6+BATyZBury7wnhyc8QU=",
+        "lastModified": 1727749966,
+        "narHash": "sha256-DUS8ehzqB1DQzfZ4bRXVSollJhu+y7cvh1DJ9mbWebE=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "a0df72e106322b67e9c6e591fe870380bd0da0d5",
+        "rev": "00decf1b4f9886d25030b9ee4aed7bfddccb5f66",
         "type": "github"
       },
       "original": {
@@ -108,21 +89,6 @@
         "repo": "default",
         "type": "github"
       }
-    },
-    "systems_2": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
     }
   },
   "root": "root",

hydration_context/Cargo.toml

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

integrations/actix/Cargo.toml

@@ -33,7 +33,7 @@ once_cell = "1"
 rustdoc-args = ["--generate-link-to-definition"]
 
 [features]
-islands-router = []
+dont-use-islands-router = []
 tracing = ["dep:tracing"]
 
 [package.metadata.cargo-all-features]

integrations/actix/src/lib.rs

@@ -24,7 +24,7 @@ use leptos::{
     config::LeptosOptions,
     context::{provide_context, use_context},
     prelude::expect_context,
-    reactive_graph::{computed::ScopedFuture, owner::Owner},
+    reactive::{computed::ScopedFuture, owner::Owner},
     IntoView,
 };
 use leptos_integration_utils::{
@@ -35,13 +35,14 @@ use leptos_router::{
     components::provide_server_redirect,
     location::RequestUrl,
     static_routes::{RegenerationFn, ResolvedStaticPath},
-    Method, PathSegment, RouteList, RouteListing, SsrMode,
+    ExpandOptionals, Method, PathSegment, RouteList, RouteListing, SsrMode,
 };
 use once_cell::sync::Lazy;
 use parking_lot::RwLock;
 use send_wrapper::SendWrapper;
 use server_fn::{
-    redirect::REDIRECT_HEADER, request::actix::ActixRequest, ServerFnError,
+    actix::unregister_server_fns, redirect::REDIRECT_HEADER,
+    request::actix::ActixRequest, ServerFnError,
 };
 use std::{
     fmt::{Debug, Display},
@@ -749,7 +750,7 @@ where
     IV: IntoView + 'static,
 {
     Box::pin(async move {
-        let app = if cfg!(feature = "islands-router") {
+        let app = if cfg!(feature = "dont-use-islands-router") {
             app.to_html_stream_in_order_branching()
         } else {
             app.to_html_stream_in_order()
@@ -900,7 +901,7 @@ trait ActixPath {
     fn to_actix_path(&self) -> String;
 }
 
-impl ActixPath for &[PathSegment] {
+impl ActixPath for Vec<PathSegment> {
     fn to_actix_path(&self) -> String {
         let mut path = String::new();
         for segment in self.iter() {
@@ -922,6 +923,14 @@ impl ActixPath for &[PathSegment] {
                     path.push_str(":.*}");
                 }
                 PathSegment::Unit => {}
+                PathSegment::OptionalParam(_) => {
+                    #[cfg(feature = "tracing")]
+                    tracing::error!(
+                        "to_axum_path should only be called on expanded \
+                         paths, which do not have OptionalParam any longer"
+                    );
+                    Default::default()
+                }
             }
         }
         path
@@ -937,23 +946,34 @@ pub struct ActixRouteListing {
     regenerate: Vec<RegenerationFn>,
 }
 
-impl From<RouteListing> for ActixRouteListing {
-    fn from(value: RouteListing) -> Self {
-        let path = value.path().to_actix_path();
-        let path = if path.is_empty() {
-            "/".to_string()
-        } else {
-            path
-        };
-        let mode = value.mode();
-        let methods = value.methods().collect();
-        let regenerate = value.regenerate().into();
-        Self {
-            path,
-            mode: mode.clone(),
-            methods,
-            regenerate,
-        }
+trait IntoRouteListing: Sized {
+    fn into_route_listing(self) -> Vec<ActixRouteListing>;
+}
+
+impl IntoRouteListing for RouteListing {
+    fn into_route_listing(self) -> Vec<ActixRouteListing> {
+        self.path()
+            .to_vec()
+            .expand_optionals()
+            .into_iter()
+            .map(|path| {
+                let path = path.to_actix_path();
+                let path = if path.is_empty() {
+                    "/".to_string()
+                } else {
+                    path
+                };
+                let mode = self.mode();
+                let methods = self.methods().collect();
+                let regenerate = self.regenerate().into();
+                ActixRouteListing {
+                    path,
+                    mode: mode.clone(),
+                    methods,
+                    regenerate,
+                }
+            })
+            .collect()
     }
 }
 
@@ -1004,6 +1024,11 @@ where
 {
     let _ = any_spawner::Executor::init_tokio();
 
+    // remove any server fns that match excluded paths
+    if let Some(excluded) = &excluded_routes {
+        unregister_server_fns(excluded);
+    }
+
     let owner = Owner::new_root(Some(Arc::new(SsrSharedContext::new())));
     let (mock_meta, _) = ServerMetaContext::new();
     let routes = owner
@@ -1027,7 +1052,7 @@ where
     let mut routes = routes
         .into_inner()
         .into_iter()
-        .map(ActixRouteListing::from)
+        .flat_map(IntoRouteListing::into_route_listing)
         .collect::<Vec<_>>();
 
     (
@@ -1381,39 +1406,41 @@ where
                         ),
                     )
                 } else {
-                    router.route(
-                    path,
-                    match mode {
-                        SsrMode::OutOfOrder => {
-                            render_app_to_stream_with_context(
-                                additional_context_and_method.clone(),
-                                app_fn.clone(),
-                                method,
-                            )
-                        }
-                        SsrMode::PartiallyBlocked => {
-                            render_app_to_stream_with_context_and_replace_blocks(
-                                additional_context_and_method.clone(),
-                                app_fn.clone(),
-                                method,
-                                true,
-                            )
-                        }
-                        SsrMode::InOrder => {
-                            render_app_to_stream_in_order_with_context(
-                                additional_context_and_method.clone(),
-                                app_fn.clone(),
-                                method,
-                            )
-                        }
-                        SsrMode::Async => render_app_async_with_context(
-                            additional_context_and_method.clone(),
-                            app_fn.clone(),
-                            method,
-                        ),
-                        _ => unreachable!()
-                    },
-                )
+                    router
+                        .route(path, web::head().to(HttpResponse::Ok))
+                        .route(
+                            path,
+                            match mode {
+                                SsrMode::OutOfOrder => {
+                                    render_app_to_stream_with_context(
+                                        additional_context_and_method.clone(),
+                                        app_fn.clone(),
+                                        method,
+                                    )
+                                }
+                                SsrMode::PartiallyBlocked => {
+                                    render_app_to_stream_with_context_and_replace_blocks(
+                                        additional_context_and_method.clone(),
+                                        app_fn.clone(),
+                                        method,
+                                        true,
+                                    )
+                                }
+                                SsrMode::InOrder => {
+                                    render_app_to_stream_in_order_with_context(
+                                        additional_context_and_method.clone(),
+                                        app_fn.clone(),
+                                        method,
+                                    )
+                                }
+                                SsrMode::Async => render_app_async_with_context(
+                                    additional_context_and_method.clone(),
+                                    app_fn.clone(),
+                                    method,
+                                ),
+                                _ => unreachable!()
+                            },
+                        )
                 };
             }
         }

integrations/axum/Cargo.toml

@@ -16,8 +16,6 @@ axum = { version = "0.7.5", default-features = false, features = [
 ] }
 dashmap = "6"
 futures = "0.3.30"
-http = "1.1"
-http-body-util = "0.1.2"
 leptos = { workspace = true, features = ["nonce", "ssr"] }
 server_fn = { workspace = true, features = ["axum-no-default"] }
 leptos_macro = { workspace = true, features = ["axum"] }
@@ -26,9 +24,8 @@ 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 }
-tower = "0.4.13"
+tower = { version = "0.4.13", features = ["util"] }
 tower-http = "0.5.2"
 tracing = { version = "0.1.40", optional = true }
 
@@ -39,7 +36,7 @@ tokio = { version = "1.39", features = ["net", "rt-multi-thread"] }
 [features]
 wasm = []
 default = ["tokio/fs", "tokio/sync", "tower-http/fs", "tower/util"]
-islands-router = []
+dont-use-islands-router = []
 tracing = ["dep:tracing"]
 
 [package.metadata.docs.rs]

integrations/axum/src/lib.rs

@@ -53,7 +53,7 @@ use leptos::{
     config::LeptosOptions,
     context::{provide_context, use_context},
     prelude::*,
-    reactive_graph::{computed::ScopedFuture, owner::Owner},
+    reactive::{computed::ScopedFuture, owner::Owner},
     IntoView,
 };
 use leptos_integration_utils::{
@@ -66,17 +66,19 @@ use leptos_router::{
     components::provide_server_redirect,
     location::RequestUrl,
     static_routes::{RegenerationFn, StaticParamsMap},
-    PathSegment, RouteList, RouteListing, SsrMode,
+    ExpandOptionals, PathSegment, RouteList, RouteListing, SsrMode,
 };
 #[cfg(feature = "default")]
 use once_cell::sync::Lazy;
 use parking_lot::RwLock;
-use server_fn::{redirect::REDIRECT_HEADER, ServerFnError};
+use server_fn::{
+    axum::unregister_server_fns, 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;
+use tower::util::ServiceExt;
 #[cfg(feature = "default")]
 use tower_http::services::ServeDir;
 // use tracing::Instrument; // TODO check tracing span -- was this used in 0.6 for a missing link?
@@ -606,9 +608,9 @@ where
 /// use axum::{
 ///     body::Body,
 ///     extract::Path,
+///     http::Request,
 ///     response::{IntoResponse, Response},
 /// };
-/// use http::Request;
 /// use leptos::{config::LeptosOptions, context::provide_context, prelude::*};
 ///
 /// async fn custom_handler(
@@ -784,7 +786,7 @@ where
     _ = replace_blocks; // TODO
     handle_response(additional_context, app_fn, |app, chunks| {
         Box::pin(async move {
-            let app = if cfg!(feature = "islands-router") {
+            let app = if cfg!(feature = "dont-use-islands-router") {
                 app.to_html_stream_out_of_order_branching()
             } else {
                 app.to_html_stream_out_of_order()
@@ -806,9 +808,9 @@ where
 /// use axum::{
 ///     body::Body,
 ///     extract::Path,
+///     http::Request,
 ///     response::{IntoResponse, Response},
 /// };
-/// use http::Request;
 /// use leptos::context::provide_context;
 ///
 /// async fn custom_handler(
@@ -849,7 +851,7 @@ where
     IV: IntoView + 'static,
 {
     handle_response(additional_context, app_fn, |app, chunks| {
-        let app = if cfg!(feature = "islands-router") {
+        let app = if cfg!(feature = "dont-use-islands-router") {
             app.to_html_stream_in_order_branching()
         } else {
             app.to_html_stream_in_order()
@@ -1025,9 +1027,9 @@ where
 /// use axum::{
 ///     body::Body,
 ///     extract::Path,
+///     http::Request,
 ///     response::{IntoResponse, Response},
 /// };
-/// use http::Request;
 /// use leptos::context::provide_context;
 ///
 /// async fn custom_handler(
@@ -1069,7 +1071,7 @@ where
 {
     handle_response(additional_context, app_fn, |app, chunks| {
         Box::pin(async move {
-            let app = if cfg!(feature = "islands-router") {
+            let app = if cfg!(feature = "dont-use-islands-router") {
                 app.to_html_stream_in_order_branching()
             } else {
                 app.to_html_stream_in_order()
@@ -1093,9 +1095,9 @@ where
 /// use axum::{
 ///     body::Body,
 ///     extract::Path,
+///     http::Request,
 ///     response::{IntoResponse, Response},
 /// };
-/// use http::Request;
 /// use leptos::context::provide_context;
 ///
 /// async fn custom_handler(
@@ -1146,7 +1148,7 @@ where
     IV: IntoView + 'static,
 {
     Box::pin(async move {
-        let app = if cfg!(feature = "islands-router") {
+        let app = if cfg!(feature = "dont-use-islands-router") {
             app.to_html_stream_in_order_branching()
         } else {
             app.to_html_stream_in_order()
@@ -1265,23 +1267,34 @@ pub struct AxumRouteListing {
     regenerate: Vec<RegenerationFn>,
 }
 
-impl From<RouteListing> for AxumRouteListing {
-    fn from(value: RouteListing) -> Self {
-        let path = value.path().to_axum_path();
-        let path = if path.is_empty() {
-            "/".to_string()
-        } else {
-            path
-        };
-        let mode = value.mode();
-        let methods = value.methods().collect();
-        let regenerate = value.regenerate().into();
-        Self {
-            path,
-            mode: mode.clone(),
-            methods,
-            regenerate,
-        }
+trait IntoRouteListing: Sized {
+    fn into_route_listing(self) -> Vec<AxumRouteListing>;
+}
+
+impl IntoRouteListing for RouteListing {
+    fn into_route_listing(self) -> Vec<AxumRouteListing> {
+        self.path()
+            .to_vec()
+            .expand_optionals()
+            .into_iter()
+            .map(|path| {
+                let path = path.to_axum_path();
+                let path = if path.is_empty() {
+                    "/".to_string()
+                } else {
+                    path
+                };
+                let mode = self.mode();
+                let methods = self.methods().collect();
+                let regenerate = self.regenerate().into();
+                AxumRouteListing {
+                    path,
+                    mode: mode.clone(),
+                    methods,
+                    regenerate,
+                }
+            })
+            .collect()
     }
 }
 
@@ -1338,12 +1351,16 @@ where
     init_executor();
     let owner = Owner::new_root(Some(Arc::new(SsrSharedContext::new())));
 
+    // remove any server fns that match excluded paths
+    if let Some(excluded) = &excluded_routes {
+        unregister_server_fns(excluded);
+    }
+
     let routes = owner
         .with(|| {
             // stub out a path for now
             provide_context(RequestUrl::new(""));
-            let (mock_parts, _) =
-                http::Request::new(Body::from("")).into_parts();
+            let (mock_parts, _) = Request::new(Body::from("")).into_parts();
             let (mock_meta, _) = ServerMetaContext::new();
             provide_contexts("", &mock_meta, mock_parts, Default::default());
             additional_context();
@@ -1361,7 +1378,7 @@ where
     let mut routes = routes
         .into_inner()
         .into_iter()
-        .map(AxumRouteListing::from)
+        .flat_map(IntoRouteListing::into_route_listing)
         .collect::<Vec<_>>();
 
     (
@@ -1402,8 +1419,8 @@ impl StaticRouteGenerator {
             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)
+                let mock_req = Request::builder()
+                    .method(Method::GET)
                     .header("Accept", "text/html")
                     .body(Body::empty())
                     .unwrap();
@@ -1495,10 +1512,12 @@ impl StaticRouteGenerator {
             _ = routes;
             _ = app_fn;
             _ = additional_context;
-            panic!(
-                "Static routes are not currently supported on WASM32 server \
-                 targets."
-            );
+            Self(Box::new(|_| {
+                panic!(
+                    "Static routes are not currently supported on WASM32 \
+                     server targets."
+                );
+            }))
         }
     }
 
@@ -1692,7 +1711,7 @@ trait AxumPath {
     fn to_axum_path(&self) -> String;
 }
 
-impl AxumPath for &[PathSegment] {
+impl AxumPath for Vec<PathSegment> {
     fn to_axum_path(&self) -> String {
         let mut path = String::new();
         for segment in self.iter() {
@@ -1712,6 +1731,14 @@ impl AxumPath for &[PathSegment] {
                     path.push_str(s);
                 }
                 PathSegment::Unit => {}
+                PathSegment::OptionalParam(_) => {
+                    #[cfg(feature = "tracing")]
+                    tracing::error!(
+                        "to_axum_path should only be called on expanded \
+                         paths, which do not have OptionalParam any longer"
+                    );
+                    Default::default()
+                }
             }
         }
         path
@@ -1933,7 +1960,7 @@ where
 ///
 /// #[server]
 /// pub async fn request_method() -> Result<String, ServerFnError> {
-///     use http::Method;
+///     use axum::http::Method;
 ///     use leptos_axum::extract;
 ///
 ///     // you can extract anything that a regular Axum extractor can extract
@@ -1992,7 +2019,7 @@ where
     move |uri: Uri, State(options): State<S>, req: Request<Body>| {
         Box::pin(async move {
             let options = LeptosOptions::from_ref(&options);
-            let res = get_static_file(uri, &options.site_root);
+            let res = get_static_file(uri, &options.site_root, req.headers());
             let res = res.await.unwrap();
 
             if res.status() == StatusCode::OK {
@@ -2026,14 +2053,26 @@ where
 async fn get_static_file(
     uri: Uri,
     root: &str,
+    headers: &HeaderMap<HeaderValue>,
 ) -> Result<Response<Body>, (StatusCode, String)> {
-    let req = Request::builder()
-        .uri(uri.clone())
-        .body(Body::empty())
-        .unwrap();
+    use axum::http::header::ACCEPT_ENCODING;
+
+    let req = Request::builder().uri(uri);
+
+    let req = match headers.get(ACCEPT_ENCODING) {
+        Some(value) => req.header(ACCEPT_ENCODING, value),
+        None => req,
+    };
+
+    let req = req.body(Body::empty()).unwrap();
     // `ServeDir` implements `tower::Service` so we can call it with `tower::ServiceExt::oneshot`
     // This path is relative to the cargo root
-    match ServeDir::new(root).oneshot(req).await {
+    match ServeDir::new(root)
+        .precompressed_gzip()
+        .precompressed_br()
+        .oneshot(req)
+        .await
+    {
         Ok(res) => Ok(res.into_response()),
         Err(err) => Err((
             StatusCode::INTERNAL_SERVER_ERROR,

integrations/utils/src/lib.rs

@@ -2,7 +2,7 @@ use futures::{stream::once, Stream, StreamExt};
 use hydration_context::{SharedContext, SsrSharedContext};
 use leptos::{
     nonce::use_nonce,
-    reactive_graph::owner::{Owner, Sandboxed},
+    reactive::owner::{Owner, Sandboxed},
     IntoView,
 };
 use leptos_config::LeptosOptions;

leptos/Cargo.toml

@@ -28,7 +28,7 @@ paste = "1.0"
 rand = { version = "0.8.5", optional = true }
 reactive_graph = { workspace = true, features = ["serde"] }
 rustc-hash = "2.0"
-tachys = { workspace = true, features = ["reactive_graph", "oco"] }
+tachys = { workspace = true, features = ["reactive_graph", "reactive_stores", "oco"] }
 thiserror = "1.0"
 tracing = { version = "0.1.40", optional = true }
 typed-builder = "0.19.1"
@@ -45,7 +45,7 @@ web-sys = { version = "0.3.70", features = [
   "ShadowRootInit",
   "ShadowRootMode",
 ] }
-wasm-bindgen = "0.2.93"
+wasm-bindgen = "=0.2.93"
 serde_qs = "0.13.0"
 slotmap = "1.0"
 futures = "0.3.30"

leptos/src/additional_attributes.rs

@@ -1,59 +0,0 @@
-#![allow(deprecated)]
-
-use crate::TextProp;
-use std::rc::Rc;
-
-/// A collection of additional HTML attributes to be applied to an element,
-/// each of which may or may not be reactive.
-#[derive(Clone)]
-#[repr(transparent)]
-#[deprecated = "Most uses of `AdditionalAttributes` can be replaced with `#[prop(attrs)]` \
-and the `attr:` syntax. If you have a use case that still requires `AdditionalAttributes`, please \
-open a GitHub issue here and share it: https://github.com/leptos-rs/leptos"]
-pub struct AdditionalAttributes(pub(crate) Rc<[(String, TextProp)]>);
-
-impl<I, T, U> From<I> for AdditionalAttributes
-where
-    I: IntoIterator<Item = (T, U)>,
-    T: Into<String>,
-    U: Into<TextProp>,
-{
-    fn from(value: I) -> Self {
-        Self(
-            value
-                .into_iter()
-                .map(|(k, v)| (k.into(), v.into()))
-                .collect(),
-        )
-    }
-}
-
-impl Default for AdditionalAttributes {
-    fn default() -> Self {
-        Self([].into_iter().collect())
-    }
-}
-
-/// Iterator over additional HTML attributes.
-#[repr(transparent)]
-pub struct AdditionalAttributesIter<'a>(
-    std::slice::Iter<'a, (String, TextProp)>,
-);
-
-impl<'a> Iterator for AdditionalAttributesIter<'a> {
-    type Item = &'a (String, TextProp);
-
-    #[inline(always)]
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next()
-    }
-}
-
-impl<'a> IntoIterator for &'a AdditionalAttributes {
-    type Item = &'a (String, TextProp);
-    type IntoIter = AdditionalAttributesIter<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        AdditionalAttributesIter(self.0.iter())
-    }
-}

leptos/src/animated_show.rs

@@ -1,12 +1,15 @@
-use crate::{ChildrenFn, Show};
+use crate::{children::ChildrenFn, component, control_flow::Show, IntoView};
 use core::time::Duration;
-use leptos::component;
-use leptos_dom::{helpers::TimeoutHandle, IntoView};
+use leptos_dom::helpers::TimeoutHandle;
 use leptos_macro::view;
-use leptos_reactive::{
-    create_render_effect, on_cleanup, signal_prelude::*, store_value,
-    StoredValue,
+use reactive_graph::{
+    effect::RenderEffect,
+    owner::{on_cleanup, StoredValue},
+    signal::RwSignal,
+    traits::{Get, GetUntracked, GetValue, Set, SetValue},
+    wrappers::read::Signal,
 };
+use tachys::prelude::*;
 
 /// A component that will show its children when the `when` condition is `true`.
 /// Additionally, you need to specify a `hide_delay`. If the `when` condition changes to `false`,
@@ -16,10 +19,10 @@ use leptos_reactive::{
 ///
 /// ```rust
 /// # use core::time::Duration;
-/// # use leptos::*;
+/// # use leptos::prelude::*;
 /// # #[component]
 /// # pub fn App() -> impl IntoView {
-/// let show = create_rw_signal(false);
+/// let show = RwSignal::new(false);
 ///
 /// view! {
 ///     <div
@@ -50,7 +53,7 @@ pub fn AnimatedShow(
     children: ChildrenFn,
     /// If the component should show or not
     #[prop(into)]
-    when: MaybeSignal<bool>,
+    when: Signal<bool>,
     /// Optional CSS class to apply if `when == true`
     #[prop(optional)]
     show_class: &'static str,
@@ -60,15 +63,15 @@ pub fn AnimatedShow(
     /// The timeout after which the component will be unmounted if `when == false`
     hide_delay: Duration,
 ) -> impl IntoView {
-    let handle: StoredValue<Option<TimeoutHandle>> = store_value(None);
-    let cls = create_rw_signal(if when.get_untracked() {
+    let handle: StoredValue<Option<TimeoutHandle>> = StoredValue::new(None);
+    let cls = RwSignal::new(if when.get_untracked() {
         show_class
     } else {
         hide_class
     });
-    let show = create_rw_signal(when.get_untracked());
+    let show = RwSignal::new(when.get_untracked());
 
-    create_render_effect(move |_| {
+    let eff = RenderEffect::new(move |_| {
         if when.get() {
             // clear any possibly active timer
             if let Some(h) = handle.get_value() {
@@ -93,6 +96,7 @@ pub fn AnimatedShow(
         if let Some(Some(h)) = handle.try_get_value() {
             h.clear();
         }
+        drop(eff);
     });
 
     view! {

leptos/src/await_.rs

@@ -1,10 +1,8 @@
-use crate::Suspense;
-use leptos_dom::IntoView;
+use crate::{prelude::Suspend, suspense_component::Suspense, IntoView};
 use leptos_macro::{component, view};
-use leptos_reactive::{
-    create_blocking_resource, create_local_resource, create_resource,
-    store_value, Serializable,
-};
+use leptos_server::ArcOnceResource;
+use reactive_graph::prelude::ReadUntracked;
+use serde::{de::DeserializeOwned, Serialize};
 
 #[component]
 /// Allows you to inline the data loading for an `async` block or
@@ -15,11 +13,8 @@ use leptos_reactive::{
 /// Adding `let:{variable name}` to the props makes the data available in the children
 /// that variable name, when resolved.
 /// ```
-/// # use leptos_reactive::*;
-/// # use leptos_macro::*;
-/// # use leptos_dom::*; use leptos::*;
+/// # use leptos::prelude::*;
 /// # if false {
-/// # let runtime = create_runtime();
 /// async fn fetch_monkeys(monkey: i32) -> i32 {
 ///     // do some expensive work
 ///     3
@@ -27,29 +22,23 @@ use leptos_reactive::{
 ///
 /// view! {
 ///     <Await
-///         future=|| fetch_monkeys(3)
+///         future=fetch_monkeys(3)
 ///         let:data
 ///     >
 ///         <p>{*data} " little monkeys, jumping on the bed."</p>
 ///     </Await>
 /// }
 /// # ;
-/// # runtime.dispose();
 /// # }
 /// ```
-pub fn Await<T, Fut, FF, VF, V>(
-    /// A function that returns the [`Future`](std::future::Future) that
-    /// will the component will `.await` before rendering.
-    future: FF,
-    /// If `true`, the component will use [`create_blocking_resource`], preventing
+pub fn Await<T, Fut, Chil, V>(
+    /// A [`Future`](std::future::Future) that will the component will `.await`
+    /// before rendering.
+    future: Fut,
+    /// If `true`, the component will create a blocking resource, preventing
     /// the HTML stream from returning anything before `future` has resolved.
     #[prop(optional)]
     blocking: bool,
-    /// If `true`, the component will use [`create_local_resource`], this will
-    /// always run on the local system and therefore its result type does not
-    /// need to be `Serializable`.
-    #[prop(optional)]
-    local: bool,
     /// A function that takes a reference to the resolved data from the `future`
     /// renders a view.
     ///
@@ -58,65 +47,58 @@ pub fn Await<T, Fut, FF, VF, V>(
     /// `let:` syntax to specify the name for the data variable.
     ///
     /// ```rust
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # if false {
-    /// # let runtime = create_runtime();
     /// # async fn fetch_monkeys(monkey: i32) -> i32 {
     /// #    3
     /// # }
     /// view! {
     ///     <Await
-    ///         future=|| fetch_monkeys(3)
+    ///         future=fetch_monkeys(3)
     ///         let:data
     ///     >
     ///         <p>{*data} " little monkeys, jumping on the bed."</p>
     ///     </Await>
     /// }
     /// # ;
-    /// # runtime.dispose();
     /// # }
     /// ```
     /// is the same as
     ///  ```rust
-    /// # use leptos::*;
+    /// # use leptos::prelude::*;
     /// # if false {
-    /// # let runtime = create_runtime();
     /// # async fn fetch_monkeys(monkey: i32) -> i32 {
     /// #    3
     /// # }
     /// view! {
     ///     <Await
-    ///         future=|| fetch_monkeys(3)
+    ///         future=fetch_monkeys(3)
     ///         children=|data| view! {
     ///           <p>{*data} " little monkeys, jumping on the bed."</p>
     ///         }
     ///     />
     /// }
     /// # ;
-    /// # runtime.dispose();
     /// # }
     /// ```
-    children: VF,
+    children: Chil,
 ) -> impl IntoView
 where
-    Fut: std::future::Future<Output = T> + 'static,
-    FF: Fn() -> Fut + 'static,
-    V: IntoView,
-    VF: Fn(&T) -> V + 'static,
-    T: Serializable + 'static,
+    T: Send + Sync + Serialize + DeserializeOwned + 'static,
+    Fut: std::future::Future<Output = T> + Send + 'static,
+    Chil: FnOnce(&T) -> V + Send + 'static,
+    V: IntoView + 'static,
 {
-    let res = if blocking {
-        create_blocking_resource(|| (), move |_| future())
-    } else if local {
-        create_local_resource(|| (), move |_| future())
-    } else {
-        create_resource(|| (), move |_| future())
-    };
-    let view = store_value(children);
+    let res = ArcOnceResource::<T>::new_with_options(future, blocking);
+    let ready = res.ready();
 
     view! {
         <Suspense fallback=|| ()>
-            {move || res.map(|data| view.with_value(|view| view(data)))}
+            {Suspend::new(async move {
+                ready.await;
+                children(res.read_untracked().as_ref().unwrap())
+            })}
+
         </Suspense>
     }
 }

leptos/src/callback.rs

@@ -41,7 +41,10 @@
 //!
 //! Use `SyncCallback` if the function is not `Sync` and `Send`.
 
-use reactive_graph::owner::{LocalStorage, StoredValue};
+use reactive_graph::{
+    owner::{LocalStorage, StoredValue},
+    traits::WithValue,
+};
 use std::{fmt, rc::Rc, sync::Arc};
 
 /// A wrapper trait for calling callbacks.

leptos/src/hydration/mod.rs

@@ -50,7 +50,7 @@ pub fn HydrationScripts(
                 path.parent().map(|p| p.to_path_buf()).unwrap_or_default()
             })
             .unwrap_or_default()
-            .join(&options.hash_file);
+            .join(options.hash_file.as_ref());
         if hash_path.exists() {
             let hashes = std::fs::read_to_string(&hash_path)
                 .expect("failed to read hash file");

leptos/src/lib.rs

@@ -168,14 +168,15 @@ 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::*, graph::untrack, owner::*,
+            signal::*, wrappers::read::*,
         };
         pub use server_fn::{self, ServerFnError};
         pub use tachys::{
-            self,
             reactive_graph::{bind::BindAttribute, node_ref::*, Suspend},
-            view::template::ViewTemplate,
+            view::{
+                any_view::AnyView, fragment::Fragment, template::ViewTemplate,
+            },
         };
     }
     pub use export_types::*;
@@ -201,10 +202,12 @@ pub mod error {
     pub use throw_error::*;
 }
 
-/// Control-flow components like `<Show>` and `<For>`.
+/// Control-flow components like `<Show>`, `<For>`, and `<Await>`.
 pub mod control_flow {
-    pub use crate::{for_loop::*, show::*};
+    pub use crate::{animated_show::*, await_::*, for_loop::*, show::*};
 }
+mod animated_show;
+mod await_;
 mod for_loop;
 mod show;
 
@@ -230,6 +233,7 @@ mod suspense_component;
 pub mod text_prop;
 mod transition;
 pub use leptos_macro::*;
+#[doc(inline)]
 pub use server_fn;
 #[doc(hidden)]
 pub use typed_builder;
@@ -237,16 +241,22 @@ pub use typed_builder;
 pub use typed_builder_macro;
 mod into_view;
 pub use into_view::IntoView;
+#[doc(inline)]
 pub use leptos_dom;
 mod provider;
+#[doc(inline)]
 pub use tachys;
 /// Tools to mount an application to the DOM, or to hydrate it from server-rendered HTML.
 pub mod mount;
+#[doc(inline)]
 pub use leptos_config as config;
+#[doc(inline)]
 pub use oco_ref as oco;
 mod from_form_data;
+#[doc(inline)]
 pub use either_of as either;
-pub use reactive_graph;
+#[doc(inline)]
+pub use reactive_graph as reactive;
 
 /// Provide and access data along the reactive graph, sharing data without directly passing arguments.
 pub mod context {
@@ -254,17 +264,22 @@ pub mod context {
     pub use reactive_graph::owner::{provide_context, use_context};
 }
 
+#[doc(inline)]
 pub use leptos_server as server;
 /// HTML attribute types.
+#[doc(inline)]
 pub use tachys::html::attribute as attr;
 /// HTML element types.
+#[doc(inline)]
 pub use tachys::html::element as html;
 /// HTML event types.
 #[doc(no_inline)]
 pub use tachys::html::event as ev;
 /// MathML element types.
+#[doc(inline)]
 pub use tachys::mathml as math;
 /// SVG element types.
+#[doc(inline)]
 pub use tachys::svg;
 
 /// Utilities for simple isomorphic logging to the console or terminal.
@@ -272,7 +287,7 @@ pub mod logging {
     pub use leptos_dom::{debug_warn, error, log, warn};
 }
 
-pub mod spawn {
+pub mod task {
     pub use any_spawner::Executor;
     use std::future::Future;
 
@@ -290,6 +305,7 @@ pub mod spawn {
         Executor::spawn_local(fut)
     }
 
+    /// Waits until the next "tick" of the current async executor.
     pub async fn tick() {
         Executor::tick().await
     }
@@ -313,234 +329,3 @@ pub use tracing;
 pub use wasm_bindgen;
 #[doc(hidden)]
 pub use web_sys;
-
-/*mod additional_attributes;
-pub use additional_attributes::*;
-mod await_;
-pub use await_::*;
-pub use leptos_config::{self, get_configuration, LeptosOptions};
-#[cfg(not(all(
-    target_arch = "wasm32",
-    any(feature = "csr", feature = "hydrate")
-)))]
-/// Utilities for server-side rendering HTML.
-pub mod ssr {
-    pub use leptos_dom::{ssr::*, ssr_in_order::*};
-}
-pub use leptos_dom::{
-    self, create_node_ref, document, ev,
-    helpers::{
-        event_target, event_target_checked, event_target_value,
-        request_animation_frame, request_animation_frame_with_handle,
-        request_idle_callback, request_idle_callback_with_handle, set_interval,
-        set_interval_with_handle, set_timeout, set_timeout_with_handle,
-        window_event_listener, window_event_listener_untyped,
-    },
-    html,
-    html::Binding,
-    math, mount_to, mount_to_body, nonce, svg, window, Attribute, Class,
-    CollectView, Errors, EventHandlerFn, Fragment, HtmlElement, IntoAttribute,
-    IntoClass, IntoProperty, IntoStyle, IntoView, NodeRef, Property, View,
-};
-
-/// Types to make it easier to handle errors in your application.
-pub mod error {
-    pub use server_fn::error::{Error, Result};
-}
-#[cfg(all(target_arch = "wasm32", feature = "template_macro"))]
-pub use leptos_macro::template;
-#[cfg(not(all(target_arch = "wasm32", feature = "template_macro")))]
-pub use leptos_macro::view as template;
-pub use leptos_macro::{component, island, slice, slot, view, Params};
-cfg_if::cfg_if!(
-    if #[cfg(feature="spin")] {
-        pub use leptos_spin_macro::server;
-    } else {
-        pub use leptos_macro::server;
-    }
-);
-pub use leptos_reactive::*;
-pub use leptos_server::{
-    self, create_action, create_multi_action, create_server_action,
-    create_server_multi_action, Action, MultiAction, ServerFnError,
-    ServerFnErrorErr,
-};
-pub use server_fn::{self, ServerFn as _};
-mod error_boundary;
-pub use error_boundary::*;
-mod animated_show;
-mod for_loop;
-mod provider;
-mod show;
-pub use animated_show::*;
-pub use for_loop::*;
-pub use provider::*;
-#[cfg(feature = "experimental-islands")]
-pub use serde;
-#[cfg(feature = "experimental-islands")]
-pub use serde_json;
-pub use show::*;
-//pub use suspense_component::*;
-mod suspense_component;
-//mod transition;
-#[cfg(feature = "tracing")]
-#[doc(hidden)]
-pub use tracing;
-pub use transition::*;
-#[doc(hidden)]
-pub use typed_builder;
-#[doc(hidden)]
-pub use typed_builder::Optional;
-#[doc(hidden)]
-pub use typed_builder_macro;
-#[doc(hidden)]
-#[cfg(any(
-    feature = "csr",
-    feature = "hydrate",
-    feature = "template_macro"
-))]
-pub use wasm_bindgen; // used in islands
-#[doc(hidden)]
-#[cfg(any(
-    feature = "csr",
-    feature = "hydrate",
-    feature = "template_macro"
-))]
-pub use web_sys; // used in islands
-
-mod children;
-mod portal;
-mod view_fn;
-pub use children::*;
-pub use portal::*;
-pub use view_fn::*;
-
-extern crate self as leptos;
-
-/// A type for taking anything that implements [`IntoAttribute`].
-///
-/// ```rust
-/// use leptos::*;
-///
-/// #[component]
-/// pub fn MyHeading(
-///     text: String,
-///     #[prop(optional, into)] class: Option<AttributeValue>,
-/// ) -> impl IntoView {
-///     view! {
-///       <h1 class=class>{text}</h1>
-///     }
-/// }
-/// ```
-pub type AttributeValue = Box<dyn IntoAttribute>;
-
-#[doc(hidden)]
-pub trait Component<P> {}
-
-#[doc(hidden)]
-pub trait Props {
-    type Builder;
-    fn builder() -> Self::Builder;
-}
-
-#[doc(hidden)]
-pub trait DynAttrs {
-    fn dyn_attrs(self, _args: Vec<(&'static str, Attribute)>) -> Self
-    where
-        Self: Sized,
-    {
-        self
-    }
-}
-
-impl DynAttrs for () {}
-
-#[doc(hidden)]
-pub trait DynBindings {
-    fn dyn_bindings<B: Into<Binding>>(
-        self,
-        _args: impl IntoIterator<Item = B>,
-    ) -> Self
-    where
-        Self: Sized,
-    {
-        self
-    }
-}
-
-impl DynBindings for () {}
-
-#[doc(hidden)]
-pub trait PropsOrNoPropsBuilder {
-    type Builder;
-    fn builder_or_not() -> Self::Builder;
-}
-
-#[doc(hidden)]
-#[derive(Copy, Clone, Debug, Default)]
-pub struct EmptyPropsBuilder {}
-
-impl EmptyPropsBuilder {
-    pub fn build(self) {}
-}
-
-impl<P: Props> PropsOrNoPropsBuilder for P {
-    type Builder = <P as Props>::Builder;
-    fn builder_or_not() -> Self::Builder {
-        Self::builder()
-    }
-}
-
-impl PropsOrNoPropsBuilder for EmptyPropsBuilder {
-    type Builder = EmptyPropsBuilder;
-    fn builder_or_not() -> Self::Builder {
-        EmptyPropsBuilder {}
-    }
-}
-
-impl<F, R> Component<EmptyPropsBuilder> for F where F: FnOnce() -> R {}
-
-impl<P, F, R> Component<P> for F
-where
-    F: FnOnce(P) -> R,
-    P: Props,
-{
-}
-
-#[doc(hidden)]
-pub fn component_props_builder<P: PropsOrNoPropsBuilder>(
-    _f: &impl Component<P>,
-) -> <P as PropsOrNoPropsBuilder>::Builder {
-    <P as PropsOrNoPropsBuilder>::builder_or_not()
-}
-
-#[doc(hidden)]
-pub fn component_view<P>(f: impl ComponentConstructor<P>, props: P) -> View {
-    f.construct(props)
-}
-
-#[doc(hidden)]
-pub trait ComponentConstructor<P> {
-    fn construct(self, props: P) -> View;
-}
-
-impl<Func, V> ComponentConstructor<()> for Func
-where
-    Func: FnOnce() -> V,
-    V: IntoView,
-{
-    fn construct(self, (): ()) -> View {
-        (self)().into_view()
-    }
-}
-
-impl<Func, V, P> ComponentConstructor<P> for Func
-where
-    Func: FnOnce(P) -> V,
-    V: IntoView,
-    P: PropsOrNoPropsBuilder,
-{
-    fn construct(self, props: P) -> View {
-        (self)(props).into_view()
-    }
-}*/

leptos/src/portal.rs

@@ -1,7 +1,7 @@
 use crate::{children::TypedChildrenFn, mount, IntoView};
 use leptos_dom::helpers::document;
 use leptos_macro::component;
-use reactive_graph::{effect::Effect, owner::Owner, untrack};
+use reactive_graph::{effect::Effect, graph::untrack, owner::Owner};
 use std::sync::Arc;
 
 /// Renders components somewhere else in the DOM.

leptos/src/provider.rs

@@ -35,7 +35,7 @@ pub fn Provider<T, Chil>(
 ) -> impl IntoView
 where
     T: Send + Sync + 'static,
-    Chil: IntoView,
+    Chil: IntoView + 'static,
 {
     let owner = Owner::current()
         .expect("no current reactive Owner found")

leptos/src/view_fn.rs

@@ -1,30 +0,0 @@
-use leptos_dom::{IntoView, View};
-use std::rc::Rc;
-
-/// New-type wrapper for the a function that returns a view with `From` and `Default` traits implemented
-/// to enable optional props in for example `<Show>` and `<Suspense>`.
-#[derive(Clone)]
-pub struct ViewFn(Rc<dyn Fn() -> View>);
-
-impl Default for ViewFn {
-    fn default() -> Self {
-        Self(Rc::new(|| ().into_view()))
-    }
-}
-
-impl<F, IV> From<F> for ViewFn
-where
-    F: Fn() -> IV + 'static,
-    IV: IntoView,
-{
-    fn from(value: F) -> Self {
-        Self(Rc::new(move || value().into_view()))
-    }
-}
-
-impl ViewFn {
-    /// Execute the wrapped function
-    pub fn run(&self) -> View {
-        (self.0)()
-    }
-}

leptos/tests/ssr.rs

@@ -1,5 +1,7 @@
+#[cfg(feature = "ssr")]
 use leptos::html::HtmlElement;
 
+#[cfg(feature = "ssr")]
 #[test]
 fn simple_ssr_test() {
     use leptos::prelude::*;
@@ -20,6 +22,7 @@ fn simple_ssr_test() {
     );
 }
 
+#[cfg(feature = "ssr")]
 #[test]
 fn ssr_test_with_components() {
     use leptos::prelude::*;
@@ -51,6 +54,7 @@ fn ssr_test_with_components() {
     );
 }
 
+#[cfg(feature = "ssr")]
 #[test]
 fn ssr_test_with_snake_case_components() {
     use leptos::prelude::*;
@@ -81,6 +85,7 @@ fn ssr_test_with_snake_case_components() {
     );
 }
 
+#[cfg(feature = "ssr")]
 #[test]
 fn test_classes() {
     use leptos::prelude::*;
@@ -98,6 +103,7 @@ fn test_classes() {
     assert_eq!(rendered.to_html(), "<div class=\"my big  red car\"></div>");
 }
 
+#[cfg(feature = "ssr")]
 #[test]
 fn ssr_with_styles() {
     use leptos::prelude::*;
@@ -119,6 +125,7 @@ fn ssr_with_styles() {
     );
 }
 
+#[cfg(feature = "ssr")]
 #[test]
 fn ssr_option() {
     use leptos::prelude::*;

leptos_config/Cargo.toml

@@ -15,7 +15,7 @@ config = { version = "0.14.0", default-features = false, features = [
   "convert-case",
 ] }
 regex = "1.10"
-serde = { version = "1.0", features = ["derive"] }
+serde = { version = "1.0", features = ["derive", "rc"] }
 thiserror = "1.0"
 typed-builder = "0.19.1"
 

leptos_config/src/lib.rs

@@ -5,7 +5,9 @@ pub mod errors;
 use crate::errors::LeptosConfigError;
 use config::{Case, Config, File, FileFormat};
 use regex::Regex;
-use std::{env::VarError, fs, net::SocketAddr, path::Path, str::FromStr};
+use std::{
+    env::VarError, fs, net::SocketAddr, path::Path, str::FromStr, sync::Arc,
+};
 use typed_builder::TypedBuilder;
 
 /// A Struct to allow us to parse LeptosOptions from the file. Not really needed, most interactions should
@@ -25,17 +27,17 @@ pub struct ConfFile {
 pub struct LeptosOptions {
     /// The name of the WASM and JS files generated by wasm-bindgen. Defaults to the crate name with underscores instead of dashes
     #[builder(setter(into), default=default_output_name())]
-    pub output_name: String,
+    pub output_name: Arc<str>,
     /// The path of the all the files generated by cargo-leptos. This defaults to '.' for convenience when integrating with other
     /// tools.
     #[builder(setter(into), default=default_site_root())]
     #[serde(default = "default_site_root")]
-    pub site_root: String,
+    pub site_root: Arc<str>,
     /// The path of the WASM and JS files generated by wasm-bindgen from the root of your app
     /// By default, wasm-bindgen puts them in `pkg`.
     #[builder(setter(into), default=default_site_pkg_dir())]
     #[serde(default = "default_site_pkg_dir")]
-    pub site_pkg_dir: String,
+    pub site_pkg_dir: Arc<str>,
     /// Used to configure the running environment of Leptos. Can be used to load dev constants and keys v prod, or change
     /// things based on the deployment environment
     /// I recommend passing in the result of `env::var("LEPTOS_ENV")`
@@ -66,11 +68,11 @@ pub struct LeptosOptions {
     /// The path of a custom 404 Not Found page to display when statically serving content, defaults to `site_root/404.html`
     #[builder(default = default_not_found_path())]
     #[serde(default = "default_not_found_path")]
-    pub not_found_path: String,
+    pub not_found_path: Arc<str>,
     /// The file name of the hash text file generated by cargo-leptos. Defaults to `hash.txt`.
     #[builder(default = default_hash_file_name())]
     #[serde(default = "default_hash_file_name")]
-    pub hash_file: String,
+    pub hash_file: Arc<str>,
     /// If true, hashes will be generated for all files in the site_root and added to their file names.
     /// Defaults to `true`.
     #[builder(default = default_hash_files())]
@@ -96,9 +98,9 @@ impl LeptosOptions {
             );
         }
         Ok(LeptosOptions {
-            output_name,
-            site_root: env_w_default("LEPTOS_SITE_ROOT", "target/site")?,
-            site_pkg_dir: env_w_default("LEPTOS_SITE_PKG_DIR", "pkg")?,
+            output_name: output_name.into(),
+            site_root: env_w_default("LEPTOS_SITE_ROOT", "target/site")?.into(),
+            site_pkg_dir: env_w_default("LEPTOS_SITE_PKG_DIR", "pkg")?.into(),
             env: env_from_str(env_w_default("LEPTOS_ENV", "DEV")?.as_str())?,
             site_addr: env_w_default("LEPTOS_SITE_ADDR", "127.0.0.1:3000")?
                 .parse()?,
@@ -113,8 +115,10 @@ impl LeptosOptions {
             reload_ws_protocol: ws_from_str(
                 env_w_default("LEPTOS_RELOAD_WS_PROTOCOL", "ws")?.as_str(),
             )?,
-            not_found_path: env_w_default("LEPTOS_NOT_FOUND_PATH", "/404")?,
-            hash_file: env_w_default("LEPTOS_HASH_FILE_NAME", "hash.txt")?,
+            not_found_path: env_w_default("LEPTOS_NOT_FOUND_PATH", "/404")?
+                .into(),
+            hash_file: env_w_default("LEPTOS_HASH_FILE_NAME", "hash.txt")?
+                .into(),
             hash_files: env_w_default("LEPTOS_HASH_FILES", "false")?.parse()?,
         })
     }
@@ -126,16 +130,16 @@ impl Default for LeptosOptions {
     }
 }
 
-fn default_output_name() -> String {
-    env!("CARGO_CRATE_NAME").replace('-', "_")
+fn default_output_name() -> Arc<str> {
+    env!("CARGO_CRATE_NAME").replace('-', "_").into()
 }
 
-fn default_site_root() -> String {
-    ".".to_string()
+fn default_site_root() -> Arc<str> {
+    ".".into()
 }
 
-fn default_site_pkg_dir() -> String {
-    "pkg".to_string()
+fn default_site_pkg_dir() -> Arc<str> {
+    "pkg".into()
 }
 
 fn default_env() -> Env {
@@ -150,12 +154,12 @@ fn default_reload_port() -> u32 {
     3001
 }
 
-fn default_not_found_path() -> String {
-    "/404".to_string()
+fn default_not_found_path() -> Arc<str> {
+    "/404".into()
 }
 
-fn default_hash_file_name() -> String {
-    "hash.txt".to_string()
+fn default_hash_file_name() -> Arc<str> {
+    "hash.txt".into()
 }
 
 fn default_hash_files() -> bool {

leptos_config/src/tests.rs

@@ -76,9 +76,9 @@ fn try_from_env_test() {
         || LeptosOptions::try_from_env().unwrap(),
     );
 
-    assert_eq!(config.output_name, "app_test");
-    assert_eq!(config.site_root, "my_target/site");
-    assert_eq!(config.site_pkg_dir, "my_pkg");
+    assert_eq!(config.output_name.as_ref(), "app_test");
+    assert_eq!(config.site_root.as_ref(), "my_target/site");
+    assert_eq!(config.site_pkg_dir.as_ref(), "my_pkg");
     assert_eq!(
         config.site_addr,
         SocketAddr::from_str("0.0.0.0:80").unwrap()

leptos_config/tests/config.rs

@@ -50,9 +50,9 @@ async fn get_configuration_from_file_ok() {
     )
     .await;
 
-    assert_eq!(config.output_name, "app-test");
-    assert_eq!(config.site_root, "my_target/site");
-    assert_eq!(config.site_pkg_dir, "my_pkg");
+    assert_eq!(config.output_name.as_ref(), "app-test");
+    assert_eq!(config.site_root.as_ref(), "my_target/site");
+    assert_eq!(config.site_pkg_dir.as_ref(), "my_pkg");
     assert_eq!(
         config.site_addr,
         SocketAddr::from_str("0.0.0.0:80").unwrap()
@@ -106,9 +106,9 @@ async fn get_config_from_file_ok() {
     )
     .await;
 
-    assert_eq!(config.output_name, "app-test");
-    assert_eq!(config.site_root, "my_target/site");
-    assert_eq!(config.site_pkg_dir, "my_pkg");
+    assert_eq!(config.output_name.as_ref(), "app-test");
+    assert_eq!(config.site_root.as_ref(), "my_target/site");
+    assert_eq!(config.site_pkg_dir.as_ref(), "my_pkg");
     assert_eq!(
         config.site_addr,
         SocketAddr::from_str("0.0.0.0:80").unwrap()
@@ -151,9 +151,9 @@ fn get_config_from_str_content() {
         || get_config_from_str(CARGO_TOML_CONTENT_OK).unwrap(),
     );
 
-    assert_eq!(config.output_name, "app-test");
-    assert_eq!(config.site_root, "my_target/site");
-    assert_eq!(config.site_pkg_dir, "my_pkg");
+    assert_eq!(config.output_name.as_ref(), "app-test");
+    assert_eq!(config.site_root.as_ref(), "my_target/site");
+    assert_eq!(config.site_pkg_dir.as_ref(), "my_pkg");
     assert_eq!(
         config.site_addr,
         SocketAddr::from_str("0.0.0.0:80").unwrap()
@@ -178,9 +178,9 @@ async fn get_config_from_env() {
     )
     .await;
 
-    assert_eq!(config.output_name, "app-test");
-    assert_eq!(config.site_root, "my_target/site");
-    assert_eq!(config.site_pkg_dir, "my_pkg");
+    assert_eq!(config.output_name.as_ref(), "app-test");
+    assert_eq!(config.site_root.as_ref(), "my_target/site");
+    assert_eq!(config.site_pkg_dir.as_ref(), "my_pkg");
     assert_eq!(
         config.site_addr,
         SocketAddr::from_str("0.0.0.0:80").unwrap()
@@ -202,8 +202,8 @@ async fn get_config_from_env() {
     )
     .await;
 
-    assert_eq!(config.site_root, "target/site");
-    assert_eq!(config.site_pkg_dir, "pkg");
+    assert_eq!(config.site_root.as_ref(), "target/site");
+    assert_eq!(config.site_pkg_dir.as_ref(), "pkg");
     assert_eq!(
         config.site_addr,
         SocketAddr::from_str("127.0.0.1:3000").unwrap()
@@ -215,10 +215,10 @@ async fn get_config_from_env() {
 #[test]
 fn leptos_options_builder_default() {
     let conf = LeptosOptions::builder().output_name("app-test").build();
-    assert_eq!(conf.output_name, "app-test");
+    assert_eq!(conf.output_name.as_ref(), "app-test");
     assert!(matches!(conf.env, Env::DEV));
-    assert_eq!(conf.site_pkg_dir, "pkg");
-    assert_eq!(conf.site_root, ".");
+    assert_eq!(conf.site_pkg_dir.as_ref(), "pkg");
+    assert_eq!(conf.site_root.as_ref(), ".");
     assert_eq!(
         conf.site_addr,
         SocketAddr::from_str("127.0.0.1:3000").unwrap()
@@ -242,9 +242,9 @@ fn environment_variable_override() {
         || get_config_from_str(CARGO_TOML_CONTENT_OK).unwrap(),
     );
 
-    assert_eq!(config.output_name, "app-test");
-    assert_eq!(config.site_root, "my_target/site");
-    assert_eq!(config.site_pkg_dir, "my_pkg");
+    assert_eq!(config.output_name.as_ref(), "app-test");
+    assert_eq!(config.site_root.as_ref(), "my_target/site");
+    assert_eq!(config.site_pkg_dir.as_ref(), "my_pkg");
     assert_eq!(
         config.site_addr,
         SocketAddr::from_str("0.0.0.0:80").unwrap()
@@ -265,9 +265,9 @@ fn environment_variable_override() {
         || get_config_from_str(CARGO_TOML_CONTENT_OK).unwrap(),
     );
 
-    assert_eq!(config.output_name, "app-test2");
-    assert_eq!(config.site_root, "my_target/site2");
-    assert_eq!(config.site_pkg_dir, "my_pkg2");
+    assert_eq!(config.output_name.as_ref(), "app-test2");
+    assert_eq!(config.site_root.as_ref(), "my_target/site2");
+    assert_eq!(config.site_pkg_dir.as_ref(), "my_pkg2");
     assert_eq!(
         config.site_addr,
         SocketAddr::from_str("0.0.0.0:82").unwrap()

leptos_dom/src/helpers.rs

@@ -396,8 +396,7 @@ impl IntervalHandle {
     }
 }
 
-/// Repeatedly calls the given function, with a delay of the given duration between calls,
-/// returning a cancelable handle.
+/// Repeatedly calls the given function, with a delay of the given duration between calls.
 /// See [`setInterval()`](https://developer.mozilla.org/en-US/docs/Web/API/setInterval).
 #[cfg_attr(
   feature = "tracing",

leptos_macro/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos_macro"
-version = "0.7.0-gamma"
+version = "0.7.0-rc0"
 authors = ["Greg Johnston"]
 license = "MIT"
 repository = "https://github.com/leptos-rs/leptos"
@@ -51,7 +51,27 @@ axum = ["server_fn_macro/axum"]
 
 [package.metadata.cargo-all-features]
 denylist = ["nightly", "tracing", "trace-component-props"]
-skip_feature_sets = [["csr", "hydrate"], ["hydrate", "csr"], ["hydrate", "ssr"]]
+skip_feature_sets = [
+	[
+		"csr",
+		"hydrate",
+	],
+	[
+		"hydrate",
+		"csr",
+	],
+	[
+		"hydrate",
+		"ssr",
+	],
+	[
+		"actix",
+		"axum",
+	],
+]
 
 [package.metadata.docs.rs]
 rustdoc-args = ["--generate-link-to-definition"]
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(erase_components)'] }

leptos_macro/src/component.rs

@@ -18,6 +18,7 @@ use syn::{
 };
 
 pub struct Model {
+    is_transparent: bool,
     island: Option<String>,
     docs: Docs,
     unknown_attrs: UnknownAttrs,
@@ -62,6 +63,7 @@ impl Parse for Model {
         });
 
         Ok(Self {
+            is_transparent: false,
             island: None,
             docs,
             unknown_attrs,
@@ -102,6 +104,7 @@ pub fn convert_from_snake_case(name: &Ident) -> Ident {
 impl ToTokens for Model {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let Self {
+            is_transparent,
             island,
             docs,
             unknown_attrs,
@@ -116,20 +119,22 @@ impl ToTokens for Model {
         let no_props = props.is_empty();
 
         // check for components that end ;
-        let ends_semi =
-            body.block.stmts.iter().last().and_then(|stmt| match stmt {
-                Stmt::Item(Item::Macro(mac)) => mac.semi_token.as_ref(),
-                _ => None,
-            });
-        if let Some(semi) = ends_semi {
-            proc_macro_error2::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 \
-                 accident, not intentional, so we prevent it. If you’d like \
-                 to return (), you can do it it explicitly by returning () as \
-                 the last item from the component."
-            );
+        if !is_transparent {
+            let ends_semi =
+                body.block.stmts.iter().last().and_then(|stmt| match stmt {
+                    Stmt::Item(Item::Macro(mac)) => mac.semi_token.as_ref(),
+                    _ => None,
+                });
+            if let Some(semi) = ends_semi {
+                proc_macro_error2::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 accident, not intentional, so we prevent it. If you’d \
+                     like to return (), you can do it it explicitly by \
+                     returning () as the last item from the component."
+                );
+            }
         }
 
         //body.sig.ident = format_ident!("__{}", body.sig.ident);
@@ -255,7 +260,7 @@ impl ToTokens for Model {
         let body_name = unmodified_fn_name_from_fn_name(&body_name);
         let body_expr = if is_island {
             quote! {
-                ::leptos::reactive_graph::owner::Owner::with_hydration(move || {
+                ::leptos::reactive::owner::Owner::with_hydration(move || {
                     #body_name(#prop_names)
                 })
             }
@@ -265,14 +270,30 @@ impl ToTokens for Model {
             }
         };
 
-        let component = quote! {
-            ::leptos::reactive_graph::untrack(
-                move || {
-                    #tracing_guard_expr
-                    #tracing_props_expr
-                    #body_expr
-                }
-            )
+        let component = if *is_transparent {
+            body_expr
+        } else if cfg!(erase_components) {
+            quote! {
+                ::leptos::prelude::IntoAny::into_any(
+                    ::leptos::prelude::untrack(
+                        move || {
+                            #tracing_guard_expr
+                            #tracing_props_expr
+                            #body_expr
+                        }
+                    )
+                )
+            }
+        } else {
+            quote! {
+                ::leptos::prelude::untrack(
+                    move || {
+                        #tracing_guard_expr
+                        #tracing_props_expr
+                        #body_expr
+                    }
+                )
+            }
         };
 
         // add island wrapper if island
@@ -280,7 +301,7 @@ impl ToTokens for Model {
             let hydrate_fn_name = hydrate_fn_name.as_ref().unwrap();
             quote! {
                 {
-                    if ::leptos::reactive_graph::owner::Owner::current_shared_context()
+                    if ::leptos::reactive::owner::Owner::current_shared_context()
                         .map(|sc| sc.get_is_hydrating())
                         .unwrap_or(false) {
                         ::leptos::either::Either::Left(
@@ -316,9 +337,9 @@ impl ToTokens for Model {
                 quote! {
                     use leptos::tachys::view::any_view::IntoAny;
                     let children = Box::new(|| {
-                        let sc = ::leptos::reactive_graph::owner::Owner::current_shared_context().unwrap();
+                        let sc = ::leptos::reactive::owner::Owner::current_shared_context().unwrap();
                         let prev = sc.get_is_hydrating();
-                        let value = ::leptos::reactive_graph::owner::Owner::with_no_hydration(||
+                        let value = ::leptos::reactive::owner::Owner::with_no_hydration(||
                             ::leptos::tachys::html::islands::IslandChildren::new(children()).into_any()
                         );
                         sc.set_is_hydrating(prev);
@@ -520,6 +541,13 @@ impl ToTokens for Model {
 }
 
 impl Model {
+    #[allow(clippy::wrong_self_convention)]
+    pub fn is_transparent(mut self, is_transparent: bool) -> Self {
+        self.is_transparent = is_transparent;
+
+        self
+    }
+
     #[allow(clippy::wrong_self_convention)]
     pub fn with_island(mut self, island: Option<String>) -> Self {
         self.island = island;

leptos_macro/src/lib.rs

@@ -535,11 +535,24 @@ pub fn include_view(tokens: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_error2::proc_macro_error]
 #[proc_macro_attribute]
-pub fn component(
-    _args: proc_macro::TokenStream,
-    s: TokenStream,
-) -> TokenStream {
-    component_macro(s, None)
+pub fn component(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
+    let is_transparent = if !args.is_empty() {
+        let transparent = parse_macro_input!(args as syn::Ident);
+
+        if transparent != "transparent" {
+            abort!(
+                transparent,
+                "only `transparent` is supported";
+                help = "try `#[component(transparent)]` or `#[component]`"
+            );
+        }
+
+        true
+    } else {
+        false
+    };
+
+    component_macro(s, is_transparent, None)
 }
 
 /// Defines a component as an interactive island when you are using the
@@ -615,17 +628,37 @@ pub fn component(
 /// ```
 #[proc_macro_error2::proc_macro_error]
 #[proc_macro_attribute]
-pub fn island(_args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
+pub fn island(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
+    let is_transparent = if !args.is_empty() {
+        let transparent = parse_macro_input!(args as syn::Ident);
+
+        if transparent != "transparent" {
+            abort!(
+                transparent,
+                "only `transparent` is supported";
+                help = "try `#[component(transparent)]` or `#[component]`"
+            );
+        }
+
+        true
+    } else {
+        false
+    };
+
     let island_src = s.to_string();
-    component_macro(s, Some(island_src))
+    component_macro(s, is_transparent, Some(island_src))
 }
 
-fn component_macro(s: TokenStream, island: Option<String>) -> TokenStream {
+fn component_macro(
+    s: TokenStream,
+    is_transparent: bool,
+    island: Option<String>,
+) -> 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_transparent(is_transparent).with_island(island).into_token_stream();
         if !matches!(unexpanded.vis, Visibility::Public(_)) {
             unexpanded.vis = Visibility::Public(Pub {
                 span: unexpanded.vis.span(),
@@ -893,7 +926,7 @@ pub fn server(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
 
 /// Derives a trait that parses a map of string keys and values into a typed
 /// data structure, e.g., for route params.
-#[proc_macro_derive(Params, attributes(params))]
+#[proc_macro_derive(Params)]
 pub fn params_derive(
     input: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {

leptos_macro/src/memo.rs

@@ -40,9 +40,9 @@ impl ToTokens for MemoMacroInput {
         let path = &self.path;
 
         tokens.extend(quote! {
-            ::leptos::reactive_graph::computed::Memo::new(
+            ::leptos::reactive::computed::Memo::new(
                 move |_| {
-                    use ::leptos::reactive_graph::traits::With;
+                    use ::leptos::reactive::traits::With;
                     #root.with(|st: _| st.#path.clone())
                 }
             )

leptos_macro/src/params.rs

@@ -32,7 +32,7 @@ pub fn params_impl(ast: &syn::DeriveInput) -> proc_macro::TokenStream {
 
     let gen = quote! {
         impl Params for #name {
-            fn from_map(map: &::leptos_router::params::ParamsMap) -> Result<Self, ::leptos_router::params::ParamsError> {
+            fn from_map(map: &::leptos_router::params::ParamsMap) -> ::core::result::Result<Self, ::leptos_router::params::ParamsError> {
                 Ok(Self {
                     #(#fields,)*
                 })

leptos_macro/src/slice.rs

@@ -40,7 +40,7 @@ impl ToTokens for SliceMacroInput {
         let path = &self.path;
 
         tokens.extend(quote! {
-            ::leptos::reactive_graph::computed::create_slice(
+            ::leptos::reactive::computed::create_slice(
                 #root,
                 |st: &_| st.#path.clone(),
                 |st: &mut _, n| st.#path = n

leptos_macro/src/view/component_builder.rs

@@ -1,4 +1,6 @@
-use super::{fragment_to_tokens, TagType};
+use super::{
+    fragment_to_tokens, utils::is_nostrip_optional_and_update_key, TagType,
+};
 use crate::view::{attribute_absolute, utils::filter_prefixed_attrs};
 use proc_macro2::{Ident, TokenStream, TokenTree};
 use quote::{format_ident, quote, quote_spanned};
@@ -44,9 +46,10 @@ pub(crate) fn component_to_tokens(
         })
         .unwrap_or_else(|| node.attributes().len());
 
-    let attrs = node
-        .attributes()
-        .iter()
+    // Initially using uncloned mutable reference, as the node.key might be mutated during prop extraction (for nostrip:)
+    let mut attrs = node
+        .attributes_mut()
+        .iter_mut()
         .filter_map(|node| {
             if let NodeAttribute::Attribute(node) = node {
                 Some(node)
@@ -54,39 +57,46 @@ pub(crate) fn component_to_tokens(
                 None
             }
         })
-        .cloned()
         .collect::<Vec<_>>();
 
-    let props = attrs
-        .iter()
-        .enumerate()
-        .filter(|(idx, attr)| {
-            idx < &spread_marker && {
-                let attr_key = attr.key.to_string();
-                !is_attr_let(&attr.key)
-                    && !attr_key.starts_with("clone:")
-                    && !attr_key.starts_with("class:")
-                    && !attr_key.starts_with("style:")
-                    && !attr_key.starts_with("attr:")
-                    && !attr_key.starts_with("prop:")
-                    && !attr_key.starts_with("on:")
-                    && !attr_key.starts_with("use:")
-            }
-        })
-        .map(|(_, attr)| {
-            let name = &attr.key;
+    let mut required_props = vec![];
+    let mut optional_props = vec![];
+    for (_, attr) in attrs.iter_mut().enumerate().filter(|(idx, attr)| {
+        idx < &spread_marker && {
+            let attr_key = attr.key.to_string();
+            !is_attr_let(&attr.key)
+                && !attr_key.starts_with("clone:")
+                && !attr_key.starts_with("class:")
+                && !attr_key.starts_with("style:")
+                && !attr_key.starts_with("attr:")
+                && !attr_key.starts_with("prop:")
+                && !attr_key.starts_with("on:")
+                && !attr_key.starts_with("use:")
+        }
+    }) {
+        let optional = is_nostrip_optional_and_update_key(&mut attr.key);
+        let name = &attr.key;
 
-            let value = attr
-                .value()
-                .map(|v| {
-                    quote! { #v }
-                })
-                .unwrap_or_else(|| quote! { #name });
+        let value = attr
+            .value()
+            .map(|v| {
+                quote! { #v }
+            })
+            .unwrap_or_else(|| quote! { #name });
 
-            quote! {
+        if optional {
+            optional_props.push(quote! {
+                props.#name = { #value }.map(Into::into);
+            })
+        } else {
+            required_props.push(quote! {
                 .#name(#[allow(unused_braces)] { #value })
-            }
-        });
+            })
+        }
+    }
+
+    // Drop the mutable reference to the node, go to an owned clone:
+    let attrs = attrs.into_iter().map(|a| a.clone()).collect::<Vec<_>>();
 
     let items_to_bind = attrs
         .iter()
@@ -264,14 +274,20 @@ pub(crate) fn component_to_tokens(
     let mut component = quote! {
         {
             #[allow(unreachable_code)]
+            #[allow(unused_mut)]
+            #[allow(clippy::let_and_return)]
             ::leptos::component::component_view(
                 #[allow(clippy::needless_borrows_for_generic_args)]
                 &#name,
-                ::leptos::component::component_props_builder(&#name #generics)
-                    #(#props)*
-                    #(#slots)*
-                    #children
-                    .build()
+                {
+                    let mut props = ::leptos::component::component_props_builder(&#name #generics)
+                        #(#required_props)*
+                        #(#slots)*
+                        #children
+                        .build();
+                    #(#optional_props)*
+                    props
+                }
             )
             #spreads
         }

leptos_macro/src/view/mod.rs

@@ -179,7 +179,7 @@ fn is_inert_element(orig_node: &Node<impl CustomNode>) -> bool {
 }
 
 enum Item<'a, T> {
-    Node(&'a Node<T>),
+    Node(&'a Node<T>, bool),
     ClosingTag(String),
 }
 
@@ -290,10 +290,11 @@ impl<'a> InertElementBuilder<'a> {
 
 fn inert_element_to_tokens(
     node: &Node<impl CustomNode>,
+    escape_text: bool,
     global_class: Option<&TokenTree>,
 ) -> Option<TokenStream> {
     let mut html = InertElementBuilder::new(global_class);
-    let mut nodes = VecDeque::from([Item::Node(node)]);
+    let mut nodes = VecDeque::from([Item::Node(node, escape_text)]);
 
     while let Some(current) = nodes.pop_front() {
         match current {
@@ -303,19 +304,32 @@ fn inert_element_to_tokens(
                 html.push_str(&tag);
                 html.push('>');
             }
-            Item::Node(current) => {
+            Item::Node(current, escape) => {
                 match current {
                     Node::RawText(raw) => {
                         let text = raw.to_string_best();
+                        let text = if escape {
+                            html_escape::encode_text(&text)
+                        } else {
+                            text.into()
+                        };
                         html.push_str(&text);
                     }
                     Node::Text(text) => {
                         let text = text.value_string();
+                        let text = if escape {
+                            html_escape::encode_text(&text)
+                        } else {
+                            text.into()
+                        };
                         html.push_str(&text);
                     }
                     Node::Element(node) => {
                         let self_closing = is_self_closing(node);
                         let el_name = node.name().to_string();
+                        let escape = el_name != "script"
+                            && el_name != "style"
+                            && el_name != "textarea";
 
                         // opening tag
                         html.push('<');
@@ -324,9 +338,12 @@ fn inert_element_to_tokens(
                         for attr in node.attributes() {
                             if let NodeAttribute::Attribute(attr) = attr {
                                 let attr_name = attr.key.to_string();
+                                // trim r# from raw identifiers like r#as
+                                let attr_name =
+                                    attr_name.trim_start_matches("r#");
                                 if attr_name != "class" {
                                     html.push(' ');
-                                    html.push_str(&attr_name);
+                                    html.push_str(attr_name);
                                 }
 
                                 if let Some(value) =
@@ -337,11 +354,13 @@ fn inert_element_to_tokens(
                                     )) = &value.value
                                     {
                                         if let Lit::Str(txt) = &lit.lit {
+                                            let value = txt.value();
+                                            let value = html_escape::encode_double_quoted_attribute(&value);
                                             if attr_name == "class" {
-                                                html.push_class(&txt.value());
+                                                html.push_class(&value);
                                             } else {
                                                 html.push_str("=\"");
-                                                html.push_str(&txt.value());
+                                                html.push_str(&value);
                                                 html.push('"');
                                             }
                                         }
@@ -357,7 +376,7 @@ fn inert_element_to_tokens(
                             nodes.push_front(Item::ClosingTag(el_name));
                             let children = node.children.iter().rev();
                             for child in children {
-                                nodes.push_front(Item::Node(child));
+                                nodes.push_front(Item::Node(child, escape));
                             }
                         }
                     }
@@ -541,7 +560,9 @@ fn node_to_tokens(
             view_marker,
             disable_inert_html,
         ),
-        Node::Block(block) => Some(quote! { #block }),
+        Node::Block(block) => {
+            Some(quote! { ::leptos::prelude::IntoRender::into_render(#block) })
+        }
         Node::Text(text) => Some(text_to_tokens(&text.value)),
         Node::RawText(raw) => {
             let text = raw.to_string_best();
@@ -550,7 +571,11 @@ fn node_to_tokens(
         }
         Node::Element(el_node) => {
             if !top_level && is_inert {
-                inert_element_to_tokens(node, global_class)
+                let el_name = el_node.name().to_string();
+                let escape = el_name != "script"
+                    && el_name != "style"
+                    && el_name != "textarea";
+                inert_element_to_tokens(node, escape, global_class)
             } else {
                 element_to_tokens(
                     el_node,
@@ -718,6 +743,11 @@ pub(crate) fn element_to_tokens(
             quote! { ::leptos::tachys::html::element::#custom(#name) }
         } else if is_svg_element(&tag) {
             parent_type = TagType::Svg;
+            let name = if tag == "use" || tag == "use_" {
+                Ident::new_raw("use", name.span()).to_token_stream()
+            } else {
+                name.to_token_stream()
+            };
             quote! { ::leptos::tachys::svg::#name() }
         } else if is_math_ml_element(&tag) {
             parent_type = TagType::Math;
@@ -871,7 +901,7 @@ fn attribute_to_tokens(
                     NodeName::Path(path) => path.path.get_ident(),
                     _ => unreachable!(),
                 };
-                let value = attribute_value(node);
+                let value = attribute_value(node, false);
                 quote! {
                     .#node_ref(#value)
                 }
@@ -921,13 +951,13 @@ fn attribute_to_tokens(
                 // we don't provide statically-checked methods for SVG attributes
                 || (tag_type == TagType::Svg && name != "inner_html")
             {
-                let value = attribute_value(node);
+                let value = attribute_value(node, true);
                 quote! {
                     .attr(#name, #value)
                 }
             } else {
                 let key = attribute_name(&node.key);
-                let value = attribute_value(node);
+                let value = attribute_value(node, true);
 
                 // special case of global_class and class attribute
                 if &node.key.to_string() == "class"
@@ -964,11 +994,11 @@ pub(crate) fn attribute_absolute(
                 let id = &parts[0];
                 match id {
                     NodeNameFragment::Ident(id) => {
-                        let value = attribute_value(node);
                         // ignore `let:` and `clone:`
                         if id == "let" || id == "clone" {
                             None
                         } else if id == "attr" {
+                        let value = attribute_value(node, true);
                             let key = &parts[1];
                             let key_name = key.to_string();
                             if key_name == "class" || key_name == "style" {
@@ -976,6 +1006,7 @@ pub(crate) fn attribute_absolute(
                                     quote! { ::leptos::tachys::html::#key::#key(#value) },
                                 )
                             } else if key_name == "aria" {
+                                let value = attribute_value(node, true);
                                 let mut parts_iter = parts.iter();
                                 parts_iter.next();
                                 let fn_name = parts_iter.map(|p| p.to_string()).collect::<Vec<String>>().join("_");
@@ -1004,6 +1035,7 @@ pub(crate) fn attribute_absolute(
                                 },
                             )
                         } else if id == "style" || id == "class" {
+                            let value = attribute_value(node, false);
                             let key = &node.key.to_string();
                             let key = key
                                 .replacen("style:", "", 1)
@@ -1012,6 +1044,7 @@ pub(crate) fn attribute_absolute(
                                 quote! { ::leptos::tachys::html::#id::#id((#key, #value)) },
                             )
                         } else if id == "prop" {
+                            let value = attribute_value(node, false);
                             let key = &node.key.to_string();
                             let key = key.replacen("prop:", "", 1);
                             Some(
@@ -1068,7 +1101,7 @@ pub(crate) fn two_way_binding_to_tokens(
     name: &str,
     node: &KeyedAttribute,
 ) -> TokenStream {
-    let value = attribute_value(node);
+    let value = attribute_value(node, false);
 
     let ident =
         format_ident!("{}", name.to_case(UpperCamel), span = node.key.span());
@@ -1093,7 +1126,7 @@ pub(crate) fn event_type_and_handler(
     name: &str,
     node: &KeyedAttribute,
 ) -> (TokenStream, TokenStream, TokenStream) {
-    let handler = attribute_value(node);
+    let handler = attribute_value(node, false);
 
     let (event_type, is_custom, is_force_undelegated, is_targeted) =
         parse_event_name(name);
@@ -1150,7 +1183,7 @@ fn class_to_tokens(
     class: TokenStream,
     class_name: Option<&str>,
 ) -> TokenStream {
-    let value = attribute_value(node);
+    let value = attribute_value(node, false);
     if let Some(class_name) = class_name {
         quote! {
             .#class((#class_name, #value))
@@ -1167,7 +1200,7 @@ fn style_to_tokens(
     style: TokenStream,
     style_name: Option<&str>,
 ) -> TokenStream {
-    let value = attribute_value(node);
+    let value = attribute_value(node, false);
     if let Some(style_name) = style_name {
         quote! {
             .#style((#style_name, #value))
@@ -1184,7 +1217,7 @@ fn prop_to_tokens(
     prop: TokenStream,
     key: &str,
 ) -> TokenStream {
-    let value = attribute_value(node);
+    let value = attribute_value(node, false);
     quote! {
         .#prop(#key, #value)
     }
@@ -1341,7 +1374,10 @@ fn attribute_name(name: &NodeName) -> TokenStream {
     }
 }
 
-fn attribute_value(attr: &KeyedAttribute) -> TokenStream {
+fn attribute_value(
+    attr: &KeyedAttribute,
+    is_attribute_proper: bool,
+) -> TokenStream {
     match attr.possible_value.to_value() {
         None => quote! { true },
         Some(value) => match &value.value {
@@ -1356,14 +1392,26 @@ fn attribute_value(attr: &KeyedAttribute) -> TokenStream {
                     }
                 }
 
-                quote! {
-                    {#expr}
+                if matches!(expr, Expr::Lit(_)) || !is_attribute_proper {
+                    quote! {
+                        #expr
+                    }
+                } else {
+                    quote! {
+                        ::leptos::prelude::IntoAttributeValue::into_attribute_value(#expr)
+                    }
                 }
             }
             // any value in braces: expand as-is to give proper r-a support
             KVAttributeValue::InvalidBraced(block) => {
-                quote! {
-                    #block
+                if is_attribute_proper {
+                    quote! {
+                        ::leptos::prelude::IntoAttributeValue::into_attribute_value(#block)
+                    }
+                } else {
+                    quote! {
+                        #block
+                    }
                 }
             }
         },

leptos_macro/src/view/utils.rs

@@ -1,7 +1,7 @@
 use proc_macro2::Ident;
 use quote::format_ident;
-use rstml::node::KeyedAttribute;
-use syn::spanned::Spanned;
+use rstml::node::{KeyedAttribute, NodeName};
+use syn::{spanned::Spanned, ExprPath};
 
 pub fn filter_prefixed_attrs<'a, A>(attrs: A, prefix: &str) -> Vec<Ident>
 where
@@ -17,3 +17,37 @@ where
         })
         .collect()
 }
+
+/// Handle nostrip: prefix:
+/// if there strip from the name, and return true to indicate that
+/// the prop should be an Option<T> and shouldn't be called on the builder if None,
+/// if Some(T) then T supplied to the builder.
+pub fn is_nostrip_optional_and_update_key(key: &mut NodeName) -> bool {
+    let maybe_cleaned_name_and_span = if let NodeName::Punctuated(punct) = &key
+    {
+        if punct.len() == 2 {
+            if let Some(cleaned_name) = key.to_string().strip_prefix("nostrip:")
+            {
+                punct
+                    .get(1)
+                    .map(|segment| (cleaned_name.to_string(), segment.span()))
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+    if let Some((cleaned_name, span)) = maybe_cleaned_name_and_span {
+        *key = NodeName::Path(ExprPath {
+            attrs: vec![],
+            qself: None,
+            path: format_ident!("{}", cleaned_name, span = span).into(),
+        });
+        true
+    } else {
+        false
+    }
+}

leptos_macro/tests/component.rs

@@ -4,6 +4,7 @@ use leptos::prelude::*;
 #[component]
 fn Component(
     #[prop(optional)] optional: bool,
+    #[prop(optional, into)] optional_into: Option<String>,
     #[prop(optional_no_strip)] optional_no_strip: Option<String>,
     #[prop(strip_option)] strip_option: Option<u8>,
     #[prop(default = NonZeroUsize::new(10).unwrap())] default: NonZeroUsize,
@@ -11,6 +12,7 @@ fn Component(
     impl_trait: impl Fn() -> i32 + 'static,
 ) -> impl IntoView {
     _ = optional;
+    _ = optional_into;
     _ = optional_no_strip;
     _ = strip_option;
     _ = default;
@@ -26,9 +28,29 @@ fn component() {
         .impl_trait(|| 42)
         .build();
     assert!(!cp.optional);
+    assert_eq!(cp.optional_into, None);
     assert_eq!(cp.optional_no_strip, None);
     assert_eq!(cp.strip_option, Some(9));
     assert_eq!(cp.default, NonZeroUsize::new(10).unwrap());
     assert_eq!(cp.into, "");
     assert_eq!((cp.impl_trait)(), 42);
 }
+
+#[test]
+fn component_nostrip() {
+    // Should compile (using nostrip:optional_into in second <Component />)
+    view! {
+        <Component
+            optional_into="foo"
+            strip_option=9
+            into=""
+            impl_trait=|| 42
+        />
+        <Component
+            nostrip:optional_into=Some("foo")
+            strip_option=9
+            into=""
+            impl_trait=|| 42
+        />
+    };
+}

leptos_macro/tests/ui.rs

@@ -1,3 +1,4 @@
+#[cfg(not(erase_components))]
 #[test]
 fn ui() {
     let t = trybuild::TestCases::new();

leptos_server/Cargo.toml

@@ -19,6 +19,7 @@ tracing = { version = "0.1.40", optional = true }
 futures = "0.3.30"
 
 any_spawner = { workspace = true }
+or_poisoned = { workspace = true }
 tachys = { workspace = true, optional = true, features = ["reactive_graph"] }
 send_wrapper = "0.6"
 

leptos_server/src/lib.rs

@@ -8,6 +8,8 @@ mod local_resource;
 pub use local_resource::*;
 mod multi_action;
 pub use multi_action::*;
+mod once_resource;
+pub use once_resource::*;
 mod resource;
 pub use resource::*;
 mod shared;
@@ -183,7 +185,7 @@ impl FromEncodedStr for [u8] {
 mod view_implementations {
     use crate::Resource;
     use reactive_graph::traits::Read;
-    use std::{future::Future, pin::Pin};
+    use std::future::Future;
     use tachys::{
         html::attribute::Attribute,
         hydration::Cursor,
@@ -217,16 +219,11 @@ mod view_implementations {
     {
         type Output<SomeNewAttr: Attribute> = Box<
             dyn FnMut() -> Suspend<
-                    Pin<
-                        Box<
-                            dyn Future<
-                                    Output = <T as AddAnyAttr>::Output<
-                                        <SomeNewAttr::CloneableOwned as Attribute>::CloneableOwned,
-                                    >,
-                                > + Send,
-                        >,
-                    >,
-                > + Send,
+                <T as AddAnyAttr>::Output<
+                    <SomeNewAttr::CloneableOwned as Attribute>::CloneableOwned,
+                >,
+            >
+            + Send
         >;
 
         fn add_any_attr<NewAttr: Attribute>(

leptos_server/src/local_resource.rs

@@ -35,10 +35,10 @@ impl<T> Clone for ArcLocalResource<T> {
 
 impl<T> ArcLocalResource<T> {
     #[track_caller]
-    pub fn new<Fut>(fetcher: impl Fn() -> Fut + Send + Sync + 'static) -> Self
+    pub fn new<Fut>(fetcher: impl Fn() -> Fut + 'static) -> Self
     where
-        T: Send + Sync + 'static,
-        Fut: Future<Output = T> + Send + 'static,
+        T: 'static,
+        Fut: Future<Output = T> + 'static,
     {
         let fetcher = move || {
             let fut = fetcher();
@@ -60,7 +60,7 @@ impl<T> ArcLocalResource<T> {
             }
         };
         Self {
-            data: ArcAsyncDerived::new(fetcher),
+            data: ArcAsyncDerived::new_unsync(fetcher),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
         }
@@ -103,7 +103,7 @@ impl<T> DefinedAt for ArcLocalResource<T> {
 
 impl<T> ReadUntracked for ArcLocalResource<T>
 where
-    T: Send + Sync + 'static,
+    T: 'static,
 {
     type Value = ReadGuard<Option<T>, AsyncPlain<Option<T>>>;
 
@@ -201,7 +201,7 @@ impl<T> LocalResource<T> {
     pub fn new<Fut>(fetcher: impl Fn() -> Fut + 'static) -> Self
     where
         T: 'static,
-        Fut: Future<Output = T> + Send + 'static,
+        Fut: Future<Output = T> + 'static,
     {
         let fetcher = move || {
             let fut = fetcher();
@@ -230,7 +230,7 @@ impl<T> LocalResource<T> {
                 let fetcher = SendWrapper::new(fetcher);
                 AsyncDerived::new(move || {
                     let fut = fetcher();
-                    async move { SendWrapper::new(fut.await) }
+                    SendWrapper::new(async move { SendWrapper::new(fut.await) })
                 })
             },
             #[cfg(debug_assertions)]
@@ -280,7 +280,7 @@ impl<T> DefinedAt for LocalResource<T> {
 
 impl<T> ReadUntracked for LocalResource<T>
 where
-    T: Send + Sync + 'static,
+    T: 'static,
 {
     type Value =
         ReadGuard<Option<SendWrapper<T>>, AsyncPlain<Option<SendWrapper<T>>>>;
@@ -307,7 +307,7 @@ impl<T: 'static> IsDisposed for LocalResource<T> {
 
 impl<T: 'static> ToAnySource for LocalResource<T>
 where
-    T: Send + Sync + 'static,
+    T: 'static,
 {
     fn to_any_source(&self) -> AnySource {
         self.data.to_any_source()
@@ -316,7 +316,7 @@ where
 
 impl<T: 'static> ToAnySubscriber for LocalResource<T>
 where
-    T: Send + Sync + 'static,
+    T: 'static,
 {
     fn to_any_subscriber(&self) -> AnySubscriber {
         self.data.to_any_subscriber()
@@ -325,7 +325,7 @@ where
 
 impl<T> Source for LocalResource<T>
 where
-    T: Send + Sync + 'static,
+    T: 'static,
 {
     fn add_subscriber(&self, subscriber: AnySubscriber) {
         self.data.add_subscriber(subscriber)
@@ -342,7 +342,7 @@ where
 
 impl<T> ReactiveNode for LocalResource<T>
 where
-    T: Send + Sync + 'static,
+    T: 'static,
 {
     fn mark_dirty(&self) {
         self.data.mark_dirty();
@@ -363,7 +363,7 @@ where
 
 impl<T> Subscriber for LocalResource<T>
 where
-    T: Send + Sync + 'static,
+    T: 'static,
 {
     fn add_source(&self, source: AnySource) {
         self.data.add_source(source);

leptos_server/src/once_resource.rs

@@ -0,0 +1,708 @@
+use crate::{
+    initial_value, FromEncodedStr, IntoEncodedString,
+    IS_SUPPRESSING_RESOURCE_LOAD,
+};
+#[cfg(feature = "rkyv")]
+use codee::binary::RkyvCodec;
+#[cfg(feature = "serde-wasm-bindgen")]
+use codee::string::JsonSerdeWasmCodec;
+#[cfg(feature = "miniserde")]
+use codee::string::MiniserdeCodec;
+#[cfg(feature = "serde-lite")]
+use codee::SerdeLite;
+use codee::{
+    string::{FromToStringCodec, JsonSerdeCodec},
+    Decoder, Encoder,
+};
+use core::{fmt::Debug, marker::PhantomData};
+use futures::Future;
+use or_poisoned::OrPoisoned;
+use reactive_graph::{
+    computed::{
+        suspense::SuspenseContext, AsyncDerivedReadyFuture, ScopedFuture,
+    },
+    diagnostics::{SpecialNonReactiveFuture, SpecialNonReactiveZone},
+    graph::{AnySource, ToAnySource},
+    owner::{use_context, ArenaItem, Owner},
+    prelude::*,
+    signal::{
+        guards::{Plain, ReadGuard},
+        ArcTrigger,
+    },
+    unwrap_signal,
+};
+use std::{
+    future::IntoFuture,
+    mem,
+    panic::Location,
+    pin::Pin,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc, RwLock,
+    },
+    task::{Context, Poll, Waker},
+};
+
+#[derive(Debug)]
+pub struct ArcOnceResource<T, Ser = JsonSerdeCodec> {
+    trigger: ArcTrigger,
+    value: Arc<RwLock<Option<T>>>,
+    wakers: Arc<RwLock<Vec<Waker>>>,
+    suspenses: Arc<RwLock<Vec<SuspenseContext>>>,
+    loading: Arc<AtomicBool>,
+    ser: PhantomData<fn() -> Ser>,
+    #[cfg(debug_assertions)]
+    defined_at: &'static Location<'static>,
+}
+
+impl<T, Ser> Clone for ArcOnceResource<T, Ser> {
+    fn clone(&self) -> Self {
+        Self {
+            trigger: self.trigger.clone(),
+            value: self.value.clone(),
+            wakers: self.wakers.clone(),
+            suspenses: self.suspenses.clone(),
+            loading: self.loading.clone(),
+            ser: self.ser,
+            #[cfg(debug_assertions)]
+            defined_at: self.defined_at,
+        }
+    }
+}
+
+impl<T, Ser> ArcOnceResource<T, Ser>
+where
+    T: Send + Sync + 'static,
+    Ser: Encoder<T> + Decoder<T>,
+    <Ser as Encoder<T>>::Error: Debug,
+    <Ser as Decoder<T>>::Error: Debug,
+    <<Ser as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
+    <Ser as Encoder<T>>::Encoded: IntoEncodedString,
+    <Ser as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new_with_options(
+        fut: impl Future<Output = T> + Send + 'static,
+        #[allow(unused)] // this is used with `feature = "ssr"`
+        blocking: bool,
+    ) -> Self {
+        let shared_context = Owner::current_shared_context();
+        let id = shared_context
+            .as_ref()
+            .map(|sc| sc.next_id())
+            .unwrap_or_default();
+
+        let initial = initial_value::<T, Ser>(&id, shared_context.as_ref());
+        let is_ready = initial.is_some();
+        let value = Arc::new(RwLock::new(initial));
+        let wakers = Arc::new(RwLock::new(Vec::<Waker>::new()));
+        let suspenses = Arc::new(RwLock::new(Vec::<SuspenseContext>::new()));
+        let loading = Arc::new(AtomicBool::new(!is_ready));
+        let trigger = ArcTrigger::new();
+
+        let fut = ScopedFuture::new(fut);
+
+        if !is_ready && !IS_SUPPRESSING_RESOURCE_LOAD.load(Ordering::Relaxed) {
+            let value = Arc::clone(&value);
+            let wakers = Arc::clone(&wakers);
+            let loading = Arc::clone(&loading);
+            let trigger = trigger.clone();
+            reactive_graph::spawn(async move {
+                let loaded = fut.await;
+                *value.write().or_poisoned() = Some(loaded);
+                loading.store(false, Ordering::Relaxed);
+                for waker in mem::take(&mut *wakers.write().or_poisoned()) {
+                    waker.wake();
+                }
+                trigger.notify();
+            });
+        }
+
+        let data = Self {
+            trigger,
+            value: value.clone(),
+            loading,
+            wakers,
+            suspenses,
+            ser: PhantomData,
+            #[cfg(debug_assertions)]
+            defined_at: Location::caller(),
+        };
+
+        #[cfg(feature = "ssr")]
+        if let Some(shared_context) = shared_context {
+            let value = Arc::clone(&value);
+            let ready_fut = data.ready();
+
+            if blocking {
+                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;
+                        let value = value.read().or_poisoned();
+                        let value = value.as_ref().unwrap();
+                        Ser::encode(value).unwrap().into_encoded_string()
+                    }),
+                );
+            }
+        }
+
+        data
+    }
+}
+
+impl<T, Ser> ArcOnceResource<T, Ser> {
+    /// Returns a `Future` that is ready when this resource has next finished loading.
+    pub fn ready(&self) -> AsyncDerivedReadyFuture {
+        AsyncDerivedReadyFuture::new(
+            self.to_any_source(),
+            &self.loading,
+            &self.wakers,
+        )
+    }
+}
+
+impl<T, Ser> DefinedAt for ArcOnceResource<T, Ser> {
+    fn defined_at(&self) -> Option<&'static Location<'static>> {
+        #[cfg(not(debug_assertions))]
+        {
+            None
+        }
+        #[cfg(debug_assertions)]
+        {
+            Some(self.defined_at)
+        }
+    }
+}
+
+impl<T, Ser> IsDisposed for ArcOnceResource<T, Ser> {
+    #[inline(always)]
+    fn is_disposed(&self) -> bool {
+        false
+    }
+}
+
+impl<T, Ser> ToAnySource for ArcOnceResource<T, Ser> {
+    fn to_any_source(&self) -> AnySource {
+        self.trigger.to_any_source()
+    }
+}
+
+impl<T, Ser> Track for ArcOnceResource<T, Ser> {
+    fn track(&self) {
+        self.trigger.track();
+    }
+}
+
+impl<T, Ser> ReadUntracked for ArcOnceResource<T, Ser>
+where
+    T: 'static,
+{
+    type Value = ReadGuard<Option<T>, Plain<Option<T>>>;
+
+    fn try_read_untracked(&self) -> Option<Self::Value> {
+        if let Some(suspense_context) = use_context::<SuspenseContext>() {
+            if self.value.read().or_poisoned().is_none() {
+                let handle = suspense_context.task_id();
+                let ready = SpecialNonReactiveFuture::new(self.ready());
+                reactive_graph::spawn(async move {
+                    ready.await;
+                    drop(handle);
+                });
+                self.suspenses.write().or_poisoned().push(suspense_context);
+            }
+        }
+        Plain::try_new(Arc::clone(&self.value)).map(ReadGuard::new)
+    }
+}
+
+impl<T, Ser> IntoFuture for ArcOnceResource<T, Ser>
+where
+    T: Clone + 'static,
+{
+    type Output = T;
+    type IntoFuture = OnceResourceFuture<T>;
+
+    fn into_future(self) -> Self::IntoFuture {
+        OnceResourceFuture {
+            source: self.to_any_source(),
+            value: Arc::clone(&self.value),
+            loading: Arc::clone(&self.loading),
+            wakers: Arc::clone(&self.wakers),
+            suspenses: Arc::clone(&self.suspenses),
+        }
+    }
+}
+
+/// A [`Future`] that is ready when an [`ArcAsyncDerived`] is finished loading or reloading,
+/// and contains its value. `.await`ing this clones the value `T`.
+pub struct OnceResourceFuture<T> {
+    source: AnySource,
+    value: Arc<RwLock<Option<T>>>,
+    loading: Arc<AtomicBool>,
+    wakers: Arc<RwLock<Vec<Waker>>>,
+    suspenses: Arc<RwLock<Vec<SuspenseContext>>>,
+}
+
+impl<T> Future for OnceResourceFuture<T>
+where
+    T: Clone + 'static,
+{
+    type Output = T;
+
+    #[track_caller]
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        #[cfg(debug_assertions)]
+        let _guard = SpecialNonReactiveZone::enter();
+        let waker = cx.waker();
+        self.source.track();
+
+        if let Some(suspense_context) = use_context::<SuspenseContext>() {
+            self.suspenses.write().or_poisoned().push(suspense_context);
+        }
+
+        if self.loading.load(Ordering::Relaxed) {
+            self.wakers.write().or_poisoned().push(waker.clone());
+            Poll::Pending
+        } else {
+            Poll::Ready(
+                self.value.read().or_poisoned().as_ref().unwrap().clone(),
+            )
+        }
+    }
+}
+
+impl<T> ArcOnceResource<T, JsonSerdeCodec>
+where
+    T: Send + Sync + 'static,
+    JsonSerdeCodec: Encoder<T> + Decoder<T>,
+    <JsonSerdeCodec as Encoder<T>>::Error: Debug,
+    <JsonSerdeCodec as Decoder<T>>::Error: Debug,
+    <<JsonSerdeCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
+        Debug,
+    <JsonSerdeCodec as Encoder<T>>::Encoded: IntoEncodedString,
+    <JsonSerdeCodec as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new(fut: impl Future<Output = T> + Send + 'static) -> Self {
+        ArcOnceResource::new_with_options(fut, false)
+    }
+
+    #[track_caller]
+    pub fn new_blocking(fut: impl Future<Output = T> + Send + 'static) -> Self {
+        ArcOnceResource::new_with_options(fut, true)
+    }
+}
+
+impl<T> ArcOnceResource<T, FromToStringCodec>
+where
+T: Send + Sync + 'static,
+    FromToStringCodec: Encoder<T> + Decoder<T>,
+    <FromToStringCodec as Encoder<T>>::Error: Debug, <FromToStringCodec as Decoder<T>>::Error: Debug,
+    <<FromToStringCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
+    <FromToStringCodec as Encoder<T>>::Encoded: IntoEncodedString,
+    <FromToStringCodec as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    pub fn new_str(
+        fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        ArcOnceResource::new_with_options(fut, false)
+    }
+
+    pub fn new_str_blocking(
+        fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        ArcOnceResource::new_with_options(fut, true)
+    }
+}
+
+#[cfg(feature = "serde-wasm-bindgen")]
+impl<T> ArcOnceResource<T, JsonSerdeWasmCodec>
+where
+T: Send + Sync + 'static,
+    JsonSerdeWasmCodec: Encoder<T> + Decoder<T>,
+    <JsonSerdeWasmCodec as Encoder<T>>::Error: Debug, <JsonSerdeWasmCodec as Decoder<T>>::Error: Debug,
+    <<JsonSerdeWasmCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
+    <JsonSerdeWasmCodec as Encoder<T>>::Encoded: IntoEncodedString,
+    <JsonSerdeWasmCodec as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new_serde_wb(
+fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        ArcOnceResource::new_with_options(fut, false)
+    }
+
+    #[track_caller]
+    pub fn new_serde_wb_blocking(
+fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        ArcOnceResource::new_with_options(fut, true)
+    }
+}
+#[cfg(feature = "miniserde")]
+impl<T> ArcOnceResource<T, MiniserdeCodec>
+where
+    T: Send + Sync + 'static,
+    MiniserdeCodec: Encoder<T> + Decoder<T>,
+    <MiniserdeCodec as Encoder<T>>::Error: Debug,
+    <MiniserdeCodec as Decoder<T>>::Error: Debug,
+    <<MiniserdeCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
+        Debug,
+    <MiniserdeCodec as Encoder<T>>::Encoded: IntoEncodedString,
+    <MiniserdeCodec as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new_miniserde(
+        fut: impl Future<Output = T> + Send + 'static,
+    ) -> Self {
+        ArcOnceResource::new_with_options(fut, false)
+    }
+
+    #[track_caller]
+    pub fn new_miniserde_blocking(
+        fut: impl Future<Output = T> + Send + 'static,
+    ) -> Self {
+        ArcOnceResource::new_with_options(fut, true)
+    }
+}
+
+#[cfg(feature = "serde-lite")]
+impl<T> ArcOnceResource<T, SerdeLite<JsonSerdeCodec>>
+where
+T: Send + Sync + 'static,
+    SerdeLite<JsonSerdeCodec>: Encoder<T> + Decoder<T>,
+    <SerdeLite<JsonSerdeCodec> as Encoder<T>>::Error: Debug, <SerdeLite<JsonSerdeCodec> as Decoder<T>>::Error: Debug,
+    <<SerdeLite<JsonSerdeCodec> as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
+    <SerdeLite<JsonSerdeCodec> as Encoder<T>>::Encoded: IntoEncodedString,
+    <SerdeLite<JsonSerdeCodec> as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new_serde_lite(
+fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        ArcOnceResource::new_with_options(fut, false)
+    }
+
+    #[track_caller]
+    pub fn new_serde_lite_blocking(
+fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        ArcOnceResource::new_with_options(fut, true)
+    }
+}
+
+#[cfg(feature = "rkyv")]
+impl<T> ArcOnceResource<T, RkyvCodec>
+where
+    T: Send + Sync + 'static,
+    RkyvCodec: Encoder<T> + Decoder<T>,
+    <RkyvCodec as Encoder<T>>::Error: Debug,
+    <RkyvCodec as Decoder<T>>::Error: Debug,
+    <<RkyvCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
+        Debug,
+    <RkyvCodec as Encoder<T>>::Encoded: IntoEncodedString,
+    <RkyvCodec as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new_rkyv(fut: impl Future<Output = T> + Send + 'static) -> Self {
+        ArcOnceResource::new_with_options(fut, false)
+    }
+
+    #[track_caller]
+    pub fn new_rkyv_blocking(
+        fut: impl Future<Output = T> + Send + 'static,
+    ) -> Self {
+        ArcOnceResource::new_with_options(fut, true)
+    }
+}
+
+#[derive(Debug)]
+pub struct OnceResource<T, Ser = JsonSerdeCodec> {
+    inner: ArenaItem<ArcOnceResource<T, Ser>>,
+    #[cfg(debug_assertions)]
+    defined_at: &'static Location<'static>,
+}
+
+impl<T, Ser> Clone for OnceResource<T, Ser> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T, Ser> Copy for OnceResource<T, Ser> {}
+
+impl<T, Ser> OnceResource<T, Ser>
+where
+    T: Send + Sync + 'static,
+    Ser: Encoder<T> + Decoder<T>,
+    <Ser as Encoder<T>>::Error: Debug,
+    <Ser as Decoder<T>>::Error: Debug,
+    <<Ser as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
+    <Ser as Encoder<T>>::Encoded: IntoEncodedString,
+    <Ser as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new_with_options(
+        fut: impl Future<Output = T> + Send + 'static,
+        blocking: bool,
+    ) -> Self {
+        #[cfg(debug_assertions)]
+        let defined_at = Location::caller();
+        Self {
+            inner: ArenaItem::new(ArcOnceResource::new_with_options(
+                fut, blocking,
+            )),
+            #[cfg(debug_assertions)]
+            defined_at,
+        }
+    }
+}
+
+impl<T, Ser> OnceResource<T, Ser>
+where
+    T: Send + Sync + 'static,
+    Ser: 'static,
+{
+    /// Returns a `Future` that is ready when this resource has next finished loading.
+    pub fn ready(&self) -> AsyncDerivedReadyFuture {
+        self.inner
+            .try_with_value(|inner| inner.ready())
+            .unwrap_or_else(unwrap_signal!(self))
+    }
+}
+
+impl<T, Ser> DefinedAt for OnceResource<T, Ser> {
+    fn defined_at(&self) -> Option<&'static Location<'static>> {
+        #[cfg(not(debug_assertions))]
+        {
+            None
+        }
+        #[cfg(debug_assertions)]
+        {
+            Some(self.defined_at)
+        }
+    }
+}
+
+impl<T, Ser> IsDisposed for OnceResource<T, Ser> {
+    #[inline(always)]
+    fn is_disposed(&self) -> bool {
+        false
+    }
+}
+
+impl<T, Ser> ToAnySource for OnceResource<T, Ser>
+where
+    T: Send + Sync + 'static,
+    Ser: 'static,
+{
+    fn to_any_source(&self) -> AnySource {
+        self.inner
+            .try_with_value(|inner| inner.to_any_source())
+            .unwrap_or_else(unwrap_signal!(self))
+    }
+}
+
+impl<T, Ser> Track for OnceResource<T, Ser>
+where
+    T: Send + Sync + 'static,
+    Ser: 'static,
+{
+    fn track(&self) {
+        if let Some(inner) = self.inner.try_get_value() {
+            inner.track();
+        }
+    }
+}
+
+impl<T, Ser> ReadUntracked for OnceResource<T, Ser>
+where
+    T: Send + Sync + 'static,
+    Ser: 'static,
+{
+    type Value = ReadGuard<Option<T>, Plain<Option<T>>>;
+
+    fn try_read_untracked(&self) -> Option<Self::Value> {
+        self.inner
+            .try_with_value(|inner| inner.try_read_untracked())
+            .flatten()
+    }
+}
+
+impl<T, Ser> IntoFuture for OnceResource<T, Ser>
+where
+    T: Clone + Send + Sync + 'static,
+    Ser: 'static,
+{
+    type Output = T;
+    type IntoFuture = OnceResourceFuture<T>;
+
+    fn into_future(self) -> Self::IntoFuture {
+        self.inner
+            .try_get_value()
+            .unwrap_or_else(unwrap_signal!(self))
+            .into_future()
+    }
+}
+
+impl<T> OnceResource<T, JsonSerdeCodec>
+where
+    T: Send + Sync + 'static,
+    JsonSerdeCodec: Encoder<T> + Decoder<T>,
+    <JsonSerdeCodec as Encoder<T>>::Error: Debug,
+    <JsonSerdeCodec as Decoder<T>>::Error: Debug,
+    <<JsonSerdeCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
+        Debug,
+    <JsonSerdeCodec as Encoder<T>>::Encoded: IntoEncodedString,
+    <JsonSerdeCodec as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new(fut: impl Future<Output = T> + Send + 'static) -> Self {
+        OnceResource::new_with_options(fut, false)
+    }
+
+    #[track_caller]
+    pub fn new_blocking(fut: impl Future<Output = T> + Send + 'static) -> Self {
+        OnceResource::new_with_options(fut, true)
+    }
+}
+
+impl<T> OnceResource<T, FromToStringCodec>
+where
+T: Send + Sync + 'static,
+    FromToStringCodec: Encoder<T> + Decoder<T>,
+    <FromToStringCodec as Encoder<T>>::Error: Debug, <FromToStringCodec as Decoder<T>>::Error: Debug,
+    <<FromToStringCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
+    <FromToStringCodec as Encoder<T>>::Encoded: IntoEncodedString,
+    <FromToStringCodec as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    pub fn new_str(
+        fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        OnceResource::new_with_options(fut, false)
+    }
+
+    pub fn new_str_blocking(
+        fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        OnceResource::new_with_options(fut, true)
+    }
+}
+
+#[cfg(feature = "serde-wasm-bindgen")]
+impl<T> OnceResource<T, JsonSerdeWasmCodec>
+where
+T: Send + Sync + 'static,
+    JsonSerdeWasmCodec: Encoder<T> + Decoder<T>,
+    <JsonSerdeWasmCodec as Encoder<T>>::Error: Debug, <JsonSerdeWasmCodec as Decoder<T>>::Error: Debug,
+    <<JsonSerdeWasmCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
+    <JsonSerdeWasmCodec as Encoder<T>>::Encoded: IntoEncodedString,
+    <JsonSerdeWasmCodec as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new_serde_wb(
+fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        OnceResource::new_with_options(fut, false)
+    }
+
+    #[track_caller]
+    pub fn new_serde_wb_blocking(
+fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        OnceResource::new_with_options(fut, true)
+    }
+}
+#[cfg(feature = "miniserde")]
+impl<T> OnceResource<T, MiniserdeCodec>
+where
+    T: Send + Sync + 'static,
+    MiniserdeCodec: Encoder<T> + Decoder<T>,
+    <MiniserdeCodec as Encoder<T>>::Error: Debug,
+    <MiniserdeCodec as Decoder<T>>::Error: Debug,
+    <<MiniserdeCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
+        Debug,
+    <MiniserdeCodec as Encoder<T>>::Encoded: IntoEncodedString,
+    <MiniserdeCodec as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new_miniserde(
+        fut: impl Future<Output = T> + Send + 'static,
+    ) -> Self {
+        OnceResource::new_with_options(fut, false)
+    }
+
+    #[track_caller]
+    pub fn new_miniserde_blocking(
+        fut: impl Future<Output = T> + Send + 'static,
+    ) -> Self {
+        OnceResource::new_with_options(fut, true)
+    }
+}
+
+#[cfg(feature = "serde-lite")]
+impl<T> OnceResource<T, SerdeLite<JsonSerdeCodec>>
+where
+T: Send + Sync + 'static,
+    SerdeLite<JsonSerdeCodec>: Encoder<T> + Decoder<T>,
+    <SerdeLite<JsonSerdeCodec> as Encoder<T>>::Error: Debug, <SerdeLite<JsonSerdeCodec> as Decoder<T>>::Error: Debug,
+    <<SerdeLite<JsonSerdeCodec> as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
+    <SerdeLite<JsonSerdeCodec> as Encoder<T>>::Encoded: IntoEncodedString,
+    <SerdeLite<JsonSerdeCodec> as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new_serde_lite(
+fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        OnceResource::new_with_options(fut, false)
+    }
+
+    #[track_caller]
+    pub fn new_serde_lite_blocking(
+fut: impl Future<Output = T> + Send + 'static
+    ) -> Self
+    {
+        OnceResource::new_with_options(fut, true)
+    }
+}
+
+#[cfg(feature = "rkyv")]
+impl<T> OnceResource<T, RkyvCodec>
+where
+    T: Send + Sync + 'static,
+    RkyvCodec: Encoder<T> + Decoder<T>,
+    <RkyvCodec as Encoder<T>>::Error: Debug,
+    <RkyvCodec as Decoder<T>>::Error: Debug,
+    <<RkyvCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
+        Debug,
+    <RkyvCodec as Encoder<T>>::Encoded: IntoEncodedString,
+    <RkyvCodec as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[track_caller]
+    pub fn new_rkyv(fut: impl Future<Output = T> + Send + 'static) -> Self {
+        OnceResource::new_with_options(fut, false)
+    }
+
+    #[track_caller]
+    pub fn new_rkyv_blocking(
+        fut: impl Future<Output = T> + Send + 'static,
+    ) -> Self {
+        OnceResource::new_with_options(fut, true)
+    }
+}

leptos_server/src/resource.rs

@@ -13,7 +13,7 @@ use codee::{
 };
 use core::{fmt::Debug, marker::PhantomData};
 use futures::Future;
-use hydration_context::SerializedDataId;
+use hydration_context::{SerializedDataId, SharedContext};
 use reactive_graph::{
     computed::{
         ArcAsyncDerived, ArcMemo, AsyncDerived, AsyncDerivedFuture,
@@ -28,10 +28,14 @@ use std::{
     future::{pending, IntoFuture},
     ops::Deref,
     panic::Location,
-    sync::atomic::{AtomicBool, Ordering},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
 };
 
-static IS_SUPPRESSING_RESOURCE_LOAD: AtomicBool = AtomicBool::new(false);
+pub(crate) static IS_SUPPRESSING_RESOURCE_LOAD: AtomicBool =
+    AtomicBool::new(false);
 
 pub struct SuppressResourceLoad;
 
@@ -72,6 +76,38 @@ impl<T, Ser> Debug for ArcResource<T, Ser> {
     }
 }
 
+impl<T, Ser> From<ArcResource<T, Ser>> for Resource<T, Ser>
+where
+    T: Send + Sync,
+{
+    #[track_caller]
+    fn from(arc_resource: ArcResource<T, Ser>) -> Self {
+        Resource {
+            ser: PhantomData,
+            data: arc_resource.data.into(),
+            refetch: arc_resource.refetch.into(),
+            #[cfg(debug_assertions)]
+            defined_at: Location::caller(),
+        }
+    }
+}
+
+impl<T, Ser> From<Resource<T, Ser>> for ArcResource<T, Ser>
+where
+    T: Send + Sync,
+{
+    #[track_caller]
+    fn from(resource: Resource<T, Ser>) -> Self {
+        ArcResource {
+            ser: PhantomData,
+            data: resource.data.into(),
+            refetch: resource.refetch.into(),
+            #[cfg(debug_assertions)]
+            defined_at: Location::caller(),
+        }
+    }
+}
+
 impl<T, Ser> DefinedAt for ArcResource<T, Ser> {
     fn defined_at(&self) -> Option<&'static Location<'static>> {
         #[cfg(debug_assertions)]
@@ -125,22 +161,23 @@ where
         #[cfg(all(feature = "hydration", debug_assertions))]
         {
             use reactive_graph::{
-                computed::suspense::SuspenseContext, owner::use_context,
+                computed::suspense::SuspenseContext, effect::in_effect_scope,
+                owner::use_context,
             };
-            let suspense = use_context::<SuspenseContext>();
-            if suspense.is_none() {
+            if !in_effect_scope() && use_context::<SuspenseContext>().is_none()
+            {
                 let location = std::panic::Location::caller();
                 reactive_graph::log_warning(format_args!(
                     "At {location}, you are reading a resource in `hydrate` \
-                     mode outside a <Suspense/> or <Transition/>. This can \
-                     cause hydration mismatch errors and loses out on a \
-                     significant performance optimization. To fix this issue, \
-                     you can either: \n1. Wrap the place where you read the \
-                     resource in a <Suspense/> or <Transition/> component, or \
-                     \n2. Switch to using ArcLocalResource::new(), which will \
-                     wait to load the resource until the app is hydrated on \
-                     the client side. (This will have worse performance in \
-                     most cases.)",
+                     mode outside a <Suspense/> or <Transition/> or effect. \
+                     This can cause hydration mismatch errors and loses out \
+                     on a significant performance optimization. To fix this \
+                     issue, you can either: \n1. Wrap the place where you \
+                     read the resource in a <Suspense/> or <Transition/> \
+                     component, or \n2. Switch to using \
+                     ArcLocalResource::new(), which will wait to load the \
+                     resource until the app is hydrated on the client side. \
+                     (This will have worse performance in most cases.)",
                 ));
             }
         }
@@ -175,7 +212,7 @@ where
             .map(|sc| sc.next_id())
             .unwrap_or_default();
 
-        let initial = Self::initial_value(&id);
+        let initial = initial_value::<T, Ser>(&id, shared_context.as_ref());
         let is_ready = initial.is_some();
 
         let refetch = ArcRwSignal::new(0);
@@ -253,43 +290,53 @@ where
     pub fn refetch(&self) {
         *self.refetch.write() += 1;
     }
+}
 
-    #[inline(always)]
-    #[allow(unused)]
-    fn initial_value(id: &SerializedDataId) -> Option<T> {
-        #[cfg(feature = "hydration")]
-        {
-            use std::borrow::Borrow;
+#[inline(always)]
+#[allow(unused)]
+pub(crate) fn initial_value<T, Ser>(
+    id: &SerializedDataId,
+    shared_context: Option<&Arc<dyn SharedContext + Send + Sync>>,
+) -> Option<T>
+where
+    Ser: Encoder<T> + Decoder<T>,
+    <Ser as Encoder<T>>::Error: Debug,
+    <Ser as Decoder<T>>::Error: Debug,
+    <<Ser as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
+    <Ser as Encoder<T>>::Encoded: IntoEncodedString,
+    <Ser as Decoder<T>>::Encoded: FromEncodedStr,
+{
+    #[cfg(feature = "hydration")]
+    {
+        use std::borrow::Borrow;
 
-            let shared_context = Owner::current_shared_context();
-            if let Some(shared_context) = shared_context {
-                let value = shared_context.read_data(id);
-                if let Some(value) = value {
-                    let encoded =
-                        match <Ser as Decoder<T>>::Encoded::from_encoded_str(
-                            &value,
-                        ) {
-                            Ok(value) => value,
-                            Err(e) => {
-                                #[cfg(feature = "tracing")]
-                                tracing::error!("couldn't deserialize: {e:?}");
-                                return None;
-                            }
-                        };
-                    let encoded = encoded.borrow();
-                    match Ser::decode(encoded) {
-                        Ok(value) => return Some(value),
-                        #[allow(unused)]
+        let shared_context = Owner::current_shared_context();
+        if let Some(shared_context) = shared_context {
+            let value = shared_context.read_data(id);
+            if let Some(value) = value {
+                let encoded =
+                    match <Ser as Decoder<T>>::Encoded::from_encoded_str(&value)
+                    {
+                        Ok(value) => value,
                         Err(e) => {
                             #[cfg(feature = "tracing")]
                             tracing::error!("couldn't deserialize: {e:?}");
+                            return None;
                         }
+                    };
+                let encoded = encoded.borrow();
+                match Ser::decode(encoded) {
+                    Ok(value) => return Some(value),
+                    #[allow(unused)]
+                    Err(e) => {
+                        #[cfg(feature = "tracing")]
+                        tracing::error!("couldn't deserialize: {e:?}");
                     }
                 }
             }
         }
-        None
     }
+    None
 }
 
 impl<T, E, Ser> ArcResource<Result<T, E>, Ser>
@@ -627,22 +674,23 @@ where
         #[cfg(all(feature = "hydration", debug_assertions))]
         {
             use reactive_graph::{
-                computed::suspense::SuspenseContext, owner::use_context,
+                computed::suspense::SuspenseContext, effect::in_effect_scope,
+                owner::use_context,
             };
-            let suspense = use_context::<SuspenseContext>();
-            if suspense.is_none() {
+            if !in_effect_scope() && use_context::<SuspenseContext>().is_none()
+            {
                 let location = std::panic::Location::caller();
                 reactive_graph::log_warning(format_args!(
                     "At {location}, you are reading a resource in `hydrate` \
-                     mode outside a <Suspense/> or <Transition/>. This can \
-                     cause hydration mismatch errors and loses out on a \
-                     significant performance optimization. To fix this issue, \
-                     you can either: \n1. Wrap the place where you read the \
-                     resource in a <Suspense/> or <Transition/> component, or \
-                     \n2. Switch to using LocalResource::new(), which will \
-                     wait to load the resource until the app is hydrated on \
-                     the client side. (This will have worse performance in \
-                     most cases.)",
+                     mode outside a <Suspense/> or <Transition/> or effect. \
+                     This can cause hydration mismatch errors and loses out \
+                     on a significant performance optimization. To fix this \
+                     issue, you can either: \n1. Wrap the place where you \
+                     read the resource in a <Suspense/> or <Transition/> \
+                     component, or \n2. Switch to using LocalResource::new(), \
+                     which will wait to load the resource until the app is \
+                     hydrated on the client side. (This will have worse \
+                     performance in most cases.)",
                 ));
             }
         }

meta/Cargo.toml

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

meta/src/body.rs

@@ -2,7 +2,7 @@ use crate::ServerMetaContext;
 use leptos::{
     attr::NextAttribute,
     component, html,
-    reactive_graph::owner::use_context,
+    reactive::owner::use_context,
     tachys::{
         dom::document,
         html::attribute::Attribute,

meta/src/html.rs

@@ -2,7 +2,7 @@ use crate::ServerMetaContext;
 use leptos::{
     attr::NextAttribute,
     component, html,
-    reactive_graph::owner::use_context,
+    reactive::owner::use_context,
     tachys::{
         dom::document,
         html::attribute::Attribute,

meta/src/lib.rs

@@ -52,7 +52,7 @@ use leptos::{
     attr::NextAttribute,
     component,
     logging::debug_warn,
-    reactive_graph::owner::{provide_context, use_context},
+    reactive::owner::{provide_context, use_context},
     tachys::{
         dom::document,
         html::{

meta/src/stylesheet.rs

@@ -54,7 +54,7 @@ pub fn HashedStylesheet(
                 path.parent().map(|p| p.to_path_buf()).unwrap_or_default()
             })
             .unwrap_or_default()
-            .join(&options.hash_file);
+            .join(options.hash_file.as_ref());
         if hash_path.exists() {
             let hashes = std::fs::read_to_string(&hash_path)
                 .expect("failed to read hash file");

meta/src/title.rs

@@ -3,7 +3,7 @@ use leptos::{
     attr::Attribute,
     component,
     oco::Oco,
-    reactive_graph::{
+    reactive::{
         effect::RenderEffect,
         owner::{use_context, Owner},
     },

next_tuple/Cargo.toml

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

projects/session_auth_axum/Cargo.toml

@@ -30,23 +30,21 @@ sqlx = { version = "0.8.0", features = [
 ], optional = true }
 thiserror = "1.0"
 wasm-bindgen = "0.2.0"
-axum_session_auth = { version = "0.14.0", features = [
-  "sqlite-rustls",
-], optional = true }
-axum_session = { version = "0.14.0", features = [
-  "sqlite-rustls",
-], optional = true }
+axum_session_auth = { version = "0.14.0", features = [], optional = true }
+axum_session = { version = "0.14.0", features = [], optional = true }
+axum_session_sqlx = { version = "0.3.0", features = [ "sqlite", "tls-rustls"], optional = true }
 bcrypt = { version = "0.15.0", optional = true }
 async-trait = { version = "0.1.0", optional = true }
 
 [features]
 default = ["ssr"]
-hydrate = ["leptos/hydrate", "leptos_meta/hydrate", "leptos_router/hydrate"]
+hydrate = ["leptos/hydrate"]
 ssr = [
   "dep:axum",
   "dep:tower",
   "dep:tower-http",
   "dep:tokio",
+  "dep:axum_session_sqlx",
   "dep:axum_session_auth",
   "dep:axum_session",
   "dep:async-trait",

projects/session_auth_axum/src/auth.rs

@@ -28,9 +28,8 @@ impl Default for User {
 #[cfg(feature = "ssr")]
 pub mod ssr {
     pub use super::{User, UserPasshash};
-    pub use axum_session_auth::{
-        Authentication, HasPermission, SessionSqlitePool,
-    };
+    pub use axum_session_auth::{Authentication, HasPermission};
+    use axum_session_sqlx::SessionSqlitePool;
     pub use sqlx::SqlitePool;
     pub use std::collections::HashSet;
     pub type AuthSession = axum_session_auth::AuthSession<

projects/session_auth_axum/src/error_template.rs

@@ -8,10 +8,10 @@ use leptos_axum::ResponseOptions;
 #[component]
 pub fn ErrorTemplate(
     #[prop(optional)] outside_errors: Option<Errors>,
-    #[prop(optional)] errors: Option<RwSignal<Errors>>,
+    #[prop(optional)] errors: Option<ArcRwSignal<Errors>>,
 ) -> impl IntoView {
     let errors = match outside_errors {
-        Some(e) => RwSignal::new(e),
+        Some(e) => ArcRwSignal::new(e),
         None => match errors {
             Some(e) => e,
             None => panic!("No Errors found and we expected errors!"),

projects/session_auth_axum/src/fallback.rs

@@ -1,50 +0,0 @@
-use crate::{error_template::ErrorTemplate, errors::TodoAppError};
-use axum::{
-    body::Body,
-    extract::State,
-    http::{Request, Response, StatusCode, Uri},
-    response::{IntoResponse, Response as AxumResponse},
-};
-use leptos::{view, Errors, LeptosOptions};
-use tower::ServiceExt;
-use tower_http::services::ServeDir;
-
-pub async fn file_and_error_handler(
-    uri: Uri,
-    State(options): State<LeptosOptions>,
-    req: Request<Body>,
-) -> AxumResponse {
-    let root = options.site_root.clone();
-    let res = get_static_file(uri.clone(), &root).await.unwrap();
-
-    if res.status() == StatusCode::OK {
-        res.into_response()
-    } else {
-        let mut errors = Errors::default();
-        errors.insert_with_default_key(TodoAppError::NotFound);
-        let handler = leptos_axum::render_app_to_stream(
-            options.to_owned(),
-            move || view! {<ErrorTemplate outside_errors=errors.clone()/>},
-        );
-        handler(req).await.into_response()
-    }
-}
-
-async fn get_static_file(
-    uri: Uri,
-    root: &str,
-) -> Result<Response<Body>, (StatusCode, String)> {
-    let req = Request::builder()
-        .uri(uri.clone())
-        .body(Body::empty())
-        .unwrap();
-    // `ServeDir` implements `tower::Service` so we can call it with `tower::ServiceExt::oneshot`
-    // This path is relative to the cargo root
-    match ServeDir::new(root).oneshot(req).await {
-        Ok(res) => Ok(res.into_response()),
-        Err(err) => Err((
-            StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Something went wrong: {err}"),
-        )),
-    }
-}

projects/session_auth_axum/src/lib.rs

@@ -2,8 +2,6 @@ pub mod auth;
 pub mod error_template;
 pub mod errors;
 #[cfg(feature = "ssr")]
-pub mod fallback;
-#[cfg(feature = "ssr")]
 pub mod state;
 pub mod todo;
 
@@ -14,5 +12,5 @@ pub fn hydrate() {
     _ = console_log::init_with_level(log::Level::Debug);
     console_error_panic_hook::set_once();
 
-    leptos::mount_to_body(TodoApp);
+    leptos::mount::hydrate_body(TodoApp);
 }

projects/session_auth_axum/src/main.rs

@@ -7,14 +7,16 @@ use axum::{
     Router,
 };
 use axum_session::{SessionConfig, SessionLayer, SessionStore};
-use axum_session_auth::{AuthConfig, AuthSessionLayer, SessionSqlitePool};
-use leptos::{get_configuration, logging::log, provide_context};
+use axum_session_auth::{AuthConfig, AuthSessionLayer};
+use axum_session_sqlx::SessionSqlitePool;
+use leptos::{
+    config::get_configuration, logging::log, prelude::provide_context,
+};
 use leptos_axum::{
     generate_route_list, handle_server_fns_with_context, LeptosRoutes,
 };
 use session_auth_axum::{
     auth::{ssr::AuthSession, User},
-    fallback::file_and_error_handler,
     state::AppState,
     todo::*,
 };
@@ -40,19 +42,19 @@ async fn server_fn_handler(
 
 async fn leptos_routes_handler(
     auth_session: AuthSession,
-    State(app_state): State<AppState>,
+    state: State<AppState>,
     req: Request<AxumBody>,
 ) -> Response {
+    let State(app_state) = state.clone();
     let handler = leptos_axum::render_route_with_context(
-        app_state.leptos_options.clone(),
         app_state.routes.clone(),
         move || {
             provide_context(auth_session.clone());
             provide_context(app_state.pool.clone());
         },
-        TodoApp,
+        move || shell(app_state.leptos_options.clone()),
     );
-    handler(req).await.into_response()
+    handler(state, req).await.into_response()
 }
 
 #[tokio::main]
@@ -111,7 +113,7 @@ async fn main() {
             get(server_fn_handler).post(server_fn_handler),
         )
         .leptos_routes_with_handler(routes, get(leptos_routes_handler))
-        .fallback(file_and_error_handler)
+        .fallback(leptos_axum::file_and_error_handler::<AppState, _>(shell))
         .layer(
             AuthSessionLayer::<User, i64, SessionSqlitePool, SqlitePool>::new(
                 Some(pool.clone()),

projects/session_auth_axum/src/state.rs

@@ -1,6 +1,6 @@
 use axum::extract::FromRef;
-use leptos::LeptosOptions;
-use leptos_router::RouteListing;
+use leptos::prelude::LeptosOptions;
+use leptos_axum::AxumRouteListing;
 use sqlx::SqlitePool;
 
 /// This takes advantage of Axum's SubStates feature by deriving FromRef. This is the only way to have more than one
@@ -9,5 +9,5 @@ use sqlx::SqlitePool;
 pub struct AppState {
     pub leptos_options: LeptosOptions,
     pub pool: SqlitePool,
-    pub routes: Vec<RouteListing>,
+    pub routes: Vec<AxumRouteListing>,
 }

projects/session_auth_axum/src/todo.rs

@@ -1,7 +1,7 @@
 use crate::{auth::*, error_template::ErrorTemplate};
 use leptos::prelude::*;
 use leptos_meta::*;
-use leptos_router::*;
+use leptos_router::{components::*, *};
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -109,13 +109,33 @@ pub async fn delete_todo(id: u16) -> Result<(), ServerFnError> {
         .map(|_| ())?)
 }
 
+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/>
+                <link rel="stylesheet" id="leptos" href="/pkg/session_auth_axum.css"/>
+                <link rel="shortcut icon" type="image/ico" href="/favicon.ico"/>
+                <MetaTags/>
+            </head>
+            <body>
+                <TodoApp/>
+            </body>
+        </html>
+    }
+}
+
 #[component]
 pub fn TodoApp() -> impl IntoView {
-    let login = create_server_action::<Login>();
-    let logout = create_server_action::<Logout>();
-    let signup = create_server_action::<Signup>();
+    let login = ServerAction::<Login>::new();
+    let logout = ServerAction::<Logout>::new();
+    let signup = ServerAction::<Signup>::new();
 
-    let user = create_resource(
+    let user = Resource::new(
         move || {
             (
                 login.version().get(),
@@ -128,8 +148,6 @@ pub fn TodoApp() -> impl IntoView {
     provide_meta_context();
 
     view! {
-        <Link rel="shortcut icon" type_="image/ico" href="/favicon.ico"/>
-        <Stylesheet id="leptos" href="/pkg/session_auth_axum.css"/>
         <Router>
             <header>
                 <A href="/">
@@ -149,7 +167,7 @@ pub fn TodoApp() -> impl IntoView {
                                         ", "
                                         <span>{format!("Login error: {}", e)}</span>
                                     }
-                                        .into_view()
+                                        .into_any()
                                 }
                                 Ok(None) => {
                                     view! {
@@ -159,7 +177,7 @@ pub fn TodoApp() -> impl IntoView {
                                         ", "
                                         <span>"Logged out."</span>
                                     }
-                                        .into_view()
+                                        .into_any()
                                 }
                                 Ok(Some(user)) => {
                                     view! {
@@ -169,7 +187,7 @@ pub fn TodoApp() -> impl IntoView {
                                             {format!("Logged in as: {} ({})", user.username, user.id)}
                                         </span>
                                     }
-                                        .into_view()
+                                        .into_any()
                                 }
                             })
                     }}
@@ -178,13 +196,15 @@ pub fn TodoApp() -> impl IntoView {
             </header>
             <hr/>
             <main>
-                <Routes>
+                <FlatRoutes fallback=|| "Not found.">
                     // Route
-                    <Route path="" view=Todos/>
-                    <Route path="signup" view=move || view! { <Signup action=signup/> }/>
-                    <Route path="login" view=move || view! { <Login action=login/> }/>
-                    <Route
-                        path="settings"
+                    <Route path=path!("") view=Todos/>
+                    <Route path=path!("signup") view=move || view! { <Signup action=signup/> }/>
+                    <Route path=path!("login") view=move || view! { <Login action=login/> }/>
+                    <ProtectedRoute
+                        path=path!("settings")
+                        condition=move || user.get().map(|r| r.ok().flatten().is_some())
+                        redirect_path=|| "/"
                         view=move || {
                             view! {
                                 <h1>"Settings"</h1>
@@ -193,7 +213,7 @@ pub fn TodoApp() -> impl IntoView {
                         }
                     />
 
-                </Routes>
+                </FlatRoutes>
             </main>
         </Router>
     }
@@ -201,12 +221,12 @@ pub fn TodoApp() -> impl IntoView {
 
 #[component]
 pub fn Todos() -> impl IntoView {
-    let add_todo = create_server_multi_action::<AddTodo>();
-    let delete_todo = create_server_action::<DeleteTodo>();
+    let add_todo = ServerMultiAction::<AddTodo>::new();
+    let delete_todo = ServerAction::<DeleteTodo>::new();
     let submissions = add_todo.submissions();
 
     // list of todos is loaded from the server in reaction to changes
-    let todos = create_resource(
+    let todos = Resource::new(
         move || (add_todo.version().get(), delete_todo.version().get()),
         move |_| get_todos(),
     );
@@ -231,11 +251,11 @@ pub fn Todos() -> impl IntoView {
                                             view! {
                                                 <pre class="error">"Server Error: " {e.to_string()}</pre>
                                             }
-                                                .into_view()
+                                                .into_any()
                                         }
                                         Ok(todos) => {
                                             if todos.is_empty() {
-                                                view! { <p>"No tasks were found."</p> }.into_view()
+                                                view! { <p>"No tasks were found."</p> }.into_any()
                                             } else {
                                                 todos
                                                     .into_iter()
@@ -252,10 +272,11 @@ pub fn Todos() -> impl IntoView {
                                                         }
                                                     })
                                                     .collect_view()
+                                                    .into_any()
                                             }
                                         }
                                     })
-                                    .unwrap_or_default()
+                                    .unwrap_or(().into_any())
                             }
                         };
                         let pending_todos = move || {
@@ -266,7 +287,7 @@ pub fn Todos() -> impl IntoView {
                                 .map(|submission| {
                                     view! {
                                         <li class="pending">
-                                            {move || submission.input.get().map(|data| data.title)}
+                                            {move || submission.input().get().map(|data| data.title)}
                                         </li>
                                     }
                                 })
@@ -282,9 +303,7 @@ pub fn Todos() -> impl IntoView {
 }
 
 #[component]
-pub fn Login(
-    action: Action<Login, Result<(), ServerFnError>>,
-) -> impl IntoView {
+pub fn Login(action: ServerAction<Login>) -> impl IntoView {
     view! {
         <ActionForm action=action>
             <h1>"Log In"</h1>
@@ -317,9 +336,7 @@ pub fn Login(
 }
 
 #[component]
-pub fn Signup(
-    action: Action<Signup, Result<(), ServerFnError>>,
-) -> impl IntoView {
+pub fn Signup(action: ServerAction<Signup>) -> impl IntoView {
     view! {
         <ActionForm action=action>
             <h1>"Sign Up"</h1>
@@ -362,9 +379,7 @@ pub fn Signup(
 }
 
 #[component]
-pub fn Logout(
-    action: Action<Logout, Result<(), ServerFnError>>,
-) -> impl IntoView {
+pub fn Logout(action: ServerAction<Logout>) -> impl IntoView {
     view! {
         <div id="loginbox">
             <ActionForm action=action>

reactive_graph/Cargo.toml

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

reactive_graph/src/actions/action.rs

@@ -1,9 +1,12 @@
 use crate::{
     computed::{ArcMemo, Memo},
     diagnostics::is_suppressing_resource_load,
-    owner::{ArenaItem, FromLocal, LocalStorage, Storage, SyncStorage},
+    owner::{
+        ArcStoredValue, ArenaItem, FromLocal, LocalStorage, Storage,
+        SyncStorage,
+    },
     signal::{ArcRwSignal, RwSignal},
-    traits::{DefinedAt, Dispose, Get, GetUntracked, Update},
+    traits::{DefinedAt, Dispose, Get, GetUntracked, GetValue, Set, Update},
     unwrap_signal,
 };
 use any_spawner::Executor;
@@ -93,6 +96,7 @@ pub struct ArcAction<I, O> {
     input: ArcRwSignal<Option<I>>,
     value: ArcRwSignal<Option<O>>,
     version: ArcRwSignal<usize>,
+    dispatched: ArcStoredValue<usize>,
     #[allow(clippy::complexity)]
     action_fn: Arc<
         dyn Fn(&I) -> Pin<Box<dyn Future<Output = O> + Send>> + Send + Sync,
@@ -108,6 +112,7 @@ impl<I, O> Clone for ArcAction<I, O> {
             input: self.input.clone(),
             value: self.value.clone(),
             version: self.version.clone(),
+            dispatched: self.dispatched.clone(),
             action_fn: self.action_fn.clone(),
             #[cfg(debug_assertions)]
             defined_at: self.defined_at,
@@ -191,11 +196,21 @@ where
             input: Default::default(),
             value: ArcRwSignal::new(value),
             version: Default::default(),
+            dispatched: Default::default(),
             action_fn: Arc::new(move |input| Box::pin(action_fn(input))),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
         }
     }
+
+    /// Clears the value of the action, setting its current value to `None`.
+    ///
+    /// This has no other effect: i.e., it will not cancel in-flight actions, set the
+    /// input, etc.
+    #[track_caller]
+    pub fn clear(&self) {
+        self.value.set(None);
+    }
 }
 
 /// A handle that allows aborting an in-flight action. It is returned from [`Action::dispatch`] or
@@ -230,14 +245,14 @@ where
 
             // Update the state before loading
             self.in_flight.update(|n| *n += 1);
-            let current_version =
-                self.version.try_get_untracked().unwrap_or_default();
+            let current_version = self.dispatched.get_value();
             self.input.try_update(|inp| *inp = Some(input));
 
             // Spawn the task
             crate::spawn({
                 let input = self.input.clone();
                 let version = self.version.clone();
+                let dispatched = self.dispatched.clone();
                 let value = self.value.clone();
                 let in_flight = self.in_flight.clone();
                 async move {
@@ -249,7 +264,7 @@ where
                         // otherwise, update the value
                         result = fut => {
                             in_flight.update(|n| *n = n.saturating_sub(1));
-                            let is_latest = version.get_untracked() <= current_version;
+                            let is_latest = dispatched.get_value() <= current_version;
                             if is_latest {
                                 version.update(|n| *n += 1);
                                 value.update(|n| *n = Some(result));
@@ -282,8 +297,7 @@ where
 
             // Update the state before loading
             self.in_flight.update(|n| *n += 1);
-            let current_version =
-                self.version.try_get_untracked().unwrap_or_default();
+            let current_version = self.dispatched.get_value();
             self.input.try_update(|inp| *inp = Some(input));
 
             // Spawn the task
@@ -291,6 +305,7 @@ where
                 let input = self.input.clone();
                 let version = self.version.clone();
                 let value = self.value.clone();
+                let dispatched = self.dispatched.clone();
                 let in_flight = self.in_flight.clone();
                 async move {
                     select! {
@@ -301,7 +316,7 @@ where
                         // otherwise, update the value
                         result = fut => {
                             in_flight.update(|n| *n = n.saturating_sub(1));
-                            let is_latest = version.get_untracked() <= current_version;
+                            let is_latest = dispatched.get_value() <= current_version;
                             if is_latest {
                                 version.update(|n| *n += 1);
                                 value.update(|n| *n = Some(result));
@@ -351,6 +366,7 @@ where
             input: Default::default(),
             value: ArcRwSignal::new(value),
             version: Default::default(),
+            dispatched: Default::default(),
             action_fn: Arc::new(move |input| {
                 Box::pin(SendWrapper::new(action_fn(input)))
             }),
@@ -671,6 +687,22 @@ where
     }
 }
 
+impl<I, O, S> Action<I, O, S>
+where
+    I: 'static,
+    O: 'static,
+    S: Storage<ArcAction<I, O>>,
+{
+    /// Clears the value of the action, setting its current value to `None`.
+    ///
+    /// This has no other effect: i.e., it will not cancel in-flight actions, set the
+    /// input, etc.
+    #[track_caller]
+    pub fn clear(&self) {
+        self.inner.try_with_value(|inner| inner.value.set(None));
+    }
+}
+
 impl<I, O> Action<I, O, LocalStorage>
 where
     I: 'static,

reactive_graph/src/computed.rs

@@ -15,6 +15,7 @@ use crate::{
 };
 pub use arc_memo::*;
 pub use async_derived::*;
+pub(crate) use inner::MemoInner;
 pub use memo::*;
 pub use selector::*;
 

reactive_graph/src/computed/async_derived/arc_async_derived.rs

@@ -19,7 +19,7 @@ use crate::{
     },
     traits::{
         DefinedAt, IsDisposed, Notify, ReadUntracked, Track, UntrackableGuard,
-        Writeable,
+        Write,
     },
     transition::AsyncTransition,
 };
@@ -534,11 +534,11 @@ impl<T: 'static> ArcAsyncDerived<T> {
 
     /// Returns a `Future` that is ready when this resource has next finished loading.
     pub fn ready(&self) -> AsyncDerivedReadyFuture {
-        AsyncDerivedReadyFuture {
-            source: self.to_any_source(),
-            loading: Arc::clone(&self.loading),
-            wakers: Arc::clone(&self.wakers),
-        }
+        AsyncDerivedReadyFuture::new(
+            self.to_any_source(),
+            &self.loading,
+            &self.wakers,
+        )
     }
 }
 
@@ -600,7 +600,7 @@ impl<T: 'static> Notify for ArcAsyncDerived<T> {
     }
 }
 
-impl<T: 'static> Writeable for ArcAsyncDerived<T> {
+impl<T: 'static> Write for ArcAsyncDerived<T> {
     type Value = Option<T>;
 
     fn try_write(&self) -> Option<impl UntrackableGuard<Target = Self::Value>> {

reactive_graph/src/computed/async_derived/async_derived.rs

@@ -8,7 +8,7 @@ use crate::{
     signal::guards::{AsyncPlain, ReadGuard, WriteGuard},
     traits::{
         DefinedAt, Dispose, IsDisposed, Notify, ReadUntracked,
-        UntrackableGuard, Writeable,
+        UntrackableGuard, Write,
     },
     unwrap_signal,
 };
@@ -109,6 +109,19 @@ where
     }
 }
 
+impl<T> From<AsyncDerived<T>> for ArcAsyncDerived<T>
+where
+    T: Send + Sync + 'static,
+{
+    #[track_caller]
+    fn from(value: AsyncDerived<T>) -> Self {
+        value
+            .inner
+            .try_get_value()
+            .unwrap_or_else(unwrap_signal!(value))
+    }
+}
+
 impl<T> FromLocal<ArcAsyncDerived<T>> for AsyncDerived<T, LocalStorage>
 where
     T: 'static,
@@ -300,7 +313,7 @@ where
     }
 }
 
-impl<T, S> Writeable for AsyncDerived<T, S>
+impl<T, S> Write for AsyncDerived<T, S>
 where
     T: 'static,
     S: Storage<ArcAsyncDerived<T>>,

reactive_graph/src/computed/async_derived/future_impls.rs

@@ -34,6 +34,21 @@ pub struct AsyncDerivedReadyFuture {
     pub(crate) wakers: Arc<RwLock<Vec<Waker>>>,
 }
 
+impl AsyncDerivedReadyFuture {
+    /// Creates a new [`Future`] that will be ready when the given resource is ready.
+    pub fn new(
+        source: AnySource,
+        loading: &Arc<AtomicBool>,
+        wakers: &Arc<RwLock<Vec<Waker>>>,
+    ) -> Self {
+        AsyncDerivedReadyFuture {
+            source,
+            loading: Arc::clone(loading),
+            wakers: Arc::clone(wakers),
+        }
+    }
+}
+
 impl Future for AsyncDerivedReadyFuture {
     type Output = ();
 

reactive_graph/src/computed/async_derived/mod.rs

@@ -58,7 +58,7 @@ impl<Fut: Future> Future for ScopedFuture<Fut> {
 pub mod suspense {
     use crate::{
         signal::ArcRwSignal,
-        traits::{Update, Writeable},
+        traits::{Update, Write},
     };
     use futures::channel::oneshot::Sender;
     use or_poisoned::OrPoisoned;

reactive_graph/src/diagnostics.rs

@@ -53,7 +53,8 @@ impl Drop for SpecialNonReactiveZoneGuard {
 }
 
 pin_project! {
-    pub(crate) struct SpecialNonReactiveFuture<Fut> {
+    #[doc(hidden)]
+    pub struct SpecialNonReactiveFuture<Fut> {
         #[pin]
         inner: Fut
     }

reactive_graph/src/effect/effect.rs

@@ -13,7 +13,7 @@ use futures::StreamExt;
 use or_poisoned::OrPoisoned;
 use std::{
     mem,
-    sync::{Arc, RwLock},
+    sync::{atomic::AtomicBool, Arc, RwLock},
 };
 
 /// Effects run a certain chunk of code whenever the signals they depend on change.
@@ -109,6 +109,29 @@ fn effect_base() -> (Receiver, Owner, Arc<RwLock<EffectInner>>) {
     (rx, owner, inner)
 }
 
+thread_local! {
+    static EFFECT_SCOPE_ACTIVE: AtomicBool = const { AtomicBool::new(false) };
+}
+
+/// Returns whether the current thread is currently running an effect.
+pub fn in_effect_scope() -> bool {
+    EFFECT_SCOPE_ACTIVE
+        .with(|scope| scope.load(std::sync::atomic::Ordering::Relaxed))
+}
+
+/// Set a static to true whilst running the given function.
+/// [`is_in_effect_scope`] will return true whilst the function is running.
+fn run_in_effect_scope<T>(fun: impl FnOnce() -> T) -> T {
+    // For the theoretical nested case, set back to initial value rather than false:
+    let initial = EFFECT_SCOPE_ACTIVE
+        .with(|scope| scope.swap(true, std::sync::atomic::Ordering::Relaxed));
+    let result = fun();
+    EFFECT_SCOPE_ACTIVE.with(|scope| {
+        scope.store(initial, std::sync::atomic::Ordering::Relaxed)
+    });
+    result
+}
+
 impl<S> Effect<S>
 where
     S: Storage<StoredEffect>,
@@ -157,7 +180,9 @@ impl Effect<LocalStorage> {
                             let old_value =
                                 mem::take(&mut *value.write().or_poisoned());
                             let new_value = owner.with_cleanup(|| {
-                                subscriber.with_observer(|| fun.run(old_value))
+                                subscriber.with_observer(|| {
+                                    run_in_effect_scope(|| fun.run(old_value))
+                                })
                             });
                             *value.write().or_poisoned() = Some(new_value);
                         }
@@ -375,7 +400,9 @@ impl Effect<SyncStorage> {
                             let old_value =
                                 mem::take(&mut *value.write().or_poisoned());
                             let new_value = owner.with_cleanup(|| {
-                                subscriber.with_observer(|| fun.run(old_value))
+                                subscriber.with_observer(|| {
+                                    run_in_effect_scope(|| fun.run(old_value))
+                                })
                             });
                             *value.write().or_poisoned() = Some(new_value);
                         }
@@ -419,7 +446,9 @@ impl Effect<SyncStorage> {
                         let old_value =
                             mem::take(&mut *value.write().or_poisoned());
                         let new_value = owner.with_cleanup(|| {
-                            subscriber.with_observer(|| fun.run(old_value))
+                            subscriber.with_observer(|| {
+                                run_in_effect_scope(|| fun.run(old_value))
+                            })
                         });
                         *value.write().or_poisoned() = Some(new_value);
                     }