lighthouse 9.6.8 → 10.0.0

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-speed-index.js

@@ -0,0 +1,150 @@
+/**
+ * @license Copyright 2018 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.
+ */
+
+import {makeComputedArtifact} from '../computed-artifact.js';
+import {LanternMetric} from './lantern-metric.js';
+import {BaseNode} from '../../lib/dependency-graph/base-node.js';
+import {Speedline} from '../speedline.js';
+import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
+import {throttling as defaultThrottling} from '../../config/constants.js';
+
+/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
+
+class LanternSpeedIndex extends LanternMetric {
+  /**
+   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   */
+  static get COEFFICIENTS() {
+    return {
+      // Negative intercept is OK because estimate is Math.max(FCP, Speed Index) and
+      // the optimistic estimate is based on the real observed speed index rather than a real
+      // lantern graph.
+      intercept: -250,
+      optimistic: 1.4,
+      pessimistic: 0.65,
+    };
+  }
+
+  /**
+   * @param {number} rttMs
+   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   */
+  static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
+    // We want to scale our default coefficients based on the speed of the connection.
+    // We will linearly interpolate coefficients for the passed-in rttMs based on two pre-determined points:
+    //   1. Baseline point of 30 ms RTT where Speed Index should be a ~50/50 blend of optimistic/pessimistic.
+    //      30 ms was based on a typical home WiFi connection's actual RTT.
+    //      Coefficients here follow from the fact that the optimistic estimate should be very close
+    //      to reality at this connection speed and the pessimistic estimate compensates for minor
+    //      connection speed differences.
+    //   2. Default throttled point of 150 ms RTT where the default coefficients have been determined to be most accurate.
+    //      Coefficients here were determined through thorough analysis and linear regression on the
+    //      lantern test data set. See core/scripts/test-lantern.sh for more detail.
+    // While the coefficients haven't been analyzed at the interpolated points, it's our current best effort.
+    const defaultCoefficients = this.COEFFICIENTS;
+    const defaultRttExcess = defaultThrottling.mobileSlow4G.rttMs - 30;
+    const multiplier = Math.max((rttMs - 30) / defaultRttExcess, 0);
+
+    return {
+      intercept: defaultCoefficients.intercept * multiplier,
+      optimistic: 0.5 + (defaultCoefficients.optimistic - 0.5) * multiplier,
+      pessimistic: 0.5 + (defaultCoefficients.pessimistic - 0.5) * multiplier,
+    };
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getOptimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getPessimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result} simulationResult
+   * @param {import('./lantern-metric.js').Extras} extras
+   * @return {LH.Gatherer.Simulation.Result}
+   */
+  static getEstimateFromSimulation(simulationResult, extras) {
+    if (!extras.fcpResult) throw new Error('missing fcpResult');
+    if (!extras.speedline) throw new Error('missing speedline');
+
+    const fcpTimeInMs = extras.fcpResult.pessimisticEstimate.timeInMs;
+    const estimate = extras.optimistic
+      ? extras.speedline.speedIndex
+      : LanternSpeedIndex.computeLayoutBasedSpeedIndex(simulationResult.nodeTimings, fcpTimeInMs);
+    return {
+      timeInMs: estimate,
+      nodeTimings: simulationResult.nodeTimings,
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts.MetricComputationDataInput} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static async compute_(data, context) {
+    const speedline = await Speedline.request(data.trace, context);
+    const fcpResult = await LanternFirstContentfulPaint.request(data, context);
+    const metricResult = await this.computeMetricWithGraphs(data, context, {
+      speedline,
+      fcpResult,
+    });
+    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
+    return metricResult;
+  }
+
+  /**
+   * 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, fcpTimeInMs) {
+    /** @type {Array<{time: number, weight: number}>} */
+    const layoutWeights = [];
+    for (const [node, timing] of nodeTimings.entries()) {
+      if (node.type !== BaseNode.TYPES.CPU) continue;
+
+      if (node.childEvents.some(x => x.name === 'Layout')) {
+        const timingWeight = Math.max(Math.log2(timing.endTime - timing.startTime), 0);
+        layoutWeights.push({time: timing.endTime, weight: timingWeight});
+      }
+    }
+
+    const totalWeightedTime = layoutWeights
+      .map(evt => evt.weight * Math.max(evt.time, fcpTimeInMs))
+      .reduce((a, b) => a + b, 0);
+    const totalWeight = layoutWeights.map(evt => evt.weight).reduce((a, b) => a + b, 0);
+
+    if (!totalWeight) return fcpTimeInMs;
+    return totalWeightedTime / totalWeight;
+  }
+}
+
+const LanternSpeedIndexComputed = makeComputedArtifact(
+  LanternSpeedIndex,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {LanternSpeedIndexComputed as LanternSpeedIndex};

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/lantern-total-blocking-time.js

@@ -0,0 +1,126 @@
+/**
+ * @license Copyright 2019 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.
+ */
+
+import {makeComputedArtifact} from '../computed-artifact.js';
+import {LanternMetric} from './lantern-metric.js';
+import {BaseNode} from '../../lib/dependency-graph/base-node.js';
+import {LanternFirstContentfulPaint} from './lantern-first-contentful-paint.js';
+import {LanternInteractive} from './lantern-interactive.js';
+import {BLOCKING_TIME_THRESHOLD, calculateSumOfBlockingTime} from './tbt-utils.js';
+
+/** @typedef {import('../../lib/dependency-graph/base-node.js').Node} Node */
+
+class LanternTotalBlockingTime extends LanternMetric {
+  /**
+   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   */
+  static get COEFFICIENTS() {
+    return {
+      intercept: 0,
+      optimistic: 0.5,
+      pessimistic: 0.5,
+    };
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getOptimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getPessimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result} simulation
+   * @param {import('./lantern-metric.js').Extras} extras
+   * @return {LH.Gatherer.Simulation.Result}
+   */
+  static getEstimateFromSimulation(simulation, extras) {
+    if (!extras.fcpResult) throw new Error('missing fcpResult');
+    if (!extras.interactiveResult) throw new Error('missing interactiveResult');
+
+    // Intentionally use the opposite FCP estimate. A pessimistic FCP is higher than equal to an
+    // optimistic FCP, which means potentially more tasks are excluded from the Total Blocking Time
+    // computation. So a more pessimistic FCP gives a more optimistic Total Blocking Time for the
+    // same work.
+    const fcpTimeInMs = extras.optimistic
+      ? extras.fcpResult.pessimisticEstimate.timeInMs
+      : extras.fcpResult.optimisticEstimate.timeInMs;
+
+    // Similarly, we always have pessimistic TTI >= optimistic TTI. Therefore, picking optimistic
+    // TTI means our window of interest is smaller and thus potentially more tasks are excluded from
+    // Total Blocking Time computation, yielding a lower (more optimistic) Total Blocking Time value
+    // for the same work.
+    const interactiveTimeMs = extras.optimistic
+      ? extras.interactiveResult.optimisticEstimate.timeInMs
+      : extras.interactiveResult.pessimisticEstimate.timeInMs;
+
+    const minDurationMs = BLOCKING_TIME_THRESHOLD;
+
+    const events = LanternTotalBlockingTime.getTopLevelEvents(
+      simulation.nodeTimings,
+      minDurationMs
+    );
+
+    return {
+      timeInMs: calculateSumOfBlockingTime(
+        events,
+        fcpTimeInMs,
+        interactiveTimeMs
+      ),
+      nodeTimings: simulation.nodeTimings,
+    };
+  }
+
+  /**
+   * @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 interactiveResult = await LanternInteractive.request(data, context);
+    return this.computeMetricWithGraphs(data, context, {fcpResult, interactiveResult});
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {number} minDurationMs
+   */
+  static getTopLevelEvents(nodeTimings, minDurationMs) {
+    /** @type {Array<{start: number, end: number, duration: number}>}
+     */
+    const events = [];
+
+    for (const [node, timing] of nodeTimings.entries()) {
+      if (node.type !== BaseNode.TYPES.CPU) continue;
+      // Filtering out events below minimum duration.
+      if (timing.duration < minDurationMs) continue;
+
+      events.push({
+        start: timing.startTime,
+        end: timing.endTime,
+        duration: timing.duration,
+      });
+    }
+
+    return events;
+  }
+}
+
+const LanternTotalBlockingTimeComputed = makeComputedArtifact(
+  LanternTotalBlockingTime,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {LanternTotalBlockingTimeComputed as LanternTotalBlockingTime};

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-all-frames.js

@@ -0,0 +1,45 @@
+/**
+ * @license Copyright 2020 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.
+ */
+
+/**
+ * @fileoverview Computed Largest Contentful Paint (LCP) for all frames.
+ */
+
+import {makeComputedArtifact} from '../computed-artifact.js';
+import {NavigationMetric} from './navigation-metric.js';
+import {LighthouseError} from '../../lib/lh-error.js';
+
+class LargestContentfulPaintAllFrames extends NavigationMetric {
+  /**
+   * TODO: Simulate LCP all frames in lantern.
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static async computeSimulatedMetric() {
+    throw new Error('LCP All Frames not implemented in lantern');
+  }
+
+  /**
+   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @return {Promise<LH.Artifacts.Metric>}
+   */
+  static async computeObservedMetric(data) {
+    const {processedNavigation} = data;
+    if (processedNavigation.timings.largestContentfulPaintAllFrames === undefined) {
+      throw new LighthouseError(LighthouseError.errors.NO_LCP_ALL_FRAMES);
+    }
+
+    return {
+      timing: processedNavigation.timings.largestContentfulPaintAllFrames,
+      timestamp: processedNavigation.timestamps.largestContentfulPaintAllFrames,
+    };
+  }
+}
+
+const LargestContentfulPaintAllFramesComputed = makeComputedArtifact(
+  LargestContentfulPaintAllFrames,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {LargestContentfulPaintAllFramesComputed as LargestContentfulPaintAllFrames};

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/largest-contentful-paint.js

@@ -0,0 +1,52 @@
+/**
+ * @license Copyright 2019 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.
+ */
+
+/**
+ * @fileoverview Computed Largest Contentful Paint (LCP), the paint time of the largest in-viewport contentful element
+ * COMPAT: LCP's trace event was first introduced in m78. We can't surface an LCP for older Chrome versions
+ * @see https://github.com/WICG/largest-contentful-paint
+ * @see https://wicg.github.io/largest-contentful-paint/
+ * @see https://web.dev/lcp
+ */
+
+import {makeComputedArtifact} from '../computed-artifact.js';
+import {NavigationMetric} from './navigation-metric.js';
+import {LighthouseError} from '../../lib/lh-error.js';
+import {LanternLargestContentfulPaint} from './lantern-largest-contentful-paint.js';
+
+class LargestContentfulPaint 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 LanternLargestContentfulPaint.request(metricData, context);
+  }
+
+  /**
+   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @return {Promise<LH.Artifacts.Metric>}
+   */
+  static async computeObservedMetric(data) {
+    const {processedNavigation} = data;
+    if (processedNavigation.timings.largestContentfulPaint === undefined) {
+      throw new LighthouseError(LighthouseError.errors.NO_LCP);
+    }
+
+    return {
+      timing: processedNavigation.timings.largestContentfulPaint,
+      timestamp: processedNavigation.timestamps.largestContentfulPaint,
+    };
+  }
+}
+
+const LargestContentfulPaintComputed = makeComputedArtifact(
+  LargestContentfulPaint,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {LargestContentfulPaintComputed as LargestContentfulPaint};

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/max-potential-fid.js

@@ -0,0 +1,45 @@
+/**
+ * @license Copyright 2018 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.
+ */
+
+import {makeComputedArtifact} from '../computed-artifact.js';
+import {NavigationMetric} from './navigation-metric.js';
+import {LanternMaxPotentialFID} from './lantern-max-potential-fid.js';
+import {TraceProcessor} from '../../lib/tracehouse/trace-processor.js';
+
+class MaxPotentialFID 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 LanternMaxPotentialFID.request(metricData, context);
+  }
+
+  /**
+   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @return {Promise<LH.Artifacts.Metric>}
+   */
+  static computeObservedMetric(data) {
+    const {firstContentfulPaint} = data.processedNavigation.timings;
+
+    const events = TraceProcessor.getMainThreadTopLevelEvents(
+      data.processedTrace,
+      firstContentfulPaint
+    ).filter(evt => evt.duration >= 1);
+
+    return Promise.resolve({
+      timing: Math.max(...events.map(evt => evt.duration), 16),
+    });
+  }
+}
+
+const MaxPotentialFIDComputed = makeComputedArtifact(
+  MaxPotentialFID,
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
+);
+export {MaxPotentialFIDComputed as MaxPotentialFID};

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