🎥 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 {assert} from './assert';
import type {HeadlessBrowser} from './Browser';
import {BrowserEmittedEvents} from './Browser';
import type {CDPSession} from './Connection';
import type {DevtoolsRemoteObject, ExceptionDetails} from './devtools-types';
import {TimeoutError} from './Errors';
import type {CommonEventEmitter} from './EventEmitter';
export function getExceptionMessage(
exceptionDetails: ExceptionDetails,
): string {
if (exceptionDetails.exception) {
return (
exceptionDetails.exception.description || exceptionDetails.exception.value
);
}
let message = exceptionDetails.text;
if (exceptionDetails.stackTrace) {
for (const callframe of exceptionDetails.stackTrace.callFrames) {
const location =
callframe.url +
':' +
callframe.lineNumber +
':' +
callframe.columnNumber;
const functionName = callframe.functionName || '<anonymous>';
message += `\n at ${functionName} (${location})`;
}
}
return message;
}
export function valueFromRemoteObject(remoteObject: DevtoolsRemoteObject) {
assert(!remoteObject.objectId, 'Cannot extract value when objectId is given');
if (remoteObject.unserializableValue) {
if (remoteObject.type === 'bigint' && typeof BigInt !== 'undefined') {
return BigInt(remoteObject.unserializableValue.replace('n', ''));
}
switch (remoteObject.unserializableValue) {
case '-0':
return -0;
case 'NaN':
return NaN;
case 'Infinity':
return Infinity;
case '-Infinity':
return -Infinity;
default:
throw new Error(
'Unsupported unserializable value: ' +
remoteObject.unserializableValue,
);
}
}
return remoteObject.value;
}
export async function releaseObject(
client: CDPSession,
remoteObject: DevtoolsRemoteObject,
): Promise<void> {
if (!remoteObject.objectId) {
return;
}
await client
.send('Runtime.releaseObject', {objectId: remoteObject.objectId})
.catch(() => {
// Exceptions might happen in case of a page been navigated or closed.
// Swallow these since they are harmless and we don't leak anything in this case.
});
}
export function addEventListener(
emitter: CommonEventEmitter,
eventName: string | symbol,
handler: (...args: any[]) => void,
) {
emitter.on(eventName, handler);
return () => emitter.off(eventName, handler);
}
export function removeEventListeners(listeners: Array<() => void>): void {
for (const listener of listeners) {
listener();
}
listeners.length = 0;
}
export const isString = (obj: unknown): obj is string => {
return typeof obj === 'string' || obj instanceof String;
};
export function evaluationString(
fun: Function | string,
...args: unknown[]
): string {
if (isString(fun)) {
assert(args.length === 0, 'Cannot evaluate a string with arguments');
return fun;
}
function serializeArgument(arg: unknown): string {
if (Object.is(arg, undefined)) {
return 'undefined';
}
return JSON.stringify(arg);
}
return `(${fun})(${args.map(serializeArgument).join(',')})`;
}
export function pageBindingDeliverResultString(
name: string,
seq: number,
result: unknown,
): string {
function deliverResult(_name: string, _seq: number, _result: unknown): void {
(window as any)[_name].callbacks.get(_seq).resolve(_result);
(window as any)[_name].callbacks.delete(_seq);
}
return evaluationString(deliverResult, name, seq, result);
}
export function pageBindingDeliverErrorString(
name: string,
seq: number,
message: string,
stack?: string,
): string {
function deliverError(
_name: string,
_seq: number,
_message: string,
_stack?: string,
): void {
const error = new Error(_message);
error.stack = _stack;
(window as any)[_name].callbacks.get(_seq).reject(error);
(window as any)[_name].callbacks.delete(_seq);
}
return evaluationString(deliverError, name, seq, message, stack);
}
export function pageBindingDeliverErrorValueString(
name: string,
seq: number,
value: unknown,
): string {
function deliverErrorValue(
_name: string,
_seq: number,
_value: unknown,
): void {
(window as any)[_name].callbacks.get(_seq).reject(_value);
(window as any)[_name].callbacks.delete(_seq);
}
return evaluationString(deliverErrorValue, name, seq, value);
}
export async function waitWithTimeout<T>(
promise: Promise<T>,
taskName: string,
timeout: number,
browser: HeadlessBrowser,
): Promise<T> {
let reject: (reason?: Error) => void;
const timeoutError = new TimeoutError(
`waiting for ${taskName} failed: timeout ${timeout}ms exceeded`,
);
const timeoutPromise = new Promise<T>((_res, rej) => {
reject = rej;
});
let timeoutTimer = null;
if (timeout) {
timeoutTimer = setTimeout(() => {
return reject(timeoutError);
}, timeout);
}
try {
return await Promise.race([
new Promise<T>((_, rej) => {
browser.once(BrowserEmittedEvents.Closed, () => {
return rej();
});
}),
promise,
timeoutPromise,
]);
} finally {
if (timeoutTimer) {
clearTimeout(timeoutTimer);
}
}
}
interface ErrorLike extends Error {
name: string;
message: string;
}
export function isErrorLike(obj: unknown): obj is ErrorLike {
return (
typeof obj === 'object' && obj !== null && 'name' in obj && 'message' in obj
);
}
export function isErrnoException(obj: unknown): obj is NodeJS.ErrnoException {
return (
isErrorLike(obj) &&
('errno' in obj || 'code' in obj || 'path' in obj || 'syscall' in obj)
);
}