Add AsyncCallback.awaitAll

Closes #807

Author: japgolly

core/src/main/scala/japgolly/scalajs/react/AsyncCallback.scala

@@ -104,8 +104,22 @@ object AsyncCallback {
   def pure[A](a: A): AsyncCallback[A] =
     const(Success(a))
 
-  def throwException[A](t: Throwable): AsyncCallback[A] =
-    const(Failure(t))
+  def throwException[A](t: => Throwable): AsyncCallback[A] =
+    const {
+      try
+        Failure(t)
+      catch {
+        case t2: Throwable => Failure(t2)
+      }
+    }
+
+  def throwExceptionWhenDefined(o: => Option[Throwable]): AsyncCallback[Unit] =
+    byName {
+      o match {
+        case None    => unit
+        case Some(t) => throwException(t)
+      }
+    }
 
   def const[A](t: Try[A]): AsyncCallback[A] =
     AsyncCallback(_(t))
@@ -182,14 +196,24 @@ object AsyncCallback {
         case 0 => AsyncCallback.unit
         case 1 => AsyncCallback.byName(f(as(0))).void
         case n =>
+          var error = Option.empty[Throwable]
           val latch = countDownLatch(n).runNow()
 
+          def onTaskComplete(r: Try[B]): Callback =
+            Callback {
+              r match {
+                case Success(_) =>
+                case Failure(e) => error = Some(e)
+              }
+            } >> latch.countDown
+
           for (a <- as)
             AsyncCallback.byName(f(a))
-              .finallyRunSync(latch.countDown)
+              .attemptTry
+              .flatMapSync(onTaskComplete)
               .runNow()
 
-          latch.await
+          latch.await >> throwExceptionWhenDefined(error)
       }
     }
 
@@ -290,6 +314,12 @@ object AsyncCallback {
   }
 
   final case class Forked[A](await: AsyncCallback[A], isComplete: CallbackTo[Boolean])
+
+  def awaitAll(as: AsyncCallback[_]*): AsyncCallback[Unit] =
+    if (as.isEmpty)
+      unit
+    else
+      sequence_(as.iterator.asInstanceOf[Iterator[AsyncCallback[Any]]])
 }
 
 /** Pure asynchronous callback.

doc/changelog/1.7.7.md

@@ -13,6 +13,8 @@ This entire release is focused on `AsyncCallback`.
 
 * `AsyncCallback` object:
 
+  * Added `def awaitAll(as: AsyncCallback[_]*): AsyncCallback[Unit]` to wait for a number of async processes to complete.
+
   * Added `countDownLatch(count: Int)` which returns an `AsyncCallback.CountDownLatch`.
     It has the same purpose and semantics as Java's `CountDownLatch`.
 
@@ -32,6 +34,10 @@ This entire release is focused on `AsyncCallback`.
     * `traverseOption`
     * `sequenceOption`
 
+  * The argument to `throwException` is now by-name
+
+  * Added `def throwExceptionWhenDefined(o: => Option[Throwable]): AsyncCallback[Unit]`
+
 * `AsyncCallback.Barrier`:
 
   * Added `isComplete: CallbackTo[Boolean]` to synchronously query whether the barrier is complete or not.

test/src/test/scala/japgolly/scalajs/react/core/AsyncCallbackTest.scala

@@ -203,5 +203,29 @@ object AsyncCallbackTest extends TestSuite {
       }
     }
 
+    "awaitAll" - {
+      "ok" - asyncTest {
+        for {
+          b1 <- AsyncCallback.barrier.asAsyncCallback
+          b2 <- AsyncCallback.barrier.asAsyncCallback
+          f  <- AsyncCallback.awaitAll(b1.await.ret(1), b2.await.ret("a")).fork.asAsyncCallback
+          _  <- f.isComplete.asAsyncCallback.tap(assertEq(_, false))
+          _  <- b1.complete.asAsyncCallback
+          _  <- f.isComplete.asAsyncCallback.tap(assertEq(_, false))
+          _  <- b2.complete.asAsyncCallback
+          _  <- f.await
+          _  <- f.isComplete.asAsyncCallback.tap(assertEq(_, true))
+        } yield ()
+      }
+
+      "ko" - asyncTest {
+        val b1 = AsyncCallback.unit
+        val b2 = AsyncCallback.throwException(new RuntimeException("yep")).delayMs(1)
+        for {
+          t <- AsyncCallback.awaitAll(b1, b2).attemptTry
+        } yield assert(t.isFailure)
+      }
+    }
+
   }
 }