Merge branch 'main' into resource-dependancies

packages/hooks/src/use_context.rs

@@ -15,6 +15,9 @@ pub fn try_use_context<T: 'static + Clone>() -> Option<T> {
 ///
 /// Does not regenerate the value if the value is changed at the parent.
 /// ```rust
+/// # use dioxus::prelude::*;
+/// # #[derive(Clone, Copy, PartialEq, Debug)]
+/// # enum Theme { Dark, Light }
 /// fn Parent() -> Element {
 ///     use_context_provider(|| Theme::Dark);
 ///     rsx! { Child {} }
@@ -38,6 +41,7 @@ pub fn use_context<T: 'static + Clone>() -> T {
 /// drilling, using a context provider with a Signal inside is a good way to provide global/shared
 /// state in your app:
 /// ```rust
+/// # use dioxus::prelude::*;
 ///fn app() -> Element {
 ///    use_context_provider(|| Signal::new(0));
 ///    rsx! { Child {} }
@@ -45,7 +49,7 @@ pub fn use_context<T: 'static + Clone>() -> T {
 /// // This component does read from the signal, so when the signal changes it will rerun
 ///#[component]
 ///fn Child() -> Element {
-///     let signal: Signal<i32> = use_context();
+///     let mut signal: Signal<i32> = use_context();
 ///     rsx! {
 ///         button { onclick: move |_| signal += 1, "increment context" }
 ///         p {"{signal}"}

packages/hooks/src/use_effect.rs

@@ -9,6 +9,7 @@ use dioxus_signals::*;
 /// effects will always run after first mount and then whenever the signal values change
 /// If the use_effect call was skipped due to an early return, the effect will no longer activate.
 /// ```rust
+/// # use dioxus::prelude::*;
 /// fn app() -> Element {
 ///     let mut count = use_signal(|| 0);
 ///     //the effect runs again each time count changes

packages/hooks/src/use_future.rs

@@ -13,6 +13,8 @@ use std::ops::Deref;
 /// `use_future` **won't return a value**.
 /// If you want to return a value from a future, use `use_resource` instead.
 /// ```rust
+/// # use dioxus::prelude::*;
+/// # use std::time::Duration;
 /// fn app() -> Element {
 ///     let mut count = use_signal(|| 0);
 ///     let mut running = use_signal(|| true);

packages/hooks/src/use_resource.rs

@@ -15,16 +15,28 @@ use std::{cell::Cell, future::Future, rc::Rc};
 /// Similar to `use_future` but `use_resource` returns a value.
 /// See [`Resource`] for more details.
 /// ```rust
-///fn app() -> Element {
-///    let country = use_signal(|| WeatherLocation {
-///        city: "Berlin".to_string(),
-///        country: "Germany".to_string(),
-///        coordinates: (52.5244, 13.4105)
-///    });
+/// # use dioxus::prelude::*;
+/// # #[derive(Clone)]
+/// # struct WeatherLocation {
+/// #     city: String,
+/// #     country: String,
+/// #     coordinates: (f64, f64),
+/// # }
+/// # async fn get_weather(location: &WeatherLocation) -> Result<String, String> {
+/// #     Ok("Sunny".to_string())
+/// # }
+/// # #[component]
+/// # fn WeatherElement (weather: String ) -> Element { rsx! { p { "The weather is {weather}" } } }
+/// fn app() -> Element {
+///     let country = use_signal(|| WeatherLocation {
+///         city: "Berlin".to_string(),
+///         country: "Germany".to_string(),
+///         coordinates: (52.5244, 13.4105)
+///     });
 ///
 ///    // Because the resource's future subscribes to `country` by reading it (`country.read()`),
 ///    // every time `country` changes the resource's future will run again and thus provide a new value.
-///    let current_weather = use_resource(move || async move { get_weather(&country.read().clone()).await });
+///    let current_weather = use_resource(move || async move { get_weather(&country()).await });
 ///    
 ///    rsx! {
 ///        // the value of the resource can be polled to
@@ -32,9 +44,9 @@ use std::{cell::Cell, future::Future, rc::Rc};
 ///        // finished (Some(Ok(_)), errored Some(Err(_)),
 ///        // or is still running (None)
 ///        match current_weather.value() {
-///            Some(Ok(weather)) => WeatherElement { weather },
-///            Some(Err(e)) => p { "Loading weather failed, {e}" }
-///            None =>  p { "Loading..." }
+///            Some(Ok(weather)) => rsx! { WeatherElement { weather } },
+///            Some(Err(e)) => rsx! { p { "Loading weather failed, {e}" } },
+///            None =>  rsx! { p { "Loading..." } }
 ///        }
 ///    }
 ///}
@@ -107,6 +119,13 @@ pub struct Resource<T: 'static> {
     callback: UseCallback<Task>,
 }
 
+impl<T> Clone for Resource<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<T> Copy for Resource<T> {}
+
 /// A signal that represents the state of the resource
 // we might add more states (panicked, etc)
 #[derive(Clone, Copy, PartialEq, Hash, Eq, Debug)]