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

package/dist/browser/FileChooser.js

@@ -0,0 +1,86 @@
+"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 _FileChooser_element, _FileChooser_multiple, _FileChooser_handled;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileChooser = void 0;
+const assert_1 = require("./assert");
+/**
+ * File choosers let you react to the page requesting for a file.
+ * @remarks
+ * `FileChooser` objects are returned via the `page.waitForFileChooser` method.
+ * @example
+ * An example of using `FileChooser`:
+ * ```js
+ * const [fileChooser] = await Promise.all([
+ *   page.waitForFileChooser(),
+ *   page.click('#upload-file-button'), // some button that triggers file selection
+ * ]);
+ * await fileChooser.accept(['/tmp/myfile.pdf']);
+ * ```
+ * **NOTE** In browsers, only one file chooser can be opened at a time.
+ * All file choosers must be accepted or canceled. Not doing so will prevent
+ * subsequent file choosers from appearing.
+ * @public
+ */
+class FileChooser {
+    /**
+     * @internal
+     */
+    constructor(element, event) {
+        _FileChooser_element.set(this, void 0);
+        _FileChooser_multiple.set(this, void 0);
+        _FileChooser_handled.set(this, false);
+        __classPrivateFieldSet(this, _FileChooser_element, element, "f");
+        __classPrivateFieldSet(this, _FileChooser_multiple, event.mode !== 'selectSingle', "f");
+    }
+    /**
+     * Whether file chooser allow for {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#attr-multiple | multiple} file selection.
+     */
+    isMultiple() {
+        return __classPrivateFieldGet(this, _FileChooser_multiple, "f");
+    }
+    /**
+     * Accept the file chooser request with given paths.
+     * @param filePaths - If some of the  `filePaths` are relative paths,
+     * then they are resolved relative to the {@link https://nodejs.org/api/process.html#process_process_cwd | current working directory}.
+     */
+    async accept(filePaths) {
+        (0, assert_1.assert)(!__classPrivateFieldGet(this, _FileChooser_handled, "f"), 'Cannot accept FileChooser which is already handled!');
+        __classPrivateFieldSet(this, _FileChooser_handled, true, "f");
+        await __classPrivateFieldGet(this, _FileChooser_element, "f").uploadFile(...filePaths);
+    }
+    /**
+     * Closes the file chooser without selecting any files.
+     */
+    cancel() {
+        (0, assert_1.assert)(!__classPrivateFieldGet(this, _FileChooser_handled, "f"), 'Cannot cancel FileChooser which is already handled!');
+        __classPrivateFieldSet(this, _FileChooser_handled, true, "f");
+    }
+}
+exports.FileChooser = FileChooser;
+_FileChooser_element = new WeakMap(), _FileChooser_multiple = new WeakMap(), _FileChooser_handled = new WeakMap();

package/dist/browser/FrameManager.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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 { DOMWorld } from './DOMWorld';
+import { EvaluateFn, EvaluateFnReturnType, EvaluateHandleFn, SerializableOrJSHandle, UnwrapPromiseLike } from './EvalTypes';
+import { EventEmitter } from './EventEmitter';
+import { ExecutionContext } from './ExecutionContext';
+import { HTTPResponse } from './HTTPResponse';
+import { JSHandle } from './JSHandle';
+import { PuppeteerLifeCycleEvent } from './LifecycleWatcher';
+import { NetworkManager } from './NetworkManager';
+import { Page } from './Page';
+import { TimeoutSettings } from './TimeoutSettings';
+export declare const FrameManagerEmittedEvents: {
+    FrameNavigated: symbol;
+    FrameDetached: symbol;
+    FrameSwapped: symbol;
+    LifecycleEvent: symbol;
+    FrameNavigatedWithinDocument: symbol;
+    ExecutionContextCreated: symbol;
+    ExecutionContextDestroyed: symbol;
+};
+export declare class FrameManager extends EventEmitter {
+    #private;
+    get _timeoutSettings(): TimeoutSettings;
+    get _client(): CDPSession;
+    constructor(client: CDPSession, page: Page, timeoutSettings: TimeoutSettings);
+    private setupEventListeners;
+    initialize(client?: CDPSession): Promise<void>;
+    networkManager(): NetworkManager;
+    navigateFrame(frame: Frame, url: string, options?: {
+        referer?: string;
+        timeout?: number;
+        waitUntil?: PuppeteerLifeCycleEvent | PuppeteerLifeCycleEvent[];
+    }): Promise<HTTPResponse | null>;
+    page(): Page;
+    mainFrame(): Frame;
+    frames(): Frame[];
+    frame(frameId: string): Frame | null;
+    _ensureIsolatedWorld(session: CDPSession, name: string): Promise<void>;
+    executionContextById(contextId: number, session?: CDPSession): ExecutionContext;
+}
+export declare class Frame {
+    #private;
+    _frameManager: FrameManager;
+    _id: string;
+    _loaderId: string;
+    _name?: string;
+    _hasStartedLoading: boolean;
+    _lifecycleEvents: Set<string>;
+    _mainWorld: DOMWorld;
+    _secondaryWorld: DOMWorld;
+    _childFrames: Set<Frame>;
+    constructor(frameManager: FrameManager, parentFrame: Frame | null, frameId: string, client: CDPSession);
+    _updateClient(client: CDPSession): void;
+    isOOPFrame(): boolean;
+    goto(url: string, options?: {
+        referer?: string;
+        timeout?: number;
+        waitUntil?: PuppeteerLifeCycleEvent | PuppeteerLifeCycleEvent[];
+    }): Promise<HTTPResponse | null>;
+    _client(): CDPSession;
+    /**
+     * @returns a promise that resolves to the frame's default execution context.
+     */
+    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>>>;
+    name(): string;
+    url(): string;
+    parentFrame(): Frame | null;
+    childFrames(): Frame[];
+    isDetached(): boolean;
+    waitForFunction(pageFunction: Function | string, ...args: SerializableOrJSHandle[]): Promise<JSHandle>;
+    title(): Promise<string>;
+    _navigated(framePayload: Protocol.Page.Frame): void;
+    _navigatedWithinDocument(url: string): void;
+    _onLifecycleEvent(loaderId: string, name: string): void;
+    _onLoadingStopped(): void;
+    _onLoadingStarted(): void;
+    _detach(): void;
+}