@remotion/renderer
Version:
Render Remotion videos using Node.js or Bun
244 lines (243 loc) • 11.9 kB
JavaScript
"use strict";
/**
* 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.
*/
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var _HeadlessBrowser_instances, _HeadlessBrowser_defaultViewport, _HeadlessBrowser_defaultContext, _HeadlessBrowser_contexts, _HeadlessBrowser_targets, _HeadlessBrowser_targetCreated, _HeadlessBrowser_targetDestroyed, _HeadlessBrowser_targetInfoChanged, _BrowserContext_browser;
Object.defineProperty(exports, "__esModule", { value: true });
exports.BrowserContext = exports.HeadlessBrowser = void 0;
const assert_1 = require("./assert");
const BrowserRunner_1 = require("./BrowserRunner");
const EventEmitter_1 = require("./EventEmitter");
const Target_1 = require("./Target");
const util_1 = require("./util");
class HeadlessBrowser extends EventEmitter_1.EventEmitter {
static async create({ defaultViewport, timeout, userDataDir, args, executablePath, logLevel, indent, }) {
const runner = await (0, BrowserRunner_1.makeBrowserRunner)({
executablePath,
processArguments: args,
userDataDir,
indent,
logLevel,
timeout,
});
const browser = new HeadlessBrowser({
connection: runner.connection,
defaultViewport,
runner,
});
await runner.connection.send('Target.setDiscoverTargets', { discover: true });
return browser;
}
get _targets() {
return __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f");
}
constructor({ connection, defaultViewport, runner, }) {
super();
_HeadlessBrowser_instances.add(this);
_HeadlessBrowser_defaultViewport.set(this, void 0);
_HeadlessBrowser_defaultContext.set(this, void 0);
_HeadlessBrowser_contexts.set(this, void 0);
_HeadlessBrowser_targets.set(this, void 0);
__classPrivateFieldSet(this, _HeadlessBrowser_defaultViewport, defaultViewport, "f");
this.connection = connection;
this.id = Math.random().toString(36).substring(2, 15);
__classPrivateFieldSet(this, _HeadlessBrowser_defaultContext, new BrowserContext(this), "f");
__classPrivateFieldSet(this, _HeadlessBrowser_contexts, new Map(), "f");
__classPrivateFieldSet(this, _HeadlessBrowser_targets, new Map(), "f");
this.connection.on('Target.targetCreated', __classPrivateFieldGet(this, _HeadlessBrowser_instances, "m", _HeadlessBrowser_targetCreated).bind(this));
this.connection.on('Target.targetDestroyed', __classPrivateFieldGet(this, _HeadlessBrowser_instances, "m", _HeadlessBrowser_targetDestroyed).bind(this));
this.connection.on('Target.targetInfoChanged', __classPrivateFieldGet(this, _HeadlessBrowser_instances, "m", _HeadlessBrowser_targetInfoChanged).bind(this));
this.runner = runner;
}
browserContexts() {
return [__classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f"), ...Array.from(__classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").values())];
}
newPage({ context, logLevel, indent, pageIndex, onBrowserLog, }) {
return __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f").newPage({
context,
logLevel,
indent,
pageIndex,
onBrowserLog,
});
}
async _createPageInContext({ context, logLevel, indent, pageIndex, onBrowserLog, }) {
const { value: { targetId }, } = await this.connection.send('Target.createTarget', {
url: 'about:blank',
browserContextId: undefined,
});
const target = __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").get(targetId);
if (!target) {
throw new Error(`Missing target for page (id = ${targetId})`);
}
const initialized = await target._initializedPromise;
if (!initialized) {
throw new Error(`Failed to create target for page (id = ${targetId})`);
}
const page = await target.page({
sourceMapGetter: context,
logLevel,
indent,
pageIndex,
onBrowserLog,
});
if (!page) {
throw new Error(`Failed to create a page for context`);
}
return page;
}
targets() {
return Array.from(__classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").values()).filter((target) => {
return target._isInitialized;
});
}
async waitForTarget(predicate, options = {}) {
const { timeout = 30000 } = options;
let resolve;
let isResolved = false;
const targetPromise = new Promise((x) => {
resolve = x;
});
this.on("targetcreated" /* BrowserEmittedEvents.TargetCreated */, check);
this.on("targetchanged" /* BrowserEmittedEvents.TargetChanged */, check);
try {
if (!timeout) {
return await targetPromise;
}
this.targets().forEach(check);
return await (0, util_1.waitWithTimeout)(targetPromise, 'target', timeout, this);
}
finally {
this.off("targetcreated" /* BrowserEmittedEvents.TargetCreated */, check);
this.off("targetchanged" /* BrowserEmittedEvents.TargetChanged */, check);
}
async function check(target) {
if ((await predicate(target)) && !isResolved) {
isResolved = true;
resolve(target);
}
}
}
async pages() {
const contextPages = await Promise.all(this.browserContexts().map((context) => {
return context.pages();
}));
// Flatten array.
return contextPages.reduce((acc, x) => {
return acc.concat(x);
}, []);
}
async close({ silent }) {
await this.runner.closeProcess();
(await this.pages()).forEach((page) => {
page.emit("disposed" /* PageEmittedEvents.Disposed */);
page.closed = true;
});
this.disconnect();
this.emit(silent ? "closed-silent" /* BrowserEmittedEvents.ClosedSilent */ : "closed" /* BrowserEmittedEvents.Closed */);
}
disconnect() {
this.connection.dispose();
}
}
exports.HeadlessBrowser = HeadlessBrowser;
_HeadlessBrowser_defaultViewport = new WeakMap(), _HeadlessBrowser_defaultContext = new WeakMap(), _HeadlessBrowser_contexts = new WeakMap(), _HeadlessBrowser_targets = new WeakMap(), _HeadlessBrowser_instances = new WeakSet(), _HeadlessBrowser_targetCreated = async function _HeadlessBrowser_targetCreated(event) {
var _a;
const { targetInfo } = event;
const { browserContextId } = targetInfo;
const context = browserContextId && __classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").has(browserContextId)
? __classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").get(browserContextId)
: __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f");
if (!context) {
throw new Error('Missing browser context');
}
const target = new Target_1.Target(targetInfo, context, () => {
return this.connection.createSession(targetInfo);
}, (_a = __classPrivateFieldGet(this, _HeadlessBrowser_defaultViewport, "f")) !== null && _a !== void 0 ? _a : null);
(0, assert_1.assert)(!__classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
__classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").set(event.targetInfo.targetId, target);
if (await target._initializedPromise) {
this.emit("targetcreated" /* BrowserEmittedEvents.TargetCreated */, target);
}
}, _HeadlessBrowser_targetDestroyed = function _HeadlessBrowser_targetDestroyed(event) {
const target = __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").get(event.targetId);
if (!target) {
throw new Error(`Missing target in _targetDestroyed (id = ${event.targetId})`);
}
target._initializedCallback(false);
__classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").delete(event.targetId);
target._closedCallback();
}, _HeadlessBrowser_targetInfoChanged = function _HeadlessBrowser_targetInfoChanged(event) {
const target = __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").get(event.targetInfo.targetId);
if (!target) {
throw new Error(`Missing target in targetInfoChanged (id = ${event.targetInfo.targetId})`);
}
const previousURL = target.url();
const wasInitialized = target._isInitialized;
target._targetInfoChanged(event.targetInfo);
if (wasInitialized && previousURL !== target.url()) {
this.emit("targetchanged" /* BrowserEmittedEvents.TargetChanged */, target);
}
};
class BrowserContext extends EventEmitter_1.EventEmitter {
constructor(browser) {
super();
_BrowserContext_browser.set(this, void 0);
__classPrivateFieldSet(this, _BrowserContext_browser, browser, "f");
}
targets() {
return __classPrivateFieldGet(this, _BrowserContext_browser, "f").targets().filter((target) => {
return target.browserContext() === this;
});
}
waitForTarget(predicate, options = {}) {
return __classPrivateFieldGet(this, _BrowserContext_browser, "f").waitForTarget((target) => {
return target.browserContext() === this && predicate(target);
}, options);
}
async pages() {
const pages = await Promise.all(this.targets()
.filter((target) => target.type() === 'page')
.map((target) => target.expectPage()));
return pages.filter((page) => {
return Boolean(page);
});
}
newPage({ context, logLevel, indent, pageIndex, onBrowserLog, }) {
return __classPrivateFieldGet(this, _BrowserContext_browser, "f")._createPageInContext({
context,
logLevel,
indent,
pageIndex,
onBrowserLog,
});
}
browser() {
return __classPrivateFieldGet(this, _BrowserContext_browser, "f");
}
}
exports.BrowserContext = BrowserContext;
_BrowserContext_browser = new WeakMap();