Add cloned_async and peek_async

Author: mcmah309

packages/hooks/src/use_resource.rs

@@ -475,7 +475,8 @@ impl<T> Resource<T> {
     ///    let guard1 = resource1.read_async().await;
     ///    drop(guard1);
     ///    let guard2 = resource2.read_async().await;
-    ///    // Value exists
+    ///    // Value exists if used inside another `use_resource`,
+    ///    // since otherwise the resource would have restarted
     ///    let guard1 = resource1.read().as_ref().unwrap();
     ///    ```
     ///
@@ -521,6 +522,111 @@ impl<T> Resource<T> {
         }
         read.map(|e| std::cell::Ref::map(e, |option| option.as_ref().unwrap()))
     }
+
+    /// Asynchronously wait for the resource to be ready and return a clone of its value.
+    ///
+    /// The primary advantage of `cloned_async` is that it avoids the complex
+    /// borrowing rules of `read_async` by immediately cloning the value, allowing
+    /// it to be used freely across further `.await` points.
+    ///
+    /// **This method requires `T` to implement `Clone`.**
+    ///
+    /// ## Example
+    ///
+    /// ```rust,no_run
+    /// # use dioxus::prelude::*;
+    /// #[derive(Clone, Debug)]
+    /// struct User { id: u32, name: String }
+    ///
+    /// fn App() -> Element {
+    ///     let user_id = use_signal(|| 42);
+    ///     let user_resource = use_resource(move || async move {
+    ///         // Some expensive fetch that returns a User
+    ///         fetch_user(*user_id.read()).await
+    ///     });
+    ///     
+    ///     let cloned_user = use_resource(move || async move {
+    ///         // Wait for user_resource, clone the User struct, and then continue
+    ///         let user: User = user_resource.cloned_async().await;
+    ///         
+    ///         // Safe to use 'user' across async boundaries
+    ///         log_user_activity(user.id).await;
+    ///         
+    ///         // Return the cloned value for this resource
+    ///         user
+    ///     });
+    ///     
+    ///     rsx! {
+    ///         "Fetched User: {cloned_user:?}"
+    ///     }
+    /// }
+    /// # async fn fetch_user(_id: u32) -> User { User { id: 42, name: "Alice".to_string() } }
+    /// # async fn log_user_activity(_id: u32) {}
+    /// ```
+    pub async fn cloned_async<'a>(&'a self) -> T
+    where
+        T: Clone,
+    {
+        let mut read: generational_box::GenerationalRef<std::cell::Ref<'a, Option<T>>> =
+            self.read();
+        while read.is_none() {
+            drop(read);
+            let _: () = (*self).await;
+            read = self.read();
+        }
+        read.as_ref().unwrap().clone()
+    }
+
+    /// Asynchronously wait for the resource to be ready and return a guard to its value, *without* subscribing the current component.
+    ///
+    /// This method is identical to `read_async`, but uses `peek()` internally instead of `read()`.
+    /// This means the component rendering this code **will not** be re-rendered when the resource value changes.
+    ///
+    /// ## Important: Handling Guards Across Await Points
+    ///
+    /// Like `read_async`, **never hold the returned guard across await points.**
+    /// You must drop the guard or clone the data before awaiting.
+    ///
+    /// ## Example
+    ///
+    /// Reading a prerequisite resource without causing a re-render:
+    ///
+    /// ```rust,no_run
+    /// # use dioxus::prelude::*;
+    /// #[derive(Clone, Debug)]
+    /// struct Config { version: String }
+    ///
+    /// fn App() -> Element {
+    ///     let config_resource = use_resource(|| async { fetch_config().await });
+    ///     
+    ///     let final_data = use_resource(move || async move {
+    ///         // Use peek_async to wait for the config, but not subscribe this
+    ///         // resource's internal future to config_resource's changes.
+    ///         let config_guard = config_resource.peek_async().await;
+    ///         let version = config_guard.version.clone();
+    ///         drop(config_guard); // Drop guard
+    ///         
+    ///         // Now safe to proceed
+    ///         fetch_data_for_version(&version).await
+    ///     });
+    ///     
+    ///     rsx! { "Data: {final_data:?}" }
+    /// }
+    /// # async fn fetch_config() -> Config { Config { version: "v1".to_string() } }
+    /// # async fn fetch_data_for_version(_v: &str) -> String { "Some Data".to_string() }
+    /// ```
+    pub async fn peek_async<'a>(
+        &'a self,
+    ) -> generational_box::GenerationalRef<std::cell::Ref<'a, T>> {
+        let mut peek: generational_box::GenerationalRef<std::cell::Ref<'a, Option<T>>> =
+            self.peek();
+        while peek.is_none() {
+            drop(peek);
+            let _: () = (*self).await;
+            peek = self.peek();
+        }
+        peek.map(|e| std::cell::Ref::map(e, |option| option.as_ref().unwrap()))
+    }
 }
 
 impl<T, E> Resource<Result<T, E>> {