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

package/core/lib/manifest-parser.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Parse a manifest from the given inputs.
+ * @param {string} string Manifest JSON string.
+ * @param {string} manifestUrl URL of manifest file.
+ * @param {string} documentUrl URL of document containing manifest link element.
+ */
+export function parseManifest(string: string, manifestUrl: string, documentUrl: string): {
+    raw: string;
+    value: undefined;
+    warning: string;
+    url: string;
+} | {
+    raw: string;
+    value: {
+        name: {
+            raw: any;
+            value: string | undefined;
+            warning: string | undefined;
+        };
+        short_name: {
+            raw: any;
+            value: string | undefined;
+            warning: string | undefined;
+        };
+        start_url: {
+            raw: any;
+            value: string;
+            warning?: string | undefined;
+        };
+        display: {
+            raw: any;
+            value: string;
+            warning: string | undefined;
+        };
+        orientation: {
+            raw: any;
+            value: string | undefined;
+            warning: string | undefined;
+        };
+        icons: {
+            raw: any;
+            /** @type {Array<ReturnType<typeof parseIcon>>} */
+            value: Array<ReturnType<typeof parseIcon>>;
+            warning: undefined;
+        } | {
+            raw: any;
+            /** @type {Array<ReturnType<typeof parseIcon>>} */
+            value: Array<ReturnType<typeof parseIcon>>;
+            warning: string;
+        } | {
+            raw: any[];
+            value: {
+                raw: any;
+                value: {
+                    src: {
+                        raw: any;
+                        value: string | undefined;
+                        warning: string | undefined;
+                    };
+                    type: {
+                        raw: any;
+                        value: string | undefined;
+                        warning: string | undefined;
+                    };
+                    density: {
+                        raw: any;
+                        value: number;
+                        /** @type {string|undefined} */
+                        warning: string | undefined;
+                    };
+                    sizes: {
+                        raw: any;
+                        value: string[] | undefined;
+                        warning: undefined;
+                    } | {
+                        value: undefined;
+                        raw: any;
+                        warning: string | undefined;
+                    };
+                    purpose: {
+                        raw: any;
+                        value: string[];
+                        /** @type {string|undefined} */
+                        warning: string | undefined;
+                    };
+                };
+                warning: undefined;
+            }[];
+            warning: string | undefined;
+        };
+        related_applications: {
+            raw: any;
+            value: undefined;
+            warning: undefined;
+        } | {
+            raw: any;
+            value: undefined;
+            warning: string;
+        } | {
+            raw: any[];
+            value: {
+                raw: any;
+                value: {
+                    platform: {
+                        raw: any;
+                        value: string | undefined;
+                        warning: string | undefined;
+                    };
+                    id: {
+                        raw: any;
+                        value: string | undefined;
+                        warning: string | undefined;
+                    };
+                    url: {
+                        raw: any;
+                        value: string | undefined;
+                        warning: string | undefined;
+                    };
+                };
+                warning: undefined;
+            }[];
+            warning: undefined;
+        };
+        prefer_related_applications: {
+            raw: any;
+            value: boolean | undefined;
+            warning: string | undefined;
+        };
+        theme_color: {
+            raw: any;
+            value: string | undefined;
+            warning: string | undefined;
+        };
+        background_color: {
+            raw: any;
+            value: string | undefined;
+            warning: string | undefined;
+        };
+    };
+    warning: string | undefined;
+    url: string;
+};
+/**
+ * @see https://www.w3.org/TR/2016/WD-appmanifest-20160825/#src-member
+ * @param {*} raw
+ * @param {string} manifestUrl
+ */
+declare function parseIcon(raw: any, manifestUrl: string): {
+    raw: any;
+    value: {
+        src: {
+            raw: any;
+            value: string | undefined;
+            warning: string | undefined;
+        };
+        type: {
+            raw: any;
+            value: string | undefined;
+            warning: string | undefined;
+        };
+        density: {
+            raw: any;
+            value: number;
+            /** @type {string|undefined} */
+            warning: string | undefined;
+        };
+        sizes: {
+            raw: any;
+            value: string[] | undefined;
+            warning: undefined;
+        } | {
+            value: undefined;
+            raw: any;
+            warning: string | undefined;
+        };
+        purpose: {
+            raw: any;
+            value: string[];
+            /** @type {string|undefined} */
+            warning: string | undefined;
+        };
+    };
+    warning: undefined;
+};
+export {};
+//# sourceMappingURL=manifest-parser.d.ts.map

package/core/lib/median-run.d.ts

@@ -0,0 +1,17 @@
+/**
+ * We want the run that's closest to the median of the FCP and the median of the TTI.
+ * We're using the Euclidean distance for that (https://en.wikipedia.org/wiki/Euclidean_distance).
+ * We use FCP and TTI because they represent the earliest and latest moments in the page lifecycle.
+ * We avoid the median of single measures like the performance score because they can still exhibit
+ * outlier behavior at the beginning or end of load.
+ *
+ * @param {Array<LH.Result>} runs
+ * @return {LH.Result}
+ */
+export function computeMedianRun(runs: Array<LH.Result>): LH.Result;
+/**
+ * @param {Array<LH.Result>} runs
+ * @return {Array<LH.Result>}
+ */
+export function filterToValidRuns(runs: Array<LH.Result>): Array<LH.Result>;
+//# sourceMappingURL=median-run.d.ts.map

package/core/lib/minification-estimator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {string} content
+ */
+export function computeJSTokenLength(content: string): number;
+/**
+ * @param {string} content
+ */
+export function computeCSSTokenLength(content: string): number;
+//# sourceMappingURL=minification-estimator.d.ts.map

package/core/lib/minify-devtoolslog.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {LH.DevtoolsLog} log
+ * @return {LH.DevtoolsLog}
+ */
+export function minifyDevtoolsLog(log: import("..").DevtoolsLog): import("..").DevtoolsLog;
+//# sourceMappingURL=minify-devtoolslog.d.ts.map

package/core/lib/minify-trace.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {LH.Trace} inputTrace
+ * @return {LH.Trace}
+ */
+export function minifyTrace(inputTrace: LH.Trace): LH.Trace;
+//# sourceMappingURL=minify-trace.d.ts.map

package/core/lib/navigation-error.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Returns an error if the original network request failed or wasn't found.
+ * @param {LH.Artifacts.NetworkRequest|undefined} mainRecord
+ * @return {LH.LighthouseError|undefined}
+ */
+export function getNetworkError(mainRecord: LH.Artifacts.NetworkRequest | undefined): LH.LighthouseError | undefined;
+/**
+ * Returns an error if we ended up on the `chrome-error` page and all other requests failed.
+ * @param {LH.Artifacts.NetworkRequest|undefined} mainRecord
+ * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+ * @return {LH.LighthouseError|undefined}
+ */
+export function getInterstitialError(mainRecord: LH.Artifacts.NetworkRequest | undefined, networkRecords: Array<LH.Artifacts.NetworkRequest>): LH.LighthouseError | undefined;
+/**
+ * Returns an error if the page load should be considered failed, e.g. from a
+ * main document request failure, a security issue, etc.
+ * @param {LH.LighthouseError|undefined} navigationError
+ * @param {{url: string, loadFailureMode: LH.Gatherer.PassContext['passConfig']['loadFailureMode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
+ * @return {LH.LighthouseError|undefined}
+ */
+export function getPageLoadError(navigationError: LH.LighthouseError | undefined, context: {
+    url: string;
+    loadFailureMode: LH.Gatherer.PassContext['passConfig']['loadFailureMode'];
+    networkRecords: Array<LH.Artifacts.NetworkRequest>;
+    warnings: Array<string | LH.IcuMessage>;
+}): LH.LighthouseError | undefined;
+/**
+ * Returns an error if we try to load a non-HTML page.
+ * Expects a network request with all redirects resolved, otherwise the MIME type may be incorrect.
+ * @param {LH.Artifacts.NetworkRequest|undefined} finalRecord
+ * @return {LH.LighthouseError|undefined}
+ */
+export function getNonHtmlError(finalRecord: LH.Artifacts.NetworkRequest | undefined): LH.LighthouseError | undefined;
+export namespace UIStrings {
+    const warningXhtml: string;
+}
+import { NetworkRequest } from "./network-request.js";
+import { LighthouseError } from "./lh-error.js";
+//# sourceMappingURL=navigation-error.d.ts.map

package/core/lib/network-recorder.d.ts

@@ -0,0 +1,115 @@
+export type NetworkRecorderEventMap = {
+    requeststarted: [NetworkRequest];
+    requestfinished: [NetworkRequest];
+};
+export type RequestEmitter = LH.Protocol.StrictEventEmitterClass<NetworkRecorderEventMap>;
+declare const NetworkRecorder_base: RequestEmitter;
+export class NetworkRecorder extends NetworkRecorder_base {
+    /**
+     * @param {NetworkRequest} record The record to find the initiator of
+     * @param {Map<string, NetworkRequest[]>} recordsByURL
+     * @return {NetworkRequest|null}
+     * @private
+     */
+    private static _chooseInitiatorRequest;
+    /**
+     * Construct network records from a log of devtools protocol messages.
+     * @param {LH.DevtoolsLog} devtoolsLog
+     * @return {Array<LH.Artifacts.NetworkRequest>}
+     */
+    static recordsFromLogs(devtoolsLog: import("../index.js").DevtoolsLog): Array<LH.Artifacts.NetworkRequest>;
+    /** @type {NetworkRequest[]} */
+    _records: NetworkRequest[];
+    /** @type {Map<string, NetworkRequest>} */
+    _recordsById: Map<string, NetworkRequest>;
+    /** @type {string|null|undefined} */
+    _mainSessionId: string | null | undefined;
+    /**
+     * Returns the array of raw network request data without finalizing the initiator and
+     * redirect chain.
+     * @return {Array<NetworkRequest>}
+     */
+    getRawRecords(): Array<NetworkRequest>;
+    /**
+     * Listener for the DevTools SDK NetworkManager's RequestStarted event, which includes both
+     * web socket and normal request creation.
+     * @param {NetworkRequest} request
+     * @private
+     */
+    private onRequestStarted;
+    /**
+     * Listener for the DevTools SDK NetworkManager's RequestFinished event, which includes
+     * request finish, failure, and redirect, as well as the closing of web sockets.
+     * @param {NetworkRequest} request
+     * @private
+     */
+    private onRequestFinished;
+    /**
+     * @param {{params: LH.Crdp.Network.RequestWillBeSentEvent, sessionId?: string}} event
+     */
+    onRequestWillBeSent(event: {
+        params: LH.Crdp.Network.RequestWillBeSentEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.RequestServedFromCacheEvent, sessionId?: string}} event
+     */
+    onRequestServedFromCache(event: {
+        params: LH.Crdp.Network.RequestServedFromCacheEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.ResponseReceivedEvent, sessionId?: string}} event
+     */
+    onResponseReceived(event: {
+        params: LH.Crdp.Network.ResponseReceivedEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.DataReceivedEvent, sessionId?: string}} event
+     */
+    onDataReceived(event: {
+        params: LH.Crdp.Network.DataReceivedEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.LoadingFinishedEvent, sessionId?: string}} event
+     */
+    onLoadingFinished(event: {
+        params: LH.Crdp.Network.LoadingFinishedEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.LoadingFailedEvent, sessionId?: string}} event
+     */
+    onLoadingFailed(event: {
+        params: LH.Crdp.Network.LoadingFailedEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.ResourceChangedPriorityEvent, sessionId?: string}} event
+     */
+    onResourceChangedPriority(event: {
+        params: LH.Crdp.Network.ResourceChangedPriorityEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * Routes network events to their handlers, so we can construct networkRecords
+     * @param {LH.Protocol.RawEventMessage} event
+     */
+    dispatch(event: LH.Protocol.RawEventMessage): void;
+    /**
+     * Redirected requests all have identical requestIds over the protocol. Once a request has been
+     * redirected all future messages referrencing that requestId are about the new destination, not
+     * the original. This method is a helper for finding the real request object to which the current
+     * message is referring.
+     *
+     * @param {string} requestId
+     * @param {string|undefined} sessionId
+     * @return {NetworkRequest|undefined}
+     */
+    _findRealRequestAndSetSession(requestId: string, sessionId: string | undefined): NetworkRequest | undefined;
+}
+import { NetworkRequest } from "./network-request.js";
+export {};
+//# sourceMappingURL=network-recorder.d.ts.map

package/core/lib/network-request.d.ts

@@ -0,0 +1,245 @@
+export type HeaderEntry = {
+    name: string;
+    value: string;
+};
+export type ParsedURL = {
+    /**
+     * Equivalent to a `new URL(url).protocol` BUT w/o the trailing colon (:)
+     */
+    scheme: string;
+    /**
+     * Equivalent to a `new URL(url).hostname`
+     */
+    host: string;
+    securityOrigin: string;
+};
+/**
+ * The difference in endTime between the observed Lighthouse endTime and Lightrider's derived endTime.
+ */
+export type LightriderStatistics = {
+    /**
+     * The time spent making a TCP connection (connect + SSL).
+     */
+    endTimeDeltaMs: number;
+    /**
+     * The time spent requesting a resource from a remote server, we use this to approx RTT.
+     */
+    TCPMs: number;
+    /**
+     * The time spent transferring a resource from a remote server.
+     */
+    requestMs: number;
+    responseMs: number;
+};
+export class NetworkRequest {
+    /**
+     * Convert the requestId to backend-version by removing the `:redirect` portion
+     *
+     * @param {string} requestId
+     * @return {string}
+     */
+    static getRequestIdForBackend(requestId: string): string;
+    /**
+     * Based on DevTools NetworkManager.
+     * @see https://github.com/ChromeDevTools/devtools-frontend/blob/3415ee28e86a3f4bcc2e15b652d22069938df3a6/front_end/sdk/NetworkManager.js#L285-L297
+     * @param {LH.Crdp.Network.Headers} headersDict
+     * @return {Array<HeaderEntry>}
+     */
+    static _headersDictToHeadersArray(headersDict: LH.Crdp.Network.Headers): Array<HeaderEntry>;
+    static get TYPES(): LH.Util.SelfMap<LH.Crdp.Network.ResourceType>;
+    /**
+     * @param {NetworkRequest} record
+     * @return {boolean}
+     */
+    static isNonNetworkRequest(record: NetworkRequest): boolean;
+    /**
+     * Technically there's not alignment on URLs that create "secure connections" vs "secure contexts"
+     * https://github.com/GoogleChrome/lighthouse/pull/11766#discussion_r582340683
+     * But for our purposes, we don't need to worry too much.
+     * @param {NetworkRequest} record
+     * @return {boolean}
+     */
+    static isSecureRequest(record: NetworkRequest): boolean;
+    /**
+     * Returns whether the network request was an HSTS redirect request.
+     * @param {NetworkRequest} record
+     * @return {boolean}
+     */
+    static isHstsRequest(record: NetworkRequest): boolean;
+    /**
+     * Resource size is almost always the right one to be using because of the below:
+     *     `transferSize = resourceSize + headers.length`.
+     * HOWEVER, there are some cases where an image is compressed again over the network and transfer size
+     * is smaller (see https://github.com/GoogleChrome/lighthouse/pull/4968).
+     * Use the min of the two numbers to be safe.
+     * `tranferSize` of cached records is 0
+     * @param {NetworkRequest} networkRecord
+     * @return {number}
+     */
+    static getResourceSizeOnNetwork(networkRecord: NetworkRequest): number;
+    requestId: string;
+    connectionId: string;
+    connectionReused: boolean;
+    url: string;
+    protocol: string;
+    isSecure: boolean;
+    isValid: boolean;
+    parsedURL: ParsedURL;
+    documentURL: string;
+    /**
+     * When the network service is about to handle a request, ie. just before going to the
+     * HTTP cache or going to the network for DNS/connection setup, in milliseconds.
+     */
+    startTime: number;
+    /** When the last byte of the response body is received, in milliseconds. */
+    endTime: number;
+    /** When the last byte of the response headers is received, in milliseconds. */
+    responseReceivedTime: number;
+    transferSize: number;
+    resourceSize: number;
+    fromDiskCache: boolean;
+    fromMemoryCache: boolean;
+    fromPrefetchCache: boolean;
+    /** @type {LightriderStatistics|undefined} Extra timing information available only when run in Lightrider. */
+    lrStatistics: LightriderStatistics | undefined;
+    finished: boolean;
+    requestMethod: string;
+    statusCode: number;
+    /** @type {NetworkRequest|undefined} The network request that redirected to this one */
+    redirectSource: NetworkRequest | undefined;
+    /** @type {NetworkRequest|undefined} The network request that this one redirected to */
+    redirectDestination: NetworkRequest | undefined;
+    /** @type {NetworkRequest[]|undefined} The chain of network requests that redirected to this one */
+    redirects: NetworkRequest[] | undefined;
+    failed: boolean;
+    localizedFailDescription: string;
+    /** @type {LH.Crdp.Network.Initiator} */
+    initiator: LH.Crdp.Network.Initiator;
+    /** @type {LH.Crdp.Network.ResourceTiming|undefined} */
+    timing: LH.Crdp.Network.ResourceTiming | undefined;
+    /** @type {LH.Crdp.Network.ResourceType|undefined} */
+    resourceType: LH.Crdp.Network.ResourceType | undefined;
+    mimeType: string;
+    /** @type {LH.Crdp.Network.ResourcePriority} */
+    priority: LH.Crdp.Network.ResourcePriority;
+    /** @type {NetworkRequest|undefined} */
+    initiatorRequest: NetworkRequest | undefined;
+    /** @type {HeaderEntry[]} */
+    responseHeaders: HeaderEntry[];
+    /** @type {string} */
+    responseHeadersText: string;
+    fetchedViaServiceWorker: boolean;
+    /** @type {string|undefined} */
+    frameId: string | undefined;
+    /**
+     * @type {string|undefined}
+     * Only set for child targets (OOPIFs). This is the sessionId of the protocol connection on
+     * which this request was discovered. `undefined` means it came from the root.
+     */
+    sessionId: string | undefined;
+    isLinkPreload: boolean;
+    /**
+     * @return {boolean}
+     */
+    hasErrorStatusCode(): boolean;
+    /**
+     * @param {NetworkRequest} initiatorRequest
+     */
+    setInitiatorRequest(initiatorRequest: NetworkRequest): void;
+    /**
+     * @param {LH.Crdp.Network.RequestWillBeSentEvent} data
+     */
+    onRequestWillBeSent(data: LH.Crdp.Network.RequestWillBeSentEvent): void;
+    onRequestServedFromCache(): void;
+    /**
+     * @param {LH.Crdp.Network.ResponseReceivedEvent} data
+     */
+    onResponseReceived(data: LH.Crdp.Network.ResponseReceivedEvent): void;
+    /**
+     * @param {LH.Crdp.Network.DataReceivedEvent} data
+     */
+    onDataReceived(data: LH.Crdp.Network.DataReceivedEvent): void;
+    /**
+     * @param {LH.Crdp.Network.LoadingFinishedEvent} data
+     */
+    onLoadingFinished(data: LH.Crdp.Network.LoadingFinishedEvent): void;
+    /**
+     * @param {LH.Crdp.Network.LoadingFailedEvent} data
+     */
+    onLoadingFailed(data: LH.Crdp.Network.LoadingFailedEvent): void;
+    /**
+     * @param {LH.Crdp.Network.ResourceChangedPriorityEvent} data
+     */
+    onResourceChangedPriority(data: LH.Crdp.Network.ResourceChangedPriorityEvent): void;
+    /**
+     * @param {LH.Crdp.Network.RequestWillBeSentEvent} data
+     */
+    onRedirectResponse(data: LH.Crdp.Network.RequestWillBeSentEvent): void;
+    /**
+     * @param {string=} sessionId
+     */
+    setSession(sessionId?: string | undefined): void;
+    /**
+     * @param {LH.Crdp.Network.Response} response
+     * @param {number} timestamp in seconds
+     * @param {LH.Crdp.Network.ResponseReceivedEvent['type']=} resourceType
+     */
+    _onResponse(response: LH.Crdp.Network.Response, timestamp: number, resourceType?: LH.Crdp.Network.ResponseReceivedEvent['type'] | undefined): void;
+    /**
+     * Resolve differences between conflicting timing signals. Based on the property setters in DevTools.
+     * @see https://github.com/ChromeDevTools/devtools-frontend/blob/56a99365197b85c24b732ac92b0ac70feed80179/front_end/sdk/NetworkRequest.js#L485-L502
+     * @param {LH.Crdp.Network.ResourceTiming} timing
+     */
+    _recomputeTimesWithResourceTiming(timing: LH.Crdp.Network.ResourceTiming): void;
+    /**
+     * Update responseReceivedTime to the endTime if endTime is earlier.
+     * A response can't be received after the entire request finished.
+     */
+    _updateResponseReceivedTimeIfNecessary(): void;
+    /**
+     * LR loses transfer size information, but passes it in the 'X-TotalFetchedSize' header.
+     * 'X-TotalFetchedSize' is the canonical transfer size in LR. Nothing should supersede it.
+     *
+     * The total length of the encoded data is spread out among multiple events. The sum of the
+     * values in onResponseReceived and all the onDataReceived events typically equals the value
+     * seen on the onLoadingFinished event. In <1% of cases we see the values differ. As we process
+     * onResponseReceived and onDataReceived we accumulate the total encodedDataLength. When we
+     * process onLoadingFinished, we override the accumulated total. We do this so that if the
+     * request is aborted or fails, we still get a value via the accumulation.
+     *
+     * In Lightrider, due to instrumentation limitations, our values for encodedDataLength are bogus
+     * and not valid. However the resource's true encodedDataLength/transferSize is shared via a
+     * special response header, X-TotalFetchedSize. In this situation, we read this value from
+     * responseReceived, use it for the transferSize and ignore the encodedDataLength values in
+     * both dataReceived and loadingFinished.
+     */
+    _updateTransferSizeForLightrider(): void;
+    /**
+     * LR loses protocol information.
+     */
+    _updateProtocolForLightrider(): void;
+    /**
+     * LR gets additional, accurate timing information from its underlying fetch infrastructure.  This
+     * is passed in via X-Headers similar to 'X-TotalFetchedSize'.
+     */
+    _updateTimingsForLightrider(): void;
+}
+export namespace NetworkRequest {
+    export { HEADER_TCP };
+    export { HEADER_SSL };
+    export { HEADER_REQ };
+    export { HEADER_RES };
+    export { HEADER_TOTAL };
+    export { HEADER_FETCHED_SIZE };
+    export { HEADER_PROTOCOL_IS_H2 };
+}
+import * as LH from "../../types/lh.js";
+declare const HEADER_TCP: "X-TCPMs";
+declare const HEADER_SSL: "X-SSLMs";
+declare const HEADER_REQ: "X-RequestMs";
+declare const HEADER_RES: "X-ResponseMs";
+declare const HEADER_TOTAL: "X-TotalMs";
+declare const HEADER_FETCHED_SIZE: "X-TotalFetchedSize";
+declare const HEADER_PROTOCOL_IS_H2: "X-ProtocolIsH2";
+export {};
+//# sourceMappingURL=network-request.d.ts.map

package/core/lib/network-request.js

@@ -52,6 +52,7 @@
       Trace: ResourceFinish.ts
  */
 
+import * as LH from '../../types/lh.js';
 import UrlUtils from './url-utils.js';
 
 // Lightrider X-Header names for timing information.