lighthouse 9.2.0 → 9.3.0

package/flow-report/src/common.tsx

@@ -93,7 +93,7 @@ const FlowStepThumbnail: FunctionComponent<{
   }
 
   let thumbnail;
-  if (frames && frames.length) {
+  if (frames?.length) {
     thumbnail = frames[frames.length - 1].data;
     if (lhr.gatherMode === 'timespan') {
       return <FlowStepAnimatedThumbnail frames={frames} width={width} height={height} />;

package/flow-report/src/sidebar/flow.tsx

@@ -59,7 +59,7 @@ export const SidebarFlow: FunctionComponent = () => {
               mode={lhr.gatherMode}
               href={`#index=${index}`}
               label={name}
-              isCurrent={index === (hashState && hashState.index)}
+              isCurrent={index === hashState?.index}
             />
           </>;
         })

package/flow-report/src/util.ts

@@ -44,8 +44,7 @@ function getScreenDimensions(reportResult: LH.Result) {
 function getFullPageScreenshot(reportResult: LH.Result) {
   const fullPageScreenshotAudit = reportResult.audits['full-page-screenshot'];
   const fullPageScreenshot =
-    fullPageScreenshotAudit &&
-    fullPageScreenshotAudit.details &&
+    fullPageScreenshotAudit?.details &&
     fullPageScreenshotAudit.details.type === 'full-page-screenshot' &&
     fullPageScreenshotAudit.details;
 

package/lighthouse-cli/bin.js

@@ -24,7 +24,6 @@ import url from 'url';
 import module from 'module';
 
 import log from 'lighthouse-logger';
-import updateNotifier from 'update-notifier';
 
 import * as commands from './commands/commands.js';
 import * as Printer from './printer.js';
@@ -51,9 +50,6 @@ function isDev() {
  * @return {Promise<LH.RunnerResult|void>}
  */
 async function begin() {
-  // Tell user if there's a newer version of LH.
-  updateNotifier({pkg}).notify();
-
   const cliFlags = getFlags();
 
   // Process terminating command

package/lighthouse-cli/cli-flags.js

@@ -178,7 +178,6 @@ function getFlags(manualArgv, options = {}) {
         },
         'enable-error-reporting': {
           type: 'boolean',
-          default: undefined, // Explicitly `undefined` so prompted by default.
           describe: 'Enables error reporting, overriding any saved preference. --no-enable-error-reporting will do the opposite. More: https://git.io/vFFTO',
         },
         'gather-mode': {
@@ -343,19 +342,26 @@ function getFlags(manualArgv, options = {}) {
 
   // Augmenting yargs type with auto-camelCasing breaks in tsc@4.1.2 and @types/yargs@15.0.11,
   // so for now cast to add yarg's camelCase properties to type.
-  const argv = parser.argv;
+  const argv = /** @type {Awaited<typeof parser.argv>} */ (parser.argv);
   const cliFlags = /** @type {typeof argv & CamelCasify<typeof argv>} */ (argv);
 
+  // yargs will return `undefined` for options that have a `coerce` function but
+  // are not actually present in the user input. Instead of passing properties
+  // explicitly set to undefined, delete them from the flags object.
+  for (const [k, v] of Object.entries(cliFlags)) {
+    if (v === undefined) delete cliFlags[k];
+  }
+
   return cliFlags;
 }
 
 /**
  * Support comma-separated values for some array flags by splitting on any ',' found.
  * @param {Array<string>=} strings
- * @return {Array<string>|undefined}
+ * @return {Array<string>=}
  */
 function splitCommaSeparatedValues(strings) {
-  if (!strings) return strings;
+  if (!strings) return;
 
   return strings.flatMap(value => value.split(','));
 }
@@ -365,7 +371,9 @@ function splitCommaSeparatedValues(strings) {
  * @return {boolean|string|undefined}
  */
 function coerceOptionalStringBoolean(value) {
-  if (typeof value !== 'undefined' && typeof value !== 'string' && typeof value !== 'boolean') {
+  if (value === undefined) return;
+
+  if (typeof value !== 'string' && typeof value !== 'boolean') {
     throw new Error('Invalid value: Argument must be a string or a boolean');
   }
   return value;
@@ -399,9 +407,11 @@ function coerceOutput(values) {
  * allowlist specific locales. Why? So we can support the user who requests 'es-MX' (unsupported)
  * and we'll fall back to 'es' (supported).
  * @param {unknown} value
- * @return {LH.Locale}
+ * @return {LH.Locale|undefined}
  */
 function coerceLocale(value) {
+  if (value === undefined) return;
+
   if (typeof value !== 'string') throw new Error(`Invalid value: Argument 'locale' must be a string`);
   return /** @type {LH.Locale} */ (value);
 }
@@ -431,9 +441,11 @@ function coerceExtraHeaders(value) {
 /**
  * Take yarg's unchecked object value and ensure it's proper throttling settings.
  * @param {unknown} value
- * @return {LH.ThrottlingSettings}
+ * @return {LH.ThrottlingSettings|undefined}
  */
 function coerceThrottling(value) {
+  if (value === undefined) return;
+
   if (!isObjectOfUnknownValues(value)) {
     throw new Error(`Invalid value: Argument 'throttling' must be an object, specified per-property ('throttling.rttMs', 'throttling.throughputKbps', etc)`);
   }
@@ -465,9 +477,11 @@ function coerceThrottling(value) {
 /**
  * Take yarg's unchecked object value and ensure it is a proper LH.screenEmulationSettings.
  * @param {unknown} value
- * @return {Partial<LH.ScreenEmulationSettings>}
+ * @return {Partial<LH.ScreenEmulationSettings>|undefined}
  */
 function coerceScreenEmulation(value) {
+  if (value === undefined) return;
+
   if (!isObjectOfUnknownValues(value)) {
     throw new Error(`Invalid value: Argument 'screenEmulation' must be an object, specified per-property ('screenEmulation.width', 'screenEmulation.deviceScaleFactor', etc)`);
   }

package/lighthouse-cli/run.js

@@ -232,6 +232,10 @@ async function runLighthouse(url, flags, config) {
   let launchedChrome;
 
   try {
+    if (url && flags.auditMode && !flags.gatherMode) {
+      log.warn('CLI', 'URL parameter is ignored if -A flag is used without -G flag');
+    }
+
     const shouldGather = flags.gatherMode || flags.gatherMode === flags.auditMode;
     const shouldUseLocalChrome = URL.isLikeLocalhost(flags.hostname);
     if (shouldGather && shouldUseLocalChrome) {
@@ -254,7 +258,7 @@ async function runLighthouse(url, flags, config) {
     // Runtime errors indicate something was *very* wrong with the page result.
     // We don't want the user to have to parse the report to figure it out, so we'll still exit
     // with an error code after we saved the results.
-    if (runnerResult && runnerResult.lhr.runtimeError) {
+    if (runnerResult?.lhr.runtimeError) {
       const {runtimeError} = runnerResult.lhr;
       return printErrorAndExit({
         name: 'LHError',

package/lighthouse-cli/test/smokehouse/frontends/smokehouse-bin.js

@@ -36,6 +36,7 @@ const coreTestDefnsPath =
 const runnerPaths = {
   cli: '../lighthouse-runners/cli.js',
   bundle: '../lighthouse-runners/bundle.js',
+  devtools: '../lighthouse-runners/devtools.js',
 };
 
 /**
@@ -151,7 +152,7 @@ async function begin() {
       },
       'runner': {
         default: 'cli',
-        choices: ['cli', 'bundle'],
+        choices: ['cli', 'bundle', 'devtools'],
         describe: 'The method of running Lighthouse',
       },
       'tests-path': {
@@ -174,7 +175,8 @@ async function begin() {
 
   // Augmenting yargs type with auto-camelCasing breaks in tsc@4.1.2 and @types/yargs@15.0.11,
   // so for now cast to add yarg's camelCase properties to type.
-  const argv = /** @type {typeof rawArgv & CamelCasify<typeof rawArgv>} */ (rawArgv);
+  const argv =
+    /** @type {Awaited<typeof rawArgv> & CamelCasify<Awaited<typeof rawArgv>>} */ (rawArgv);
 
   const jobs = Number.isFinite(argv.jobs) ? argv.jobs : undefined;
   const retries = Number.isFinite(argv.retries) ? argv.retries : undefined;

package/lighthouse-cli/test/smokehouse/lighthouse-runners/cli.js

@@ -133,7 +133,7 @@ async function internalRun(url, tmpPath, configJson, options) {
 
   // There should either be both an error exitCode and a lhr.runtimeError or neither.
   if (Boolean(exitCode) !== Boolean(lhr.runtimeError)) {
-    const runtimeErrorCode = lhr.runtimeError && lhr.runtimeError.code;
+    const runtimeErrorCode = lhr.runtimeError?.code;
     throw new ChildProcessError(`Lighthouse did not exit with an error correctly, exiting with ${exitCode} but with runtimeError '${runtimeErrorCode}'`, // eslint-disable-line max-len
         localConsole.getLog());
   }

package/lighthouse-cli/test/smokehouse/lighthouse-runners/devtools.js

@@ -0,0 +1,103 @@
+/**
+ * @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.
+ */
+'use strict';
+
+/**
+ * @fileoverview A runner that launches Chrome and executes Lighthouse via DevTools.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import {spawn} from 'child_process';
+
+import {LH_ROOT} from '../../../../root.js';
+
+const devtoolsDir =
+  process.env.DEVTOOLS_PATH || `${LH_ROOT}/.tmp/chromium-web-tests/devtools/devtools-frontend`;
+
+/**
+ * @param {string} command
+ * @param {string[]} args
+ */
+async function spawnAndLog(command, args) {
+  let log = '';
+
+  /** @type {Promise<void>} */
+  const promise = new Promise((resolve, reject) => {
+    const spawnHandle = spawn(command, args);
+    spawnHandle.on('close', code => {
+      if (code === 0) resolve();
+      else reject(new Error(`Command exited with code ${code}`));
+    });
+    spawnHandle.on('error', reject);
+    spawnHandle.stdout.on('data', data => {
+      console.log(data.toString());
+      log += `STDOUT: ${data.toString()}`;
+    });
+    spawnHandle.stderr.on('data', data => {
+      console.log(data.toString());
+      log += `STDERR: ${data.toString()}`;
+    });
+  });
+  await promise;
+
+  return log;
+}
+
+/** @type {Promise<void>} */
+let buildDevtoolsPromise;
+/**
+ * Download/pull latest DevTools, build Lighthouse for DevTools, roll to DevTools, and build DevTools.
+ */
+async function buildDevtools() {
+  if (process.env.CI) return;
+
+  process.env.DEVTOOLS_PATH = devtoolsDir;
+  await spawnAndLog('bash', ['lighthouse-core/test/chromium-web-tests/download-devtools.sh']);
+  await spawnAndLog('bash', ['lighthouse-core/test/chromium-web-tests/roll-devtools.sh']);
+}
+
+/**
+ * Launch Chrome and do a full Lighthouse run via DevTools.
+ * By default, the latest DevTools frontend is used (.tmp/chromium-web-tests/devtools/devtools-frontend)
+ * unless DEVTOOLS_PATH is set.
+ * CHROME_PATH determines which Chrome is used–otherwise the default is puppeteer's chrome binary.
+ * @param {string} url
+ * @param {LH.Config.Json=} configJson
+ * @param {{isDebug?: boolean}=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ */
+async function runLighthouse(url, configJson, testRunnerOptions = {}) {
+  if (!buildDevtoolsPromise) buildDevtoolsPromise = buildDevtools();
+  await buildDevtoolsPromise;
+
+  const outputDir = fs.mkdtempSync(os.tmpdir() + '/lh-smoke-cdt-runner-');
+  const args = [
+    'run-devtools',
+    url,
+    `--custom-devtools-frontend=file://${devtoolsDir}/out/Default/gen/front_end`,
+    '--output-dir', outputDir,
+  ];
+  if (configJson) {
+    args.push('--config', JSON.stringify(configJson));
+  }
+
+  const log = await spawnAndLog('yarn', args);
+  const lhr = JSON.parse(fs.readFileSync(`${outputDir}/lhr-0.json`, 'utf-8'));
+  const artifacts = JSON.parse(fs.readFileSync(`${outputDir}/artifacts-0.json`, 'utf-8'));
+
+  if (testRunnerOptions.isDebug) {
+    console.log(`${url} results saved at ${outputDir}`);
+  } else {
+    fs.rmSync(outputDir, {recursive: true, force: true});
+  }
+
+  return {lhr, artifacts, log};
+}
+
+export {
+  runLighthouse,
+};

package/lighthouse-cli/test/smokehouse/readme.md

@@ -118,14 +118,15 @@ Smokehouse Frontends                                        Lighthouse Runners
 |            |    |            |               |   <lhr   |   +--------------+
 +------------+    |            +-------+-------+          |   |              |
                   |                    ^                  +-->+   bundle.js  |
-+------------+    |                    |                      |              |
-|            |    |                    |                      +--------------+
-|   lib.js   +----+                    v
-|            |                +--------+--------+
-+------------+                |                 |
-                              |  report/assert  |
-                              |                 |
-                              +-----------------+
++------------+    |                    |                  |   |              |
+|            |    |                    |                  |   +--------------+
+|   lib.js   +----+                    v                  |
+|            |                +--------+--------+         |
++------------+                |                 |         |   +--------------+
+                              |  report/assert  |         |   |              |
+                              |                 |         +-->+  devtools.js |
+                              +-----------------+             |              |
+                                                              +--------------+
 ```
 
 ### Smokehouse frontends
@@ -142,6 +143,7 @@ Smokehouse Frontends                                        Lighthouse Runners
 
 - `lighthouse-runners/cli.js` - the original test runner, exercising the Lighthouse CLI from command-line argument parsing to the results written to disk on completion.
 - `lighthouse-runners/bundle.js` - a smoke test runner that operates on an already-bundled version of Lighthouse for end-to-end testing of that version.
+- `lighthouse-runners/devtools.js` - a smoke test runner that operates on Lighthouse running from inside DevTools.
 
 ## Custom smoke tests (for plugins et al.)
 

package/lighthouse-cli/test/smokehouse/report-assert.js

@@ -162,7 +162,7 @@ function makeComparison(name, actualResult, expectedResult) {
  */
 function pruneExpectations(localConsole, lhr, expected, reportOptions) {
   const isFraggleRock = lhr.configSettings.channel === 'fraggle-rock-cli';
-  const isBundled = reportOptions && reportOptions.isBundled;
+  const isBundled = reportOptions?.isBundled;
 
   /**
    * Lazily compute the Chrome version because some reports are explicitly asserting error conditions.

package/lighthouse-cli/test/smokehouse/smokehouse.js

@@ -32,7 +32,7 @@
  * @property {Run[]} runs
  */
 
-import {strict as assert} from 'assert';
+import assert from 'assert';
 
 import log from 'lighthouse-logger';
 
@@ -244,7 +244,7 @@ function getShardedDefinitions(testDefns, shardArg) {
   // eslint-disable-next-line max-len
   const errorMessage = `'shard' must be of the form 'n/d' and n and d must be positive integers with 1 ≤ n ≤ d. Got '${shardArg}'`;
   const match = /^(?<shardNumber>\d+)\/(?<shardTotal>\d+)$/.exec(shardArg);
-  assert(match && match.groups, errorMessage);
+  assert(match?.groups, errorMessage);
   const shardNumber = Number(match.groups.shardNumber);
   const shardTotal = Number(match.groups.shardTotal);
   assert(shardNumber > 0 && Number.isInteger(shardNumber), errorMessage);
@@ -267,15 +267,14 @@ function getShardedDefinitions(testDefns, shardArg) {
     shards.push(testDefns.slice(index, index + shardSize));
     index += shardSize;
   }
-  assert.equal(shards.length, shardTotal);
-  assert.deepEqual(shards.flat(), testDefns);
+  assert.strictEqual(shards.length, shardTotal);
+  assert.deepStrictEqual(shards.flat(), testDefns);
 
   const shardDefns = shards[shardNumber - 1];
   console.log(`In this shard (${shardArg}), running: ${shardDefns.map(d => d.id).join(' ')}\n`);
   return shardDefns;
 }
 
-
 export {
   runSmokehouse,
   getShardedDefinitions,

package/lighthouse-core/audits/accessibility/axe-audit.js

@@ -47,7 +47,7 @@ class AxeAudit extends Audit {
     // If aXe reports an error, then bubble it up to the caller
     const incomplete = artifacts.Accessibility.incomplete || [];
     const incompleteResult = incomplete.find(result => result.id === this.meta.id);
-    if (incompleteResult && incompleteResult.error) {
+    if (incompleteResult?.error) {
       return {
         score: null,
         errorMessage: `axe-core Error: ${incompleteResult.error.message || 'Unknown error'}`,
@@ -58,8 +58,8 @@ class AxeAudit extends Audit {
     const violations = artifacts.Accessibility.violations || [];
     const failureCases = isInformative ? violations.concat(incomplete) : violations;
     const rule = failureCases.find(result => result.id === this.meta.id);
-    const impact = rule && rule.impact;
-    const tags = rule && rule.tags;
+    const impact = rule?.impact;
+    const tags = rule?.tags;
 
     // Handle absence of aXe failure results for informative rules as 'not applicable'
     // This scenario indicates that no action is required by the web property owner
@@ -73,7 +73,7 @@ class AxeAudit extends Audit {
 
     /** @type {LH.Audit.Details.Table['items']}>} */
     let items = [];
-    if (rule && rule.nodes) {
+    if (rule?.nodes) {
       items = rule.nodes.map(axeNode => ({
         node: {
           ...Audit.makeNodeItem(axeNode.node),

package/lighthouse-core/audits/accessibility/object-alt.js

@@ -15,11 +15,11 @@ const i18n = require('../../lib/i18n/i18n.js');
 
 const UIStrings = {
   /** Title of an accesibility audit that evaluates if all object elements have an alt HTML attribute that describes their contents. This title is descriptive of the successful state and is shown to users when no user action is required. */
-  title: '`<object>` elements have `[alt]` text',
+  title: '`<object>` elements have alternate text',
   /** Title of an accesibility audit that evaluates if all object elements have an alt HTML attribute that describes their contents. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
-  failureTitle: '`<object>` elements do not have `[alt]` text',
+  failureTitle: '`<object>` elements do not have alternate text',
   /** Description of a Lighthouse audit that tells the user *why* they should try to pass. This is displayed after a user expands the section to see more. No character length limits. 'Learn More' becomes link text to additional documentation. */
-  description: 'Screen readers cannot translate non-text content. Adding alt text to ' +
+  description: 'Screen readers cannot translate non-text content. Adding alternate text to ' +
       '`<object>` elements helps screen readers convey meaning to users. ' +
       '[Learn more](https://web.dev/object-alt/).',
 };

package/lighthouse-core/audits/audit.js

@@ -73,13 +73,28 @@ class Audit {
    * considering a log-normal distribution governed by two control points (the 10th
    * percentile value and the median value) and represents the percentage of sites that are
    * greater than `value`.
+   *
+   * Score characteristics:
+   * - within [0, 1]
+   * - rounded to two digits
+   * - value must meet or beat a controlPoint value to meet or exceed its percentile score:
+   *   - value > median will give a score < 0.5; value ≤ median will give a score ≥ 0.5.
+   *   - value > p10 will give a score < 0.9; value ≤ p10 will give a score ≥ 0.9.
+   * - values < p10 will get a slight boost so a score of 1 is achievable by a
+   *   `value` other than those close to 0. Scores of > ~0.99524 end up rounded to 1.
    * @param {{median: number, p10: number}} controlPoints
    * @param {number} value
    * @return {number}
    */
   static computeLogNormalScore(controlPoints, value) {
-    const percentile = statistics.getLogNormalScore(controlPoints, value);
-    return clampTo2Decimals(percentile);
+    let percentile = statistics.getLogNormalScore(controlPoints, value);
+    // Add a boost to scores of 90+, linearly ramping from 0 at 0.9 to half a
+    // point (0.005) at 1. Expands scores in (0.9, 1] to (0.9, 1.005], so more top
+    // scores will be a perfect 1 after the two-digit `Math.floor()` rounding below.
+    if (percentile > 0.9) { // getLogNormalScore ensures `percentile` can't exceed 1.
+      percentile += 0.05 * (percentile - 0.9);
+    }
+    return Math.floor(percentile * 100) / 100;
   }
 
   /**
@@ -360,8 +375,8 @@ class Audit {
 
       score,
       scoreDisplayMode,
-      numericValue: numericProduct && numericProduct.numericValue,
-      numericUnit: numericProduct && numericProduct.numericUnit,
+      numericValue: numericProduct?.numericValue,
+      numericUnit: numericProduct?.numericUnit,
 
       displayValue: product.displayValue,
       explanation: product.explanation,

package/lighthouse-core/audits/byte-efficiency/byte-efficiency-audit.js

@@ -109,7 +109,7 @@ class UnusedBytes extends Audit {
     const gatherContext = artifacts.GatherContext;
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
-    const settings = context && context.settings || {};
+    const settings = context?.settings || {};
     const simulatorOptions = {
       devtoolsLog,
       settings,

package/lighthouse-core/audits/byte-efficiency/duplicated-javascript.js

@@ -127,7 +127,7 @@ class DuplicatedJavascript extends ByteEfficiencyAudit {
    */
   static async audit_(artifacts, networkRecords, context) {
     const ignoreThresholdInBytes =
-      context.options && context.options.ignoreThresholdInBytes || IGNORE_THRESHOLD_IN_BYTES;
+      context.options?.ignoreThresholdInBytes || IGNORE_THRESHOLD_IN_BYTES;
     const duplication =
       await DuplicatedJavascript._getDuplicationGroupedByNodeModules(artifacts, context);
     const mainDocumentRecord = NetworkAnalyzer.findOptionalMainDocument(networkRecords);

package/lighthouse-core/audits/deprecations.js

@@ -62,8 +62,8 @@ class Deprecations extends Audit {
     const bundles = await JsBundles.request(artifacts, context);
 
     let deprecations;
-    if (artifacts.InspectorIssues.deprecations.length) {
-      deprecations = artifacts.InspectorIssues.deprecations
+    if (artifacts.InspectorIssues.deprecationIssue.length) {
+      deprecations = artifacts.InspectorIssues.deprecationIssue
         .map(deprecation => {
           const {url, lineNumber, columnNumber} = deprecation.sourceCodeLocation;
           const bundle = bundles.find(bundle => bundle.script.src === url);

package/lighthouse-core/audits/dobetterweb/inspector-issues.js

@@ -58,7 +58,7 @@ class IssuesPanelEntries extends Audit {
   static getMixedContentRow(mixedContentIssues) {
     const requestUrls = new Set();
     for (const issue of mixedContentIssues) {
-      const requestUrl = (issue.request && issue.request.url) || issue.mainResourceURL;
+      const requestUrl = issue.request?.url || issue.mainResourceURL;
       requestUrls.add(requestUrl);
     }
     return {
@@ -77,7 +77,7 @@ class IssuesPanelEntries extends Audit {
   static getSameSiteCookieRow(sameSiteCookieIssues) {
     const requestUrls = new Set();
     for (const issue of sameSiteCookieIssues) {
-      const requestUrl = (issue.request && issue.request.url) || issue.cookieUrl;
+      const requestUrl = (issue.request?.url) || issue.cookieUrl;
       if (requestUrl) {
         requestUrls.add(requestUrl);
       }
@@ -102,7 +102,7 @@ class IssuesPanelEntries extends Audit {
   static getBlockedByResponseRow(blockedByResponseIssues) {
     const requestUrls = new Set();
     for (const issue of blockedByResponseIssues) {
-      const requestUrl = issue.request && issue.request.url;
+      const requestUrl = issue.request?.url;
       if (requestUrl) {
         requestUrls.add(requestUrl);
       }
@@ -161,19 +161,19 @@ class IssuesPanelEntries extends Audit {
     /** @type LH.Audit.Details.TableItem[] */
     const items = [];
 
-    if (issues.mixedContent.length) {
-      items.push(this.getMixedContentRow(issues.mixedContent));
+    if (issues.mixedContentIssue.length) {
+      items.push(this.getMixedContentRow(issues.mixedContentIssue));
     }
-    if (issues.sameSiteCookies.length) {
-      items.push(this.getSameSiteCookieRow(issues.sameSiteCookies));
+    if (issues.sameSiteCookieIssue.length) {
+      items.push(this.getSameSiteCookieRow(issues.sameSiteCookieIssue));
     }
-    if (issues.blockedByResponse.length) {
-      items.push(this.getBlockedByResponseRow(issues.blockedByResponse));
+    if (issues.blockedByResponseIssue.length) {
+      items.push(this.getBlockedByResponseRow(issues.blockedByResponseIssue));
     }
-    if (issues.heavyAds.length) {
+    if (issues.heavyAdIssue.length) {
       items.push({issueType: str_(UIStrings.issueTypeHeavyAds)});
     }
-    const cspIssues = issues.contentSecurityPolicy.filter(issue => {
+    const cspIssues = issues.contentSecurityPolicyIssue.filter(issue => {
       // kTrustedTypesSinkViolation and kTrustedTypesPolicyViolation aren't currently supported by the Issues panel
       return issue.contentSecurityPolicyViolationType !== 'kTrustedTypesSinkViolation' &&
         issue.contentSecurityPolicyViolationType !== 'kTrustedTypesPolicyViolation';

package/lighthouse-core/audits/dobetterweb/uses-http2.js

@@ -227,7 +227,7 @@ class UsesHTTP2Audit extends Audit {
       };
     }
 
-    const settings = context && context.settings || {};
+    const settings = context?.settings || {};
     const simulatorOptions = {
       devtoolsLog,
       settings,

package/lighthouse-core/audits/font-display.js

@@ -79,7 +79,7 @@ class FontDisplay extends Audit {
         // Find the font-display value by matching a single token, optionally surrounded by whitespace,
         // followed either by a semicolon or the end of a block.
         const fontDisplayMatch = declaration.match(/font-display\s*:\s*(\w+)\s*(;|\})/);
-        const rawFontDisplay = (fontDisplayMatch && fontDisplayMatch[1]) || '';
+        const rawFontDisplay = fontDisplayMatch?.[1] || '';
         const hasPassingFontDisplay = passingFontDisplayRegex.test(rawFontDisplay);
         const targetURLSet = hasPassingFontDisplay ? passingURLs : failingURLs;
 

package/lighthouse-core/audits/installable-manifest.js

@@ -169,7 +169,7 @@ class InstallableManifest extends Audit {
        * If there is an argument value, get it.
        * We only expect a `minimum-icon-size-in-pixels` errorArg[0] for two errorIds, currently.
        */
-      const value0 = err.errorArguments && err.errorArguments.length && err.errorArguments[0].value;
+      const value0 = err.errorArguments?.length && err.errorArguments[0].value;
 
       if (matchingString && err.errorArguments.length !== UIStringArguments.length) {
         // Matching string, but have the incorrect number of arguments for the message.

package/lighthouse-core/audits/is-on-https.js

@@ -87,7 +87,7 @@ class HTTPS extends Audit {
         {key: 'resolution', itemType: 'text', text: str_(UIStrings.columnResolution)},
       ];
 
-      for (const details of artifacts.InspectorIssues.mixedContent) {
+      for (const details of artifacts.InspectorIssues.mixedContentIssue) {
         let item = items.find(item => item.url === details.insecureURL);
         if (!item) {
           item = {url: details.insecureURL};

package/lighthouse-core/audits/maskable-icon.js

@@ -62,7 +62,7 @@ class MaskableIcon extends Audit {
     }
     const maskableIconCheck = manifestValues.allChecks.find(i => i.id === 'hasMaskableIcon');
     return {
-      score: (maskableIconCheck && maskableIconCheck.passing) ? 1 : 0,
+      score: maskableIconCheck?.passing ? 1 : 0,
     };
   }
 }

package/lighthouse-core/audits/multi-check-audit.js

@@ -35,7 +35,7 @@ class MultiCheckAudit extends Audit {
       allChecks: undefined,
     };
 
-    if (result.manifestValues && result.manifestValues.allChecks) {
+    if (result.manifestValues?.allChecks) {
       result.manifestValues.allChecks.forEach(check => {
         detailsItem[check.id] = check.passing;
       });

package/lighthouse-core/audits/network-requests.js

@@ -41,10 +41,10 @@ class NetworkRequests extends Audit {
         undefined : (time - earliestStartTime) * 1000;
 
       const results = records.map(record => {
-        const endTimeDeltaMs = record.lrStatistics && record.lrStatistics.endTimeDeltaMs;
-        const TCPMs = record.lrStatistics && record.lrStatistics.TCPMs;
-        const requestMs = record.lrStatistics && record.lrStatistics.requestMs;
-        const responseMs = record.lrStatistics && record.lrStatistics.responseMs;
+        const endTimeDeltaMs = record.lrStatistics?.endTimeDeltaMs;
+        const TCPMs = record.lrStatistics?.TCPMs;
+        const requestMs = record.lrStatistics?.requestMs;
+        const responseMs = record.lrStatistics?.responseMs;
 
         return {
           url: URL.elideDataURI(record.url),

package/lighthouse-core/audits/preload-fonts.js

@@ -97,9 +97,8 @@ class PreloadFontsAudit extends Audit {
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit() {
-    // Preload advice is dangerous until https://bugs.chromium.org/p/chromium/issues/detail?id=788757
-    // has been fixed and validated. All preload audits are on hold until then.
-    // See https://github.com/GoogleChrome/lighthouse/issues/11960 for more discussion.
+    // Preload advice is on hold until https://github.com/GoogleChrome/lighthouse/issues/11960
+    // is resolved.
     return {score: 1, notApplicable: true};
   }
 }