puppeteer-core
Version:
A high-level API to control headless Chrome over the DevTools Protocol
200 lines • 7.12 kB
JavaScript
"use strict";
/**
* @license
* Copyright 2022 Google Inc.
* SPDX-License-Identifier: Apache-2.0
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.TaskManager = exports.WaitTask = void 0;
const Deferred_js_1 = require("../util/Deferred.js");
const ErrorLike_js_1 = require("../util/ErrorLike.js");
const Function_js_1 = require("../util/Function.js");
const Errors_js_1 = require("./Errors.js");
const LazyArg_js_1 = require("./LazyArg.js");
/**
* @internal
*/
class WaitTask {
#world;
#polling;
#root;
#fn;
#args;
#timeout;
#timeoutError;
#result = Deferred_js_1.Deferred.create();
#poller;
#signal;
#reruns = [];
constructor(world, options, fn, ...args) {
this.#world = world;
this.#polling = options.polling;
this.#root = options.root;
this.#signal = options.signal;
this.#signal?.addEventListener('abort', this.#onAbortSignal, {
once: true,
});
switch (typeof fn) {
case 'string':
this.#fn = `() => {return (${fn});}`;
break;
default:
this.#fn = (0, Function_js_1.stringifyFunction)(fn);
break;
}
this.#args = args;
this.#world.taskManager.add(this);
if (options.timeout) {
this.#timeoutError = new Errors_js_1.TimeoutError(`Waiting failed: ${options.timeout}ms exceeded`);
this.#timeout = setTimeout(() => {
void this.terminate(this.#timeoutError);
}, options.timeout);
}
void this.rerun();
}
get result() {
return this.#result.valueOrThrow();
}
async rerun() {
for (const prev of this.#reruns) {
prev.abort();
}
this.#reruns.length = 0;
const controller = new AbortController();
this.#reruns.push(controller);
try {
switch (this.#polling) {
case 'raf':
this.#poller = await this.#world.evaluateHandle(({ RAFPoller, createFunction }, fn, ...args) => {
const fun = createFunction(fn);
return new RAFPoller(() => {
return fun(...args);
});
}, LazyArg_js_1.LazyArg.create(context => {
return context.puppeteerUtil;
}), this.#fn, ...this.#args);
break;
case 'mutation':
this.#poller = await this.#world.evaluateHandle(({ MutationPoller, createFunction }, root, fn, ...args) => {
const fun = createFunction(fn);
return new MutationPoller(() => {
return fun(...args);
}, root || document);
}, LazyArg_js_1.LazyArg.create(context => {
return context.puppeteerUtil;
}), this.#root, this.#fn, ...this.#args);
break;
default:
this.#poller = await this.#world.evaluateHandle(({ IntervalPoller, createFunction }, ms, fn, ...args) => {
const fun = createFunction(fn);
return new IntervalPoller(() => {
return fun(...args);
}, ms);
}, LazyArg_js_1.LazyArg.create(context => {
return context.puppeteerUtil;
}), this.#polling, this.#fn, ...this.#args);
break;
}
await this.#poller.evaluate(poller => {
void poller.start();
});
const result = await this.#poller.evaluateHandle(poller => {
return poller.result();
});
this.#result.resolve(result);
await this.terminate();
}
catch (error) {
if (controller.signal.aborted) {
return;
}
const badError = this.getBadError(error);
if (badError) {
await this.terminate(badError);
}
}
}
async terminate(error) {
this.#world.taskManager.delete(this);
this.#signal?.removeEventListener('abort', this.#onAbortSignal);
clearTimeout(this.#timeout);
if (error && !this.#result.finished()) {
this.#result.reject(error);
}
if (this.#poller) {
try {
await this.#poller.evaluate(async (poller) => {
await poller.stop();
});
if (this.#poller) {
await this.#poller.dispose();
this.#poller = undefined;
}
}
catch {
// Ignore errors since they most likely come from low-level cleanup.
}
}
}
/**
* Not all errors lead to termination. They usually imply we need to rerun the task.
*/
getBadError(error) {
if ((0, ErrorLike_js_1.isErrorLike)(error)) {
// When frame is detached the task should have been terminated by the IsolatedWorld.
// This can fail if we were adding this task while the frame was detached,
// so we terminate here instead.
if (error.message.includes('Execution context is not available in detached frame')) {
return new Error('Waiting failed: Frame detached');
}
// When the page is navigated, the promise is rejected.
// We will try again in the new execution context.
if (error.message.includes('Execution context was destroyed')) {
return;
}
// We could have tried to evaluate in a context which was already
// destroyed.
if (error.message.includes('Cannot find context with specified id')) {
return;
}
// Errors coming from WebDriver BiDi. TODO: Adjust messages after
// https://github.com/w3c/webdriver-bidi/issues/540 is resolved.
if (error.message.includes('DiscardedBrowsingContextError')) {
return;
}
return error;
}
return new Error('WaitTask failed with an error', {
cause: error,
});
}
#onAbortSignal = () => {
void this.terminate(this.#signal?.reason);
};
}
exports.WaitTask = WaitTask;
/**
* @internal
*/
class TaskManager {
#tasks = new Set();
add(task) {
this.#tasks.add(task);
}
delete(task) {
this.#tasks.delete(task);
}
terminateAll(error) {
for (const task of this.#tasks) {
void task.terminate(error);
}
this.#tasks.clear();
}
async rerunAll() {
await Promise.all([...this.#tasks].map(task => {
return task.rerun();
}));
}
}
exports.TaskManager = TaskManager;
//# sourceMappingURL=WaitTask.js.map