Function waitForCondition

src/test/common.ts:45–105

(
    condition: () => Promise<T> | T,
    timeoutMs: number,
    errorMessage: string | (() => string),
    intervalTimeoutMs: number = 10,
    throwOnError: boolean = false,
    cancelToken?: { isCancellationRequested: boolean; onCancellationRequested: Function }
)

 * @returns {Promise<void>}
 */
export async function waitForCondition<T>(
    condition: () => Promise<T> | T,
    timeoutMs: number,
    errorMessage: string | (() => string),
    intervalTimeoutMs: number = 10,
    throwOnError: boolean = false,
    cancelToken?: { isCancellationRequested: boolean; onCancellationRequested: Function }
): Promise<NonNullable<T>> {
    return new Promise<NonNullable<T>>(async (resolve, reject) => {
        const disposables: IDisposable[] = [];
        let timer: NodeJS.Timer;
        const timerFunc = async () => {
            if (cancelToken?.isCancellationRequested) {
                dispose(disposables);
                reject(new Error('Cancelled Wait Condition via cancellation token'));
                return;
            }
            let success: T | undefined = undefined;
            try {
                const promise = condition();
                success = isPromise(promise) ? await promise : promise;
            } catch (exc) {
                if (throwOnError) {
                    dispose(disposables);
                    reject(exc);
                }
            }
            if (!success) {
                // Start up a timer again, but don't do it until after
                // the condition is false.
                timer = setTimeout(timerFunc, intervalTimeoutMs);
                disposables.push({ dispose: () => clearTimeout(timer as any) });
            } else {
                dispose(disposables);
                resolve(success as NonNullable<T>);
            }
        };
        disposables.push({ dispose: () => clearTimeout(timer as any) });
        timer = setTimeout(timerFunc, 0);
        if (cancelToken) {
            cancelToken.onCancellationRequested(
                () => {
                    dispose(disposables);
                    reject(new Error('Cancelled Wait Condition via cancellation token'));
                    return;
                },
                undefined,
                disposables
            );
        }
        const timeout = setTimeout(() => {
            dispose(disposables);
            errorMessage = typeof errorMessage === 'string' ? errorMessage : errorMessage();
            reject(new Error(errorMessage));
        }, timeoutMs);
        disposables.push({ dispose: () => clearTimeout(timeout) });

        pendingTimers.push(timer);