async-utils.js

function createTimeoutError(utilName, { timeout }) {
  const timeoutError = new Error(`Timed out in ${utilName} after ${timeout}ms.`)
  timeoutError.timeout = true
  return timeoutError
}

function asyncUtils(act, addResolver) {
  let nextUpdatePromise = null

  const waitForNextUpdate = async (options = {}) => {
    if (!nextUpdatePromise) {
      nextUpdatePromise = new Promise((resolve, reject) => {
        let timeoutId
        if (options.timeout > 0) {
          timeoutId = setTimeout(
            () => reject(createTimeoutError('waitForNextUpdate', options)),
            options.timeout
          )
        }
        addResolver(() => {
          clearTimeout(timeoutId)
          nextUpdatePromise = null
          resolve()
        })
      })
      await act(() => nextUpdatePromise)
    }
    await nextUpdatePromise
  }

  const wait = async (callback, { timeout, suppressErrors = true } = {}) => {
    const checkResult = () => {
      try {
        const callbackResult = callback()
        return callbackResult || callbackResult === undefined
      } catch (e) {
        if (!suppressErrors) {
          throw e
        }
      }
    }

    const waitForResult = async () => {
      const initialTimeout = timeout
      while (true) {
        const startTime = Date.now()
        try {
          await waitForNextUpdate({ timeout })
          if (checkResult()) {
            return
          }
        } catch (e) {
          if (e.timeout) {
            throw createTimeoutError('wait', { timeout: initialTimeout })
          }
          throw e
        }
        timeout -= Date.now() - startTime
      }
    }

    if (!checkResult()) {
      await waitForResult()
    }
  }

  const waitForValueToChange = async (selector, options = {}) => {
    const initialValue = selector()
    try {
      await wait(() => selector() !== initialValue, {
        suppressErrors: false,
        ...options
      })
    } catch (e) {
      if (e.timeout) {
        throw createTimeoutError('waitForValueToChange', options)
      }
      throw e
    }
  }

  return {
    wait,
    waitForNextUpdate,
    waitForValueToChange
  }
}

export default asyncUtils