lighthouse 9.6.8 → 10.0.0-dev.20230209

package/cli/test/smokehouse/smokehouse.js

@@ -0,0 +1,336 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview An end-to-end test runner for Lighthouse. Takes a set of smoke
+ * test definitions and a method of running Lighthouse, returns whether all the
+ * smoke tests passed.
+ */
+
+/* eslint-disable no-console */
+
+/** @typedef {import('./lib/child-process-error.js').ChildProcessError} ChildProcessError */
+
+/**
+ * @typedef Run
+ * @property {string[] | undefined} networkRequests
+ * @property {LH.Result} lhr
+ * @property {LH.Artifacts} artifacts
+ * @property {string} lighthouseLog
+ * @property {string} assertionLog
+ */
+
+/**
+ * @typedef SmokehouseResult
+ * @property {string} id
+ * @property {number} passed
+ * @property {number} failed
+ * @property {Run[]} runs
+ */
+
+import assert from 'assert/strict';
+
+import log from 'lighthouse-logger';
+
+import {runLighthouse as cliLighthouseRunner} from './lighthouse-runners/cli.js';
+import {getAssertionReport} from './report-assert.js';
+import {LocalConsole} from './lib/local-console.js';
+import {ConcurrentMapper} from './lib/concurrent-mapper.js';
+
+// The number of concurrent (`!runSerially`) tests to run if `jobs` isn't set.
+const DEFAULT_CONCURRENT_RUNS = 5;
+const DEFAULT_RETRIES = 0;
+
+/**
+ * Runs the selected smoke tests. Returns whether all assertions pass.
+ * @param {Array<Smokehouse.TestDfn>} smokeTestDefns
+ * @param {Smokehouse.SmokehouseOptions} smokehouseOptions
+ * @return {Promise<{success: boolean, testResults: SmokehouseResult[]}>}
+ */
+async function runSmokehouse(smokeTestDefns, smokehouseOptions) {
+  const {
+    isDebug,
+    useLegacyNavigation,
+    jobs = DEFAULT_CONCURRENT_RUNS,
+    retries = DEFAULT_RETRIES,
+    lighthouseRunner = Object.assign(cliLighthouseRunner, {runnerName: 'cli'}),
+    takeNetworkRequestUrls,
+    setup,
+  } = smokehouseOptions;
+  assertPositiveInteger('jobs', jobs);
+  assertNonNegativeInteger('retries', retries);
+
+  try {
+    await setup?.();
+  } catch (err) {
+    console.error(log.redify('\nERROR DURING SETUP:'));
+    console.error(log.redify(err.stack || err));
+    return {success: false, testResults: []};
+  }
+
+  // Run each testDefn in parallel based on the concurrencyLimit.
+  const concurrentMapper = new ConcurrentMapper();
+
+  const testOptions = {
+    isDebug,
+    useLegacyNavigation,
+    retries,
+    lighthouseRunner,
+    takeNetworkRequestUrls,
+  };
+  const smokePromises = smokeTestDefns.map(testDefn => {
+    // If defn is set to `runSerially`, we'll run it in succession with other tests, not parallel.
+    const concurrency = testDefn.runSerially ? 1 : jobs;
+    return concurrentMapper.runInPool(() => runSmokeTest(testDefn, testOptions), {concurrency});
+  });
+  const testResults = await Promise.all(smokePromises);
+
+  // Print final summary.
+  let passingCount = 0;
+  let failingCount = 0;
+  for (const testResult of testResults) {
+    passingCount += testResult.passed;
+    failingCount += testResult.failed;
+  }
+  if (passingCount) console.log(log.greenify(`${getAssertionLog(passingCount)} passing in total`));
+  if (failingCount) console.log(log.redify(`${getAssertionLog(failingCount)} failing in total`));
+
+  // Print id(s) and fail if there were failing tests.
+  const failingDefns = testResults.filter(result => result.failed);
+  if (failingDefns.length) {
+    const testNames = failingDefns.map(d => d.id).join(', ');
+    console.log(log.redify(`We have ${failingDefns.length} failing smoketest(s): ${testNames}`));
+    return {success: false, testResults};
+  }
+
+  return {success: true, testResults};
+}
+
+/**
+ * @param {string} loggableName
+ * @param {number} value
+ */
+function assertPositiveInteger(loggableName, value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${loggableName} must be a positive integer`);
+  }
+}
+/**
+ * @param {string} loggableName
+ * @param {number} value
+ */
+function assertNonNegativeInteger(loggableName, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${loggableName} must be a non-negative integer`);
+  }
+}
+
+/** @param {string} str */
+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
+ * @return {Promise<SmokehouseResult>}
+ */
+async function runSmokeTest(smokeTestDefn, testOptions) {
+  const {id, expectations} = smokeTestDefn;
+  const {
+    lighthouseRunner,
+    retries,
+    isDebug,
+    useLegacyNavigation,
+    takeNetworkRequestUrls,
+  } = testOptions;
+  const requestedUrl = expectations.lhr.requestedUrl;
+
+  console.log(`${purpleify(id)} smoketest starting…`);
+
+  // Rerun test until there's a passing result or retries are exhausted to prevent flakes.
+  /** @type {Run[]} */
+  const runs = [];
+  let result;
+  let report;
+  const bufferedConsole = new LocalConsole();
+  bufferedConsole.log(`\n${purpleify(id)}: testing '${requestedUrl}'…`);
+  for (let i = 0; i <= retries; i++) {
+    if (i !== 0) {
+      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}),
+        networkRequests: takeNetworkRequestUrls ? takeNetworkRequestUrls() : undefined,
+      };
+
+      if (!result.lhr?.audits || !result.artifacts) {
+        // Something went really wrong and the runner didn't catch it.
+        throw new Error('lighthouse runner returned a bad result. got lhr:\n' +
+          JSON.stringify(result.lhr, null, 2));
+      }
+    } catch (e) {
+      // Clear the network requests so that when we retry, we don't see duplicates.
+      if (takeNetworkRequestUrls) takeNetworkRequestUrls();
+
+      logChildProcessError(bufferedConsole, e);
+      continue; // Retry, if possible.
+    }
+
+    // Assert result.
+    report = getAssertionReport(result, expectations, {
+      runner: lighthouseRunner.runnerName,
+      isDebug,
+      useLegacyNavigation,
+    });
+
+    runs.push({
+      ...result,
+      lighthouseLog: result.log,
+      assertionLog: report.log,
+    });
+
+    if (report.failed) {
+      bufferedConsole.log(`  ${getAssertionLog(report.failed)} failed.`);
+      continue; // Retry, if possible.
+    }
+
+    break; // Passing result, no need to retry.
+  }
+
+  bufferedConsole.log(`  smoketest results:`);
+
+  // Write result log if we have one.
+  if (result) bufferedConsole.write(result.log);
+
+  // If there's not an assertion report, just report the whole thing as a single failure.
+  if (report) bufferedConsole.write(report.log);
+  const passed = report ? report.passed : 0;
+  const failed = report ? report.failed : 1;
+
+  const correctStr = getAssertionLog(passed);
+  const colorFn = passed === 0 ? log.redify : log.greenify;
+  bufferedConsole.log(`  Correctly passed ${colorFn(correctStr)}`);
+
+  if (failed) {
+    const failedString = getAssertionLog(failed);
+    bufferedConsole.log(`  Failed ${log.redify(failedString)}`);
+  }
+  bufferedConsole.log(`${purpleify(id)} smoketest complete.`);
+
+  // Log now so right after finish, but all at once so not interleaved with other tests.
+  console.log(bufferedConsole.getLog());
+
+  return {
+    id,
+    passed,
+    failed,
+    runs,
+  };
+}
+
+/**
+ * Logs an error to the console, including stdout and stderr if `err` is a
+ * `ChildProcessError`.
+ * @param {LocalConsole} localConsole
+ * @param {ChildProcessError|Error} err
+ */
+function logChildProcessError(localConsole, err) {
+  if ('stdout' in err && 'stderr' in err) {
+    localConsole.adoptStdStrings(err);
+  }
+
+  localConsole.log(log.redify(err.stack || err.message));
+}
+
+/**
+ * @param {number} count
+ * @return {string}
+ */
+function getAssertionLog(count) {
+  const plural = count === 1 ? '' : 's';
+  return `${count} assertion${plural}`;
+}
+
+/**
+ * Parses the cli `shardArg` flag into `shardNumber/shardTotal`. Splits
+ * `testDefns` into `shardTotal` shards and returns the `shardNumber`th shard.
+ * Shards will differ in size by at most 1.
+ * Shard params must be 1 ≤ shardNumber ≤ shardTotal.
+ * @param {Array<Smokehouse.TestDfn>} testDefns
+ * @param {string=} shardArg
+ * @return {Array<Smokehouse.TestDfn>}
+ */
+function getShardedDefinitions(testDefns, shardArg) {
+  if (!shardArg) return testDefns;
+
+  // 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?.groups, errorMessage);
+  const shardNumber = Number(match.groups.shardNumber);
+  const shardTotal = Number(match.groups.shardTotal);
+  assert(shardNumber > 0 && Number.isInteger(shardNumber), errorMessage);
+  assert(shardTotal > 0 && Number.isInteger(shardTotal));
+  assert(shardNumber <= shardTotal, errorMessage);
+
+  // Array is sharded with `Math.ceil(length / shardTotal)` shards first
+  // and then the remaining `Math.floor(length / shardTotal) shards.
+  // e.g. `[0, 1, 2, 3]` split into 3 shards is `[[0, 1], [2], [3]]`.
+  const baseSize = Math.floor(testDefns.length / shardTotal);
+  const biggerSize = baseSize + 1;
+  const biggerShardCount = testDefns.length % shardTotal;
+
+  // Since we don't have tests for this file, construct all shards so correct
+  // structure can be asserted.
+  const shards = [];
+  let index = 0;
+  for (let i = 0; i < shardTotal; i++) {
+    const shardSize = i < biggerShardCount ? biggerSize : baseSize;
+    shards.push(testDefns.slice(index, index + shardSize));
+    index += shardSize;
+  }
+  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/cli/test/smokehouse/version-check-test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=version-check-test.d.ts.map

package/cli/test/smokehouse/version-check-test.js

@@ -0,0 +1,43 @@
+/**
+ * @license Copyright 2022 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 {chromiumVersionCheck, compareVersions} from './version-check.js';
+
+describe('version check', () => {
+  it('compareVersions', async () => {
+    expect(compareVersions([100, 0, 0, 0], [100, 0, 0, 0])).toBe(0);
+    expect(compareVersions([101, 0, 0, 0], [100, 0, 0, 0])).toBe(1);
+    expect(compareVersions([99, 0, 0, 0], [100, 0, 0, 0])).toBe(-1);
+
+    expect(compareVersions([100, 0, 10, 0], [100, 0, 10, 0])).toBe(0);
+    expect(compareVersions([100, 0, 11, 0], [100, 0, 10, 0])).toBe(1);
+    expect(compareVersions([100, 0, 9, 0], [100, 0, 10, 0])).toBe(-1);
+
+    expect(compareVersions([100, 0, 0, 0], [100])).toBe(0);
+    expect(compareVersions([100, 0, 0, 1], [100])).toBe(1);
+    expect(compareVersions([99, 0, 0, 0], [100])).toBe(-1);
+  });
+
+  it('chromiumVersionCheck', async () => {
+    expect(chromiumVersionCheck({version: '100'})).toBe(true);
+    expect(chromiumVersionCheck({version: '100', min: '100'})).toBe(true);
+    expect(chromiumVersionCheck({version: '100', max: '100'})).toBe(true);
+    expect(chromiumVersionCheck({version: '100', min: '101'})).toBe(false);
+    expect(chromiumVersionCheck({version: '100', max: '99'})).toBe(false);
+
+    expect(chromiumVersionCheck({version: '100.0.2331.3'})).toBe(true);
+    expect(chromiumVersionCheck({version: '100.0.2331.3', min: '100.0.2331.3'})).toBe(true);
+    expect(chromiumVersionCheck({version: '100.0.2331.3', min: '100.0.0.0'})).toBe(true);
+    expect(chromiumVersionCheck({version: '100.0.2331.3', max: '100.0.3333.3'})).toBe(true);
+    expect(chromiumVersionCheck({version: '100.0.2331.3', min: '100.0.2331.2'})).toBe(true);
+    expect(chromiumVersionCheck({version: '100.0.2331.3', max: '99'})).toBe(false);
+
+    expect(chromiumVersionCheck({
+      version: '100.0.2331.3', min: '100.0.2331.0', max: '100.0.2331.10'})).toBe(true);
+    expect(chromiumVersionCheck({
+      version: '100.3.2331.3', min: '100.0.2331.0', max: '100.0.2331.10'})).toBe(false);
+  });
+});

package/cli/test/smokehouse/version-check.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns false if fails check.
+ * @param {{version: string, min?: string, max?: string}} opts
+ */
+export function chromiumVersionCheck(opts: {
+    version: string;
+    min?: string | undefined;
+    max?: string | undefined;
+}): boolean;
+/**
+ * @param {number[]} versionA
+ * @param {number[]} versionB
+ */
+export function compareVersions(versionA: number[], versionB: number[]): 1 | 0 | -1;
+//# sourceMappingURL=version-check.d.ts.map

package/cli/test/smokehouse/version-check.js

@@ -0,0 +1,48 @@
+/**
+ * @license Copyright 2022 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 Compares chromium version strings: 103.0.5017.0
+ */
+
+/**
+ * @param {string} versionString
+ * @return {number[]}
+ */
+function parseVersion(versionString) {
+  const versionParts = versionString.split('.');
+  return versionParts.map(Number);
+}
+
+/**
+ * @param {number[]} versionA
+ * @param {number[]} versionB
+ */
+function compareVersions(versionA, versionB) {
+  for (let i = 0; i < versionA.length; i++) {
+    if ((versionA[i] ?? 0) > (versionB[i] ?? 0)) return 1;
+    if ((versionA[i] ?? 0) < (versionB[i] ?? 0)) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Returns false if fails check.
+ * @param {{version: string, min?: string, max?: string}} opts
+ */
+function chromiumVersionCheck(opts) {
+  const version = parseVersion(opts.version);
+  const min = opts.min && parseVersion(opts.min);
+  const max = opts.max && parseVersion(opts.max);
+  if (min && compareVersions(version, min) === -1) return false;
+  if (max && compareVersions(version, max) === 1) return false;
+  return true;
+}
+
+export {
+  chromiumVersionCheck,
+  compareVersions,
+};

package/commitlint.config.js

@@ -3,7 +3,6 @@
  * 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';
 
 module.exports = {
   extends: ['cz'],

package/core/audits/accessibility/accesskeys.d.ts

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

package/core/audits/accessibility/accesskeys.js

@@ -0,0 +1,44 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures accesskey values are unique.
+ * 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 the accesskey HTML attribute values are unique across all elements. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[accesskey]` values are unique',
+  /** Title of an accesibility audit that evaluates if the ARIA HTML attributes are misaligned with the aria-role HTML attribute specificed on the element, such mismatches are invalid. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[accesskey]` values are not unique',
+  /** 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: 'Access keys let users quickly focus a part of the page. For proper ' +
+      'navigation, each access key must be unique. ' +
+      '[Learn more about access keys](https://dequeuniversity.com/rules/axe/4.6/accesskeys).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class Accesskeys extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'accesskeys',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default Accesskeys;
+export {UIStrings};

package/core/audits/accessibility/aria-allowed-attr.d.ts

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

package/core/audits/accessibility/aria-allowed-attr.js

@@ -0,0 +1,44 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures ARIA attributes are allowed for an element's role.
+ * 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 the ARIA HTML attributes are misaligned with the aria-role HTML attribute specificed on the element, such mismatches are invalid. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[aria-*]` attributes match their roles',
+  /** Title of an accesibility audit that evaluates if the ARIA HTML attributes are misaligned with the aria-role HTML attribute specificed on the element, such mismatches are invalid. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[aria-*]` attributes do not match their roles',
+  /** 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: 'Each ARIA `role` supports a specific subset of `aria-*` attributes. ' +
+      'Mismatching these invalidates the `aria-*` attributes. [Learn ' +
+      'how to match ARIA attributes to their roles](https://dequeuniversity.com/rules/axe/4.6/aria-allowed-attr).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class ARIAAllowedAttr extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-allowed-attr',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default ARIAAllowedAttr;
+export {UIStrings};

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

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

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

@@ -0,0 +1,42 @@
+/**
+ * @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 Ensures every ARIA button, link and menuitem element has an 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 important HTML 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: '`button`, `link`, and `menuitem` elements have accessible names',
+  /** Title of an accessibility audit that evaluates if important HTML 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: '`button`, `link`, and `menuitem` elements do not have accessible names.',
+  /** Description of a Lighthouse audit that tells the user *why* they should have accessible names for HTML 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: 'When an element doesn\'t have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to make command elements more accessible](https://dequeuniversity.com/rules/axe/4.6/aria-command-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaCommandName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-command-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaCommandName;
+export {UIStrings};

package/core/audits/accessibility/aria-hidden-body.d.ts

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