lighthouse 9.5.0-dev.20230118 → 9.5.0-dev.20230119

package/cli/bin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @return {Promise<LH.RunnerResult|void>}
+ */
+export function begin(): Promise<LH.RunnerResult | void>;
+//# sourceMappingURL=bin.d.ts.map

package/cli/cli-flags.d.ts

@@ -0,0 +1,258 @@
+/**
+ * @param {string=} manualArgv
+ * @param {{noExitOnFailure?: boolean}=} options
+ * @return {LH.CliFlags}
+ */
+export function getFlags(manualArgv?: string | undefined, options?: {
+    noExitOnFailure?: boolean;
+} | undefined): LH.CliFlags;
+/**
+ * @param {string=} manualArgv
+ */
+export function getYargsParser(manualArgv?: string | undefined): yargs.Argv<yargs.Omit<yargs.Omit<yargs.Omit<yargs.Omit<yargs.Omit<yargs.Omit<yargs.Omit<yargs.Omit<{
+    _: string[] | undefined;
+} & {
+    "cli-flags-path": unknown;
+}, "verbose" | "quiet"> & yargs.InferredOptionTypes<{
+    verbose: {
+        type: "boolean";
+        default: boolean;
+        describe: string;
+    };
+    quiet: {
+        type: "boolean";
+        default: boolean;
+        describe: string;
+    };
+}>, "port" | "screenEmulation" | "emulatedUserAgent" | "hostname" | "preset" | "save-assets" | "list-all-audits" | "list-locales" | "list-trace-categories" | "debug-navigation" | "legacy-navigation" | "additional-trace-categories" | "config-path" | "chrome-flags" | "form-factor" | "max-wait-for-load" | "enable-error-reporting" | "gather-mode" | "audit-mode" | "only-audits" | "only-categories" | "skip-audits" | "budget-path" | "disable-full-page-screenshot"> & yargs.InferredOptionTypes<{
+    'save-assets': {
+        type: "boolean";
+        default: boolean;
+        describe: string;
+    };
+    'list-all-audits': {
+        type: "boolean";
+        default: boolean;
+        describe: string;
+    };
+    'list-locales': {
+        type: "boolean";
+        default: boolean;
+        describe: string;
+    };
+    'list-trace-categories': {
+        type: "boolean";
+        default: boolean;
+        describe: string;
+    };
+    'debug-navigation': {
+        type: "boolean";
+        describe: string;
+    };
+    'legacy-navigation': {
+        type: "boolean";
+        default: boolean;
+        describe: string;
+    };
+    'additional-trace-categories': {
+        type: "string";
+        describe: string;
+    };
+    'config-path': {
+        type: "string";
+        describe: string;
+    };
+    preset: {
+        type: "string";
+        describe: string;
+    };
+    'chrome-flags': {
+        type: "string";
+        default: string;
+        describe: string;
+    };
+    port: {
+        type: "number";
+        default: number;
+        describe: string;
+    };
+    hostname: {
+        type: "string";
+        default: string;
+        describe: string;
+    };
+    'form-factor': {
+        type: "string";
+        describe: string;
+    };
+    screenEmulation: {
+        describe: string;
+        coerce: typeof coerceScreenEmulation;
+    };
+    emulatedUserAgent: {
+        type: "string";
+        coerce: typeof coerceOptionalStringBoolean;
+        describe: string;
+    };
+    'max-wait-for-load': {
+        type: "number";
+        describe: string;
+    };
+    'enable-error-reporting': {
+        type: "boolean";
+        describe: string;
+    };
+    'gather-mode': {
+        alias: string;
+        coerce: typeof coerceOptionalStringBoolean;
+        describe: string;
+    };
+    'audit-mode': {
+        alias: string;
+        coerce: typeof coerceOptionalStringBoolean;
+        describe: string;
+    };
+    'only-audits': {
+        array: true;
+        type: "string";
+        coerce: typeof splitCommaSeparatedValues;
+        describe: string;
+    };
+    'only-categories': {
+        array: true;
+        type: "string";
+        coerce: typeof splitCommaSeparatedValues;
+        describe: string;
+    };
+    'skip-audits': {
+        array: true;
+        type: "string";
+        coerce: typeof splitCommaSeparatedValues;
+        describe: string;
+    };
+    'budget-path': {
+        type: "string";
+        describe: string;
+    };
+    'disable-full-page-screenshot': {
+        type: "boolean";
+        describe: string;
+    };
+}>, "output" | "view" | "output-path"> & yargs.InferredOptionTypes<{
+    output: {
+        type: "array";
+        default: readonly ["html"];
+        coerce: typeof coerceOutput;
+        describe: string;
+    };
+    'output-path': {
+        type: "string";
+        coerce: typeof coerceOutputPath;
+        describe: string;
+    };
+    view: {
+        type: "boolean";
+        default: boolean;
+        describe: string;
+    };
+}>, "locale" | "blocked-url-patterns" | "disable-storage-reset" | "throttling-method"> & yargs.InferredOptionTypes<{
+    locale: {
+        coerce: typeof coerceLocale;
+        describe: string;
+    };
+    'blocked-url-patterns': {
+        array: true;
+        type: "string";
+        describe: string;
+    };
+    'disable-storage-reset': {
+        type: "boolean";
+        describe: string;
+    };
+    'throttling-method': {
+        type: "string";
+        describe: string;
+    };
+}> & {
+    throttling: import("../types/lh.js").ThrottlingSettings | undefined;
+}, "channel" | "plugins" | "extra-headers" | "precomputed-lantern-data-path" | "lantern-data-output-path" | "chrome-ignore-default-flags"> & yargs.InferredOptionTypes<{
+    'extra-headers': {
+        coerce: typeof coerceExtraHeaders;
+        describe: string;
+    };
+    'precomputed-lantern-data-path': {
+        type: "string";
+        describe: string;
+    };
+    'lantern-data-output-path': {
+        type: "string";
+        describe: string;
+    };
+    plugins: {
+        array: true;
+        type: "string";
+        coerce: typeof splitCommaSeparatedValues;
+        describe: string;
+    };
+    channel: {
+        type: "string";
+        default: string;
+    };
+    'chrome-ignore-default-flags': {
+        type: "boolean";
+        default: boolean;
+    };
+}>, "form-factor"> & {
+    "form-factor": "mobile" | "desktop" | undefined;
+}, "throttling-method"> & {
+    "throttling-method": "devtools" | "simulate" | "provided" | undefined;
+}, "preset"> & {
+    preset: "desktop" | "experimental" | "perf" | undefined;
+}>;
+import yargs from "yargs";
+/**
+ * Take yarg's unchecked object value and ensure it is a proper LH.screenEmulationSettings.
+ * @param {unknown} value
+ * @return {Partial<LH.ScreenEmulationSettings>|undefined}
+ */
+declare function coerceScreenEmulation(value: unknown): Partial<LH.ScreenEmulationSettings> | undefined;
+/**
+ * @param {unknown} value
+ * @return {boolean|string|undefined}
+ */
+declare function coerceOptionalStringBoolean(value: unknown): boolean | string | undefined;
+/**
+ * Support comma-separated values for some array flags by splitting on any ',' found.
+ * @param {Array<string>=} strings
+ * @return {Array<string>=}
+ */
+declare function splitCommaSeparatedValues(strings?: Array<string> | undefined): Array<string> | undefined;
+/**
+ * Coerce output CLI input to `LH.SharedFlagsSettings['output']` or throw if not possible.
+ * @param {Array<unknown>} values
+ * @return {Array<LH.OutputMode>}
+ */
+declare function coerceOutput(values: Array<unknown>): Array<LH.OutputMode>;
+/**
+ * Verifies outputPath is something we can actually write to.
+ * @param {unknown=} value
+ * @return {string=}
+ */
+declare function coerceOutputPath(value?: unknown | undefined): string | undefined;
+/**
+ * Verifies value is a string, then coerces type to LH.Locale for convenience. However, don't
+ * allowlist specific locales. Why? So we can support the user who requests 'es-MX' (unsupported)
+ * and we'll fall back to 'es' (supported).
+ * @param {unknown} value
+ * @return {LH.Locale|undefined}
+ */
+declare function coerceLocale(value: unknown): LH.Locale | undefined;
+/**
+ * `--extra-headers` comes in as a JSON string or a path to a JSON string, but the flag value
+ * needs to be the parsed object. Load file (if necessary) and returns the parsed object.
+ * @param {unknown} value
+ * @return {LH.SharedFlagsSettings['extraHeaders']}
+ */
+declare function coerceExtraHeaders(value: unknown): LH.SharedFlagsSettings['extraHeaders'];
+export {};
+//# sourceMappingURL=cli-flags.d.ts.map

package/cli/commands/commands.d.ts

@@ -0,0 +1,4 @@
+export { listAudits } from "./list-audits.js";
+export { listTraceCategories } from "./list-trace-categories.js";
+export { listLocales } from "./list-locales.js";
+//# sourceMappingURL=commands.d.ts.map

package/cli/commands/list-audits.d.ts

@@ -0,0 +1,2 @@
+export function listAudits(): void;
+//# sourceMappingURL=list-audits.d.ts.map

package/cli/commands/list-locales.d.ts

@@ -0,0 +1,2 @@
+export function listLocales(): void;
+//# sourceMappingURL=list-locales.d.ts.map

package/cli/commands/list-trace-categories.d.ts

@@ -0,0 +1,2 @@
+export function listTraceCategories(): void;
+//# sourceMappingURL=list-trace-categories.d.ts.map

package/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/cli/printer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Verify output path to use, either stdout or a file path.
+ * @param {string} path
+ * @return {string}
+ */
+export function checkOutputPath(path: string): string;
+/**
+ * Writes the output.
+ * @param {string} output
+ * @param {LH.OutputMode} mode
+ * @param {string} path
+ * @return {Promise<void>}
+ */
+export function write(output: string, mode: LH.OutputMode, path: string): Promise<void>;
+/**
+ * An enumeration of acceptable output modes:
+ *   'json': JSON formatted results
+ *   'html': An HTML report
+ *   'csv': CSV formatted results
+ * @type {LH.Util.SelfMap<LH.OutputMode>}
+ */
+export const OutputMode: LH.Util.SelfMap<LH.OutputMode>;
+/**
+ * Returns a list of valid output options.
+ * @return {Array<string>}
+ */
+export function getValidOutputOptions(): Array<string>;
+//# sourceMappingURL=printer.d.ts.map

package/cli/run.d.ts

@@ -0,0 +1,24 @@
+export type ExitError = Error & {
+    code: string;
+    friendlyMessage?: string;
+};
+/**
+ * exported for testing
+ * @param {string|Array<string>} flags
+ * @return {Array<string>}
+ */
+export function parseChromeFlags(flags?: string | Array<string>): Array<string>;
+/**
+ * @param {LH.RunnerResult} runnerResult
+ * @param {LH.CliFlags} flags
+ * @return {Promise<void>}
+ */
+export function saveResults(runnerResult: LH.RunnerResult, flags: LH.CliFlags): Promise<void>;
+/**
+ * @param {string} url
+ * @param {LH.CliFlags} flags
+ * @param {LH.Config|undefined} config
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+export function runLighthouse(url: string, flags: LH.CliFlags, config: LH.Config | undefined): Promise<LH.RunnerResult | undefined>;
+//# sourceMappingURL=run.d.ts.map

package/cli/sentry-prompt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @return {Promise<boolean>}
+ */
+export function askPermission(): Promise<boolean>;
+//# sourceMappingURL=sentry-prompt.d.ts.map

package/cli/test/smokehouse/config/exclusions.d.ts

@@ -0,0 +1,12 @@
+export default exclusions;
+/**
+ * @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.
+ */
+/**
+ * List of smoke tests excluded per runner. eg: 'cli': ['a11y', 'dbw']
+ * @type {Record<string, Array<string>>}
+ */
+declare const exclusions: Record<string, Array<string>>;
+//# sourceMappingURL=exclusions.d.ts.map

package/cli/test/smokehouse/core-tests.d.ts

@@ -0,0 +1,4 @@
+export default smokeTests;
+/** @type {ReadonlyArray<Smokehouse.TestDfn>} */
+declare const smokeTests: ReadonlyArray<Smokehouse.TestDfn>;
+//# sourceMappingURL=core-tests.d.ts.map

package/cli/test/smokehouse/frontends/back-compat-util.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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.
+ */
+/**
+ * COMPAT: update from the old TestDefn format (array of `expectations` per
+ * definition) to the new format (single `expectations` per def), doing our best
+ * generating some unique IDs.
+ * TODO: remove in Lighthouse 9+ once PubAds (and others?) are updated.
+ * @see https://github.com/GoogleChrome/lighthouse/issues/11950
+ * @param {ReadonlyArray<Smokehouse.BackCompatTestDefn>} allTestDefns
+ * @return {Array<Smokehouse.TestDfn>}
+ */
+export function updateTestDefnFormat(allTestDefns: ReadonlyArray<Smokehouse.BackCompatTestDefn>): Array<Smokehouse.TestDfn>;
+//# sourceMappingURL=back-compat-util.d.ts.map

package/cli/test/smokehouse/frontends/lib.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {Smokehouse.SmokehouseLibOptions} options
+ */
+export function smokehouse(options: Smokehouse.SmokehouseLibOptions): Promise<{
+    success: boolean;
+    testResults: import("../smokehouse.js").SmokehouseResult[];
+}>;
+//# sourceMappingURL=lib.d.ts.map

package/cli/test/smokehouse/frontends/node.d.ts

@@ -0,0 +1,2 @@
+export * from "../smokehouse.js";
+//# sourceMappingURL=node.d.ts.map

package/cli/test/smokehouse/frontends/smokehouse-bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=smokehouse-bin.d.ts.map

package/cli/test/smokehouse/lib/child-process-error.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license Copyright 2019 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.
+ */
+/**
+ * An extension of Error that includes any stdout or stderr from a child
+ * process. Based on the error thrown by `child_process.exec()`.
+ * https://github.com/nodejs/node/blob/3aeae8d81b7b78668c37f7a07a72d94781126d49/lib/child_process.js#L150-L176
+ */
+export class ChildProcessError extends Error {
+    /**
+     * @param {string} message
+     * @param {string=} stdout
+     * @param {string=} stderr
+     */
+    constructor(message: string, stdout?: string | undefined, stderr?: string | undefined);
+    stdout: string;
+    stderr: string;
+}
+//# sourceMappingURL=child-process-error.d.ts.map

package/cli/test/smokehouse/lib/concurrent-mapper.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @license Copyright 2019 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.
+ */
+/**
+ * A class that maintains a concurrency pool to coordinate many jobs that should
+ * only be run `concurrencyLimit` at a time.
+ * API inspired by http://bluebirdjs.com/docs/api/promise.map.html, but
+ * independent callers of `concurrentMap()` share the same concurrency limit.
+ */
+export class ConcurrentMapper {
+    /**
+     * Runs callbackfn on `values` in parallel, at a max of `concurrency` at a
+     * time. Resolves to an array of the results or rejects with the first
+     * rejected result. Default `concurrency` limit is `Infinity`.
+     * @template T, U
+     * @param {Array<T>} values
+     * @param {(value: T, index: number, array: Array<T>) => Promise<U>} callbackfn
+     * @param {{concurrency: number}} [options]
+     * @return {Promise<Array<U>>}
+     */
+    static map<T_1, U_2>(values: T_1[], callbackfn: (value: T_1, index: number, array: T_1[]) => Promise<U_2>, options?: {
+        concurrency: number;
+    } | undefined): Promise<U_2[]>;
+    /** @type {Set<Promise<unknown>>} */
+    _promisePool: Set<Promise<unknown>>;
+    /**
+     * The limits of all currently running jobs. There will be duplicates.
+     * @type {Array<number>}
+     */
+    _allConcurrencyLimits: Array<number>;
+    /**
+     * Returns whether there are fewer running jobs than the minimum current
+     * concurrency limit and the proposed new `concurrencyLimit`.
+     * @param {number} concurrencyLimit
+     */
+    _canRunMoreAtLimit(concurrencyLimit: number): boolean;
+    /**
+     * Add a job to pool.
+     * @param {Promise<unknown>} job
+     * @param {number} concurrencyLimit
+     */
+    _addJob(job: Promise<unknown>, concurrencyLimit: number): void;
+    /**
+     * Remove a job from pool.
+     * @param {Promise<unknown>} job
+     * @param {number} concurrencyLimit
+     */
+    _removeJob(job: Promise<unknown>, concurrencyLimit: number): void;
+    /**
+     * Runs callbackfn on `values` in parallel, at a max of `concurrency` at
+     * a time across all callers on this instance. Resolves to an array of the
+     * results (for each caller separately) or rejects with the first rejected
+     * result. Default `concurrency` limit is `Infinity`.
+     * @template T, U
+     * @param {Array<T>} values
+     * @param {(value: T, index: number, array: Array<T>) => Promise<U>} callbackfn
+     * @param {{concurrency: number}} [options]
+     * @return {Promise<Array<U>>}
+     */
+    pooledMap<T, U>(values: T[], callbackfn: (value: T, index: number, array: T[]) => Promise<U>, options?: {
+        concurrency: number;
+    } | undefined): Promise<U[]>;
+    /**
+     * Runs `fn` concurrent to other operations in the pool, at a max of
+     * `concurrency` at a time across all callers on this instance. Default
+     * `concurrency` limit is `Infinity`.
+     * @template U
+     * @param {() => Promise<U>} fn
+     * @param {{concurrency: number}} [options]
+     * @return {Promise<U>}
+     */
+    runInPool<U_1>(fn: () => Promise<U_1>, options?: {
+        concurrency: number;
+    } | undefined): Promise<U_1>;
+}
+//# sourceMappingURL=concurrent-mapper.d.ts.map

package/cli/test/smokehouse/lib/local-console.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license Copyright 2019 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.
+ */
+/**
+ * A simple buffered log to use in place of `console`.
+ */
+export class LocalConsole {
+    _log: string;
+    /**
+     * @param {string} str
+     */
+    log(str: string): void;
+    /**
+     * Log but without the ending newline.
+     * @param {string} str
+     */
+    write(str: string): void;
+    /**
+     * @return {string}
+     */
+    getLog(): string;
+    /**
+     * Append a stdout and stderr to this log.
+     * @param {{stdout: string, stderr: string}} stdStrings
+     */
+    adoptStdStrings(stdStrings: {
+        stdout: string;
+        stderr: string;
+    }): void;
+}
+//# sourceMappingURL=local-console.d.ts.map

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

@@ -0,0 +1,16 @@
+/**
+ * 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
+ * @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;
+    log: string;
+}>;
+//# sourceMappingURL=bundle.d.ts.map

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

@@ -0,0 +1,18 @@
+/// <reference path="../../../../../../types/internal/lighthouse-logger.d.ts" />
+/**
+ * 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
+ * @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;
+    log: string;
+}>;
+import log from "lighthouse-logger";
+//# sourceMappingURL=cli.d.ts.map

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

@@ -0,0 +1,23 @@
+/**
+ * Launch Chrome and do a full Lighthouse run via DevTools.
+ * By default, the latest DevTools frontend is used (.tmp/chromium-web-tests/devtools/devtools-frontend)
+ * unless DEVTOOLS_PATH is set.
+ * CHROME_PATH determines which Chrome is used–otherwise the default is puppeteer's chrome binary.
+ * @param {string} url
+ * @param {LH.Config=} config
+ * @param {{isDebug?: boolean, useLegacyNavigation?: 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;
+    log: string;
+}>;
+/**
+ * Download/pull latest DevTools, build Lighthouse for DevTools, roll to DevTools, and build DevTools.
+ */
+export function setup(): Promise<void>;
+//# sourceMappingURL=devtools.d.ts.map

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

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

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

@@ -0,0 +1,50 @@
+/// <reference path="../../../../../types/internal/lighthouse-logger.d.ts" />
+export type Difference = {
+    path: string;
+    actual: any;
+    expected: any;
+};
+export type Comparison = {
+    name: string;
+    actual: any;
+    expected: any;
+    equal: boolean;
+    diffs: Difference[] | null;
+};
+/**
+ * Log all the comparisons between actual and expected test results, then print
+ * 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
+ * @return {{passed: number, failed: number, log: string}}
+ */
+export function getAssertionReport(actual: {
+    lhr: LH.Result;
+    artifacts: LH.Artifacts;
+    networkRequests?: string[];
+}, expected: Smokehouse.ExpectedRunnerResult, reportOptions?: {
+    runner?: string;
+    isDebug?: boolean;
+    useLegacyNavigation?: boolean;
+} | undefined): {
+    passed: number;
+    failed: number;
+    log: string;
+};
+/**
+ * Walk down expected result, comparing to actual result. If a difference is found,
+ * the path to the difference is returned, along with the expected primitive value
+ * and the value actually found at that location. If no difference is found, returns
+ * null.
+ *
+ * Only checks own enumerable properties, not object prototypes, and will loop
+ * until the stack is exhausted, so works best with simple objects (e.g. parsed JSON).
+ * @param {string} path
+ * @param {*} actual
+ * @param {*} expected
+ * @return {Difference[]|null}
+ */
+export function findDifferences(path: string, actual: any, expected: any): Difference[] | null;
+import log from "lighthouse-logger";
+//# sourceMappingURL=report-assert.d.ts.map