@wdio/lighthouse-service 9.0.0-alpha.321

package/build/gatherer/trace.js

@@ -0,0 +1,233 @@
+import { EventEmitter } from 'node:events';
+import NetworkRecorder from 'lighthouse/lighthouse-core/lib/network-recorder.js';
+import NetworkMonitor from 'lighthouse/lighthouse-core/gather/driver/network-monitor.js';
+import ProtocolSession from 'lighthouse/lighthouse-core/fraggle-rock/gather/session.js';
+import { waitForFullyLoaded } from 'lighthouse/lighthouse-core/gather/driver/wait-for-condition.js';
+import logger from '@wdio/logger';
+import registerPerformanceObserverInPage from '../scripts/registerPerformanceObserverInPage.js';
+import { FRAME_LOAD_START_TIMEOUT, TRACING_TIMEOUT, MAX_TRACE_WAIT_TIME, CLICK_TRANSITION, NETWORK_RECORDER_EVENTS } from '../constants.js';
+import { isSupportedUrl } from '../utils.js';
+const log = logger('@wdio/lighthouse-service:TraceGatherer');
+export default class TraceGatherer extends EventEmitter {
+    _session;
+    _page;
+    _driver;
+    _failingFrameLoadIds = [];
+    _pageLoadDetected = false;
+    _networkListeners = {};
+    _frameId;
+    _loaderId;
+    _pageUrl;
+    _networkStatusMonitor;
+    _networkMonitor;
+    _protocolSession;
+    _trace;
+    _traceStart;
+    _clickTraceTimeout;
+    _waitConditionPromises = [];
+    constructor(_session, _page, _driver) {
+        super();
+        this._session = _session;
+        this._page = _page;
+        this._driver = _driver;
+        NETWORK_RECORDER_EVENTS.forEach((method) => {
+            this._networkListeners[method] = (params) => this._networkStatusMonitor.dispatch({ method, params });
+        });
+        this._protocolSession = new ProtocolSession(_session);
+        this._networkMonitor = new NetworkMonitor(_session);
+    }
+    async startTracing(url) {
+        /**
+         * delete old trace
+         */
+        delete this._trace;
+        /**
+         * register listener for network status monitoring
+         */
+        this._networkStatusMonitor = new NetworkRecorder();
+        NETWORK_RECORDER_EVENTS.forEach((method) => {
+            this._session.on(method, this._networkListeners[method]);
+        });
+        this._traceStart = Date.now();
+        log.info(`Start tracing frame with url ${url}`);
+        await this._driver.beginTrace();
+        /**
+         * if this tracing was started from a click transition
+         * then we want to discard page trace if no load detected
+         */
+        if (url === CLICK_TRANSITION) {
+            log.info('Start checking for page load for click');
+            this._clickTraceTimeout = setTimeout(async () => {
+                log.info('No page load detected, canceling trace');
+                return this.finishTracing();
+            }, FRAME_LOAD_START_TIMEOUT);
+        }
+        /**
+         * register performance observer
+         */
+        await this._page.evaluateOnNewDocument(registerPerformanceObserverInPage);
+        this._waitConditionPromises.push(waitForFullyLoaded(this._protocolSession, this._networkMonitor, { timedOut: 1 }));
+    }
+    /**
+     * store frame id of frames that are being traced
+     */
+    async onFrameNavigated(msgObj) {
+        if (!this.isTracing) {
+            return;
+        }
+        /**
+         * page load failed, cancel tracing
+         */
+        if (this._failingFrameLoadIds.includes(msgObj.frame.url)) {
+            this._waitConditionPromises = [];
+            this._frameId = '"unsuccessful loaded frame"';
+            this.finishTracing();
+            this.emit('tracingError', new Error(`Page with url "${msgObj.frame.url}" failed to load`));
+            if (this._clickTraceTimeout) {
+                clearTimeout(this._clickTraceTimeout);
+            }
+        }
+        /**
+         * ignore event if
+         */
+        if (
+        // we already detected a frameId before
+        this._frameId ||
+            // the event was thrown for a sub frame (e.g. iframe)
+            msgObj.frame.parentId ||
+            // we don't support the url of given frame
+            !isSupportedUrl(msgObj.frame.url)) {
+            log.info(`Ignore navigated frame with url ${msgObj.frame.url}`);
+            return;
+        }
+        this._frameId = msgObj.frame.id;
+        this._loaderId = msgObj.frame.loaderId;
+        this._pageUrl = msgObj.frame.url;
+        log.info(`Page load detected: ${this._pageUrl}, set frameId ${this._frameId}, set loaderId ${this._loaderId}`);
+        /**
+         * clear click tracing timeout if it's still waiting
+         *
+         * the reason we have to tie this to Page.frameNavigated instead of Page.frameStartedLoading
+         * is because the latter can sometimes occur without the former, which will cause a hang
+         * e.g. with duolingo's sign-in button
+         */
+        if (this._clickTraceTimeout && !this._pageLoadDetected) {
+            log.info('Page load detected for click, clearing click trace timeout}');
+            this._pageLoadDetected = true;
+            clearTimeout(this._clickTraceTimeout);
+        }
+        this.emit('tracingStarted', msgObj.frame.id);
+    }
+    /**
+     * once the page load event has fired, we can grab some performance
+     * metrics and timing
+     */
+    async onLoadEventFired() {
+        if (!this.isTracing) {
+            return;
+        }
+        /**
+         * Ensure that page is fully loaded and all metrics can be calculated.
+         */
+        const loadPromise = Promise.all(this._waitConditionPromises).then(() => async () => {
+            /**
+             * ensure that we trace at least for 5s to ensure that we can
+             * calculate "interactive"
+             */
+            const minTraceTime = TRACING_TIMEOUT - (Date.now() - (this._traceStart || 0));
+            if (minTraceTime > 0) {
+                log.info(`page load happen to quick, waiting ${minTraceTime}ms more`);
+                await new Promise((resolve) => setTimeout(resolve, minTraceTime));
+            }
+            return this.completeTracing();
+        });
+        const cleanupFn = await Promise.race([
+            loadPromise,
+            this.waitForMaxTimeout()
+        ]);
+        this._waitConditionPromises = [];
+        return cleanupFn();
+    }
+    onFrameLoadFail(request) {
+        const frame = request.frame();
+        if (frame) {
+            this._failingFrameLoadIds.push(frame.url());
+        }
+    }
+    get isTracing() {
+        return typeof this._traceStart === 'number';
+    }
+    /**
+     * once tracing has finished capture trace logs into memory
+     */
+    async completeTracing() {
+        const traceDuration = Date.now() - (this._traceStart || 0);
+        log.info(`Tracing completed after ${traceDuration}ms, capturing performance data for frame ${this._frameId}`);
+        /**
+         * download all tracing data
+         * in case it fails, continue without capturing any data
+         */
+        try {
+            const traceEvents = await this._driver.endTrace();
+            /**
+             * modify pid of renderer frame to be the same as where tracing was started
+             * possibly related to https://github.com/GoogleChrome/lighthouse/issues/6968
+             */
+            const startedInBrowserEvt = traceEvents.traceEvents.find(e => e.name === 'TracingStartedInBrowser');
+            const mainFrame = (startedInBrowserEvt &&
+                startedInBrowserEvt.args &&
+                startedInBrowserEvt.args.data.frames?.find((frame) => !frame.parent));
+            if (mainFrame && mainFrame.processId) {
+                const threadNameEvt = traceEvents.traceEvents.find(e => e.ph === 'R' &&
+                    e.cat === 'blink.user_timing' && e.name === 'navigationStart' && e.args.data.isLoadingMainFrame);
+                if (threadNameEvt) {
+                    log.info(`Replace mainFrame process id ${mainFrame.processId} with actual thread process id ${threadNameEvt.pid}`);
+                    mainFrame.processId = threadNameEvt.pid;
+                }
+                else {
+                    log.info(`Couldn't replace mainFrame process id ${mainFrame.processId} with actual thread process id`);
+                }
+            }
+            this._trace = {
+                ...traceEvents,
+                frameId: this._frameId,
+                loaderId: this._loaderId,
+                pageUrl: this._pageUrl,
+                traceStart: this._traceStart,
+                traceEnd: Date.now()
+            };
+            this.emit('tracingComplete', this._trace);
+            this.finishTracing();
+        }
+        catch (err) {
+            log.error(`Error capturing tracing logs: ${err.stack}`);
+            this.emit('tracingError', err);
+            return this.finishTracing();
+        }
+    }
+    /**
+     * clear tracing states and emit tracingFinished
+     */
+    finishTracing() {
+        log.info(`Tracing for ${this._frameId} completed`);
+        this._pageLoadDetected = false;
+        /**
+         * clean up the listeners
+         */
+        NETWORK_RECORDER_EVENTS.forEach((method) => this._session.off(method, this._networkListeners[method]));
+        delete this._networkStatusMonitor;
+        delete this._traceStart;
+        delete this._frameId;
+        delete this._loaderId;
+        delete this._pageUrl;
+        this._failingFrameLoadIds = [];
+        this._waitConditionPromises = [];
+        this.emit('tracingFinished');
+    }
+    waitForMaxTimeout(maxWaitForLoadedMs = MAX_TRACE_WAIT_TIME) {
+        return new Promise((resolve) => setTimeout(resolve, maxWaitForLoadedMs)).then(() => async () => {
+            log.error('Neither network nor CPU idle time could be detected within timeout, wrapping up tracing');
+            return this.completeTracing();
+        });
+    }
+}

package/build/handler/network.d.ts

@@ -0,0 +1,45 @@
+import type { CDPSession } from 'puppeteer-core/lib/esm/puppeteer/api/CDPSession.js';
+import type { Protocol } from 'devtools-protocol';
+interface RequestLog {
+    id?: string;
+    url?: string;
+    requests: Request[];
+}
+interface Request {
+    id: string;
+    url: string;
+    method: string;
+    loaderId?: string;
+    statusCode?: number;
+    requestHeaders?: Protocol.Network.Headers;
+    responseHeaders?: Protocol.Network.Headers;
+    timing?: Protocol.Network.ResourceTiming;
+    type?: Protocol.Network.ResourceType;
+    redirect?: {
+        url: string;
+        statusCode: number;
+        requestHeaders?: Protocol.Network.Headers;
+        responseHeaders?: Protocol.Network.Headers;
+        timing?: Protocol.Network.ResourceTiming;
+    };
+}
+export interface RequestPayload {
+    size: number;
+    encoded: number;
+    count: number;
+}
+export default class NetworkHandler {
+    requestLog: RequestLog;
+    requestTypes: {
+        [key in Protocol.Network.ResourceType]?: RequestPayload;
+    };
+    cachedFirstRequest?: Request;
+    constructor(session: CDPSession);
+    findRequest(params: Protocol.Network.DataReceivedEvent | Protocol.Network.ResponseReceivedEvent): Request | undefined;
+    onDataReceived(params: Protocol.Network.DataReceivedEvent): void;
+    onNetworkResponseReceived(params: Protocol.Network.ResponseReceivedEvent): void;
+    onNetworkRequestWillBeSent(params: Protocol.Network.RequestWillBeSentEvent): number | undefined;
+    onPageFrameNavigated(params: Protocol.Page.FrameNavigatedEvent): void;
+}
+export {};
+//# sourceMappingURL=network.d.ts.map

package/build/handler/network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../src/handler/network.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oDAAoD,CAAA;AACpF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAIjD,UAAU,UAAU;IAChB,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,EAAE,CAAA;CACtB;AAED,UAAU,OAAO;IACb,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAA;IACzC,eAAe,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAA;IAC1C,MAAM,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAA;IACxC,IAAI,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAA;IACpC,QAAQ,CAAC,EAAE;QACP,GAAG,EAAE,MAAM,CAAA;QACX,UAAU,EAAE,MAAM,CAAA;QAClB,cAAc,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAA;QACzC,eAAe,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAA;QAC1C,MAAM,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAA;KAC3C,CAAA;CACJ;AAED,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,CAAC,OAAO,OAAO,cAAc;IAC/B,UAAU,EAAE,UAAU,CAAmB;IACzC,YAAY,EAAE;SACT,GAAG,IAAI,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,EAAE,cAAc;KAC1D,CAAK;IACN,kBAAkB,CAAC,EAAE,OAAO,CAAA;gBAEf,OAAO,EAAE,UAAU;IAOhC,WAAW,CAAE,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,iBAAiB,GAAG,QAAQ,CAAC,OAAO,CAAC,qBAAqB;IAYhG,cAAc,CAAE,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,iBAAiB;IAkB1D,yBAAyB,CAAE,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,qBAAqB;IAgBzE,0BAA0B,CAAE,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,sBAAsB;IAiE3E,oBAAoB,CAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,mBAAmB;CAwBlE"}

package/build/handler/network.js

@@ -0,0 +1,133 @@
+import { IGNORED_URLS } from '../constants.js';
+export default class NetworkHandler {
+    requestLog = { requests: [] };
+    requestTypes = {};
+    cachedFirstRequest;
+    constructor(session) {
+        session.on('Network.dataReceived', this.onDataReceived.bind(this));
+        session.on('Network.responseReceived', this.onNetworkResponseReceived.bind(this));
+        session.on('Network.requestWillBeSent', this.onNetworkRequestWillBeSent.bind(this));
+        session.on('Page.frameNavigated', this.onPageFrameNavigated.bind(this));
+    }
+    findRequest(params) {
+        let request = this.requestLog.requests.find((req) => req.id === params.requestId);
+        /**
+         * If no match is found, check if the corresponding request is the cached first request
+         */
+        if (!request && this.cachedFirstRequest && this.cachedFirstRequest.id === params.requestId) {
+            request = this.cachedFirstRequest;
+        }
+        return request;
+    }
+    onDataReceived(params) {
+        const request = this.findRequest(params);
+        /**
+         * ensure that
+         *  - a requestWillBeSent event was triggered before
+         *  - the request type is accurate and known (sometimes this is not the case when `Network.requestWillBeSent` is triggered)
+         */
+        if (!request || !request.type || !this.requestTypes[request.type]) {
+            return;
+        }
+        const type = request.type;
+        const requestType = this.requestTypes[type] || {};
+        requestType.size += params.dataLength;
+        requestType.encoded += params.encodedDataLength;
+    }
+    onNetworkResponseReceived(params) {
+        const request = this.findRequest(params);
+        /**
+         * ensure that a requestWillBeSent event was triggered before
+         */
+        if (!request) {
+            return;
+        }
+        request.statusCode = params.response.status;
+        request.requestHeaders = params.response.requestHeaders;
+        request.responseHeaders = params.response.headers;
+        request.timing = params.response.timing;
+        request.type = params.type;
+    }
+    onNetworkRequestWillBeSent(params) {
+        let isFirstRequestOfFrame = false;
+        if (
+        /**
+         * A new page was opened when request type is a document.
+         * The first request is sent before the Page.frameNavigated event is triggered,
+         * so this request must be cached to be able to add it to the requestLog later.
+         */
+        params.type === 'Document' &&
+            /**
+             * ensure that only page loads triggered by non scripts (devtools only) are considered
+             * new page loads
+             */
+            params.initiator.type === 'other' &&
+            /**
+             * ignore pages not initated by the user
+             */
+            IGNORED_URLS.filter((url) => params.request.url.startsWith(url)).length === 0) {
+            isFirstRequestOfFrame = true;
+            /**
+             * reset the request type sizes
+             */
+            this.requestTypes = {};
+        }
+        const log = {
+            id: params.requestId,
+            url: params.request.url,
+            method: params.request.method
+        };
+        if (params.redirectResponse) {
+            log.redirect = {
+                url: params.redirectResponse.url,
+                statusCode: params.redirectResponse.status,
+                requestHeaders: params.redirectResponse.requestHeaders,
+                responseHeaders: params.redirectResponse.headers,
+                timing: params.redirectResponse.timing
+            };
+        }
+        if (params.type) {
+            const requestType = this.requestTypes[params.type];
+            if (!requestType) {
+                this.requestTypes[params.type] = {
+                    size: 0,
+                    encoded: 0,
+                    count: 1
+                };
+            }
+            else if (requestType) {
+                requestType.count++;
+            }
+        }
+        if (isFirstRequestOfFrame) {
+            log.loaderId = params.loaderId;
+            this.cachedFirstRequest = log;
+            return;
+        }
+        return this.requestLog.requests.push(log);
+    }
+    onPageFrameNavigated(params) {
+        /**
+         * Only create a requestLog for pages that don't have a parent frame.
+         * I.e. iframes are ignored
+         */
+        if (!params.frame.parentId && IGNORED_URLS.filter((url) => params.frame.url.startsWith(url)).length === 0) {
+            this.requestLog = {
+                id: params.frame.loaderId,
+                url: params.frame.url,
+                requests: []
+            };
+            /**
+             * Add the first request that was cached before the actual requestLog could be created
+             */
+            if (this.cachedFirstRequest && this.cachedFirstRequest.loaderId === params.frame.loaderId) {
+                /**
+                 * Delete the loaderId of the first request so that all request data has the same structure
+                 */
+                delete this.cachedFirstRequest.loaderId;
+                this.requestLog.requests.push(this.cachedFirstRequest);
+                this.cachedFirstRequest = undefined;
+            }
+        }
+    }
+}

package/build/index.d.ts

@@ -0,0 +1,50 @@
+import type { Capabilities, Services, FunctionProperties, ThenArg } from '@wdio/types';
+import CommandHandler from './commands.js';
+import type Auditor from './auditor.js';
+import type { DevtoolsConfig, EnablePerformanceAuditsOptions, PWAAudits } from './types.js';
+export default class DevToolsService implements Services.ServiceInstance {
+    private _options;
+    private _command;
+    private _browser?;
+    constructor(_options: DevtoolsConfig);
+    before(caps: Capabilities.RequestedStandaloneCapabilities | Capabilities.RequestedMultiremoteCapabilities, specs: string[], browser: WebdriverIO.Browser | WebdriverIO.MultiRemoteBrowser): Promise<void>;
+    onReload(): Promise<void>;
+    beforeCommand(commandName: string, params: any[]): Promise<(void | undefined)[]>;
+    afterCommand(commandName: string): Promise<(void | undefined)[]>;
+    /**
+     * set flag to run performance audits for page transitions
+     */
+    _enablePerformanceAudits({ networkThrottling, cpuThrottling, cacheEnabled, formFactor }?: EnablePerformanceAuditsOptions): void;
+    /**
+     * custom command to disable performance audits
+     */
+    _disablePerformanceAudits(): void;
+    _setThrottlingProfile(networkThrottling?: "online" | "offline" | "GPRS" | "Regular 2G" | "Good 2G" | "Regular 3G" | "Good 3G" | "Regular 4G" | "DSL" | "Wifi", cpuThrottling?: number, cacheEnabled?: boolean): Promise<void>;
+    _checkPWA(auditsToBeRun?: PWAAudits[]): Promise<import("./types.js").AuditResult | import("./types.js").AuditResult[]>;
+    _setupHandler(): Promise<void>;
+}
+export * from './types.js';
+type CommandHandlerCommands = FunctionProperties<CommandHandler>;
+type AuditorCommands = Omit<FunctionProperties<Auditor>, '_audit' | '_auditPWA' | 'updateCommands'>;
+/**
+ * ToDo(Christian): use key remapping with TS 4.1
+ * https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-1.html#key-remapping-in-mapped-types
+ */
+interface BrowserExtension extends CommandHandlerCommands, AuditorCommands {
+}
+export type BrowserExtensionSync = {
+    [K in keyof BrowserExtension]: (...args: Parameters<BrowserExtension[K]>) => ThenArg<ReturnType<BrowserExtension[K]>>;
+};
+declare global {
+    namespace WebdriverIO {
+        interface ServiceOption extends DevtoolsConfig {
+        }
+    }
+    namespace WebdriverIO {
+        interface Browser extends BrowserExtension {
+        }
+        interface MultiRemoteBrowser extends BrowserExtension {
+        }
+    }
+}
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAGtF,OAAO,cAAc,MAAM,eAAe,CAAA;AAC1C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAGvC,OAAO,KAAK,EAAE,cAAc,EAAE,8BAA8B,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3F,MAAM,CAAC,OAAO,OAAO,eAAgB,YAAW,QAAQ,CAAC,eAAe;IAIvD,OAAO,CAAC,QAAQ;IAH7B,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,QAAQ,CAAC,CAAsD;gBAElD,QAAQ,EAAE,cAAc;IAEvC,MAAM,CACR,IAAI,EAAE,YAAY,CAAC,+BAA+B,GAAG,YAAY,CAAC,gCAAgC,EAClG,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,kBAAkB;IAM3D,QAAQ;IAQR,aAAa,CAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE;IAIjD,YAAY,CAAE,WAAW,EAAE,MAAM;IAQvC;;OAEG;IACH,wBAAwB,CAAE,EAAE,iBAAiB,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,GAAE,8BAAuD;IAkBjJ;;OAEG;IACH,yBAAyB;IAUnB,qBAAqB,CACvB,iBAAiB,sHAA2C,EAC5D,aAAa,GAAE,MAA6C,EAC5D,YAAY,GAAE,OAA6C;IAWzD,SAAS,CAAE,aAAa,CAAC,EAAE,SAAS,EAAE;IAOtC,aAAa;CAwDtB;AAED,cAAc,YAAY,CAAA;AAE1B,KAAK,sBAAsB,GAAG,kBAAkB,CAAC,cAAc,CAAC,CAAA;AAChE,KAAK,eAAe,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,QAAQ,GAAG,WAAW,GAAG,gBAAgB,CAAC,CAAA;AAEnG;;;GAGG;AACH,UAAU,gBAAiB,SAAQ,sBAAsB,EAAE,eAAe;CAAG;AAE7E,MAAM,MAAM,oBAAoB,GAAG;KAC9B,CAAC,IAAI,MAAM,gBAAgB,GAAG,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;CACxH,CAAA;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,WAAW,CAAC;QAClB,UAAU,aAAc,SAAQ,cAAc;SAAG;KACpD;IAED,UAAU,WAAW,CAAC;QAClB,UAAU,OAAQ,SAAQ,gBAAgB;SAAI;QAC9C,UAAU,kBAAmB,SAAQ,gBAAgB;SAAI;KAC5D;CACJ"}

package/build/index.js

@@ -0,0 +1,126 @@
+import CommandHandler from './commands.js';
+import { setUnsupportedCommand, getLighthouseDriver } from './utils.js';
+import { DEFAULT_THROTTLE_STATE, NETWORK_STATES } from './constants.js';
+export default class DevToolsService {
+    _options;
+    _command = [];
+    _browser;
+    constructor(_options) {
+        this._options = _options;
+    }
+    async before(caps, specs, browser) {
+        this._browser = browser;
+        return await this._setupHandler();
+    }
+    async onReload() {
+        if (!this._browser) {
+            return;
+        }
+        return this._setupHandler();
+    }
+    async beforeCommand(commandName, params) {
+        return Promise.all(this._command.map(async (c) => await c._beforeCmd(commandName, params)));
+    }
+    async afterCommand(commandName) {
+        if (commandName === 'switchToWindow') {
+            await this._setupHandler();
+        }
+        return Promise.all(this._command.map(async (c) => await c._afterCmd(commandName)));
+    }
+    /**
+     * set flag to run performance audits for page transitions
+     */
+    _enablePerformanceAudits({ networkThrottling, cpuThrottling, cacheEnabled, formFactor } = DEFAULT_THROTTLE_STATE) {
+        if (!NETWORK_STATES[networkThrottling]) {
+            throw new Error(`Network throttling profile "${networkThrottling}" is unknown, choose between ${Object.keys(NETWORK_STATES).join(', ')}`);
+        }
+        if (typeof cpuThrottling !== 'number') {
+            throw new Error(`CPU throttling rate needs to be typeof number but was "${typeof cpuThrottling}"`);
+        }
+        if (this._command.length === 1) {
+            this._command[0].enablePerformanceAudits({ networkThrottling, cpuThrottling, cacheEnabled, formFactor });
+        }
+        else {
+            for (const c of this._command) {
+                c.enablePerformanceAudits({ networkThrottling, cpuThrottling, cacheEnabled, formFactor });
+            }
+        }
+    }
+    /**
+     * custom command to disable performance audits
+     */
+    _disablePerformanceAudits() {
+        if (this._command.length === 1) {
+            this._command[0].disablePerformanceAudits();
+        }
+        else {
+            for (const c of this._command) {
+                c.disablePerformanceAudits();
+            }
+        }
+    }
+    async _setThrottlingProfile(networkThrottling = DEFAULT_THROTTLE_STATE.networkThrottling, cpuThrottling = DEFAULT_THROTTLE_STATE.cpuThrottling, cacheEnabled = DEFAULT_THROTTLE_STATE.cacheEnabled) {
+        if (this._command.length === 1) {
+            this._command[0].setThrottlingProfile(networkThrottling, cpuThrottling, cacheEnabled);
+        }
+        else {
+            for (const c of this._command) {
+                c.setThrottlingProfile(networkThrottling, cpuThrottling, cacheEnabled);
+            }
+        }
+    }
+    async _checkPWA(auditsToBeRun) {
+        if (this._command.length === 1) {
+            return await this._command[0].checkPWA(auditsToBeRun);
+        }
+        return Promise.all(this._command.map(async (c) => await c.checkPWA(auditsToBeRun)));
+    }
+    async _setupHandler() {
+        if (!this._browser) {
+            return;
+        }
+        /**
+         * In case of switchToWindow, needs to not add more commands to the array
+         */
+        this._command.length = 0;
+        /**
+         * To avoid if-else, gather all browser instances into an array
+         */
+        const browsers = Object.keys(this._browser).includes('sessionId') ?
+            [this._browser] :
+            this._browser.instances.map(i => this._browser.getInstance(i));
+        for (const browser of browsers) {
+            const puppeteer = await browser.getPuppeteer().catch(() => undefined);
+            if (!puppeteer) {
+                return setUnsupportedCommand(browser);
+            }
+            const url = await browser.getUrl();
+            const target = url !== 'data:,' ?
+                await puppeteer.waitForTarget(
+                /* istanbul ignore next */
+                (t) => t.url().includes(url)) :
+                await puppeteer.waitForTarget(
+                /* istanbul ignore next */
+                // @ts-expect-error
+                (t) => t.type() === 'page' || Boolean(t._getTargetInfo().browserContextId));
+            /* istanbul ignore next */
+            if (!target) {
+                throw new Error('No page target found');
+            }
+            const page = await target.page() || null;
+            /* istanbul ignore next */
+            if (!page) {
+                throw new Error('No page found');
+            }
+            const session = await target.createCDPSession();
+            const driver = await getLighthouseDriver(session, target);
+            const cmd = new CommandHandler(session, page, driver, this._options, browser);
+            await cmd._initCommand();
+            this._command.push(cmd);
+        }
+        this._browser.addCommand('enablePerformanceAudits', this._enablePerformanceAudits.bind(this));
+        this._browser.addCommand('disablePerformanceAudits', this._disablePerformanceAudits.bind(this));
+        this._browser.addCommand('checkPWA', this._checkPWA.bind(this));
+    }
+}
+export * from './types.js';

package/build/lighthouse/cri.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="src/@types/lighthouse.js" />
+import CriConnection from 'lighthouse/lighthouse-core/gather/connections/cri.js';
+/**
+ * this class got patched to enable connecting to a remote path like
+ * ws://192.168.0.39:4444/session/349a44a32846c2659c703e71403bd472/se/cdp
+ * as it requires to attach to a session before.
+ */
+export default class ChromeProtocolPatched extends CriConnection {
+    private _sessionId?;
+    /**
+     * Add constructor for typing safety
+     * @param {number=} port Optional port number. Defaults to 9222;
+     * @param {string=} hostname Optional hostname. Defaults to localhost.
+     * @constructor
+     */
+    constructor(port?: string, hostname?: string);
+    setSessionId(sessionId: string): void;
+    /**
+     * force every command to be send with the given session id
+     */
+    sendCommand(method: string, sessionId?: string, ...paramArgs: any[]): any;
+}
+//# sourceMappingURL=cri.d.ts.map

package/build/lighthouse/cri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cri.d.ts","sourceRoot":"","sources":["../../src/lighthouse/cri.ts"],"names":[],"mappings":";AAAA,OAAO,aAAa,MAAM,sDAAsD,CAAA;AAKhF;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,aAAa;IAC5D,OAAO,CAAC,UAAU,CAAC,CAAQ;IAE3B;;;;;OAKG;gBACS,IAAI,GAAE,MAAqB,EAAE,QAAQ,GAAE,MAAyB;IAI5E,YAAY,CAAE,SAAS,EAAE,MAAM;IAI/B;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,GAAG,EAAE;CAGtE"}

package/build/lighthouse/cri.js

@@ -0,0 +1,29 @@
+import CriConnection from 'lighthouse/lighthouse-core/gather/connections/cri.js';
+const DEFAULT_HOSTNAME = 'localhost';
+const DEFAULT_PORT = '9222';
+/**
+ * this class got patched to enable connecting to a remote path like
+ * ws://192.168.0.39:4444/session/349a44a32846c2659c703e71403bd472/se/cdp
+ * as it requires to attach to a session before.
+ */
+export default class ChromeProtocolPatched extends CriConnection {
+    _sessionId;
+    /**
+     * Add constructor for typing safety
+     * @param {number=} port Optional port number. Defaults to 9222;
+     * @param {string=} hostname Optional hostname. Defaults to localhost.
+     * @constructor
+     */
+    constructor(port = DEFAULT_PORT, hostname = DEFAULT_HOSTNAME) {
+        super(port, hostname);
+    }
+    setSessionId(sessionId) {
+        this._sessionId = sessionId;
+    }
+    /**
+     * force every command to be send with the given session id
+     */
+    sendCommand(method, sessionId, ...paramArgs) {
+        return super.sendCommand(method, sessionId || this._sessionId, ...paramArgs);
+    }
+}

package/build/scripts/collectMetaElements.d.ts

@@ -0,0 +1,8 @@
+export default function collectMetaElements(): {
+    name: any;
+    content: any;
+    property: string | undefined;
+    httpEquiv: any;
+    charset: string | undefined;
+}[];
+//# sourceMappingURL=collectMetaElements.d.ts.map

package/build/scripts/collectMetaElements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectMetaElements.d.ts","sourceRoot":"","sources":["../../src/scripts/collectMetaElements.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,mBAAmB;;;;;;IAuC1C"}