Add AsyncCallback.{promise,init}

Author: japgolly

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

@@ -1,6 +1,6 @@
 package japgolly.scalajs.react
 
-import japgolly.scalajs.react.internal.{catchAll, identityFn}
+import japgolly.scalajs.react.internal.{catchAll, identityFn, newJsPromise}
 import scala.collection.generic.CanBuildFrom
 import scala.concurrent.duration.FiniteDuration
 import scala.concurrent.{ExecutionContext, Future}
@@ -16,6 +16,21 @@ object AsyncCallback {
   def apply[A](f: (Try[A] => Callback) => Callback): AsyncCallback[A] =
     new AsyncCallback(f)
 
+  def init[A, B](f: (Try[B] => Callback) => CallbackTo[A]): CallbackTo[(A, AsyncCallback[B])] =
+    for {
+      (ac, c) <- promise[B]
+      a       <- f(c)
+    } yield (a, ac)
+
+  /** Create an AsyncCallback and separately provide the completion function.
+    *
+    * This is like Scala's promise, not the JS promise which is more like Scala's Future.
+    */
+  def promise[A]: CallbackTo[(AsyncCallback[A], Try[A] => Callback)] =
+    for {
+      (p, pc) <- newJsPromise[A]
+    } yield (fromJsPromise(p), pc)
+
   def first[A](f: (Try[A] => Callback) => Callback): AsyncCallback[A] =
     new AsyncCallback(g => {
       var first = true
@@ -398,19 +413,10 @@ final class AsyncCallback[A] private[AsyncCallback] (val completeWith: (Try[A] =
     }
 
   def asCallbackToJsPromise: CallbackTo[js.Promise[A]] =
-    CallbackTo {
-      new js.Promise[A]((respond: js.Function1[A | Thenable[A], _], reject: js.Function1[Any, _]) => {
-        def fail(t: Throwable) =
-          reject(t match {
-            case js.JavaScriptException(e) => e
-            case e                         => e
-          })
-        completeWith(t => Callback(t match {
-          case Success(a) => respond(a)
-          case Failure(e) => fail(e)
-        })).runNow()
-      })
-    }
+    for {
+      (p, pc) <- newJsPromise[A]
+      _       <- completeWith(pc)
+    } yield p
 
   def unsafeToFuture(): Future[A] =
     asCallbackToFuture.runNow()

core/src/main/scala/japgolly/scalajs/react/internal/package.scala

@@ -2,6 +2,8 @@ package japgolly.scalajs.react
 
 import scala.collection.generic.CanBuildFrom
 import scala.collection.mutable.Builder
+import scala.scalajs.js
+import scala.scalajs.js.{Thenable, |}
 import scala.util.{Failure, Success, Try}
 
 package object internal {
@@ -35,4 +37,20 @@ package object internal {
       }
     }
   }
+
+  def newJsPromise[A]: CallbackTo[(js.Promise[A], Try[A] => Callback)] = CallbackTo {
+    var complete: Try[A] => Callback = null
+    val p = new js.Promise[A]((respond: js.Function1[A | Thenable[A], _], reject: js.Function1[Any, _]) => {
+      def fail(t: Throwable) =
+        reject(t match {
+          case js.JavaScriptException(e) => e
+          case e                         => e
+        })
+      complete = {
+        case Success(a) => Callback(respond(a))
+        case Failure(e) => Callback(fail(e))
+      }
+    })
+    (p, complete)
+  }
 }