use_async refactor, spawn method

Author: ccbrown

packages/iocraft/src/handler.rs

@@ -1,4 +1,4 @@
-/// `Handler` is a type representing an optional event handler, commonly used for properties such as [`BoxProps::on_click`](crate::components::BoxProps::on_click).
+/// `Handler` is a type representing an optional event handler, commonly used for component properties.
 #[derive(Default)]
 pub enum Handler<'a, T> {
     /// No handler is set.

packages/iocraft/src/hooks/use_async.rs

@@ -10,15 +10,15 @@ use std::{
 /// component. When the component is unmounted, the tasks will be dropped.
 #[derive(Default)]
 pub struct UseAsync {
-    once_fut: Option<BoxFuture<'static, ()>>,
+    did_spawn_once: bool,
+    futures: Vec<BoxFuture<'static, ()>>,
 }
 
 impl Hook for UseAsync {
     fn poll_change(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-        match self.once_fut.as_mut() {
-            Some(f) => f.as_mut().poll(cx),
-            None => Poll::Pending,
-        }
+        self.futures
+            .retain_mut(|f| !matches!(f.as_mut().poll(cx), Poll::Ready(())));
+        Poll::Pending
     }
 }
 
@@ -33,8 +33,21 @@ impl UseAsync {
         F: FnOnce() -> T,
         T: Future<Output = ()> + Send + 'static,
     {
-        if self.once_fut.is_none() {
-            self.once_fut = Some(Box::pin(f()));
+        if !self.did_spawn_once {
+            self.futures.push(Box::pin(f()));
+            self.did_spawn_once = true;
         }
     }
+
+    /// Spawns a future which is bound to the lifetime of the component. When the component is
+    /// unmounted, the future will be dropped.
+    ///
+    /// The future will be spawned every time this function is called. If you need to run a future
+    /// in the background, use [`spawn_once`](UseAsync::spawn_once) instead.
+    pub fn spawn<F, T>(&mut self, f: F)
+    where
+        F: Future<Output = ()> + Send + 'static,
+    {
+        self.futures.push(Box::pin(f));
+    }
 }

packages/iocraft/src/style.rs

@@ -13,8 +13,8 @@ pub use taffy::style::{
 };
 
 /// Defines a type that represents a percentage [0.0-100.0] and is convertible to any of the
-/// libary's other percent types. As a shorthand, you can express this in the [`element!`] macro
-/// using the `pct` suffix, e.g. `50pct`.
+/// libary's other percent types. As a shorthand, you can express this in the
+/// [`element!`](crate::element!) macro using the `pct` suffix, e.g. `50pct`.
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct Percent(pub f32);