🎥 Make videos programmatically with React
/**
* Copyright 2019 Google Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import {assert} from './assert';
import type {HeadlessBrowser} from './Browser';
import {BrowserEmittedEvents} from './Browser';
import {TimeoutError} from './Errors';
import type {
EvaluateFn,
EvaluateFnReturnType,
EvaluateHandleFn,
SerializableOrJSHandle,
UnwrapPromiseLike,
} from './EvalTypes';
import type {ExecutionContext} from './ExecutionContext';
import type {Frame} from './FrameManager';
import type {JSHandle} from './JSHandle';
import {isString, valueFromRemoteObject} from './util';
export class DOMWorld {
#frame: Frame;
#contextPromise: Promise<ExecutionContext> | null = null;
#contextResolveCallback: ((x: ExecutionContext) => void) | null = null;
#detached = false;
#waitTasks = new Set<WaitTask>();
get _waitTasks(): Set<WaitTask> {
return this.#waitTasks;
}
constructor(frame: Frame) {
// Keep own reference to client because it might differ from the FrameManager's
// client for OOP iframes.
this.#frame = frame;
this._setContext(null);
}
frame(): Frame {
return this.#frame;
}
_setContext(context: ExecutionContext | null): void {
if (context) {
assert(
this.#contextResolveCallback,
'Execution Context has already been set.',
);
this.#contextResolveCallback?.call(null, context);
this.#contextResolveCallback = null;
for (const waitTask of this._waitTasks) {
waitTask.rerun();
}
} else {
this.#contextPromise = new Promise((fulfill) => {
this.#contextResolveCallback = fulfill;
});
}
}
_hasContext(): boolean {
return !this.#contextResolveCallback;
}
_detach(): void {
this.#detached = true;
for (const waitTask of this._waitTasks) {
waitTask.terminate(
new Error('waitForFunction failed: frame got detached.'),
);
}
}
executionContext(): Promise<ExecutionContext> {
if (this.#detached) {
throw new Error(
`Execution context is not available in detached frame "${this.#frame.url()}" (are you trying to evaluate?)`,
);
}
if (this.#contextPromise === null) {
throw new Error(`Execution content promise is missing`);
}
return this.#contextPromise;
}
async evaluateHandle<HandlerType extends JSHandle = JSHandle>(
pageFunction: EvaluateHandleFn,
...args: SerializableOrJSHandle[]
): Promise<HandlerType> {
const context = await this.executionContext();
return context.evaluateHandle(pageFunction, ...args);
}
async evaluate<T extends EvaluateFn>(
pageFunction: T,
...args: SerializableOrJSHandle[]
): Promise<UnwrapPromiseLike<EvaluateFnReturnType<T>>> {
const context = await this.executionContext();
return context.evaluate<UnwrapPromiseLike<EvaluateFnReturnType<T>>>(
pageFunction,
...args,
);
}
waitForFunction({
browser,
timeout,
pageFunction,
title,
}: {
browser: HeadlessBrowser;
timeout: number | null;
pageFunction: Function | string;
title: string;
}): WaitTask {
return new WaitTask({
domWorld: this,
predicateBody: pageFunction,
title,
timeout,
args: [],
browser,
});
}
}
interface WaitTaskOptions {
domWorld: DOMWorld;
predicateBody: Function | string;
title: string;
timeout: number | null;
browser: HeadlessBrowser;
args: SerializableOrJSHandle[];
}
const noop = (): void => undefined;
class WaitTask {
#domWorld: DOMWorld;
#timeout: number | null;
#predicateBody: string;
#args: SerializableOrJSHandle[];
#runCount = 0;
#resolve: (x: JSHandle) => void = noop;
#reject: (x: Error) => void = noop;
#timeoutTimer?: Timer;
#terminated = false;
#browser: HeadlessBrowser;
promise: Promise<JSHandle>;
constructor(options: WaitTaskOptions) {
function getPredicateBody(predicateBody: Function | string) {
if (isString(predicateBody)) {
return `return (${predicateBody});`;
}
return `return (${predicateBody})(...args);`;
}
this.#domWorld = options.domWorld;
this.#timeout = options.timeout;
this.#predicateBody = getPredicateBody(options.predicateBody);
this.#args = options.args;
this.#runCount = 0;
this.#domWorld._waitTasks.add(this);
this.promise = new Promise<JSHandle>((resolve, reject) => {
this.#resolve = resolve;
this.#reject = reject;
});
// Since page navigation requires us to re-install the pageScript, we should track
// timeout on our end.
if (options.timeout) {
const timeoutError = new TimeoutError(
`waiting for ${options.title} failed: timeout ${options.timeout}ms exceeded`,
);
this.#timeoutTimer = setTimeout(() => {
return this.#reject(timeoutError);
}, options.timeout);
}
this.#browser = options.browser;
this.#browser.on(BrowserEmittedEvents.Closed, this.onBrowserClose);
this.#browser.on(
BrowserEmittedEvents.ClosedSilent,
this.onBrowserCloseSilent,
);
this.rerun();
}
onBrowserClose = () => {
return this.terminate(new Error('Browser was closed'));
};
onBrowserCloseSilent = () => {
return this.terminate(null);
};
terminate(error: Error | null): void {
this.#terminated = true;
if (error) {
this.#reject(error);
}
this.#cleanup();
}
async rerun(): Promise<void> {
const runCount = ++this.#runCount;
let success: JSHandle | null = null;
let error: Error | null = null;
const contextPromise = this.#domWorld.executionContext();
const context = await contextPromise;
if (this.#terminated || runCount !== this.#runCount) {
return;
}
try {
success = await context.evaluateHandle(
waitForPredicatePageFunction,
this.#predicateBody,
this.#timeout,
...this.#args,
);
} catch (error_) {
error = error_ as Error;
}
if (this.#terminated || runCount !== this.#runCount) {
if (success) {
await success.dispose();
}
return;
}
// Ignore timeouts in pageScript - we track timeouts ourselves.
// Primitive results need no further CDP evaluation, but must still belong
// to the current execution context. Object handles are checked in the page.
if (
!error &&
(success && !success._remoteObject.objectId
? !valueFromRemoteObject(success._remoteObject) ||
!this.#domWorld._hasContext() ||
this.#domWorld.executionContext() !== contextPromise
: await this.#domWorld
.evaluate((s) => {
return !s;
}, success)
.catch(() => {
return true;
}))
) {
if (!success) {
throw new Error('Assertion: result handle is not available');
}
await success.dispose();
return;
}
if (this.#terminated || runCount !== this.#runCount) {
await success?.dispose();
return;
}
if (error) {
if (error.message.includes('TypeError: binding is not a function')) {
return this.rerun();
}
// When frame is detached the task should have been terminated by the DOMWorld.
// 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',
)
) {
this.terminate(
new Error('waitForFunction failed: frame got detached.'),
);
return;
}
// 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;
}
this.#reject(error);
} else {
if (!success) {
throw new Error('Assertion: result handle is not available');
}
this.#resolve(success);
}
this.#cleanup();
}
#cleanup(): void {
if (this.#timeoutTimer !== undefined) {
clearTimeout(this.#timeoutTimer);
}
this.#browser.off(BrowserEmittedEvents.Closed, this.onBrowserClose);
this.#browser.off(
BrowserEmittedEvents.ClosedSilent,
this.onBrowserCloseSilent,
);
if (this.#domWorld._waitTasks.size > 100) {
throw new Error('Leak detected: Too many WaitTasks');
}
this.#domWorld._waitTasks.delete(this);
}
}
function waitForPredicatePageFunction(
predicateBody: string,
timeout: number,
...args: unknown[]
): Promise<unknown> {
// eslint-disable-next-line no-new-func
const predicate = new Function('...args', predicateBody);
let timedOut = false;
if (timeout) {
setTimeout(() => {
timedOut = true;
}, timeout);
}
return new Promise<JSHandle | undefined>((resolve) => {
async function onRaf(): Promise<void> {
if (timedOut) {
resolve(undefined);
return;
}
const success = await predicate(...args);
if (success) {
resolve(success);
} else {
requestAnimationFrame(onRaf);
}
}
onRaf();
});
}