lighthouse 12.0.0 → 12.1.0-dev.20240618

package/core/computed/metrics/first-meaningful-paint.js

@@ -1,44 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {makeComputedArtifact} from '../computed-artifact.js';
-import {NavigationMetric} from './navigation-metric.js';
-import {LighthouseError} from '../../lib/lh-error.js';
-import {LanternFirstMeaningfulPaint} from './lantern-first-meaningful-paint.js';
-
-class FirstMeaningfulPaint extends NavigationMetric {
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static computeSimulatedMetric(data, context) {
-    const metricData = NavigationMetric.getMetricComputationInput(data);
-    return LanternFirstMeaningfulPaint.request(metricData, context);
-  }
-
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @return {Promise<LH.Artifacts.Metric>}
-   */
-  static async computeObservedMetric(data) {
-    const {processedNavigation} = data;
-    if (processedNavigation.timings.firstMeaningfulPaint === undefined) {
-      throw new LighthouseError(LighthouseError.errors.NO_FMP);
-    }
-
-    return {
-      timing: processedNavigation.timings.firstMeaningfulPaint,
-      timestamp: processedNavigation.timestamps.firstMeaningfulPaint,
-    };
-  }
-}
-
-const FirstMeaningfulPaintComputed = makeComputedArtifact(
-  FirstMeaningfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
-);
-export {FirstMeaningfulPaintComputed as FirstMeaningfulPaint};

package/core/computed/metrics/lantern-first-meaningful-paint.d.ts

@@ -1,25 +0,0 @@
-export { LanternFirstMeaningfulPaintComputed as LanternFirstMeaningfulPaint };
-export type Extras = import('../../lib/lantern/metric.js').Extras;
-declare const LanternFirstMeaningfulPaintComputed: typeof LanternFirstMeaningfulPaint & {
-    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
-        computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
-    }>) => Promise<import("../../index.js").Artifacts.LanternMetric>;
-};
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
-declare class LanternFirstMeaningfulPaint extends FirstMeaningfulPaint {
-    /**
-     * @param {LH.Artifacts.MetricComputationDataInput} data
-     * @param {LH.Artifacts.ComputedContext} context
-     * @param {Omit<Extras, 'optimistic'>=} extras
-     * @return {Promise<LH.Artifacts.LanternMetric>}
-     */
-    static computeMetricWithGraphs(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext, extras?: Omit<Extras, 'optimistic'> | undefined): Promise<LH.Artifacts.LanternMetric>;
-    /**
-     * @param {LH.Artifacts.MetricComputationDataInput} data
-     * @param {LH.Artifacts.ComputedContext} context
-     * @return {Promise<LH.Artifacts.LanternMetric>}
-     */
-    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
-}
-import { FirstMeaningfulPaint } from '../../lib/lantern/metrics/first-meaningful-paint.js';
-//# sourceMappingURL=lantern-first-meaningful-paint.d.ts.map

package/core/computed/metrics/lantern-first-meaningful-paint.js

@@ -1,43 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {makeComputedArtifact} from '../computed-artifact.js';
-import {getComputationDataParams, lanternErrorAdapter} from './lantern-metric.js';
-import {FirstMeaningfulPaint} from '../../lib/lantern/metrics/first-meaningful-paint.js';
-import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
-
-/** @typedef {import('../../lib/lantern/metric.js').Extras} Extras */
-
-class LanternFirstMeaningfulPaint extends FirstMeaningfulPaint {
-  /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @param {Omit<Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static async computeMetricWithGraphs(data, context, extras) {
-    return this.compute(await getComputationDataParams(data, context), extras)
-      .catch(lanternErrorAdapter);
-  }
-
-  /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static async compute_(data, context) {
-    const fcpResult = await LanternFirstContentfulPaint.request(data, context);
-    const metricResult = await this.computeMetricWithGraphs(data, context);
-    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
-    return metricResult;
-  }
-}
-
-const LanternFirstMeaningfulPaintComputed = makeComputedArtifact(
-  LanternFirstMeaningfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
-);
-export {LanternFirstMeaningfulPaintComputed as LanternFirstMeaningfulPaint};

package/core/lib/lantern/cpu-node.d.ts

@@ -1,44 +0,0 @@
-/**
- * @template [T=any]
- * @extends {BaseNode<T>}
- */
-export class CPUNode<T = any> extends BaseNode<T> {
-    /**
-     * @param {LH.TraceEvent} parentEvent
-     * @param {LH.TraceEvent[]=} childEvents
-     * @param {number=} correctedEndTs
-     */
-    constructor(parentEvent: LH.TraceEvent, childEvents?: LH.TraceEvent[] | undefined, correctedEndTs?: number | undefined);
-    _event: LH.TraceEvent;
-    _childEvents: LH.TraceEvent[];
-    _correctedEndTs: number | undefined;
-    get type(): "cpu";
-    /**
-     * @return {number}
-     */
-    get duration(): number;
-    /**
-     * @return {LH.TraceEvent}
-     */
-    get event(): LH.TraceEvent;
-    /**
-     * @return {LH.TraceEvent[]}
-     */
-    get childEvents(): LH.TraceEvent[];
-    /**
-     * Returns true if this node contains a Layout task.
-     * @return {boolean}
-     */
-    didPerformLayout(): boolean;
-    /**
-     * Returns the script URLs that had their EvaluateScript events occur in this task.
-     */
-    getEvaluateScriptURLs(): Set<string>;
-    /**
-     * @return {CPUNode}
-     */
-    cloneWithoutRelationships(): CPUNode;
-}
-import { BaseNode } from './base-node.js';
-import * as LH from '../../../types/lh.js';
-//# sourceMappingURL=cpu-node.d.ts.map

package/core/lib/lantern/metrics/first-meaningful-paint.d.ts

@@ -1,6 +0,0 @@
-export type Node = import('../base-node.js').Node;
-/** @typedef {import('../base-node.js').Node} Node */
-export class FirstMeaningfulPaint extends Metric {
-}
-import { Metric } from '../metric.js';
-//# sourceMappingURL=first-meaningful-paint.d.ts.map

package/core/lib/lantern/metrics/first-meaningful-paint.js

@@ -1,64 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from '../types/lantern.js';
-import {Metric} from '../metric.js';
-import {FirstContentfulPaint} from './first-contentful-paint.js';
-
-/** @typedef {import('../base-node.js').Node} Node */
-
-class FirstMeaningfulPaint extends Metric {
-  /**
-   * @return {Lantern.Simulation.MetricCoefficients}
-   */
-  static get COEFFICIENTS() {
-    return {
-      intercept: 0,
-      optimistic: 0.5,
-      pessimistic: 0.5,
-    };
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) {
-    const fmp = processedNavigation.timestamps.firstMeaningfulPaint;
-    if (!fmp) {
-      throw new Error('NO_FMP');
-    }
-    return FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: fmp,
-      // See FirstContentfulPaint's getOptimisticGraph implementation for a longer description
-      // of why we exclude script initiated resources here.
-      treatNodeAsRenderBlocking: node =>
-        node.hasRenderBlockingPriority() && node.initiatorType !== 'script',
-    });
-  }
-
-  /**
-   * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
-   * @return {Node}
-   */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) {
-    const fmp = processedNavigation.timestamps.firstMeaningfulPaint;
-    if (!fmp) {
-      throw new Error('NO_FMP');
-    }
-
-    return FirstContentfulPaint.getFirstPaintBasedGraph(dependencyGraph, {
-      cutoffTimestamp: fmp,
-      treatNodeAsRenderBlocking: node => node.hasRenderBlockingPriority(),
-      // For pessimistic FMP we'll include *all* layout nodes
-      additionalCpuNodesToTreatAsRenderBlocking: node => node.didPerformLayout(),
-    });
-  }
-}
-
-export {FirstMeaningfulPaint};

package/core/lib/lantern/metrics/interactive.d.ts

@@ -1,26 +0,0 @@
-export type Node = import('../base-node.js').Node;
-export class Interactive extends Metric {
-    /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
-     */
-    static getOptimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
-     */
-    static getPessimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {LH.Gatherer.Simulation.Result} simulationResult
-     * @param {import('../metric.js').Extras} extras
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
-    /**
-     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-     * @return {number}
-     */
-    static getLastLongTaskEndTime(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], duration?: number): number;
-}
-import { Metric } from '../metric.js';
-//# sourceMappingURL=interactive.d.ts.map

package/core/lib/lantern/metrics/largest-contentful-paint.d.ts

@@ -1,19 +0,0 @@
-export type Node = import('../base-node.js').Node;
-/** @typedef {import('../base-node.js').Node} Node */
-export class LargestContentfulPaint extends Metric {
-    /**
-     * Low priority image nodes are usually offscreen and very unlikely to be the
-     * resource that is required for LCP. Our LCP graphs include everything except for these images.
-     *
-     * @param {Node} node
-     * @return {boolean}
-     */
-    static isNotLowPriorityImageNode(node: Node): boolean;
-    /**
-     * @param {LH.Gatherer.Simulation.Result} simulationResult
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result): LH.Gatherer.Simulation.Result;
-}
-import { Metric } from '../metric.js';
-//# sourceMappingURL=largest-contentful-paint.d.ts.map

package/core/lib/lantern/metrics/max-potential-fid.d.ts

@@ -1,30 +0,0 @@
-export type Node = import('../base-node.js').Node;
-/** @typedef {import('../base-node.js').Node} Node */
-export class MaxPotentialFID extends Metric {
-    /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
-     */
-    static getOptimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
-     */
-    static getPessimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {LH.Gatherer.Simulation.Result} simulation
-     * @param {import('../metric.js').Extras} extras
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulation: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
-    /**
-     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-     * @param {number} fcpTimeInMs
-     * @return {Array<{duration: number}>}
-     */
-    static getTimingsAfterFCP(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): Array<{
-        duration: number;
-    }>;
-}
-import { Metric } from '../metric.js';
-//# sourceMappingURL=max-potential-fid.d.ts.map

package/core/lib/lantern/metrics/total-blocking-time.d.ts

@@ -1,31 +0,0 @@
-export type Node = import('../base-node.js').Node;
-/** @typedef {import('../base-node.js').Node} Node */
-export class TotalBlockingTime extends Metric {
-    /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
-     */
-    static getOptimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {Node} dependencyGraph
-     * @return {Node}
-     */
-    static getPessimisticGraph(dependencyGraph: Node): Node;
-    /**
-     * @param {LH.Gatherer.Simulation.Result} simulation
-     * @param {import('../metric.js').Extras} extras
-     * @return {LH.Gatherer.Simulation.Result}
-     */
-    static getEstimateFromSimulation(simulation: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
-    /**
-     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
-     * @param {number} minDurationMs
-     */
-    static getTopLevelEvents(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], minDurationMs: number): {
-        start: number;
-        end: number;
-        duration: number;
-    }[];
-}
-import { Metric } from '../metric.js';
-//# sourceMappingURL=total-blocking-time.d.ts.map

package/core/lib/lantern/page-dependency-graph.d.ts

@@ -1,58 +0,0 @@
-export type Node = import('./base-node.js').Node;
-export type URLArtifact = Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>;
-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} record
-     * @return {Array<string>}
-     */
-    static getNetworkInitiators(record: Lantern.NetworkRequest): Array<string>;
-    /**
-     * @param {Array<Lantern.NetworkRequest>} networkRecords
-     * @return {NetworkNodeOutput}
-     */
-    static getNetworkNodeOutput(networkRecords: Array<Lantern.NetworkRequest>): NetworkNodeOutput;
-    /**
-     * @param {LH.TraceEvent[]} mainThreadEvents
-     * @return {Array<CPUNode>}
-     */
-    static getCPUNodes(mainThreadEvents: LH.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;
-    /**
-     * @param {LH.TraceEvent[]} mainThreadEvents
-     * @param {Array<Lantern.NetworkRequest>} networkRecords
-     * @param {URLArtifact} URL
-     * @return {Node}
-     */
-    static createGraph(mainThreadEvents: LH.TraceEvent[], networkRecords: Array<Lantern.NetworkRequest>, URL: URLArtifact): Node;
-    /**
-     *
-     * @param {Node} rootNode
-     */
-    static printGraph(rootNode: Node, widthInCharacters?: number): void;
-}
-import { NetworkNode } from './network-node.js';
-import * as Lantern from './types/lantern.js';
-import { CPUNode } from './cpu-node.js';
-//# sourceMappingURL=page-dependency-graph.d.ts.map