@remotion/renderer 4.0.0-fastlambda.8 → 4.0.0-lambda.3

package/dist/browser/DOMWorld.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright 2019 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 { EvaluateFn, EvaluateFnReturnType, EvaluateHandleFn, SerializableOrJSHandle, UnwrapPromiseLike } from './EvalTypes';
+import { ExecutionContext } from './ExecutionContext';
+import { Frame } from './FrameManager';
+import { ElementHandle, JSHandle } from './JSHandle';
+import { TimeoutSettings } from './TimeoutSettings';
+export declare class DOMWorld {
+    #private;
+    get _waitTasks(): Set<WaitTask>;
+    constructor(frame: Frame, timeoutSettings: TimeoutSettings);
+    frame(): Frame;
+    _setContext(context: ExecutionContext | null): void;
+    _hasContext(): boolean;
+    _detach(): void;
+    executionContext(): Promise<ExecutionContext>;
+    evaluateHandle<HandlerType extends JSHandle = JSHandle>(pageFunction: EvaluateHandleFn, ...args: SerializableOrJSHandle[]): Promise<HandlerType>;
+    evaluate<T extends EvaluateFn>(pageFunction: T, ...args: SerializableOrJSHandle[]): Promise<UnwrapPromiseLike<EvaluateFnReturnType<T>>>;
+    _document(): Promise<ElementHandle>;
+    waitForFunction(pageFunction: Function | string, ...args: SerializableOrJSHandle[]): Promise<JSHandle>;
+    title(): Promise<string>;
+}
+interface WaitTaskOptions {
+    domWorld: DOMWorld;
+    predicateBody: Function | string;
+    title: string;
+    timeout: number;
+    args: SerializableOrJSHandle[];
+}
+declare class WaitTask {
+    #private;
+    promise: Promise<JSHandle>;
+    constructor(options: WaitTaskOptions);
+    terminate(error: Error): void;
+    rerun(): Promise<void>;
+}
+export {};

package/dist/browser/DOMWorld.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Copyright 2019 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 _DOMWorld_frame, _DOMWorld_timeoutSettings, _DOMWorld_documentPromise, _DOMWorld_contextPromise, _DOMWorld_contextResolveCallback, _DOMWorld_detached, _DOMWorld_waitTasks, _WaitTask_instances, _WaitTask_domWorld, _WaitTask_timeout, _WaitTask_predicateBody, _WaitTask_args, _WaitTask_runCount, _WaitTask_resolve, _WaitTask_reject, _WaitTask_timeoutTimer, _WaitTask_terminated, _WaitTask_cleanup;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMWorld = void 0;
+const assert_1 = require("./assert");
+const Errors_1 = require("./Errors");
+const util_1 = require("./util");
+class DOMWorld {
+    constructor(frame, timeoutSettings) {
+        _DOMWorld_frame.set(this, void 0);
+        _DOMWorld_timeoutSettings.set(this, void 0);
+        _DOMWorld_documentPromise.set(this, null);
+        _DOMWorld_contextPromise.set(this, null);
+        _DOMWorld_contextResolveCallback.set(this, null);
+        _DOMWorld_detached.set(this, false);
+        _DOMWorld_waitTasks.set(this, new Set());
+        // Keep own reference to client because it might differ from the FrameManager's
+        // client for OOP iframes.
+        __classPrivateFieldSet(this, _DOMWorld_frame, frame, "f");
+        __classPrivateFieldSet(this, _DOMWorld_timeoutSettings, timeoutSettings, "f");
+        this._setContext(null);
+    }
+    get _waitTasks() {
+        return __classPrivateFieldGet(this, _DOMWorld_waitTasks, "f");
+    }
+    frame() {
+        return __classPrivateFieldGet(this, _DOMWorld_frame, "f");
+    }
+    _setContext(context) {
+        var _a;
+        if (context) {
+            (0, assert_1.assert)(__classPrivateFieldGet(this, _DOMWorld_contextResolveCallback, "f"), 'Execution Context has already been set.');
+            (_a = __classPrivateFieldGet(this, _DOMWorld_contextResolveCallback, "f")) === null || _a === void 0 ? void 0 : _a.call(null, context);
+            __classPrivateFieldSet(this, _DOMWorld_contextResolveCallback, null, "f");
+            for (const waitTask of this._waitTasks) {
+                waitTask.rerun();
+            }
+        }
+        else {
+            __classPrivateFieldSet(this, _DOMWorld_documentPromise, null, "f");
+            __classPrivateFieldSet(this, _DOMWorld_contextPromise, new Promise((fulfill) => {
+                __classPrivateFieldSet(this, _DOMWorld_contextResolveCallback, fulfill, "f");
+            }), "f");
+        }
+    }
+    _hasContext() {
+        return !__classPrivateFieldGet(this, _DOMWorld_contextResolveCallback, "f");
+    }
+    _detach() {
+        __classPrivateFieldSet(this, _DOMWorld_detached, true, "f");
+        for (const waitTask of this._waitTasks) {
+            waitTask.terminate(new Error('waitForFunction failed: frame got detached.'));
+        }
+    }
+    executionContext() {
+        if (__classPrivateFieldGet(this, _DOMWorld_detached, "f")) {
+            throw new Error(`Execution context is not available in detached frame "${__classPrivateFieldGet(this, _DOMWorld_frame, "f").url()}" (are you trying to evaluate?)`);
+        }
+        if (__classPrivateFieldGet(this, _DOMWorld_contextPromise, "f") === null) {
+            throw new Error(`Execution content promise is missing`);
+        }
+        return __classPrivateFieldGet(this, _DOMWorld_contextPromise, "f");
+    }
+    async evaluateHandle(pageFunction, ...args) {
+        const context = await this.executionContext();
+        return context.evaluateHandle(pageFunction, ...args);
+    }
+    async evaluate(pageFunction, ...args) {
+        const context = await this.executionContext();
+        return context.evaluate(pageFunction, ...args);
+    }
+    _document() {
+        if (__classPrivateFieldGet(this, _DOMWorld_documentPromise, "f")) {
+            return __classPrivateFieldGet(this, _DOMWorld_documentPromise, "f");
+        }
+        __classPrivateFieldSet(this, _DOMWorld_documentPromise, this.executionContext().then(async (context) => {
+            const document = await context.evaluateHandle('document');
+            const element = document.asElement();
+            if (element === null) {
+                throw new Error('Document is null');
+            }
+            return element;
+        }), "f");
+        return __classPrivateFieldGet(this, _DOMWorld_documentPromise, "f");
+    }
+    waitForFunction(pageFunction, ...args) {
+        const timeout = __classPrivateFieldGet(this, _DOMWorld_timeoutSettings, "f").timeout();
+        const waitTaskOptions = {
+            domWorld: this,
+            predicateBody: pageFunction,
+            title: 'function',
+            timeout,
+            args,
+        };
+        const waitTask = new WaitTask(waitTaskOptions);
+        return waitTask.promise;
+    }
+    title() {
+        return this.evaluate(() => {
+            return document.title;
+        });
+    }
+}
+exports.DOMWorld = DOMWorld;
+_DOMWorld_frame = new WeakMap(), _DOMWorld_timeoutSettings = new WeakMap(), _DOMWorld_documentPromise = new WeakMap(), _DOMWorld_contextPromise = new WeakMap(), _DOMWorld_contextResolveCallback = new WeakMap(), _DOMWorld_detached = new WeakMap(), _DOMWorld_waitTasks = new WeakMap();
+const noop = () => undefined;
+class WaitTask {
+    constructor(options) {
+        _WaitTask_instances.add(this);
+        _WaitTask_domWorld.set(this, void 0);
+        _WaitTask_timeout.set(this, void 0);
+        _WaitTask_predicateBody.set(this, void 0);
+        _WaitTask_args.set(this, void 0);
+        _WaitTask_runCount.set(this, 0);
+        _WaitTask_resolve.set(this, noop);
+        _WaitTask_reject.set(this, noop);
+        _WaitTask_timeoutTimer.set(this, void 0);
+        _WaitTask_terminated.set(this, false);
+        function getPredicateBody(predicateBody) {
+            if ((0, util_1.isString)(predicateBody)) {
+                return `return (${predicateBody});`;
+            }
+            return `return (${predicateBody})(...args);`;
+        }
+        __classPrivateFieldSet(this, _WaitTask_domWorld, options.domWorld, "f");
+        __classPrivateFieldSet(this, _WaitTask_timeout, options.timeout, "f");
+        __classPrivateFieldSet(this, _WaitTask_predicateBody, getPredicateBody(options.predicateBody), "f");
+        __classPrivateFieldSet(this, _WaitTask_args, options.args, "f");
+        __classPrivateFieldSet(this, _WaitTask_runCount, 0, "f");
+        __classPrivateFieldGet(this, _WaitTask_domWorld, "f")._waitTasks.add(this);
+        this.promise = new Promise((resolve, reject) => {
+            __classPrivateFieldSet(this, _WaitTask_resolve, resolve, "f");
+            __classPrivateFieldSet(this, _WaitTask_reject, reject, "f");
+        });
+        // Since page navigation requires us to re-install the pageScript, we should track
+        // timeout on our end.
+        if (options.timeout) {
+            const timeoutError = new Errors_1.TimeoutError(`waiting for ${options.title} failed: timeout ${options.timeout}ms exceeded`);
+            __classPrivateFieldSet(this, _WaitTask_timeoutTimer, setTimeout(() => {
+                return this.terminate(timeoutError);
+            }, options.timeout), "f");
+        }
+        this.rerun();
+    }
+    terminate(error) {
+        __classPrivateFieldSet(this, _WaitTask_terminated, true, "f");
+        __classPrivateFieldGet(this, _WaitTask_reject, "f").call(this, error);
+        __classPrivateFieldGet(this, _WaitTask_instances, "m", _WaitTask_cleanup).call(this);
+    }
+    async rerun() {
+        var _a;
+        const runCount = __classPrivateFieldSet(this, _WaitTask_runCount, (_a = __classPrivateFieldGet(this, _WaitTask_runCount, "f"), ++_a), "f");
+        let success = null;
+        let error = null;
+        const context = await __classPrivateFieldGet(this, _WaitTask_domWorld, "f").executionContext();
+        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
+            return;
+        }
+        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
+            return;
+        }
+        try {
+            success = await context.evaluateHandle(waitForPredicatePageFunction, __classPrivateFieldGet(this, _WaitTask_predicateBody, "f"), __classPrivateFieldGet(this, _WaitTask_timeout, "f"), ...__classPrivateFieldGet(this, _WaitTask_args, "f"));
+        }
+        catch (error_) {
+            error = error_;
+        }
+        if (__classPrivateFieldGet(this, _WaitTask_terminated, "f") || runCount !== __classPrivateFieldGet(this, _WaitTask_runCount, "f")) {
+            if (success) {
+                await success.dispose();
+            }
+            return;
+        }
+        // Ignore timeouts in pageScript - we track timeouts ourselves.
+        // If the frame's execution context has already changed, `frame.evaluate` will
+        // throw an error - ignore this predicate run altogether.
+        if (!error &&
+            (await __classPrivateFieldGet(this, _WaitTask_domWorld, "f")
+                .evaluate((s) => {
+                return !s;
+            }, success)
+                .catch(() => {
+                return true;
+            }))) {
+            if (!success) {
+                throw new Error('Assertion: result handle is not available');
+            }
+            await success.dispose();
+            return;
+        }
+        if (error) {
+            if (error.message.includes('TypeError: binding is not a function')) {
+                return this.rerun();
+            }
+            // When frame is detached the task should have been terminated by the DOMWorld.
+            // This can fail if we were adding this task while the frame was detached,
+            // so we terminate here instead.
+            if (error.message.includes('Execution context is not available in detached frame')) {
+                this.terminate(new Error('waitForFunction failed: frame got detached.'));
+                return;
+            }
+            // When the page is navigated, the promise is rejected.
+            // We will try again in the new execution context.
+            if (error.message.includes('Execution context was destroyed')) {
+                return;
+            }
+            // We could have tried to evaluate in a context which was already
+            // destroyed.
+            if (error.message.includes('Cannot find context with specified id')) {
+                return;
+            }
+            __classPrivateFieldGet(this, _WaitTask_reject, "f").call(this, error);
+        }
+        else {
+            if (!success) {
+                throw new Error('Assertion: result handle is not available');
+            }
+            __classPrivateFieldGet(this, _WaitTask_resolve, "f").call(this, success);
+        }
+        __classPrivateFieldGet(this, _WaitTask_instances, "m", _WaitTask_cleanup).call(this);
+    }
+}
+_WaitTask_domWorld = new WeakMap(), _WaitTask_timeout = new WeakMap(), _WaitTask_predicateBody = new WeakMap(), _WaitTask_args = new WeakMap(), _WaitTask_runCount = new WeakMap(), _WaitTask_resolve = new WeakMap(), _WaitTask_reject = new WeakMap(), _WaitTask_timeoutTimer = new WeakMap(), _WaitTask_terminated = new WeakMap(), _WaitTask_instances = new WeakSet(), _WaitTask_cleanup = function _WaitTask_cleanup() {
+    if (__classPrivateFieldGet(this, _WaitTask_timeoutTimer, "f") !== undefined) {
+        clearTimeout(__classPrivateFieldGet(this, _WaitTask_timeoutTimer, "f"));
+    }
+    __classPrivateFieldGet(this, _WaitTask_domWorld, "f")._waitTasks.delete(this);
+};
+function waitForPredicatePageFunction(predicateBody, timeout, ...args) {
+    // eslint-disable-next-line no-new-func
+    const predicate = new Function('...args', predicateBody);
+    let timedOut = false;
+    if (timeout) {
+        setTimeout(() => {
+            timedOut = true;
+        }, timeout);
+    }
+    return new Promise((resolve) => {
+        async function onRaf() {
+            if (timedOut) {
+                resolve(undefined);
+                return;
+            }
+            const success = await predicate(...args);
+            if (success) {
+                resolve(success);
+            }
+            else {
+                requestAnimationFrame(onRaf);
+            }
+        }
+        onRaf();
+    });
+}

package/dist/browser/Debug.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+declare global {
+    var __PUPPETEER_DEBUG: string;
+}
+export declare const debug: (prefix: string) => (...args: unknown[]) => void;

package/dist/browser/Debug.js

@@ -0,0 +1,42 @@
+"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.debug = void 0;
+const debug = (prefix) => {
+    return (...logArgs) => {
+        const debugLevel = globalThis.__PUPPETEER_DEBUG;
+        if (!debugLevel) {
+            return;
+        }
+        const everythingShouldBeLogged = debugLevel === '*';
+        const prefixMatchesDebugLevel = everythingShouldBeLogged ||
+            /**
+             * If the debug level is `foo*`, that means we match any prefix that
+             * starts with `foo`. If the level is `foo`, we match only the prefix
+             * `foo`.
+             */
+            (debugLevel.endsWith('*')
+                ? prefix.startsWith(debugLevel)
+                : prefix === debugLevel);
+        if (!prefixMatchesDebugLevel) {
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.log(`${prefix}:`, ...logArgs);
+    };
+};
+exports.debug = debug;

package/dist/browser/DeviceDescriptors.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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.
+ */
+/**
+ * @public
+ */
+export interface Device {
+    name: string;
+    userAgent: string;
+    viewport: {
+        width: number;
+        height: number;
+        deviceScaleFactor: number;
+        isMobile: boolean;
+        hasTouch: boolean;
+        isLandscape: boolean;
+    };
+}
+/**
+ * @public
+ */
+export declare type DevicesMap = {
+    [name: string]: Device;
+};
+/**
+ * @internal
+ */
+export declare const _devicesMap: DevicesMap;