@remotion/renderer 3.0.22 → 3.0.23

package/dist/browser/NetworkManager.js

@@ -126,6 +126,7 @@ _NetworkManager_client = new WeakMap(), _NetworkManager_frameManager = new WeakM
         ...requestPausedEvent.request.headers,
     };
 }, _NetworkManager_onRequest = function _NetworkManager_onRequest(event, fetchRequestId) {
+    let redirectChain = [];
     if (event.redirectResponse) {
         // We want to emit a response and requestfinished for the
         // redirectResponse, but we can't do so unless we have a
@@ -152,12 +153,13 @@ _NetworkManager_client = new WeakMap(), _NetworkManager_frameManager = new WeakM
         // requestWillBeSent event.
         if (_request) {
             __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_handleRequestRedirect).call(this, _request, event.redirectResponse, redirectResponseExtraInfo);
+            redirectChain = _request._redirectChain;
         }
     }
     const frame = event.frameId
         ? __classPrivateFieldGet(this, _NetworkManager_frameManager, "f").frame(event.frameId)
         : null;
-    const request = new HTTPRequest_1.HTTPRequest(frame, event);
+    const request = new HTTPRequest_1.HTTPRequest(frame, event, redirectChain);
     __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").storeRequest(event.requestId, request);
     this.emit(exports.NetworkManagerEmittedEvents.Request, request);
 }, _NetworkManager_onRequestServedFromCache = function _NetworkManager_onRequestServedFromCache(event) {
@@ -166,8 +168,9 @@ _NetworkManager_client = new WeakMap(), _NetworkManager_frameManager = new WeakM
         request._fromMemoryCache = true;
     }
 }, _NetworkManager_handleRequestRedirect = function _NetworkManager_handleRequestRedirect(request, responsePayload, extraInfo) {
-    const response = new HTTPResponse_1.HTTPResponse(responsePayload, extraInfo);
+    const response = new HTTPResponse_1.HTTPResponse(__classPrivateFieldGet(this, _NetworkManager_client, "f"), request, responsePayload, extraInfo);
     request._response = response;
+    request._redirectChain.push(request);
     response._resolveBody(new Error('Response body is unavailable for redirect responses'));
     __classPrivateFieldGet(this, _NetworkManager_instances, "m", _NetworkManager_forgetRequest).call(this, request, false);
 }, _NetworkManager_emitResponseEvent = function _NetworkManager_emitResponseEvent(responseReceived, extraInfo) {
@@ -181,7 +184,7 @@ _NetworkManager_client = new WeakMap(), _NetworkManager_frameManager = new WeakM
         console.log(new Error('Unexpected extraInfo events for request ' +
             responseReceived.requestId));
     }
-    const response = new HTTPResponse_1.HTTPResponse(responseReceived.response, extraInfo);
+    const response = new HTTPResponse_1.HTTPResponse(__classPrivateFieldGet(this, _NetworkManager_client, "f"), request, responseReceived.response, extraInfo);
     request._response = response;
 }, _NetworkManager_onResponseReceived = function _NetworkManager_onResponseReceived(event) {
     const request = __classPrivateFieldGet(this, _NetworkManager_networkEventManager, "f").getRequest(event.requestId);
@@ -272,6 +275,7 @@ _NetworkManager_client = new WeakMap(), _NetworkManager_frameManager = new WeakM
     if (!request) {
         return;
     }
+    request._failureText = event.errorText;
     const response = request.response();
     if (response) {
         response._resolveBody(null);

package/dist/browser/NodeWebSocketTransport.d.ts

@@ -1,17 +1,11 @@
 import NodeWebSocket from 'ws';
-interface ConnectionTransport {
-    send(message: string): void;
-    close(): void;
-    onmessage?: (message: string) => void;
-    onclose?: () => void;
-}
+import { ConnectionTransport } from './ConnectionTransport';
 export declare class NodeWebSocketTransport implements ConnectionTransport {
     #private;
     static create(urlString: string): Promise<NodeWebSocketTransport>;
-    onmessage?: (message: string) => void;
+    onmessage?: (message: NodeWebSocket.Data) => void;
     onclose?: () => void;
     constructor(ws: NodeWebSocket);
     send(message: string): void;
     close(): void;
 }
-export {};

package/dist/browser/NodeWebSocketTransport.js

@@ -52,7 +52,7 @@ class NodeWebSocketTransport {
         __classPrivateFieldGet(this, _NodeWebSocketTransport_ws, "f").addEventListener('error', () => undefined);
     }
     static async create(urlString) {
-        // Starting in Node 17, IPv6 is favoured over IPv4 due to a change
+        // TODO(jrandolf): Starting in Node 17, IPv6 is favoured over IPv4 due to a change
         // in a default option:
         // - https://github.com/nodejs/node/issues/40537,
         // Due to this, for Firefox, we must parse and resolve the `localhost` hostname

package/dist/browser/PDFOptions.d.ts

@@ -0,0 +1,165 @@
+/**
+ * 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.
+ */
+/**
+ * @public
+ */
+export interface PDFMargin {
+    top?: string | number;
+    bottom?: string | number;
+    left?: string | number;
+    right?: string | number;
+}
+/**
+ * @public
+ */
+export declare type LowerCasePaperFormat = 'letter' | 'legal' | 'tabloid' | 'ledger' | 'a0' | 'a1' | 'a2' | 'a3' | 'a4' | 'a5' | 'a6';
+/**
+ * All the valid paper format types when printing a PDF.
+ *
+ * @remarks
+ *
+ * The sizes of each format are as follows:
+ * - `Letter`: 8.5in x 11in
+ *
+ * - `Legal`: 8.5in x 14in
+ *
+ * - `Tabloid`: 11in x 17in
+ *
+ * - `Ledger`: 17in x 11in
+ *
+ * - `A0`: 33.1in x 46.8in
+ *
+ * - `A1`: 23.4in x 33.1in
+ *
+ * - `A2`: 16.54in x 23.4in
+ *
+ * - `A3`: 11.7in x 16.54in
+ *
+ * - `A4`: 8.27in x 11.7in
+ *
+ * - `A5`: 5.83in x 8.27in
+ *
+ * - `A6`: 4.13in x 5.83in
+ *
+ * @public
+ */
+export declare type PaperFormat = Uppercase<LowerCasePaperFormat> | Capitalize<LowerCasePaperFormat> | LowerCasePaperFormat;
+/**
+ * Valid options to configure PDF generation via {@link Page.pdf}.
+ * @public
+ */
+export interface PDFOptions {
+    /**
+     * Scales the rendering of the web page. Amount must be between `0.1` and `2`.
+     * @defaultValue 1
+     */
+    scale?: number;
+    /**
+     * Whether to show the header and footer.
+     * @defaultValue false
+     */
+    displayHeaderFooter?: boolean;
+    /**
+     * HTML template for the print header. Should be valid HTML with the following
+     * classes used to inject values into them:
+     * - `date` formatted print date
+     *
+     * - `title` document title
+     *
+     * - `url` document location
+     *
+     * - `pageNumber` current page number
+     *
+     * - `totalPages` total pages in the document
+     */
+    headerTemplate?: string;
+    /**
+     * HTML template for the print footer. Has the same constraints and support
+     * for special classes as {@link PDFOptions.headerTemplate}.
+     */
+    footerTemplate?: string;
+    /**
+     * Set to `true` to print background graphics.
+     * @defaultValue false
+     */
+    printBackground?: boolean;
+    /**
+     * Whether to print in landscape orientation.
+     * @defaultValue = false
+     */
+    landscape?: boolean;
+    /**
+     * Paper ranges to print, e.g. `1-5, 8, 11-13`.
+     * @defaultValue The empty string, which means all pages are printed.
+     */
+    pageRanges?: string;
+    /**
+     * @remarks
+     * If set, this takes priority over the `width` and `height` options.
+     * @defaultValue `letter`.
+     */
+    format?: PaperFormat;
+    /**
+     * Sets the width of paper. You can pass in a number or a string with a unit.
+     */
+    width?: string | number;
+    /**
+     * Sets the height of paper. You can pass in a number or a string with a unit.
+     */
+    height?: string | number;
+    /**
+     * Give any CSS `@page` size declared in the page priority over what is
+     * declared in the `width` or `height` or `format` option.
+     * @defaultValue `false`, which will scale the content to fit the paper size.
+     */
+    preferCSSPageSize?: boolean;
+    /**
+     * Set the PDF margins.
+     * @defaultValue no margins are set.
+     */
+    margin?: PDFMargin;
+    /**
+     * The path to save the file to.
+     *
+     * @remarks
+     *
+     * If the path is relative, it's resolved relative to the current working directory.
+     *
+     * @defaultValue the empty string, which means the PDF will not be written to disk.
+     */
+    path?: string;
+    /**
+     * Hides default white background and allows generating pdfs with transparency.
+     * @defaultValue false
+     */
+    omitBackground?: boolean;
+    /**
+     * Timeout in milliseconds
+     * @defaultValue 30000
+     */
+    timeout?: number;
+}
+/**
+ * @internal
+ */
+export interface PaperFormatDimensions {
+    width: number;
+    height: number;
+}
+/**
+ * @internal
+ */
+export declare const _paperFormats: Record<LowerCasePaperFormat, PaperFormatDimensions>;

package/dist/browser/PDFOptions.js

@@ -0,0 +1,34 @@
+"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._paperFormats = void 0;
+/**
+ * @internal
+ */
+exports._paperFormats = {
+    letter: { width: 8.5, height: 11 },
+    legal: { width: 8.5, height: 14 },
+    tabloid: { width: 11, height: 17 },
+    ledger: { width: 17, height: 11 },
+    a0: { width: 33.1, height: 46.8 },
+    a1: { width: 23.4, height: 33.1 },
+    a2: { width: 16.54, height: 23.4 },
+    a3: { width: 11.7, height: 16.54 },
+    a4: { width: 8.27, height: 11.7 },
+    a5: { width: 5.83, height: 8.27 },
+    a6: { width: 4.13, height: 5.83 },
+};

package/dist/browser/PipeTransport.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { ConnectionTransport } from './ConnectionTransport';
+export declare class PipeTransport implements ConnectionTransport {
+    #private;
+    onclose?: () => void;
+    onmessage?: (value: string) => void;
+    constructor(pipeWrite: NodeJS.WritableStream, pipeRead: NodeJS.ReadableStream);
+    send(message: string): void;
+    close(): void;
+}

package/dist/browser/PipeTransport.js

@@ -0,0 +1,86 @@
+"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 _PipeTransport_instances, _PipeTransport_pipeWrite, _PipeTransport_eventListeners, _PipeTransport_isClosed, _PipeTransport_pendingMessage, _PipeTransport_dispatch;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipeTransport = void 0;
+/**
+ * Copyright 2018 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 util_1 = require("./util");
+class PipeTransport {
+    constructor(pipeWrite, pipeRead) {
+        _PipeTransport_instances.add(this);
+        _PipeTransport_pipeWrite.set(this, void 0);
+        _PipeTransport_eventListeners.set(this, void 0);
+        _PipeTransport_isClosed.set(this, false);
+        _PipeTransport_pendingMessage.set(this, '');
+        __classPrivateFieldSet(this, _PipeTransport_pipeWrite, pipeWrite, "f");
+        __classPrivateFieldSet(this, _PipeTransport_eventListeners, [
+            (0, util_1.addEventListener)(pipeRead, 'data', (buffer) => {
+                return __classPrivateFieldGet(this, _PipeTransport_instances, "m", _PipeTransport_dispatch).call(this, buffer);
+            }),
+            (0, util_1.addEventListener)(pipeRead, 'close', () => {
+                if (this.onclose) {
+                    this.onclose.call(null);
+                }
+            }),
+            (0, util_1.addEventListener)(pipeRead, 'error', util_1.debugError),
+            (0, util_1.addEventListener)(pipeWrite, 'error', util_1.debugError),
+        ], "f");
+    }
+    send(message) {
+        (0, assert_1.assert)(!__classPrivateFieldGet(this, _PipeTransport_isClosed, "f"), '`PipeTransport` is closed.');
+        __classPrivateFieldGet(this, _PipeTransport_pipeWrite, "f").write(message);
+        __classPrivateFieldGet(this, _PipeTransport_pipeWrite, "f").write('\0');
+    }
+    close() {
+        __classPrivateFieldSet(this, _PipeTransport_isClosed, true, "f");
+        (0, util_1.removeEventListeners)(__classPrivateFieldGet(this, _PipeTransport_eventListeners, "f"));
+    }
+}
+exports.PipeTransport = PipeTransport;
+_PipeTransport_pipeWrite = new WeakMap(), _PipeTransport_eventListeners = new WeakMap(), _PipeTransport_isClosed = new WeakMap(), _PipeTransport_pendingMessage = new WeakMap(), _PipeTransport_instances = new WeakSet(), _PipeTransport_dispatch = function _PipeTransport_dispatch(buffer) {
+    (0, assert_1.assert)(!__classPrivateFieldGet(this, _PipeTransport_isClosed, "f"), '`PipeTransport` is closed.');
+    let end = buffer.indexOf('\0');
+    if (end === -1) {
+        __classPrivateFieldSet(this, _PipeTransport_pendingMessage, __classPrivateFieldGet(this, _PipeTransport_pendingMessage, "f") + buffer.toString(), "f");
+        return;
+    }
+    const message = __classPrivateFieldGet(this, _PipeTransport_pendingMessage, "f") + buffer.toString(undefined, 0, end);
+    if (this.onmessage) {
+        this.onmessage.call(null, message);
+    }
+    let start = end + 1;
+    end = buffer.indexOf('\0', start);
+    while (end !== -1) {
+        if (this.onmessage) {
+            this.onmessage.call(null, buffer.toString(undefined, start, end));
+        }
+        start = end + 1;
+        end = buffer.indexOf('\0', start);
+    }
+    __classPrivateFieldSet(this, _PipeTransport_pendingMessage, buffer.toString(undefined, start), "f");
+};

package/dist/browser/Puppeteer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { Browser } from './Browser';
+import { BrowserConnectOptions } from './BrowserConnector';
+import { ConnectionTransport } from './ConnectionTransport';
+import { Product } from './Product';
+/**
+ * @public
+ */
+export interface ConnectOptions extends BrowserConnectOptions {
+    browserWSEndpoint?: string;
+    transport?: ConnectionTransport;
+    product?: Product;
+}
+export declare class Puppeteer {
+    protected _changedProduct: boolean;
+    /**
+     * @internal
+     */
+    constructor();
+    connect(options: ConnectOptions): Promise<Browser>;
+}

package/dist/browser/Puppeteer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Puppeteer = void 0;
+const BrowserConnector_1 = require("./BrowserConnector");
+class Puppeteer {
+    /**
+     * @internal
+     */
+    constructor() {
+        this._changedProduct = false;
+        this.connect = this.connect.bind(this);
+    }
+    connect(options) {
+        return (0, BrowserConnector_1._connectToBrowser)(options);
+    }
+}
+exports.Puppeteer = Puppeteer;

package/dist/browser/PuppeteerNode.d.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { Browser } from './Browser';
-import { BrowserConnectOptions } from './BrowserConnector';
+import { BrowserConnectOptions, ConnectToBrowserOptions } from './BrowserConnector';
 import { BrowserFetcher, BrowserFetcherOptions } from './BrowserFetcher';
 import { ProductLauncher } from './Launcher';
 import { BrowserLaunchArgumentOptions, LaunchOptions } from './LaunchOptions';
@@ -30,6 +30,9 @@ export declare class PuppeteerNode {
         preferredRevision: string;
         productName?: Product;
     });
+    connect(options: ConnectToBrowserOptions & {
+        product: Product;
+    }): Promise<Browser>;
     get _productName(): Product | undefined;
     set _productName(name: Product | undefined);
     /**

package/dist/browser/PuppeteerNode.js

@@ -31,6 +31,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var _PuppeteerNode_lazyLauncher, _PuppeteerNode_productName;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PuppeteerNode = void 0;
+const BrowserConnector_1 = require("./BrowserConnector");
 const BrowserFetcher_1 = require("./BrowserFetcher");
 const Launcher_1 = __importDefault(require("./Launcher"));
 const revisions_1 = require("./revisions");
@@ -41,10 +42,17 @@ class PuppeteerNode {
         const { preferredRevision, productName } = settings;
         __classPrivateFieldSet(this, _PuppeteerNode_productName, productName, "f");
         this._preferredRevision = preferredRevision;
+        this.connect = this.connect.bind(this);
         this.launch = this.launch.bind(this);
         this.executablePath = this.executablePath.bind(this);
         this.createBrowserFetcher = this.createBrowserFetcher.bind(this);
     }
+    connect(options) {
+        if (options.product) {
+            this._productName = options.product;
+        }
+        return (0, BrowserConnector_1._connectToBrowser)(options);
+    }
     get _productName() {
         return __classPrivateFieldGet(this, _PuppeteerNode_productName, "f");
     }

package/dist/browser/QueryHandler.d.ts

@@ -0,0 +1,64 @@
+/**
+ * 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 { DOMWorld, WaitForSelectorOptions } from './DOMWorld';
+import { ElementHandle, JSHandle } from './JSHandle';
+/**
+ * @internal
+ */
+export interface InternalQueryHandler {
+    queryOne?: (element: ElementHandle, selector: string) => Promise<ElementHandle | null>;
+    waitFor?: (domWorld: DOMWorld, selector: string, options: WaitForSelectorOptions) => Promise<ElementHandle | null>;
+    queryAll?: (element: ElementHandle, selector: string) => Promise<ElementHandle[]>;
+    queryAllArray?: (element: ElementHandle, selector: string) => Promise<JSHandle<Element[]>>;
+}
+/**
+ * Contains two functions `queryOne` and `queryAll` that can
+ * be {@link Puppeteer.registerCustomQueryHandler | registered}
+ * as alternative querying strategies. The functions `queryOne` and `queryAll`
+ * are executed in the page context.  `queryOne` should take an `Element` and a
+ * selector string as argument and return a single `Element` or `null` if no
+ * element is found. `queryAll` takes the same arguments but should instead
+ * return a `NodeListOf<Element>` or `Array<Element>` with all the elements
+ * that match the given query selector.
+ * @public
+ */
+export interface CustomQueryHandler {
+    queryOne?: (element: Element | Document, selector: string) => Element | null;
+    queryAll?: (element: Element | Document, selector: string) => Element[] | NodeListOf<Element>;
+}
+/**
+ * @internal
+ */
+export declare function _registerCustomQueryHandler(name: string, handler: CustomQueryHandler): void;
+/**
+ * @internal
+ */
+export declare function _unregisterCustomQueryHandler(name: string): void;
+/**
+ * @internal
+ */
+export declare function _customQueryHandlerNames(): string[];
+/**
+ * @internal
+ */
+export declare function _clearCustomQueryHandlers(): void;
+/**
+ * @internal
+ */
+export declare function _getQueryHandlerAndSelector(selector: string): {
+    updatedSelector: string;
+    queryHandler: InternalQueryHandler;
+};