@wdio/lighthouse-service 9.0.0-alpha.321

package/LICENSE-MIT

@@ -0,0 +1,20 @@
+Copyright (c) OpenJS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,258 @@
+WebdriverIO Lighthouse Service
+==============================
+
+> A WebdriverIO service that allows you to run accessibility and performance tests with [Google Lighthouse](https://developer.chrome.com/docs/lighthouse/overview).
+
+**Note:** this service currently only supports tests running on Google Chrome or Chromium! Given that most 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.
+
+## Installation
+
+The easiest way is to keep `@wdio/lighthouse-service` as a dev dependency in your `package.json`, via:
+
+```sh
+npm install @wdio/lighthouse-service --save-dev
+```
+
+Instructions on how to install `WebdriverIO` can be found [here](https://webdriver.io/docs/gettingstarted).
+
+## Configuration
+
+In order to use the service you just need to add the service to your service list in your `wdio.conf.js`, like:
+
+```js
+// wdio.conf.js
+export const config = {
+    // ...
+    services: ['devtools'],
+    // ...
+};
+```
+
+## Usage
+
+The `@wdio/lighthouse-service` allows you to run Google Lighthouse accessibility and performance tests through WebdriverIO.
+
+### Performance Testing
+
+The Lighthouse service allows you to capture performance data from every page load or page transition that was caused by a click. To enable it call `browser.enablePerformanceAudits(<options>)`. After you are done capturing all necessary performance data disable it to revert the throttling settings, e.g.:
+
+```js
+import assert from 'node:assert'
+
+describe('JSON.org page', () => {
+    before(async () => {
+        await browser.enablePerformanceAudits()
+    })
+
+    it('should load within performance budget', async () => {
+        /**
+         * this page load will take a bit longer as the DevTools service will
+         * capture all metrics in the background
+         */
+        await browser.url('http://json.org')
+
+        let metrics = await browser.getMetrics()
+        assert.ok(metrics.speedIndex < 1500) // check that speedIndex is below 1.5ms
+
+        let score = await browser.getPerformanceScore() // get Lighthouse Performance score
+        assert.ok(score >= .99) // Lighthouse Performance score is at 99% or higher
+
+        $('=Esperanto').click()
+
+        metrics = await browser.getMetrics()
+        assert.ok(metrics.speedIndex < 1500)
+        score = await browser.getPerformanceScore()
+        assert.ok(score >= .99)
+    })
+
+    after(async () => {
+        await browser.disablePerformanceAudits()
+    })
+})
+```
+
+You can emulate a mobile device by using the `emulateDevice` command, throttling CPU and network as well as setting `mobile` as form factor:
+
+```js
+await browser.emulateDevice('iPhone X')
+await browser.enablePerformanceAudits({
+    networkThrottling: 'Good 3G',
+    cpuThrottling: 4,
+    formFactor: 'mobile'
+})
+```
+
+The following commands with their results are available:
+
+#### `getMetrics`
+
+Gets the most commonly used performance metrics, e.g.:
+
+```js
+console.log(await browser.getMetrics())
+/**
+ * { timeToFirstByte: 566,
+ *   serverResponseTime: 566,
+ *   domContentLoaded: 3397,
+ *   firstVisualChange: 2610,
+ *   firstPaint: 2822,
+ *   firstContentfulPaint: 2822,
+ *   firstMeaningfulPaint: 2822,
+ *   largestContentfulPaint: 2822,
+ *   lastVisualChange: 15572,
+ *   interactive: 6135,
+ *   load: 8429,
+ *   speedIndex: 3259,
+ *   totalBlockingTime: 31,
+ *   maxPotentialFID: 161,
+ *   cumulativeLayoutShift: 2822 }
+ */
+```
+
+#### `getDiagnostics`
+
+Get some useful diagnostics about the page load.
+
+```js
+console.log(await browser.getDiagnostics())
+/**
+ * { numRequests: 8,
+ *   numScripts: 0,
+ *   numStylesheets: 0,
+ *   numFonts: 0,
+ *   numTasks: 237,
+ *   numTasksOver10ms: 5,
+ *   numTasksOver25ms: 2,
+ *   numTasksOver50ms: 2,
+ *   numTasksOver100ms: 0,
+ *   numTasksOver500ms: 0,
+ *   rtt: 147.20600000000002,
+ *   throughput: 47729.68474448835,
+ *   maxRtt: 176.085,
+ *   maxServerLatency: 1016.813,
+ *   totalByteWeight: 62929,
+ *   totalTaskTime: 254.07899999999978,
+ *   mainDocumentTransferSize: 8023 }
+ */
+```
+
+#### getMainThreadWorkBreakdown
+
+Returns a list with a breakdown of all main thread tasks and their total duration.
+
+```js
+console.log(await browser.getMainThreadWorkBreakdown())
+/**
+ * [ { group: 'styleLayout', duration: 130.59099999999998 },
+ *   { group: 'other', duration: 44.819 },
+ *   { group: 'paintCompositeRender', duration: 13.732000000000005 },
+ *   { group: 'parseHTML', duration: 3.9080000000000004 },
+ *   { group: 'scriptEvaluation', duration: 2.437999999999999 },
+ *   { group: 'scriptParseCompile', duration: 0.20800000000000002 } ]
+ */
+```
+
+#### getPerformanceScore
+
+Returns the [Lighthouse Performance Score](https://developers.google.com/web/tools/lighthouse/scoring) which is a weighted mean of the following metrics: `firstContentfulPaint`, `speedIndex`, `largestContentfulPaint`, `cumulativeLayoutShift`, `totalBlockingTime`, `interactive`, `maxPotentialFID` or `cumulativeLayoutShift`.
+
+```js
+console.log(await browser.getPerformanceScore())
+/**
+ * 0.897826278457836
+ */
+```
+
+#### enablePerformanceAudits
+
+Enables auto performance audits for all page loads that are caused by calling the `url` command or clicking on a link or anything that causes a page load. You can pass in a config object to determine some throttling options. The default throttling profile is `Good 3G` network with a 4x CPU throttling.
+
+```js
+await browser.enablePerformanceAudits({
+    networkThrottling: 'Good 3G',
+    cpuThrottling: 4,
+    cacheEnabled: true,
+    formFactor: 'mobile'
+})
+```
+
+The following network throttling profiles are available: `offline`, `GPRS`, `Regular 2G`, `Good 2G`, `Regular 3G`, `Good 3G`, `Regular 4G`, `DSL`, `Wifi` and `online` (no throttling).
+
+### PWA Testing
+
+With the `checkPWA` command, you can validate if your web app is compliant to the latest web standards when it comes to progressive web apps. It checks:
+
+- whether your app is installable
+- provides a service worker
+- has a splash screen
+- provides Apple Touch and Maskable Icons
+- can be served on mobile devices
+
+If you are not interested in one of these checks you can pass in a list of checks you like to run. The `passed` property will return `true` if all checks pass. If they fail you can use the `details` property to enrich your failure message with details of the failure.
+
+```js
+// open page first
+await browser.url('https://webdriver.io')
+// validate PWA
+const result = await browser.checkPWA()
+expect(result.passed).toBe(true)
+```
+
+### `startTracing(categories, samplingFrequency)` Command
+
+Start tracing the browser. You can optionally pass in custom tracing categories (defaults to [this list](https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-lighthouse-service/src/constants.js#L1-L9)) and the sampling frequency (defaults to `10000`).
+
+```js
+await browser.startTracing()
+```
+
+### `endTracing` Command
+
+Stop tracing the browser.
+
+```js
+await browser.endTracing()
+```
+
+### `getTraceLogs` Command
+
+Returns the trace-logs that were 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.
+
+```js
+import fs from 'node:fs/promises'
+
+await browser.startTracing()
+await browser.url('http://json.org')
+await browser.endTracing()
+
+await fs.writeFile('/path/to/tracelog.json', JSON.stringify(browser.getTraceLogs()))
+```
+
+### `getPageWeight` Command
+
+Returns page weight information of the last page load.
+
+```js
+await browser.startTracing()
+await browser.url('https://webdriver.io')
+await browser.endTracing()
+
+console.log(await browser.getPageWeight())
+// outputs:
+// { pageWeight: 2438485,
+//   transferred: 1139136,
+//   requestCount: 72,
+//   details: {
+//       Document: { size: 221705, encoded: 85386, count: 11 },
+//       Stylesheet: { size: 52712, encoded: 50130, count: 2 },
+//       Image: { size: 495023, encoded: 482433, count: 36 },
+//       Script: { size: 1073597, encoded: 322854, count: 15 },
+//       Font: { size: 84412, encoded: 84412, count: 5 },
+//       Other: { size: 1790, encoded: 1790, count: 2 },
+//       XHR: { size: 509246, encoded: 112131, count: 1 } }
+// }
+```
+
+----
+
+For more information on WebdriverIO see the [homepage](https://webdriver.io).

package/build/auditor.d.ts

@@ -0,0 +1,54 @@
+import type { CustomInstanceCommands } from 'webdriverio';
+import type { FormFactor, Audit, AuditResult, LHAuditResult, ErrorAudit } from './types.js';
+import type { Trace } from './gatherer/trace.js';
+import type { CDPSessionOnMessageObject } from './gatherer/devtools.js';
+export default class Auditor {
+    private _traceLogs?;
+    private _devtoolsLogs?;
+    private _formFactor?;
+    private _url?;
+    constructor(_traceLogs?: Trace | undefined, _devtoolsLogs?: CDPSessionOnMessageObject[] | undefined, _formFactor?: FormFactor | undefined);
+    _audit(AUDIT: Audit, params?: {}): Promise<LHAuditResult> | ErrorAudit;
+    /**
+     * an Auditor instance is created for every trace so provide an updateCommands
+     * function to receive the latest performance metrics with the browser instance
+     */
+    updateCommands(browser: WebdriverIO.Browser, customFn?: CustomInstanceCommands<WebdriverIO.Browser>['addCommand']): void;
+    /**
+     * Returns a list with a breakdown of all main thread task and their total duration
+     */
+    getMainThreadWorkBreakdown(): Promise<{
+        group: string;
+        duration: number;
+    }[]>;
+    /**
+     * Get some useful diagnostics about the page load
+     */
+    getDiagnostics(): Promise<any>;
+    /**
+     * Get most common used performance metrics
+     */
+    getMetrics(): Promise<{
+        timeToFirstByte: number;
+        serverResponseTime: number;
+        domContentLoaded: number;
+        firstVisualChange: number;
+        firstPaint: number;
+        firstContentfulPaint: number;
+        firstMeaningfulPaint: number;
+        largestContentfulPaint: number;
+        lastVisualChange: number;
+        interactive: number;
+        load: number;
+        speedIndex: number;
+        totalBlockingTime: number;
+        maxPotentialFID: number;
+        cumulativeLayoutShift: number;
+    }>;
+    /**
+     * Returns the Lighthouse Performance Score which is a weighted mean of the following metrics: firstMeaningfulPaint, interactive, speedIndex
+     */
+    getPerformanceScore(): Promise<any>;
+    _auditPWA(params: any, auditsToBeRun?: ("isInstallable" | "serviceWorker" | "splashScreen" | "themedOmnibox" | "contentWith" | "viewport" | "appleTouchIcon" | "maskableIcon")[]): Promise<AuditResult>;
+}
+//# sourceMappingURL=auditor.d.ts.map

package/build/auditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auditor.d.ts","sourceRoot":"","sources":["../src/auditor.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGzD,OAAO,KAAK,EACR,UAAU,EAAE,KAAK,EAEjB,WAAW,EAAE,aAAa,EAAE,UAAU,EACzC,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAA;AAMvE,MAAM,CAAC,OAAO,OAAO,OAAO;IAIpB,OAAO,CAAC,UAAU,CAAC;IACnB,OAAO,CAAC,aAAa,CAAC;IACtB,OAAO,CAAC,WAAW,CAAC;IALxB,OAAO,CAAC,IAAI,CAAC,CAAQ;gBAGT,UAAU,CAAC,mBAAO,EAClB,aAAa,CAAC,yCAA6B,EAC3C,WAAW,CAAC,wBAAY;IAOpC,MAAM,CAAE,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC,GAAG,UAAU;IA8BvE;;;OAGG;IACH,cAAc,CAAE,OAAO,EAAE,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,sBAAsB,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC;IAMlH;;OAEG;IACG,0BAA0B;;;;IAOhC;;OAEG;IACG,cAAc;IAapB;;OAEG;IACG,UAAU;;;;;;;;;;;;;;;;;IAwBhB;;OAEG;IACG,mBAAmB;IAuBnB,SAAS,CACX,MAAM,EAAE,GAAG,EACX,aAAa,4IAAyC,GACvD,OAAO,CAAC,WAAW,CAAC;CAgB1B"}

package/build/auditor.js

@@ -0,0 +1,147 @@
+import Diagnostics from 'lighthouse/lighthouse-core/audits/diagnostics.js';
+import MainThreadWorkBreakdown from 'lighthouse/lighthouse-core/audits/mainthread-work-breakdown.js';
+import Metrics from 'lighthouse/lighthouse-core/audits/metrics.js';
+import ServerResponseTime from 'lighthouse/lighthouse-core/audits/server-response-time.js';
+import CumulativeLayoutShift from 'lighthouse/lighthouse-core/audits/metrics/cumulative-layout-shift.js';
+import FirstContentfulPaint from 'lighthouse/lighthouse-core/audits/metrics/first-contentful-paint.js';
+import LargestContentfulPaint from 'lighthouse/lighthouse-core/audits/metrics/largest-contentful-paint.js';
+import SpeedIndex from 'lighthouse/lighthouse-core/audits/metrics/speed-index.js';
+import InteractiveMetric from 'lighthouse/lighthouse-core/audits/metrics/interactive.js';
+import TotalBlockingTime from 'lighthouse/lighthouse-core/audits/metrics/total-blocking-time.js';
+import ReportScoring from 'lighthouse/lighthouse-core/scoring.js';
+import defaultConfig from 'lighthouse/lighthouse-core/config/default-config.js';
+import logger from '@wdio/logger';
+import { DEFAULT_FORM_FACTOR, PWA_AUDITS } from './constants.js';
+const log = logger('@wdio/lighthouse-service:Auditor');
+export default class Auditor {
+    _traceLogs;
+    _devtoolsLogs;
+    _formFactor;
+    _url;
+    constructor(_traceLogs, _devtoolsLogs, _formFactor) {
+        this._traceLogs = _traceLogs;
+        this._devtoolsLogs = _devtoolsLogs;
+        this._formFactor = _formFactor;
+        if (_traceLogs) {
+            this._url = _traceLogs.pageUrl;
+        }
+    }
+    _audit(AUDIT, params = {}) {
+        const auditContext = {
+            options: {
+                ...AUDIT.defaultOptions
+            },
+            settings: {
+                throttlingMethod: 'devtools',
+                formFactor: this._formFactor || DEFAULT_FORM_FACTOR
+            },
+            LighthouseRunWarnings: false,
+            computedCache: new Map()
+        };
+        try {
+            return AUDIT.audit({
+                traces: { defaultPass: this._traceLogs },
+                devtoolsLogs: { defaultPass: this._devtoolsLogs },
+                TestedAsMobileDevice: true,
+                GatherContext: { gatherMode: 'navigation' },
+                ...params
+            }, auditContext);
+        }
+        catch (error) {
+            log.error(error);
+            return {
+                score: 0,
+                error
+            };
+        }
+    }
+    /**
+     * an Auditor instance is created for every trace so provide an updateCommands
+     * function to receive the latest performance metrics with the browser instance
+     */
+    updateCommands(browser, customFn) {
+        const commands = Object.getOwnPropertyNames(Object.getPrototypeOf(this)).filter(fnName => fnName !== 'constructor' && fnName !== 'updateCommands' && !fnName.startsWith('_'));
+        commands.forEach(fnName => browser.addCommand(fnName, customFn || this[fnName].bind(this)));
+    }
+    /**
+     * Returns a list with a breakdown of all main thread task and their total duration
+     */
+    async getMainThreadWorkBreakdown() {
+        const result = await this._audit(MainThreadWorkBreakdown);
+        return result.details.items.map(({ group, duration }) => ({ group, duration }));
+    }
+    /**
+     * Get some useful diagnostics about the page load
+     */
+    async getDiagnostics() {
+        const result = await this._audit(Diagnostics);
+        /**
+         * return null if Audit fails
+         */
+        if (!Object.prototype.hasOwnProperty.call(result, 'details')) {
+            return null;
+        }
+        return result.details.items[0];
+    }
+    /**
+     * Get most common used performance metrics
+     */
+    async getMetrics() {
+        const serverResponseTime = await this._audit(ServerResponseTime, { URL: this._url });
+        const cumulativeLayoutShift = await this._audit(CumulativeLayoutShift);
+        const result = await this._audit(Metrics);
+        const metrics = result.details.items[0] || {};
+        return {
+            timeToFirstByte: Math.round(serverResponseTime.numericValue),
+            serverResponseTime: Math.round(serverResponseTime.numericValue),
+            domContentLoaded: metrics.observedDomContentLoaded,
+            firstVisualChange: metrics.observedFirstVisualChange,
+            firstPaint: metrics.observedFirstPaint,
+            firstContentfulPaint: metrics.firstContentfulPaint,
+            firstMeaningfulPaint: metrics.firstMeaningfulPaint,
+            largestContentfulPaint: metrics.largestContentfulPaint,
+            lastVisualChange: metrics.observedLastVisualChange,
+            interactive: metrics.interactive,
+            load: metrics.observedLoad,
+            speedIndex: metrics.speedIndex,
+            totalBlockingTime: metrics.totalBlockingTime,
+            maxPotentialFID: metrics.maxPotentialFID,
+            cumulativeLayoutShift: cumulativeLayoutShift.numericValue,
+        };
+    }
+    /**
+     * Returns the Lighthouse Performance Score which is a weighted mean of the following metrics: firstMeaningfulPaint, interactive, speedIndex
+     */
+    async getPerformanceScore() {
+        const auditResults = {
+            'speed-index': await this._audit(SpeedIndex),
+            'first-contentful-paint': await this._audit(FirstContentfulPaint),
+            'largest-contentful-paint': await this._audit(LargestContentfulPaint),
+            'cumulative-layout-shift': await this._audit(CumulativeLayoutShift),
+            'total-blocking-time': await this._audit(TotalBlockingTime),
+            interactive: await this._audit(InteractiveMetric)
+        };
+        if (!auditResults.interactive || !auditResults['cumulative-layout-shift'] || !auditResults['first-contentful-paint'] ||
+            !auditResults['largest-contentful-paint'] || !auditResults['speed-index'] || !auditResults['total-blocking-time']) {
+            log.info('One or multiple required metrics couldn\'t be found, setting performance score to: null');
+            return null;
+        }
+        const scores = defaultConfig.categories.performance.auditRefs.filter((auditRef) => auditRef.weight).map((auditRef) => ({
+            score: auditResults[auditRef.id].score,
+            weight: auditRef.weight,
+        }));
+        return ReportScoring.arithmeticMean(scores);
+    }
+    async _auditPWA(params, auditsToBeRun = Object.keys(PWA_AUDITS)) {
+        const audits = await Promise.all(Object.entries(PWA_AUDITS)
+            .filter(([name]) => auditsToBeRun.includes(name))
+            .map(async ([name, Audit]) => [name, await this._audit(Audit, params)]));
+        return {
+            passed: !audits.find(([, result]) => result.score < 1),
+            details: audits.reduce((details, [name, result]) => {
+                details[name] = result;
+                return details;
+            }, {})
+        };
+    }
+}

package/build/commands.d.ts

@@ -0,0 +1,86 @@
+import type { TraceEvent } from '@tracerbench/trace-event';
+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 { TracingOptions } from 'puppeteer-core/lib/esm/puppeteer/cdp/Tracing.js';
+import type { RequestPayload } from './handler/network.js';
+import type { DevtoolsConfig, EnablePerformanceAuditsOptions, GathererDriver, PWAAudits } from './types.js';
+export default class CommandHandler {
+    private _session;
+    private _page;
+    private _driver;
+    private _options;
+    private _browser;
+    private _isTracing;
+    private _networkHandler;
+    private _traceEvents?;
+    private _shouldRunPerformanceAudits;
+    private _cacheEnabled?;
+    private _cpuThrottling?;
+    private _networkThrottling?;
+    private _formFactor?;
+    private _traceGatherer?;
+    private _devtoolsGatherer?;
+    private _pwaGatherer?;
+    constructor(_session: CDPSession, _page: Page, _driver: GathererDriver, _options: DevtoolsConfig, _browser: WebdriverIO.Browser | WebdriverIO.MultiRemoteBrowser);
+    /**
+     * Start tracing the browser. You can optionally pass in custom tracing categories and the
+     * sampling frequency.
+     */
+    startTracing({ categories, path, screenshots }?: TracingOptions): Promise<void>;
+    /**
+     * Stop tracing the browser.
+     */
+    endTracing(): Promise<TraceEvent[] | undefined>;
+    /**
+     * 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(): TraceEvent[] | undefined;
+    /**
+     * Returns page weight information of the last page load.
+     */
+    getPageWeight(): {
+        pageWeight: number;
+        transferred: number;
+        requestCount: number;
+        details: {
+            Document?: RequestPayload | undefined;
+            Stylesheet?: RequestPayload | undefined;
+            Image?: RequestPayload | undefined;
+            Media?: RequestPayload | undefined;
+            Font?: RequestPayload | undefined;
+            Script?: RequestPayload | undefined;
+            TextTrack?: RequestPayload | undefined;
+            XHR?: RequestPayload | undefined;
+            Fetch?: RequestPayload | undefined;
+            Prefetch?: RequestPayload | undefined;
+            EventSource?: RequestPayload | undefined;
+            WebSocket?: RequestPayload | undefined;
+            Manifest?: RequestPayload | undefined;
+            SignedExchange?: RequestPayload | undefined;
+            Ping?: RequestPayload | undefined;
+            CSPViolationReport?: RequestPayload | undefined;
+            Preflight?: RequestPayload | undefined;
+            Other?: RequestPayload | 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;
+    /**
+     * helper method to set throttling profile
+     */
+    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>;
+    private _propagateWSEvents;
+    _initCommand(): Promise<void>;
+    _beforeCmd(commandName: string, params: any[]): Promise<void> | undefined;
+    _afterCmd(commandName: string): Promise<void> | undefined;
+}
+//# sourceMappingURL=commands.d.ts.map

package/build/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oDAAoD,CAAA;AACpF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8CAA8C,CAAA;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAA;AAErF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAK1D,OAAO,KAAK,EACR,cAAc,EACd,8BAA8B,EAE9B,cAAc,EACd,SAAS,EACZ,MAAM,YAAY,CAAA;AAqBnB,MAAM,CAAC,OAAO,OAAO,cAAc;IAiB3B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,QAAQ;IApBpB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,eAAe,CAAgB;IACvC,OAAO,CAAC,YAAY,CAAC,CAAc;IAEnC,OAAO,CAAC,2BAA2B,CAAQ;IAE3C,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,cAAc,CAAC,CAAQ;IAC/B,OAAO,CAAC,kBAAkB,CAAC,CAA6B;IACxD,OAAO,CAAC,WAAW,CAAC,CAAY;IAEhC,OAAO,CAAC,cAAc,CAAC,CAAe;IACtC,OAAO,CAAC,iBAAiB,CAAC,CAAkB;IAC5C,OAAO,CAAC,YAAY,CAAC,CAAa;gBAGtB,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,IAAI,EACX,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,WAAW,CAAC,OAAO,GAAG,WAAW,CAAC,kBAAkB;IA2B1E;;;OAGG;IACH,YAAY,CAAE,EACV,UAAuC,EACvC,IAAI,EACJ,WAAkB,EACrB,GAAE,cAAmB;IAUtB;;OAEG;IACG,UAAU;IAmBhB;;;;OAIG;IACH,YAAY;IAIZ;;OAEG;IACH,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;IAQb;;OAEG;IACH,uBAAuB,CAAE,EAAE,iBAAiB,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,GAAE,8BAAuD;IAgBhJ;;OAEG;IACH,wBAAwB;IAIxB;;OAEG;IACG,oBAAoB,CACtB,iBAAiB,sHAA2C,EAC5D,aAAa,GAAE,MAA6C,EAC5D,YAAY,GAAE,OAA6C;IAWzD,QAAQ,CAAE,aAAa,CAAC,EAAE,SAAS,EAAE;IAM3C,OAAO,CAAC,kBAAkB;IAkBpB,YAAY;IAWlB,UAAU,CAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE;IAiB9C,SAAS,CAAE,WAAW,EAAE,MAAM;CAmCjC"}