🎥 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 {NoReactInternals} from 'remotion/no-react';
import {BrowserLog} from '../browser-log';
import {formatRemoteObject} from '../format-logs';
import type {LogLevel} from '../log-level';
import {isEqualOrBelowLogLevel} from '../log-level';
import {Log} from '../logger';
import {truthy} from '../truthy';
import {assert} from './assert';
import type {HeadlessBrowser} from './Browser';
import type {CDPSession} from './Connection';
import type {ConsoleMessageType} from './ConsoleMessage';
import {ConsoleMessage} from './ConsoleMessage';
import type {
AttachedToTargetEvent,
BindingCalledEvent,
ConsoleAPICalledEvent,
DevtoolsRemoteObject,
EntryAddedEvent,
SetDeviceMetricsOverrideRequest,
StackTrace,
} from './devtools-types';
import type {
EvaluateFn,
EvaluateFnReturnType,
EvaluateHandleFn,
SerializableOrJSHandle,
UnwrapPromiseLike,
} from './EvalTypes';
import {EventEmitter} from './EventEmitter';
import type {Frame} from './FrameManager';
import {FrameManager} from './FrameManager';
import type {HTTPResponse} from './HTTPResponse';
import type {JSHandle} from './JSHandle';
import {_createJSHandle} from './JSHandle';
import type {Viewport} from './PuppeteerViewport';
import type {SourceMapGetter} from './source-map-getter';
import type {Target} from './Target';
import {TaskQueue} from './TaskQueue';
import {TimeoutSettings} from './TimeoutSettings';
import {
evaluationString,
isErrorLike,
pageBindingDeliverErrorString,
pageBindingDeliverErrorValueString,
pageBindingDeliverResultString,
releaseObject,
valueFromRemoteObject,
} from './util';
interface WaitForOptions {
timeout?: number;
}
const shouldHideWarning = (log: ConsoleMessage) => {
// Mixed Content warnings caused by localhost should not be displayed
if (
log.text.includes('Mixed Content:') &&
log.text.includes('http://localhost:')
) {
return true;
}
return false;
};
export const enum PageEmittedEvents {
Error = 'error',
Disposed = 'disposed',
}
interface PageEventObject {
console: ConsoleMessage;
error: Error;
disposed: undefined;
}
const format = (
eventType: ConsoleMessageType,
args: DevtoolsRemoteObject[],
) => {
const previewString = args
.filter(
(a) => !(a.type === 'symbol' && a.description?.includes(`__remotion_`)),
)
.map((a) => formatRemoteObject(a))
.filter(Boolean)
.join(' ');
let logLevelFromRemotionLog: LogLevel | null = null;
let tag: string | null = null;
for (const a of args) {
if (a.type === 'symbol' && a.description?.includes(`__remotion_level_`)) {
logLevelFromRemotionLog = a.description
?.split('__remotion_level_')?.[1]
?.replace(')', '') as LogLevel;
}
if (a.type === 'symbol' && a.description?.includes(`__remotion_tag_`)) {
tag = a.description?.split('__remotion_tag_')?.[1]?.replace(')', '');
}
}
const logLevelFromEvent: LogLevel =
eventType === 'debug'
? 'verbose'
: eventType === 'error'
? 'error'
: eventType === 'warning'
? 'warn'
: 'verbose';
return {previewString, logLevelFromRemotionLog, logLevelFromEvent, tag};
};
export type OnLog = ({
logLevel,
previewString,
tag,
}: {
logLevel: LogLevel;
tag: string;
previewString: string;
}) => void;
export class Page extends EventEmitter {
id: string;
static async _create({
client,
target,
defaultViewport,
browser,
sourceMapGetter,
logLevel,
indent,
pageIndex,
onBrowserLog,
onLog,
}: {
client: CDPSession;
target: Target;
defaultViewport: Viewport;
browser: HeadlessBrowser;
sourceMapGetter: SourceMapGetter;
logLevel: LogLevel;
indent: boolean;
pageIndex: number;
onBrowserLog: null | ((log: BrowserLog) => void);
onLog: OnLog;
}): Promise<Page> {
const page = new Page({
client,
target,
browser,
sourceMapGetter,
logLevel,
indent,
pageIndex,
onBrowserLog,
onLog,
});
await page.#initialize();
await page.setViewport(defaultViewport);
return page;
}
closed = false;
#client: CDPSession;
#target: Target;
#timeoutSettings = new TimeoutSettings();
#frameManager: FrameManager;
#pageBindings = new Map<string, Function>();
browser: HeadlessBrowser;
screenshotTaskQueue: TaskQueue;
sourceMapGetter: SourceMapGetter;
logLevel: LogLevel;
indent: boolean;
pageIndex: number;
onBrowserLog: null | ((log: BrowserLog) => void);
onLog: OnLog;
constructor({
client,
target,
browser,
sourceMapGetter,
logLevel,
indent,
pageIndex,
onBrowserLog,
onLog,
}: {
client: CDPSession;
target: Target;
browser: HeadlessBrowser;
sourceMapGetter: SourceMapGetter;
logLevel: LogLevel;
indent: boolean;
pageIndex: number;
onBrowserLog: null | ((log: BrowserLog) => void);
onLog: OnLog;
}) {
super();
this.#client = client;
this.#target = target;
this.#frameManager = new FrameManager(client, this, indent, logLevel);
this.screenshotTaskQueue = new TaskQueue();
this.browser = browser;
this.id = String(Math.random());
this.sourceMapGetter = sourceMapGetter;
this.logLevel = logLevel;
this.indent = indent;
this.pageIndex = pageIndex;
this.onBrowserLog = onBrowserLog;
this.onLog = onLog;
client.on('Target.attachedToTarget', (event: AttachedToTargetEvent) => {
switch (event.targetInfo.type) {
case 'iframe':
break;
case 'worker':
break;
default:
// If we don't detach from service workers, they will never die.
// We still want to attach to workers for emitting events.
// We still want to attach to iframes so sessions may interact with them.
// We detach from all other types out of an abundance of caution.
// See https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/devtools_agent_host_impl.cc?ss=chromium&q=f:devtools%20-f:out%20%22::kTypePage%5B%5D%22
// for the complete list of available types.
client
.send('Target.detachFromTarget', {
sessionId: event.sessionId,
})
.catch((err) => Log.error({indent, logLevel}, err));
}
});
client.on('Runtime.consoleAPICalled', (event) => {
return this.#onConsoleAPI(event);
});
client.on('Runtime.bindingCalled', (event) => {
return this.#onBindingCalled(event);
});
client.on('Inspector.targetCrashed', () => {
return this.#onTargetCrashed();
});
client.on('Log.entryAdded', (event) => {
return this.#onLogEntryAdded(event);
});
}
#onConsole = (log: ConsoleMessage) => {
const stackTrace = log.stackTrace();
const {url, columnNumber, lineNumber} = stackTrace[0] ?? {};
const logLevel = this.logLevel;
const indent = this.indent;
if (shouldHideWarning(log)) {
return;
}
this.onBrowserLog?.({
stackTrace,
text: log.text,
type: log.type,
});
if (
url?.endsWith(NoReactInternals.bundleName) &&
lineNumber &&
this.sourceMapGetter()
) {
if (!isEqualOrBelowLogLevel(logLevel, log.logLevel)) {
return;
}
const origPosition = this.sourceMapGetter()?.originalPositionFor({
column: columnNumber ?? 0,
line: lineNumber,
});
const file = [
origPosition?.source,
origPosition?.line,
origPosition?.column,
]
.filter(truthy)
.join(':');
const isDelayRenderClear = log.previewString.includes(
NoReactInternals.DELAY_RENDER_CLEAR_TOKEN,
);
const tabInfo = `Tab ${this.pageIndex}`;
const tagInfo = [origPosition?.name, isDelayRenderClear ? null : file]
.filter(truthy)
.join('@');
const tag = [tabInfo, log.tag, log.tag ? null : tagInfo]
.filter(truthy)
.join(', ');
this.onLog({
logLevel: log.logLevel,
tag,
previewString: log.previewString,
});
} else if (log.type === 'error') {
if (log.text.includes('Failed to load resource:')) {
Log.error(
{logLevel, tag: url, indent},
// Sometimes the log is like this:
// Failed to load resource: the server responded with a status of 404 ()
// We remove the empty parentheses.
log.text.replace(/\(\)$/, ''),
);
} else {
Log.error({logLevel, tag: `console.${log.type}`, indent}, log.text);
}
} else {
Log.verbose({logLevel, tag: `console.${log.type}`, indent}, log.text);
}
};
async #initialize(): Promise<void> {
await Promise.all([
this.#frameManager.initialize(),
this.#client.send('Target.setAutoAttach', {
autoAttach: true,
waitForDebuggerOnStart: false,
flatten: true,
}),
this.#client.send('Performance.enable'),
this.#client.send('Log.enable'),
]);
}
/**
* Listen to page events.
*/
// Note: this method exists to define event typings and handle
// proper wireup of cooperative request interception. Actual event listening and
// dispatching is delegated to EventEmitter.
public override on<K extends keyof PageEventObject>(
eventName: K,
handler: (event: PageEventObject[K]) => void,
): EventEmitter {
return super.on(eventName, handler);
}
public override once<K extends keyof PageEventObject>(
eventName: K,
handler: (event: PageEventObject[K]) => void,
): EventEmitter {
// Note: this method only exists to define the types; we delegate the impl
// to EventEmitter.
return super.once(eventName, handler);
}
override off<K extends keyof PageEventObject>(
eventName: K,
handler: (event: PageEventObject[K]) => void,
): EventEmitter {
return super.off(eventName, handler);
}
/**
* @returns A target this page was created from.
*/
target(): Target {
return this.#target;
}
_client(): CDPSession {
return this.#client;
}
#onTargetCrashed(): void {
// This error message is being checked against in is-flaky-error.ts
this.emit('error', new Error('Page crashed!'));
}
#onLogEntryAdded(event: EntryAddedEvent): void {
const {level, text, args, source, url, lineNumber} = event.entry;
if (args) {
args.map((arg) => {
return releaseObject(this.#client, arg);
});
}
const {previewString, logLevelFromRemotionLog, logLevelFromEvent, tag} =
format(level, args ?? []);
if (source !== 'worker') {
const message = new ConsoleMessage({
type: level,
text,
args: [],
stackTraceLocations: [{url, lineNumber}],
previewString,
logLevel: logLevelFromRemotionLog ?? logLevelFromEvent,
tag,
});
this.onBrowserLog?.({
stackTrace: message.stackTrace(),
text: message.text,
type: message.type,
});
this.#onConsole(message);
}
}
/**
* @returns The page's main frame.
* @remarks
* Page is guaranteed to have a main frame which persists during navigations.
*/
mainFrame(): Frame {
return this.#frameManager.mainFrame();
}
async setViewport(viewport: Viewport): Promise<void> {
const fromSurface = !process.env.DISABLE_FROM_SURFACE;
const request: SetDeviceMetricsOverrideRequest = fromSurface
? {
mobile: false,
width: viewport.width,
height: viewport.height,
deviceScaleFactor: viewport.deviceScaleFactor,
screenOrientation: {
angle: 0,
type: 'portraitPrimary',
},
}
: {
mobile: false,
width: viewport.width,
height: viewport.height,
// View scaling resamples painted pixels instead of increasing their density.
deviceScaleFactor: viewport.deviceScaleFactor,
screenHeight: viewport.height,
screenWidth: viewport.width,
scale: 1,
viewport: {
height: viewport.height,
width: viewport.width,
scale: 1,
x: 0,
y: 0,
},
};
const {value} = await this.#client.send(
'Emulation.setDeviceMetricsOverride',
request,
);
return value;
}
setDefaultNavigationTimeout(timeout: number): void {
this.#timeoutSettings.setDefaultNavigationTimeout(timeout);
}
setDefaultTimeout(timeout: number): void {
this.#timeoutSettings.setDefaultTimeout(timeout);
}
async evaluateHandle<HandlerType extends JSHandle = JSHandle>(
pageFunction: EvaluateHandleFn,
...args: SerializableOrJSHandle[]
): Promise<HandlerType> {
const context = await this.mainFrame().executionContext();
return context.evaluateHandle<HandlerType>(pageFunction, ...args);
}
#onConsoleAPI(event: ConsoleAPICalledEvent): void {
if (event.executionContextId === 0) {
return;
}
const context = this.#frameManager.executionContextById(
event.executionContextId,
this.#client,
);
const values = event.args.map((arg) => {
return _createJSHandle(context, arg);
});
this.#addConsoleMessage(event.type, values, event.stackTrace);
}
async #onBindingCalled(event: BindingCalledEvent): Promise<void> {
let payload: {type: string; name: string; seq: number; args: unknown[]};
try {
payload = JSON.parse(event.payload);
} catch {
// The binding was either called by something in the page or it was
// called before our wrapper was initialized.
return;
}
const {type, name, seq, args} = payload;
if (type !== 'exposedFun' || !this.#pageBindings.has(name)) {
return;
}
let expression = null;
try {
const pageBinding = this.#pageBindings.get(name);
assert(pageBinding);
const result = await pageBinding(...args);
expression = pageBindingDeliverResultString(name, seq, result);
} catch (_error) {
if (isErrorLike(_error)) {
expression = pageBindingDeliverErrorString(
name,
seq,
_error.message,
_error.stack,
);
} else {
expression = pageBindingDeliverErrorValueString(name, seq, _error);
}
}
await this.#client.send('Runtime.evaluate', {
expression,
contextId: event.executionContextId,
});
}
#addConsoleMessage(
eventType: ConsoleMessageType,
args: JSHandle[],
stackTrace?: StackTrace,
): void {
const textTokens = [];
for (const arg of args) {
const remoteObject = arg._remoteObject;
if (remoteObject.objectId) {
textTokens.push(arg.toString());
} else {
textTokens.push(valueFromRemoteObject(remoteObject));
}
}
const stackTraceLocations = [];
if (stackTrace) {
for (const callFrame of stackTrace.callFrames) {
stackTraceLocations.push({
url: callFrame.url,
lineNumber: callFrame.lineNumber,
columnNumber: callFrame.columnNumber,
});
}
}
const {previewString, logLevelFromRemotionLog, logLevelFromEvent, tag} =
format(eventType, args.map((a) => a._remoteObject) ?? []);
const logLevel = (logLevelFromRemotionLog as LogLevel) ?? logLevelFromEvent;
const message = new ConsoleMessage({
type: eventType,
text: textTokens.join(' '),
args,
stackTraceLocations,
previewString,
logLevel,
tag,
});
this.#onConsole(message);
}
url(): string {
return this.mainFrame().url();
}
goto({
url,
timeout,
options = {},
}: {
url: string;
timeout: number;
options?: WaitForOptions & {referer?: string};
}): Promise<HTTPResponse | null> {
return this.#frameManager.mainFrame().goto(url, timeout, options);
}
async bringToFront(): Promise<void> {
await this.#client.send('Page.bringToFront');
}
async setAutoDarkModeOverride(): Promise<void> {
await this.#client.send('Emulation.setEmulatedMedia', {
media: 'screen',
features: [
{
name: 'prefers-color-scheme',
value: 'dark',
},
],
});
}
evaluate<T extends EvaluateFn>(
pageFunction: T,
...args: SerializableOrJSHandle[]
): Promise<UnwrapPromiseLike<EvaluateFnReturnType<T>>> {
return this.#frameManager.mainFrame().evaluate<T>(pageFunction, ...args);
}
async evaluateOnNewDocument(
pageFunction: Function | string,
...args: unknown[]
): Promise<void> {
const source = evaluationString(pageFunction, ...args);
await this.#client.send('Page.addScriptToEvaluateOnNewDocument', {
source,
});
}
async close(
options: {runBeforeUnload?: boolean} = {runBeforeUnload: undefined},
): Promise<void> {
const connection = this.#client.connection();
if (!connection) {
return;
}
const runBeforeUnload = Boolean(options.runBeforeUnload);
if (runBeforeUnload) {
await this.#client.send('Page.close');
} else {
await connection.send('Target.closeTarget', {
targetId: this.#target._targetId,
});
await this.#target._isClosedPromise;
}
}
setBrowserSourceMapGetter(context: SourceMapGetter) {
this.sourceMapGetter = context;
}
}