lighthouse 11.6.0-dev.20240303 → 11.6.0-dev.20240305

package/core/lib/lantern/lantern.js

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/** @type {LH.Util.SelfMap<LH.Crdp.Network.ResourceType>} */
+const NetworkRequestTypes = {
+  XHR: 'XHR',
+  Fetch: 'Fetch',
+  EventSource: 'EventSource',
+  Script: 'Script',
+  Stylesheet: 'Stylesheet',
+  Image: 'Image',
+  Media: 'Media',
+  Font: 'Font',
+  Document: 'Document',
+  TextTrack: 'TextTrack',
+  WebSocket: 'WebSocket',
+  Other: 'Other',
+  Manifest: 'Manifest',
+  SignedExchange: 'SignedExchange',
+  Ping: 'Ping',
+  Preflight: 'Preflight',
+  CSPViolationReport: 'CSPViolationReport',
+  Prefetch: 'Prefetch',
+};
+
+export {
+  NetworkRequestTypes,
+};

package/core/lib/{dependency-graph → lantern}/network-node.d.ts

@@ -1,15 +1,24 @@
-export class NetworkNode extends BaseNode {
+export type NetworkRequest<T> = import('../../../types/internal/lantern.js').Lantern.NetworkRequest<T>;
+/**
+ * @template [T=any]
+ * @extends {BaseNode<T>}
+ */
+export class NetworkNode<T = any> extends BaseNode<T> {
     /**
-     * @param {LH.Artifacts.NetworkRequest} networkRecord
+     * @param {NetworkRequest<T>} networkRequest
      */
-    constructor(networkRecord: LH.Artifacts.NetworkRequest);
+    constructor(networkRequest: NetworkRequest<T>);
     /** @private */
-    private _record;
+    private _request;
     get type(): "network";
     /**
-     * @return {LH.Artifacts.NetworkRequest}
+     * @return {Readonly<T>}
      */
-    get record(): NetworkRequest;
+    get record(): Readonly<T>;
+    /**
+     * @return {NetworkRequest<T>}
+     */
+    get request(): import("../../../types/internal/lantern.js").Lantern.NetworkRequest<T>;
     /**
      * @return {string}
      */
@@ -33,11 +42,9 @@ export class NetworkNode extends BaseNode {
      */
     hasRenderBlockingPriority(): boolean;
     /**
-     * @return {NetworkNode}
+     * @return {NetworkNode<T>}
      */
-    cloneWithoutRelationships(): NetworkNode;
+    cloneWithoutRelationships(): NetworkNode<T>;
 }
 import { BaseNode } from './base-node.js';
-import { NetworkRequest } from '../network-request.js';
-import * as LH from '../../../types/lh.js';
 //# sourceMappingURL=network-node.d.ts.map

package/core/lib/lantern/network-node.js

@@ -0,0 +1,115 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/** @template T @typedef {import('../../../types/internal/lantern.js').Lantern.NetworkRequest<T>} NetworkRequest */
+
+import {NetworkRequestTypes} from './lantern.js';
+import {BaseNode} from './base-node.js';
+// TODO(15841): bring impl of isNonNetworkRequest inside lantern and remove this.
+import UrlUtils from '../url-utils.js';
+
+/**
+ * @template [T=any]
+ * @extends {BaseNode<T>}
+ */
+class NetworkNode extends BaseNode {
+  /**
+   * @param {NetworkRequest<T>} networkRequest
+   */
+  constructor(networkRequest) {
+    super(networkRequest.requestId);
+    /** @private */
+    this._request = networkRequest;
+  }
+
+  get type() {
+    return BaseNode.TYPES.NETWORK;
+  }
+
+  /**
+   * @return {number}
+   */
+  get startTime() {
+    return this._request.rendererStartTime * 1000;
+  }
+
+  /**
+   * @return {number}
+   */
+  get endTime() {
+    return this._request.networkEndTime * 1000;
+  }
+
+  /**
+   * @return {Readonly<T>}
+   */
+  get record() {
+    return /** @type {Required<T>} */ (this._request.record);
+  }
+
+  /**
+   * @return {NetworkRequest<T>}
+   */
+  get request() {
+    return this._request;
+  }
+
+  /**
+   * @return {string}
+   */
+  get initiatorType() {
+    return this._request.initiator && this._request.initiator.type;
+  }
+
+  /**
+   * @return {boolean}
+   */
+  get fromDiskCache() {
+    return !!this._request.fromDiskCache;
+  }
+
+  /**
+   * @return {boolean}
+   */
+  get isNonNetworkProtocol() {
+    // The 'protocol' field in devtools a string more like a `scheme`
+    return UrlUtils.isNonNetworkProtocol(this.request.protocol) ||
+      // But `protocol` can fail to be populated if the request fails, so fallback to scheme.
+      UrlUtils.isNonNetworkProtocol(this.request.parsedURL.scheme);
+  }
+
+  /**
+   * Returns whether this network record can be downloaded without a TCP connection.
+   * During simulation we treat data coming in over a network connection separately from on-device data.
+   * @return {boolean}
+   */
+  get isConnectionless() {
+    return this.fromDiskCache || this.isNonNetworkProtocol;
+  }
+
+  /**
+   * @return {boolean}
+   */
+  hasRenderBlockingPriority() {
+    const priority = this._request.priority;
+    const isScript = this._request.resourceType === NetworkRequestTypes.Script;
+    const isDocument = this._request.resourceType === NetworkRequestTypes.Document;
+    const isBlockingScript = priority === 'High' && isScript;
+    const isBlockingHtmlImport = priority === 'High' && isDocument;
+    return priority === 'VeryHigh' || isBlockingScript || isBlockingHtmlImport;
+  }
+
+  /**
+   * @return {NetworkNode<T>}
+   */
+  cloneWithoutRelationships() {
+    const node = new NetworkNode(this._request);
+    node.setIsMainDocument(this._isMainDocument);
+    return node;
+  }
+}
+
+export {NetworkNode};

package/core/lib/lantern/page-dependency-graph.d.ts

@@ -0,0 +1,58 @@
+export type NetworkRequest = import('../../../types/internal/lantern.js').Lantern.NetworkRequest;
+export type Node = import('./base-node.js').Node;
+export type URLArtifact = Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>;
+export type NetworkNodeOutput = {
+    nodes: Array<NetworkNode>;
+    idToNodeMap: Map<string, NetworkNode>;
+    urlToNodeMap: Map<string, Array<NetworkNode>>;
+    frameIdToNodeMap: Map<string, NetworkNode | null>;
+};
+export class PageDependencyGraph {
+    /**
+     * @param {NetworkRequest} record
+     * @return {Array<string>}
+     */
+    static getNetworkInitiators(record: NetworkRequest): Array<string>;
+    /**
+     * @param {Array<NetworkRequest>} networkRecords
+     * @return {NetworkNodeOutput}
+     */
+    static getNetworkNodeOutput(networkRecords: Array<NetworkRequest>): NetworkNodeOutput;
+    /**
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @return {Array<CPUNode>}
+     */
+    static getCPUNodes({ mainThreadEvents }: LH.Artifacts.ProcessedTrace): Array<CPUNode>;
+    /**
+     * @param {NetworkNode} rootNode
+     * @param {NetworkNodeOutput} networkNodeOutput
+     */
+    static linkNetworkNodes(rootNode: NetworkNode, networkNodeOutput: NetworkNodeOutput): void;
+    /**
+     * @param {Node} rootNode
+     * @param {NetworkNodeOutput} networkNodeOutput
+     * @param {Array<CPUNode>} cpuNodes
+     */
+    static linkCPUNodes(rootNode: Node, networkNodeOutput: NetworkNodeOutput, cpuNodes: Array<CPUNode>): void;
+    /**
+     * Removes the given node from the graph, but retains all paths between its dependencies and
+     * dependents.
+     * @param {Node} node
+     */
+    static _pruneNode(node: Node): void;
+    /**
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @param {Array<NetworkRequest>} networkRecords
+     * @param {URLArtifact} URL
+     * @return {Node}
+     */
+    static createGraph(processedTrace: LH.Artifacts.ProcessedTrace, networkRecords: Array<NetworkRequest>, URL: URLArtifact): Node;
+    /**
+     *
+     * @param {Node} rootNode
+     */
+    static printGraph(rootNode: Node, widthInCharacters?: number): void;
+}
+import { NetworkNode } from './network-node.js';
+import { CPUNode } from './cpu-node.js';
+//# sourceMappingURL=page-dependency-graph.d.ts.map