🎥 Make videos programmatically with React
/**
* Copyright 2017 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 type {LogLevel} from '../log-level';
import {assert} from './assert';
import type {Page} from './BrowserPage';
import type {CDPSession} from './Connection';
import {Connection} from './Connection';
import type {
AttachedToTargetEvent,
DetachedFromTargetEvent,
ExecutionContextDescription,
FrameDetachedEvent,
FrameDetachedEventReason,
FrameTree,
LifecycleEventEvent,
Frame as TFrame,
} from './devtools-types';
import {DOMWorld} from './DOMWorld';
import type {
EvaluateFn,
EvaluateFnReturnType,
EvaluateHandleFn,
SerializableOrJSHandle,
UnwrapPromiseLike,
} from './EvalTypes';
import {EventEmitter} from './EventEmitter';
import {EVALUATION_SCRIPT_URL, ExecutionContext} from './ExecutionContext';
import {isTargetClosedErr} from './flaky-errors';
import type {HTTPResponse} from './HTTPResponse';
import type {JSHandle} from './JSHandle';
import type {PuppeteerLifeCycleEvent} from './LifecycleWatcher';
import {LifecycleWatcher} from './LifecycleWatcher';
import {NetworkManager} from './NetworkManager';
import {isErrorLike} from './util';
const UTILITY_WORLD_NAME = '__puppeteer_utility_world__';
export const FrameManagerEmittedEvents = {
FrameNavigated: Symbol('FrameManager.FrameNavigated'),
FrameDetached: Symbol('FrameManager.FrameDetached'),
FrameSwapped: Symbol('FrameManager.FrameSwapped'),
LifecycleEvent: Symbol('FrameManager.LifecycleEvent'),
FrameNavigatedWithinDocument: Symbol(
'FrameManager.FrameNavigatedWithinDocument',
),
ExecutionContextCreated: Symbol('FrameManager.ExecutionContextCreated'),
ExecutionContextDestroyed: Symbol('FrameManager.ExecutionContextDestroyed'),
};
export class FrameManager extends EventEmitter {
#page: Page;
#networkManager: NetworkManager;
#frames = new Map<string, Frame>();
#contextIdToContext = new Map<string, ExecutionContext>();
#isolatedWorlds = new Set<string>();
#mainFrame?: Frame;
#client: CDPSession;
get _client(): CDPSession {
return this.#client;
}
constructor(
client: CDPSession,
page: Page,
indent: boolean,
logLevel: LogLevel,
) {
super();
this.#client = client;
this.#page = page;
this.#networkManager = new NetworkManager(client, this, indent, logLevel);
this.setupEventListeners(this.#client);
}
private setupEventListeners(session: CDPSession) {
session.on('Page.frameAttached', (event) => {
this.#onFrameAttached(session, event.frameId, event.parentFrameId);
});
session.on('Page.frameNavigated', (event) => {
this.#onFrameNavigated(event.frame);
});
session.on('Page.navigatedWithinDocument', (event) => {
this.#onFrameNavigatedWithinDocument(event.frameId, event.url);
});
session.on('Page.frameDetached', (event: FrameDetachedEvent) => {
this.#onFrameDetached(
event.frameId,
event.reason as FrameDetachedEventReason,
);
});
session.on('Page.frameStartedLoading', (event) => {
this.#onFrameStartedLoading(event.frameId);
});
session.on('Page.frameStoppedLoading', (event) => {
this.#onFrameStoppedLoading(event.frameId);
});
session.on('Runtime.executionContextCreated', (event) => {
this.#onExecutionContextCreated(event.context, session);
});
session.on('Runtime.executionContextDestroyed', (event) => {
this.#onExecutionContextDestroyed(event.executionContextId, session);
});
session.on('Runtime.executionContextsCleared', () => {
this.#onExecutionContextsCleared(session);
});
session.on('Page.lifecycleEvent', (event) => {
this.#onLifecycleEvent(event);
});
session.on('Target.attachedToTarget', (event) => {
this.#onAttachedToTarget(event);
});
session.on('Target.detachedFromTarget', (event) => {
this.#onDetachedFromTarget(event);
});
}
async initialize(client: CDPSession = this.#client): Promise<void> {
try {
const result = await Promise.all([
client.send('Page.enable'),
client.send('Page.getFrameTree'),
client === this.#client
? Promise.resolve()
: client.send('Target.setAutoAttach', {
autoAttach: true,
waitForDebuggerOnStart: false,
flatten: true,
}),
]);
const {
value: {frameTree},
} = result[1];
this.#handleFrameTree(client, frameTree);
await Promise.all([
client.send('Page.setLifecycleEventsEnabled', {enabled: true}),
client.send('Runtime.enable').then(() => {
return this._ensureIsolatedWorld(client, UTILITY_WORLD_NAME);
}),
client === this.#client
? this.#networkManager.initialize()
: Promise.resolve(),
]);
} catch (error) {
// The target might have been closed before the initialization finished.
if (isErrorLike(error) && isTargetClosedErr(error)) {
return;
}
throw error;
}
}
networkManager(): NetworkManager {
return this.#networkManager;
}
async navigateFrame(
frame: Frame,
url: string,
timeout: number,
options: {
referer?: string;
timeout?: number;
waitUntil?: PuppeteerLifeCycleEvent;
} = {},
): Promise<HTTPResponse | null> {
const {referer = undefined, waitUntil = 'load'} = options;
const watcher = new LifecycleWatcher(this, frame, waitUntil, timeout);
let error = await Promise.race([
navigate(this.#client, url, referer, frame._id),
watcher.timeoutOrTerminationPromise(),
]);
if (!error) {
error = await Promise.race([
watcher.timeoutOrTerminationPromise(),
watcher.newDocumentNavigationPromise(),
watcher.sameDocumentNavigationPromise(),
]);
}
watcher.dispose();
if (error) {
throw error;
}
return watcher.navigationResponse();
async function navigate(
client: CDPSession,
_url: string,
referrer: string | undefined,
frameId: string,
): Promise<Error | null> {
try {
const {value: response} = await client.send('Page.navigate', {
url: _url,
referrer,
frameId,
});
return response.errorText
? new Error(`${response.errorText} at ${_url}`)
: null;
} catch (_error) {
if (isErrorLike(_error)) {
return _error;
}
throw _error;
}
}
}
async #onAttachedToTarget(event: AttachedToTargetEvent) {
if (event.targetInfo.type !== 'iframe') {
return;
}
const frame = this.#frames.get(event.targetInfo.targetId);
const connection = Connection.fromSession(this.#client);
assert(connection);
const session = connection.session(event.sessionId);
assert(session);
if (frame) {
frame._updateClient(session);
}
this.setupEventListeners(session);
await this.initialize(session);
}
#onDetachedFromTarget(event: DetachedFromTargetEvent) {
if (!event.targetId) {
return;
}
const frame = this.#frames.get(event.targetId);
if (frame?.isOOPFrame()) {
// When an OOP iframe is removed from the page, it
// will only get a Target.detachedFromTarget event.
this.#removeFramesRecursively(frame);
}
}
#onLifecycleEvent(event: LifecycleEventEvent): void {
const frame = this.#frames.get(event.frameId);
if (!frame) {
return;
}
frame._onLifecycleEvent(event.loaderId, event.name);
this.emit(FrameManagerEmittedEvents.LifecycleEvent, frame);
}
#onFrameStartedLoading(frameId: string): void {
const frame = this.#frames.get(frameId);
if (!frame) {
return;
}
frame._onLoadingStarted();
}
#onFrameStoppedLoading(frameId: string): void {
const frame = this.#frames.get(frameId);
if (!frame) {
return;
}
frame._onLoadingStopped();
this.emit(FrameManagerEmittedEvents.LifecycleEvent, frame);
}
#handleFrameTree(session: CDPSession, frameTree: FrameTree): void {
if (frameTree.frame.parentId) {
this.#onFrameAttached(
session,
frameTree.frame.id,
frameTree.frame.parentId,
);
}
this.#onFrameNavigated(frameTree.frame);
if (!frameTree.childFrames) {
return;
}
for (const child of frameTree.childFrames) {
this.#handleFrameTree(session, child);
}
}
page(): Page {
return this.#page;
}
mainFrame(): Frame {
assert(this.#mainFrame, 'Requesting main frame too early!');
return this.#mainFrame;
}
frames(): Frame[] {
return Array.from(this.#frames.values());
}
frame(frameId: string): Frame | null {
return this.#frames.get(frameId) || null;
}
#onFrameAttached(
session: CDPSession,
frameId: string,
parentFrameId?: string,
): void {
if (this.#frames.has(frameId)) {
const _frame = this.#frames.get(frameId) as Frame;
if (session && _frame.isOOPFrame()) {
// If an OOP iframes becomes a normal iframe again
// it is first attached to the parent page before
// the target is removed.
_frame._updateClient(session);
}
return;
}
assert(parentFrameId);
const parentFrame = this.#frames.get(parentFrameId);
assert(parentFrame);
const frame = new Frame(this, parentFrame, frameId, session);
this.#frames.set(frame._id, frame);
}
#onFrameNavigated(framePayload: TFrame): void {
const isMainFrame = !framePayload.parentId;
let frame = isMainFrame
? this.#mainFrame
: this.#frames.get(framePayload.id);
assert(
isMainFrame || frame,
'We either navigate top level or have old version of the navigated frame',
);
// Detach all child frames first.
if (frame) {
for (const child of frame.childFrames()) {
this.#removeFramesRecursively(child);
}
}
// Update or create main frame.
if (isMainFrame) {
if (frame) {
// Update frame id to retain frame identity on cross-process navigation.
this.#frames.delete(frame._id);
frame._id = framePayload.id;
} else {
// Initial main frame navigation.
frame = new Frame(this, null, framePayload.id, this.#client);
}
this.#frames.set(framePayload.id, frame);
this.#mainFrame = frame;
}
// Update frame payload.
assert(frame);
frame._navigated(framePayload);
this.emit(FrameManagerEmittedEvents.FrameNavigated, frame);
}
async _ensureIsolatedWorld(session: CDPSession, name: string): Promise<void> {
const key = `${session.id()}:${name}`;
if (this.#isolatedWorlds.has(key)) {
return;
}
this.#isolatedWorlds.add(key);
await session.send('Page.addScriptToEvaluateOnNewDocument', {
source: `//# sourceURL=${EVALUATION_SCRIPT_URL}`,
worldName: name,
});
// Frames might be removed before we send this.
await Promise.all(
this.frames()
.filter((frame) => {
return frame._client() === session;
})
.map((frame) => {
return session
.send('Page.createIsolatedWorld', {
frameId: frame._id,
worldName: name,
grantUniveralAccess: true,
})
.catch(() => undefined);
}),
);
}
#onFrameNavigatedWithinDocument(frameId: string, url: string): void {
const frame = this.#frames.get(frameId);
if (!frame) {
return;
}
frame._navigatedWithinDocument(url);
this.emit(FrameManagerEmittedEvents.FrameNavigatedWithinDocument, frame);
this.emit(FrameManagerEmittedEvents.FrameNavigated, frame);
}
#onFrameDetached(frameId: string, reason: FrameDetachedEventReason): void {
const frame = this.#frames.get(frameId);
if (reason === 'remove') {
// Only remove the frame if the reason for the detached event is
// an actual removement of the frame.
// For frames that become OOP iframes, the reason would be 'swap'.
if (frame) {
this.#removeFramesRecursively(frame);
}
} else if (reason === 'swap') {
this.emit(FrameManagerEmittedEvents.FrameSwapped, frame);
}
}
#onExecutionContextCreated(
contextPayload: ExecutionContextDescription,
session: CDPSession,
): void {
const auxData = contextPayload.auxData as {frameId?: string} | undefined;
const frameId = auxData?.frameId;
const frame =
typeof frameId === 'string' ? this.#frames.get(frameId) : undefined;
let world: DOMWorld | undefined;
if (frame) {
// Only care about execution contexts created for the current session.
if (frame._client() !== session) {
return;
}
if (contextPayload.auxData && Boolean(contextPayload.auxData.isDefault)) {
world = frame._mainWorld;
} else if (
contextPayload.name === UTILITY_WORLD_NAME &&
!frame._secondaryWorld._hasContext()
) {
// In case of multiple sessions to the same target, there's a race between
// connections so we might end up creating multiple isolated worlds.
// We can use either.
world = frame._secondaryWorld;
}
}
const context = new ExecutionContext(
frame?._client() || this.#client,
contextPayload,
world as DOMWorld,
);
if (world) {
world._setContext(context);
}
const key = `${session.id()}:${contextPayload.id}`;
this.#contextIdToContext.set(key, context);
}
#onExecutionContextDestroyed(
executionContextId: number,
session: CDPSession,
): void {
const key = `${session.id()}:${executionContextId}`;
const context = this.#contextIdToContext.get(key);
if (!context) {
return;
}
this.#contextIdToContext.delete(key);
if (context._world) {
context._world._setContext(null);
}
}
#onExecutionContextsCleared(session: CDPSession): void {
for (const [key, context] of this.#contextIdToContext.entries()) {
// Make sure to only clear execution contexts that belong
// to the current session.
if (context._client !== session) {
continue;
}
if (context._world) {
context._world._setContext(null);
}
this.#contextIdToContext.delete(key);
}
}
executionContextById(
contextId: number,
session: CDPSession = this.#client,
): ExecutionContext {
const key = `${session.id()}:${contextId}`;
const context = this.#contextIdToContext.get(key);
assert(context, 'INTERNAL ERROR: missing context with id = ' + contextId);
return context;
}
#removeFramesRecursively(frame: Frame): void {
for (const child of frame.childFrames()) {
this.#removeFramesRecursively(child);
}
frame._detach();
this.#frames.delete(frame._id);
this.emit(FrameManagerEmittedEvents.FrameDetached, frame);
}
}
export class Frame {
#parentFrame: Frame | null;
#url = '';
#client!: CDPSession;
_frameManager: FrameManager;
_id: string;
_loaderId = '';
_name?: string;
_hasStartedLoading = false;
_lifecycleEvents = new Set<string>();
_mainWorld!: DOMWorld;
_secondaryWorld!: DOMWorld;
_childFrames: Set<Frame>;
constructor(
frameManager: FrameManager,
parentFrame: Frame | null,
frameId: string,
client: CDPSession,
) {
this._frameManager = frameManager;
this.#parentFrame = parentFrame ?? null;
this.#url = '';
this._id = frameId;
this._loaderId = '';
this._childFrames = new Set();
if (this.#parentFrame) {
this.#parentFrame._childFrames.add(this);
}
this._updateClient(client);
}
_updateClient(client: CDPSession): void {
this.#client = client;
this._mainWorld = new DOMWorld(this);
this._secondaryWorld = new DOMWorld(this);
}
isOOPFrame(): boolean {
return this.#client !== this._frameManager._client;
}
goto(
url: string,
timeout: number,
options: {
referer?: string;
waitUntil?: PuppeteerLifeCycleEvent;
} = {},
): Promise<HTTPResponse | null> {
return this._frameManager.navigateFrame(this, url, timeout, options);
}
_client(): CDPSession {
return this.#client;
}
/**
* @returns a promise that resolves to the frame's default execution context.
*/
executionContext(): Promise<ExecutionContext> {
return this._mainWorld.executionContext();
}
evaluateHandle<HandlerType extends JSHandle = JSHandle>(
pageFunction: EvaluateHandleFn,
...args: SerializableOrJSHandle[]
): Promise<HandlerType> {
return this._mainWorld.evaluateHandle<HandlerType>(pageFunction, ...args);
}
evaluate<T extends EvaluateFn>(
pageFunction: T,
...args: SerializableOrJSHandle[]
): Promise<UnwrapPromiseLike<EvaluateFnReturnType<T>>> {
return this._mainWorld.evaluate<T>(pageFunction, ...args);
}
url(): string {
return this.#url;
}
childFrames(): Frame[] {
return Array.from(this._childFrames);
}
_navigated(framePayload: TFrame): void {
this._name = framePayload.name;
this.#url = `${framePayload.url}${framePayload.urlFragment || ''}`;
}
_navigatedWithinDocument(url: string): void {
this.#url = url;
}
_onLifecycleEvent(loaderId: string, name: string): void {
if (name === 'init') {
this._loaderId = loaderId;
this._lifecycleEvents.clear();
}
this._lifecycleEvents.add(name);
}
_onLoadingStopped(): void {
this._lifecycleEvents.add('load');
}
_onLoadingStarted(): void {
this._hasStartedLoading = true;
}
_detach(): void {
this._mainWorld._detach();
this._secondaryWorld._detach();
if (this.#parentFrame) {
this.#parentFrame._childFrames.delete(this);
}
this.#parentFrame = null;
}
}