@remotion/renderer 4.0.0-imgloading.2 → 4.0.0-lambda.3

package/dist/browser/LifecycleWatcher.js

@@ -0,0 +1,193 @@
+"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 _LifecycleWatcher_instances, _LifecycleWatcher_expectedLifecycle, _LifecycleWatcher_frameManager, _LifecycleWatcher_frame, _LifecycleWatcher_timeout, _LifecycleWatcher_navigationRequest, _LifecycleWatcher_eventListeners, _LifecycleWatcher_sameDocumentNavigationCompleteCallback, _LifecycleWatcher_sameDocumentNavigationPromise, _LifecycleWatcher_lifecycleCallback, _LifecycleWatcher_lifecyclePromise, _LifecycleWatcher_newDocumentNavigationCompleteCallback, _LifecycleWatcher_newDocumentNavigationPromise, _LifecycleWatcher_terminationCallback, _LifecycleWatcher_terminationPromise, _LifecycleWatcher_timeoutPromise, _LifecycleWatcher_maximumTimer, _LifecycleWatcher_hasSameDocumentNavigation, _LifecycleWatcher_newDocumentNavigation, _LifecycleWatcher_swapped, _LifecycleWatcher_onRequest, _LifecycleWatcher_onFrameDetached, _LifecycleWatcher_terminate, _LifecycleWatcher_createTimeoutPromise, _LifecycleWatcher_navigatedWithinDocument, _LifecycleWatcher_navigated, _LifecycleWatcher_frameSwapped, _LifecycleWatcher_checkLifecycleComplete;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleWatcher = void 0;
+const assert_1 = require("./assert");
+const Connection_1 = require("./Connection");
+const Errors_1 = require("./Errors");
+const FrameManager_1 = require("./FrameManager");
+const NetworkManager_1 = require("./NetworkManager");
+const util_1 = require("./util");
+const puppeteerToProtocolLifecycle = new Map([
+    ['load', 'load'],
+    ['domcontentloaded', 'DOMContentLoaded'],
+    ['networkidle0', 'networkIdle'],
+    ['networkidle2', 'networkAlmostIdle'],
+]);
+const noop = () => undefined;
+class LifecycleWatcher {
+    constructor(frameManager, frame, waitUntil, timeout) {
+        _LifecycleWatcher_instances.add(this);
+        _LifecycleWatcher_expectedLifecycle.set(this, void 0);
+        _LifecycleWatcher_frameManager.set(this, void 0);
+        _LifecycleWatcher_frame.set(this, void 0);
+        _LifecycleWatcher_timeout.set(this, void 0);
+        _LifecycleWatcher_navigationRequest.set(this, null);
+        _LifecycleWatcher_eventListeners.set(this, void 0);
+        _LifecycleWatcher_sameDocumentNavigationCompleteCallback.set(this, noop);
+        _LifecycleWatcher_sameDocumentNavigationPromise.set(this, new Promise((fulfill) => {
+            __classPrivateFieldSet(this, _LifecycleWatcher_sameDocumentNavigationCompleteCallback, fulfill, "f");
+        }));
+        _LifecycleWatcher_lifecycleCallback.set(this, noop);
+        _LifecycleWatcher_lifecyclePromise.set(this, new Promise((fulfill) => {
+            __classPrivateFieldSet(this, _LifecycleWatcher_lifecycleCallback, fulfill, "f");
+        }));
+        _LifecycleWatcher_newDocumentNavigationCompleteCallback.set(this, noop);
+        _LifecycleWatcher_newDocumentNavigationPromise.set(this, new Promise((fulfill) => {
+            __classPrivateFieldSet(this, _LifecycleWatcher_newDocumentNavigationCompleteCallback, fulfill, "f");
+        }));
+        _LifecycleWatcher_terminationCallback.set(this, noop);
+        _LifecycleWatcher_terminationPromise.set(this, new Promise((fulfill) => {
+            __classPrivateFieldSet(this, _LifecycleWatcher_terminationCallback, fulfill, "f");
+        }));
+        _LifecycleWatcher_timeoutPromise.set(this, void 0);
+        _LifecycleWatcher_maximumTimer.set(this, void 0);
+        _LifecycleWatcher_hasSameDocumentNavigation.set(this, void 0);
+        _LifecycleWatcher_newDocumentNavigation.set(this, void 0);
+        _LifecycleWatcher_swapped.set(this, void 0);
+        if (Array.isArray(waitUntil)) {
+            waitUntil = waitUntil.slice();
+        }
+        else if (typeof waitUntil === 'string') {
+            waitUntil = [waitUntil];
+        }
+        __classPrivateFieldSet(this, _LifecycleWatcher_expectedLifecycle, waitUntil.map((value) => {
+            const protocolEvent = puppeteerToProtocolLifecycle.get(value);
+            (0, assert_1.assert)(protocolEvent, 'Unknown value for options.waitUntil: ' + value);
+            return protocolEvent;
+        }), "f");
+        __classPrivateFieldSet(this, _LifecycleWatcher_frameManager, frameManager, "f");
+        __classPrivateFieldSet(this, _LifecycleWatcher_frame, frame, "f");
+        __classPrivateFieldSet(this, _LifecycleWatcher_timeout, timeout, "f");
+        __classPrivateFieldSet(this, _LifecycleWatcher_eventListeners, [
+            (0, util_1.addEventListener)(frameManager._client, Connection_1.CDPSessionEmittedEvents.Disconnected, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_terminate).bind(this, new Error('Navigation failed because browser has disconnected!'))),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f"), FrameManager_1.FrameManagerEmittedEvents.LifecycleEvent, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).bind(this)),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f"), FrameManager_1.FrameManagerEmittedEvents.FrameNavigatedWithinDocument, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_navigatedWithinDocument).bind(this)),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f"), FrameManager_1.FrameManagerEmittedEvents.FrameNavigated, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_navigated).bind(this)),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f"), FrameManager_1.FrameManagerEmittedEvents.FrameSwapped, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_frameSwapped).bind(this)),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f"), FrameManager_1.FrameManagerEmittedEvents.FrameDetached, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_onFrameDetached).bind(this)),
+            (0, util_1.addEventListener)(__classPrivateFieldGet(this, _LifecycleWatcher_frameManager, "f").networkManager(), NetworkManager_1.NetworkManagerEmittedEvents.Request, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_onRequest).bind(this)),
+        ], "f");
+        __classPrivateFieldSet(this, _LifecycleWatcher_timeoutPromise, __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_createTimeoutPromise).call(this), "f");
+        __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).call(this);
+    }
+    navigationResponse() {
+        if (!__classPrivateFieldGet(this, _LifecycleWatcher_navigationRequest, "f")) {
+            return null;
+        }
+        const res = __classPrivateFieldGet(this, _LifecycleWatcher_navigationRequest, "f").response();
+        return res;
+    }
+    sameDocumentNavigationPromise() {
+        return __classPrivateFieldGet(this, _LifecycleWatcher_sameDocumentNavigationPromise, "f");
+    }
+    newDocumentNavigationPromise() {
+        return __classPrivateFieldGet(this, _LifecycleWatcher_newDocumentNavigationPromise, "f");
+    }
+    lifecyclePromise() {
+        return __classPrivateFieldGet(this, _LifecycleWatcher_lifecyclePromise, "f");
+    }
+    timeoutOrTerminationPromise() {
+        return Promise.race([__classPrivateFieldGet(this, _LifecycleWatcher_timeoutPromise, "f"), __classPrivateFieldGet(this, _LifecycleWatcher_terminationPromise, "f")]);
+    }
+    dispose() {
+        (0, util_1.removeEventListeners)(__classPrivateFieldGet(this, _LifecycleWatcher_eventListeners, "f"));
+        if (__classPrivateFieldGet(this, _LifecycleWatcher_maximumTimer, "f") !== undefined) {
+            clearTimeout(__classPrivateFieldGet(this, _LifecycleWatcher_maximumTimer, "f"));
+        }
+    }
+}
+exports.LifecycleWatcher = LifecycleWatcher;
+_LifecycleWatcher_expectedLifecycle = new WeakMap(), _LifecycleWatcher_frameManager = new WeakMap(), _LifecycleWatcher_frame = new WeakMap(), _LifecycleWatcher_timeout = new WeakMap(), _LifecycleWatcher_navigationRequest = new WeakMap(), _LifecycleWatcher_eventListeners = new WeakMap(), _LifecycleWatcher_sameDocumentNavigationCompleteCallback = new WeakMap(), _LifecycleWatcher_sameDocumentNavigationPromise = new WeakMap(), _LifecycleWatcher_lifecycleCallback = new WeakMap(), _LifecycleWatcher_lifecyclePromise = new WeakMap(), _LifecycleWatcher_newDocumentNavigationCompleteCallback = new WeakMap(), _LifecycleWatcher_newDocumentNavigationPromise = new WeakMap(), _LifecycleWatcher_terminationCallback = new WeakMap(), _LifecycleWatcher_terminationPromise = new WeakMap(), _LifecycleWatcher_timeoutPromise = new WeakMap(), _LifecycleWatcher_maximumTimer = new WeakMap(), _LifecycleWatcher_hasSameDocumentNavigation = new WeakMap(), _LifecycleWatcher_newDocumentNavigation = new WeakMap(), _LifecycleWatcher_swapped = new WeakMap(), _LifecycleWatcher_instances = new WeakSet(), _LifecycleWatcher_onRequest = function _LifecycleWatcher_onRequest(request) {
+    if (request.frame() !== __classPrivateFieldGet(this, _LifecycleWatcher_frame, "f") || !request.isNavigationRequest()) {
+        return;
+    }
+    __classPrivateFieldSet(this, _LifecycleWatcher_navigationRequest, request, "f");
+}, _LifecycleWatcher_onFrameDetached = function _LifecycleWatcher_onFrameDetached(frame) {
+    if (__classPrivateFieldGet(this, _LifecycleWatcher_frame, "f") === frame) {
+        __classPrivateFieldGet(this, _LifecycleWatcher_terminationCallback, "f").call(null, new Error('Navigating frame was detached'));
+        return;
+    }
+    __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).call(this);
+}, _LifecycleWatcher_terminate = function _LifecycleWatcher_terminate(error) {
+    __classPrivateFieldGet(this, _LifecycleWatcher_terminationCallback, "f").call(null, error);
+}, _LifecycleWatcher_createTimeoutPromise = async function _LifecycleWatcher_createTimeoutPromise() {
+    if (!__classPrivateFieldGet(this, _LifecycleWatcher_timeout, "f")) {
+        return new Promise(noop);
+    }
+    const errorMessage = 'Navigation timeout of ' + __classPrivateFieldGet(this, _LifecycleWatcher_timeout, "f") + ' ms exceeded';
+    await new Promise((fulfill) => {
+        __classPrivateFieldSet(this, _LifecycleWatcher_maximumTimer, setTimeout(fulfill, __classPrivateFieldGet(this, _LifecycleWatcher_timeout, "f")), "f");
+    });
+    return new Errors_1.TimeoutError(errorMessage);
+}, _LifecycleWatcher_navigatedWithinDocument = function _LifecycleWatcher_navigatedWithinDocument(frame) {
+    if (frame !== __classPrivateFieldGet(this, _LifecycleWatcher_frame, "f")) {
+        return;
+    }
+    __classPrivateFieldSet(this, _LifecycleWatcher_hasSameDocumentNavigation, true, "f");
+    __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).call(this);
+}, _LifecycleWatcher_navigated = function _LifecycleWatcher_navigated(frame) {
+    if (frame !== __classPrivateFieldGet(this, _LifecycleWatcher_frame, "f")) {
+        return;
+    }
+    __classPrivateFieldSet(this, _LifecycleWatcher_newDocumentNavigation, true, "f");
+    __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).call(this);
+}, _LifecycleWatcher_frameSwapped = function _LifecycleWatcher_frameSwapped(frame) {
+    if (frame !== __classPrivateFieldGet(this, _LifecycleWatcher_frame, "f")) {
+        return;
+    }
+    __classPrivateFieldSet(this, _LifecycleWatcher_swapped, true, "f");
+    __classPrivateFieldGet(this, _LifecycleWatcher_instances, "m", _LifecycleWatcher_checkLifecycleComplete).call(this);
+}, _LifecycleWatcher_checkLifecycleComplete = function _LifecycleWatcher_checkLifecycleComplete() {
+    // We expect navigation to commit.
+    if (!checkLifecycle(__classPrivateFieldGet(this, _LifecycleWatcher_frame, "f"), __classPrivateFieldGet(this, _LifecycleWatcher_expectedLifecycle, "f"))) {
+        return;
+    }
+    __classPrivateFieldGet(this, _LifecycleWatcher_lifecycleCallback, "f").call(this);
+    if (__classPrivateFieldGet(this, _LifecycleWatcher_hasSameDocumentNavigation, "f")) {
+        __classPrivateFieldGet(this, _LifecycleWatcher_sameDocumentNavigationCompleteCallback, "f").call(this);
+    }
+    if (__classPrivateFieldGet(this, _LifecycleWatcher_swapped, "f") || __classPrivateFieldGet(this, _LifecycleWatcher_newDocumentNavigation, "f")) {
+        __classPrivateFieldGet(this, _LifecycleWatcher_newDocumentNavigationCompleteCallback, "f").call(this);
+    }
+    function checkLifecycle(frame, expectedLifecycle) {
+        for (const event of expectedLifecycle) {
+            if (!frame._lifecycleEvents.has(event)) {
+                return false;
+            }
+        }
+        for (const child of frame.childFrames()) {
+            if (child._hasStartedLoading &&
+                !checkLifecycle(child, expectedLifecycle)) {
+                return false;
+            }
+        }
+        return true;
+    }
+};

package/dist/browser/NetworkConditions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2021 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 { NetworkConditions } from './NetworkManager';
+/**
+ * @public
+ */
+export declare type PredefinedNetworkConditions = {
+    [name: string]: NetworkConditions;
+};
+/**
+ * @public
+ */
+export declare const networkConditions: PredefinedNetworkConditions;

package/dist/browser/NetworkConditions.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Copyright 2021 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.networkConditions = void 0;
+/**
+ * @public
+ */
+exports.networkConditions = {
+    'Slow 3G': {
+        download: ((500 * 1000) / 8) * 0.8,
+        upload: ((500 * 1000) / 8) * 0.8,
+        latency: 400 * 5,
+    },
+    'Fast 3G': {
+        download: ((1.6 * 1000 * 1000) / 8) * 0.9,
+        upload: ((750 * 1000) / 8) * 0.9,
+        latency: 150 * 3.75,
+    },
+};

package/dist/browser/NetworkEventManager.d.ts

@@ -0,0 +1,35 @@
+import { Protocol } from 'devtools-protocol';
+import { HTTPRequest } from './HTTPRequest';
+declare type QueuedEventGroup = {
+    responseReceivedEvent: Protocol.Network.ResponseReceivedEvent;
+    loadingFinishedEvent?: Protocol.Network.LoadingFinishedEvent;
+    loadingFailedEvent?: Protocol.Network.LoadingFailedEvent;
+};
+export declare type FetchRequestId = string;
+declare type NetworkRequestId = string;
+declare type RedirectInfo = {
+    event: Protocol.Network.RequestWillBeSentEvent;
+    fetchRequestId?: FetchRequestId;
+};
+export declare class NetworkEventManager {
+    #private;
+    forget(networkRequestId: NetworkRequestId): void;
+    responseExtraInfo(networkRequestId: NetworkRequestId): Protocol.Network.ResponseReceivedExtraInfoEvent[];
+    private queuedRedirectInfo;
+    queueRedirectInfo(fetchRequestId: FetchRequestId, redirectInfo: RedirectInfo): void;
+    takeQueuedRedirectInfo(fetchRequestId: FetchRequestId): RedirectInfo | undefined;
+    numRequestsInProgress(): number;
+    storeRequestWillBeSent(networkRequestId: NetworkRequestId, event: Protocol.Network.RequestWillBeSentEvent): void;
+    getRequestWillBeSent(networkRequestId: NetworkRequestId): Protocol.Network.RequestWillBeSentEvent | undefined;
+    forgetRequestWillBeSent(networkRequestId: NetworkRequestId): void;
+    getRequestPaused(networkRequestId: NetworkRequestId): Protocol.Fetch.RequestPausedEvent | undefined;
+    forgetRequestPaused(networkRequestId: NetworkRequestId): void;
+    storeRequestPaused(networkRequestId: NetworkRequestId, event: Protocol.Fetch.RequestPausedEvent): void;
+    getRequest(networkRequestId: NetworkRequestId): HTTPRequest | undefined;
+    storeRequest(networkRequestId: NetworkRequestId, request: HTTPRequest): void;
+    forgetRequest(networkRequestId: NetworkRequestId): void;
+    getQueuedEventGroup(networkRequestId: NetworkRequestId): QueuedEventGroup | undefined;
+    queueEventGroup(networkRequestId: NetworkRequestId, event: QueuedEventGroup): void;
+    forgetQueuedEventGroup(networkRequestId: NetworkRequestId): void;
+}
+export {};

package/dist/browser/NetworkEventManager.js

@@ -0,0 +1,128 @@
+"use strict";
+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 _NetworkEventManager_requestWillBeSentMap, _NetworkEventManager_requestPausedMap, _NetworkEventManager_httpRequestsMap, _NetworkEventManager_responseReceivedExtraInfoMap, _NetworkEventManager_queuedRedirectInfoMap, _NetworkEventManager_queuedEventGroupMap;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkEventManager = void 0;
+class NetworkEventManager {
+    constructor() {
+        /*
+         * There are four possible orders of events:
+         *  A. `_onRequestWillBeSent`
+         *  B. `_onRequestWillBeSent`, `_onRequestPaused`
+         *  C. `_onRequestPaused`, `_onRequestWillBeSent`
+         *  D. `_onRequestPaused`, `_onRequestWillBeSent`, `_onRequestPaused`,
+         *     `_onRequestWillBeSent`, `_onRequestPaused`, `_onRequestPaused`
+         *     (see crbug.com/1196004)
+         *
+         * For `_onRequest` we need the event from `_onRequestWillBeSent` and
+         * optionally the `interceptionId` from `_onRequestPaused`.
+         *
+         * If request interception is disabled, call `_onRequest` once per call to
+         * `_onRequestWillBeSent`.
+         * If request interception is enabled, call `_onRequest` once per call to
+         * `_onRequestPaused` (once per `interceptionId`).
+         *
+         * Events are stored to allow for subsequent events to call `_onRequest`.
+         *
+         * Note that (chains of) redirect requests have the same `requestId` (!) as
+         * the original request. We have to anticipate series of events like these:
+         *  A. `_onRequestWillBeSent`,
+         *     `_onRequestWillBeSent`, ...
+         *  B. `_onRequestWillBeSent`, `_onRequestPaused`,
+         *     `_onRequestWillBeSent`, `_onRequestPaused`, ...
+         *  C. `_onRequestWillBeSent`, `_onRequestPaused`,
+         *     `_onRequestPaused`, `_onRequestWillBeSent`, ...
+         *  D. `_onRequestPaused`, `_onRequestWillBeSent`,
+         *     `_onRequestPaused`, `_onRequestWillBeSent`, `_onRequestPaused`,
+         *     `_onRequestWillBeSent`, `_onRequestPaused`, `_onRequestPaused`, ...
+         *     (see crbug.com/1196004)
+         */
+        _NetworkEventManager_requestWillBeSentMap.set(this, new Map());
+        _NetworkEventManager_requestPausedMap.set(this, new Map());
+        _NetworkEventManager_httpRequestsMap.set(this, new Map());
+        /*
+         * The below maps are used to reconcile Network.responseReceivedExtraInfo
+         * events with their corresponding request. Each response and redirect
+         * response gets an ExtraInfo event, and we don't know which will come first.
+         * This means that we have to store a Response or an ExtraInfo for each
+         * response, and emit the event when we get both of them. In addition, to
+         * handle redirects, we have to make them Arrays to represent the chain of
+         * events.
+         */
+        _NetworkEventManager_responseReceivedExtraInfoMap.set(this, new Map());
+        _NetworkEventManager_queuedRedirectInfoMap.set(this, new Map());
+        _NetworkEventManager_queuedEventGroupMap.set(this, new Map());
+    }
+    forget(networkRequestId) {
+        __classPrivateFieldGet(this, _NetworkEventManager_requestWillBeSentMap, "f").delete(networkRequestId);
+        __classPrivateFieldGet(this, _NetworkEventManager_requestPausedMap, "f").delete(networkRequestId);
+        __classPrivateFieldGet(this, _NetworkEventManager_queuedEventGroupMap, "f").delete(networkRequestId);
+        __classPrivateFieldGet(this, _NetworkEventManager_queuedRedirectInfoMap, "f").delete(networkRequestId);
+        __classPrivateFieldGet(this, _NetworkEventManager_responseReceivedExtraInfoMap, "f").delete(networkRequestId);
+    }
+    responseExtraInfo(networkRequestId) {
+        if (!__classPrivateFieldGet(this, _NetworkEventManager_responseReceivedExtraInfoMap, "f").has(networkRequestId)) {
+            __classPrivateFieldGet(this, _NetworkEventManager_responseReceivedExtraInfoMap, "f").set(networkRequestId, []);
+        }
+        return __classPrivateFieldGet(this, _NetworkEventManager_responseReceivedExtraInfoMap, "f").get(networkRequestId);
+    }
+    queuedRedirectInfo(fetchRequestId) {
+        if (!__classPrivateFieldGet(this, _NetworkEventManager_queuedRedirectInfoMap, "f").has(fetchRequestId)) {
+            __classPrivateFieldGet(this, _NetworkEventManager_queuedRedirectInfoMap, "f").set(fetchRequestId, []);
+        }
+        return __classPrivateFieldGet(this, _NetworkEventManager_queuedRedirectInfoMap, "f").get(fetchRequestId);
+    }
+    queueRedirectInfo(fetchRequestId, redirectInfo) {
+        this.queuedRedirectInfo(fetchRequestId).push(redirectInfo);
+    }
+    takeQueuedRedirectInfo(fetchRequestId) {
+        return this.queuedRedirectInfo(fetchRequestId).shift();
+    }
+    numRequestsInProgress() {
+        return [...__classPrivateFieldGet(this, _NetworkEventManager_httpRequestsMap, "f")].filter(([, request]) => {
+            return !request.response();
+        }).length;
+    }
+    storeRequestWillBeSent(networkRequestId, event) {
+        __classPrivateFieldGet(this, _NetworkEventManager_requestWillBeSentMap, "f").set(networkRequestId, event);
+    }
+    getRequestWillBeSent(networkRequestId) {
+        return __classPrivateFieldGet(this, _NetworkEventManager_requestWillBeSentMap, "f").get(networkRequestId);
+    }
+    forgetRequestWillBeSent(networkRequestId) {
+        __classPrivateFieldGet(this, _NetworkEventManager_requestWillBeSentMap, "f").delete(networkRequestId);
+    }
+    getRequestPaused(networkRequestId) {
+        return __classPrivateFieldGet(this, _NetworkEventManager_requestPausedMap, "f").get(networkRequestId);
+    }
+    forgetRequestPaused(networkRequestId) {
+        __classPrivateFieldGet(this, _NetworkEventManager_requestPausedMap, "f").delete(networkRequestId);
+    }
+    storeRequestPaused(networkRequestId, event) {
+        __classPrivateFieldGet(this, _NetworkEventManager_requestPausedMap, "f").set(networkRequestId, event);
+    }
+    getRequest(networkRequestId) {
+        return __classPrivateFieldGet(this, _NetworkEventManager_httpRequestsMap, "f").get(networkRequestId);
+    }
+    storeRequest(networkRequestId, request) {
+        __classPrivateFieldGet(this, _NetworkEventManager_httpRequestsMap, "f").set(networkRequestId, request);
+    }
+    forgetRequest(networkRequestId) {
+        __classPrivateFieldGet(this, _NetworkEventManager_httpRequestsMap, "f").delete(networkRequestId);
+    }
+    getQueuedEventGroup(networkRequestId) {
+        return __classPrivateFieldGet(this, _NetworkEventManager_queuedEventGroupMap, "f").get(networkRequestId);
+    }
+    queueEventGroup(networkRequestId, event) {
+        __classPrivateFieldGet(this, _NetworkEventManager_queuedEventGroupMap, "f").set(networkRequestId, event);
+    }
+    forgetQueuedEventGroup(networkRequestId) {
+        __classPrivateFieldGet(this, _NetworkEventManager_queuedEventGroupMap, "f").delete(networkRequestId);
+    }
+}
+exports.NetworkEventManager = NetworkEventManager;
+_NetworkEventManager_requestWillBeSentMap = new WeakMap(), _NetworkEventManager_requestPausedMap = new WeakMap(), _NetworkEventManager_httpRequestsMap = new WeakMap(), _NetworkEventManager_responseReceivedExtraInfoMap = new WeakMap(), _NetworkEventManager_queuedRedirectInfoMap = new WeakMap(), _NetworkEventManager_queuedEventGroupMap = new WeakMap();

package/dist/browser/NetworkManager.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 type { ProtocolMapping } from 'devtools-protocol/types/protocol-mapping';
+import { EventEmitter } from './EventEmitter';
+import { Frame } from './FrameManager';
+export declare const NetworkManagerEmittedEvents: {
+    readonly Request: symbol;
+};
+interface CDPSession extends EventEmitter {
+    send<T extends keyof ProtocolMapping.Commands>(method: T, ...paramArgs: ProtocolMapping.Commands[T]['paramsType']): Promise<ProtocolMapping.Commands[T]['returnType']>;
+}
+interface FrameManager {
+    frame(frameId: string): Frame | null;
+}
+export declare class NetworkManager extends EventEmitter {
+    #private;
+    constructor(client: CDPSession, frameManager: FrameManager);
+    initialize(): Promise<void>;
+    setExtraHTTPHeaders(extraHTTPHeaders: Record<string, string>): Promise<void>;
+    extraHTTPHeaders(): Record<string, string>;
+    numRequestsInProgress(): number;
+}
+export {};