chore: refactor runAsync function

- pass an `AnimationTarget` object to `runAsync` function
- check for invalidated `runAsync` call whenever an `animate` promise is resolved
- only set `state.asyncTo` on a default cancel, because using `cancel: true` without `default: true` should only affect the update it's defined in
- use `getResult` functions for brevity

Author: aleclarson

packages/core/src/Controller.ts

@@ -5,6 +5,7 @@ import { Lookup, Falsy } from './types/common'
 import { inferTo } from './helpers'
 import { FrameValue } from './FrameValue'
 import { SpringPhase, CREATED, ACTIVE, IDLE } from './SpringPhase'
+import { SpringValue, createLoopUpdate, createUpdate } from './SpringValue'
 import {
   getCombinedResult,
   AnimationResult,
@@ -88,7 +89,7 @@ export class Controller<State extends Lookup = Lookup>
    */
   get idle() {
     return (
-      !this._state.promise &&
+      !this._state.asyncTo &&
       Object.values(this.springs as Lookup<SpringValue>).every(
         spring => spring.idle
       )
@@ -309,24 +310,16 @@ export function flushUpdate(
         state,
         action(props, resolve) {
           props.onRest = onRest as any
-          resolve(
-            runAsync(
-              asyncTo,
-              props,
-              state,
-              ctrl.get.bind(ctrl),
-              () => false, // TODO: add pausing to Controller
-              ctrl.start.bind(ctrl) as any,
-              ctrl.stop.bind(ctrl)
-            )
-          )
+          resolve(runAsync(asyncTo, props, state, ctrl))
         },
       })
     )
   }
-  // Cancel an active "asyncTo" if desired.
+  // Respect the `cancel` prop when no keys are affected.
   else if (!props.keys && props.cancel === true) {
     state.cancelId = ctrl['_lastAsyncId']
+    // Ensure the `idle` property returns true.
+    state.asyncTo = undefined
   }
 
   return Promise.all(promises).then(results => {

packages/core/src/SpringValue.ts

@@ -786,17 +786,7 @@ export class SpringValue<T = any> extends FrameValue<T> {
     }
 
     if (hasAsyncTo) {
-      resolve(
-        runAsync(
-          props.to,
-          props,
-          this._state,
-          () => this.get(),
-          () => this.is(PAUSED),
-          this.start.bind(this),
-          this.stop.bind(this) as any
-        )
-      )
+      resolve(runAsync(props.to, props, this._state, this))
     }
 
     // Start an animation

packages/core/src/runAsync.ts

@@ -8,12 +8,14 @@ import {
   SpringChain,
   SpringDefaultProps,
   SpringProps,
-  SpringStopFn,
   SpringToFn,
 } from './types'
 import {
+  getCancelledResult,
+  getFinishedResult,
   AnimationResult,
   AsyncResult,
+  AnimationTarget,
 } from './AnimationResult'
 
 export interface RunAsyncProps<T = any> extends SpringProps<T> {
@@ -50,17 +52,14 @@ export async function runAsync<T>(
   to: SpringChain<T> | SpringToFn<T>,
   props: RunAsyncProps<T>,
   state: RunAsyncState<T>,
-  getValue: () => T,
-  getPaused: () => boolean,
-  update: (props: any) => AsyncResult<T>,
-  stop: SpringStopFn<T>
+  target: AnimationTarget<T>
 ): AsyncResult<T> {
   if (props.cancel) {
-    state.asyncTo = undefined
-    return {
-      value: getValue(),
-      cancelled: true,
+    // Stop the active `asyncTo` only on "default cancel".
+    if (props.default) {
+      state.asyncTo = undefined
     }
+    return getCancelledResult(target)
   }
   if (props.pause) {
     await new Promise(next => {
@@ -92,17 +91,21 @@ export async function runAsync<T>(
     })
 
     const { callId, onRest } = props
-
-    // Note: This function cannot be async, because `checkFailConditions` must be sync.
-    const animate: any = (arg1: any, arg2?: any) => {
+    const throwInvalidated = () => {
       // Prevent further animation if cancelled.
       if (callId <= (state.cancelId || 0)) {
-        throw (result = { value: getValue(), cancelled: true })
+        throw (result = getCancelledResult(target))
       }
       // Prevent further animation if another "runAsync" call is active.
       if (to !== state.asyncTo) {
-        throw (result = { value: getValue(), finished: false })
+        throw (result = getFinishedResult(target, false))
       }
+    }
+
+    // Note: This function cannot use the `async` keyword, because we want the
+    // `throw` statements to interrupt the caller.
+    const animate: any = (arg1: any, arg2?: any) => {
+      throwInvalidated()
 
       const props: ControllerUpdate<T> = is.obj(arg1)
         ? { ...arg1 }
@@ -115,12 +118,14 @@ export async function runAsync<T>(
       })
 
       const parentTo = state.asyncTo
-      return update(props).then(async result => {
+      return target.start(props).then(async result => {
+        throwInvalidated()
+
         if (state.asyncTo == null) {
           state.asyncTo = parentTo
         }
 
-        if (getPaused()) {
+        if (target.is('PAUSED')) {
           await new Promise(resolve => {
             state.unpause = concatFn(state.unpause, () => {
               state.unpause = void 0
@@ -142,12 +147,9 @@ export async function runAsync<T>(
       }
       // Async script
       else if (is.fun(to)) {
-        await to(animate, stop)
-      }
-      result = {
-        value: getValue(),
-        finished: true,
+        await to(animate, target.stop.bind(target) as any)
       }
+      result = getFinishedResult(target, true)
     } catch (err) {
       if (err !== result) {
         throw err