lighthouse 9.6.8 → 10.0.0

package/core/audits/metrics/interactive.js

@@ -0,0 +1,93 @@
+/**
+ * @license Copyright 2017 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 {Audit} from '../audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+import {Interactive} from '../../computed/metrics/interactive.js';
+
+const UIStrings = {
+  /** Description of the Time to Interactive (TTI) metric, which evaluates when a page has completed its primary network activity and main thread work. This is displayed within a tooltip when the user hovers on the metric name to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Time to Interactive is the amount of time it takes for the page to become fully ' +
+    'interactive. [Learn more about the Time to Interactive metric](https://developer.chrome.com/docs/lighthouse/performance/interactive/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/**
+ * @fileoverview This audit identifies the time the page is "consistently interactive".
+ * Looks for the first period of at least 5 seconds after FMP where both CPU and network were quiet,
+ * and returns the timestamp of the beginning of the CPU quiet period.
+ * @see https://docs.google.com/document/d/1GGiI9-7KeY3TPqS3YT271upUVimo-XiL5mwWorDUD4c/edit#
+ */
+class InteractiveMetric extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'interactive',
+      title: str_(i18n.UIStrings.interactiveMetric),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
+    };
+  }
+
+  /**
+   * @return {{mobile: {scoring: LH.Audit.ScoreOptions}, desktop: {scoring: LH.Audit.ScoreOptions}}}
+   */
+  static get defaultOptions() {
+    return {
+      mobile: {
+        // 25th and 5th percentiles HTTPArchive -> median and PODR, then p10 derived from them.
+        // https://bigquery.cloud.google.com/table/httparchive:lighthouse.2018_04_01_mobile?pli=1
+        // see https://www.desmos.com/calculator/o98tbeyt1t
+        scoring: {
+          p10: 3785,
+          median: 7300,
+        },
+      },
+      desktop: {
+        // SELECT QUANTILES(fullyLoaded, 21) FROM [httparchive:summary_pages.2018_12_15_desktop] LIMIT 1000
+        scoring: {
+          p10: 2468,
+          median: 4500,
+        },
+      },
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const gatherContext = artifacts.GatherContext;
+    const metricComputationData = {trace, devtoolsLog, gatherContext,
+      settings: context.settings, URL: artifacts.URL};
+    const metricResult = await Interactive.request(metricComputationData, context);
+    const timeInMs = metricResult.timing;
+    const options = context.options[context.settings.formFactor];
+
+
+    return {
+      score: Audit.computeLogNormalScore(
+        options.scoring,
+        timeInMs
+      ),
+      numericValue: timeInMs,
+      numericUnit: 'millisecond',
+      displayValue: str_(i18n.UIStrings.seconds, {timeInMs}),
+    };
+  }
+}
+
+export default InteractiveMetric;
+export {UIStrings};

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

@@ -0,0 +1,25 @@
+export default LargestContentfulPaint;
+declare class LargestContentfulPaint extends Audit {
+    /**
+     * @return {{mobile: {scoring: LH.Audit.ScoreOptions}, desktop: {scoring: LH.Audit.ScoreOptions}}}
+     */
+    static get defaultOptions(): {
+        mobile: {
+            scoring: LH.Audit.ScoreOptions;
+        };
+        desktop: {
+            scoring: LH.Audit.ScoreOptions;
+        };
+    };
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const description: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=largest-contentful-paint.d.ts.map

package/core/audits/metrics/largest-contentful-paint.js

@@ -0,0 +1,94 @@
+/**
+ * @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 {Audit} from '../audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+import {LargestContentfulPaint as ComputedLcp} from '../../computed/metrics/largest-contentful-paint.js';
+
+const UIStrings = {
+  /** Description of the Largest Contentful Paint (LCP) metric, which marks the time at which the largest text or image is painted by the browser. This is displayed within a tooltip when the user hovers on the metric name to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Largest Contentful Paint marks the time at which the largest text or image is ' +
+      `painted. [Learn more about the Largest Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-largest-contentful-paint/)`,
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class LargestContentfulPaint extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'largest-contentful-paint',
+      title: str_(i18n.UIStrings.largestContentfulPaintMetric),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['HostUserAgent', 'traces', 'devtoolsLogs', 'GatherContext', 'URL'],
+    };
+  }
+
+  /**
+   * @return {{mobile: {scoring: LH.Audit.ScoreOptions}, desktop: {scoring: LH.Audit.ScoreOptions}}}
+   */
+  static get defaultOptions() {
+    return {
+      mobile: {
+        // 25th and 13th percentiles HTTPArchive -> median and p10 points.
+        // https://bigquery.cloud.google.com/table/httparchive:lighthouse.2020_02_01_mobile?pli=1
+        // https://web.dev/lcp/#what-is-a-good-lcp-score
+        // see https://www.desmos.com/calculator/1etesp32kt
+        scoring: {
+          p10: 2500,
+          median: 4000,
+        },
+      },
+      desktop: {
+        // 25th and 5th percentiles HTTPArchive -> median and p10 points.
+        // SELECT
+        //   APPROX_QUANTILES(lcpValue, 100)[OFFSET(5)] AS p05_lcp,
+        //   APPROX_QUANTILES(lcpValue, 100)[OFFSET(25)] AS p25_lcp
+        // FROM (
+        //   SELECT CAST(JSON_EXTRACT_SCALAR(payload, "$['_chromeUserTiming.LargestContentfulPaint']") AS NUMERIC) AS lcpValue
+        //   FROM `httparchive.pages.2020_04_01_desktop`
+        // )
+        scoring: {
+          p10: 1200,
+          median: 2400,
+        },
+      },
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const gatherContext = artifacts.GatherContext;
+    const metricComputationData = {trace, devtoolsLog, gatherContext,
+      settings: context.settings, URL: artifacts.URL};
+
+    const metricResult = await ComputedLcp.request(metricComputationData, context);
+    const options = context.options[context.settings.formFactor];
+
+    return {
+      score: Audit.computeLogNormalScore(
+        options.scoring,
+        metricResult.timing
+      ),
+      numericValue: metricResult.timing,
+      numericUnit: 'millisecond',
+      displayValue: str_(i18n.UIStrings.seconds, {timeInMs: metricResult.timing}),
+    };
+  }
+}
+
+export default LargestContentfulPaint;
+export {UIStrings};

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

@@ -0,0 +1,23 @@
+export default MaxPotentialFID;
+/**
+ * @fileoverview This metric is the duration of the longest task after FCP. It is meant to capture
+ * the worst case First Input Delay that a user might experience.
+ * Tasks before FCP are excluded because it is unlikely that the user will try to interact with a page before it has painted anything.
+ */
+declare class MaxPotentialFID extends Audit {
+    /**
+     * @return {LH.Audit.ScoreOptions}
+     */
+    static get defaultOptions(): import("../../../types/audit.js").default.ScoreOptions;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const description: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=max-potential-fid.d.ts.map

package/core/audits/metrics/max-potential-fid.js

@@ -0,0 +1,77 @@
+/**
+ * @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 {Audit} from '../audit.js';
+import {MaxPotentialFID as ComputedFid} from '../../computed/metrics/max-potential-fid.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Description of the Maximum Potential First Input Delay metric that marks the maximum estimated time between the page receiving input (a user clicking, tapping, or typing) and the page responding. This description is displayed within a tooltip when the user hovers on the metric name to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'The maximum potential First Input Delay that your users could experience is the ' +
+      'duration of the longest task. ' +
+      '[Learn more about the Maximum Potential First Input Delay metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-max-potential-fid/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/**
+ * @fileoverview This metric is the duration of the longest task after FCP. It is meant to capture
+ * the worst case First Input Delay that a user might experience.
+ * Tasks before FCP are excluded because it is unlikely that the user will try to interact with a page before it has painted anything.
+ */
+class MaxPotentialFID extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'max-potential-fid',
+      title: str_(i18n.UIStrings.maxPotentialFIDMetric),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
+    };
+  }
+
+  /**
+   * @return {LH.Audit.ScoreOptions}
+   */
+  static get defaultOptions() {
+    return {
+      // see https://www.desmos.com/calculator/onxmbblyqo
+      p10: 130,
+      median: 250,
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const gatherContext = artifacts.GatherContext;
+    const metricComputationData = {trace, devtoolsLog, gatherContext,
+      settings: context.settings, URL: artifacts.URL};
+    const metricResult = await ComputedFid.request(metricComputationData, context);
+
+    return {
+      score: Audit.computeLogNormalScore(
+        {p10: context.options.p10, median: context.options.median},
+        metricResult.timing
+      ),
+      numericValue: metricResult.timing,
+      numericUnit: 'millisecond',
+      displayValue: str_(i18n.UIStrings.ms, {timeInMs: metricResult.timing}),
+    };
+  }
+}
+
+export default MaxPotentialFID;
+export {UIStrings};

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

@@ -0,0 +1,27 @@
+export default SpeedIndex;
+declare class SpeedIndex extends Audit {
+    /**
+     * @return {{mobile: {scoring: LH.Audit.ScoreOptions}, desktop: {scoring: LH.Audit.ScoreOptions}}}
+     */
+    static get defaultOptions(): {
+        mobile: {
+            scoring: LH.Audit.ScoreOptions;
+        };
+        desktop: {
+            scoring: LH.Audit.ScoreOptions;
+        };
+    };
+    /**
+     * Audits the page to give a score for the Speed Index.
+     * @see https://github.com/GoogleChrome/lighthouse/issues/197
+     * @param {LH.Artifacts} artifacts The artifacts from the gather phase.
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const description: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=speed-index.d.ts.map

package/core/audits/metrics/speed-index.js

@@ -0,0 +1,88 @@
+/**
+ * @license Copyright 2016 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 {Audit} from '../audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+import {SpeedIndex as ComputedSi} from '../../computed/metrics/speed-index.js';
+
+const UIStrings = {
+  /** Description of the Speed Index metric, which summarizes how quickly the page looked visually complete. This is displayed within a tooltip when the user hovers on the metric name to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Speed Index shows how quickly the contents of a page are visibly populated. ' +
+      '[Learn more about the Speed Index metric](https://developer.chrome.com/docs/lighthouse/performance/speed-index/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class SpeedIndex extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'speed-index',
+      title: str_(i18n.UIStrings.speedIndexMetric),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
+    };
+  }
+
+  /**
+   * @return {{mobile: {scoring: LH.Audit.ScoreOptions}, desktop: {scoring: LH.Audit.ScoreOptions}}}
+   */
+  static get defaultOptions() {
+    return {
+      mobile: {
+        // 25th and 5th percentiles HTTPArchive -> median and PODR, then p10 derived from them.
+        // https://bigquery.cloud.google.com/table/httparchive:lighthouse.2018_04_01_mobile?pli=1
+        // see https://www.desmos.com/calculator/dvuzvpl7mi
+        scoring: {
+          p10: 3387,
+          median: 5800,
+        },
+      },
+      desktop: {
+        // SELECT QUANTILES(SpeedIndex, 21) FROM [httparchive:summary_pages.2018_12_15_desktop] LIMIT 1000
+        scoring: {
+          p10: 1311,
+          median: 2300,
+        },
+      },
+    };
+  }
+
+  /**
+   * Audits the page to give a score for the Speed Index.
+   * @see https://github.com/GoogleChrome/lighthouse/issues/197
+   * @param {LH.Artifacts} artifacts The artifacts from the gather phase.
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const gatherContext = artifacts.GatherContext;
+    const metricComputationData = {trace, devtoolsLog, gatherContext,
+      settings: context.settings, URL: artifacts.URL};
+    const metricResult = await ComputedSi.request(metricComputationData, context);
+    const options = context.options[context.settings.formFactor];
+
+
+    return {
+      score: Audit.computeLogNormalScore(
+        options.scoring,
+        metricResult.timing
+      ),
+      numericValue: metricResult.timing,
+      numericUnit: 'millisecond',
+      displayValue: str_(i18n.UIStrings.seconds, {timeInMs: metricResult.timing}),
+    };
+  }
+}
+
+export default SpeedIndex;
+export {UIStrings};

package/core/audits/metrics/total-blocking-time.d.ts

@@ -0,0 +1,32 @@
+export default TotalBlockingTime;
+declare class TotalBlockingTime extends Audit {
+    /**
+     * @return {{mobile: {scoring: LH.Audit.ScoreOptions}, desktop: {scoring: LH.Audit.ScoreOptions}}}
+     */
+    static get defaultOptions(): {
+        mobile: {
+            scoring: LH.Audit.ScoreOptions;
+        };
+        desktop: {
+            scoring: LH.Audit.ScoreOptions;
+        };
+    };
+    /**
+     * Audits the page to calculate Total Blocking Time.
+     *
+     * We define Blocking Time as any time interval in the loading timeline where task length exceeds
+     * 50ms. For example, if there is a 110ms main thread task, the last 60ms of it is blocking time.
+     * Total Blocking Time is the sum of all Blocking Time between First Contentful Paint and
+     * Interactive Time (TTI).
+     *
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const description: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=total-blocking-time.d.ts.map

package/core/audits/metrics/total-blocking-time.js

@@ -0,0 +1,118 @@
+/**
+ * @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 {Audit} from '../audit.js';
+import {TotalBlockingTime as ComputedTBT} from '../../computed/metrics/total-blocking-time.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Description of the Total Blocking Time (TBT) metric, which calculates the total duration of blocking time for a web page. Blocking times are time periods when the page would be blocked (prevented) from responding to user input (clicks, taps, and keypresses will feel slow to respond). This is displayed within a tooltip when the user hovers on the metric name to see more. No character length limits.*/
+  description: 'Sum of all time periods between FCP and Time to Interactive, ' +
+      'when task length exceeded 50ms, expressed in milliseconds. ' +
+      '[Learn more about the Total Blocking Time metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-total-blocking-time/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class TotalBlockingTime extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'total-blocking-time',
+      title: str_(i18n.UIStrings.totalBlockingTimeMetric),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
+    };
+  }
+
+  /**
+   * @return {{mobile: {scoring: LH.Audit.ScoreOptions}, desktop: {scoring: LH.Audit.ScoreOptions}}}
+   */
+  static get defaultOptions() {
+    return {
+      mobile: {
+        // If determined from HTTP Archive data…
+        //     SELECT
+        //         APPROX_QUANTILES(tbt_value, 100)[OFFSET(8)] AS p08_tbt,
+        //         APPROX_QUANTILES(tbt_value, 100)[OFFSET(25)] AS p25_tbt
+        //     FROM (
+        //         SELECT CAST(JSON_EXTRACT_SCALAR(report, '$.audits.total-blocking-time.numericValue') AS FLOAT64) AS tbt_value
+        //         FROM `httparchive.lighthouse.2021_05_01_mobile`
+        //         WHERE report is not NULL
+        //     )
+        // …we'd use control points of 19 and 189, which leads to surprisingly harsh scoring.
+        //
+        // The following coefficients are semi-arbitrarily chosen, but start to approach the "correct" ones:
+        // See https://www.desmos.com/calculator/pwcgna1cvf go/lh8-tbt-curves
+        scoring: {
+          p10: 200,
+          median: 600,
+        },
+      },
+      desktop: {
+        // Chosen in HTTP Archive desktop results to approximate curve easing described above.
+        // SELECT
+        //   APPROX_QUANTILES(tbtValue, 100)[OFFSET(40)] AS p40_tbt,
+        //   APPROX_QUANTILES(tbtValue, 100)[OFFSET(60)] AS p60_tbt
+        // FROM (
+        //   SELECT CAST(JSON_EXTRACT_SCALAR(payload, '$._TotalBlockingTime') AS NUMERIC) AS tbtValue
+        //   FROM `httparchive.pages.2020_04_01_desktop`
+        // )
+        scoring: {
+          p10: 150,
+          median: 350,
+        },
+      },
+    };
+  }
+
+  /**
+   * Audits the page to calculate Total Blocking Time.
+   *
+   * We define Blocking Time as any time interval in the loading timeline where task length exceeds
+   * 50ms. For example, if there is a 110ms main thread task, the last 60ms of it is blocking time.
+   * Total Blocking Time is the sum of all Blocking Time between First Contentful Paint and
+   * Interactive Time (TTI).
+   *
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const gatherContext = artifacts.GatherContext;
+    const metricComputationData = {trace, devtoolsLog, gatherContext,
+      settings: context.settings, URL: artifacts.URL};
+    if (
+      gatherContext.gatherMode === 'timespan' &&
+      context.settings.throttlingMethod === 'simulate'
+    ) {
+      return {score: 1, notApplicable: true};
+    }
+
+    const metricResult = await ComputedTBT.request(metricComputationData, context);
+
+    const options = context.options[context.settings.formFactor];
+
+
+    return {
+      score: Audit.computeLogNormalScore(
+        options.scoring,
+        metricResult.timing
+      ),
+      numericValue: metricResult.timing,
+      numericUnit: 'millisecond',
+      displayValue: str_(i18n.UIStrings.ms, {timeInMs: metricResult.timing}),
+    };
+  }
+}
+
+export default TotalBlockingTime;
+export {UIStrings};

package/core/audits/metrics.d.ts

@@ -0,0 +1,11 @@
+export default Metrics;
+declare class Metrics extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=metrics.d.ts.map

package/core/audits/metrics.js

@@ -0,0 +1,73 @@
+/**
+ * @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 {Audit} from './audit.js';
+import {TimingSummary} from '../computed/metrics/timing-summary.js';
+
+/** @type {Set<keyof LH.Artifacts.TimingSummary>} */
+const DECIMAL_METRIC_KEYS = new Set([
+  'cumulativeLayoutShift',
+  'cumulativeLayoutShiftMainFrame',
+  'totalCumulativeLayoutShift',
+  'observedCumulativeLayoutShift',
+  'observedCumulativeLayoutShiftMainFrame',
+  'observedTotalCumulativeLayoutShift',
+]);
+
+class Metrics extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'metrics',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: 'Metrics',
+      description: 'Collects all available metrics.',
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const gatherContext = artifacts.GatherContext;
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const URL = artifacts.URL;
+    const summary = await TimingSummary
+      .request({trace, devtoolsLog, gatherContext, settings: context.settings, URL}, context);
+    const metrics = summary.metrics;
+    const debugInfo = summary.debugInfo;
+
+    for (const [name, value] of Object.entries(metrics)) {
+      const key = /** @type {keyof LH.Artifacts.TimingSummary} */ (name);
+      if (typeof value === 'number' && !DECIMAL_METRIC_KEYS.has(key)) {
+        metrics[key] = Math.round(value);
+      }
+    }
+
+    /** @type {LH.Audit.Details.DebugData} */
+    const details = {
+      type: 'debugdata',
+      // TODO: Consider not nesting metrics under `items`.
+      items: [metrics, debugInfo],
+    };
+
+    return {
+      score: 1,
+      numericValue: metrics.interactive || 0,
+      numericUnit: 'millisecond',
+      details,
+    };
+  }
+}
+
+export default Metrics;