playwright-fluent
Version:
Fluent API around playwright
76 lines (75 loc) • 3.12 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.waitUntil = exports.noWaitNoThrowOptions = exports.defaultWaitUntilOptions = void 0;
const report_1 = require("../report");
const sleep_1 = require("../sleep");
exports.defaultWaitUntilOptions = {
stabilityInMilliseconds: 300,
throwOnTimeout: true,
timeoutInMilliseconds: 30000,
verbose: false,
wrapPredicateExecutionInsideTryCatch: false,
};
exports.noWaitNoThrowOptions = {
stabilityInMilliseconds: 0,
throwOnTimeout: false,
timeoutInMilliseconds: 0,
verbose: false,
wrapPredicateExecutionInsideTryCatch: true,
};
/**
* Wait until predicate becomes true,
* and always return true during 300 ms.
* The waiting mechanism can be modified by setting options
*
* @export
* @param {() => Promise<boolean>} predicate
* @param {(string | (() => Promise<string>))} errorMessage
* @param {WaitUntilOptions} [options=defaultWaitUntilOptions]
* @returns {Promise<void>}
*/
async function waitUntil(predicate, errorMessage, options = exports.defaultWaitUntilOptions) {
(0, report_1.report)('wait options:', options.verbose);
(0, report_1.report)(JSON.stringify(options, null, 2), options.verbose);
const timeout = options.timeoutInMilliseconds;
const interval = options.stabilityInMilliseconds <= 3 ? 1 : options.stabilityInMilliseconds / 3;
const nbIntervals = timeout <= 0 ? 1 : timeout / interval;
const stabilityCounterMaxValue = timeout <= 0 ? 1 : options.stabilityInMilliseconds / interval;
let stabilityCounterCurrentValue = 0;
for (let index = 0; index < nbIntervals; index++) {
await (0, sleep_1.sleep)(interval);
const result = await safeExecutePredicate(predicate, options.wrapPredicateExecutionInsideTryCatch);
(0, report_1.report)(`predicate returned ${result} after waiting ${(index + 1) * interval} ms`, options.verbose);
if (result === true) {
stabilityCounterCurrentValue += 1;
}
if (result === false) {
stabilityCounterCurrentValue = 0;
}
if (result && stabilityCounterCurrentValue >= stabilityCounterMaxValue) {
(0, report_1.report)(`predicate always returned ${result} during ${stabilityCounterCurrentValue > 0 ? stabilityCounterCurrentValue * interval : interval} ms: no need to wait anymore.`, options.verbose);
return;
}
}
(0, report_1.report)(`predicate could not converge to a stable result or always returned false during ${options.timeoutInMilliseconds} ms.`, options.verbose);
if (!options.throwOnTimeout) {
(0, report_1.report)('exiting waiting mechanism without throwing', options.verbose);
return;
}
if (typeof errorMessage === 'string') {
throw new Error(errorMessage);
}
throw new Error(await errorMessage());
}
exports.waitUntil = waitUntil;
async function safeExecutePredicate(predicate, noThrow) {
try {
return await predicate();
}
catch (error) {
if (noThrow) {
return false;
}
throw error;
}
}