Merge pull request #545 from japgolly/sync-promise

Make AsyncCallback.promise synchronous once completed

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, newJsPromise}
+import japgolly.scalajs.react.internal.{catchAll, identityFn, newJsPromise, SyncPromise}
 import scala.collection.generic.CanBuildFrom
 import scala.concurrent.duration.FiniteDuration
 import scala.concurrent.{ExecutionContext, Future}
@@ -28,8 +28,8 @@ object AsyncCallback {
     */
   def promise[A]: CallbackTo[(AsyncCallback[A], Try[A] => Callback)] =
     for {
-      (p, pc) <- newJsPromise[A]
-    } yield (fromJsPromise(p), pc)
+      p <- SyncPromise[A]
+    } yield (AsyncCallback(p.onComplete), p.complete)
 
   def first[A](f: (Try[A] => Callback) => Callback): AsyncCallback[A] =
     new AsyncCallback(g => CallbackTo {
@@ -134,7 +134,7 @@ object AsyncCallback {
   def fromCallbackToJsPromise[A](c: CallbackTo[js.Promise[A]]): AsyncCallback[A] =
     c.asAsyncCallback.flatMap(fromJsPromise(_))
 
-  @inline implicit def asynCallbackCovariance[A, B >: A](c: AsyncCallback[A]): AsyncCallback[B] =
+  @inline implicit def asyncCallbackCovariance[A, B >: A](c: AsyncCallback[A]): AsyncCallback[B] =
     c.widen
 
   /** Not literally tail-recursive because AsyncCallback is continuation-based, but this utility in this shape may still

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

@@ -0,0 +1,37 @@
+package japgolly.scalajs.react.internal
+
+import japgolly.scalajs.react.Callback
+import scala.util.Try
+import japgolly.scalajs.react.CallbackTo
+
+/** Promise that is synchronous once its value has been set. */
+final class SyncPromise[A] {
+  private var result    = Option.empty[Try[A]]
+  private var callbacks = List.empty[Try[A] => Callback]
+
+  val complete: Try[A] => Callback =
+    t =>
+      Callback {
+        if (result.isEmpty) {
+          result = Some(t)
+          try
+            callbacks.foreach(_(t).runNow())
+          finally
+            callbacks = Nil
+        }
+      }
+
+  def onComplete: (Try[A] => Callback) => Callback =
+    f =>
+      Callback {
+        result match {
+          case Some(t) => f(t).runNow()
+          case None    => callbacks :+= f
+        }
+      }
+}
+
+object SyncPromise {
+  def apply[A]: CallbackTo[SyncPromise[A]] =
+    CallbackTo(new SyncPromise)
+}

doc/changelog/1.4.2.md

@@ -5,6 +5,7 @@
   * `AsyncCallback#race(…).toCallback` should start a new race each time the `Callback` is invoked
   * `AsyncCallback#flatten` wouldn't compile (oops)
   * `AsyncCallback.fromFuture` should be sync if future already complete
+  * `AsyncCallback.promise` should be sync if promise already complete
   * Fix bug where in `fullOptJS`, using a key and a ref would result in the key being lost.
   * Fix CSS-Grid style definitions to not cause React warnings
 

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

@@ -4,6 +4,7 @@ import japgolly.scalajs.react.{AsyncCallback, Callback}
 import utest._
 import scala.concurrent.Future
 import scala.concurrent.ExecutionContext.Implicits.global
+import scala.util.Success
 
 object AsyncCallbackTest extends TestSuite {
 
@@ -49,6 +50,26 @@ object AsyncCallbackTest extends TestSuite {
           future.isCompleted ==> true
         }
       }
+
+      'promise {
+        val (ac, complete) = AsyncCallback.promise[Int].runNow()
+        var r1,r2,r3 = 0
+        ac.map(i => r1 = i).toCallback.runNow()
+        r1 ==> 0
+        complete(Success(666)).runNow()
+        r1 ==> 666
+        r2 ==> 0
+        r1 = 123
+        ac.map(i => r2 = i).toCallback.runNow()
+        r1 ==> 123
+        r2 ==> 666
+        r3 ==> 0
+        r2 = 123
+        ac.map(i => r3 = i).toCallback.runNow()
+        r1 ==> 123
+        r2 ==> 123
+        r3 ==> 666
+      }
     }
 
   }