lighthouse 12.1.0 → 12.2.0

package/core/lib/lantern/Metric.js

@@ -1,137 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from './lantern.js';
-
-/** @typedef {import('./BaseNode.js').Node} Node */
-/** @typedef {import('./NetworkNode.js').NetworkNode} NetworkNode */
-/** @typedef {import('./simulation/Simulator.js').Simulator} Simulator */
-
-/**
- * @typedef Extras
- * @property {boolean} optimistic
- * @property {Lantern.Metrics.Result=} fcpResult
- * @property {Lantern.Metrics.Result=} lcpResult
- * @property {Lantern.Metrics.Result=} interactiveResult
- * @property {number=} observedSpeedIndex
- */
-
-class Metric {
-  /**
-   * @param {Node} dependencyGraph
-   * @param {function(NetworkNode):boolean=} treatNodeAsRenderBlocking
-   * @return {Set<string>}
-   */
-  static getScriptUrls(dependencyGraph, treatNodeAsRenderBlocking) {
-    /** @type {Set<string>} */
-    const scriptUrls = new Set();
-
-    dependencyGraph.traverse(node => {
-      if (node.type !== Lantern.BaseNode.TYPES.NETWORK) return;
-      if (node.request.resourceType !== Lantern.NetworkRequestTypes.Script) return;
-      if (treatNodeAsRenderBlocking?.(node)) {
-        scriptUrls.add(node.request.url);
-      }
-    });
-
-    return scriptUrls;
-  }
-
-  /**
-   * @return {Lantern.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    throw new Error('COEFFICIENTS unimplemented!');
-  }
-
-  /**
-   * Returns the coefficients, scaled by the throttling settings if needed by the metric.
-   * Some lantern metrics (speed-index) use components in their estimate that are not
-   * from the simulator. In this case, we need to adjust the coefficients as the target throttling
-   * settings change.
-   *
-   * @param {number} rttMs
-   * @return {Lantern.Simulation.MetricCoefficients}
-   */
-  static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
-    return this.COEFFICIENTS;
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
-    throw new Error('Optimistic graph unimplemented!');
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {Lantern.Simulation.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
-    throw new Error('Pessmistic graph unimplemented!');
-  }
-
-  /**
-   * @param {Lantern.Simulation.Result} simulationResult
-   * @param {Extras} extras
-   * @return {Lantern.Simulation.Result}
-   */
-  static getEstimateFromSimulation(simulationResult, extras) { // eslint-disable-line no-unused-vars
-    return simulationResult;
-  }
-
-  /**
-   * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<Extras, 'optimistic'>=} extras
-   * @return {Promise<Lantern.Metrics.Result>}
-   */
-  static async compute(data, extras) {
-    const {simulator, graph, processedNavigation} = data;
-
-    const metricName = this.name.replace('Lantern', '');
-    const optimisticGraph = this.getOptimisticGraph(graph, processedNavigation);
-    const pessimisticGraph = this.getPessimisticGraph(graph, processedNavigation);
-
-    let simulateOptions = {label: `optimistic${metricName}`};
-    const optimisticSimulation = simulator.simulate(optimisticGraph, simulateOptions);
-
-    simulateOptions = {label: `pessimistic${metricName}`};
-    const pessimisticSimulation = simulator.simulate(pessimisticGraph, simulateOptions);
-
-    const optimisticEstimate = this.getEstimateFromSimulation(
-      optimisticSimulation,
-      {...extras, optimistic: true}
-    );
-
-    const pessimisticEstimate = this.getEstimateFromSimulation(
-      pessimisticSimulation,
-      {...extras, optimistic: false}
-    );
-
-    const coefficients = this.getScaledCoefficients(simulator.rtt);
-    // Estimates under 1s don't really follow the normal curve fit, minimize the impact of the intercept
-    const interceptMultiplier = coefficients.intercept > 0 ?
-      Math.min(1, optimisticEstimate.timeInMs / 1000) : 1;
-    const timing =
-      coefficients.intercept * interceptMultiplier +
-      coefficients.optimistic * optimisticEstimate.timeInMs +
-      coefficients.pessimistic * pessimisticEstimate.timeInMs;
-
-    return {
-      timing,
-      optimisticEstimate,
-      pessimisticEstimate,
-      optimisticGraph,
-      pessimisticGraph,
-    };
-  }
-}
-
-export {Metric};

package/core/lib/lantern/NetworkNode.d.ts

@@ -1,49 +0,0 @@
-/**
- * @template [T=any]
- * @extends {Lantern.BaseNode<T>}
- */
-export class NetworkNode<T = any> extends Lantern.BaseNode<T> {
-    /**
-     * @param {Lantern.NetworkRequest<T>} networkRequest
-     */
-    constructor(networkRequest: Lantern.NetworkRequest<T>);
-    /** @private */
-    private _request;
-    get type(): "network";
-    /**
-     * @return {Readonly<T>}
-     */
-    get rawRequest(): Readonly<T>;
-    /**
-     * @return {Lantern.NetworkRequest<T>}
-     */
-    get request(): Lantern.NetworkRequest<T>;
-    /**
-     * @return {string}
-     */
-    get initiatorType(): string;
-    /**
-     * @return {boolean}
-     */
-    get fromDiskCache(): boolean;
-    /**
-     * @return {boolean}
-     */
-    get isNonNetworkProtocol(): boolean;
-    /**
-     * Returns whether this network request can be downloaded without a TCP connection.
-     * During simulation we treat data coming in over a network connection separately from on-device data.
-     * @return {boolean}
-     */
-    get isConnectionless(): boolean;
-    /**
-     * @return {boolean}
-     */
-    hasRenderBlockingPriority(): boolean;
-    /**
-     * @return {NetworkNode<T>}
-     */
-    cloneWithoutRelationships(): NetworkNode<T>;
-}
-import * as Lantern from './lantern.js';
-//# sourceMappingURL=NetworkNode.d.ts.map

package/core/lib/lantern/NetworkNode.js

@@ -1,136 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from './lantern.js';
-import {NetworkRequestTypes} from './lantern.js';
-
-const NON_NETWORK_SCHEMES = [
-  'blob', // @see https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
-  'data', // @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
-  'intent', // @see https://developer.chrome.com/docs/multidevice/android/intents/
-  'file', // @see https://en.wikipedia.org/wiki/File_URI_scheme
-  'filesystem', // @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystem
-  'chrome-extension',
-];
-
-/**
- * Note: the `protocol` field from CDP can be 'h2', 'http', (not 'https'!) or it'll be url's scheme.
- *   https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/protocol/network_handler.cc;l=598-611;drc=56d4a9a9deb30be73adcee8737c73bcb2a5ab64f
- * However, a `new URL(href).protocol` has a colon suffix.
- *   https://url.spec.whatwg.org/#dom-url-protocol
- * A URL's `scheme` is specced as the `protocol` sans-colon, but isn't exposed on a URL object.
- * This method can take all 3 of these string types as a parameter.
- * @param {string} protocol Either a networkRequest's `protocol` per CDP or a `new URL(href).protocol`
- * @return {boolean}
- */
-function isNonNetworkProtocol(protocol) {
-  // Strip off any colon
-  const urlScheme = protocol.includes(':') ? protocol.slice(0, protocol.indexOf(':')) : protocol;
-  return NON_NETWORK_SCHEMES.includes(urlScheme);
-}
-
-/**
- * @template [T=any]
- * @extends {Lantern.BaseNode<T>}
- */
-class NetworkNode extends Lantern.BaseNode {
-  /**
-   * @param {Lantern.NetworkRequest<T>} networkRequest
-   */
-  constructor(networkRequest) {
-    super(networkRequest.requestId);
-    /** @private */
-    this._request = networkRequest;
-  }
-
-  get type() {
-    return Lantern.BaseNode.TYPES.NETWORK;
-  }
-
-  /**
-   * @return {number}
-   */
-  get startTime() {
-    return this._request.rendererStartTime * 1000;
-  }
-
-  /**
-   * @return {number}
-   */
-  get endTime() {
-    return this._request.networkEndTime * 1000;
-  }
-
-  /**
-   * @return {Readonly<T>}
-   */
-  get rawRequest() {
-    return /** @type {Required<T>} */ (this._request.rawRequest);
-  }
-
-  /**
-   * @return {Lantern.NetworkRequest<T>}
-   */
-  get request() {
-    return this._request;
-  }
-
-  /**
-   * @return {string}
-   */
-  get initiatorType() {
-    return this._request.initiator && this._request.initiator.type;
-  }
-
-  /**
-   * @return {boolean}
-   */
-  get fromDiskCache() {
-    return !!this._request.fromDiskCache;
-  }
-
-  /**
-   * @return {boolean}
-   */
-  get isNonNetworkProtocol() {
-    // The 'protocol' field in devtools a string more like a `scheme`
-    return isNonNetworkProtocol(this.request.protocol) ||
-      // But `protocol` can fail to be populated if the request fails, so fallback to scheme.
-      isNonNetworkProtocol(this.request.parsedURL.scheme);
-  }
-
-  /**
-   * Returns whether this network request can be downloaded without a TCP connection.
-   * During simulation we treat data coming in over a network connection separately from on-device data.
-   * @return {boolean}
-   */
-  get isConnectionless() {
-    return this.fromDiskCache || this.isNonNetworkProtocol;
-  }
-
-  /**
-   * @return {boolean}
-   */
-  hasRenderBlockingPriority() {
-    const priority = this._request.priority;
-    const isScript = this._request.resourceType === NetworkRequestTypes.Script;
-    const isDocument = this._request.resourceType === NetworkRequestTypes.Document;
-    const isBlockingScript = priority === 'High' && isScript;
-    const isBlockingHtmlImport = priority === 'High' && isDocument;
-    return priority === 'VeryHigh' || isBlockingScript || isBlockingHtmlImport;
-  }
-
-  /**
-   * @return {NetworkNode<T>}
-   */
-  cloneWithoutRelationships() {
-    const node = new NetworkNode(this._request);
-    node.setIsMainDocument(this._isMainDocument);
-    return node;
-  }
-}
-
-export {NetworkNode};

package/core/lib/lantern/PageDependencyGraph.d.ts

@@ -1,82 +0,0 @@
-export type Node = import('./BaseNode.js').Node;
-export type NetworkNodeOutput = {
-    nodes: Array<NetworkNode>;
-    idToNodeMap: Map<string, NetworkNode>;
-    urlToNodeMap: Map<string, Array<NetworkNode>>;
-    frameIdToNodeMap: Map<string, NetworkNode | null>;
-};
-export class PageDependencyGraph {
-    /**
-     * @param {Lantern.NetworkRequest} request
-     * @return {Array<string>}
-     */
-    static getNetworkInitiators(request: Lantern.NetworkRequest): Array<string>;
-    /**
-     * @param {Array<Lantern.NetworkRequest>} networkRequests
-     * @return {NetworkNodeOutput}
-     */
-    static getNetworkNodeOutput(networkRequests: Array<Lantern.NetworkRequest>): NetworkNodeOutput;
-    /**
-     * @param {Lantern.TraceEvent} evt
-     * @return {boolean}
-     */
-    static isScheduleableTask(evt: Lantern.TraceEvent): boolean;
-    /**
-     * There should *always* be at least one top level event, having 0 typically means something is
-     * drastically wrong with the trace and we should just give up early and loudly.
-     *
-     * @param {Lantern.TraceEvent[]} events
-     */
-    static assertHasToplevelEvents(events: Lantern.TraceEvent[]): void;
-    /**
-     * @param {Lantern.TraceEvent[]} mainThreadEvents
-     * @return {Array<CPUNode>}
-     */
-    static getCPUNodes(mainThreadEvents: Lantern.TraceEvent[]): Array<CPUNode>;
-    /**
-     * @param {NetworkNode} rootNode
-     * @param {NetworkNodeOutput} networkNodeOutput
-     */
-    static linkNetworkNodes(rootNode: NetworkNode, networkNodeOutput: NetworkNodeOutput): void;
-    /**
-     * @param {Node} rootNode
-     * @param {NetworkNodeOutput} networkNodeOutput
-     * @param {Array<CPUNode>} cpuNodes
-     */
-    static linkCPUNodes(rootNode: Node, networkNodeOutput: NetworkNodeOutput, cpuNodes: Array<CPUNode>): void;
-    /**
-     * Removes the given node from the graph, but retains all paths between its dependencies and
-     * dependents.
-     * @param {Node} node
-     */
-    static _pruneNode(node: Node): void;
-    /**
-     * TODO(15841): remove when CDT backend is gone. until then, this is a useful debugging tool
-     * to find delta between using CDP or the trace to create the network requests.
-     *
-     * When a test fails using the trace backend, I enabled this debug method and copied the network
-     * requests when CDP was used, then when trace is used, and diff'd them. This method helped
-     * remove non-logical differences from the comparison (order of properties, slight rounding
-     * discrepancies, removing object cycles, etc).
-     *
-     * When using for a unit test, make sure to do `.only` so you are getting what you expect.
-     * @param {Lantern.NetworkRequest[]} lanternRequests
-     * @return {never}
-     */
-    static _debugNormalizeRequests(lanternRequests: Lantern.NetworkRequest[]): never;
-    /**
-     * @param {Lantern.TraceEvent[]} mainThreadEvents
-     * @param {Lantern.NetworkRequest[]} networkRequests
-     * @param {Lantern.Simulation.URL} URL
-     * @return {Node}
-     */
-    static createGraph(mainThreadEvents: Lantern.TraceEvent[], networkRequests: Lantern.NetworkRequest[], URL: Lantern.Simulation.URL): Node;
-    /**
-     * @param {Node} rootNode
-     */
-    static printGraph(rootNode: Node, widthInCharacters?: number): void;
-}
-import { NetworkNode } from './NetworkNode.js';
-import * as Lantern from './lantern.js';
-import { CPUNode } from './CpuNode.js';
-//# sourceMappingURL=PageDependencyGraph.d.ts.map