feat: sleep fn for time crate

Author: DogeDark

packages/time/src/debounce.rs

@@ -39,15 +39,16 @@ impl<T> PartialEq for UseDebounce<T> {
 /// Once the [`UseDebounce::action`] method is called, a timer will start counting down until
 /// the callback is ran. If the [`UseDebounce::action`] method is called again, the timer will restart.
 ///
-/// # Example
+/// # Examples
 ///
 /// ```rust
 /// use dioxus::prelude::*;
 /// use dioxus_time::use_debounce;
 /// use std::time::Duration;
 ///
+/// #[component]
 /// fn App() -> Element {
-///     let mut debounce = use_debounce(Duration::from_millis(2000), |_| println!("ran"));
+///     let mut debounce = use_debounce(Duration::from_secs(2), |_| println!("ran"));
 ///     
 ///     rsx! {
 ///         button {

packages/time/src/interval.rs

@@ -1,6 +1,9 @@
 use dioxus::prelude::{use_hook, Callback, Writable};
 use std::time::Duration;
 
+/// A handle to an interval.
+/// 
+/// This handle allows you to cancel an interval.
 #[derive(Clone, PartialEq, Copy)]
 pub struct UseInterval {
     inner: dioxus::prelude::Signal<InnerUseInterval>,
@@ -28,6 +31,25 @@ impl UseInterval {
 }
 
 /// Repeatedly call a function at a specific interval.
+/// 
+/// Intervals are cancelable with the [`UseInterval::cancel`] method.
+/// 
+/// # Examples
+/// ```rust
+/// use dioxus::prelude::*;
+/// use dioxus_time::use_interval;
+/// use std::time::Duration;
+///
+/// #[component]
+/// fn App() -> Element {
+///     let mut time_elapsed = use_signal(|| 0);
+///      use_interval(Duration::from_secs(1), move || *time_elapsed.write() += 1);
+///     
+///     rsx! {
+///         "It has been {time_elapsed} since the app started."
+///     }
+/// }
+/// ```
 pub fn use_interval(period: Duration, mut action: impl FnMut() + 'static) -> UseInterval {
     let inner = use_hook(|| {
         let callback = Callback::new(move |()| {

packages/time/src/lib.rs

@@ -1,7 +1,49 @@
-//! Dioxus time utilities.
+//! # Dioxus Time Utilities
+//! 
+//! Cross-platform timing utilities for your Dioxus apps.
+//! 
+//! We currently offer:
+//! - [`use_debounce`]
+//! - [`use_interval`]
+//! - and [`sleep`]
+#![warn(missing_docs)]
+
+use std::time::Duration;
 
 mod interval;
 pub use interval::{use_interval, UseInterval};
 
 mod debounce;
 pub use debounce::{use_debounce, UseDebounce};
+
+
+/// Pause the current task for the specified duration.
+/// 
+/// # Examples
+/// ```rust
+/// use std::time::Duration;
+/// use dioxus::prelude::*;
+/// 
+/// #[component]
+/// pub fn App() -> Element {
+///     let mut has_slept = use_signal(|| false);
+///     
+///     use_effect(move || {
+///         spawn(async move {
+///             dioxus_time::sleep(Duration::from_secs(3)).await;
+///             has_slept.set(true);
+///         });
+///     });
+/// 
+///     rsx! {
+///         "I have slept: {has_slept}"
+///     }
+/// }
+/// ```
+pub async fn sleep(duration: Duration) {
+    #[cfg(not(target_family = "wasm"))]
+    tokio::time::sleep(duration).await;
+
+    #[cfg(target_family = "wasm")]
+    gloo_timers::future::sleep(duration).await;
+}