Function runAsync

packages/core/src/runAsync.ts:47–196

(
  to: AsyncTo<InferState<T>>,
  props: RunAsyncProps<T>,
  state: RunAsyncState<T>,
  target: T
)

 * or a primitive type for a single animated value.
 */
export function runAsync<T extends AnimationTarget>(
  to: AsyncTo<InferState<T>>,
  props: RunAsyncProps<T>,
  state: RunAsyncState<T>,
  target: T
): AsyncResult<T> {
  const { callId, parentId, onRest } = props
  const { asyncTo: prevTo, promise: prevPromise } = state

  if (!parentId && to === prevTo && !props.reset) {
    return prevPromise!
  }

  return (state.promise = (async () => {
    state.asyncId = callId
    state.asyncTo = to

    // The default props of any `animate` calls.
    const defaultProps = getDefaultProps<InferProps<T>>(props, (value, key) =>
      // The `onRest` prop is only called when the `runAsync` promise is resolved.
      key === 'onRest' ? undefined : value
    )

    let preventBail!: () => void
    let bail: (error: any) => void

    // This promise is rejected when the animation is interrupted.
    const bailPromise = new Promise<void>(
      (resolve, reject) => ((preventBail = resolve), (bail = reject))
    )

    const bailIfEnded = (bailSignal: BailSignal) => {
      const bailResult =
        // The `cancel` prop or `stop` method was used.
        (callId <= (state.cancelId || 0) && getCancelledResult(target)) ||
        // The async `to` prop was replaced.
        (callId !== state.asyncId && getFinishedResult(target, false))

      if (bailResult) {
        bailSignal.result = bailResult

        // Reject the `bailPromise` to ensure the `runAsync` promise
        // is not relying on the caller to rethrow the error for us.
        bail(bailSignal)
        throw bailSignal
      }
    }

    // Safety cap for unterminating async scripts under `skipAnimation`.
    // Without animation frames to pace it, `while (true) await next(...)`
    // becomes a tight microtask loop that would hang the host.
    let skipAnimationCallCount = 0
    const SKIP_ANIMATION_CALL_LIMIT = 1024

    const animate: any = (arg1: any, arg2?: any) => {
      // Create the bail signal outside the returned promise,
      // so the generated stack trace is relevant.
      const bailSignal = new BailSignal()