lighthouse 9.5.0-dev.20230117 → 9.5.0-dev.20230119

package/core/gather/gatherers/trace-elements.d.ts

@@ -0,0 +1,83 @@
+export default TraceElements;
+export type TraceElementData = {
+    nodeId: number;
+    score?: number;
+    animations?: {
+        name?: string;
+        failureReasonsMask?: number;
+        unsupportedProperties?: string[];
+    }[];
+    type?: string;
+};
+declare class TraceElements extends FRGatherer {
+    /**
+     * @param {Array<number>} rect
+     * @return {LH.Artifacts.Rect}
+     */
+    static traceRectToLHRect(rect: Array<number>): LH.Artifacts.Rect;
+    /**
+     * This function finds the top (up to 5) elements that contribute to the CLS score of the page.
+     * Each layout shift event has a 'score' which is the amount added to the CLS as a result of the given shift(s).
+     * We calculate the score per element by taking the 'score' of each layout shift event and
+     * distributing it between all the nodes that were shifted, proportianal to the impact region of
+     * each shifted element.
+     * @param {Array<LH.TraceEvent>} mainThreadEvents
+     * @return {Array<TraceElementData>}
+     */
+    static getTopLayoutShiftElements(mainThreadEvents: Array<LH.TraceEvent>): Array<TraceElementData>;
+    /**
+     * @param {LH.Trace} trace
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<TraceElementData|undefined>}
+     */
+    static getResponsivenessElement(trace: LH.Trace, context: LH.Gatherer.FRTransitionalContext): Promise<TraceElementData | undefined>;
+    /**
+     * @param {LH.Trace} trace
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<{nodeId: number, type: string} | undefined>}
+     */
+    static getLcpElement(trace: LH.Trace, context: LH.Gatherer.FRTransitionalContext): Promise<{
+        nodeId: number;
+        type: string;
+    } | undefined>;
+    /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
+    meta: LH.Gatherer.GathererMeta<'Trace'>;
+    /** @type {Map<string, string>} */
+    animationIdToName: Map<string, string>;
+    /** @param {LH.Crdp.Animation.AnimationStartedEvent} args */
+    _onAnimationStarted({ animation: { id, name } }: LH.Crdp.Animation.AnimationStartedEvent): void;
+    /**
+     * Find the node ids of elements which are animated using the Animation trace events.
+     * @param {Array<LH.TraceEvent>} mainThreadEvents
+     * @return {Promise<Array<TraceElementData>>}
+     */
+    getAnimatedElements(mainThreadEvents: Array<LH.TraceEvent>): Promise<Array<TraceElementData>>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    startInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    stopInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @param {LH.Trace|undefined} trace
+     * @return {Promise<LH.Artifacts['TraceElements']>}
+     */
+    _getArtifact(context: LH.Gatherer.FRTransitionalContext, trace: LH.Trace | undefined): Promise<LH.Artifacts['TraceElements']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'Trace'>} context
+     * @return {Promise<LH.Artifacts.TraceElement[]>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'Trace'>): Promise<LH.Artifacts.TraceElement[]>;
+    /**
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {Promise<LH.Artifacts.TraceElement[]>}
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Artifacts.TraceElement[]>;
+}
+import FRGatherer from "../base-gatherer.js";
+import Trace from "./trace.js";
+//# sourceMappingURL=trace-elements.d.ts.map

package/core/gather/gatherers/trace-elements.js

@@ -213,14 +213,14 @@ class TraceElements extends FRGatherer {
   }
 
   /**
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
+   * @param {LH.Trace} trace
    * @param {LH.Gatherer.FRTransitionalContext} context
    * @return {Promise<{nodeId: number, type: string} | undefined>}
    */
-  static async getLcpElement(processedTrace, context) {
+  static async getLcpElement(trace, context) {
     let processedNavigation;
     try {
-      processedNavigation = await ProcessedNavigation.request(processedTrace, context);
+      processedNavigation = await ProcessedNavigation.request(trace, context);
     } catch (err) {
       // If we were running in timespan mode and there was no paint, treat LCP as missing.
       if (context.gatherMode === 'timespan' && err.code === LighthouseError.errors.NO_FCP.code) {
@@ -270,7 +270,7 @@ class TraceElements extends FRGatherer {
     const processedTrace = await ProcessedTrace.request(trace, context);
     const {mainThreadEvents} = processedTrace;
 
-    const lcpNodeData = await TraceElements.getLcpElement(processedTrace, context);
+    const lcpNodeData = await TraceElements.getLcpElement(trace, context);
     const clsNodeData = TraceElements.getTopLayoutShiftElements(mainThreadEvents);
     const animatedElementData = await this.getAnimatedElements(mainThreadEvents);
     const responsivenessElementData = await TraceElements.getResponsivenessElement(trace, context);

package/core/gather/gatherers/trace.d.ts

@@ -0,0 +1,23 @@
+export default Trace;
+declare class Trace extends FRGatherer {
+    static getDefaultTraceCategories(): string[];
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @return {Promise<LH.Trace>}
+     */
+    static endTraceAndCollectEvents(session: LH.Gatherer.FRProtocolSession): Promise<LH.Trace>;
+    static symbol: symbol;
+    /** @type {LH.Trace} */
+    _trace: LH.Trace;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     */
+    startSensitiveInstrumentation({ driver, gatherMode, settings }: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     */
+    stopSensitiveInstrumentation({ driver }: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    getArtifact(): import("../../index.js").Trace;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=trace.d.ts.map

package/core/gather/gatherers/viewport-dimensions.d.ts

@@ -0,0 +1,10 @@
+export default ViewportDimensions;
+declare class ViewportDimensions extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<LH.Artifacts.ViewportDimensions>}
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts.ViewportDimensions>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=viewport-dimensions.d.ts.map

package/core/gather/gatherers/web-app-manifest.d.ts

@@ -0,0 +1,32 @@
+export default WebAppManifest;
+declare class WebAppManifest extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @return {Promise<{url: string, data: string}|null>}
+     */
+    static fetchAppManifest(session: LH.Gatherer.FRProtocolSession): Promise<{
+        url: string;
+        data: string;
+    } | null>;
+    /**
+     * Uses the debugger protocol to fetch the manifest from within the context of
+     * the target page, reusing any credentials, emulation, etc, already established
+     * there.
+     *
+     * Returns the parsed manifest or null if the page had no manifest. If the manifest
+     * was unparseable as JSON, manifest.value will be undefined and manifest.warning
+     * will have the reason. See manifest-parser.js for more information.
+     *
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @param {string} pageUrl
+     * @return {Promise<LH.Artifacts.Manifest|null>}
+     */
+    static getWebAppManifest(session: LH.Gatherer.FRProtocolSession, pageUrl: string): Promise<LH.Artifacts.Manifest | null>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Artifacts['WebAppManifest']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['WebAppManifest']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=web-app-manifest.d.ts.map

package/core/gather/navigation-runner.d.ts

@@ -0,0 +1,92 @@
+export type NavigationContext = {
+    driver: Driver;
+    page: LH.Puppeteer.Page;
+    resolvedConfig: LH.Config.ResolvedConfig;
+    navigation: LH.Config.NavigationDefn;
+    requestor: LH.NavigationRequestor;
+    baseArtifacts: LH.FRBaseArtifacts;
+    computedCache: Map<string, LH.ArbitraryEqualityMap>;
+};
+export type PhaseState = Omit<Parameters<typeof collectPhaseArtifacts>[0], 'phase'>;
+/**
+ * @param {LH.Puppeteer.Page|undefined} page
+ * @param {LH.NavigationRequestor|undefined} requestor
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<LH.Gatherer.FRGatherResult>}
+ */
+export function navigationGather(page: LH.Puppeteer.Page | undefined, requestor: LH.NavigationRequestor | undefined, options?: {
+    config?: import("../../types/config.js").default | undefined;
+    flags?: import("../index.js").Flags | undefined;
+} | undefined): Promise<LH.Gatherer.FRGatherResult>;
+/**
+ * @param {{driver: Driver, resolvedConfig: LH.Config.ResolvedConfig, requestor: LH.NavigationRequestor}} args
+ * @return {Promise<{baseArtifacts: LH.FRBaseArtifacts}>}
+ */
+export function _setup({ driver, resolvedConfig, requestor }: {
+    driver: Driver;
+    resolvedConfig: LH.Config.ResolvedConfig;
+    requestor: LH.NavigationRequestor;
+}): Promise<{
+    baseArtifacts: LH.FRBaseArtifacts;
+}>;
+/**
+ * @param {NavigationContext} navigationContext
+ * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
+ */
+export function _setupNavigation({ requestor, driver, navigation, resolvedConfig }: NavigationContext): Promise<{
+    warnings: Array<LH.IcuMessage>;
+}>;
+/**
+ * @param {NavigationContext} navigationContext
+ * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, navigationError: LH.LighthouseError | undefined, warnings: Array<LH.IcuMessage>}>}
+ */
+export function _navigate(navigationContext: NavigationContext): Promise<{
+    requestedUrl: string;
+    mainDocumentUrl: string;
+    navigationError: LH.LighthouseError | undefined;
+    warnings: Array<LH.IcuMessage>;
+}>;
+/**
+ * @param {NavigationContext} navigationContext
+ * @return {ReturnType<typeof _computeNavigationResult>}
+ */
+export function _navigation(navigationContext: NavigationContext): ReturnType<typeof _computeNavigationResult>;
+/**
+ * @param {{driver: Driver, page: LH.Puppeteer.Page, resolvedConfig: LH.Config.ResolvedConfig, requestor: LH.NavigationRequestor; baseArtifacts: LH.FRBaseArtifacts, computedCache: NavigationContext['computedCache']}} args
+ * @return {Promise<{artifacts: Partial<LH.FRArtifacts & LH.FRBaseArtifacts>}>}
+ */
+export function _navigations(args: {
+    driver: Driver;
+    page: LH.Puppeteer.Page;
+    resolvedConfig: LH.Config.ResolvedConfig;
+    requestor: LH.NavigationRequestor;
+    baseArtifacts: LH.FRBaseArtifacts;
+    computedCache: NavigationContext['computedCache'];
+}): Promise<{
+    artifacts: Partial<LH.FRArtifacts & LH.FRBaseArtifacts>;
+}>;
+/**
+ * @param {{requestedUrl?: string, driver: Driver, resolvedConfig: LH.Config.ResolvedConfig}} args
+ */
+export function _cleanup({ requestedUrl, driver, resolvedConfig }: {
+    requestedUrl?: string;
+    driver: Driver;
+    resolvedConfig: LH.Config.ResolvedConfig;
+}): Promise<void>;
+import { Driver } from "./driver.js";
+import { collectPhaseArtifacts } from "./runner-helpers.js";
+import { LighthouseError } from "../lib/lh-error.js";
+/**
+ * @param {NavigationContext} navigationContext
+ * @param {PhaseState} phaseState
+ * @param {Awaited<ReturnType<typeof _setupNavigation>>} setupResult
+ * @param {Awaited<ReturnType<typeof _navigate>>} navigateResult
+ * @return {Promise<{artifacts: Partial<LH.GathererArtifacts>, warnings: Array<LH.IcuMessage>, pageLoadError: LH.LighthouseError | undefined}>}
+ */
+declare function _computeNavigationResult(navigationContext: NavigationContext, phaseState: PhaseState, setupResult: Awaited<ReturnType<typeof _setupNavigation>>, navigateResult: Awaited<ReturnType<typeof _navigate>>): Promise<{
+    artifacts: Partial<LH.GathererArtifacts>;
+    warnings: Array<LH.IcuMessage>;
+    pageLoadError: LH.LighthouseError | undefined;
+}>;
+export {};
+//# sourceMappingURL=navigation-runner.d.ts.map

package/core/gather/runner-helpers.d.ts

@@ -0,0 +1,39 @@
+export type CollectPhaseArtifactOptions = {
+    driver: import('./driver.js').Driver;
+    page: LH.Puppeteer.Page;
+    artifactDefinitions: Array<LH.Config.AnyArtifactDefn>;
+    artifactState: ArtifactState;
+    baseArtifacts: LH.FRBaseArtifacts;
+    phase: LH.Gatherer.FRGatherPhase;
+    gatherMode: LH.Gatherer.GatherMode;
+    computedCache: Map<string, LH.ArbitraryEqualityMap>;
+    settings: LH.Config.Settings;
+};
+export type IntermediateArtifacts = Record<string, Promise<any>>;
+export type ArtifactState = Record<CollectPhaseArtifactOptions['phase'], IntermediateArtifacts>;
+export type Dependencies = LH.Gatherer.FRTransitionalContext<LH.Gatherer.DependencyKey>['dependencies'];
+/** @return {ArtifactState} */
+export function getEmptyArtifactState(): ArtifactState;
+/**
+ * Awaits the result of artifact, catching errors to set the artifact to an error instead.
+ *
+ * @param {ArtifactState} artifactState
+ * @return {Promise<Partial<LH.GathererArtifacts>>}
+ */
+export function awaitArtifacts(artifactState: ArtifactState): Promise<Partial<LH.GathererArtifacts>>;
+/**
+ * Runs the gatherer methods for a particular navigation phase (startInstrumentation/getArtifact/etc).
+ * All gatherer method return values are stored on the artifact state object, organized by phase.
+ * This method collects required dependencies, runs the applicable gatherer methods, and saves the
+ * result on the artifact state object that was passed as part of `options`.
+ *
+ * @param {CollectPhaseArtifactOptions} options
+ */
+export function collectPhaseArtifacts(options: CollectPhaseArtifactOptions): Promise<void>;
+/**
+ * @param {LH.Config.AnyArtifactDefn} artifact
+ * @param {Record<string, LH.Gatherer.PhaseResult>} artifactsById
+ * @return {Promise<Dependencies>}
+ */
+export function collectArtifactDependencies(artifact: LH.Config.AnyArtifactDefn, artifactsById: Record<string, LH.Gatherer.PhaseResult>): Promise<Dependencies>;
+//# sourceMappingURL=runner-helpers.d.ts.map

package/core/gather/session.d.ts

@@ -0,0 +1,50 @@
+export type CrdpEventMessageEmitter = LH.Protocol.StrictEventEmitterClass<LH.CrdpEvents>;
+declare const ProtocolSession_base: CrdpEventMessageEmitter;
+/** @implements {LH.Gatherer.FRProtocolSession} */
+export class ProtocolSession extends ProtocolSession_base implements LH.Gatherer.FRProtocolSession {
+    /**
+     * @param {LH.Puppeteer.CDPSession} cdpSession
+     */
+    constructor(cdpSession: LH.Puppeteer.CDPSession);
+    _cdpSession: import("../../types/puppeteer.js").default.CDPSession;
+    /** @type {LH.Crdp.Target.TargetInfo|undefined} */
+    _targetInfo: LH.Crdp.Target.TargetInfo | undefined;
+    /** @type {number|undefined} */
+    _nextProtocolTimeout: number | undefined;
+    /**
+     * Re-emit protocol events from the underlying CDPSession.
+     * @template {keyof LH.CrdpEvents} E
+     * @param {E} method
+     * @param {LH.CrdpEvents[E]} params
+     */
+    _handleProtocolEvent<E extends keyof import("puppeteer-core").ProtocolMapping.Events>(method: E, ...params: import("puppeteer-core").ProtocolMapping.Events[E]): void;
+    id(): string;
+    /** @param {LH.Crdp.Target.TargetInfo} targetInfo */
+    setTargetInfo(targetInfo: LH.Crdp.Target.TargetInfo): void;
+    /**
+     * @return {boolean}
+     */
+    hasNextProtocolTimeout(): boolean;
+    /**
+     * @return {number}
+     */
+    getNextProtocolTimeout(): number;
+    /**
+     * @param {number} ms
+     */
+    setNextProtocolTimeout(ms: number): void;
+    /**
+     * @template {keyof LH.CrdpCommands} C
+     * @param {C} method
+     * @param {LH.CrdpCommands[C]['paramsType']} params
+     * @return {Promise<LH.CrdpCommands[C]['returnType']>}
+     */
+    sendCommand<C extends keyof import("puppeteer-core").ProtocolMapping.Commands>(method: C, ...params: import("puppeteer-core").ProtocolMapping.Commands[C]["paramsType"]): Promise<import("puppeteer-core").ProtocolMapping.Commands[C]["returnType"]>;
+    /**
+     * Disposes of a session so that it can no longer talk to Chrome.
+     * @return {Promise<void>}
+     */
+    dispose(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=session.d.ts.map

package/core/gather/snapshot-runner.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {LH.Puppeteer.Page} page
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<LH.Gatherer.FRGatherResult>}
+ */
+export function snapshotGather(page: LH.Puppeteer.Page, options?: {
+    config?: import("../../types/config.js").default | undefined;
+    flags?: import("../index.js").Flags | undefined;
+} | undefined): Promise<LH.Gatherer.FRGatherResult>;
+//# sourceMappingURL=snapshot-runner.d.ts.map

package/core/gather/timespan-runner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {LH.Puppeteer.Page} page
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<{endTimespanGather(): Promise<LH.Gatherer.FRGatherResult>}>}
+ */
+export function startTimespanGather(page: LH.Puppeteer.Page, options?: {
+    config?: import("../../types/config.js").default | undefined;
+    flags?: import("../index.js").Flags | undefined;
+} | undefined): Promise<{
+    endTimespanGather(): Promise<LH.Gatherer.FRGatherResult>;
+}>;
+//# sourceMappingURL=timespan-runner.d.ts.map

package/core/index.d.cts

@@ -0,0 +1,4 @@
+export = lighthouse;
+/** @type {import('./index.js')['default']} */
+declare const lighthouse: typeof import("./index.js")['default'];
+//# sourceMappingURL=index.d.cts.map

package/core/index.d.ts

@@ -0,0 +1,88 @@
+export default lighthouse;
+export { Audit } from "./audits/audit.js";
+export { default as Gatherer } from "./gather/base-gatherer.js";
+export { NetworkRecords } from "./computed/network-records.js";
+export { default as defaultConfig } from "./config/default-config.js";
+export { default as desktopConfig } from "./config/desktop-config.js";
+export * from "../types/lh.js";
+export type Connection = import('./legacy/gather/connections/connection.js').Connection;
+/** @typedef {import('./legacy/gather/connections/connection.js').Connection} Connection */
+/**
+ * Run Lighthouse.
+ * @param {string=} url The URL to test. Optional if running in auditMode.
+ * @param {LH.Flags=} flags Optional settings for the Lighthouse run. If present,
+ *   they will override any settings in the config.
+ * @param {LH.Config=} config Configuration for the Lighthouse run. If
+ *   not present, the default config is used.
+ * @param {LH.Puppeteer.Page=} page
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+declare function lighthouse(url?: string | undefined, flags?: LH.Flags | undefined, config?: LH.Config | undefined, page?: LH.Puppeteer.Page | undefined): Promise<LH.RunnerResult | undefined>;
+/**
+ * Run Lighthouse using the legacy navigation runner.
+ * This is left in place for any clients that don't support FR navigations yet (e.g. Lightrider)
+ * @deprecated
+ * @param {string=} url The URL to test. Optional if running in auditMode.
+ * @param {LH.Flags=} flags Optional settings for the Lighthouse run. If present,
+ *   they will override any settings in the config.
+ * @param {LH.Config=} config Configuration for the Lighthouse run. If
+ *   not present, the default config is used.
+ * @param {Connection=} userConnection
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+export function legacyNavigation(url?: string | undefined, flags?: LH.Flags | undefined, config?: LH.Config | undefined, userConnection?: Connection | undefined): Promise<LH.RunnerResult | undefined>;
+/**
+ * @param {LH.Puppeteer.Page} page
+ * @param {LH.UserFlow.Options} [options]
+ */
+export function startFlow(page: LH.Puppeteer.Page, options?: LH.UserFlow.Options | undefined): Promise<UserFlow>;
+/**
+ * @param {LH.Puppeteer.Page|undefined} page
+ * @param {LH.NavigationRequestor|undefined} requestor
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+export function navigation(page: LH.Puppeteer.Page | undefined, requestor: LH.NavigationRequestor | undefined, options?: {
+    config?: LH.Config | undefined;
+    flags?: LH.Flags | undefined;
+} | undefined): Promise<LH.RunnerResult | undefined>;
+/**
+ * @param {LH.Puppeteer.Page} page
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<{endTimespan: () => Promise<LH.RunnerResult|undefined>}>}
+ */
+export function startTimespan(page: LH.Puppeteer.Page, options?: {
+    config?: LH.Config | undefined;
+    flags?: LH.Flags | undefined;
+} | undefined): Promise<{
+    endTimespan: () => Promise<LH.RunnerResult | undefined>;
+}>;
+/**
+ * @param {LH.Puppeteer.Page} page
+ * @param {{config?: LH.Config, flags?: LH.Flags}} [options]
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+export function snapshot(page: LH.Puppeteer.Page, options?: {
+    config?: LH.Config | undefined;
+    flags?: LH.Flags | undefined;
+} | undefined): Promise<LH.RunnerResult | undefined>;
+/**
+ * @template {LH.Result|LH.FlowResult} R
+ * @param {R} result
+ * @param {[R] extends [LH.Result] ? LH.OutputMode : Exclude<LH.OutputMode, 'csv'>} [format]
+ * @return {string}
+ */
+export function generateReport<R extends LH.Result | LH.FlowResult>(result: R, format?: ([R] extends [LH.Result] ? LH.OutputMode : "json" | "html") | undefined): string;
+/**
+ * @param {LH.UserFlow.FlowArtifacts} flowArtifacts
+ * @param {LH.Config} [config]
+ */
+export function auditFlowArtifacts(flowArtifacts: LH.UserFlow.FlowArtifacts, config?: LH.Config | undefined): Promise<{
+    steps: LH.FlowResult.Step[];
+    name: string;
+}>;
+export function getAuditList(): string[];
+export const traceCategories: string[];
+import * as LH from "../types/lh.js";
+import { UserFlow } from "./user-flow.js";
+//# sourceMappingURL=index.d.ts.map

package/core/index.js

@@ -16,6 +16,7 @@ import {ReportGenerator} from '../report/generator/report-generator.js';
 import {startTimespanGather} from './gather/timespan-runner.js';
 import {snapshotGather} from './gather/snapshot-runner.js';
 import {navigationGather} from './gather/navigation-runner.js';
+import * as LH from '../types/lh.js';
 
 /** @typedef {import('./legacy/gather/connections/connection.js').Connection} Connection */
 
@@ -157,6 +158,7 @@ export {default as Gatherer} from './gather/base-gatherer.js';
 export {NetworkRecords} from './computed/network-records.js';
 export {default as defaultConfig} from './config/default-config.js';
 export {default as desktopConfig} from './config/desktop-config.js';
+export * from '../types/lh.js';
 export {
   legacyNavigation,
   startFlow,

package/core/legacy/config/config.d.ts

@@ -0,0 +1,107 @@
+export type GathererConstructor = typeof import('../../gather/gatherers/gatherer.js').Gatherer;
+export type Gatherer = InstanceType<GathererConstructor>;
+/**
+ * @implements {LH.Config.LegacyResolvedConfig}
+ */
+export class LegacyResolvedConfig implements LH.Config.LegacyResolvedConfig {
+    /**
+     * Resolves the provided config (inherits from extended config, if set), resolves
+     * all referenced modules, and validates.
+     * @param {LH.Config=} config If not provided, uses the default config.
+     * @param {LH.Flags=} flags
+     * @return {Promise<LegacyResolvedConfig>}
+     */
+    static fromJson(config?: LH.Config | undefined, flags?: LH.Flags | undefined): Promise<LegacyResolvedConfig>;
+    /**
+     * @param {LH.Config} baseJSON The JSON of the configuration to extend
+     * @param {LH.Config} extendJSON The JSON of the extensions
+     * @return {LH.Config}
+     */
+    static extendConfigJSON(baseJSON: LH.Config, extendJSON: LH.Config): LH.Config;
+    /**
+     * @param {LH.Config['passes']} passes
+     * @return {?Array<Required<LH.Config.PassJson>>}
+     */
+    static augmentPassesWithDefaults(passes: LH.Config['passes']): Array<Required<LH.Config.PassJson>> | null;
+    /**
+     * Observed throttling methods (devtools/provided) require at least 5s of quiet for the metrics to
+     * be computed. This method adjusts the quiet thresholds to the required minimums if necessary.
+     * @param {LH.Config.Settings} settings
+     * @param {?Array<Required<LH.Config.PassJson>>} passes
+     */
+    static adjustDefaultPassForThrottling(settings: LH.Config.Settings, passes: Array<Required<LH.Config.PassJson>> | null): void;
+    /**
+     * Filter out any unrequested items from the config, based on requested categories or audits.
+     * @param {LegacyResolvedConfig} config
+     */
+    static filterConfigIfNeeded(config: LegacyResolvedConfig): void;
+    /**
+     * Filter out any unrequested categories or audits from the categories object.
+     * @param {LegacyResolvedConfig['categories']} oldCategories
+     * @param {LH.Config.Settings} settings
+     * @return {{categories: LegacyResolvedConfig['categories'], requestedAuditNames: Set<string>}}
+     */
+    static filterCategoriesAndAudits(oldCategories: LegacyResolvedConfig['categories'], settings: LH.Config.Settings): {
+        categories: LegacyResolvedConfig['categories'];
+        requestedAuditNames: Set<string>;
+    };
+    /**
+     * From some requested audits, return names of all required and optional artifacts
+     * @param {LegacyResolvedConfig['audits']} audits
+     * @return {Set<string>}
+     */
+    static getGatherersRequestedByAudits(audits: LegacyResolvedConfig['audits']): Set<string>;
+    /**
+     * Filters to only requested passes and gatherers, returning a new passes array.
+     * @param {LegacyResolvedConfig['passes']} passes
+     * @param {Set<string>} requestedGatherers
+     * @return {LegacyResolvedConfig['passes']}
+     */
+    static generatePassesNeededByGatherers(passes: LegacyResolvedConfig['passes'], requestedGatherers: Set<string>): LegacyResolvedConfig['passes'];
+    /**
+     * Take an array of audits and audit paths and require any paths (possibly
+     * relative to the optional `configDir`) using `resolveModulePath`,
+     * leaving only an array of AuditDefns.
+     * @param {LH.Config['audits']} audits
+     * @param {string=} configDir
+     * @return {Promise<LegacyResolvedConfig['audits']>}
+     */
+    static requireAudits(audits: LH.Config['audits'], configDir?: string | undefined): Promise<LegacyResolvedConfig['audits']>;
+    /**
+     * Takes an array of passes with every property now initialized except the
+     * gatherers and requires them, (relative to the optional `configDir` if
+     * provided) using `resolveModulePath`, returning an array of full Passes.
+     * @param {?Array<Required<LH.Config.PassJson>>} passes
+     * @param {string=} configDir
+     * @return {Promise<LegacyResolvedConfig['passes']>}
+     */
+    static requireGatherers(passes: Array<Required<LH.Config.PassJson>> | null, configDir?: string | undefined): Promise<LegacyResolvedConfig['passes']>;
+    /**
+     * @deprecated `Config.fromJson` should be used instead.
+     * @constructor
+     * @param {LH.Config} config
+     * @param {{settings: LH.Config.Settings, passes: ?LH.Config.Pass[], audits: ?LH.Config.AuditDefn[]}} opts
+     */
+    constructor(config: LH.Config, opts: {
+        settings: LH.Config.Settings;
+        passes: LH.Config.Pass[] | null;
+        audits: LH.Config.AuditDefn[] | null;
+    });
+    /** @type {LH.Config.Settings} */
+    settings: LH.Config.Settings;
+    /** @type {?Array<LH.Config.Pass>} */
+    passes: Array<LH.Config.Pass> | null;
+    /** @type {?Array<LH.Config.AuditDefn>} */
+    audits: Array<LH.Config.AuditDefn> | null;
+    /** @type {?Record<string, LH.Config.Category>} */
+    categories: Record<string, LH.Config.Category> | null;
+    /** @type {?Record<string, LH.Config.Group>} */
+    groups: Record<string, LH.Config.Group> | null;
+    /**
+     * Provides a cleaned-up, stringified version of this config. Gatherer and
+     * Audit `implementation` and `instance` do not survive this process.
+     * @return {string}
+     */
+    getPrintString(): string;
+}
+//# sourceMappingURL=config.d.ts.map

package/core/legacy/config/legacy-default-config.d.ts

@@ -0,0 +1,4 @@
+export default legacyDefaultConfig;
+/** @type {LH.Config} */
+declare const legacyDefaultConfig: LH.Config;
+//# sourceMappingURL=legacy-default-config.d.ts.map