lighthouse 12.8.2-dev.20251007 → 12.8.2-dev.20251008

package/core/gather/gatherers/cache-contents.js

@@ -1,56 +0,0 @@
-/**
- * @license
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import BaseGatherer from '../base-gatherer.js';
-
-/**
- * @return {Promise<Array<string>>}
- */
-/* c8 ignore start */
-function getCacheContents() {
-  // Get every cache by name.
-  return caches.keys()
-
-      // Open each one.
-      .then(cacheNames => Promise.all(cacheNames.map(cacheName => caches.open(cacheName))))
-
-      .then(caches => {
-        /** @type {Array<string>} */
-        const requests = [];
-
-        // Take each cache and get any requests is contains, and bounce each one down to its URL.
-        return Promise.all(caches.map(cache => {
-          return cache.keys()
-              .then(reqs => {
-                requests.push(...reqs.map(r => r.url));
-              });
-        })).then(_ => {
-          return requests;
-        });
-      });
-}
-/* c8 ignore stop */
-
-class CacheContents extends BaseGatherer {
-  /** @type {LH.Gatherer.GathererMeta} */
-  meta = {
-    supportedModes: ['snapshot', 'navigation'],
-  };
-
-  /**
-   * Creates an array of cached URLs.
-   * @param {LH.Gatherer.Context} passContext
-   * @return {Promise<LH.Artifacts['CacheContents']>}
-   */
-  async getArtifact(passContext) {
-    const driver = passContext.driver;
-
-    const cacheUrls = await driver.executionContext.evaluate(getCacheContents, {args: []});
-    return cacheUrls;
-  }
-}
-
-export default CacheContents;

package/core/gather/gatherers/dobetterweb/domstats.d.ts

@@ -1,10 +0,0 @@
-export default DOMStats;
-declare class DOMStats extends BaseGatherer {
-    /**
-     * @param {LH.Gatherer.Context} passContext
-     * @return {Promise<LH.Artifacts['DOMStats']>}
-     */
-    getArtifact(passContext: LH.Gatherer.Context): Promise<LH.Artifacts["DOMStats"]>;
-}
-import BaseGatherer from '../../base-gatherer.js';
-//# sourceMappingURL=domstats.d.ts.map

package/core/gather/gatherers/dobetterweb/domstats.js

@@ -1,102 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Gathers stats about the max height and width of the DOM tree
- * and total number of elements used on the page.
- */
-
-/* global getNodeDetails */
-
-
-import BaseGatherer from '../../base-gatherer.js';
-import {pageFunctions} from '../../../lib/page-functions.js';
-
-/**
- * Calculates the maximum tree depth of the DOM.
- * @param {HTMLElement} element Root of the tree to look in.
- * @param {boolean=} deep True to include shadow roots. Defaults to true.
- * @return {LH.Artifacts.DOMStats}
- */
-/* c8 ignore start */
-function getDOMStats(element = document.body, deep = true) {
-  let deepestElement = null;
-  let maxDepth = -1;
-  let maxWidth = -1;
-  let numElements = 0;
-  let parentWithMostChildren = null;
-
-  /**
-   * @param {Element|ShadowRoot} element
-   * @param {number} depth
-   */
-  const _calcDOMWidthAndHeight = function(element, depth = 1) {
-    if (depth > maxDepth) {
-      deepestElement = element;
-      maxDepth = depth;
-    }
-    if (element.children.length > maxWidth) {
-      parentWithMostChildren = element;
-      maxWidth = element.children.length;
-    }
-
-    let child = element.firstElementChild;
-    while (child) {
-      _calcDOMWidthAndHeight(child, depth + 1);
-      // If element has shadow dom, traverse into that tree.
-      if (deep && child.shadowRoot) {
-        _calcDOMWidthAndHeight(child.shadowRoot, depth + 1);
-      }
-      child = child.nextElementSibling;
-      numElements++;
-    }
-
-    return {maxDepth, maxWidth, numElements};
-  };
-
-  const result = _calcDOMWidthAndHeight(element);
-
-  return {
-    depth: {
-      max: result.maxDepth,
-      // @ts-expect-error - getNodeDetails put into scope via stringification
-      ...getNodeDetails(deepestElement),
-    },
-    width: {
-      max: result.maxWidth,
-      // @ts-expect-error - getNodeDetails put into scope via stringification
-      ...getNodeDetails(parentWithMostChildren),
-    },
-    totalBodyElements: result.numElements,
-  };
-}
-/* c8 ignore stop */
-
-class DOMStats extends BaseGatherer {
-  /** @type {LH.Gatherer.GathererMeta} */
-  meta = {
-    supportedModes: ['snapshot', 'navigation'],
-  };
-
-  /**
-   * @param {LH.Gatherer.Context} passContext
-   * @return {Promise<LH.Artifacts['DOMStats']>}
-   */
-  async getArtifact(passContext) {
-    const driver = passContext.driver;
-
-    await driver.defaultSession.sendCommand('DOM.enable');
-    const results = await driver.executionContext.evaluate(getDOMStats, {
-      args: [],
-      useIsolation: true,
-      deps: [pageFunctions.getNodeDetails],
-    });
-    await driver.defaultSession.sendCommand('DOM.disable');
-    return results;
-  }
-}
-
-export default DOMStats;

package/core/gather/gatherers/dobetterweb/optimized-images.d.ts

@@ -1,48 +0,0 @@
-export default OptimizedImages;
-export type SimplifiedNetworkRecord = {
-    requestId: string;
-    url: string;
-    mimeType: string;
-    resourceSize: number;
-};
-/** @typedef {{requestId: string, url: string, mimeType: string, resourceSize: number}} SimplifiedNetworkRecord */
-declare class OptimizedImages extends BaseGatherer {
-    /**
-     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-     * @return {Array<SimplifiedNetworkRecord>}
-     */
-    static filterImageRequests(networkRecords: Array<LH.Artifacts.NetworkRequest>): Array<SimplifiedNetworkRecord>;
-    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
-    meta: LH.Gatherer.GathererMeta<"DevtoolsLog">;
-    _encodingStartAt: number;
-    /**
-     * @param {LH.Gatherer.ProtocolSession} session
-     * @param {string} requestId
-     * @param {'jpeg'|'webp'} encoding Either webp or jpeg.
-     * @return {Promise<LH.Crdp.Audits.GetEncodedResponseResponse>}
-     */
-    _getEncodedResponse(session: LH.Gatherer.ProtocolSession, requestId: string, encoding: "jpeg" | "webp"): Promise<LH.Crdp.Audits.GetEncodedResponseResponse>;
-    /**
-     * @param {LH.Gatherer.ProtocolSession} session
-     * @param {SimplifiedNetworkRecord} networkRecord
-     * @return {Promise<{originalSize: number, jpegSize?: number, webpSize?: number}>}
-     */
-    calculateImageStats(session: LH.Gatherer.ProtocolSession, networkRecord: SimplifiedNetworkRecord): Promise<{
-        originalSize: number;
-        jpegSize?: number;
-        webpSize?: number;
-    }>;
-    /**
-     * @param {LH.Gatherer.ProtocolSession} session
-     * @param {Array<SimplifiedNetworkRecord>} imageRecords
-     * @return {Promise<LH.Artifacts['OptimizedImages']>}
-     */
-    computeOptimizedImages(session: LH.Gatherer.ProtocolSession, imageRecords: Array<SimplifiedNetworkRecord>): Promise<LH.Artifacts["OptimizedImages"]>;
-    /**
-     * @param {LH.Gatherer.Context<'DevtoolsLog'>} context
-     * @return {Promise<LH.Artifacts['OptimizedImages']>}
-     */
-    getArtifact(context: LH.Gatherer.Context<"DevtoolsLog">): Promise<LH.Artifacts["OptimizedImages"]>;
-}
-import BaseGatherer from '../../base-gatherer.js';
-//# sourceMappingURL=optimized-images.d.ts.map

package/core/gather/gatherers/dobetterweb/optimized-images.js

@@ -1,169 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
-  * @fileoverview Determines optimized jpeg/webp filesizes for all same-origin and dataURI images
-  */
-
-import log from 'lighthouse-logger';
-
-import BaseGatherer from '../../base-gatherer.js';
-import UrlUtils from '../../../lib/url-utils.js';
-import {NetworkRequest} from '../../../lib/network-request.js';
-import {Sentry} from '../../../lib/sentry.js';
-import {NetworkRecords} from '../../../computed/network-records.js';
-import DevtoolsLog from '../devtools-log.js';
-
-// Image encoding can be slow and we don't want to spend forever on it.
-// Cap our encoding to 5 seconds, anything after that will be estimated.
-const MAX_TIME_TO_SPEND_ENCODING = 5000;
-// Cap our image file size at 2MB, anything bigger than that will be estimated.
-const MAX_RESOURCE_SIZE_TO_ENCODE = 2000 * 1024;
-
-const JPEG_QUALITY = 0.92;
-const WEBP_QUALITY = 0.85;
-
-const MINIMUM_IMAGE_SIZE = 4096; // savings of <4 KiB will be ignored in the audit anyway
-
-const IMAGE_REGEX = /^image\/((x|ms|x-ms)-)?(png|bmp|jpeg)$/;
-
-/** @typedef {{requestId: string, url: string, mimeType: string, resourceSize: number}} SimplifiedNetworkRecord */
-
-class OptimizedImages extends BaseGatherer {
-  /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
-  meta = {
-    supportedModes: ['timespan', 'navigation'],
-    dependencies: {DevtoolsLog: DevtoolsLog.symbol},
-  };
-
-  constructor() {
-    super();
-    this._encodingStartAt = 0;
-  }
-
-  /**
-   * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   * @return {Array<SimplifiedNetworkRecord>}
-   */
-  static filterImageRequests(networkRecords) {
-    /** @type {Set<string>} */
-    const seenUrls = new Set();
-    return networkRecords.reduce((prev, record) => {
-      // Skip records that we've seen before, never finished, or came from OOPIFs/web workers.
-      if (seenUrls.has(record.url) || !record.finished || record.sessionTargetType !== 'page') {
-        return prev;
-      }
-
-      seenUrls.add(record.url);
-      const isOptimizableImage = record.resourceType === NetworkRequest.TYPES.Image &&
-        IMAGE_REGEX.test(record.mimeType);
-
-      const actualResourceSize = NetworkRequest.getResourceSizeOnNetwork(record);
-      if (isOptimizableImage && actualResourceSize > MINIMUM_IMAGE_SIZE) {
-        prev.push({
-          requestId: record.requestId,
-          url: record.url,
-          mimeType: record.mimeType,
-          resourceSize: actualResourceSize,
-        });
-      }
-
-      return prev;
-    }, /** @type {Array<SimplifiedNetworkRecord>} */ ([]));
-  }
-
-  /**
-   * @param {LH.Gatherer.ProtocolSession} session
-   * @param {string} requestId
-   * @param {'jpeg'|'webp'} encoding Either webp or jpeg.
-   * @return {Promise<LH.Crdp.Audits.GetEncodedResponseResponse>}
-   */
-  _getEncodedResponse(session, requestId, encoding) {
-    requestId = NetworkRequest.getRequestIdForBackend(requestId);
-
-    const quality = encoding === 'jpeg' ? JPEG_QUALITY : WEBP_QUALITY;
-    const params = {requestId, encoding, quality, sizeOnly: true};
-    return session.sendCommand('Audits.getEncodedResponse', params);
-  }
-
-  /**
-   * @param {LH.Gatherer.ProtocolSession} session
-   * @param {SimplifiedNetworkRecord} networkRecord
-   * @return {Promise<{originalSize: number, jpegSize?: number, webpSize?: number}>}
-   */
-  async calculateImageStats(session, networkRecord) {
-    const originalSize = networkRecord.resourceSize;
-    // Once we've hit our execution time limit or when the image is too big, don't try to re-encode it.
-    // Images in this execution path will fallback to byte-per-pixel heuristics on the audit side.
-    if (Date.now() - this._encodingStartAt > MAX_TIME_TO_SPEND_ENCODING ||
-        originalSize > MAX_RESOURCE_SIZE_TO_ENCODE) {
-      return {originalSize, jpegSize: undefined, webpSize: undefined};
-    }
-
-    const jpegData = await this._getEncodedResponse(session, networkRecord.requestId, 'jpeg');
-    const webpData = await this._getEncodedResponse(session, networkRecord.requestId, 'webp');
-
-    return {
-      originalSize,
-      jpegSize: jpegData.encodedSize,
-      webpSize: webpData.encodedSize,
-    };
-  }
-
-  /**
-   * @param {LH.Gatherer.ProtocolSession} session
-   * @param {Array<SimplifiedNetworkRecord>} imageRecords
-   * @return {Promise<LH.Artifacts['OptimizedImages']>}
-   */
-  async computeOptimizedImages(session, imageRecords) {
-    this._encodingStartAt = Date.now();
-
-    /** @type {LH.Artifacts['OptimizedImages']} */
-    const results = [];
-
-    for (const record of imageRecords) {
-      try {
-        const stats = await this.calculateImageStats(session, record);
-        /** @type {LH.Artifacts.OptimizedImage} */
-        const image = {failed: false, ...stats, ...record};
-        results.push(image);
-      } catch (err) {
-        log.warn('optimized-images', err.message, record.url);
-
-        // Track this with Sentry since these errors aren't surfaced anywhere else, but we don't
-        // want to tank the entire run due to a single image.
-        Sentry.captureException(err, {
-          tags: {gatherer: 'OptimizedImages'},
-          extra: {imageUrl: UrlUtils.elideDataURI(record.url)},
-          level: 'warning',
-        });
-
-        /** @type {LH.Artifacts.OptimizedImageError} */
-        const imageError = {failed: true, errMsg: err.message, ...record};
-        results.push(imageError);
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * @param {LH.Gatherer.Context<'DevtoolsLog'>} context
-   * @return {Promise<LH.Artifacts['OptimizedImages']>}
-   */
-  async getArtifact(context) {
-    const devtoolsLog = context.dependencies.DevtoolsLog;
-    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-
-    const imageRecords = OptimizedImages
-      .filterImageRequests(networkRecords)
-      .sort((a, b) => b.resourceSize - a.resourceSize);
-
-    return await this.computeOptimizedImages(context.driver.defaultSession, imageRecords);
-  }
-}
-
-export default OptimizedImages;

package/core/gather/gatherers/dobetterweb/response-compression.d.ts

@@ -1,23 +0,0 @@
-export default ResponseCompression;
-declare class ResponseCompression extends BaseGatherer {
-    /**
-     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
-     * @return {LH.Artifacts['ResponseCompression']}
-     */
-    static filterUnoptimizedResponses(networkRecords: LH.Artifacts.NetworkRequest[]): LH.Artifacts["ResponseCompression"];
-    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
-    meta: LH.Gatherer.GathererMeta<"DevtoolsLog">;
-    /**
-     * @param {LH.Gatherer.Context} context
-     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
-     * @return {Promise<LH.Artifacts['ResponseCompression']>}
-     */
-    getCompressibleRecords(context: LH.Gatherer.Context, networkRecords: LH.Artifacts.NetworkRequest[]): Promise<LH.Artifacts["ResponseCompression"]>;
-    /**
-     * @param {LH.Gatherer.Context<'DevtoolsLog'>} context
-     * @return {Promise<LH.Artifacts['ResponseCompression']>}
-     */
-    getArtifact(context: LH.Gatherer.Context<"DevtoolsLog">): Promise<LH.Artifacts["ResponseCompression"]>;
-}
-import BaseGatherer from '../../base-gatherer.js';
-//# sourceMappingURL=response-compression.d.ts.map

package/core/gather/gatherers/dobetterweb/response-compression.js

@@ -1,136 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
-  * @fileoverview Determines optimized gzip/br/deflate filesizes for all responses by
-  *   checking the content-encoding header.
-  */
-
-
-import {Buffer} from 'buffer';
-import {gzip} from 'zlib';
-
-import log from 'lighthouse-logger';
-
-import BaseGatherer from '../../base-gatherer.js';
-import UrlUtils from '../../../lib/url-utils.js';
-import {NetworkRequest} from '../../../lib/network-request.js';
-import DevtoolsLog from '../devtools-log.js';
-import {fetchResponseBodyFromCache} from '../../driver/network.js';
-import {NetworkRecords} from '../../../computed/network-records.js';
-
-const CHROME_EXTENSION_PROTOCOL = 'chrome-extension:';
-const binaryMimeTypes = ['image', 'audio', 'video'];
-/** @type {LH.Crdp.Network.ResourceType[]} */
-const textResourceTypes = [
-  NetworkRequest.TYPES.Document,
-  NetworkRequest.TYPES.Script,
-  NetworkRequest.TYPES.Stylesheet,
-  NetworkRequest.TYPES.XHR,
-  NetworkRequest.TYPES.Fetch,
-  NetworkRequest.TYPES.EventSource,
-];
-
-class ResponseCompression extends BaseGatherer {
-  /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
-  meta = {
-    supportedModes: ['timespan', 'navigation'],
-    dependencies: {DevtoolsLog: DevtoolsLog.symbol},
-  };
-
-  /**
-   * @param {LH.Artifacts.NetworkRequest[]} networkRecords
-   * @return {LH.Artifacts['ResponseCompression']}
-   */
-  static filterUnoptimizedResponses(networkRecords) {
-    /** @type {LH.Artifacts['ResponseCompression']} */
-    const unoptimizedResponses = [];
-
-    networkRecords.forEach(record => {
-      if (record.sessionTargetType !== 'page') return;
-
-      const mimeType = record.mimeType;
-      const resourceType = record.resourceType || NetworkRequest.TYPES.Other;
-      const resourceSize = record.resourceSize;
-
-      const isBinaryResource = mimeType && binaryMimeTypes.some(type => mimeType.startsWith(type));
-      const isTextResource = !isBinaryResource && textResourceTypes.includes(resourceType);
-      const isChromeExtensionResource = record.url.startsWith(CHROME_EXTENSION_PROTOCOL);
-
-      if (!isTextResource || !resourceSize || !record.finished ||
-        isChromeExtensionResource || !record.transferSize || record.statusCode === 304) {
-        return;
-      }
-
-      if (!NetworkRequest.isContentEncoded(record)) {
-        unoptimizedResponses.push({
-          requestId: record.requestId,
-          url: record.url,
-          mimeType: mimeType,
-          transferSize: record.transferSize,
-          resourceSize: resourceSize,
-          gzipSize: 0,
-        });
-      }
-    });
-
-    return unoptimizedResponses;
-  }
-
-  /**
-   * @param {LH.Gatherer.Context} context
-   * @param {LH.Artifacts.NetworkRequest[]} networkRecords
-   * @return {Promise<LH.Artifacts['ResponseCompression']>}
-   */
-  async getCompressibleRecords(context, networkRecords) {
-    const session = context.driver.defaultSession;
-    const textRecords = ResponseCompression.filterUnoptimizedResponses(networkRecords);
-
-    return Promise.all(textRecords.map(record => {
-      return fetchResponseBodyFromCache(session, record.requestId).then(content => {
-        // if we don't have any content, gzipSize is already set to 0
-        if (!content) {
-          return record;
-        }
-
-        return new Promise((resolve, reject) => {
-          return gzip(content, (err, res) => {
-            if (err) {
-              return reject(err);
-            }
-
-            // get gzip size
-            record.gzipSize = Buffer.byteLength(res, 'utf8');
-
-            resolve(record);
-          });
-        });
-      }).catch(err => {
-        const isExpectedError = err?.message?.includes('No resource with given identifier found');
-        if (!isExpectedError) {
-          err.extra = {url: UrlUtils.elideDataURI(record.url)};
-          throw err;
-        }
-
-        log.error('ResponseCompression', err.message);
-        record.gzipSize = undefined;
-        return record;
-      });
-    }));
-  }
-
-  /**
-   * @param {LH.Gatherer.Context<'DevtoolsLog'>} context
-   * @return {Promise<LH.Artifacts['ResponseCompression']>}
-   */
-  async getArtifact(context) {
-    const devtoolsLog = context.dependencies.DevtoolsLog;
-    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    return this.getCompressibleRecords(context, networkRecords);
-  }
-}
-
-export default ResponseCompression;

package/types/internal/parse-cache-control.d.ts

@@ -1,20 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-declare module 'parse-cache-control' {
-  // Follows the potential settings of cache-control, see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control
-  interface CacheHeaders {
-    'max-age'?: number;
-    'must-revalidate'?: boolean;
-    'no-cache'?: boolean;
-    'no-store'?: boolean;
-    'private'?: boolean;
-    'stale-while-revalidate'?: boolean;
-  }
-
-  function ParseCacheControl(headers?: string): CacheHeaders | null;
-  export = ParseCacheControl;
-}