@remotion/renderer 3.0.20 → 3.0.23

package/dist/browser/Browser.js

@@ -0,0 +1,402 @@
+"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 __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 __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 _Browser_instances, _Browser_defaultViewport, _Browser_process, _Browser_connection, _Browser_closeCallback, _Browser_defaultContext, _Browser_contexts, _Browser_targets, _Browser_targetCreated, _Browser_targetDestroyed, _Browser_targetInfoChanged, _Browser_getVersion, _BrowserContext_browser, _BrowserContext_id;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserContext = exports.Browser = void 0;
+const assert_1 = require("./assert");
+const EventEmitter_1 = require("./EventEmitter");
+const Target_1 = require("./Target");
+const util_1 = require("./util");
+class Browser extends EventEmitter_1.EventEmitter {
+    // eslint-disable-next-line max-params
+    constructor(connection, contextIds, defaultViewport, process, closeCallback) {
+        super();
+        _Browser_instances.add(this);
+        _Browser_defaultViewport.set(this, void 0);
+        _Browser_process.set(this, void 0);
+        _Browser_connection.set(this, void 0);
+        _Browser_closeCallback.set(this, void 0);
+        _Browser_defaultContext.set(this, void 0);
+        _Browser_contexts.set(this, void 0);
+        _Browser_targets.set(this, void 0);
+        __classPrivateFieldSet(this, _Browser_defaultViewport, defaultViewport, "f");
+        __classPrivateFieldSet(this, _Browser_process, process, "f");
+        __classPrivateFieldSet(this, _Browser_connection, connection, "f");
+        __classPrivateFieldSet(this, _Browser_closeCallback, closeCallback ||
+            function () {
+                return undefined;
+            }, "f");
+        __classPrivateFieldSet(this, _Browser_defaultContext, new BrowserContext(this), "f");
+        __classPrivateFieldSet(this, _Browser_contexts, new Map(), "f");
+        for (const contextId of contextIds) {
+            __classPrivateFieldGet(this, _Browser_contexts, "f").set(contextId, new BrowserContext(this, contextId));
+        }
+        __classPrivateFieldSet(this, _Browser_targets, new Map(), "f");
+        __classPrivateFieldGet(this, _Browser_connection, "f").on('Target.targetCreated', __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_targetCreated).bind(this));
+        __classPrivateFieldGet(this, _Browser_connection, "f").on('Target.targetDestroyed', __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_targetDestroyed).bind(this));
+        __classPrivateFieldGet(this, _Browser_connection, "f").on('Target.targetInfoChanged', __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_targetInfoChanged).bind(this));
+    }
+    static async _create({ connection, contextIds, defaultViewport, process, closeCallback, }) {
+        const browser = new Browser(connection, contextIds, defaultViewport, process, closeCallback);
+        await connection.send('Target.setDiscoverTargets', { discover: true });
+        return browser;
+    }
+    get _targets() {
+        return __classPrivateFieldGet(this, _Browser_targets, "f");
+    }
+    /**
+     * The spawned browser process. Returns `null` if the browser instance was created with
+     * {@link Puppeteer.connect}.
+     */
+    process() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _Browser_process, "f")) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Creates a new incognito browser context. This won't share cookies/cache with other
+     * browser contexts.
+     *
+     * @example
+     * ```js
+     * (async () => {
+     *  const browser = await puppeteer.launch();
+     *   // Create a new incognito browser context.
+     *   const context = await browser.createIncognitoBrowserContext();
+     *   // Create a new page in a pristine context.
+     *   const page = await context.newPage();
+     *   // Do stuff
+     *   await page.goto('https://example.com');
+     * })();
+     * ```
+     */
+    async createIncognitoBrowserContext(options = {}) {
+        const { proxyServer, proxyBypassList } = options;
+        const { browserContextId } = await __classPrivateFieldGet(this, _Browser_connection, "f").send('Target.createBrowserContext', {
+            proxyServer,
+            proxyBypassList: proxyBypassList === null || proxyBypassList === void 0 ? void 0 : proxyBypassList.join(','),
+        });
+        const context = new BrowserContext(this, browserContextId);
+        __classPrivateFieldGet(this, _Browser_contexts, "f").set(browserContextId, context);
+        return context;
+    }
+    /**
+     * Returns an array of all open browser contexts. In a newly created browser, this will
+     * return a single instance of {@link BrowserContext}.
+     */
+    browserContexts() {
+        return [__classPrivateFieldGet(this, _Browser_defaultContext, "f"), ...Array.from(__classPrivateFieldGet(this, _Browser_contexts, "f").values())];
+    }
+    /**
+     * Returns the default browser context. The default browser context cannot be closed.
+     */
+    defaultBrowserContext() {
+        return __classPrivateFieldGet(this, _Browser_defaultContext, "f");
+    }
+    async _disposeContext(contextId) {
+        if (!contextId) {
+            return;
+        }
+        await __classPrivateFieldGet(this, _Browser_connection, "f").send('Target.disposeBrowserContext', {
+            browserContextId: contextId,
+        });
+        __classPrivateFieldGet(this, _Browser_contexts, "f").delete(contextId);
+    }
+    /**
+     * The browser websocket endpoint which can be used as an argument to
+     * {@link Puppeteer.connect}.
+     *
+     * @returns The Browser websocket url.
+     *
+     * @remarks
+     *
+     * The format is `ws://${host}:${port}/devtools/browser/<id>`.
+     *
+     * You can find the `webSocketDebuggerUrl` from `http://${host}:${port}/json/version`.
+     * Learn more about the
+     * {@link https://chromedevtools.github.io/devtools-protocol | devtools protocol} and
+     * the {@link
+     * https://chromedevtools.github.io/devtools-protocol/#how-do-i-access-the-browser-target
+     * | browser endpoint}.
+     */
+    wsEndpoint() {
+        return __classPrivateFieldGet(this, _Browser_connection, "f").url();
+    }
+    /**
+     * Promise which resolves to a new {@link Page} object. The Page is created in
+     * a default browser context.
+     */
+    newPage() {
+        return __classPrivateFieldGet(this, _Browser_defaultContext, "f").newPage();
+    }
+    async _createPageInContext(contextId) {
+        const { targetId } = await __classPrivateFieldGet(this, _Browser_connection, "f").send('Target.createTarget', {
+            url: 'about:blank',
+            browserContextId: contextId || undefined,
+        });
+        const target = __classPrivateFieldGet(this, _Browser_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();
+        if (!page) {
+            throw new Error(`Failed to create a page for context (id = ${contextId})`);
+        }
+        return page;
+    }
+    /**
+     * All active targets inside the Browser. In case of multiple browser contexts, returns
+     * an array with all the targets in all browser contexts.
+     */
+    targets() {
+        return Array.from(__classPrivateFieldGet(this, _Browser_targets, "f").values()).filter((target) => {
+            return target._isInitialized;
+        });
+    }
+    /**
+     * The target associated with the browser.
+     */
+    target() {
+        const browserTarget = this.targets().find((target) => {
+            return target.type() === 'browser';
+        });
+        if (!browserTarget) {
+            throw new Error('Browser target is not found');
+        }
+        return browserTarget;
+    }
+    /**
+     * Searches for a target in all browser contexts.
+     *
+     * @param predicate - A function to be run for every target.
+     * @returns The first target found that matches the `predicate` function.
+     *
+     * @example
+     *
+     * An example of finding a target for a page opened via `window.open`:
+     * ```js
+     * await page.evaluate(() => window.open('https://www.example.com/'));
+     * const newWindowTarget = await browser.waitForTarget(target => target.url() === 'https://www.example.com/');
+     * ```
+     */
+    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);
+        }
+        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);
+            }
+        }
+    }
+    /**
+     * An array of all open pages inside the Browser.
+     *
+     * @remarks
+     *
+     * In case of multiple browser contexts, returns an array with all the pages in all
+     * browser contexts. Non-visible pages, such as `"background_page"`, will not be listed
+     * here. You can find them using {@link Target.page}.
+     */
+    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);
+        }, []);
+    }
+    /**
+     * A string representing the browser name and version.
+     *
+     * @remarks
+     *
+     * For headless Chromium, this is similar to `HeadlessChrome/61.0.3153.0`. For
+     * non-headless, this is similar to `Chrome/61.0.3153.0`.
+     *
+     * The format of browser.version() might change with future releases of Chromium.
+     */
+    async version() {
+        const version = await __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_getVersion).call(this);
+        return version.product;
+    }
+    /**
+     * The browser's original user agent. Pages can override the browser user agent with
+     * {@link Page.setUserAgent}.
+     */
+    async userAgent() {
+        const version = await __classPrivateFieldGet(this, _Browser_instances, "m", _Browser_getVersion).call(this);
+        return version.userAgent;
+    }
+    /**
+     * Closes Chromium and all of its pages (if any were opened). The {@link Browser} object
+     * itself is considered to be disposed and cannot be used anymore.
+     */
+    async close() {
+        await __classPrivateFieldGet(this, _Browser_closeCallback, "f").call(null);
+        this.disconnect();
+    }
+    /**
+     * Disconnects Puppeteer from the browser, but leaves the Chromium process running.
+     * After calling `disconnect`, the {@link Browser} object is considered disposed and
+     * cannot be used anymore.
+     */
+    disconnect() {
+        __classPrivateFieldGet(this, _Browser_connection, "f").dispose();
+    }
+    /**
+     * Indicates that the browser is connected.
+     */
+    isConnected() {
+        return !__classPrivateFieldGet(this, _Browser_connection, "f")._closed;
+    }
+}
+exports.Browser = Browser;
+_Browser_defaultViewport = new WeakMap(), _Browser_process = new WeakMap(), _Browser_connection = new WeakMap(), _Browser_closeCallback = new WeakMap(), _Browser_defaultContext = new WeakMap(), _Browser_contexts = new WeakMap(), _Browser_targets = new WeakMap(), _Browser_instances = new WeakSet(), _Browser_targetCreated = async function _Browser_targetCreated(event) {
+    var _a;
+    const { targetInfo } = event;
+    const { browserContextId } = targetInfo;
+    const context = browserContextId && __classPrivateFieldGet(this, _Browser_contexts, "f").has(browserContextId)
+        ? __classPrivateFieldGet(this, _Browser_contexts, "f").get(browserContextId)
+        : __classPrivateFieldGet(this, _Browser_defaultContext, "f");
+    if (!context) {
+        throw new Error('Missing browser context');
+    }
+    const target = new Target_1.Target(targetInfo, context, () => {
+        return __classPrivateFieldGet(this, _Browser_connection, "f").createSession(targetInfo);
+    }, (_a = __classPrivateFieldGet(this, _Browser_defaultViewport, "f")) !== null && _a !== void 0 ? _a : null);
+    (0, assert_1.assert)(!__classPrivateFieldGet(this, _Browser_targets, "f").has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
+    __classPrivateFieldGet(this, _Browser_targets, "f").set(event.targetInfo.targetId, target);
+    if (await target._initializedPromise) {
+        this.emit("targetcreated" /* BrowserEmittedEvents.TargetCreated */, target);
+    }
+}, _Browser_targetDestroyed = function _Browser_targetDestroyed(event) {
+    const target = __classPrivateFieldGet(this, _Browser_targets, "f").get(event.targetId);
+    if (!target) {
+        throw new Error(`Missing target in _targetDestroyed (id = ${event.targetId})`);
+    }
+    target._initializedCallback(false);
+    __classPrivateFieldGet(this, _Browser_targets, "f").delete(event.targetId);
+    target._closedCallback();
+}, _Browser_targetInfoChanged = function _Browser_targetInfoChanged(event) {
+    const target = __classPrivateFieldGet(this, _Browser_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);
+    }
+}, _Browser_getVersion = function _Browser_getVersion() {
+    return __classPrivateFieldGet(this, _Browser_connection, "f").send('Browser.getVersion');
+};
+class BrowserContext extends EventEmitter_1.EventEmitter {
+    constructor(browser, contextId) {
+        super();
+        _BrowserContext_browser.set(this, void 0);
+        _BrowserContext_id.set(this, void 0);
+        __classPrivateFieldSet(this, _BrowserContext_browser, browser, "f");
+        __classPrivateFieldSet(this, _BrowserContext_id, contextId, "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.page()));
+        return pages.filter((page) => {
+            return Boolean(page);
+        });
+    }
+    /**
+     * Returns whether BrowserContext is incognito.
+     * The default browser context is the only non-incognito browser context.
+     *
+     * @remarks
+     * The default browser context cannot be closed.
+     */
+    isIncognito() {
+        return Boolean(__classPrivateFieldGet(this, _BrowserContext_id, "f"));
+    }
+    /**
+     * Creates a new page in the browser context.
+     */
+    newPage() {
+        return __classPrivateFieldGet(this, _BrowserContext_browser, "f")._createPageInContext(__classPrivateFieldGet(this, _BrowserContext_id, "f"));
+    }
+    /**
+     * The browser this browser context belongs to.
+     */
+    browser() {
+        return __classPrivateFieldGet(this, _BrowserContext_browser, "f");
+    }
+    /**
+     * Closes the browser context. All the targets that belong to the browser context
+     * will be closed.
+     *
+     * @remarks
+     * Only incognito browser contexts can be closed.
+     */
+    async close() {
+        (0, assert_1.assert)(__classPrivateFieldGet(this, _BrowserContext_id, "f"), 'Non-incognito profiles cannot be closed!');
+        await __classPrivateFieldGet(this, _BrowserContext_browser, "f")._disposeContext(__classPrivateFieldGet(this, _BrowserContext_id, "f"));
+    }
+}
+exports.BrowserContext = BrowserContext;
+_BrowserContext_browser = new WeakMap(), _BrowserContext_id = new WeakMap();

package/dist/browser/BrowserConnector.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2020 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 { Browser } from './Browser';
+import { ConnectionTransport } from './ConnectionTransport';
+import { Viewport } from './PuppeteerViewport';
+export interface BrowserConnectOptions {
+    defaultViewport: Viewport;
+}
+export declare type ConnectToBrowserOptions = BrowserConnectOptions & {
+    browserWSEndpoint: string;
+    transport: ConnectionTransport;
+};
+export declare function _connectToBrowser(options: ConnectToBrowserOptions): Promise<Browser>;

package/dist/browser/BrowserConnector.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Copyright 2020 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._connectToBrowser = void 0;
+const assert_1 = require("./assert");
+const Browser_1 = require("./Browser");
+const Connection_1 = require("./Connection");
+const NodeWebSocketTransport_1 = require("./NodeWebSocketTransport");
+const getWebSocketTransportClass = () => {
+    return NodeWebSocketTransport_1.NodeWebSocketTransport;
+};
+async function _connectToBrowser(options) {
+    const { browserWSEndpoint, defaultViewport, transport } = options;
+    (0, assert_1.assert)(Number(Boolean(browserWSEndpoint)) + Number(Boolean(transport)) === 1, 'Exactly one of browserWSEndpoint, browserURL or transport must be passed to puppeteer.connect');
+    let connection;
+    if (transport) {
+        connection = new Connection_1.Connection('', transport);
+    }
+    else if (browserWSEndpoint) {
+        const WebSocketClass = getWebSocketTransportClass();
+        const connectionTransport = await WebSocketClass.create(browserWSEndpoint);
+        connection = new Connection_1.Connection(browserWSEndpoint, connectionTransport);
+    }
+    const { browserContextIds } = await connection.send('Target.getBrowserContexts');
+    return Browser_1.Browser._create({
+        connection,
+        contextIds: browserContextIds,
+        defaultViewport,
+        process: undefined,
+        closeCallback: () => {
+            return connection.send('Browser.close').catch(() => undefined);
+        },
+    });
+}
+exports._connectToBrowser = _connectToBrowser;

package/dist/browser/BrowserFetcher.d.ts

@@ -0,0 +1,89 @@
+/**
+ * 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 { Product } from './Product';
+declare type Platform = 'linux' | 'mac' | 'mac_arm' | 'win32' | 'win64';
+export interface BrowserFetcherOptions {
+    platform: Platform | null;
+    product: Product;
+    path: string | null;
+}
+interface BrowserFetcherRevisionInfo {
+    folderPath: string;
+    executablePath: string;
+    url: string;
+    local: boolean;
+    revision: string;
+    product: string;
+}
+export declare class BrowserFetcher {
+    #private;
+    constructor(options: BrowserFetcherOptions);
+    /**
+     * @returns Returns the current `Platform`, which is one of `mac`, `linux`,
+     * `win32` or `win64`.
+     */
+    platform(): Platform;
+    /**
+     * @returns Returns the current `Product`, which is one of `chrome` or
+     * `firefox`.
+     */
+    product(): Product;
+    /**
+     * @returns The download host being used.
+     */
+    host(): string;
+    /**
+     * Initiates a HEAD request to check if the revision is available.
+     * @remarks
+     * This method is affected by the current `product`.
+     * @param revision - The revision to check availability for.
+     * @returns A promise that resolves to `true` if the revision could be downloaded
+     * from the host.
+     */
+    canDownload(revision: string): Promise<boolean>;
+    /**
+     * Initiates a GET request to download the revision from the host.
+     * @remarks
+     * This method is affected by the current `product`.
+     * @param revision - The revision to download.
+     * @param progressCallback - A function that will be called with two arguments:
+     * How many bytes have been downloaded and the total number of bytes of the download.
+     * @returns A promise with revision information when the revision is downloaded
+     * and extracted.
+     */
+    download(revision: string, progressCallback?: (x: number, y: number) => void): Promise<BrowserFetcherRevisionInfo | undefined>;
+    /**
+     * @remarks
+     * This method is affected by the current `product`.
+     * @returns A promise with a list of all revision strings (for the current `product`)
+     * available locally on disk.
+     */
+    localRevisions(): Promise<string[]>;
+    /**
+     * @remarks
+     * This method is affected by the current `product`.
+     * @param revision - A revision to remove for the current `product`.
+     * @returns A promise that resolves when the revision has been removes or
+     * throws if the revision has not been downloaded.
+     */
+    remove(revision: string): Promise<void>;
+    /**
+     * @param revision - The revision to get info for.
+     * @returns The revision info for the given revision.
+     */
+    revisionInfo(revision: string): BrowserFetcherRevisionInfo;
+}
+export {};