lighthouse 11.7.0 → 12.0.0-dev.20240422

package/core/config/budget.js

@@ -1,340 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @param {unknown} arr
- * @return {arr is Array<Record<string, unknown>>}
- */
-function isArrayOfUnknownObjects(arr) {
-  return Array.isArray(arr) && arr.every(isObjectOfUnknownProperties);
-}
-
-/**
- * @param {unknown} val
- * @return {val is Record<string, unknown>}
- */
-function isObjectOfUnknownProperties(val) {
-  return typeof val === 'object' && val !== null && !Array.isArray(val);
-}
-
-/**
- * Returns whether `val` is numeric. Will not coerce to a number. `NaN` will
- * return false, however ±Infinity will return true.
- * @param {unknown} val
- * @return {val is number}
- */
-function isNumber(val) {
-  return typeof val === 'number' && !isNaN(val);
-}
-
-class Budget {
-  /**
-   * Asserts that obj has no own properties, throwing a nice error message if it does.
-   * `objectName` is included for nicer logging.
-   * @param {Record<string, unknown>} obj
-   * @param {string} objectName
-   */
-  static assertNoExcessProperties(obj, objectName) {
-    const invalidKeys = Object.keys(obj);
-    if (invalidKeys.length > 0) {
-      const keys = invalidKeys.join(', ');
-      throw new Error(`${objectName} has unrecognized properties: [${keys}]`);
-    }
-  }
-
-  /**
-   * Asserts that `strings` has no duplicate strings in it, throwing an error if
-   * it does. `arrayName` is included for nicer logging.
-   * @param {Array<string>} strings
-   * @param {string} arrayName
-   */
-  static assertNoDuplicateStrings(strings, arrayName) {
-    const foundStrings = new Set();
-    for (const string of strings) {
-      if (foundStrings.has(string)) {
-        throw new Error(`${arrayName} has duplicate entry of type '${string}'`);
-      }
-      foundStrings.add(string);
-    }
-  }
-
-  /**
-   * @param {Record<string, unknown>} resourceBudget
-   * @return {LH.Budget.ResourceBudget}
-   */
-  static validateResourceBudget(resourceBudget) {
-    const {resourceType, budget, ...invalidRest} = resourceBudget;
-    Budget.assertNoExcessProperties(invalidRest, 'Resource Budget');
-
-    /** @type {Array<LH.Budget.ResourceType>} */
-    const validResourceTypes = [
-      'total',
-      'document',
-      'script',
-      'stylesheet',
-      'image',
-      'media',
-      'font',
-      'other',
-      'third-party',
-    ];
-    // Assume resourceType is an allowed string, throw if not.
-    if (!validResourceTypes.includes(/** @type {LH.Budget.ResourceType} */ (resourceType))) {
-      throw new Error(`Invalid resource type: ${resourceType}. \n` +
-        `Valid resource types are: ${validResourceTypes.join(', ') }`);
-    }
-    if (!isNumber(budget)) {
-      throw new Error(`Invalid budget: ${budget}`);
-    }
-    return {
-      resourceType: /** @type {LH.Budget.ResourceType} */ (resourceType),
-      budget,
-    };
-  }
-
-  /**
-   * @param {unknown} path
-   * @param {string} error
-   */
-  static throwInvalidPathError(path, error) {
-    throw new Error(`Invalid path ${path}. ${error}\n` +
-      `'Path' should be specified using the 'robots.txt' format.\n` +
-      `Learn more about the 'robots.txt' format here:\n` +
-      `https://developers.google.com/search/reference/robots_txt#url-matching-based-on-path-values`);
-  }
-
-
-  /**
-   * Validates that path is either: a) undefined or ) properly formed.
-   * Verifies the quantity and location of the two robot.txt regex characters: $, *
-   * @param {unknown} path
-   * @return {undefined|string}
-   */
-  static validatePath(path) {
-    if (path === undefined) {
-      return undefined;
-    } else if (typeof path !== 'string') {
-      this.throwInvalidPathError(path, `Path should be a string.`);
-      return;
-    } else if (!path.startsWith('/')) {
-      this.throwInvalidPathError(path, `Path should start with '/'.`);
-    } else if ((path.match(/\*/g) || []).length > 1) {
-      this.throwInvalidPathError(path, `Path should only contain one '*'.`);
-    } else if ((path.match(/\$/g) || []).length > 1) {
-      this.throwInvalidPathError(path, `Path should only contain one '$' character.`);
-    } else if (path.includes('$') && !path.endsWith('$')) {
-      this.throwInvalidPathError(path, `'$' character should only occur at end of path.`);
-    }
-    return path;
-  }
-
-  /**
-   * Returns the budget that applies to a given URL.
-   * If multiple budgets match based on thier 'path' property,
-   * then the last-listed of those budgets is returned.
-   * @param {LH.Util.Immutable<Array<LH.Budget>>|null} budgets
-   * @param {string|undefined} url
-   * @return {LH.Util.Immutable<LH.Budget> | undefined} budget
-   */
-  static getMatchingBudget(budgets, url) {
-    if (budgets === null || url === undefined) return;
-
-    // Applies the LAST matching budget.
-    for (let i = budgets.length - 1; i >= 0; i--) {
-      const budget = budgets[i];
-      if (this.urlMatchesPattern(url, budget.path)) {
-        return budget;
-      }
-    }
-  }
-
-  /**
-   * Determines whether a URL matches against a robots.txt-style "path".
-   * Pattern should use the robots.txt format. E.g. "/*-article.html" or "/". Reference:
-   * https://developers.google.com/search/reference/robots_txt#url-matching-based-on-path-values
-   * @param {string} url
-   * @param {string=} pattern
-   * @return {boolean}
-   */
-  static urlMatchesPattern(url, pattern = '/') {
-    const urlObj = new URL(url);
-    const urlPath = urlObj.pathname + urlObj.search;
-
-    const hasWildcard = pattern.includes('*');
-    const hasDollarSign = pattern.includes('$');
-
-    /**
-     * There are 4 different cases of path strings.
-     * Paths should have already been validated with #validatePath.
-     *
-     * Case #1: No special characters
-     * Example: "/cat"
-     * Behavior: URL should start with given pattern.
-     */
-    if (!hasWildcard && !hasDollarSign) {
-      return urlPath.startsWith(pattern);
-    /**
-     * Case #2: $ only
-     * Example: "/js$"
-     * Behavior: URL should be identical to pattern.
-     */
-    } else if (!hasWildcard && hasDollarSign) {
-      return urlPath === pattern.slice(0, -1);
-    /**
-     * Case #3: * only
-     * Example: "/vendor*chunk"
-     * Behavior: URL should start with the string pattern that comes before the wildcard
-     * & later in the string contain the string pattern that comes after the wildcard.
-     */
-    } else if (hasWildcard && !hasDollarSign) {
-      const [beforeWildcard, afterWildcard] = pattern.split('*');
-      const remainingUrl = urlPath.slice(beforeWildcard.length);
-      return urlPath.startsWith(beforeWildcard) && remainingUrl.includes(afterWildcard);
-    /**
-     * Case #4: $ and *
-     * Example: "/vendor*chunk.js$"
-     * Behavior: URL should start with the string pattern that comes before the wildcard
-     * & later in the string end with the string pattern that comes after the wildcard.
-     */
-    } else if (hasWildcard && hasDollarSign) {
-      const [beforeWildcard, afterWildcard] = pattern.split('*');
-      const urlEnd = urlPath.slice(beforeWildcard.length);
-      return urlPath.startsWith(beforeWildcard) && urlEnd.endsWith(afterWildcard.slice(0, -1));
-    }
-    return false;
-  }
-
-  /**
-   * @param {Record<string, unknown>} timingBudget
-   * @return {LH.Budget.TimingBudget}
-   */
-  static validateTimingBudget(timingBudget) {
-    const {metric, budget, ...invalidRest} = timingBudget;
-    Budget.assertNoExcessProperties(invalidRest, 'Timing Budget');
-
-    /** @type {Array<LH.Budget.TimingMetric>} */
-    const validTimingMetrics = [
-      'first-contentful-paint',
-      'interactive',
-      'first-meaningful-paint',
-      'max-potential-fid',
-      'total-blocking-time',
-      'speed-index',
-      'largest-contentful-paint',
-      'cumulative-layout-shift',
-    ];
-    // Assume metric is an allowed string, throw if not.
-    if (!validTimingMetrics.includes(/** @type {LH.Budget.TimingMetric} */ (metric))) {
-      throw new Error(`Invalid timing metric: ${metric}. \n` +
-        `Valid timing metrics are: ${validTimingMetrics.join(', ')}`);
-    }
-    if (!isNumber(budget)) {
-      throw new Error(`Invalid budget: ${budget}`);
-    }
-    return {
-      metric: /** @type {LH.Budget.TimingMetric} */ (metric),
-      budget,
-    };
-  }
-
-  /**
-   * @param {string} hostname
-   * @return {string}
-   */
-  static validateHostname(hostname) {
-    const errMsg = `${hostname} is not a valid hostname.`;
-    if (hostname.length === 0) {
-      throw new Error(errMsg);
-    }
-    if (hostname.includes('/')) {
-      throw new Error(errMsg);
-    }
-    if (hostname.includes(':')) {
-      throw new Error(errMsg);
-    }
-    if (hostname.includes('*')) {
-      if (!hostname.startsWith('*.') || hostname.lastIndexOf('*') > 0) {
-        throw new Error(errMsg);
-      }
-    }
-    return hostname;
-  }
-
-  /**
-   * @param {unknown} hostnames
-   * @return {undefined|Array<string>}
-   */
-  static validateHostnames(hostnames) {
-    if (Array.isArray(hostnames) && hostnames.every(host => typeof host === 'string')) {
-      return hostnames.map(Budget.validateHostname);
-    } else if (hostnames !== undefined) {
-      throw new Error(`firstPartyHostnames should be defined as an array of strings.`);
-    }
-  }
-
-  /**
-   * More info on the Budget format:
-   * https://github.com/GoogleChrome/lighthouse/issues/6053#issuecomment-428385930
-   * @param {unknown} budgetJson
-   * @return {Array<LH.Budget>}
-   */
-  static initializeBudget(budgetJson) {
-    // Clone to prevent modifications of original and to deactivate any live properties.
-    budgetJson = JSON.parse(JSON.stringify(budgetJson));
-    if (!isArrayOfUnknownObjects(budgetJson)) {
-      throw new Error('Budget file is not defined as an array of budgets.');
-    }
-
-    const budgets = budgetJson.map((b, index) => {
-      /** @type {LH.Budget} */
-      const budget = {};
-
-      const {path, options, resourceSizes, resourceCounts, timings, ...invalidRest} = b;
-      Budget.assertNoExcessProperties(invalidRest, 'Budget');
-
-      budget.path = Budget.validatePath(path);
-
-      if (isObjectOfUnknownProperties(options)) {
-        const {firstPartyHostnames, ...invalidRest} = options;
-        Budget.assertNoExcessProperties(invalidRest, 'Options property');
-        budget.options = {};
-        budget.options.firstPartyHostnames = Budget.validateHostnames(firstPartyHostnames);
-      } else if (options !== undefined) {
-        throw new Error(`Invalid options property in budget at index ${index}`);
-      }
-
-      if (isArrayOfUnknownObjects(resourceSizes)) {
-        budget.resourceSizes = resourceSizes.map(Budget.validateResourceBudget);
-        Budget.assertNoDuplicateStrings(budget.resourceSizes.map(r => r.resourceType),
-          `budgets[${index}].resourceSizes`);
-      } else if (resourceSizes !== undefined) {
-        throw new Error(`Invalid resourceSizes entry in budget at index ${index}`);
-      }
-
-      if (isArrayOfUnknownObjects(resourceCounts)) {
-        budget.resourceCounts = resourceCounts.map(Budget.validateResourceBudget);
-        Budget.assertNoDuplicateStrings(budget.resourceCounts.map(r => r.resourceType),
-          `budgets[${index}].resourceCounts`);
-      } else if (resourceCounts !== undefined) {
-        throw new Error(`Invalid resourceCounts entry in budget at index ${index}`);
-      }
-
-      if (isArrayOfUnknownObjects(timings)) {
-        budget.timings = timings.map(Budget.validateTimingBudget);
-        Budget.assertNoDuplicateStrings(budget.timings.map(r => r.metric),
-          `budgets[${index}].timings`);
-      } else if (timings !== undefined) {
-        throw new Error(`Invalid timings entry in budget at index ${index}`);
-      }
-
-      return budget;
-    });
-
-    return budgets;
-  }
-}
-
-export {Budget};

package/core/config/metrics-to-audits.d.ts

@@ -1,19 +0,0 @@
-export namespace metricsToAudits {
-    export { fcpRelevantAudits };
-    export { lcpRelevantAudits };
-    export { tbtRelevantAudits };
-    export { clsRelevantAudits };
-    export { inpRelevantAudits };
-}
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-declare const fcpRelevantAudits: string[];
-declare const lcpRelevantAudits: string[];
-declare const tbtRelevantAudits: string[];
-declare const clsRelevantAudits: string[];
-declare const inpRelevantAudits: string[];
-export {};
-//# sourceMappingURL=metrics-to-audits.d.ts.map

package/core/config/metrics-to-audits.js

@@ -1,62 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-// go/lh-audit-metric-mapping
-const fcpRelevantAudits = [
-  'server-response-time',
-  'render-blocking-resources',
-  'redirects',
-  'critical-request-chains',
-  'uses-text-compression',
-  'uses-rel-preconnect',
-  'uses-rel-preload',
-  'font-display',
-  'unminified-javascript',
-  'unminified-css',
-  'unused-css-rules',
-];
-
-const lcpRelevantAudits = [
-  ...fcpRelevantAudits,
-  'largest-contentful-paint-element',
-  'prioritize-lcp-image',
-  'unused-javascript',
-  'efficient-animated-content',
-  'total-byte-weight',
-  'lcp-lazy-loaded',
-];
-
-const tbtRelevantAudits = [
-  'long-tasks',
-  'third-party-summary',
-  'third-party-facades',
-  'bootup-time',
-  'mainthread-work-breakdown',
-  'dom-size',
-  'duplicated-javascript',
-  'legacy-javascript',
-  'viewport',
-];
-
-const clsRelevantAudits = [
-  'layout-shift-elements',
-  'layout-shifts',
-  'non-composited-animations',
-  'unsized-images',
-  // 'preload-fonts', // actually in BP, rather than perf
-];
-
-const inpRelevantAudits = [
-  'work-during-interaction',
-];
-
-export const metricsToAudits = {
-  fcpRelevantAudits,
-  lcpRelevantAudits,
-  tbtRelevantAudits,
-  clsRelevantAudits,
-  inpRelevantAudits,
-};

package/core/gather/driver/service-workers.d.ts

@@ -1,16 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * @param {LH.Gatherer.ProtocolSession} session
- * @return {Promise<LH.Crdp.ServiceWorker.WorkerVersionUpdatedEvent>}
- */
-export function getServiceWorkerVersions(session: LH.Gatherer.ProtocolSession): Promise<LH.Crdp.ServiceWorker.WorkerVersionUpdatedEvent>;
-/**
- * @param {LH.Gatherer.ProtocolSession} session
- * @return {Promise<LH.Crdp.ServiceWorker.WorkerRegistrationUpdatedEvent>}
- */
-export function getServiceWorkerRegistrations(session: LH.Gatherer.ProtocolSession): Promise<LH.Crdp.ServiceWorker.WorkerRegistrationUpdatedEvent>;
-//# sourceMappingURL=service-workers.d.ts.map

package/core/gather/driver/service-workers.js

@@ -1,52 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @param {LH.Gatherer.ProtocolSession} session
- * @return {Promise<LH.Crdp.ServiceWorker.WorkerVersionUpdatedEvent>}
- */
-function getServiceWorkerVersions(session) {
-  return new Promise((resolve, reject) => {
-    /**
-     * @param {LH.Crdp.ServiceWorker.WorkerVersionUpdatedEvent} data
-     */
-    const versionUpdatedListener = data => {
-      // find a service worker with runningStatus that looks like active
-      // on slow connections the serviceworker might still be installing
-      const activateCandidates = data.versions.filter(sw => {
-        return sw.status !== 'redundant';
-      });
-
-      const hasActiveServiceWorker = activateCandidates.find(sw => {
-        return sw.status === 'activated';
-      });
-
-      if (!activateCandidates.length || hasActiveServiceWorker) {
-        session.off('ServiceWorker.workerVersionUpdated', versionUpdatedListener);
-        session.sendCommand('ServiceWorker.disable').then(_ => resolve(data), reject);
-      }
-    };
-
-    session.on('ServiceWorker.workerVersionUpdated', versionUpdatedListener);
-
-    session.sendCommand('ServiceWorker.enable').catch(reject);
-  });
-}
-
-/**
- * @param {LH.Gatherer.ProtocolSession} session
- * @return {Promise<LH.Crdp.ServiceWorker.WorkerRegistrationUpdatedEvent>}
- */
-function getServiceWorkerRegistrations(session) {
-  return new Promise((resolve, reject) => {
-    session.once('ServiceWorker.workerRegistrationUpdated', data => {
-      session.sendCommand('ServiceWorker.disable').then(_ => resolve(data), reject);
-    });
-    session.sendCommand('ServiceWorker.enable').catch(reject);
-  });
-}
-
-export {getServiceWorkerVersions, getServiceWorkerRegistrations};

package/core/gather/gatherers/dobetterweb/tags-blocking-first-paint.d.ts

@@ -1,47 +0,0 @@
-export default TagsBlockingFirstPaint;
-export type MediaChange = {
-    href: string;
-    media: string;
-    msSinceHTMLEnd: number;
-    matches: boolean;
-};
-export type LinkTag = {
-    tagName: 'LINK';
-    url: string;
-    href: string;
-    rel: string;
-    media: string;
-    disabled: boolean;
-    mediaChanges: Array<MediaChange>;
-};
-export type ScriptTag = {
-    tagName: 'SCRIPT';
-    url: string;
-    src: string;
-};
-declare class TagsBlockingFirstPaint extends BaseGatherer {
-    /**
-     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-     * @return {Map<string, LH.Artifacts.NetworkRequest>}
-     */
-    static _filteredAndIndexedByUrl(networkRecords: Array<LH.Artifacts.NetworkRequest>): Map<string, LH.Artifacts.NetworkRequest>;
-    /**
-     * @param {LH.Gatherer.Driver} driver
-     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-     * @return {Promise<Array<LH.Artifacts.TagBlockingFirstPaint>>}
-     */
-    static findBlockingTags(driver: LH.Gatherer.Driver, networkRecords: Array<LH.Artifacts.NetworkRequest>): Promise<Array<LH.Artifacts.TagBlockingFirstPaint>>;
-    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
-    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
-    /**
-     * @param {LH.Gatherer.Context} context
-     */
-    startSensitiveInstrumentation(context: LH.Gatherer.Context): Promise<void>;
-    /**
-     * @param {LH.Gatherer.Context<'DevtoolsLog'>} context
-     * @return {Promise<LH.Artifacts['TagsBlockingFirstPaint']>}
-     */
-    getArtifact(context: LH.Gatherer.Context<'DevtoolsLog'>): Promise<LH.Artifacts['TagsBlockingFirstPaint']>;
-}
-import BaseGatherer from '../../base-gatherer.js';
-//# sourceMappingURL=tags-blocking-first-paint.d.ts.map