Function waitForInternal

src/wait-for.ts:24–220

(
  expectation: () => T,
  {
    timeout = getConfig().asyncUtilTimeout,
    interval = DEFAULT_INTERVAL,
    stackTraceError,
    onTimeout,
  }: WaitForOptions,
)

};

function waitForInternal<T>(
  expectation: () => T,
  {
    timeout = getConfig().asyncUtilTimeout,
    interval = DEFAULT_INTERVAL,
    stackTraceError,
    onTimeout,
  }: WaitForOptions,
): Promise<T> {
  if (typeof expectation !== 'function') {
    throw new TypeError('Received `expectation` arg must be a function');
  }

  // eslint-disable-next-line no-async-promise-executor
  return new Promise(async (resolve, reject) => {
    let lastError: unknown;
    let intervalId: ReturnType<typeof setInterval> | null = null;
    let finished = false;
    let promiseStatus = 'idle';

    let overallTimeoutTimer: ReturnType<typeof setTimeout> | null = null;
    const cleanupQueueCallback = () => finalizeWaitFor({ rejectOnAbort: true });

    const fakeTimersType = getJestFakeTimersType();

    if (fakeTimersType) {
      checkExpectation();
      // this is a dangerous rule to disable because it could lead to an
      // infinite loop. However, eslint isn't smart enough to know that we're
      // setting finished inside `onDone` which will be called when we're done
      // waiting or when we've timed out.
      let fakeTimeRemaining = timeout;
      while (!finished) {
        if (!jestFakeTimersAreEnabled()) {
          const error = new Error(
            `Changed from using fake timers to real timers while using waitFor. This is not allowed and will result in very strange behavior. Please ensure you're awaiting all async things your test is doing before changing to real timers. For more info, please go to https://github.com/testing-library/dom-testing-library/issues/830`,
          );
          copyStackTraceIfNeeded(error, stackTraceError);
          reject(error);
          return;
        }

        // when fake timers are used we want to simulate the interval time passing
        if (fakeTimeRemaining <= 0) {
          handleTimeout();
          return;
        } else {
          fakeTimeRemaining -= interval;
        }

        // we *could* (maybe should?) use `advanceTimersToNextTimer` but it's
        // possible that could make this loop go on forever if someone is using
        // third party code that's setting up recursive timers so rapidly that
        // the user's timer's don't get a chance to resolve. So we'll advance
        // by an interval instead. (We have a test for this case).
        await act(() =>
          fakeTimersType === 'modern'
            ? jest.advanceTimersByTimeAsync(interval)