Merge pull request #742 from japgolly/topic/rateLimit

Add rate limiting to Callback & AsyncCallback

Author: japgolly

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

@@ -1,6 +1,6 @@
 package japgolly.scalajs.react
 
-import japgolly.scalajs.react.internal.{SyncPromise, catchAll, identityFn, newJsPromise}
+import japgolly.scalajs.react.internal.{RateLimit, SyncPromise, catchAll, identityFn, newJsPromise}
 import java.time.Duration
 import scala.collection.compat._
 import scala.concurrent.duration.FiniteDuration
@@ -399,6 +399,63 @@ final class AsyncCallback[A] private[AsyncCallback] (val completeWith: (Try[A] =
   def unless_(cond: => Boolean): AsyncCallback[Unit] =
     when_(!cond)
 
+  /** Limits the number of invocations in a given amount of time.
+    *
+    * @return Some if invocation was allowed, None if rejected/rate-limited
+    */
+  def rateLimit(window: Duration): AsyncCallback[Option[A]] =
+    rateLimitMs(window.toMillis)
+
+  /** Limits the number of invocations in a given amount of time.
+    *
+    * @return Some if invocation was allowed, None if rejected/rate-limited
+    */
+  def rateLimit(window: FiniteDuration): AsyncCallback[Option[A]] =
+    rateLimitMs(window.toMillis)
+
+  /** Limits the number of invocations in a given amount of time.
+    *
+    * @return Some if invocation was allowed, None if rejected/rate-limited
+    */
+  def rateLimit(window: Duration, maxPerWindow: Int): AsyncCallback[Option[A]] =
+    rateLimitMs(window.toMillis, maxPerWindow)
+
+  /** Limits the number of invocations in a given amount of time.
+    *
+    * @return Some if invocation was allowed, None if rejected/rate-limited
+    */
+  def rateLimit(window: FiniteDuration, maxPerWindow: Int): AsyncCallback[Option[A]] =
+    rateLimitMs(window.toMillis, maxPerWindow)
+
+  /** Limits the number of invocations in a given amount of time.
+    *
+    * @return Some if invocation was allowed, None if rejected/rate-limited
+    */
+  def rateLimitMs(windowMs: Long, maxPerWindow: Int = 1): AsyncCallback[Option[A]] =
+    _rateLimitMs(windowMs, maxPerWindow, RateLimit.realClock)
+
+  private[react] def _rateLimitMs(windowMs: Long, maxPerWindow: Int, clock: RateLimit.Clock): AsyncCallback[Option[A]] =
+    if (windowMs <= 0 || maxPerWindow <= 0)
+      AsyncCallback.pure(None)
+    else {
+      val limited =
+        RateLimit.fn(
+          run          = completeWith,
+          windowMs     = windowMs,
+          maxPerWindow = maxPerWindow,
+          clock        = clock,
+        )
+      val miss = Try(None)
+      AsyncCallback { f =>
+        Callback {
+          limited(ta => f(ta.map(Some(_)))) match {
+            case Some(cb) => cb.runNow()
+            case None     => f(miss)
+          }
+        }
+      }
+    }
+
   /** Log to the console before this callback starts, and after it completes.
     *
     * Does not change the result.

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

@@ -10,7 +10,7 @@ import scala.scalajs.js
 import scala.scalajs.js.{UndefOr, undefined, Function0 => JFn0, Function1 => JFn1}
 import scala.scalajs.js.timers.{RawTimers, SetIntervalHandle, SetTimeoutHandle}
 import scala.util.{Failure, Success, Try}
-import japgolly.scalajs.react.internal.{catchAll, identityFn, Trampoline}
+import japgolly.scalajs.react.internal.{RateLimit, Trampoline, catchAll, identityFn}
 import java.time.Duration
 import CallbackTo.MapGuard
 
@@ -572,6 +572,48 @@ final class CallbackTo[A] private[react] (private[CallbackTo] val trampoline: Tr
   def unless_(cond: => Boolean): Callback =
     when_(!cond)
 
+  /** Limits the number of invocations in a given amount of time.
+    *
+    * @return Some if invocation was allowed, None if rejected/rate-limited
+    */
+  def rateLimit(window: Duration): CallbackTo[Option[A]] =
+    rateLimitMs(window.toMillis)
+
+  /** Limits the number of invocations in a given amount of time.
+    *
+    * @return Some if invocation was allowed, None if rejected/rate-limited
+    */
+  def rateLimit(window: FiniteDuration): CallbackTo[Option[A]] =
+    rateLimitMs(window.toMillis)
+
+  /** Limits the number of invocations in a given amount of time.
+    *
+    * @return Some if invocation was allowed, None if rejected/rate-limited
+    */
+  def rateLimit(window: Duration, maxPerWindow: Int): CallbackTo[Option[A]] =
+    rateLimitMs(window.toMillis, maxPerWindow)
+
+  /** Limits the number of invocations in a given amount of time.
+    *
+    * @return Some if invocation was allowed, None if rejected/rate-limited
+    */
+  def rateLimit(window: FiniteDuration, maxPerWindow: Int): CallbackTo[Option[A]] =
+    rateLimitMs(window.toMillis, maxPerWindow)
+
+  /** Limits the number of invocations in a given amount of time.
+    *
+    * @return Some if invocation was allowed, None if rejected/rate-limited
+    */
+  def rateLimitMs(windowMs: Long, maxPerWindow: Int = 1): CallbackTo[Option[A]] =
+    if (windowMs <= 0 || maxPerWindow <= 0)
+      CallbackTo.pure(None)
+    else
+      CallbackTo.lift(RateLimit.fn0(
+        run          = toScalaFn,
+        maxPerWindow = maxPerWindow,
+        windowMs = windowMs,
+      ))
+
   /** Log to the console before this callback starts, and after it completes.
     *
     * Does not change the result.

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

@@ -0,0 +1,42 @@
+package japgolly.scalajs.react.internal
+
+import scala.scalajs.js
+
+object RateLimit {
+
+  type Clock = () => Long
+
+  val realClock: Clock =
+    () => System.currentTimeMillis()
+
+  def fn[A, B](run: A => B, maxPerWindow: Int, windowMs: Long, clock: Clock = realClock): A => Option[B] = {
+    val windowRuns = new js.Array[Long]
+
+    a => {
+      val now         = clock()
+      val windowStart = now - windowMs
+
+      // prune current window
+      while (windowRuns.nonEmpty && windowRuns(0) < windowStart)
+        windowRuns.shift()
+
+      if (windowRuns.length >= maxPerWindow)
+        None
+      else {
+        windowRuns.push(now)
+        Some(run(a))
+      }
+    }
+  }
+
+  def fn0[A](run: () => A, maxPerWindow: Int, windowMs: Long, clock: Clock = realClock): () => Option[A] = {
+    val f = fn[Unit, A](
+      run          = _ => run(),
+      windowMs     = windowMs,
+      maxPerWindow = maxPerWindow,
+      clock        = clock,
+    )
+    () => f(())
+  }
+
+}

doc/changelog/1.7.3.md

@@ -1,5 +1,15 @@
 # 1.7.3
 
+* Add rate-limiting to `Callback` and `AsyncCallback`:
+  * `def rateLimit(window: Duration, maxPerWindow: Int = 1): {CallbackTo,AsyncCallback}[Option[A]]`
+  * `def rateLimitMs(windowMs: Long, maxPerWindow: Int = 1): {CallbackTo,AsyncCallback}[Option[A]]`
+
+  For example, if you wanted to limit a callback to a max of 5 times per second it would look like this:
+
+  ```scala
+  callback.rateLimit(1.second, 5)
+  ```
+
 * Add implicit `Reusability` instances for:
   * `SetIntervalHandle`
   * `SetTimeoutHandle`

project/Build.scala

@@ -23,6 +23,7 @@ object ScalajsReact {
     val DisciplineScalaTest   = "1.0.1"
     val KindProjector         = "0.11.0"
     val MacroParadise         = "2.1.1"
+    val Microlibs             = "2.3"
     val MonocleCats           = "2.0.5"
     val MonocleScalaz         = "1.6.3"
     val MTest                 = "0.7.4"
@@ -284,11 +285,12 @@ object ScalajsReact {
         "-Xlint:adapted-args"
       ),
       libraryDependencies ++= Seq(
-        "com.github.japgolly.nyaya"  %%% "nyaya-prop"        % Ver.Nyaya         % Test,
-        "com.github.japgolly.nyaya"  %%% "nyaya-gen"         % Ver.Nyaya         % Test,
-        "com.github.japgolly.nyaya"  %%% "nyaya-test"        % Ver.Nyaya         % Test,
-        "com.github.julien-truffaut" %%% "monocle-macro"     % Ver.MonocleScalaz % Test,
-        "org.scala-js"               %%% "scalajs-java-time" % Ver.ScalaJsTime   % Test),
+        "com.github.japgolly.microlibs" %%% "test-util"         % Ver.Microlibs     % Test,
+        "com.github.japgolly.nyaya"     %%% "nyaya-prop"        % Ver.Nyaya         % Test,
+        "com.github.japgolly.nyaya"     %%% "nyaya-gen"         % Ver.Nyaya         % Test,
+        "com.github.japgolly.nyaya"     %%% "nyaya-test"        % Ver.Nyaya         % Test,
+        "com.github.julien-truffaut"    %%% "monocle-macro"     % Ver.MonocleScalaz % Test,
+        "org.scala-js"                  %%% "scalajs-java-time" % Ver.ScalaJsTime   % Test),
       jsDependencies ++= Seq(
         "org.webjars.bower" % "sizzle" % Ver.SizzleJs % Test / "sizzle.min.js" commonJSName "Sizzle",
         (ProvidedJS / "component-es6.js" dependsOn ReactDom.dev) % Test,

test/src/test/scala/japgolly/scalajs/react/MiscTest.scala

@@ -21,11 +21,11 @@ object MiscTest extends TestSuite {
 
   @Lenses
   case class StrInt(str: String, int: Int)
-  implicit def equalStrInt: Equal[StrInt] = Equal.equalA
+  implicit def equalStrInt: UnivEq[StrInt] = UnivEq.force
 
   @Lenses
   case class StrIntWrap(strInt: StrInt)
-  implicit def equalStrIntWrap: Equal[StrIntWrap] = Equal.equalA
+  implicit def equalStrIntWrap: UnivEq[StrIntWrap] = UnivEq.force
 
   val witnessOptionCallbackToCallback: Option[Callback] => Callback =
     _.getOrEmpty
@@ -208,7 +208,7 @@ object MiscTest extends TestSuite {
     }
 
     "durationFromDOMHighResTimeStamp" - {
-      assertEq(JsUtil.durationFromDOMHighResTimeStamp(3), Duration.ofMillis(3))(Equal.equalA)
+      assertEq(JsUtil.durationFromDOMHighResTimeStamp(3), Duration.ofMillis(3))
     }
 
     "static" - {

test/src/test/scala/japgolly/scalajs/react/StateSnapshotTest.scala

@@ -45,7 +45,7 @@ object StateSnapshotTest extends TestSuite {
     final case class X(int: Int, str: String)
 
     object X {
-      implicit def equal: Equal[X] = Equal.equalA
+      implicit def equal: UnivEq[X] = UnivEq.force
       implicit val reusability: Reusability[X] = Reusability.derive
     }
 

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

@@ -97,7 +97,7 @@ object RawComponentEs6PTest extends TestSuite {
           this.b - x.b,
           this.c - x.c)
       }
-      implicit def equalProps = Equal.equalA[Props]
+      implicit def equalProps = UnivEq.force[Props]
 
       var mountCountA = 0
       var mountCountB = 0
@@ -184,8 +184,8 @@ object RawComponentEs6STest extends TestSuite {
   case class State(num1: Int, s2: State2)
   case class State2(num2: Int, num3: Int)
 
-  implicit val equalState: Equal[State] = Equal.equalA
-  implicit val equalState2: Equal[State2] = Equal.equalA
+  implicit val equalState: UnivEq[State] = UnivEq.force
+  implicit val equalState2: UnivEq[State2] = UnivEq.force
 
   @nowarn("cat=unused")
   class RawComp(ctorProps: Box[Unit]) extends raw.React.Component[Box[Unit], Box[State]] {

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

@@ -86,7 +86,7 @@ object ScalaComponentPTest extends TestSuite {
           this.b - x.b,
           this.c - x.c)
       }
-      implicit def equalProps = Equal.equalA[Props]
+      implicit def equalProps = UnivEq.force[Props]
 
       var mountCountA = 0
       var mountCountB = 0
@@ -321,8 +321,8 @@ object ScalaComponentSTest extends TestSuite {
   case class State(num1: Int, s2: State2)
   case class State2(num2: Int, num3: Int)
 
-  implicit val equalState: Equal[State] = Equal.equalA
-  implicit val equalState2: Equal[State2] = Equal.equalA
+  implicit val equalState: UnivEq[State] = UnivEq.force
+  implicit val equalState2: UnivEq[State2] = UnivEq.force
 
   class Backend($: BackendScope[Int, State]) {
     val inc: Callback =