lighthouse 9.5.0-dev.20230118 → 9.5.0-dev.20230119

package/core/computed/metrics/interactive.d.ts

@@ -0,0 +1,61 @@
+export { InteractiveComputed as Interactive };
+export type TimePeriod = {
+    start: number;
+    end: number;
+};
+declare const InteractiveComputed: typeof Interactive & {
+    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.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+/**
+ * @fileoverview Computes "Time To Interactive", the time at which the page has loaded critical
+ * resources and is mostly idle.
+ * @see https://docs.google.com/document/d/1yE4YWsusi5wVXrnwhR61j-QyjK9tzENIzfxrCjA1NAk/edit#heading=h.yozfsuqcgpc4
+ */
+declare class Interactive extends NavigationMetric {
+    /**
+     * Finds all time periods where the number of inflight requests is less than or equal to the
+     * number of allowed concurrent requests (2).
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {{timestamps: {traceEnd: number}}} processedNavigation
+     * @return {Array<TimePeriod>}
+     */
+    static _findNetworkQuietPeriods(networkRecords: Array<LH.Artifacts.NetworkRequest>, processedNavigation: {
+        timestamps: {
+            traceEnd: number;
+        };
+    }): Array<TimePeriod>;
+    /**
+     * Finds all time periods where there are no long tasks.
+     * @param {Array<TimePeriod>} longTasks
+     * @param {{timestamps: {timeOrigin: number, traceEnd: number}}} processedNavigation
+     * @return {Array<TimePeriod>}
+     */
+    static _findCPUQuietPeriods(longTasks: Array<TimePeriod>, processedNavigation: {
+        timestamps: {
+            timeOrigin: number;
+            traceEnd: number;
+        };
+    }): Array<TimePeriod>;
+    /**
+     * Finds the first time period where a network quiet period and a CPU quiet period overlap.
+     * @param {Array<TimePeriod>} longTasks
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+     * @return {{cpuQuietPeriod: TimePeriod, networkQuietPeriod: TimePeriod, cpuQuietPeriods: Array<TimePeriod>, networkQuietPeriods: Array<TimePeriod>}}
+     */
+    static findOverlappingQuietPeriods(longTasks: Array<TimePeriod>, networkRecords: Array<LH.Artifacts.NetworkRequest>, processedNavigation: LH.Artifacts.ProcessedNavigation): {
+        cpuQuietPeriod: TimePeriod;
+        networkQuietPeriod: TimePeriod;
+        cpuQuietPeriods: Array<TimePeriod>;
+        networkQuietPeriods: Array<TimePeriod>;
+    };
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
+}
+import { NavigationMetric } from "./navigation-metric.js";
+//# sourceMappingURL=interactive.d.ts.map

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

@@ -0,0 +1,48 @@
+export { LanternFirstContentfulPaintComputed as LanternFirstContentfulPaint };
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+export type CPUNode = import('../../lib/dependency-graph/cpu-node').CPUNode;
+export type NetworkNode = import('../../lib/dependency-graph/network-node').NetworkNode;
+declare const LanternFirstContentfulPaintComputed: typeof LanternFirstContentfulPaint & {
+    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/dependency-graph/base-node.js').Node} Node */
+/** @typedef {import('../../lib/dependency-graph/cpu-node').CPUNode} CPUNode */
+/** @typedef {import('../../lib/dependency-graph/network-node').NetworkNode} NetworkNode */
+declare class LanternFirstContentfulPaint extends LanternMetric {
+    /**
+     * This function computes the set of URLs that *appeared* to be render-blocking based on our filter,
+     * *but definitely were not* render-blocking based on the timing of their EvaluateScript task.
+     * It also computes the set of corresponding CPU node ids that were needed for the paint at the
+     * given timestamp.
+     *
+     * @param {Node} graph
+     * @param {number} filterTimestamp The timestamp used to filter out tasks that occured after our
+     *    paint of interest. Typically this is First Contentful Paint or First Meaningful Paint.
+     * @param {function(NetworkNode):boolean} blockingScriptFilter The function that determines which scripts
+     *    should be considered *possibly* render-blocking.
+     * @param {(function(CPUNode):boolean)=} extraBlockingCpuNodesToIncludeFilter The function that determines which CPU nodes
+     *    should also be included in our blocking node IDs set.
+     * @return {{definitelyNotRenderBlockingScriptUrls: Set<string>, blockingCpuNodeIds: Set<string>}}
+     */
+    static getBlockingNodeData(graph: Node, filterTimestamp: number, blockingScriptFilter: (arg0: NetworkNode) => boolean, extraBlockingCpuNodesToIncludeFilter?: ((arg0: CPUNode) => boolean) | undefined): {
+        definitelyNotRenderBlockingScriptUrls: Set<string>;
+        blockingCpuNodeIds: Set<string>;
+    };
+    /**
+     * This function computes the graph required for the first paint of interest.
+     *
+     * @param {Node} dependencyGraph
+     * @param {number} paintTs The timestamp used to filter out tasks that occured after our
+     *    paint of interest. Typically this is First Contentful Paint or First Meaningful Paint.
+     * @param {function(NetworkNode):boolean} blockingResourcesFilter The function that determines which resources
+     *    should be considered *possibly* render-blocking.
+     * @param {(function(CPUNode):boolean)=} extraBlockingCpuNodesToIncludeFilter The function that determines which CPU nodes
+     *    should also be included in our blocking node IDs set.
+     * @return {Node}
+     */
+    static getFirstPaintBasedGraph(dependencyGraph: Node, paintTs: number, blockingResourcesFilter: (arg0: NetworkNode) => boolean, extraBlockingCpuNodesToIncludeFilter?: ((arg0: CPUNode) => boolean) | undefined): Node;
+}
+import { LanternMetric } from "./lantern-metric.js";
+//# sourceMappingURL=lantern-first-contentful-paint.d.ts.map

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

@@ -0,0 +1,12 @@
+export { LanternFirstMeaningfulPaintComputed as LanternFirstMeaningfulPaint };
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+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/dependency-graph/base-node.js').Node} Node */
+declare class LanternFirstMeaningfulPaint extends LanternMetric {
+}
+import { LanternMetric } from "./lantern-metric.js";
+//# sourceMappingURL=lantern-first-meaningful-paint.d.ts.map

package/core/computed/metrics/lantern-interactive.d.ts

@@ -0,0 +1,31 @@
+export { LanternInteractiveComputed as LanternInteractive };
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+declare const LanternInteractiveComputed: typeof LanternInteractive & {
+    /**
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    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>;
+};
+declare class LanternInteractive extends LanternMetric {
+    /**
+     * @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['nodeTimings']} nodeTimings
+     * @return {number}
+     */
+    static getLastLongTaskEndTime(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], duration?: number): number;
+}
+import { LanternMetric } from "./lantern-metric.js";
+//# sourceMappingURL=lantern-interactive.d.ts.map

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

@@ -0,0 +1,25 @@
+export { LanternLargestContentfulPaintComputed as LanternLargestContentfulPaint };
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+declare const LanternLargestContentfulPaintComputed: typeof LanternLargestContentfulPaint & {
+    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/dependency-graph/base-node.js').Node} Node */
+declare class LanternLargestContentfulPaint extends LanternMetric {
+    /**
+     * 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 { LanternMetric } from "./lantern-metric.js";
+//# sourceMappingURL=lantern-largest-contentful-paint.d.ts.map

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

@@ -0,0 +1,30 @@
+export { LanternMaxPotentialFIDComputed as LanternMaxPotentialFID };
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+declare const LanternMaxPotentialFIDComputed: typeof LanternMaxPotentialFID & {
+    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/dependency-graph/base-node.js').Node} Node */
+declare class LanternMaxPotentialFID extends LanternMetric {
+    /**
+     * @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['nodeTimings']} nodeTimings
+     * @param {number} fcpTimeInMs
+     * @return {Array<{duration: number}>}
+     */
+    static getTimingsAfterFCP(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): Array<{
+        duration: number;
+    }>;
+}
+import { LanternMetric } from "./lantern-metric.js";
+//# sourceMappingURL=lantern-max-potential-fid.d.ts.map

package/core/computed/metrics/lantern-metric.d.ts

@@ -0,0 +1,78 @@
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+export type NetworkNode = import('../../lib/dependency-graph/network-node').NetworkNode;
+export type Simulator = import('../../lib/dependency-graph/simulator/simulator').Simulator;
+export type Extras = {
+    optimistic: boolean;
+    fcpResult?: LH.Artifacts.LanternMetric | undefined;
+    fmpResult?: LH.Artifacts.LanternMetric | undefined;
+    interactiveResult?: LH.Artifacts.LanternMetric | undefined;
+    speedline?: {
+        speedIndex: number;
+    } | undefined;
+};
+/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
+/** @typedef {import('../../lib/dependency-graph/network-node').NetworkNode} NetworkNode */
+/** @typedef {import('../../lib/dependency-graph/simulator/simulator').Simulator} Simulator */
+/**
+ * @typedef Extras
+ * @property {boolean} optimistic
+ * @property {LH.Artifacts.LanternMetric=} fcpResult
+ * @property {LH.Artifacts.LanternMetric=} fmpResult
+ * @property {LH.Artifacts.LanternMetric=} interactiveResult
+ * @property {{speedIndex: number}=} speedline
+ */
+export class LanternMetric {
+    /**
+     * @param {Node} dependencyGraph
+     * @param {function(NetworkNode):boolean=} condition
+     * @return {Set<string>}
+     */
+    static getScriptUrls(dependencyGraph: Node, condition?: ((arg0: NetworkNode) => boolean) | undefined): Set<string>;
+    /**
+     * @return {LH.Gatherer.Simulation.MetricCoefficients}
+     */
+    static get COEFFICIENTS(): import("../../../types/gatherer.js").default.Simulation.MetricCoefficients;
+    /**
+     * 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 {LH.Gatherer.Simulation.MetricCoefficients}
+     */
+    static getScaledCoefficients(rttMs: number): LH.Gatherer.Simulation.MetricCoefficients;
+    /**
+     * @param {Node} dependencyGraph
+     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node, processedNavigation: LH.Artifacts.ProcessedNavigation): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node, processedNavigation: LH.Artifacts.ProcessedNavigation): Node;
+    /**
+     * @param {LH.Gatherer.Simulation.Result} simulationResult
+     * @param {Extras} extras
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result, extras: Extras): LH.Gatherer.Simulation.Result;
+    /**
+     * @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 { ProcessedNavigation } from "../processed-navigation.js";
+//# sourceMappingURL=lantern-metric.d.ts.map

package/core/computed/metrics/lantern-speed-index.d.ts

@@ -0,0 +1,38 @@
+export { LanternSpeedIndexComputed as LanternSpeedIndex };
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+declare const LanternSpeedIndexComputed: typeof LanternSpeedIndex & {
+    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/dependency-graph/base-node.js').Node} Node */
+declare class LanternSpeedIndex extends LanternMetric {
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * Approximate speed index using layout events from the simulated node timings.
+     * The layout-based speed index is the weighted average of the endTime of CPU nodes that contained
+     * a 'Layout' task. log(duration) is used as the weight to stand for "significance" to the page.
+     *
+     * If no layout events can be found or the endTime of a CPU task is too early, FCP is used instead.
+     *
+     * This approach was determined after evaluating the accuracy/complexity tradeoff of many
+     * different methods. Read more in the evaluation doc.
+     *
+     * @see https://docs.google.com/document/d/1qJWXwxoyVLVadezIp_Tgdk867G3tDNkkVRvUJSH3K1E/edit#
+     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+     * @param {number} fcpTimeInMs
+     * @return {number}
+     */
+    static computeLayoutBasedSpeedIndex(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
+}
+import { LanternMetric } from "./lantern-metric.js";
+//# sourceMappingURL=lantern-speed-index.d.ts.map

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

@@ -0,0 +1,31 @@
+export { LanternTotalBlockingTimeComputed as LanternTotalBlockingTime };
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+declare const LanternTotalBlockingTimeComputed: typeof LanternTotalBlockingTime & {
+    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/dependency-graph/base-node.js').Node} Node */
+declare class LanternTotalBlockingTime extends LanternMetric {
+    /**
+     * @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['nodeTimings']} nodeTimings
+     * @param {number} minDurationMs
+     */
+    static getTopLevelEvents(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], minDurationMs: number): {
+        start: number;
+        end: number;
+        duration: number;
+    }[];
+}
+import { LanternMetric } from "./lantern-metric.js";
+//# sourceMappingURL=lantern-total-blocking-time.d.ts.map

package/core/computed/metrics/largest-contentful-paint-all-frames.d.ts

@@ -0,0 +1,20 @@
+export { LargestContentfulPaintAllFramesComputed as LargestContentfulPaintAllFrames };
+declare const LargestContentfulPaintAllFramesComputed: typeof LargestContentfulPaintAllFrames & {
+    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.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+declare class LargestContentfulPaintAllFrames extends NavigationMetric {
+    /**
+     * TODO: Simulate LCP all frames in lantern.
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    static computeSimulatedMetric(): Promise<LH.Artifacts.LanternMetric>;
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
+}
+import { NavigationMetric } from "./navigation-metric.js";
+//# sourceMappingURL=largest-contentful-paint-all-frames.d.ts.map

package/core/computed/metrics/largest-contentful-paint.d.ts

@@ -0,0 +1,15 @@
+export { LargestContentfulPaintComputed as LargestContentfulPaint };
+declare const LargestContentfulPaintComputed: typeof LargestContentfulPaint & {
+    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.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+declare class LargestContentfulPaint extends NavigationMetric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
+}
+import { NavigationMetric } from "./navigation-metric.js";
+//# sourceMappingURL=largest-contentful-paint.d.ts.map

package/core/computed/metrics/max-potential-fid.d.ts

@@ -0,0 +1,15 @@
+export { MaxPotentialFIDComputed as MaxPotentialFID };
+declare const MaxPotentialFIDComputed: typeof MaxPotentialFID & {
+    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.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+declare class MaxPotentialFID extends NavigationMetric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData): Promise<LH.Artifacts.Metric>;
+}
+import { NavigationMetric } from "./navigation-metric.js";
+//# sourceMappingURL=max-potential-fid.d.ts.map

package/core/computed/metrics/metric.d.ts

@@ -0,0 +1,38 @@
+export default Metric;
+/**
+ * @fileOverview Encapsulates logic for choosing the correct metric computation method based on the
+ * specified throttling settings, supporting simulated and observed metric types.
+ *
+ * To implement a fully supported metric:
+ *     - Override the computeObservedMetric method with the observed-mode implementation.
+ *     - Override the computeSimulatedMetric method with the simulated-mode implementation (which
+ *       may call another computed artifact with the name LanternMyMetricName).
+ */
+declare class Metric {
+    /**
+     * Narrows the metric computation data to the input so child metric requests can be cached.
+     *
+     * @param {LH.Artifacts.MetricComputationData} data
+     * @return {LH.Artifacts.MetricComputationDataInput}
+     */
+    static getMetricComputationInput(data: LH.Artifacts.MetricComputationData): LH.Artifacts.MetricComputationDataInput;
+    /**
+     * @param {LH.Artifacts.MetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    static computeSimulatedMetric(data: LH.Artifacts.MetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
+    /**
+     * @param {LH.Artifacts.MetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.MetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.Metric>;
+    /**
+     * @param {LH.Artifacts.MetricComputationDataInput} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric|LH.Artifacts.Metric>}
+     */
+    static compute_(data: LH.Artifacts.MetricComputationDataInput, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric | LH.Artifacts.Metric>;
+}
+//# sourceMappingURL=metric.d.ts.map

package/core/computed/metrics/navigation-metric.d.ts

@@ -0,0 +1,16 @@
+export class NavigationMetric extends Metric {
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.LanternMetric>}
+     */
+    static computeSimulatedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.LanternMetric>;
+    /**
+     * @param {LH.Artifacts.NavigationMetricComputationData} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.Metric>}
+     */
+    static computeObservedMetric(data: LH.Artifacts.NavigationMetricComputationData, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.Metric>;
+}
+import Metric from "./metric.js";
+//# sourceMappingURL=navigation-metric.d.ts.map

package/core/computed/metrics/responsiveness.d.ts

@@ -0,0 +1,87 @@
+export { ResponsivenessComputed as Responsiveness };
+export type ResponsivenessEvent = LH.Trace.CompleteEvent & {
+    name: 'Responsiveness.Renderer.UserInteraction';
+    args: {
+        frame: string;
+        data: {
+            interactionType: 'drag' | 'keyboard' | 'tapOrClick';
+            maxDuration: number;
+        };
+    };
+};
+export type EventTimingType = 'keydown' | 'keypress' | 'keyup' | 'mousedown' | 'mouseup' | 'pointerdown' | 'pointerup' | 'click';
+export type EventTimingData = {
+    frame: string;
+    /**
+     * The time of user interaction (in ms from navStart).
+     */
+    timeStamp: number;
+    /**
+     * The start of interaction handling (in ms from navStart).
+     */
+    processingStart: number;
+    /**
+     * The end of interaction handling (in ms from navStart).
+     */
+    processingEnd: number;
+    /**
+     * The time from user interaction to browser paint (in ms).
+     */
+    duration: number;
+    type: EventTimingType;
+    nodeId: number;
+    interactionId: number;
+};
+export type EventTimingEvent = LH.Trace.AsyncEvent & {
+    name: 'EventTiming';
+    args: {
+        data: EventTimingData;
+    };
+};
+/**
+ * A fallback EventTiming placeholder, used if updated EventTiming events are not available.
+ * TODO: Remove once 103.0.5052.0 is sufficiently released.
+ */
+export type FallbackTimingEvent = {
+    name: 'FallbackTiming';
+    duration: number;
+};
+declare const ResponsivenessComputed: typeof Responsiveness & {
+    request: (dependencies: {
+        trace: LH.Trace;
+        settings: LH.Audit.Context['settings'];
+    }, context: import("../../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<EventTimingEvent | FallbackTimingEvent | null>;
+};
+declare class Responsiveness {
+    /**
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @return {ResponsivenessEvent|null}
+     */
+    static getHighPercentileResponsiveness(processedTrace: LH.Artifacts.ProcessedTrace): ResponsivenessEvent | null;
+    /**
+     * Finds the interaction event that was probably the responsivenessEvent.maxDuration
+     * source.
+     * Note that (presumably due to rounding to ms), the interaction duration may not
+     * be the same value as `maxDuration`, just the closest value. Function will throw
+     * if the closest match is off by more than 4ms.
+     * TODO: this doesn't try to match inputs to interactions and break ties if more than
+     * one interaction had this duration by returning the first found.
+     * @param {ResponsivenessEvent} responsivenessEvent
+     * @param {LH.Trace} trace
+     * @return {EventTimingEvent|FallbackTimingEvent}
+     */
+    static findInteractionEvent(responsivenessEvent: ResponsivenessEvent, { traceEvents }: LH.Trace): EventTimingEvent | FallbackTimingEvent;
+    /**
+     * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<EventTimingEvent|FallbackTimingEvent|null>}
+     */
+    static compute_(data: {
+        trace: LH.Trace;
+        settings: LH.Audit.Context['settings'];
+    }, context: LH.Artifacts.ComputedContext): Promise<EventTimingEvent | FallbackTimingEvent | null>;
+}
+import { ProcessedTrace } from "../processed-trace.js";
+//# sourceMappingURL=responsiveness.d.ts.map

package/core/computed/metrics/speed-index.d.ts

@@ -0,0 +1,10 @@
+export { SpeedIndexComputed as SpeedIndex };
+declare const SpeedIndexComputed: typeof SpeedIndex & {
+    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.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+declare class SpeedIndex extends NavigationMetric {
+}
+import { NavigationMetric } from "./navigation-metric.js";
+//# sourceMappingURL=speed-index.d.ts.map

package/core/computed/metrics/tbt-utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+export const BLOCKING_TIME_THRESHOLD: 50;
+/**
+ * @param {Array<{start: number, end: number, duration: number}>} topLevelEvents
+ * @param {number} startTimeMs
+ * @param {number} endTimeMs
+ * @return {number}
+ */
+export function calculateSumOfBlockingTime(topLevelEvents: Array<{
+    start: number;
+    end: number;
+    duration: number;
+}>, startTimeMs: number, endTimeMs: number): number;
+//# sourceMappingURL=tbt-utils.d.ts.map

package/core/computed/metrics/timing-summary.d.ts

@@ -0,0 +1,46 @@
+export { TimingSummaryComputed as TimingSummary };
+declare const TimingSummaryComputed: typeof TimingSummary & {
+    request: (dependencies: {
+        trace: LH.Trace;
+        devtoolsLog: import("../../index.js").DevtoolsLog;
+        gatherContext: LH.Artifacts['GatherContext'];
+        settings: LH.Util.ImmutableObject<LH.Config.Settings>;
+        URL: LH.Artifacts['URL'];
+    }, context: import("../../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<{
+        metrics: LH.Artifacts.TimingSummary;
+        debugInfo: Record<string, boolean>;
+    }>;
+};
+declare class TimingSummary {
+    /**
+       * @param {LH.Trace} trace
+       * @param {LH.DevtoolsLog} devtoolsLog
+       * @param {LH.Artifacts['GatherContext']} gatherContext
+       * @param {LH.Util.ImmutableObject<LH.Config.Settings>} settings
+       * @param {LH.Artifacts['URL']} URL
+       * @param {LH.Artifacts.ComputedContext} context
+       * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
+       */
+    static summarize(trace: LH.Trace, devtoolsLog: import("../../index.js").DevtoolsLog, gatherContext: LH.Artifacts['GatherContext'], settings: LH.Util.ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL'], context: LH.Artifacts.ComputedContext): Promise<{
+        metrics: LH.Artifacts.TimingSummary;
+        debugInfo: Record<string, boolean>;
+    }>;
+    /**
+     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: LH.Util.ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL']}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
+     */
+    static compute_(data: {
+        trace: LH.Trace;
+        devtoolsLog: import("../../index.js").DevtoolsLog;
+        gatherContext: LH.Artifacts['GatherContext'];
+        settings: LH.Util.ImmutableObject<LH.Config.Settings>;
+        URL: LH.Artifacts['URL'];
+    }, context: LH.Artifacts.ComputedContext): Promise<{
+        metrics: LH.Artifacts.TimingSummary;
+        debugInfo: Record<string, boolean>;
+    }>;
+}
+//# sourceMappingURL=timing-summary.d.ts.map