🎥 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 {Log} from '../logger';
import type {Commands} from './devtools-commands';
import type {TargetInfo} from './devtools-types';
import {ProtocolError} from './Errors';
import {EventEmitter} from './EventEmitter';
import type {NodeWebSocketTransport} from './NodeWebSocketTransport';
interface ConnectionCallback {
resolve: (value: {value: any; size: number}) => void;
reject: Function;
method: string;
params: object | null;
}
const ConnectionEmittedEvents = {
Disconnected: Symbol('Connection.Disconnected'),
} as const;
export class Connection extends EventEmitter {
transport: NodeWebSocketTransport;
#lastId = 0;
#sessions: Map<string, CDPSession> = new Map();
#closed = false;
#callbacks: Map<number, ConnectionCallback> = new Map();
constructor(transport: NodeWebSocketTransport) {
super();
this.transport = transport;
this.transport.onmessage = this.#onMessage.bind(this);
this.transport.onclose = this.#onClose.bind(this);
}
static fromSession(session: CDPSession): Connection | undefined {
return session.connection();
}
session(sessionId: string): CDPSession | null {
return this.#sessions.get(sessionId) || null;
}
send<T extends keyof Commands>(
method: T,
...paramArgs: Commands[T]['paramsType']
): Promise<{value: Commands[T]['returnType']; size: number}> {
// There is only ever 1 param arg passed, but the Protocol defines it as an
// array of 0 or 1 items See this comment:
// https://github.com/ChromeDevTools/devtools-protocol/pull/113#issuecomment-412603285
// which explains why the protocol defines the params this way for better
// type-inference.
// So now we check if there are any params or not and deal with them accordingly.
const params = paramArgs.length ? paramArgs[0] : undefined;
const id = this._rawSend({method, params});
return new Promise<{value: Commands[T]['returnType']; size: number}>(
(resolve, reject) => {
this.#callbacks.set(id, {
resolve,
reject,
method,
params: params ?? null,
});
},
);
}
_rawSend(message: Record<string, unknown>): number {
const id = ++this.#lastId;
const stringifiedMessage = JSON.stringify({...message, id});
this.transport.send(stringifiedMessage);
return id;
}
#onMessage(message: string): void {
const object = JSON.parse(message);
if (object.method === 'Target.attachedToTarget') {
const {sessionId} = object.params;
const session = new CDPSession(
this,
object.params.targetInfo.type,
sessionId,
);
this.#sessions.set(sessionId, session);
this.emit('sessionattached', session);
const parentSession = this.#sessions.get(object.sessionId);
if (parentSession) {
parentSession.emit('sessionattached', session);
}
} else if (object.method === 'Target.detachedFromTarget') {
const session = this.#sessions.get(object.params.sessionId);
if (session) {
session._onClosed();
this.#sessions.delete(object.params.sessionId);
this.emit('sessiondetached', session);
const parentSession = this.#sessions.get(object.sessionId);
if (parentSession) {
parentSession.emit('sessiondetached', session);
}
}
}
if (object.sessionId) {
const session = this.#sessions.get(object.sessionId);
if (session) {
session._onMessage(object, message.length);
}
} else if (object.id) {
const callback = this.#callbacks.get(object.id);
// Callbacks could be all rejected if someone has called `.dispose()`.
if (callback) {
this.#callbacks.delete(object.id);
if (object.error) {
callback.reject(createProtocolError(callback.method, object));
} else {
callback.resolve({value: object.result, size: message.length});
}
}
} else {
this.emit(object.method, object.params);
}
}
#onClose(): void {
if (this.#closed) {
return;
}
this.transport.onmessage = undefined;
this.transport.onclose = undefined;
for (const callback of this.#callbacks.values()) {
callback.reject(
rewriteError(
new ProtocolError(),
`Protocol error (${callback.method}): Target closed. https://www.remotion.dev/docs/target-closed`,
),
);
}
this.#callbacks.clear();
for (const session of this.#sessions.values()) {
session._onClosed();
}
this.#sessions.clear();
this.emit(ConnectionEmittedEvents.Disconnected);
}
dispose(): void {
this.#onClose();
this.transport.close();
}
/**
* @param targetInfo - The target info
* @returns The CDP session that is created
*/
async createSession(targetInfo: TargetInfo): Promise<CDPSession> {
const {
value: {sessionId},
} = await this.send('Target.attachToTarget', {
targetId: targetInfo.targetId,
flatten: true,
});
const session = this.#sessions.get(sessionId);
if (!session) {
throw new Error('CDPSession creation failed.');
}
return session;
}
}
interface CDPSessionOnMessageObject {
id?: number;
method: string;
params: Record<string, unknown>;
error: {message: string; data: any; code: number};
result?: any;
}
export const CDPSessionEmittedEvents = {
Disconnected: Symbol('CDPSession.Disconnected'),
} as const;
export class CDPSession extends EventEmitter {
#sessionId: string;
#targetType: string;
#callbacks: Map<number, ConnectionCallback> = new Map();
#connection?: Connection;
constructor(connection: Connection, targetType: string, sessionId: string) {
super();
this.#connection = connection;
this.#targetType = targetType;
this.#sessionId = sessionId;
}
connection(): Connection | undefined {
return this.#connection;
}
send<T extends keyof Commands>(
method: T,
...paramArgs: Commands[T]['paramsType']
): Promise<{value: Commands[T]['returnType']; size: number}> {
if (!this.#connection) {
return Promise.reject(
new Error(
`Protocol error (${method}): Session closed. Most likely the ${this.#targetType} has been closed.`,
),
);
}
// See the comment in Connection#send explaining why we do this.
const params = paramArgs.length ? paramArgs[0] : undefined;
const id = this.#connection._rawSend({
sessionId: this.#sessionId,
method,
params,
});
return new Promise<{value: Commands[T]['returnType']; size: number}>(
(resolve, reject) => {
if (this.#callbacks.size > 100) {
for (const callback of this.#callbacks.values()) {
Log.info(
{indent: false, logLevel: 'info'},
callback.method + JSON.stringify(callback.params),
);
}
throw new Error('Leak detected: Too many callbacks');
}
this.#callbacks.set(id, {
resolve,
reject,
method,
params: params ?? null,
});
},
);
}
_onMessage(object: CDPSessionOnMessageObject, size: number): void {
const callback = object.id ? this.#callbacks.get(object.id) : undefined;
if (object.id && callback) {
this.#callbacks.delete(object.id);
if (object.error) {
callback.reject(createProtocolError(callback.method, object));
} else {
callback.resolve({value: object.result, size});
}
} else {
this.emit(object.method, object.params);
}
}
_onClosed(): void {
this.#connection = undefined;
for (const callback of this.#callbacks.values()) {
callback.reject(
rewriteError(
new ProtocolError(),
`Protocol error (${callback.method}): Target closed. https://www.remotion.dev/docs/target-closed`,
),
);
}
this.#callbacks.clear();
this.emit(CDPSessionEmittedEvents.Disconnected);
}
id(): string {
return this.#sessionId;
}
}
function createProtocolError(
method: string,
object: {error: {message: string; data: any; code: number}},
): Error {
let message = `Protocol error (${method}): ${object.error.message}`;
if ('data' in object.error) {
message += ` ${object.error.data}`;
}
return rewriteError(new ProtocolError(), message, object.error.message);
}
function rewriteError(
error: ProtocolError,
message: string,
originalMessage?: string,
): Error {
error.message = message;
error.originalMessage = originalMessage ?? error.originalMessage;
return error;
}