@remotion/renderer 4.0.0-fastlambda.8 → 4.0.0-forcepublish.7

package/dist/browser/create-browser-fetcher.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 { Product } from './Product';
+export declare function downloadBrowser(product: Product): Promise<void>;

package/dist/browser/create-browser-fetcher.js

@@ -0,0 +1,119 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadBrowser = void 0;
+const https_1 = __importDefault(require("https"));
+const node_1 = require("./node");
+const revisions_1 = require("./revisions");
+const supportedProducts = {
+    chrome: 'Chromium',
+    firefox: 'Firefox Nightly',
+};
+async function downloadBrowser(product) {
+    const browserFetcher = node_1.puppeteer.createBrowserFetcher({
+        product,
+        path: null,
+        platform: null,
+    });
+    const revision = await getRevision();
+    await fetchBinary(revision);
+    async function getRevision() {
+        if (product === 'chrome') {
+            return Promise.resolve(revisions_1.PUPPETEER_REVISIONS.chromium);
+        }
+        if (product === 'firefox') {
+            node_1.puppeteer._preferredRevision = revisions_1.PUPPETEER_REVISIONS.firefox;
+            try {
+                return await getFirefoxNightlyVersion();
+            }
+            catch (error) {
+                console.error(error);
+                process.exit(1);
+            }
+        }
+        throw new Error(`Unsupported product ${product}`);
+    }
+    function fetchBinary(_revision) {
+        const revisionInfo = browserFetcher.revisionInfo(_revision);
+        // Do nothing if the revision is already downloaded.
+        if (revisionInfo.local) {
+            console.log(`${supportedProducts[product]} is already in ${revisionInfo.folderPath}; skipping download.`);
+            return;
+        }
+        function onSuccess(localRevisions) {
+            console.log(`${supportedProducts[product]} (${revisionInfo.revision}) downloaded to ${revisionInfo.folderPath}`);
+            localRevisions = localRevisions.filter((__revision) => {
+                return __revision !== revisionInfo.revision;
+            });
+            const cleanupOldVersions = localRevisions.map((__revision) => {
+                return browserFetcher.remove(__revision);
+            });
+            Promise.all([...cleanupOldVersions]);
+        }
+        function onError(error) {
+            console.error(`ERROR: Failed to set up ${supportedProducts[product]} r${_revision}! Set "PUPPETEER_SKIP_DOWNLOAD" env variable to skip download.`);
+            console.error(error);
+            process.exit(1);
+        }
+        function onProgress(downloadedBytes, totalBytes) {
+            console.log('Downloading', supportedProducts[product], toMegabytes(downloadedBytes) + '/' + toMegabytes(totalBytes));
+        }
+        return browserFetcher
+            .download(revisionInfo.revision, onProgress)
+            .then(() => {
+            return browserFetcher.localRevisions();
+        })
+            .then(onSuccess)
+            .catch(onError);
+    }
+    function toMegabytes(bytes) {
+        const mb = bytes / 1024 / 1024;
+        return `${Math.round(mb * 10) / 10} Mb`;
+    }
+    function getFirefoxNightlyVersion() {
+        const firefoxVersionsUrl = 'https://product-details.mozilla.org/1.0/firefox_versions.json';
+        const requestOptions = {};
+        const promise = new Promise((resolve, reject) => {
+            let data = '';
+            console.log(`Requesting latest Firefox Nightly version from ${firefoxVersionsUrl}`);
+            https_1.default
+                .get(firefoxVersionsUrl, requestOptions, (r) => {
+                if (r.statusCode && r.statusCode >= 400) {
+                    return reject(new Error(`Got status code ${r.statusCode}`));
+                }
+                r.on('data', (chunk) => {
+                    data += chunk;
+                });
+                r.on('end', () => {
+                    try {
+                        const versions = JSON.parse(data);
+                        return resolve(versions.FIREFOX_NIGHTLY);
+                    }
+                    catch (_a) {
+                        return reject(new Error('Firefox version not found'));
+                    }
+                });
+            })
+                .on('error', reject);
+        });
+        return promise;
+    }
+}
+exports.downloadBrowser = downloadBrowser;

package/dist/browser/devtools-commands.d.ts

@@ -0,0 +1,270 @@
+import type { ActivateTargetRequest, AddScriptToEvaluateOnNewDocumentRequest, AddScriptToEvaluateOnNewDocumentResponse, CallFunctionOnRequest, CallFunctionOnResponse, CaptureScreenshotRequest, CaptureScreenshotResponse, CloseTargetRequest, CloseTargetResponse, CreateIsolatedWorldRequest, CreateIsolatedWorldResponse, DetachFromTargetRequest, DevtoolsRemoteObject, EnableRequest, ExceptionDetails, GetFrameTreeResponse, NavigateRequest, NavigateResponse, ReleaseObjectRequest, SetAutoAttachRequest, SetDefaultBackgroundColorOverrideRequest, SetDeviceMetricsOverrideRequest, SetLifecycleEventsEnabledRequest } from './devtools-types';
+export interface Commands {
+    /**
+     * Does nothing.
+     */
+    'Console.clearMessages': {
+        paramsType: [];
+        returnType: void;
+    };
+    'Target.setDiscoverTargets': {
+        paramsType: [
+            {
+                /**
+                 * Whether to discover available targets.
+                 */
+                discover: boolean;
+            }
+        ];
+        returnType: void;
+    };
+    'Target.createTarget': {
+        paramsType: [
+            {
+                /**
+                 * The initial URL the page will be navigated to. An empty string indicates about:blank.
+                 */
+                url: string;
+                /**
+                 * Frame width in DIP (headless chrome only).
+                 */
+                width?: number;
+                /**
+                 * Frame height in DIP (headless chrome only).
+                 */
+                height?: number;
+                /**
+                 * The browser context to create the page in.
+                 */
+                browserContextId?: string;
+                /**
+                 * Whether BeginFrames for this target will be controlled via DevTools (headless chrome only,
+                 * not supported on MacOS yet, false by default).
+                 */
+                enableBeginFrameControl?: boolean;
+                /**
+                 * Whether to create a new Window or Tab (chrome-only, false by default).
+                 */
+                newWindow?: boolean;
+                /**
+                 * Whether to create the target in background or foreground (chrome-only,
+                 * false by default).
+                 */
+                background?: boolean;
+            }
+        ];
+        returnType: {
+            targetId: string;
+        };
+    };
+    'Browser.close': {
+        paramsType: [];
+        returnType: void;
+    };
+    'Target.attachToTarget': {
+        paramsType: [
+            {
+                targetId: string;
+                /**
+                 * Enables "flat" access to the session via specifying sessionId attribute in the commands.
+                 * We plan to make this the default, deprecate non-flattened mode,
+                 * and eventually retire it. See crbug.com/991325.
+                 */
+                flatten?: boolean;
+            }
+        ];
+        returnType: {
+            /**
+             * Id assigned to the session.
+             */
+            sessionId: string;
+        };
+    };
+    'Runtime.callFunctionOn': {
+        paramsType: [CallFunctionOnRequest];
+        returnType: CallFunctionOnResponse;
+    };
+    'Runtime.evaluate': {
+        paramsType: [
+            {
+                /**
+                 * Expression to evaluate.
+                 */
+                expression: string;
+                /**
+                 * Symbolic group name that can be used to release multiple objects.
+                 */
+                objectGroup?: string;
+                /**
+                 * Determines whether Command Line API should be available during the evaluation.
+                 */
+                includeCommandLineAPI?: boolean;
+                /**
+                 * In silent mode exceptions thrown during evaluation are not reported and do not pause
+                 * execution. Overrides `setPauseOnException` state.
+                 */
+                silent?: boolean;
+                /**
+                 * Specifies in which execution context to perform evaluation. If the parameter is omitted the
+                 * evaluation will be performed in the context of the inspected page.
+                 * This is mutually exclusive with `uniqueContextId`, which offers an
+                 * alternative way to identify the execution context that is more reliable
+                 * in a multi-process environment.
+                 */
+                contextId?: number;
+                /**
+                 * Whether the result is expected to be a JSON object that should be sent by value.
+                 */
+                returnByValue?: boolean;
+                /**
+                 * Whether preview should be generated for the result.
+                 */
+                generatePreview?: boolean;
+                /**
+                 * Whether execution should be treated as initiated by user in the UI.
+                 */
+                userGesture?: boolean;
+                /**
+                 * Whether execution should `await` for resulting value and return once awaited promise is
+                 * resolved.
+                 */
+                awaitPromise?: boolean;
+                /**
+                 * Whether to throw an exception if side effect cannot be ruled out during evaluation.
+                 * This implies `disableBreaks` below.
+                 */
+                throwOnSideEffect?: boolean;
+                /**
+                 * Terminate execution after timing out (number of milliseconds).
+                 */
+                /**
+                 * Disable breakpoints during execution.
+                 */
+                disableBreaks?: boolean;
+                /**
+                 * Setting this flag to true enables `let` re-declaration and top-level `await`.
+                 * Note that `let` variables can only be re-declared if they originate from
+                 * `replMode` themselves.
+                 */
+                replMode?: boolean;
+                /**
+                 * The Content Security Policy (CSP) for the target might block 'unsafe-eval'
+                 * which includes eval(), Function(), setTimeout() and setInterval()
+                 * when called with non-callable arguments. This flag bypasses CSP for this
+                 * evaluation and allows unsafe-eval. Defaults to true.
+                 */
+                allowUnsafeEvalBlockedByCSP?: boolean;
+                /**
+                 * An alternative way to specify the execution context to evaluate in.
+                 * Compared to contextId that may be reused across processes, this is guaranteed to be
+                 * system-unique, so it can be used to prevent accidental evaluation of the expression
+                 * in context different than intended (e.g. as a result of navigation across process
+                 * boundaries).
+                 * This is mutually exclusive with `contextId`.
+                 */
+                uniqueContextId?: string;
+                /**
+                 * Whether the result should be serialized according to https://w3c.github.io/webdriver-bidi.
+                 */
+                generateWebDriverValue?: boolean;
+            }
+        ];
+        returnType: {
+            /**
+             * Evaluation result.
+             */
+            result: DevtoolsRemoteObject;
+            /**
+             * Exception details.
+             */
+            exceptionDetails?: ExceptionDetails;
+        };
+    };
+    'Page.enable': {
+        paramsType: [];
+        returnType: void;
+    };
+    'Page.getFrameTree': {
+        paramsType: [];
+        returnType: GetFrameTreeResponse;
+    };
+    'Target.setAutoAttach': {
+        paramsType: [SetAutoAttachRequest];
+        returnType: void;
+    };
+    'Page.setLifecycleEventsEnabled': {
+        paramsType: [SetLifecycleEventsEnabledRequest];
+        returnType: void;
+    };
+    'Runtime.enable': {
+        paramsType: [];
+        returnType: void;
+    };
+    'Page.navigate': {
+        paramsType: [NavigateRequest];
+        returnType: NavigateResponse;
+    };
+    'Page.addScriptToEvaluateOnNewDocument': {
+        paramsType: [AddScriptToEvaluateOnNewDocumentRequest];
+        returnType: AddScriptToEvaluateOnNewDocumentResponse;
+    };
+    'Page.createIsolatedWorld': {
+        paramsType: [CreateIsolatedWorldRequest];
+        returnType: CreateIsolatedWorldResponse;
+    };
+    'Page.captureScreenshot': {
+        paramsType: [CaptureScreenshotRequest?];
+        returnType: CaptureScreenshotResponse;
+    };
+    'Target.activateTarget': {
+        paramsType: [ActivateTargetRequest];
+        returnType: void;
+    };
+    'Emulation.setDefaultBackgroundColorOverride': {
+        paramsType: [SetDefaultBackgroundColorOverrideRequest?];
+        returnType: void;
+    };
+    'Network.enable': {
+        paramsType: [EnableRequest?];
+        returnType: void;
+    };
+    'Target.detachFromTarget': {
+        paramsType: [DetachFromTargetRequest?];
+        returnType: void;
+    };
+    /**
+     * Enable collecting and reporting metrics.
+     */
+    'Performance.enable': {
+        paramsType: [EnableRequest?];
+        returnType: void;
+    };
+    'Log.enable': {
+        paramsType: [];
+        returnType: void;
+    };
+    'Page.setDeviceMetricsOverride': {
+        paramsType: [SetDeviceMetricsOverrideRequest];
+        returnType: void;
+    };
+    'Page.bringToFront': {
+        paramsType: [];
+        returnType: void;
+    };
+    'Emulation.setDeviceMetricsOverride': {
+        paramsType: [SetDeviceMetricsOverrideRequest];
+        returnType: void;
+    };
+    'Target.closeTarget': {
+        paramsType: [CloseTargetRequest];
+        returnType: CloseTargetResponse;
+    };
+    'Page.close': {
+        paramsType: [];
+        returnType: void;
+    };
+    'Runtime.releaseObject': {
+        paramsType: [ReleaseObjectRequest];
+        returnType: void;
+    };
+}

package/dist/browser/devtools-commands.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });