lighthouse 10.3.0 → 10.4.0-dev.20230711

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

@@ -25,6 +25,8 @@ import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
 import {updateTestDefnFormat} from './back-compat-util.js';
 import {LH_ROOT} from '../../../../root.js';
 import exclusions from '../config/exclusions.js';
+import {saveArtifacts} from '../../../../core/lib/asset-saver.js';
+import {saveLhr} from '../../../../core/lib/asset-saver.js';
 
 const coreTestDefnsPath =
   path.join(LH_ROOT, 'cli/test/smokehouse/core-tests.js');
@@ -134,11 +136,6 @@ async function begin() {
         default: false,
         describe: 'Save test artifacts and output verbose logs',
       },
-      'legacy-navigation': {
-        type: 'boolean',
-        default: false,
-        describe: 'Use the legacy navigation runner',
-      },
       'jobs': {
         type: 'number',
         alias: 'j',
@@ -216,7 +213,6 @@ async function begin() {
       jobs,
       retries,
       isDebug: argv.debug,
-      useLegacyNavigation: argv.legacyNavigation,
       lighthouseRunner: runLighthouse,
       takeNetworkRequestUrls,
       setup,
@@ -227,27 +223,47 @@ async function begin() {
     servers?.forEach(s => s.close());
   }
 
+  let smokehouseOutputDir;
+  let testResultsToOutput;
   if (!smokehouseResult.success) {
-    const failedTestResults = smokehouseResult.testResults.filter(r => r.failed);
-
-    // For CI, save failed runs to directory to be uploaded.
-    if (process.env.CI) {
-      const failuresDir = `${LH_ROOT}/.tmp/smokehouse-ci-failures`;
-      fs.mkdirSync(failuresDir, {recursive: true});
-
-      for (const testResult of failedTestResults) {
-        for (let i = 0; i < testResult.runs.length; i++) {
-          const run = testResult.runs[i];
-          fs.writeFileSync(`${failuresDir}/${testResult.id}-${i}.json`, JSON.stringify({
-            ...run,
-            lighthouseLog: run.lighthouseLog.split('\n'),
-            assertionLog: run.assertionLog.split('\n'),
-          }, null, 2));
+    // Save failed runs to directory. In CI, this is uploaded as an artifact.
+    smokehouseOutputDir = `${LH_ROOT}/.tmp/smokehouse-failures`;
+    testResultsToOutput = smokehouseResult.testResults.filter(r => r.failed);
+  } else if (!process.env.CI) {
+    // Otherwise, only write to disk in debug mode.
+    smokehouseOutputDir = `${LH_ROOT}/.tmp/smokehouse-output`;
+    testResultsToOutput = smokehouseResult.testResults;
+  }
+
+  if (smokehouseOutputDir && testResultsToOutput) {
+    fs.rmSync(smokehouseOutputDir, {recursive: true, force: true});
+    fs.mkdirSync(smokehouseOutputDir);
+
+    for (const testResult of testResultsToOutput) {
+      for (let i = 0; i < testResult.runs.length; i++) {
+        const runDir = `${smokehouseOutputDir}/${i}/${testResult.id}`;
+        fs.mkdirSync(runDir, {recursive: true});
+
+        const run = testResult.runs[i];
+        await saveArtifacts(run.artifacts, runDir);
+        await saveLhr(run.lhr, runDir);
+        fs.writeFileSync(`${runDir}/assertionLog.txt`, run.assertionLog);
+        fs.writeFileSync(`${runDir}/lighthouseLog.txt`, run.lighthouseLog);
+        if (run.networkRequests) {
+          fs.writeFileSync(`${runDir}/networkRequests.txt`, run.networkRequests.join('\n'));
+        }
+        const config = testDefns.find(test => test.id === testResult.id)?.config;
+        if (config) {
+          fs.writeFileSync(`${runDir}/config.json`, JSON.stringify(config, null, 2));
         }
       }
     }
 
-    const cmd = `yarn smoke ${failedTestResults.map(r => r.id).join(' ')}`;
+    console.log(`smokehouse artifacts written to ${smokehouseOutputDir}`);
+  }
+
+  if (!smokehouseResult.success && testResultsToOutput) {
+    const cmd = `yarn smoke ${testResultsToOutput.map(r => r.id).join(' ')}`;
     console.log(`rerun failures: ${cmd}`);
   }
 

package/cli/test/smokehouse/lighthouse-runners/bundle.d.ts

@@ -2,12 +2,11 @@
  * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
     isDebug?: boolean;
-    useLegacyNavigation?: boolean;
 } | undefined): Promise<{
     lhr: LH.Result;
     artifacts: LH.Artifacts;

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

@@ -19,7 +19,6 @@ import {once} from 'events';
 import puppeteer from 'puppeteer-core';
 import ChromeLauncher from 'chrome-launcher';
 
-import {CriConnection} from '../../../../core/legacy/gather/connections/cri.js';
 import {LH_ROOT} from '../../../../root.js';
 import {loadArtifacts, saveArtifacts} from '../../../../core/lib/asset-saver.js';
 
@@ -39,7 +38,7 @@ if (!isMainThread && parentPort) {
       parentPort?.postMessage({type: 'result', value});
     } catch (err) {
       console.error(err);
-      parentPort?.postMessage({type: 'error', value: err});
+      parentPort?.postMessage({type: 'error', value: err.toString()});
     }
   })();
 }
@@ -47,7 +46,7 @@ if (!isMainThread && parentPort) {
 /**
  * @param {string} url
  * @param {LH.Config|undefined} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}} testRunnerOptions
+ * @param {{isDebug?: boolean}} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts}>}
  */
 async function runBundledLighthouse(url, config, testRunnerOptions) {
@@ -72,28 +71,18 @@ async function runBundledLighthouse(url, config, testRunnerOptions) {
   // @ts-expect-error - not worth giving test global an actual type.
   const lighthouse = global.runBundledLighthouse;
 
-  /** @type {import('../../../../core/index.js')['legacyNavigation']} */
-  // @ts-expect-error - not worth giving test global an actual type.
-  const legacyNavigation = global.runBundledLighthouseLegacyNavigation;
-
   // Launch and connect to Chrome.
   const launchedChrome = await ChromeLauncher.launch();
   const port = launchedChrome.port;
 
   // Run Lighthouse.
   try {
-    const logLevel = testRunnerOptions.isDebug ? 'info' : undefined;
-    let runnerResult;
-    if (testRunnerOptions.useLegacyNavigation) {
-      const connection = new CriConnection(port);
-      runnerResult =
-        await legacyNavigation(url, {port, logLevel}, config, connection);
-    } else {
-      // Puppeteer is not included in the bundle, we must create the page here.
-      const browser = await puppeteer.connect({browserURL: `http://localhost:${port}`});
-      const page = await browser.newPage();
-      runnerResult = await lighthouse(url, {port, logLevel}, config, page);
-    }
+    const logLevel = testRunnerOptions.isDebug ? 'verbose' : 'info';
+
+    // Puppeteer is not included in the bundle, we must create the page here.
+    const browser = await puppeteer.connect({browserURL: `http://localhost:${port}`});
+    const page = await browser.newPage();
+    const runnerResult = await lighthouse(url, {port, logLevel}, config, page);
     if (!runnerResult) throw new Error('No runnerResult');
 
     return {
@@ -110,7 +99,7 @@ async function runBundledLighthouse(url, config, testRunnerOptions) {
  * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function runLighthouse(url, config, testRunnerOptions = {}) {
@@ -124,12 +113,10 @@ async function runLighthouse(url, config, testRunnerOptions = {}) {
   worker.stdout.setEncoding('utf8');
   worker.stderr.setEncoding('utf8');
   worker.stdout.addListener('data', (data) => {
-    process.stdout.write(data);
-    logs.push(`STDOUT: ${data}`);
+    logs.push(`[STDOUT] ${data}`);
   });
   worker.stderr.addListener('data', (data) => {
-    process.stderr.write(data);
-    logs.push(`STDERR: ${data}`);
+    logs.push(`[STDERR] ${data}`);
   });
   const [workerResponse] = await once(worker, 'message');
   const log = logs.join('') + '\n';

package/cli/test/smokehouse/lighthouse-runners/cli.d.ts

@@ -3,12 +3,11 @@
  * Launch Chrome and do a full Lighthouse run via the Lighthouse CLI.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useFraggleRock?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
     isDebug?: boolean | undefined;
-    useFraggleRock?: boolean | undefined;
 } | undefined): Promise<{
     lhr: LH.Result;
     artifacts: LH.Artifacts;

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

@@ -28,7 +28,7 @@ const execFileAsync = promisify(execFile);
  * Launch Chrome and do a full Lighthouse run via the Lighthouse CLI.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useFraggleRock?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function runLighthouse(url, config, testRunnerOptions = {}) {
@@ -46,11 +46,11 @@ async function runLighthouse(url, config, testRunnerOptions = {}) {
  * @param {string} url
  * @param {string} tmpPath
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} options
+ * @param {{isDebug?: boolean}=} options
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function internalRun(url, tmpPath, config, options) {
-  const {isDebug = false, useLegacyNavigation = false} = options || {};
+  const {isDebug = false} = options || {};
   const localConsole = new LocalConsole();
 
   const outputPath = `${tmpPath}/smokehouse.report.json`;
@@ -67,10 +67,6 @@ async function internalRun(url, tmpPath, config, options) {
     '--quiet',
   ];
 
-  if (useLegacyNavigation) {
-    args.push('--legacy-navigation');
-  }
-
   // Config can be optionally provided.
   if (config) {
     const configPath = `${tmpPath}/config.json`;

package/cli/test/smokehouse/lighthouse-runners/devtools.d.ts

@@ -5,12 +5,11 @@
  * CHROME_PATH determines which Chrome is used–otherwise the default is puppeteer's chrome binary.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
     isDebug?: boolean;
-    useLegacyNavigation?: boolean;
 } | undefined): Promise<{
     lhr: LH.Result;
     artifacts: LH.Artifacts;

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

@@ -8,8 +8,6 @@
  * @fileoverview A runner that launches Chrome and executes Lighthouse via DevTools.
  */
 
-import fs from 'fs';
-import os from 'os';
 import {execFileSync} from 'child_process';
 
 import {LH_ROOT} from '../../../../root.js';
@@ -42,7 +40,7 @@ async function setup() {
  * CHROME_PATH determines which Chrome is used–otherwise the default is puppeteer's chrome binary.
  * @param {string} url
  * @param {LH.Config=} config
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @param {{isDebug?: boolean}=} testRunnerOptions
  * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
  */
 async function runLighthouse(url, config, testRunnerOptions = {}) {
@@ -52,16 +50,8 @@ async function runLighthouse(url, config, testRunnerOptions = {}) {
   const {lhr, artifacts, logs} = await testUrlFromDevtools(url, {
     config,
     chromeFlags,
-    useLegacyNavigation: testRunnerOptions.useLegacyNavigation,
   });
 
-  if (testRunnerOptions.isDebug) {
-    const outputDir = fs.mkdtempSync(os.tmpdir() + '/lh-smoke-cdt-runner-');
-    fs.writeFileSync(`${outputDir}/lhr.json`, JSON.stringify(lhr));
-    fs.writeFileSync(`${outputDir}/artifacts.json`, JSON.stringify(artifacts));
-    console.log(`${url} results saved at ${outputDir}`);
-  }
-
   const log = logs.join('') + '\n';
   return {lhr, artifacts, log};
 }

package/cli/test/smokehouse/readme.md

@@ -118,8 +118,6 @@ All pruning checks:
 
 - `_minChromiumVersion`
 - `_maxChromiumVersion`
-- `_legacyOnly`
-- `_fraggleRockOnly`
 - `_runner` (set to same value provided to CLI --runner flag, ex: `'devtools'`)
 - `_excludeRunner` (set to same value provided to CLI --runner flag, ex: `'devtools'`)
 

package/cli/test/smokehouse/report-assert.d.ts

@@ -16,7 +16,7 @@ export type Comparison = {
  * summary. Returns count of passed and failed tests.
  * @param {{lhr: LH.Result, artifacts: LH.Artifacts, networkRequests?: string[]}} actual
  * @param {Smokehouse.ExpectedRunnerResult} expected
- * @param {{runner?: string, isDebug?: boolean, useLegacyNavigation?: boolean}=} reportOptions
+ * @param {{runner?: string, isDebug?: boolean}=} reportOptions
  * @return {{passed: number, failed: number, log: string}}
  */
 export function getAssertionReport(actual: {
@@ -26,7 +26,6 @@ export function getAssertionReport(actual: {
 }, expected: Smokehouse.ExpectedRunnerResult, reportOptions?: {
     runner?: string;
     isDebug?: boolean;
-    useLegacyNavigation?: boolean;
 } | undefined): {
     passed: number;
     failed: number;

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

@@ -237,11 +237,9 @@ function makeComparison(name, actualResult, expectedResult) {
  * @param {LocalConsole} localConsole
  * @param {LH.Result} lhr
  * @param {Smokehouse.ExpectedRunnerResult} expected
- * @param {{runner?: string, useLegacyNavigation?: boolean}=} reportOptions
+ * @param {{runner?: string}=} reportOptions
  */
 function pruneExpectations(localConsole, lhr, expected, reportOptions) {
-  const isLegacyNavigation = reportOptions?.useLegacyNavigation;
-
   /**
    * Lazily compute the Chrome version because some reports are explicitly asserting error conditions.
    * @returns {string}
@@ -295,19 +293,6 @@ function pruneExpectations(localConsole, lhr, expected, reportOptions) {
           `Actual Chromium version: ${getChromeVersionString()}`,
         ].join(' '));
         remove(key);
-      } else if (value._legacyOnly && !isLegacyNavigation) {
-        localConsole.log([
-          `[${key}] marked legacy only but run is Fraggle Rock, pruning expectation:`,
-          JSON.stringify(value, null, 2),
-        ].join(' '));
-        remove(key);
-      } else if (value._fraggleRockOnly && isLegacyNavigation) {
-        localConsole.log([
-          `[${key}] marked Fraggle Rock only but run is legacy, pruning expectation:`,
-          JSON.stringify(value, null, 2),
-          `Actual channel: ${lhr.configSettings.channel}`,
-        ].join(' '));
-        remove(key);
       } else if (value._runner && reportOptions?.runner !== value._runner) {
         localConsole.log([
           `[${key}] is only for runner ${value._runner}, pruning expectation:`,
@@ -325,8 +310,6 @@ function pruneExpectations(localConsole, lhr, expected, reportOptions) {
       }
     }
 
-    delete obj._legacyOnly;
-    delete obj._fraggleRockOnly;
     delete obj._skipInBundled;
     delete obj._minChromiumVersion;
     delete obj._maxChromiumVersion;
@@ -483,7 +466,7 @@ function reportAssertion(localConsole, assertion) {
  * summary. Returns count of passed and failed tests.
  * @param {{lhr: LH.Result, artifacts: LH.Artifacts, networkRequests?: string[]}} actual
  * @param {Smokehouse.ExpectedRunnerResult} expected
- * @param {{runner?: string, isDebug?: boolean, useLegacyNavigation?: boolean}=} reportOptions
+ * @param {{runner?: string, isDebug?: boolean}=} reportOptions
  * @return {{passed: number, failed: number, log: string}}
  */
 function getAssertionReport(actual, expected, reportOptions = {}) {

package/cli/test/smokehouse/smokehouse.js

@@ -53,7 +53,6 @@ const DEFAULT_RETRIES = 0;
 async function runSmokehouse(smokeTestDefns, smokehouseOptions) {
   const {
     isDebug,
-    useLegacyNavigation,
     jobs = DEFAULT_CONCURRENT_RUNS,
     retries = DEFAULT_RETRIES,
     lighthouseRunner = Object.assign(cliLighthouseRunner, {runnerName: 'cli'}),
@@ -76,7 +75,6 @@ async function runSmokehouse(smokeTestDefns, smokehouseOptions) {
 
   const testOptions = {
     isDebug,
-    useLegacyNavigation,
     retries,
     lighthouseRunner,
     takeNetworkRequestUrls,
@@ -133,39 +131,18 @@ function purpleify(str) {
   return `${log.purple}${str}${log.reset}`;
 }
 
-/**
- * @param {LH.Config=} config
- * @return {LH.Config|undefined}
- */
-function convertToLegacyConfig(config) {
-  if (!config) return config;
-
-  return {
-    ...config,
-    passes: [{
-      passName: 'defaultPass',
-      pauseAfterFcpMs: config.settings?.pauseAfterFcpMs,
-      pauseAfterLoadMs: config.settings?.pauseAfterLoadMs,
-      networkQuietThresholdMs: config.settings?.networkQuietThresholdMs,
-      cpuQuietThresholdMs: config.settings?.cpuQuietThresholdMs,
-      blankPage: config.settings?.blankPage,
-    }],
-  };
-}
-
 /**
  * Run Lighthouse in the selected runner.
  * @param {Smokehouse.TestDfn} smokeTestDefn
- * @param {{isDebug?: boolean, useLegacyNavigation?: boolean, retries: number, lighthouseRunner: Smokehouse.LighthouseRunner, takeNetworkRequestUrls?: () => string[]}} testOptions
+ * @param {{isDebug?: boolean, retries: number, lighthouseRunner: Smokehouse.LighthouseRunner, takeNetworkRequestUrls?: () => string[]}} testOptions
  * @return {Promise<SmokehouseResult>}
  */
 async function runSmokeTest(smokeTestDefn, testOptions) {
-  const {id, expectations} = smokeTestDefn;
+  const {id, expectations, config} = smokeTestDefn;
   const {
     lighthouseRunner,
     retries,
     isDebug,
-    useLegacyNavigation,
     takeNetworkRequestUrls,
   } = testOptions;
   const requestedUrl = expectations.lhr.requestedUrl;
@@ -184,15 +161,10 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
       bufferedConsole.log(`  Retrying run (${i} out of ${retries} retries)…`);
     }
 
-    let config = smokeTestDefn.config;
-    if (useLegacyNavigation) {
-      config = convertToLegacyConfig(config);
-    }
-
     // Run Lighthouse.
     try {
       result = {
-        ...await lighthouseRunner(requestedUrl, config, {isDebug, useLegacyNavigation}),
+        ...await lighthouseRunner(requestedUrl, config, {isDebug}),
         networkRequests: takeNetworkRequestUrls ? takeNetworkRequestUrls() : undefined,
       };
 
@@ -213,7 +185,6 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
     report = getAssertionReport(result, expectations, {
       runner: lighthouseRunner.runnerName,
       isDebug,
-      useLegacyNavigation,
     });
 
     runs.push({

package/core/audits/accessibility/aria-dialog-name.d.ts

@@ -0,0 +1,10 @@
+export default AriaDialogName;
+declare class AriaDialogName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-dialog-name.d.ts.map

package/core/audits/accessibility/aria-dialog-name.js

@@ -0,0 +1,45 @@
+/**
+ * @license Copyright 2023 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 Ensures every ARIA dialog element has a discernable, accessible name.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accessibility audit that evaluates if ARIA dialog elements have an accessible name. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Elements with `role="dialog"` or `role="alertdialog"` have accessible names.',
+  /** Title of an accessibility audit that evaluates if ARIA dialog elements do not have accessible names. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Elements with `role="dialog"` or `role="alertdialog"` do not have accessible ' +
+      'names.',
+  /** Description of a Lighthouse audit that tells the user *why* they should have accessible names for ARIA dialog elements. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'ARIA dialog elements without accessible names may prevent screen readers users ' +
+      'from discerning the purpose of these elements. ' +
+      '[Learn how to make ARIA dialog elements more accessible](https://dequeuniversity.com/rules/axe/4.7/aria-dialog-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaDialogName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-dialog-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaDialogName;
+export {UIStrings};

package/core/audits/accessibility/aria-text.d.ts

@@ -0,0 +1,10 @@
+export default AriaText;
+declare class AriaText extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-text.d.ts.map

package/core/audits/accessibility/aria-text.js

@@ -0,0 +1,44 @@
+/**
+ * @license Copyright 2023 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 Ensures all elements with `role=text` have no focusable descendents.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if elements with `role=text` have no focusable descendents. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Elements with the `role=text` attribute do not have focusable descendents.',
+  /** Title of an accesibility audit that evaluates if elements with `role=text` have focusable descendents. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  failureTitle: 'Elements with the `role=text` attribute do have focusable descendents.',
+  /** 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. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Adding `role=text` around a text node split by markup enables VoiceOver to treat ' +
+      'it as one phrase, but the element\'s focusable descendents will not be announced. ' +
+      '[Learn more about the `role=text` attribute](https://dequeuniversity.com/rules/axe/4.7/aria-text).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaText extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-text',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaText;
+export {UIStrings};

package/core/audits/accessibility/empty-heading.d.ts

@@ -0,0 +1,10 @@
+export default EmptyHeading;
+declare class EmptyHeading extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=empty-heading.d.ts.map

package/core/audits/accessibility/empty-heading.js

@@ -0,0 +1,45 @@
+/**
+ * @license Copyright 2023 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 Ensures that headings are not empty.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if all heading elements have content. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'All heading elements contain content.',
+  /** Title of an accesibility audit that checks if all heading elements have content. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Heading elements do not contain content.',
+  /** 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. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'A heading with no content or inaccessible text prevent screen reader users from ' +
+      'accessing information on the page\'s structure. ' +
+      '[Learn more about headings](https://dequeuniversity.com/rules/axe/4.7/empty-heading).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class EmptyHeading extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'empty-heading',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: AxeAudit.SCORING_MODES.INFORMATIVE,
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default EmptyHeading;
+export {UIStrings};

package/core/audits/accessibility/identical-links-same-purpose.d.ts

@@ -0,0 +1,10 @@
+export default IdenticalLinksSamePurpose;
+declare class IdenticalLinksSamePurpose extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=identical-links-same-purpose.d.ts.map