@remotion/renderer 4.0.0-preload.17 → 4.0.0-skia.20

package/dist/browser/Connection.js

@@ -0,0 +1,242 @@
+"use strict";
+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 _Connection_instances, _Connection_transport, _Connection_lastId, _Connection_sessions, _Connection_closed, _Connection_callbacks, _Connection_onMessage, _Connection_onClose, _CDPSession_sessionId, _CDPSession_targetType, _CDPSession_callbacks, _CDPSession_connection;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDPSession = exports.CDPSessionEmittedEvents = exports.Connection = void 0;
+/**
+ * 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.
+ */
+const assert_1 = require("./assert");
+const Errors_1 = require("./Errors");
+const EventEmitter_1 = require("./EventEmitter");
+const ConnectionEmittedEvents = {
+    Disconnected: Symbol('Connection.Disconnected'),
+};
+class Connection extends EventEmitter_1.EventEmitter {
+    constructor(transport) {
+        super();
+        _Connection_instances.add(this);
+        _Connection_transport.set(this, void 0);
+        _Connection_lastId.set(this, 0);
+        _Connection_sessions.set(this, new Map());
+        _Connection_closed.set(this, false);
+        _Connection_callbacks.set(this, new Map());
+        __classPrivateFieldSet(this, _Connection_transport, transport, "f");
+        __classPrivateFieldGet(this, _Connection_transport, "f").onmessage = __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onMessage).bind(this);
+        __classPrivateFieldGet(this, _Connection_transport, "f").onclose = __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onClose).bind(this);
+    }
+    static fromSession(session) {
+        return session.connection();
+    }
+    session(sessionId) {
+        return __classPrivateFieldGet(this, _Connection_sessions, "f").get(sessionId) || null;
+    }
+    send(method, ...paramArgs) {
+        // 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((resolve, reject) => {
+            __classPrivateFieldGet(this, _Connection_callbacks, "f").set(id, {
+                resolve,
+                reject,
+                error: new Errors_1.ProtocolError(),
+                method,
+            });
+        });
+    }
+    _rawSend(message) {
+        var _a;
+        const id = __classPrivateFieldSet(this, _Connection_lastId, (_a = __classPrivateFieldGet(this, _Connection_lastId, "f"), ++_a), "f");
+        const stringifiedMessage = JSON.stringify({ ...message, id });
+        __classPrivateFieldGet(this, _Connection_transport, "f").send(stringifiedMessage);
+        return id;
+    }
+    dispose() {
+        __classPrivateFieldGet(this, _Connection_instances, "m", _Connection_onClose).call(this);
+        __classPrivateFieldGet(this, _Connection_transport, "f").close();
+    }
+    /**
+     * @param targetInfo - The target info
+     * @returns The CDP session that is created
+     */
+    async createSession(targetInfo) {
+        const { sessionId } = await this.send('Target.attachToTarget', {
+            targetId: targetInfo.targetId,
+            flatten: true,
+        });
+        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(sessionId);
+        if (!session) {
+            throw new Error('CDPSession creation failed.');
+        }
+        return session;
+    }
+}
+exports.Connection = Connection;
+_Connection_transport = new WeakMap(), _Connection_lastId = new WeakMap(), _Connection_sessions = new WeakMap(), _Connection_closed = new WeakMap(), _Connection_callbacks = new WeakMap(), _Connection_instances = new WeakSet(), _Connection_onMessage = function _Connection_onMessage(message) {
+    const object = JSON.parse(message);
+    if (object.method === 'Target.attachedToTarget') {
+        const { sessionId } = object.params;
+        const session = new CDPSession(this, object.params.targetInfo.type, sessionId);
+        __classPrivateFieldGet(this, _Connection_sessions, "f").set(sessionId, session);
+        this.emit('sessionattached', session);
+        const parentSession = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.sessionId);
+        if (parentSession) {
+            parentSession.emit('sessionattached', session);
+        }
+    }
+    else if (object.method === 'Target.detachedFromTarget') {
+        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.params.sessionId);
+        if (session) {
+            session._onClosed();
+            __classPrivateFieldGet(this, _Connection_sessions, "f").delete(object.params.sessionId);
+            this.emit('sessiondetached', session);
+            const parentSession = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.sessionId);
+            if (parentSession) {
+                parentSession.emit('sessiondetached', session);
+            }
+        }
+    }
+    if (object.sessionId) {
+        const session = __classPrivateFieldGet(this, _Connection_sessions, "f").get(object.sessionId);
+        if (session) {
+            session._onMessage(object);
+        }
+    }
+    else if (object.id) {
+        const callback = __classPrivateFieldGet(this, _Connection_callbacks, "f").get(object.id);
+        // Callbacks could be all rejected if someone has called `.dispose()`.
+        if (callback) {
+            __classPrivateFieldGet(this, _Connection_callbacks, "f").delete(object.id);
+            if (object.error) {
+                callback.reject(createProtocolError(callback.error, callback.method, object));
+            }
+            else {
+                callback.resolve(object.result);
+            }
+        }
+    }
+    else {
+        this.emit(object.method, object.params);
+    }
+}, _Connection_onClose = function _Connection_onClose() {
+    if (__classPrivateFieldGet(this, _Connection_closed, "f")) {
+        return;
+    }
+    __classPrivateFieldGet(this, _Connection_transport, "f").onmessage = undefined;
+    __classPrivateFieldGet(this, _Connection_transport, "f").onclose = undefined;
+    for (const callback of __classPrivateFieldGet(this, _Connection_callbacks, "f").values()) {
+        callback.reject(rewriteError(callback.error, `Protocol error (${callback.method}): Target closed. https://www.remotion.dev/docs/target-closed`));
+    }
+    __classPrivateFieldGet(this, _Connection_callbacks, "f").clear();
+    for (const session of __classPrivateFieldGet(this, _Connection_sessions, "f").values()) {
+        session._onClosed();
+    }
+    __classPrivateFieldGet(this, _Connection_sessions, "f").clear();
+    this.emit(ConnectionEmittedEvents.Disconnected);
+};
+exports.CDPSessionEmittedEvents = {
+    Disconnected: Symbol('CDPSession.Disconnected'),
+};
+class CDPSession extends EventEmitter_1.EventEmitter {
+    constructor(connection, targetType, sessionId) {
+        super();
+        _CDPSession_sessionId.set(this, void 0);
+        _CDPSession_targetType.set(this, void 0);
+        _CDPSession_callbacks.set(this, new Map());
+        _CDPSession_connection.set(this, void 0);
+        __classPrivateFieldSet(this, _CDPSession_connection, connection, "f");
+        __classPrivateFieldSet(this, _CDPSession_targetType, targetType, "f");
+        __classPrivateFieldSet(this, _CDPSession_sessionId, sessionId, "f");
+    }
+    connection() {
+        return __classPrivateFieldGet(this, _CDPSession_connection, "f");
+    }
+    send(method, ...paramArgs) {
+        if (!__classPrivateFieldGet(this, _CDPSession_connection, "f")) {
+            return Promise.reject(new Error(`Protocol error (${method}): Session closed. Most likely the ${__classPrivateFieldGet(this, _CDPSession_targetType, "f")} has been closed.`));
+        }
+        // See the comment in Connection#send explaining why we do this.
+        const params = paramArgs.length ? paramArgs[0] : undefined;
+        const id = __classPrivateFieldGet(this, _CDPSession_connection, "f")._rawSend({
+            sessionId: __classPrivateFieldGet(this, _CDPSession_sessionId, "f"),
+            method,
+            params,
+        });
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _CDPSession_callbacks, "f").set(id, {
+                resolve,
+                reject,
+                error: new Errors_1.ProtocolError(),
+                method,
+            });
+        });
+    }
+    _onMessage(object) {
+        const callback = object.id ? __classPrivateFieldGet(this, _CDPSession_callbacks, "f").get(object.id) : undefined;
+        if (object.id && callback) {
+            __classPrivateFieldGet(this, _CDPSession_callbacks, "f").delete(object.id);
+            if (object.error) {
+                callback.reject(createProtocolError(callback.error, callback.method, object));
+            }
+            else {
+                callback.resolve(object.result);
+            }
+        }
+        else {
+            (0, assert_1.assert)(!object.id);
+            this.emit(object.method, object.params);
+        }
+    }
+    _onClosed() {
+        for (const callback of __classPrivateFieldGet(this, _CDPSession_callbacks, "f").values()) {
+            callback.reject(rewriteError(callback.error, `Protocol error (${callback.method}): Target closed. https://www.remotion.dev/docs/target-closed`));
+        }
+        __classPrivateFieldGet(this, _CDPSession_callbacks, "f").clear();
+        __classPrivateFieldSet(this, _CDPSession_connection, undefined, "f");
+        this.emit(exports.CDPSessionEmittedEvents.Disconnected);
+    }
+    id() {
+        return __classPrivateFieldGet(this, _CDPSession_sessionId, "f");
+    }
+}
+exports.CDPSession = CDPSession;
+_CDPSession_sessionId = new WeakMap(), _CDPSession_targetType = new WeakMap(), _CDPSession_callbacks = new WeakMap(), _CDPSession_connection = new WeakMap();
+function createProtocolError(error, method, object) {
+    let message = `Protocol error (${method}): ${object.error.message}`;
+    if ('data' in object.error) {
+        message += ` ${object.error.data}`;
+    }
+    return rewriteError(error, message, object.error.message);
+}
+function rewriteError(error, message, originalMessage) {
+    error.message = message;
+    error.originalMessage = originalMessage !== null && originalMessage !== void 0 ? originalMessage : error.originalMessage;
+    return error;
+}

package/dist/browser/ConnectionTransport.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+export interface ConnectionTransport {
+    send(message: string): void;
+    close(): void;
+    onmessage?: (message: string) => void;
+    onclose?: () => void;
+}

package/dist/browser/ConnectionTransport.js

@@ -0,0 +1,17 @@
+"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 });

package/dist/browser/ConsoleMessage.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 type { JSHandle } from './JSHandle';
+export interface ConsoleMessageLocation {
+    url?: string;
+    lineNumber?: number;
+    columnNumber?: number;
+}
+export declare type ConsoleMessageType = 'log' | 'debug' | 'info' | 'error' | 'warning' | 'dir' | 'dirxml' | 'table' | 'trace' | 'clear' | 'startGroup' | 'startGroupCollapsed' | 'endGroup' | 'assert' | 'profile' | 'profileEnd' | 'count' | 'timeEnd' | 'verbose';
+export declare class ConsoleMessage {
+    #private;
+    type: ConsoleMessageType;
+    text: string;
+    args: JSHandle[];
+    constructor(type: ConsoleMessageType, text: string, args: JSHandle[], stackTraceLocations: ConsoleMessageLocation[]);
+    location(): ConsoleMessageLocation;
+    stackTrace(): ConsoleMessageLocation[];
+}

package/dist/browser/ConsoleMessage.js

@@ -0,0 +1,48 @@
+"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.
+ */
+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 _ConsoleMessage_stackTraceLocations;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleMessage = void 0;
+class ConsoleMessage {
+    constructor(type, text, args, stackTraceLocations) {
+        _ConsoleMessage_stackTraceLocations.set(this, void 0);
+        this.type = type;
+        this.text = text;
+        this.args = args;
+        __classPrivateFieldSet(this, _ConsoleMessage_stackTraceLocations, stackTraceLocations, "f");
+    }
+    location() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _ConsoleMessage_stackTraceLocations, "f")[0]) !== null && _a !== void 0 ? _a : {};
+    }
+    stackTrace() {
+        return __classPrivateFieldGet(this, _ConsoleMessage_stackTraceLocations, "f");
+    }
+}
+exports.ConsoleMessage = ConsoleMessage;
+_ConsoleMessage_stackTraceLocations = new WeakMap();

package/dist/browser/Coverage.d.ts

@@ -0,0 +1,180 @@
+/**
+ * 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 { Protocol } from 'devtools-protocol';
+import { CDPSession } from './Connection';
+import { PuppeteerEventListener } from './util';
+/**
+ * @internal
+ */
+export { PuppeteerEventListener };
+/**
+ * The CoverageEntry class represents one entry of the coverage report.
+ * @public
+ */
+export interface CoverageEntry {
+    /**
+     * The URL of the style sheet or script.
+     */
+    url: string;
+    /**
+     * The content of the style sheet or script.
+     */
+    text: string;
+    /**
+     * The covered range as start and end positions.
+     */
+    ranges: Array<{
+        start: number;
+        end: number;
+    }>;
+}
+/**
+ * The CoverageEntry class for JavaScript
+ * @public
+ */
+export interface JSCoverageEntry extends CoverageEntry {
+    /**
+     * Raw V8 script coverage entry.
+     */
+    rawScriptCoverage?: Protocol.Profiler.ScriptCoverage;
+}
+/**
+ * Set of configurable options for JS coverage.
+ * @public
+ */
+export interface JSCoverageOptions {
+    /**
+     * Whether to reset coverage on every navigation.
+     */
+    resetOnNavigation?: boolean;
+    /**
+     * Whether anonymous scripts generated by the page should be reported.
+     */
+    reportAnonymousScripts?: boolean;
+    /**
+     * Whether the result includes raw V8 script coverage entries.
+     */
+    includeRawScriptCoverage?: boolean;
+}
+/**
+ * Set of configurable options for CSS coverage.
+ * @public
+ */
+export interface CSSCoverageOptions {
+    /**
+     * Whether to reset coverage on every navigation.
+     */
+    resetOnNavigation?: boolean;
+}
+/**
+ * The Coverage class provides methods to gathers information about parts of
+ * JavaScript and CSS that were used by the page.
+ *
+ * @remarks
+ * To output coverage in a form consumable by {@link https://github.com/istanbuljs | Istanbul},
+ * see {@link https://github.com/istanbuljs/puppeteer-to-istanbul | puppeteer-to-istanbul}.
+ *
+ * @example
+ * An example of using JavaScript and CSS coverage to get percentage of initially
+ * executed code:
+ * ```js
+ * // Enable both JavaScript and CSS coverage
+ * await Promise.all([
+ *   page.coverage.startJSCoverage(),
+ *   page.coverage.startCSSCoverage()
+ * ]);
+ * // Navigate to page
+ * await page.goto('https://example.com');
+ * // Disable both JavaScript and CSS coverage
+ * const [jsCoverage, cssCoverage] = await Promise.all([
+ *   page.coverage.stopJSCoverage(),
+ *   page.coverage.stopCSSCoverage(),
+ * ]);
+ * let totalBytes = 0;
+ * let usedBytes = 0;
+ * const coverage = [...jsCoverage, ...cssCoverage];
+ * for (const entry of coverage) {
+ *   totalBytes += entry.text.length;
+ *   for (const range of entry.ranges)
+ *     usedBytes += range.end - range.start - 1;
+ * }
+ * console.log(`Bytes used: ${usedBytes / totalBytes * 100}%`);
+ * ```
+ * @public
+ */
+export declare class Coverage {
+    #private;
+    constructor(client: CDPSession);
+    /**
+     * @param options - Set of configurable options for coverage defaults to
+     * `resetOnNavigation : true, reportAnonymousScripts : false`
+     * @returns Promise that resolves when coverage is started.
+     *
+     * @remarks
+     * Anonymous scripts are ones that don't have an associated url. These are
+     * scripts that are dynamically created on the page using `eval` or
+     * `new Function`. If `reportAnonymousScripts` is set to `true`, anonymous
+     * scripts will have `pptr://__puppeteer_evaluation_script__` as their URL.
+     */
+    startJSCoverage(options?: JSCoverageOptions): Promise<void>;
+    /**
+     * @returns Promise that resolves to the array of coverage reports for
+     * all scripts.
+     *
+     * @remarks
+     * JavaScript Coverage doesn't include anonymous scripts by default.
+     * However, scripts with sourceURLs are reported.
+     */
+    stopJSCoverage(): Promise<JSCoverageEntry[]>;
+    /**
+     * @param options - Set of configurable options for coverage, defaults to
+     * `resetOnNavigation : true`
+     * @returns Promise that resolves when coverage is started.
+     */
+    startCSSCoverage(options?: CSSCoverageOptions): Promise<void>;
+    /**
+     * @returns Promise that resolves to the array of coverage reports
+     * for all stylesheets.
+     * @remarks
+     * CSS Coverage doesn't include dynamically injected style tags
+     * without sourceURLs.
+     */
+    stopCSSCoverage(): Promise<CoverageEntry[]>;
+}
+/**
+ * @public
+ */
+export declare class JSCoverage {
+    #private;
+    constructor(client: CDPSession);
+    start(options?: {
+        resetOnNavigation?: boolean;
+        reportAnonymousScripts?: boolean;
+        includeRawScriptCoverage?: boolean;
+    }): Promise<void>;
+    stop(): Promise<JSCoverageEntry[]>;
+}
+/**
+ * @public
+ */
+export declare class CSSCoverage {
+    #private;
+    constructor(client: CDPSession);
+    start(options?: {
+        resetOnNavigation?: boolean;
+    }): Promise<void>;
+    stop(): Promise<CoverageEntry[]>;
+}