conductor-oss 0.3.4 → 0.4.0

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/JSHandle.js

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Copyright 2019 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { JSHandle } from '../api/JSHandle.js';
+import { debugError } from '../common/util.js';
+import { valueFromPrimitiveRemoteObject } from './utils.js';
+/**
+ * @internal
+ */
+export class CdpJSHandle extends JSHandle {
+    #disposed = false;
+    #remoteObject;
+    #world;
+    constructor(world, remoteObject) {
+        super();
+        this.#world = world;
+        this.#remoteObject = remoteObject;
+    }
+    get disposed() {
+        return this.#disposed;
+    }
+    get realm() {
+        return this.#world;
+    }
+    get client() {
+        return this.realm.environment.client;
+    }
+    async jsonValue() {
+        if (!this.#remoteObject.objectId) {
+            return valueFromPrimitiveRemoteObject(this.#remoteObject);
+        }
+        const value = await this.evaluate(object => {
+            return object;
+        });
+        if (value === undefined) {
+            throw new Error('Could not serialize referenced object');
+        }
+        return value;
+    }
+    /**
+     * Either `null` or the handle itself if the handle is an
+     * instance of {@link ElementHandle}.
+     */
+    asElement() {
+        return null;
+    }
+    async dispose() {
+        if (this.#disposed) {
+            return;
+        }
+        this.#disposed = true;
+        await releaseObject(this.client, this.#remoteObject);
+    }
+    toString() {
+        if (!this.#remoteObject.objectId) {
+            return 'JSHandle:' + valueFromPrimitiveRemoteObject(this.#remoteObject);
+        }
+        const type = this.#remoteObject.subtype || this.#remoteObject.type;
+        return 'JSHandle@' + type;
+    }
+    get id() {
+        return this.#remoteObject.objectId;
+    }
+    remoteObject() {
+        return this.#remoteObject;
+    }
+    async getProperties() {
+        // We use Runtime.getProperties rather than iterative version for
+        // improved performance as it allows getting everything at once.
+        const response = await this.client.send('Runtime.getProperties', {
+            objectId: this.#remoteObject.objectId,
+            ownProperties: true,
+        });
+        const result = new Map();
+        for (const property of response.result) {
+            if (!property.enumerable || !property.value) {
+                continue;
+            }
+            result.set(property.name, this.#world.createCdpHandle(property.value));
+        }
+        return result;
+    }
+}
+/**
+ * @internal
+ */
+export async function releaseObject(client, remoteObject) {
+    if (!remoteObject.objectId) {
+        return;
+    }
+    await client
+        .send('Runtime.releaseObject', { objectId: remoteObject.objectId })
+        .catch(error => {
+        // Exceptions might happen in case of a page been navigated or closed.
+        // Swallow these since they are harmless and we don't leak anything in this case.
+        debugError(error);
+    });
+}
+//# sourceMappingURL=JSHandle.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/LifecycleWatcher.js

@@ -0,0 +1,174 @@
+/**
+ * @license
+ * Copyright 2019 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FrameEvent } from '../api/Frame.js';
+import { EventEmitter } from '../common/EventEmitter.js';
+import { NetworkManagerEvent } from '../common/NetworkManagerEvents.js';
+import { assert } from '../util/assert.js';
+import { Deferred } from '../util/Deferred.js';
+import { DisposableStack } from '../util/disposable.js';
+import { FrameManagerEvent } from './FrameManagerEvents.js';
+const puppeteerToProtocolLifecycle = new Map([
+    ['load', 'load'],
+    ['domcontentloaded', 'DOMContentLoaded'],
+    ['networkidle0', 'networkIdle'],
+    ['networkidle2', 'networkAlmostIdle'],
+]);
+/**
+ * @internal
+ */
+export class LifecycleWatcher {
+    #expectedLifecycle;
+    #frame;
+    #timeout;
+    #navigationRequest = null;
+    #subscriptions = new DisposableStack();
+    #initialLoaderId;
+    #terminationDeferred;
+    #sameDocumentNavigationDeferred = Deferred.create();
+    #lifecycleDeferred = Deferred.create();
+    #newDocumentNavigationDeferred = Deferred.create();
+    #error = new Error('LifecycleWatcher terminated');
+    #hasSameDocumentNavigation;
+    #swapped;
+    #navigationResponseReceived;
+    constructor(networkManager, frame, waitUntil, timeout, signal) {
+        if (Array.isArray(waitUntil)) {
+            waitUntil = waitUntil.slice();
+        }
+        else if (typeof waitUntil === 'string') {
+            waitUntil = [waitUntil];
+        }
+        this.#initialLoaderId = frame._loaderId;
+        this.#expectedLifecycle = waitUntil.map(value => {
+            const protocolEvent = puppeteerToProtocolLifecycle.get(value);
+            assert(protocolEvent, 'Unknown value for options.waitUntil: ' + value);
+            return protocolEvent;
+        });
+        signal?.addEventListener('abort', () => {
+            if (signal.reason instanceof Error) {
+                signal.reason.cause = this.#error;
+            }
+            this.#terminationDeferred.reject(signal.reason);
+        });
+        this.#frame = frame;
+        this.#timeout = timeout;
+        const frameManagerEmitter = this.#subscriptions.use(new EventEmitter(frame._frameManager));
+        frameManagerEmitter.on(FrameManagerEvent.LifecycleEvent, this.#checkLifecycleComplete.bind(this));
+        const frameEmitter = this.#subscriptions.use(new EventEmitter(frame));
+        frameEmitter.on(FrameEvent.FrameNavigatedWithinDocument, this.#navigatedWithinDocument.bind(this));
+        frameEmitter.on(FrameEvent.FrameNavigated, this.#navigated.bind(this));
+        frameEmitter.on(FrameEvent.FrameSwapped, this.#frameSwapped.bind(this));
+        frameEmitter.on(FrameEvent.FrameSwappedByActivation, this.#frameSwapped.bind(this));
+        frameEmitter.on(FrameEvent.FrameDetached, this.#onFrameDetached.bind(this));
+        const networkManagerEmitter = this.#subscriptions.use(new EventEmitter(networkManager));
+        networkManagerEmitter.on(NetworkManagerEvent.Request, this.#onRequest.bind(this));
+        networkManagerEmitter.on(NetworkManagerEvent.Response, this.#onResponse.bind(this));
+        networkManagerEmitter.on(NetworkManagerEvent.RequestFailed, this.#onRequestFailed.bind(this));
+        this.#terminationDeferred = Deferred.create({
+            timeout: this.#timeout,
+            message: `Navigation timeout of ${this.#timeout} ms exceeded`,
+        });
+        this.#checkLifecycleComplete();
+    }
+    #onRequest(request) {
+        if (request.frame() !== this.#frame || !request.isNavigationRequest()) {
+            return;
+        }
+        this.#navigationRequest = request;
+        // Resolve previous navigation response in case there are multiple
+        // navigation requests reported by the backend. This generally should not
+        // happen by it looks like it's possible.
+        this.#navigationResponseReceived?.resolve();
+        this.#navigationResponseReceived = Deferred.create();
+        if (request.response() !== null) {
+            this.#navigationResponseReceived?.resolve();
+        }
+    }
+    #onRequestFailed(request) {
+        if (this.#navigationRequest?.id !== request.id) {
+            return;
+        }
+        this.#navigationResponseReceived?.resolve();
+    }
+    #onResponse(response) {
+        if (this.#navigationRequest?.id !== response.request().id) {
+            return;
+        }
+        this.#navigationResponseReceived?.resolve();
+    }
+    #onFrameDetached(frame) {
+        if (this.#frame === frame) {
+            this.#error.message = 'Navigating frame was detached';
+            this.#terminationDeferred.resolve(this.#error);
+            return;
+        }
+        this.#checkLifecycleComplete();
+    }
+    async navigationResponse() {
+        // Continue with a possibly null response.
+        await this.#navigationResponseReceived?.valueOrThrow();
+        return this.#navigationRequest ? this.#navigationRequest.response() : null;
+    }
+    sameDocumentNavigationPromise() {
+        return this.#sameDocumentNavigationDeferred.valueOrThrow();
+    }
+    newDocumentNavigationPromise() {
+        return this.#newDocumentNavigationDeferred.valueOrThrow();
+    }
+    lifecyclePromise() {
+        return this.#lifecycleDeferred.valueOrThrow();
+    }
+    terminationPromise() {
+        return this.#terminationDeferred.valueOrThrow();
+    }
+    #navigatedWithinDocument() {
+        this.#hasSameDocumentNavigation = true;
+        this.#checkLifecycleComplete();
+    }
+    #navigated(navigationType) {
+        if (navigationType === 'BackForwardCacheRestore') {
+            return this.#frameSwapped();
+        }
+        this.#checkLifecycleComplete();
+    }
+    #frameSwapped() {
+        this.#swapped = true;
+        this.#checkLifecycleComplete();
+    }
+    #checkLifecycleComplete() {
+        // We expect navigation to commit.
+        if (!checkLifecycle(this.#frame, this.#expectedLifecycle)) {
+            return;
+        }
+        this.#lifecycleDeferred.resolve();
+        if (this.#hasSameDocumentNavigation) {
+            this.#sameDocumentNavigationDeferred.resolve(undefined);
+        }
+        if (this.#swapped || this.#frame._loaderId !== this.#initialLoaderId) {
+            this.#newDocumentNavigationDeferred.resolve(undefined);
+        }
+        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;
+        }
+    }
+    dispose() {
+        this.#subscriptions.dispose();
+        this.#error.cause = new Error('LifecycleWatcher disposed');
+        this.#terminationDeferred.resolve(this.#error);
+    }
+}
+//# sourceMappingURL=LifecycleWatcher.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/NetworkEventManager.js

@@ -0,0 +1,162 @@
+/**
+ * @license
+ * Copyright 2022 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CdpHTTPRequest } from './HTTPRequest.js';
+/**
+ * Helper class to track network events by request ID
+ *
+ * @internal
+ */
+export class NetworkEventManager {
+    /**
+     * 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)
+     */
+    #requestWillBeSentMap = new Map();
+    #requestPausedMap = new Map();
+    #httpRequestsMap = new Map();
+    #requestWillBeSentExtraInfoMap = 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.
+     */
+    #responseReceivedExtraInfoMap = new Map();
+    #queuedRedirectInfoMap = new Map();
+    #queuedEventGroupMap = new Map();
+    forget(networkRequestId) {
+        this.#requestWillBeSentMap.delete(networkRequestId);
+        this.#requestPausedMap.delete(networkRequestId);
+        this.#requestWillBeSentExtraInfoMap.delete(networkRequestId);
+        this.#queuedEventGroupMap.delete(networkRequestId);
+        this.#queuedRedirectInfoMap.delete(networkRequestId);
+        this.#responseReceivedExtraInfoMap.delete(networkRequestId);
+    }
+    requestExtraInfo(networkRequestId) {
+        if (!this.#requestWillBeSentExtraInfoMap.has(networkRequestId)) {
+            this.#requestWillBeSentExtraInfoMap.set(networkRequestId, []);
+        }
+        return this.#requestWillBeSentExtraInfoMap.get(networkRequestId);
+    }
+    responseExtraInfo(networkRequestId) {
+        if (!this.#responseReceivedExtraInfoMap.has(networkRequestId)) {
+            this.#responseReceivedExtraInfoMap.set(networkRequestId, []);
+        }
+        return this.#responseReceivedExtraInfoMap.get(networkRequestId);
+    }
+    queuedRedirectInfo(fetchRequestId) {
+        if (!this.#queuedRedirectInfoMap.has(fetchRequestId)) {
+            this.#queuedRedirectInfoMap.set(fetchRequestId, []);
+        }
+        return this.#queuedRedirectInfoMap.get(fetchRequestId);
+    }
+    queueRedirectInfo(fetchRequestId, redirectInfo) {
+        this.queuedRedirectInfo(fetchRequestId).push(redirectInfo);
+    }
+    takeQueuedRedirectInfo(fetchRequestId) {
+        return this.queuedRedirectInfo(fetchRequestId).shift();
+    }
+    inFlightRequestsCount() {
+        let inFlightRequestCounter = 0;
+        for (const request of this.#httpRequestsMap.values()) {
+            if (!request.response()) {
+                inFlightRequestCounter++;
+            }
+        }
+        return inFlightRequestCounter;
+    }
+    storeRequestWillBeSent(networkRequestId, event) {
+        this.#requestWillBeSentMap.set(networkRequestId, event);
+    }
+    getRequestWillBeSent(networkRequestId) {
+        return this.#requestWillBeSentMap.get(networkRequestId);
+    }
+    forgetRequestWillBeSent(networkRequestId) {
+        this.#requestWillBeSentMap.delete(networkRequestId);
+    }
+    getRequestPaused(networkRequestId) {
+        return this.#requestPausedMap.get(networkRequestId);
+    }
+    forgetRequestPaused(networkRequestId) {
+        this.#requestPausedMap.delete(networkRequestId);
+    }
+    storeRequestPaused(networkRequestId, event) {
+        this.#requestPausedMap.set(networkRequestId, event);
+    }
+    getRequest(networkRequestId) {
+        return this.#httpRequestsMap.get(networkRequestId);
+    }
+    storeRequest(networkRequestId, request) {
+        this.#httpRequestsMap.set(networkRequestId, request);
+    }
+    forgetRequest(networkRequestId) {
+        this.#httpRequestsMap.delete(networkRequestId);
+    }
+    getQueuedEventGroup(networkRequestId) {
+        return this.#queuedEventGroupMap.get(networkRequestId);
+    }
+    queueEventGroup(networkRequestId, event) {
+        this.#queuedEventGroupMap.set(networkRequestId, event);
+    }
+    forgetQueuedEventGroup(networkRequestId) {
+        this.#queuedEventGroupMap.delete(networkRequestId);
+    }
+    printState() {
+        function replacer(_key, value) {
+            if (value instanceof Map) {
+                return {
+                    dataType: 'Map',
+                    value: Array.from(value.entries()), // or with spread: value: [...value]
+                };
+            }
+            else if (value instanceof CdpHTTPRequest) {
+                return {
+                    dataType: 'CdpHTTPRequest',
+                    value: `${value.id}: ${value.url()}`,
+                };
+            }
+            {
+                return value;
+            }
+        }
+        console.log('httpRequestsMap', JSON.stringify(this.#httpRequestsMap, replacer, 2));
+        console.log('requestWillBeSentMap', JSON.stringify(this.#requestWillBeSentMap, replacer, 2));
+        console.log('requestWillBeSentMap', JSON.stringify(this.#responseReceivedExtraInfoMap, replacer, 2));
+        console.log('requestWillBeSentMap', JSON.stringify(this.#requestPausedMap, replacer, 2));
+    }
+}
+//# sourceMappingURL=NetworkEventManager.js.map