lighthouse 9.6.7 → 10.0.0-dev.20230209

package/core/config/metrics-to-audits.js

@@ -0,0 +1,61 @@
+/**
+ * @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.
+ */
+
+// go/lh-audit-metric-mapping
+const fcpRelevantAudits = [
+  'server-response-time',
+  'render-blocking-resources',
+  'redirects',
+  'critical-request-chains',
+  'uses-text-compression',
+  'uses-rel-preconnect',
+  'uses-rel-preload',
+  'font-display',
+  'unminified-javascript',
+  'unminified-css',
+  'unused-css-rules',
+];
+
+const lcpRelevantAudits = [
+  ...fcpRelevantAudits,
+  'largest-contentful-paint-element',
+  'prioritize-lcp-image',
+  'unused-javascript',
+  'efficient-animated-content',
+  'total-byte-weight',
+  'lcp-lazy-loaded',
+];
+
+const tbtRelevantAudits = [
+  'long-tasks',
+  'third-party-summary',
+  'third-party-facades',
+  'bootup-time',
+  'mainthread-work-breakdown',
+  'dom-size',
+  'duplicated-javascript',
+  'legacy-javascript',
+  'viewport',
+];
+
+const clsRelevantAudits = [
+  'layout-shift-elements',
+  'non-composited-animations',
+  'unsized-images',
+  // 'preload-fonts', // actually in BP, rather than perf
+];
+
+const inpRelevantAudits = [
+  'work-during-interaction',
+];
+
+export const metricsToAudits = {
+  fcpRelevantAudits,
+  lcpRelevantAudits,
+  tbtRelevantAudits,
+  clsRelevantAudits,
+  inpRelevantAudits,
+};

package/core/config/perf-config.d.ts

@@ -0,0 +1,9 @@
+export default perfConfig;
+/**
+ * @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.
+ */
+/** @type {LH.Config} */
+declare const perfConfig: LH.Config;
+//# sourceMappingURL=perf-config.d.ts.map

package/core/config/perf-config.js

@@ -0,0 +1,16 @@
+/**
+ * @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.
+ */
+
+/** @type {LH.Config} */
+const perfConfig = {
+  extends: 'lighthouse:default',
+  settings: {
+    throttlingMethod: 'devtools',
+    onlyCategories: ['performance'],
+  },
+};
+
+export default perfConfig;

package/core/config/validation.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @param {LH.Config.GathererDefn | LH.Config.AnyFRGathererDefn} gathererDefn
+ * @return {gathererDefn is LH.Config.AnyFRGathererDefn}
+ */
+export function isFRGathererDefn(gathererDefn: LH.Config.GathererDefn | LH.Config.AnyFRGathererDefn): gathererDefn is import("../../types/config.js").default.AnyFRGathererDefn;
+/**
+ * Determines if the artifact dependency direction is valid. The dependency's minimum supported mode
+ * must be less than or equal to the dependent's.
+ *
+ * @param {LH.Config.AnyFRGathererDefn} dependent The artifact that depends on the other.
+ * @param {LH.Config.AnyFRGathererDefn} dependency The artifact that is being depended on by the other.
+ * @return {boolean}
+ */
+export function isValidArtifactDependency(dependent: LH.Config.AnyFRGathererDefn, dependency: LH.Config.AnyFRGathererDefn): boolean;
+/**
+ * Throws if pluginName is invalid or (somehow) collides with a category in the
+ * config being added to.
+ * @param {LH.Config} config
+ * @param {string} pluginName
+ */
+export function assertValidPluginName(config: LH.Config, pluginName: string): void;
+/**
+ * Throws an error if the provided object does not implement the required Fraggle Rock gatherer interface.
+ * @param {LH.Config.AnyFRGathererDefn} gathererDefn
+ */
+export function assertValidFRGatherer(gathererDefn: LH.Config.AnyFRGathererDefn): void;
+/**
+ * Throws an error if the provided object does not implement the required navigations interface.
+ * @param {LH.Config.ResolvedConfig['navigations']} navigationsDefn
+ * @return {{warnings: string[]}}
+ */
+export function assertValidFRNavigations(navigationsDefn: LH.Config.ResolvedConfig['navigations']): {
+    warnings: string[];
+};
+/**
+ * Throws an error if the provided object does not implement the required properties of an audit
+ * definition.
+ * @param {LH.Config.AuditDefn} auditDefinition
+ */
+export function assertValidAudit(auditDefinition: LH.Config.AuditDefn): void;
+/**
+ * @param {LH.Config.ResolvedConfig['categories']} categories
+ * @param {LH.Config.ResolvedConfig['audits']} audits
+ * @param {LH.Config.ResolvedConfig['groups']} groups
+ */
+export function assertValidCategories(categories: LH.Config.ResolvedConfig['categories'], audits: LH.Config.ResolvedConfig['audits'], groups: LH.Config.ResolvedConfig['groups']): void;
+/**
+ * Validate the settings after they've been built.
+ * @param {LH.Config.Settings} settings
+ */
+export function assertValidSettings(settings: LH.Config.Settings): void;
+/**
+ * Asserts that artifacts are in a valid dependency order that can be computed.
+ *
+ * @param {Array<LH.Config.NavigationDefn>} navigations
+ */
+export function assertArtifactTopologicalOrder(navigations: Array<LH.Config.NavigationDefn>): void;
+/**
+ * @param {LH.Config.ResolvedConfig} resolvedConfig
+ * @return {{warnings: string[]}}
+ */
+export function assertValidConfig(resolvedConfig: LH.Config.ResolvedConfig): {
+    warnings: string[];
+};
+/**
+ * @param {string} artifactId
+ * @param {string} dependencyKey
+ * @return {never}
+ */
+export function throwInvalidDependencyOrder(artifactId: string, dependencyKey: string): never;
+/**
+ * @param {string} artifactId
+ * @param {string} dependencyKey
+ * @return {never}
+ */
+export function throwInvalidArtifactDependency(artifactId: string, dependencyKey: string): never;
+//# sourceMappingURL=validation.d.ts.map

package/core/config/validation.js

@@ -0,0 +1,312 @@
+/**
+ * @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.
+ */
+
+import {Audit} from '../audits/audit.js';
+import BaseFRGatherer from '../gather/base-gatherer.js';
+import * as i18n from '../lib/i18n/i18n.js';
+
+/**
+ * @param {LH.Config.GathererDefn | LH.Config.AnyFRGathererDefn} gathererDefn
+ * @return {gathererDefn is LH.Config.AnyFRGathererDefn}
+ */
+function isFRGathererDefn(gathererDefn) {
+  return 'meta' in gathererDefn.instance;
+}
+
+/**
+ * Determines if the artifact dependency direction is valid. The dependency's minimum supported mode
+ * must be less than or equal to the dependent's.
+ *
+ * @param {LH.Config.AnyFRGathererDefn} dependent The artifact that depends on the other.
+ * @param {LH.Config.AnyFRGathererDefn} dependency The artifact that is being depended on by the other.
+ * @return {boolean}
+ */
+function isValidArtifactDependency(dependent, dependency) {
+  const levels = {timespan: 0, snapshot: 1, navigation: 2};
+  const dependentLevel = Math.min(...dependent.instance.meta.supportedModes.map(l => levels[l]));
+  const dependencyLevel = Math.min(...dependency.instance.meta.supportedModes.map(l => levels[l]));
+
+  // A timespan artifact cannot depend on a snapshot/navigation artifact because it might run without a snapshot.
+  if (dependentLevel === levels.timespan) return dependencyLevel === levels.timespan;
+  // A snapshot artifact cannot depend on a timespan/navigation artifact because it might run without a timespan.
+  if (dependentLevel === levels.snapshot) return dependencyLevel === levels.snapshot;
+  // A navigation artifact can depend on anything.
+  return true;
+}
+
+/**
+ * Throws if pluginName is invalid or (somehow) collides with a category in the
+ * config being added to.
+ * @param {LH.Config} config
+ * @param {string} pluginName
+ */
+function assertValidPluginName(config, pluginName) {
+  if (!pluginName.startsWith('lighthouse-plugin-')) {
+    throw new Error(`plugin name '${pluginName}' does not start with 'lighthouse-plugin-'`);
+  }
+
+  if (config.categories?.[pluginName]) {
+    throw new Error(`plugin name '${pluginName}' not allowed because it is the id of a category already found in config`); // eslint-disable-line max-len
+  }
+}
+
+/**
+ * Throws an error if the provided object does not implement the required Fraggle Rock gatherer interface.
+ * @param {LH.Config.AnyFRGathererDefn} gathererDefn
+ */
+function assertValidFRGatherer(gathererDefn) {
+  const gatherer = gathererDefn.instance;
+  const gathererName = gatherer.name;
+
+  if (typeof gatherer.meta !== 'object') {
+    throw new Error(`${gathererName} gatherer did not provide a meta object.`);
+  }
+
+  if (gatherer.meta.supportedModes.length === 0) {
+    throw new Error(`${gathererName} gatherer did not support any gather modes.`);
+  }
+
+  if (
+    typeof gatherer.getArtifact !== 'function' ||
+    gatherer.getArtifact === BaseFRGatherer.prototype.getArtifact
+  ) {
+    throw new Error(`${gathererName} gatherer did not define a "getArtifact" method.`);
+  }
+}
+
+/**
+ * Throws an error if the provided object does not implement the required navigations interface.
+ * @param {LH.Config.ResolvedConfig['navigations']} navigationsDefn
+ * @return {{warnings: string[]}}
+ */
+function assertValidFRNavigations(navigationsDefn) {
+  if (!navigationsDefn || !navigationsDefn.length) return {warnings: []};
+
+  /** @type {string[]} */
+  const warnings = [];
+
+  // Assert that the first navigation has loadFailureMode fatal.
+  const firstNavigation = navigationsDefn[0];
+  if (firstNavigation.loadFailureMode !== 'fatal') {
+    const currentMode = firstNavigation.loadFailureMode;
+    const warning = [
+      `"${firstNavigation.id}" is the first navigation but had a failure mode of ${currentMode}.`,
+      `The first navigation will always be treated as loadFailureMode=fatal.`,
+    ].join(' ');
+
+    warnings.push(warning);
+    firstNavigation.loadFailureMode = 'fatal';
+  }
+
+  // Assert that navigations have unique IDs.
+  const navigationIds = navigationsDefn.map(navigation => navigation.id);
+  const duplicateId = navigationIds.find(
+    (id, i) => navigationIds.slice(i + 1).some(other => id === other)
+  );
+
+  if (duplicateId) {
+    throw new Error(`Navigation must have unique identifiers, but "${duplicateId}" was repeated.`);
+  }
+
+  return {warnings};
+}
+
+/**
+ * Throws an error if the provided object does not implement the required properties of an audit
+ * definition.
+ * @param {LH.Config.AuditDefn} auditDefinition
+ */
+function assertValidAudit(auditDefinition) {
+  const {implementation, path: auditPath} = auditDefinition;
+  const auditName = auditPath ||
+    implementation?.meta?.id ||
+    'Unknown audit';
+
+  if (typeof implementation.audit !== 'function' || implementation.audit === Audit.audit) {
+    throw new Error(`${auditName} has no audit() method.`);
+  }
+
+  if (typeof implementation.meta.id !== 'string') {
+    throw new Error(`${auditName} has no meta.id property, or the property is not a string.`);
+  }
+
+  if (!i18n.isStringOrIcuMessage(implementation.meta.title)) {
+    throw new Error(`${auditName} has no meta.title property, or the property is not a string.`);
+  }
+
+  // If it'll have a ✔ or ✖ displayed alongside the result, it should have failureTitle
+  const scoreDisplayMode = implementation.meta.scoreDisplayMode || Audit.SCORING_MODES.BINARY;
+  if (
+    !i18n.isStringOrIcuMessage(implementation.meta.failureTitle) &&
+    scoreDisplayMode === Audit.SCORING_MODES.BINARY
+  ) {
+    throw new Error(`${auditName} has no meta.failureTitle and should.`);
+  }
+
+  if (!i18n.isStringOrIcuMessage(implementation.meta.description)) {
+    throw new Error(
+      `${auditName} has no meta.description property, or the property is not a string.`
+    );
+  } else if (implementation.meta.description === '') {
+    throw new Error(
+      `${auditName} has an empty meta.description string. Please add a description for the UI.`
+    );
+  }
+
+  if (!Array.isArray(implementation.meta.requiredArtifacts)) {
+    throw new Error(
+      `${auditName} has no meta.requiredArtifacts property, or the property is not an array.`
+    );
+  }
+}
+
+/**
+ * @param {LH.Config.ResolvedConfig['categories']} categories
+ * @param {LH.Config.ResolvedConfig['audits']} audits
+ * @param {LH.Config.ResolvedConfig['groups']} groups
+ */
+function assertValidCategories(categories, audits, groups) {
+  if (!categories) {
+    return;
+  }
+
+  /** @type {Map<string, LH.Config.AuditDefn>} */
+  const auditsKeyedById = new Map((audits || []).map(audit => {
+    return [audit.implementation.meta.id, audit];
+  }));
+
+  Object.keys(categories).forEach(categoryId => {
+    categories[categoryId].auditRefs.forEach((auditRef, index) => {
+      if (!auditRef.id) {
+        throw new Error(`missing an audit id at ${categoryId}[${index}]`);
+      }
+
+      const audit = auditsKeyedById.get(auditRef.id);
+      if (!audit) {
+        throw new Error(`could not find ${auditRef.id} audit for category ${categoryId}`);
+      }
+
+      const auditImpl = audit.implementation;
+      const isManual = auditImpl.meta.scoreDisplayMode === 'manual';
+      if (categoryId === 'accessibility' && !auditRef.group && !isManual) {
+        throw new Error(`${auditRef.id} accessibility audit does not have a group`);
+      }
+
+      if (auditRef.weight > 0 && isManual) {
+        throw new Error(`${auditRef.id} is manual but has a positive weight`);
+      }
+
+      if (auditRef.group && (!groups || !groups[auditRef.group])) {
+        throw new Error(`${auditRef.id} references unknown group ${auditRef.group}`);
+      }
+    });
+  });
+}
+
+/**
+ * Validate the settings after they've been built.
+ * @param {LH.Config.Settings} settings
+ */
+function assertValidSettings(settings) {
+  if (!settings.formFactor) {
+    throw new Error(`\`settings.formFactor\` must be defined as 'mobile' or 'desktop'. See https://github.com/GoogleChrome/lighthouse/blob/main/docs/emulation.md`);
+  }
+
+  if (!settings.screenEmulation.disabled) {
+    // formFactor doesn't control emulation. So we don't want a mismatch:
+    //   Bad mismatch A: user wants mobile emulation but scoring is configured for desktop
+    //   Bad mismtach B: user wants everything desktop and set formFactor, but accidentally not screenEmulation
+    if (settings.screenEmulation.mobile !== (settings.formFactor === 'mobile')) {
+      throw new Error(`Screen emulation mobile setting (${settings.screenEmulation.mobile}) does not match formFactor setting (${settings.formFactor}). See https://github.com/GoogleChrome/lighthouse/blob/main/docs/emulation.md`);
+    }
+  }
+}
+
+/**
+ * Asserts that artifacts are in a valid dependency order that can be computed.
+ *
+ * @param {Array<LH.Config.NavigationDefn>} navigations
+ */
+function assertArtifactTopologicalOrder(navigations) {
+  const availableArtifacts = new Set();
+
+  for (const navigation of navigations) {
+    for (const artifact of navigation.artifacts) {
+      availableArtifacts.add(artifact.id);
+      if (!artifact.dependencies) continue;
+
+      for (const [dependencyKey, {id: dependencyId}] of Object.entries(artifact.dependencies)) {
+        if (availableArtifacts.has(dependencyId)) continue;
+        throwInvalidDependencyOrder(artifact.id, dependencyKey);
+      }
+    }
+  }
+}
+
+/**
+ * @param {LH.Config.ResolvedConfig} resolvedConfig
+ * @return {{warnings: string[]}}
+ */
+function assertValidConfig(resolvedConfig) {
+  const {warnings} = assertValidFRNavigations(resolvedConfig.navigations);
+
+  for (const artifactDefn of resolvedConfig.artifacts || []) {
+    assertValidFRGatherer(artifactDefn.gatherer);
+  }
+
+  for (const auditDefn of resolvedConfig.audits || []) {
+    assertValidAudit(auditDefn);
+  }
+
+  assertValidCategories(resolvedConfig.categories, resolvedConfig.audits, resolvedConfig.groups);
+  assertValidSettings(resolvedConfig.settings);
+  return {warnings};
+}
+
+/**
+ * @param {string} artifactId
+ * @param {string} dependencyKey
+ * @return {never}
+ */
+function throwInvalidDependencyOrder(artifactId, dependencyKey) {
+  throw new Error(
+    [
+      `Failed to find dependency "${dependencyKey}" for "${artifactId}" artifact`,
+      `Check that...`,
+      `  1. A gatherer exposes a matching Symbol that satisfies "${dependencyKey}".`,
+      `  2. "${dependencyKey}" is configured to run before "${artifactId}"`,
+    ].join('\n')
+  );
+}
+
+/**
+ * @param {string} artifactId
+ * @param {string} dependencyKey
+ * @return {never}
+ */
+function throwInvalidArtifactDependency(artifactId, dependencyKey) {
+  throw new Error(
+    [
+      `Dependency "${dependencyKey}" for "${artifactId}" artifact is invalid.`,
+      `The dependency must be collected before the dependent.`,
+    ].join('\n')
+  );
+}
+
+export {
+  isFRGathererDefn,
+  isValidArtifactDependency,
+  assertValidPluginName,
+  assertValidFRGatherer,
+  assertValidFRNavigations,
+  assertValidAudit,
+  assertValidCategories,
+  assertValidSettings,
+  assertArtifactTopologicalOrder,
+  assertValidConfig,
+  throwInvalidDependencyOrder,
+  throwInvalidArtifactDependency,
+};

package/core/gather/base-artifacts.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {LH.Config.ResolvedConfig} resolvedConfig
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ * @param {{gatherMode: LH.Gatherer.GatherMode}} context
+ * @return {Promise<LH.BaseArtifacts>}
+ */
+export function getBaseArtifacts(resolvedConfig: LH.Config.ResolvedConfig, driver: LH.Gatherer.FRTransitionalDriver, context: {
+    gatherMode: LH.Gatherer.GatherMode;
+}): Promise<LH.BaseArtifacts>;
+/**
+ * @param {LH.FRBaseArtifacts} baseArtifacts
+ * @param {Partial<LH.Artifacts>} gathererArtifacts
+ * @return {LH.Artifacts}
+ */
+export function finalizeArtifacts(baseArtifacts: LH.FRBaseArtifacts, gathererArtifacts: Partial<LH.Artifacts>): LH.Artifacts;
+//# sourceMappingURL=base-artifacts.d.ts.map

package/core/gather/base-artifacts.js

@@ -0,0 +1,95 @@
+/**
+ * @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.
+ */
+
+import log from 'lighthouse-logger';
+import isDeepEqual from 'lodash/isEqual.js';
+
+import {
+  getBrowserVersion, getBenchmarkIndex, getEnvironmentWarnings,
+} from './driver/environment.js';
+
+/**
+ * @param {LH.Config.ResolvedConfig} resolvedConfig
+ * @param {LH.Gatherer.FRTransitionalDriver} driver
+ * @param {{gatherMode: LH.Gatherer.GatherMode}} context
+ * @return {Promise<LH.BaseArtifacts>}
+ */
+async function getBaseArtifacts(resolvedConfig, driver, context) {
+  const BenchmarkIndex = await getBenchmarkIndex(driver.executionContext);
+  const {userAgent} = await getBrowserVersion(driver.defaultSession);
+
+  return {
+    // Meta artifacts.
+    fetchTime: new Date().toJSON(),
+    Timing: [],
+    LighthouseRunWarnings: [],
+    settings: resolvedConfig.settings,
+    // Environment artifacts that can always be computed.
+    BenchmarkIndex,
+    HostUserAgent: userAgent,
+    HostFormFactor: userAgent.includes('Android') || userAgent.includes('Mobile') ?
+      'mobile' : 'desktop',
+    // Contextual artifacts whose collection changes based on gather mode.
+    URL: {
+      finalDisplayedUrl: '',
+    },
+    PageLoadError: null,
+    GatherContext: context,
+    // Artifacts that have been replaced by regular gatherers in Fraggle Rock.
+    NetworkUserAgent: '',
+    traces: {},
+    devtoolsLogs: {},
+  };
+}
+
+/**
+ * Deduplicates identical warnings.
+ * @param {Array<string | LH.IcuMessage>} warnings
+ * @return {Array<string | LH.IcuMessage>}
+ */
+function deduplicateWarnings(warnings) {
+  /** @type {Array<string | LH.IcuMessage>} */
+  const unique = [];
+
+  for (const warning of warnings) {
+    if (unique.some(existing => isDeepEqual(warning, existing))) continue;
+    unique.push(warning);
+  }
+
+  return unique;
+}
+
+/**
+ * @param {LH.FRBaseArtifacts} baseArtifacts
+ * @param {Partial<LH.Artifacts>} gathererArtifacts
+ * @return {LH.Artifacts}
+ */
+function finalizeArtifacts(baseArtifacts, gathererArtifacts) {
+  const warnings = baseArtifacts.LighthouseRunWarnings
+    .concat(gathererArtifacts.LighthouseRunWarnings || [])
+    .concat(getEnvironmentWarnings({settings: baseArtifacts.settings, baseArtifacts}));
+
+  // Cast to remove the partial from gathererArtifacts.
+  const artifacts = /** @type {LH.Artifacts} */ ({...baseArtifacts, ...gathererArtifacts});
+
+  // Set the post-run meta artifacts.
+  artifacts.Timing = log.getTimeEntries();
+  artifacts.LighthouseRunWarnings = deduplicateWarnings(warnings);
+
+  if (artifacts.PageLoadError && !artifacts.URL.finalDisplayedUrl) {
+    artifacts.URL.finalDisplayedUrl = artifacts.URL.requestedUrl || '';
+  }
+
+  // Check that the runner remembered to mutate the special-case URL artifact.
+  if (!artifacts.URL.finalDisplayedUrl) throw new Error('Runner did not set finalDisplayedUrl');
+
+  return artifacts;
+}
+
+export {
+  getBaseArtifacts,
+  finalizeArtifacts,
+};

package/core/gather/base-gatherer.d.ts

@@ -0,0 +1,72 @@
+export default FRGatherer;
+/**
+ * Base class for all gatherers supporting both Fraggle Rock and the legacy flow.
+ * Most extending classes should implement the Fraggle Rock API and let this class handle translation.
+ * See core/gather/gatherers/gatherer.js for legacy method explanations.
+ *
+ * @implements {LH.Gatherer.GathererInstance}
+ * @implements {LH.Gatherer.FRGathererInstance}
+ */
+declare class FRGatherer implements LH.Gatherer.GathererInstance, LH.Gatherer.FRGathererInstance {
+    /** @type {LH.Gatherer.GathererMeta} */
+    meta: LH.Gatherer.GathererMeta;
+    /**
+     * Method to start observing a page for an arbitrary period of time.
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<void>|void}
+     */
+    startInstrumentation(passContext: LH.Gatherer.FRTransitionalContext): Promise<void> | void;
+    /**
+     * Method to start observing a page when the measurements are very sensitive and
+     * should observe as little Lighthouse-induced work as possible.
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<void>|void}
+     */
+    startSensitiveInstrumentation(passContext: LH.Gatherer.FRTransitionalContext): Promise<void> | void;
+    /**
+     * Method to stop observing a page when the measurements are very sensitive and
+     * should observe as little Lighthouse-induced work as possible.
+     *
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<void>|void}
+     */
+    stopSensitiveInstrumentation(passContext: LH.Gatherer.FRTransitionalContext): Promise<void> | void;
+    /**
+     * Method to end observing a page after an arbitrary period of time.
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<void>|void}
+     */
+    stopInstrumentation(passContext: LH.Gatherer.FRTransitionalContext): Promise<void> | void;
+    /**
+     * Method to gather results about a page.
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {LH.Gatherer.PhaseResult}
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): LH.Gatherer.PhaseResult;
+    /**
+     * Legacy property used to define the artifact ID. In Fraggle Rock, the artifact ID lives on the config.
+     * @return {keyof LH.GathererArtifacts}
+     */
+    get name(): keyof LH.GathererArtifacts;
+    /**
+     * Legacy method. Called before navigation to target url, roughly corresponds to `startInstrumentation`.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @return {Promise<LH.Gatherer.PhaseResultNonPromise>}
+     */
+    beforePass(passContext: LH.Gatherer.PassContext): Promise<LH.Gatherer.PhaseResultNonPromise>;
+    /**
+     * Legacy method. Should never be used by a Fraggle Rock gatherer, here for compat only.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @return {LH.Gatherer.PhaseResult}
+     */
+    pass(passContext: LH.Gatherer.PassContext): LH.Gatherer.PhaseResult;
+    /**
+     * Legacy method. Roughly corresponds to `stopInstrumentation` or `getArtifact` depending on type of gatherer.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {Promise<LH.Gatherer.PhaseResultNonPromise>}
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Gatherer.PhaseResultNonPromise>;
+}
+import * as LH from "../../types/lh.js";
+//# sourceMappingURL=base-gatherer.d.ts.map