@wdio/lighthouse-service 9.0.0-alpha.321

package/build/commands.js

@@ -0,0 +1,212 @@
+import logger from '@wdio/logger';
+import NetworkHandler from './handler/network.js';
+import { CLICK_TRANSITION, DEFAULT_THROTTLE_STATE, DEFAULT_TRACING_CATEGORIES, NETWORK_STATES } from './constants.js';
+import { sumByKey } from './utils.js';
+import DevtoolsGatherer from './gatherer/devtools.js';
+import Auditor from './auditor.js';
+import PWAGatherer from './gatherer/pwa.js';
+import TraceGatherer from './gatherer/trace.js';
+const log = logger('@wdio/lighthouse-service:CommandHandler');
+const TRACE_COMMANDS = ['click', 'navigateTo', 'url'];
+function isCDPSessionOnMessageObject(data) {
+    return (data !== null &&
+        typeof data === 'object' &&
+        Object.prototype.hasOwnProperty.call(data, 'params') &&
+        Object.prototype.hasOwnProperty.call(data, 'method'));
+}
+export default class CommandHandler {
+    _session;
+    _page;
+    _driver;
+    _options;
+    _browser;
+    _isTracing = false;
+    _networkHandler;
+    _traceEvents;
+    _shouldRunPerformanceAudits = false;
+    _cacheEnabled;
+    _cpuThrottling;
+    _networkThrottling;
+    _formFactor;
+    _traceGatherer;
+    _devtoolsGatherer;
+    _pwaGatherer;
+    constructor(_session, _page, _driver, _options, _browser) {
+        this._session = _session;
+        this._page = _page;
+        this._driver = _driver;
+        this._options = _options;
+        this._browser = _browser;
+        this._networkHandler = new NetworkHandler(_session);
+        this._traceGatherer = new TraceGatherer(_session, _page, _driver);
+        this._pwaGatherer = new PWAGatherer(_session, _page, _driver);
+        _session.on('Page.loadEventFired', this._traceGatherer.onLoadEventFired.bind(this._traceGatherer));
+        _session.on('Page.frameNavigated', this._traceGatherer.onFrameNavigated.bind(this._traceGatherer));
+        _page.on('requestfailed', this._traceGatherer.onFrameLoadFail.bind(this._traceGatherer));
+        this._pwaGatherer = new PWAGatherer(_session, _page, _driver);
+        /**
+         * register browser commands
+         */
+        const commands = Object.getOwnPropertyNames(Object.getPrototypeOf(this)).filter(fnName => fnName !== 'constructor' && !fnName.startsWith('_'));
+        commands.forEach(fnName => _browser.addCommand(fnName, this[fnName].bind(this)));
+        this._devtoolsGatherer = new DevtoolsGatherer();
+        _session.on('*', this._propagateWSEvents.bind(this));
+    }
+    /**
+     * Start tracing the browser. You can optionally pass in custom tracing categories and the
+     * sampling frequency.
+     */
+    startTracing({ categories = DEFAULT_TRACING_CATEGORIES, path, screenshots = true } = {}) {
+        if (this._isTracing) {
+            throw new Error('browser is already being traced');
+        }
+        this._isTracing = true;
+        this._traceEvents = undefined;
+        return this._page.tracing.start({ categories, path, screenshots });
+    }
+    /**
+     * Stop tracing the browser.
+     */
+    async endTracing() {
+        if (!this._isTracing) {
+            throw new Error('No tracing was initiated, call `browser.startTracing()` first');
+        }
+        try {
+            const traceBuffer = await this._page.tracing.stop();
+            if (!traceBuffer) {
+                throw new Error('No tracebuffer captured');
+            }
+            this._traceEvents = JSON.parse(traceBuffer.toString('utf8'));
+            this._isTracing = false;
+        }
+        catch (err) {
+            throw new Error(`Couldn't parse trace events: ${err.message}`);
+        }
+        return this._traceEvents;
+    }
+    /**
+     * Returns the tracelogs that was captured within the tracing period.
+     * You can use this command to store the trace logs on the file system to analyse the trace
+     * via Chrome DevTools interface.
+     */
+    getTraceLogs() {
+        return this._traceEvents;
+    }
+    /**
+     * Returns page weight information of the last page load.
+     */
+    getPageWeight() {
+        const requestTypes = Object.values(this._networkHandler.requestTypes).filter(Boolean);
+        const pageWeight = sumByKey(requestTypes, 'size');
+        const transferred = sumByKey(requestTypes, 'encoded');
+        const requestCount = sumByKey(requestTypes, 'count');
+        return { pageWeight, transferred, requestCount, details: this._networkHandler.requestTypes };
+    }
+    /**
+     * 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}"`);
+        }
+        this._networkThrottling = networkThrottling;
+        this._cpuThrottling = cpuThrottling;
+        this._cacheEnabled = Boolean(cacheEnabled);
+        this._formFactor = formFactor;
+        this._shouldRunPerformanceAudits = true;
+    }
+    /**
+     * custom command to disable performance audits
+     */
+    disablePerformanceAudits() {
+        this._shouldRunPerformanceAudits = false;
+    }
+    /**
+     * helper method to set throttling profile
+     */
+    async setThrottlingProfile(networkThrottling = DEFAULT_THROTTLE_STATE.networkThrottling, cpuThrottling = DEFAULT_THROTTLE_STATE.cpuThrottling, cacheEnabled = DEFAULT_THROTTLE_STATE.cacheEnabled) {
+        if (!this._page || !this._session) {
+            throw new Error('No page or session has been captured yet');
+        }
+        await this._page.setCacheEnabled(Boolean(cacheEnabled));
+        await this._session.send('Emulation.setCPUThrottlingRate', { rate: cpuThrottling });
+        await this._session.send('Network.emulateNetworkConditions', NETWORK_STATES[networkThrottling]);
+    }
+    async checkPWA(auditsToBeRun) {
+        const auditor = new Auditor();
+        const artifacts = await this._pwaGatherer.gatherData();
+        return auditor._auditPWA(artifacts, auditsToBeRun);
+    }
+    _propagateWSEvents(data) {
+        if (!isCDPSessionOnMessageObject(data)) {
+            return;
+        }
+        this._devtoolsGatherer?.onMessage(data);
+        const method = data.method || 'event';
+        try {
+            // can fail due to "Cannot convert a Symbol value to a string"
+            log.debug(`cdp event: ${method} with params ${JSON.stringify(data.params)}`);
+        }
+        catch {
+            // ignore
+        }
+        if (this._browser) {
+            this._browser.emit(method, data.params);
+        }
+    }
+    async _initCommand() {
+        /**
+         * enable domains for client
+         */
+        await Promise.all(['Page', 'Network', 'Runtime'].map((domain) => Promise.all([
+            this._session?.send(`${domain}.enable`)
+        ])));
+    }
+    _beforeCmd(commandName, params) {
+        const isCommandNavigation = ['url', 'navigateTo'].some(cmdName => cmdName === commandName);
+        if (!this._shouldRunPerformanceAudits || !this._traceGatherer || this._traceGatherer.isTracing || !TRACE_COMMANDS.includes(commandName)) {
+            return;
+        }
+        /**
+         * set browser profile
+         */
+        this.setThrottlingProfile(this._networkThrottling, this._cpuThrottling, this._cacheEnabled);
+        const url = isCommandNavigation
+            ? params[0]
+            : CLICK_TRANSITION;
+        return this._traceGatherer.startTracing(url);
+    }
+    _afterCmd(commandName) {
+        if (!this._traceGatherer || !this._traceGatherer.isTracing || !TRACE_COMMANDS.includes(commandName)) {
+            return;
+        }
+        /**
+         * update custom commands once tracing finishes
+         */
+        this._traceGatherer.once('tracingComplete', (traceEvents) => {
+            const auditor = new Auditor(traceEvents, this._devtoolsGatherer?.getLogs(), this._formFactor);
+            auditor.updateCommands(this._browser);
+        });
+        this._traceGatherer.once('tracingError', (err) => {
+            const auditor = new Auditor();
+            auditor.updateCommands(this._browser, /* istanbul ignore next */ () => {
+                throw new Error(`Couldn't capture performance due to: ${err.message}`);
+            });
+        });
+        return new Promise((resolve) => {
+            log.info(`Wait until tracing for command ${commandName} finishes`);
+            /**
+             * wait until tracing stops
+             */
+            this._traceGatherer?.once('tracingFinished', async () => {
+                log.info('Disable throttling');
+                await this.setThrottlingProfile('online', 0, true);
+                log.info('continuing with next WebDriver command');
+                resolve();
+            });
+        });
+    }
+}

package/build/constants.d.ts

@@ -0,0 +1,95 @@
+/**
+ * performance tracing categories
+ */
+export declare const DEFAULT_TRACING_CATEGORIES: string[];
+/**
+ * ignored urls in request logger
+ */
+export declare const IGNORED_URLS: readonly ["data:,", "about:", "chrome-extension://"];
+export declare const FRAME_LOAD_START_TIMEOUT = 2000;
+export declare const TRACING_TIMEOUT = 15000;
+export declare const MAX_TRACE_WAIT_TIME = 45000;
+export declare const DEFAULT_NETWORK_THROTTLING_STATE: "online";
+export declare const DEFAULT_FORM_FACTOR: "desktop";
+export declare const UNSUPPORTED_ERROR_MESSAGE: string;
+export declare const NETWORK_STATES: {
+    offline: {
+        offline: boolean;
+        latency: number;
+        downloadThroughput: number;
+        uploadThroughput: number;
+    };
+    GPRS: {
+        offline: boolean;
+        downloadThroughput: number;
+        uploadThroughput: number;
+        latency: number;
+    };
+    'Regular 2G': {
+        offline: boolean;
+        downloadThroughput: number;
+        uploadThroughput: number;
+        latency: number;
+    };
+    'Good 2G': {
+        offline: boolean;
+        downloadThroughput: number;
+        uploadThroughput: number;
+        latency: number;
+    };
+    'Regular 3G': {
+        offline: boolean;
+        latency: any;
+        downloadThroughput: number;
+        uploadThroughput: number;
+    };
+    'Good 3G': {
+        offline: boolean;
+        latency: any;
+        downloadThroughput: number;
+        uploadThroughput: number;
+    };
+    'Regular 4G': {
+        offline: boolean;
+        downloadThroughput: number;
+        uploadThroughput: number;
+        latency: number;
+    };
+    DSL: {
+        offline: boolean;
+        downloadThroughput: number;
+        uploadThroughput: number;
+        latency: number;
+    };
+    Wifi: {
+        offline: boolean;
+        downloadThroughput: number;
+        uploadThroughput: number;
+        latency: number;
+    };
+    online: {
+        offline: boolean;
+        latency: number;
+        downloadThroughput: number;
+        uploadThroughput: number;
+    };
+};
+export declare const CLICK_TRANSITION = "click transition";
+export declare const DEFAULT_THROTTLE_STATE: {
+    readonly networkThrottling: "online" | "offline" | "GPRS" | "Regular 2G" | "Good 2G" | "Regular 3G" | "Good 3G" | "Regular 4G" | "DSL" | "Wifi";
+    readonly cpuThrottling: 0;
+    readonly cacheEnabled: false;
+    readonly formFactor: "desktop";
+};
+export declare const NETWORK_RECORDER_EVENTS: readonly ["Network.requestWillBeSent", "Network.requestServedFromCache", "Network.responseReceived", "Network.dataReceived", "Network.loadingFinished", "Network.loadingFailed", "Network.resourceChangedPriority"];
+export declare const PWA_AUDITS: {
+    readonly isInstallable: any;
+    readonly serviceWorker: any;
+    readonly splashScreen: any;
+    readonly themedOmnibox: any;
+    readonly contentWith: any;
+    readonly viewport: any;
+    readonly appleTouchIcon: any;
+    readonly maskableIcon: any;
+};
+//# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,eAAO,MAAM,0BAA0B,UAyCtC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,sDAIf,CAAA;AAEV,eAAO,MAAM,wBAAwB,OAAO,CAAA;AAC5C,eAAO,MAAM,eAAe,QAAQ,CAAA;AACpC,eAAO,MAAM,mBAAmB,QAAQ,CAAA;AACxC,eAAO,MAAM,gCAAgC,UAAoB,CAAA;AACjE,eAAO,MAAM,mBAAmB,WAAqB,CAAA;AACrD,eAAO,MAAM,yBAAyB,QAIrC,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+D1B,CAAA;AAED,eAAO,MAAM,gBAAgB,qBAAqB,CAAA;AAClD,eAAO,MAAM,sBAAsB;;;;;CAKzB,CAAA;AAEV,eAAO,MAAM,uBAAuB,qNAQ1B,CAAA;AAEV,eAAO,MAAM,UAAU;;;;;;;;;CASb,CAAA"}

package/build/constants.js

@@ -0,0 +1,150 @@
+import InstallableManifest from 'lighthouse/lighthouse-core/audits/installable-manifest.js';
+import ServiceWorker from 'lighthouse/lighthouse-core/audits/service-worker.js';
+import SplashScreen from 'lighthouse/lighthouse-core/audits/splash-screen.js';
+import ThemedOmnibox from 'lighthouse/lighthouse-core/audits/themed-omnibox.js';
+import ContentWidth from 'lighthouse/lighthouse-core/audits/content-width.js';
+import Viewport from 'lighthouse/lighthouse-core/audits/viewport.js';
+import AppleTouchIcon from 'lighthouse/lighthouse-core/audits/apple-touch-icon.js';
+import MaskableIcon from 'lighthouse/lighthouse-core/audits/maskable-icon.js';
+import { throttling } from 'lighthouse/lighthouse-core/config/constants.js';
+/**
+ * performance tracing categories
+ */
+export const DEFAULT_TRACING_CATEGORIES = [
+    // Exclude default categories. We'll be selective to minimize trace size
+    '-*',
+    // Used instead of 'toplevel' in Chrome 71+
+    'disabled-by-default-lighthouse',
+    // Used for Cumulative Layout Shift metric
+    'loading',
+    // All compile/execute events are captured by parent events in devtools.timeline..
+    // But the v8 category provides some nice context for only <0.5% of the trace size
+    'v8',
+    // Same situation here. This category is there for RunMicrotasks only, but with other teams
+    // accidentally excluding microtasks, we don't want to assume a parent event will always exist
+    'v8.execute',
+    // For extracting UserTiming marks/measures
+    'blink.user_timing',
+    // Not mandatory but not used much
+    'blink.console',
+    // Most of the events we need are from these two categories
+    'devtools.timeline',
+    'disabled-by-default-devtools.timeline',
+    // Up to 450 (https://goo.gl/rBfhn4) JPGs added to the trace
+    'disabled-by-default-devtools.screenshot',
+    // This doesn't add its own events, but adds a `stackTrace` property to devtools.timeline events
+    'disabled-by-default-devtools.timeline.stack',
+    // Additional categories used by devtools. Not used by Lighthouse, but included to facilitate
+    // loading traces from Lighthouse into the Performance panel.
+    'disabled-by-default-devtools.timeline.frame',
+    'latencyInfo',
+    // CPU sampling profiler data only enabled for debugging purposes
+    // 'disabled-by-default-v8.cpu_profiler',
+    // 'disabled-by-default-v8.cpu_profiler.hires',
+];
+/**
+ * ignored urls in request logger
+ */
+export const IGNORED_URLS = [
+    'data:,', // empty pages
+    'about:', // new tabs
+    'chrome-extension://' // all chrome extensions
+];
+export const FRAME_LOAD_START_TIMEOUT = 2000;
+export const TRACING_TIMEOUT = 15000;
+export const MAX_TRACE_WAIT_TIME = 45000;
+export const DEFAULT_NETWORK_THROTTLING_STATE = 'online';
+export const DEFAULT_FORM_FACTOR = 'desktop';
+export const UNSUPPORTED_ERROR_MESSAGE = ('Can\'t connect to Chrome DevTools! The @wdio/lighthouse-service currently only supports Chrome and Chromium!\n\n' +
+    'Given that cloud vendors don\'t expose access to the Chrome DevTools Protocol this service also usually only works when ' +
+    'running tests locally or through a Selenium Grid (https://www.selenium.dev/documentation/grid/) v4 or higher.');
+export const NETWORK_STATES = {
+    offline: {
+        offline: true,
+        latency: 0,
+        downloadThroughput: 0,
+        uploadThroughput: 0
+    },
+    GPRS: {
+        offline: false,
+        downloadThroughput: 50 * 1024 / 8,
+        uploadThroughput: 20 * 1024 / 8,
+        latency: 500
+    },
+    'Regular 2G': {
+        offline: false,
+        downloadThroughput: 250 * 1024 / 8,
+        uploadThroughput: 50 * 1024 / 8,
+        latency: 300
+    },
+    'Good 2G': {
+        offline: false,
+        downloadThroughput: 450 * 1024 / 8,
+        uploadThroughput: 150 * 1024 / 8,
+        latency: 150
+    },
+    'Regular 3G': {
+        offline: false,
+        latency: throttling.mobileRegular3G.requestLatencyMs,
+        // DevTools expects throughput in bytes per second rather than kbps
+        downloadThroughput: Math.floor(throttling.mobileRegular3G.downloadThroughputKbps * 1024 / 8),
+        uploadThroughput: Math.floor(throttling.mobileRegular3G.uploadThroughputKbps * 1024 / 8)
+    },
+    'Good 3G': {
+        offline: false,
+        latency: throttling.mobileSlow4G.requestLatencyMs,
+        // DevTools expects throughput in bytes per second rather than kbps
+        downloadThroughput: Math.floor(throttling.mobileSlow4G.downloadThroughputKbps * 1024 / 8),
+        uploadThroughput: Math.floor(throttling.mobileSlow4G.uploadThroughputKbps * 1024 / 8)
+    },
+    'Regular 4G': {
+        offline: false,
+        downloadThroughput: 4 * 1024 * 1024 / 8,
+        uploadThroughput: 3 * 1024 * 1024 / 8,
+        latency: 20
+    },
+    'DSL': {
+        offline: false,
+        downloadThroughput: 2 * 1024 * 1024 / 8,
+        uploadThroughput: 1 * 1024 * 1024 / 8,
+        latency: 5
+    },
+    'Wifi': {
+        offline: false,
+        downloadThroughput: 30 * 1024 * 1024 / 8,
+        uploadThroughput: 15 * 1024 * 1024 / 8,
+        latency: 2
+    },
+    online: {
+        offline: false,
+        latency: 0,
+        downloadThroughput: -1,
+        uploadThroughput: -1
+    }
+};
+export const CLICK_TRANSITION = 'click transition';
+export const DEFAULT_THROTTLE_STATE = {
+    networkThrottling: DEFAULT_NETWORK_THROTTLING_STATE,
+    cpuThrottling: 0,
+    cacheEnabled: false,
+    formFactor: DEFAULT_FORM_FACTOR
+};
+export const NETWORK_RECORDER_EVENTS = [
+    'Network.requestWillBeSent',
+    'Network.requestServedFromCache',
+    'Network.responseReceived',
+    'Network.dataReceived',
+    'Network.loadingFinished',
+    'Network.loadingFailed',
+    'Network.resourceChangedPriority'
+];
+export const PWA_AUDITS = {
+    isInstallable: InstallableManifest,
+    serviceWorker: ServiceWorker,
+    splashScreen: SplashScreen,
+    themedOmnibox: ThemedOmnibox,
+    contentWith: ContentWidth,
+    viewport: Viewport,
+    appleTouchIcon: AppleTouchIcon,
+    maskableIcon: MaskableIcon
+};

package/build/gatherer/devtools.d.ts

@@ -0,0 +1,19 @@
+export interface CDPSessionOnMessageObject {
+    id?: number;
+    method: string;
+    params: Record<string, unknown>;
+    error: {
+        message: string;
+        data: any;
+    };
+    result?: any;
+}
+export default class DevtoolsGatherer {
+    private _logs;
+    onMessage(msgObj: CDPSessionOnMessageObject): void;
+    /**
+     * retrieve logs and clean cache
+     */
+    getLogs(): CDPSessionOnMessageObject[];
+}
+//# sourceMappingURL=devtools.d.ts.map

package/build/gatherer/devtools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools.d.ts","sourceRoot":"","sources":["../../src/gatherer/devtools.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yBAAyB;IACtC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,KAAK,EAAE;QACH,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,GAAG,CAAC;KACb,CAAC;IACF,MAAM,CAAC,EAAE,GAAG,CAAC;CAChB;AAED,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACjC,OAAO,CAAC,KAAK,CAAkC;IAE/C,SAAS,CAAE,MAAM,EAAE,yBAAyB;IAI5C;;OAEG;IACH,OAAO;CAGV"}

package/build/gatherer/devtools.js

@@ -0,0 +1,12 @@
+export default class DevtoolsGatherer {
+    _logs = [];
+    onMessage(msgObj) {
+        this._logs.push(msgObj);
+    }
+    /**
+     * retrieve logs and clean cache
+     */
+    getLogs() {
+        return this._logs.splice(0, this._logs.length);
+    }
+}

package/build/gatherer/pwa.d.ts

@@ -0,0 +1,28 @@
+import type { CDPSession } from 'puppeteer-core/lib/esm/puppeteer/api/CDPSession.js';
+import type { Page } from 'puppeteer-core/lib/esm/puppeteer/api/Page.js';
+import type { GathererDriver } from '../types.js';
+export default class PWAGatherer {
+    private _session;
+    private _page;
+    private _driver;
+    private _frGatherer;
+    private _networkRecorder;
+    private _networkRecords;
+    constructor(_session: CDPSession, _page: Page, _driver: GathererDriver);
+    gatherData(): Promise<{
+        URL: {
+            requestedUrl: string;
+            finalUrl: string;
+        };
+        WebAppManifest: any;
+        InstallabilityErrors: any;
+        MetaElements: any;
+        ViewportDimensions: any;
+        ServiceWorker: {
+            versions: any;
+            registrations: any;
+        };
+        LinkElements: any;
+    }>;
+}
+//# sourceMappingURL=pwa.d.ts.map

package/build/gatherer/pwa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pwa.d.ts","sourceRoot":"","sources":["../../src/gatherer/pwa.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oDAAoD,CAAA;AACpF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8CAA8C,CAAA;AAIxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAEjD,MAAM,CAAC,OAAO,OAAO,WAAW;IAMxB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,OAAO;IAPnB,OAAO,CAAC,WAAW,CAAmB;IACtC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,eAAe,CAAY;gBAGvB,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,IAAI,EACX,OAAO,EAAE,cAAc;IAsB7B,UAAU;;;;;;;;;;;;;;;CA4BnB"}

package/build/gatherer/pwa.js

@@ -0,0 +1,66 @@
+import FRGatherer from 'lighthouse/lighthouse-core/fraggle-rock/gather/session.js';
+import pageFunctions from 'lighthouse/lighthouse-core/lib/page-functions.js';
+import NetworkRecorder from 'lighthouse/lighthouse-core/lib/network-recorder.js';
+import InstallabilityErrors from 'lighthouse/lighthouse-core/gather/gatherers/installability-errors.js';
+import WebAppManifest from 'lighthouse/lighthouse-core/gather/gatherers/web-app-manifest.js';
+import LinkElements from 'lighthouse/lighthouse-core/gather/gatherers/link-elements.js';
+import ViewportDimensions from 'lighthouse/lighthouse-core/gather/gatherers/viewport-dimensions.js';
+import serviceWorkers from 'lighthouse/lighthouse-core/gather/driver/service-workers.js';
+import collectMetaElements from '../scripts/collectMetaElements.js';
+import { NETWORK_RECORDER_EVENTS } from '../constants.js';
+export default class PWAGatherer {
+    _session;
+    _page;
+    _driver;
+    _frGatherer;
+    _networkRecorder;
+    _networkRecords = [];
+    constructor(_session, _page, _driver) {
+        this._session = _session;
+        this._page = _page;
+        this._driver = _driver;
+        this._frGatherer = new FRGatherer(this._session);
+        /**
+         * setup network recorder
+         */
+        this._networkRecorder = new NetworkRecorder();
+        NETWORK_RECORDER_EVENTS.forEach((method) => {
+            this._session.on(method, (params) => this._networkRecorder.dispatch({ method, params }));
+        });
+        /**
+         * clean up network records after every page load
+         */
+        this._page.on('load', () => {
+            this._networkRecords = this._networkRecorder.getRawRecords();
+            delete this._networkRecorder;
+            this._networkRecorder = new NetworkRecorder();
+        });
+    }
+    async gatherData() {
+        const pageUrl = await this._page?.url();
+        const passContext = {
+            url: pageUrl,
+            driver: this._driver
+        };
+        const loadData = {
+            networkRecords: this._networkRecords
+        };
+        const linkElements = new LinkElements();
+        const viewportDimensions = new ViewportDimensions();
+        const { registrations } = await serviceWorkers.getServiceWorkerRegistrations(this._frGatherer);
+        const { versions } = await serviceWorkers.getServiceWorkerVersions(this._frGatherer);
+        return {
+            URL: { requestedUrl: pageUrl, finalUrl: pageUrl },
+            WebAppManifest: await WebAppManifest.getWebAppManifest(this._frGatherer, pageUrl),
+            InstallabilityErrors: await InstallabilityErrors.getInstallabilityErrors(this._frGatherer),
+            MetaElements: await this._driver.evaluate(collectMetaElements, {
+                args: [],
+                useIsolation: true,
+                deps: [pageFunctions.getElementsInDocument],
+            }),
+            ViewportDimensions: await viewportDimensions.afterPass(passContext),
+            ServiceWorker: { versions, registrations },
+            LinkElements: await linkElements.afterPass(passContext, loadData)
+        };
+    }
+}

package/build/gatherer/trace.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" resolution-mode="require"/>
+import { EventEmitter } from 'node:events';
+import type { Protocol } from 'devtools-protocol';
+import type { TraceEvent } from '@tracerbench/trace-event';
+import type { HTTPRequest } from 'puppeteer-core/lib/esm/puppeteer/api/HTTPRequest.js';
+import type { CDPSession } from 'puppeteer-core/lib/esm/puppeteer/api/CDPSession.js';
+import type { Page } from 'puppeteer-core/lib/esm/puppeteer/api/Page.js';
+import type { GathererDriver } from '../types.js';
+export interface Trace {
+    traceEvents: TraceEvent[];
+    frameId?: string;
+    loaderId?: string;
+    pageUrl?: string;
+    traceStart?: number;
+    traceEnd?: number;
+}
+export interface WaitPromise {
+    promise: Promise<any>;
+    cancel: Function;
+}
+export default class TraceGatherer extends EventEmitter {
+    private _session;
+    private _page;
+    private _driver;
+    private _failingFrameLoadIds;
+    private _pageLoadDetected;
+    private _networkListeners;
+    private _frameId?;
+    private _loaderId?;
+    private _pageUrl?;
+    private _networkStatusMonitor;
+    private _networkMonitor;
+    private _protocolSession;
+    private _trace?;
+    private _traceStart?;
+    private _clickTraceTimeout?;
+    private _waitConditionPromises;
+    constructor(_session: CDPSession, _page: Page, _driver: GathererDriver);
+    startTracing(url: string): Promise<void>;
+    /**
+     * store frame id of frames that are being traced
+     */
+    onFrameNavigated(msgObj: Protocol.Page.FrameNavigatedEvent): Promise<void>;
+    /**
+     * once the page load event has fired, we can grab some performance
+     * metrics and timing
+     */
+    onLoadEventFired(): Promise<void>;
+    onFrameLoadFail(request: HTTPRequest): void;
+    get isTracing(): boolean;
+    /**
+     * once tracing has finished capture trace logs into memory
+     */
+    completeTracing(): Promise<void>;
+    /**
+     * clear tracing states and emit tracingFinished
+     */
+    finishTracing(): void;
+    waitForMaxTimeout(maxWaitForLoadedMs?: number): Promise<() => Promise<void>>;
+}
+//# sourceMappingURL=trace.d.ts.map

package/build/gatherer/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/gatherer/trace.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAO1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,0BAA0B,CAAA;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qDAAqD,CAAA;AACtF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oDAAoD,CAAA;AACpF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8CAA8C,CAAA;AASxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAIjD,MAAM,WAAW,KAAK;IAClB,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB;AAiBD,MAAM,WAAW,WAAW;IACxB,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;IACrB,MAAM,EAAE,QAAQ,CAAA;CACnB;AAED,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,YAAY;IAgBtC,OAAO,CAAC,QAAQ;IAAc,OAAO,CAAC,KAAK;IAAQ,OAAO,CAAC,OAAO;IAf/E,OAAO,CAAC,oBAAoB,CAAe;IAC3C,OAAO,CAAC,iBAAiB,CAAQ;IACjC,OAAO,CAAC,iBAAiB,CAA4C;IAErE,OAAO,CAAC,QAAQ,CAAC,CAAQ;IACzB,OAAO,CAAC,SAAS,CAAC,CAAQ;IAC1B,OAAO,CAAC,QAAQ,CAAC,CAAQ;IACzB,OAAO,CAAC,qBAAqB,CAAwB;IACrD,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,gBAAgB,CAAyB;IACjD,OAAO,CAAC,MAAM,CAAC,CAAO;IACtB,OAAO,CAAC,WAAW,CAAC,CAAQ;IAC5B,OAAO,CAAC,kBAAkB,CAAC,CAAgB;IAC3C,OAAO,CAAC,sBAAsB,CAAsB;gBAE/B,QAAQ,EAAE,UAAU,EAAU,KAAK,EAAE,IAAI,EAAU,OAAO,EAAE,cAAc;IAWzF,YAAY,CAAE,GAAG,EAAE,MAAM;IAwC/B;;OAEG;IACG,gBAAgB,CAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,mBAAmB;IAsDjE;;;OAGG;IACG,gBAAgB;IA+BtB,eAAe,CAAE,OAAO,EAAE,WAAW;IAQrC,IAAI,SAAS,YAEZ;IAED;;OAEG;IACG,eAAe;IAiDrB;;OAEG;IACH,aAAa;IAoBb,iBAAiB,CAAE,kBAAkB,SAAsB;CAQ9D"}