Merge branch 'main' into immediate-effect

Author: gbj

any_error/src/lib.rs

@@ -8,7 +8,8 @@ use std::{
     cell::RefCell,
     error,
     fmt::{self, Display},
-    future::Future, ops,
+    future::Future,
+    ops,
     pin::Pin,
     sync::Arc,
     task::{Context, Poll},
@@ -107,7 +108,9 @@ pub fn get_error_hook() -> Option<Arc<dyn ErrorHook>> {
 
 /// Sets the current thread-local error hook, which will be invoked when [`throw`] is called.
 pub fn set_error_hook(hook: Arc<dyn ErrorHook>) -> ResetErrorHookOnDrop {
-    ResetErrorHookOnDrop(ERROR_HOOK.with_borrow_mut(|this| this.replace(hook)))
+    ResetErrorHookOnDrop(
+        ERROR_HOOK.with_borrow_mut(|this| Option::replace(this, hook)),
+    )
 }
 
 /// Invokes the error hook set by [`set_error_hook`] with the given error.

examples/server_fns_axum/Cargo.toml

@@ -22,20 +22,20 @@ log = "0.4.22"
 simple_logger = "5.0"
 serde = { version = "1.0", features = ["derive"] }
 axum = { version = "0.7.5", optional = true }
-tower = { version = "0.4.13", optional = true }
-tower-http = { version = "0.5.2", features = [
+tower = { version = "0.5.2", optional = true }
+tower-http = { version = "0.6.2", features = [
   "fs",
   "tracing",
   "trace",
 ], optional = true }
 tokio = { version = "1.39", features = ["full"], optional = true }
-thiserror = "1.0"
+thiserror = "2.0.11"
 wasm-bindgen = "0.2.93"
 serde_toml = "0.0.1"
 toml = "0.8.19"
 web-sys = { version = "0.3.70", features = ["FileList", "File"] }
-strum = { version = "0.26.3", features = ["strum_macros", "derive"] }
-notify = { version = "6.1", optional = true }
+strum = { version = "0.27.1", features = ["strum_macros", "derive"] }
+notify = { version = "8.0", optional = true }
 pin-project-lite = "0.2.14"
 dashmap = { version = "6.0", optional = true }
 once_cell = { version = "1.19", optional = true }

integrations/axum/src/lib.rs

@@ -299,6 +299,9 @@ pub fn generate_request_and_parts(
 ///         .await
 ///         .unwrap();
 /// }
+///
+/// # #[cfg(not(feature = "default"))]
+/// # fn main() { }
 /// ```
 /// Leptos provides a generic implementation of `handle_server_fns`. If access to more specific parts of the Request is desired,
 /// you can specify your own server fn handler based on this one and give it it's own route in the server macro.
@@ -469,6 +472,9 @@ pub type PinnedHtmlStream =
 ///         .await
 ///         .unwrap();
 /// }
+///
+/// # #[cfg(not(feature = "default"))]
+/// # fn main() { }
 /// ```
 ///
 /// ## Provided Context Types
@@ -555,6 +561,9 @@ where
 ///         .await
 ///         .unwrap();
 /// }
+///
+/// # #[cfg(not(feature = "default"))]
+/// # fn main() { }
 /// ```
 ///
 /// ## Provided Context Types
@@ -961,6 +970,9 @@ fn provide_contexts(
 ///         .await
 ///         .unwrap();
 /// }
+///
+/// # #[cfg(not(feature = "default"))]
+/// # fn main() { }
 /// ```
 ///
 /// ## Provided Context Types

leptos_server/src/local_resource.rs

@@ -12,7 +12,9 @@ use reactive_graph::{
         guards::{AsyncPlain, ReadGuard},
         ArcRwSignal, RwSignal,
     },
-    traits::{DefinedAt, IsDisposed, ReadUntracked, Track, Update, Write},
+    traits::{
+        DefinedAt, IsDisposed, ReadUntracked, Track, Update, With, Write,
+    },
 };
 use send_wrapper::SendWrapper;
 use std::{
@@ -91,6 +93,34 @@ impl<T> ArcLocalResource<T> {
     pub fn refetch(&self) {
         *self.refetch.write() += 1;
     }
+
+    /// Synchronously, reactively reads the current value of the resource and applies the function
+    /// `f` to its value if it is `Some(_)`.
+    #[track_caller]
+    pub fn map<U>(&self, f: impl FnOnce(&SendWrapper<T>) -> U) -> Option<U>
+    where
+        T: 'static,
+    {
+        self.data.try_with(|n| n.as_ref().map(f))?
+    }
+}
+
+impl<T, E> ArcLocalResource<Result<T, E>>
+where
+    T: 'static,
+    E: Clone + 'static,
+{
+    /// Applies the given function when a resource that returns `Result<T, E>`
+    /// has resolved and loaded an `Ok(_)`, rather than requiring nested `.map()`
+    /// calls over the `Option<Result<_, _>>` returned by the resource.
+    ///
+    /// This is useful when used with features like server functions, in conjunction
+    /// with `<ErrorBoundary/>` and `<Suspense/>`, when these other components are
+    /// left to handle the `None` and `Err(_)` states.
+    #[track_caller]
+    pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E>> {
+        self.map(|data| data.as_ref().map(f).map_err(|e| e.clone()))
+    }
 }
 
 impl<T> IntoFuture for ArcLocalResource<T>

leptos_server/src/once_resource.rs

@@ -168,6 +168,41 @@ where
 
         data
     }
+
+    /// Synchronously, reactively reads the current value of the resource and applies the function
+    /// `f` to its value if it is `Some(_)`.
+    #[track_caller]
+    pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U>
+    where
+        T: Send + Sync + 'static,
+    {
+        self.try_with(|n| n.as_ref().map(f))?
+    }
+}
+
+impl<T, E, Ser> ArcOnceResource<Result<T, E>, Ser>
+where
+    Ser: Encoder<Result<T, E>> + Decoder<Result<T, E>>,
+    <Ser as Encoder<Result<T, E>>>::Error: Debug,
+    <Ser as Decoder<Result<T, E>>>::Error: Debug,
+    <<Ser as Decoder<Result<T, E>>>::Encoded as FromEncodedStr>::DecodingError:
+        Debug,
+    <Ser as Encoder<Result<T, E>>>::Encoded: IntoEncodedString,
+    <Ser as Decoder<Result<T, E>>>::Encoded: FromEncodedStr,
+    T: Send + Sync + 'static,
+    E: Send + Sync + Clone + 'static,
+{
+    /// Applies the given function when a resource that returns `Result<T, E>`
+    /// has resolved and loaded an `Ok(_)`, rather than requiring nested `.map()`
+    /// calls over the `Option<Result<_, _>>` returned by the resource.
+    ///
+    /// This is useful when used with features like server functions, in conjunction
+    /// with `<ErrorBoundary/>` and `<Suspense/>`, when these other components are
+    /// left to handle the `None` and `Err(_)` states.
+    #[track_caller]
+    pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E>> {
+        self.map(|data| data.as_ref().map(f).map_err(|e| e.clone()))
+    }
 }
 
 impl<T, Ser> ArcOnceResource<T, Ser> {
@@ -534,6 +569,37 @@ where
             defined_at,
         }
     }
+
+    /// Synchronously, reactively reads the current value of the resource and applies the function
+    /// `f` to its value if it is `Some(_)`.
+    pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U> {
+        self.try_with(|n| n.as_ref().map(|n| Some(f(n))))?.flatten()
+    }
+}
+
+impl<T, E, Ser> OnceResource<Result<T, E>, Ser>
+where
+    Ser: Encoder<Result<T, E>> + Decoder<Result<T, E>>,
+    <Ser as Encoder<Result<T, E>>>::Error: Debug,
+    <Ser as Decoder<Result<T, E>>>::Error: Debug,
+    <<Ser as Decoder<Result<T, E>>>::Encoded as FromEncodedStr>::DecodingError:
+        Debug,
+    <Ser as Encoder<Result<T, E>>>::Encoded: IntoEncodedString,
+    <Ser as Decoder<Result<T, E>>>::Encoded: FromEncodedStr,
+    T: Send + Sync + 'static,
+    E: Send + Sync + Clone + 'static,
+{
+    /// Applies the given function when a resource that returns `Result<T, E>`
+    /// has resolved and loaded an `Ok(_)`, rather than requiring nested `.map()`
+    /// calls over the `Option<Result<_, _>>` returned by the resource.
+    ///
+    /// This is useful when used with features like server functions, in conjunction
+    /// with `<ErrorBoundary/>` and `<Suspense/>`, when these other components are
+    /// left to handle the `None` and `Err(_)` states.
+    #[track_caller]
+    pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E>> {
+        self.map(|data| data.as_ref().map(f).map_err(|e| e.clone()))
+    }
 }
 
 impl<T, Ser> OnceResource<T, Ser>

reactive_graph/src/owner.rs

@@ -207,7 +207,9 @@ impl Owner {
 
     /// Runs the given function with this as the current `Owner`.
     pub fn with<T>(&self, fun: impl FnOnce() -> T) -> T {
-        let prev = { OWNER.with(|o| (*o.borrow_mut()).replace(self.clone())) };
+        let prev = {
+            OWNER.with(|o| Option::replace(&mut *o.borrow_mut(), self.clone()))
+        };
         #[cfg(feature = "sandboxed-arenas")]
         Arena::set(&self.inner.read().or_poisoned().arena);
         let val = fun();

reactive_graph/src/transition.rs

@@ -37,8 +37,10 @@ impl AsyncTransition {
         let (tx, rx) = mpsc::channel();
         let global_transition = global_transition();
         let inner = TransitionInner { tx };
-        let prev =
-            (*global_transition.write().or_poisoned()).replace(inner.clone());
+        let prev = Option::replace(
+            &mut *global_transition.write().or_poisoned(),
+            inner.clone(),
+        );
         let value = action().await;
         _ = std::mem::replace(
             &mut *global_transition.write().or_poisoned(),

reactive_stores/src/arc_field.rs

@@ -38,6 +38,20 @@ where
     track_field: Arc<dyn Fn() + Send + Sync>,
 }
 
+impl<T> Debug for ArcField<T>
+where
+    T: 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut f = f.debug_struct("ArcField");
+        #[cfg(any(debug_assertions, leptos_debuginfo))]
+        let f = f.field("defined_at", &self.defined_at);
+        f.field("path", &self.path)
+            .field("trigger", &self.trigger)
+            .finish()
+    }
+}
+
 pub struct StoreFieldReader<T>(Box<dyn Deref<Target = T>>);
 
 impl<T> StoreFieldReader<T> {

reactive_stores/src/field.rs

@@ -31,6 +31,19 @@ where
     inner: ArenaItem<ArcField<T>, S>,
 }
 
+impl<T, S> Debug for Field<T, S>
+where
+    T: 'static,
+    S: Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut f = f.debug_struct("Field");
+        #[cfg(any(debug_assertions, leptos_debuginfo))]
+        let f = f.field("defined_at", &self.defined_at);
+        f.field("inner", &self.inner).finish()
+    }
+}
+
 impl<T, S> StoreField for Field<T, S>
 where
     S: Storage<ArcField<T>>,

router/src/location/mod.rs

@@ -91,7 +91,9 @@ impl Url {
             path.push_str(&self.search);
         }
         if !self.hash.is_empty() {
-            path.push('#');
+            if !self.hash.starts_with('#') {
+                path.push('#');
+            }
             path.push_str(&self.hash);
         }
         path