Merge pull request #649 from gemini-hlsw/use-effect-result-when-deps-…

…ready

Implement WhenDepsReady for useEffectResult

README.md

@@ -256,6 +256,8 @@ Note that all versions either have dependencies or are executed `onMount`. It do
 
 Also note that when dependencies change, the hook value will revert to `Pending` until the new effect completes. If this is undesireable, there are `useEffectKeepResult*` variants which will instead keep the hook value as `Ready(oldValue)` until the new effect completes.
 
+There are also `WhenDepsReady` versions, which will only execute the effect when dependencies are ready. If they change or transition to `Pending` or `Error`, then the result will revert to `Pending`. However, if the `KeepResult` version is used, it will retain the last value.
+
 
 ``` scala
   useEffectResultWithDeps[D: Reusability, A](deps: => D)(effect: D => IO[A]): Pot[A]
@@ -266,6 +268,12 @@ Also note that when dependencies change, the hook value will revert to `Pending`
 
   useEffectResultOnMount[A](effect: IO[A]): Pot[A]
   useEffectResultOnMountBy[A](effect: Ctx => IO[A]): Pot[A]
+
+  useEffectResultWhenDepsReady[D: Reusability, A](deps: => D)(effect: D => IO[A]): Pot[A]
+  useEffectResultWhenDepsReadyBy[D: Reusability, A](deps: Ctx => D)(effect: Ctx => D => IO[A]): Pot[A]
+
+  useEffectKeepResultWhenDepsReady[D: Reusability, A](deps: => D)(effect: D => IO[A]): Pot[A]
+  useEffectKeepResultWhenDepsReadyBy[D: Reusability, A](deps: Ctx => D)(effect: Ctx => D => IO[A]): Pot[A]
 ```
 
 #### Example:

build.sbt

@@ -1,7 +1,7 @@
 Global / onChangedBuildSource := ReloadOnSourceChanges
 
 ThisBuild / crossScalaVersions := List("3.5.0")
-ThisBuild / tlBaseVersion      := "0.43"
+ThisBuild / tlBaseVersion      := "0.44"
 
 ThisBuild / tlCiReleaseBranches := Seq("master")
 

modules/core/js/src/main/scala/crystal/react/hooks/UseEffectResult.scala

@@ -3,28 +3,31 @@
 
 package crystal.react.hooks
 
+import cats.syntax.all.*
 import crystal.*
 import crystal.react.*
 import japgolly.scalajs.react.*
 import japgolly.scalajs.react.hooks.CustomHook
 import japgolly.scalajs.react.util.DefaultEffects.Async as DefaultA
 
 object UseEffectResult {
-  private case class Input[A](effect: DefaultA[A], keep: Boolean)
+  private case class Input[D, A](effect: WithPotDeps[D, DefaultA[A]], keep: Boolean):
+    val depsOpt: Option[D] = effect.deps.toOption
 
   private def hook[D: Reusability, A] =
-    CustomHook[WithDeps[D, Input[A]]]
+    CustomHook[Input[D, A]]
       .useState(Pot.pending[A])
-      .useMemoBy((props, _) => props.deps): (props, _) =>
-        deps => props.fromDeps(deps)
-      .useEffectWithDepsBy((_, _, input) => input): (_, state, _) =>
-        input => state.setState(Pot.pending).unless(input.keep).void
-      .useAsyncEffectWithDepsBy((_, _, input) => input): (_, state, _) =>
-        input =>
-          (for {
-            a <- input.effect
+      .useMemoBy((props, _) => props.depsOpt.void): (props, _) => // Memo Option[effect]
+        _ => props.depsOpt.map(props.effect.fromDeps)
+      .useEffectWithDepsBy((_, _, effectOpt) => effectOpt): (props, state, _) => // Set to Pending
+        _ => state.setState(Pot.pending).unless(props.keep).void
+      .useAsyncEffectWithDepsBy((_, _, effectOpt) => effectOpt): (_, state, _) => // Run effect
+        _.value.foldMap: effect =>
+          (for
+            a <- effect
             _ <- state.setStateAsync(a.ready)
-          } yield ()).handleErrorWith(t => state.setStateAsync(Pot.error(t)))
+          yield ()).handleErrorWith: t =>
+            state.setStateAsync(Pot.error(t))
       .buildReturning((_, state, _) => state.value)
 
   object HooksApiExt {
@@ -41,6 +44,19 @@ object UseEffectResult {
       ): step.Next[Pot[A]] =
         useEffectResultWithDepsBy(_ => deps)(_ => effect)
 
+      /**
+       * Runs an async effect when `Pot` dependencies transition into a `Ready` state and stores the
+       * result in a state, which is provided as a `Pot[A]`. When dependencies change, reverts to
+       * `Pending` while executing the new effect or while waiting for them to become `Ready` again.
+       * For multiple dependencies, use `(par1, par2, ...).tupled`.
+       */
+      final def useEffectResultWhenDepsReady[D: Reusability, A](
+        deps: => Pot[D]
+      )(effect: D => DefaultA[A])(using
+        step: Step
+      ): step.Next[Pot[A]] =
+        useEffectResultWhenDepsReadyBy(_ => deps)(_ => effect)
+
       /**
        * Runs an async effect and stores the result in a state, which is provided as a `Pot[A]`.
        * When dependencies change, keeps the old value while executing the new effect.
@@ -52,6 +68,19 @@ object UseEffectResult {
       ): step.Next[Pot[A]] =
         useEffectKeepResultWithDepsBy(_ => deps)(_ => effect)
 
+      /**
+       * Runs an async effect when `Pot` dependencies transition into a `Ready` state and stores the
+       * result in a state, which is provided as a `Pot[A]`. When dependencies change, keeps the old
+       * value while executing the new effect or while waiting for them to become `Ready` again. For
+       * multiple dependencies, use `(par1, par2, ...).tupled`.
+       */
+      final def useEffectKeepResultWhenDepsReady[D: Reusability, A](
+        deps: => Pot[D]
+      )(effect: D => DefaultA[A])(using
+        step: Step
+      ): step.Next[Pot[A]] =
+        useEffectKeepResultWhenDepsReadyBy(_ => deps)(_ => effect)
+
       /**
        * Runs an async effect and stores the result in a state, which is provided as a `Pot[A]`.
        */
@@ -64,10 +93,17 @@ object UseEffectResult {
         deps: Ctx => D
       )(effect: Ctx => D => DefaultA[A], keep: Boolean)(using
         step: Step
+      ): step.Next[Pot[A]] =
+        useEffectResultInternalWhenDepsReadyBy(deps.andThen(_.ready))(effect, keep)
+
+      private def useEffectResultInternalWhenDepsReadyBy[D: Reusability, A](
+        deps: Ctx => Pot[D]
+      )(effect: Ctx => D => DefaultA[A], keep: Boolean)(using
+        step: Step
       ): step.Next[Pot[A]] =
         api.customBy { ctx =>
           val hookInstance = hook[D, A]
-          hookInstance(WithDeps(deps(ctx), effect(ctx).andThen(Input(_, keep))))
+          hookInstance(Input(WithPotDeps(deps(ctx), effect(ctx)), keep))
         }
 
       /**
@@ -81,6 +117,19 @@ object UseEffectResult {
       ): step.Next[Pot[A]] =
         useEffectResultInternalWithDepsBy(deps)(effect, keep = false)
 
+      /**
+       * Runs an async effect when `Pot` dependencies transition into a `Ready` state and stores the
+       * result in a state, which is provided as a `Pot[A]`. When dependencies change, reverts to
+       * `Pending` while executing the new effect or while waiting for them to become `Ready` again.
+       * For multiple dependencies, use `(par1, par2, ...).tupled`.
+       */
+      final def useEffectResultWhenDepsReadyBy[D: Reusability, A](
+        deps: Ctx => Pot[D]
+      )(effect: Ctx => D => DefaultA[A])(using
+        step: Step
+      ): step.Next[Pot[A]] =
+        useEffectResultInternalWhenDepsReadyBy(deps)(effect, keep = false)
+
       /**
        * Runs an async effect and stores the result in a state, which is provided as a `Pot[A]`.
        * When dependencies change, keeps the old value while executing the new effect.
@@ -92,6 +141,19 @@ object UseEffectResult {
       ): step.Next[Pot[A]] =
         useEffectResultInternalWithDepsBy(deps)(effect, keep = true)
 
+      /**
+       * Runs an async effect when `Pot` dependencies transition into a `Ready` state and stores the
+       * result in a state, which is provided as a `Pot[A]`. When dependencies change, keeps the old
+       * value while executing the new effect or while waiting for them to become `Ready` again. For
+       * multiple dependencies, use `(par1, par2, ...).tupled`.
+       */
+      final def useEffectKeepResultWhenDepsReadyBy[D: Reusability, A](
+        deps: Ctx => Pot[D]
+      )(effect: Ctx => D => DefaultA[A])(using
+        step: Step
+      ): step.Next[Pot[A]] =
+        useEffectResultInternalWhenDepsReadyBy(deps)(effect, keep = true)
+
       /**
        * Runs an async effect and stores the result in a state, which is provided as a `Pot[A]`.
        */
@@ -116,6 +178,19 @@ object UseEffectResult {
       ): step.Next[Pot[A]] =
         useEffectResultWithDepsBy(step.squash(deps)(_))(step.squash(effect)(_))
 
+      /**
+       * Runs an async effect when `Pot` dependencies transition into a `Ready` state and stores the
+       * result in a state, which is provided as a `Pot[A]`. When dependencies change, reverts to
+       * `Pending` while executing the new effect or while waiting for them to become `Ready` again.
+       * For multiple dependencies, use `(par1, par2, ...).tupled`.
+       */
+      def useEffectResultWhenDepsReadyBy[D: Reusability, A](
+        deps: CtxFn[Pot[D]]
+      )(effect: CtxFn[D => DefaultA[A]])(using
+        step: Step
+      ): step.Next[Pot[A]] =
+        useEffectResultWhenDepsReadyBy(step.squash(deps)(_))(step.squash(effect)(_))
+
       /**
        * Runs an async effect and stores the result in a state, which is provided as a `Pot[A]`.
        * When dependencies change, keeps the old value while executing the new effect.
@@ -127,6 +202,19 @@ object UseEffectResult {
       ): step.Next[Pot[A]] =
         useEffectKeepResultWithDepsBy(step.squash(deps)(_))(step.squash(effect)(_))
 
+      /**
+       * Runs an async effect when `Pot` dependencies transition into a `Ready` state and stores the
+       * result in a state, which is provided as a `Pot[A]`. When dependencies change, keeps the old
+       * value while executing the new effect or while waiting for them to become `Ready` again. For
+       * multiple dependencies, use `(par1, par2, ...).tupled`.
+       */
+      def useEffectKeepResultWhenDepsReadysBy[D: Reusability, A](
+        deps: CtxFn[Pot[D]]
+      )(effect: CtxFn[D => DefaultA[A]])(using
+        step: Step
+      ): step.Next[Pot[A]] =
+        useEffectKeepResultWhenDepsReadyBy(step.squash(deps)(_))(step.squash(effect)(_))
+
       /**
        * Runs an async effect and stores the result in a state, which is provided as a `Pot[A]`.
        */