lighthouse 9.6.7 → 10.0.0

package/core/computed/computed-artifact.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Decorate computableArtifact with a caching `request()` method which will
+ * automatically call `computableArtifact.compute_()` under the hood.
+ * @template {{name: string, compute_(dependencies: unknown, context: LH.Artifacts.ComputedContext): Promise<unknown>}} C
+ * @template {Array<keyof LH.Util.FirstParamType<C['compute_']>>} K
+ * @param {C} computableArtifact
+ * @param {(K & ([keyof LH.Util.FirstParamType<C['compute_']>] extends [K[number]] ? unknown : never)) | null} keys List of properties of `dependencies` used by `compute_`; other properties are filtered out. Use `null` to allow all properties. Ensures that only required properties are used for caching result.
+ */
+export function makeComputedArtifact<C extends {
+    name: string;
+    compute_(dependencies: unknown, context: LH.Artifacts.ComputedContext): Promise<unknown>;
+}, K extends (keyof import("../../types/utility-types.js").default.FirstParamType<C["compute_"]>)[]>(computableArtifact: C, keys: (K & ([keyof import("../../types/utility-types.js").default.FirstParamType<C["compute_"]>] extends [K[number]] ? unknown : never)) | null): C & {
+    request: (dependencies: import("../../types/utility-types.js").default.FirstParamType<C["compute_"]>, context: LH.Artifacts.ComputedContext) => ReturnType<C["compute_"]>;
+};
+//# sourceMappingURL=computed-artifact.d.ts.map

package/core/computed/computed-artifact.js

@@ -0,0 +1,62 @@
+/**
+ * @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.
+ */
+
+import log from 'lighthouse-logger';
+
+import {ArbitraryEqualityMap} from '../lib/arbitrary-equality-map.js';
+
+/**
+ * Decorate computableArtifact with a caching `request()` method which will
+ * automatically call `computableArtifact.compute_()` under the hood.
+ * @template {{name: string, compute_(dependencies: unknown, context: LH.Artifacts.ComputedContext): Promise<unknown>}} C
+ * @template {Array<keyof LH.Util.FirstParamType<C['compute_']>>} K
+ * @param {C} computableArtifact
+ * @param {(K & ([keyof LH.Util.FirstParamType<C['compute_']>] extends [K[number]] ? unknown : never)) | null} keys List of properties of `dependencies` used by `compute_`; other properties are filtered out. Use `null` to allow all properties. Ensures that only required properties are used for caching result.
+ */
+function makeComputedArtifact(computableArtifact, keys) {
+  // tsc (3.1) has more difficulty with template inter-references in jsdoc, so
+  // give types to params and return value the long way, essentially recreating
+  // polymorphic-this behavior for C.
+  /**
+   * Return an automatically cached result from the computed artifact.
+   * @param {LH.Util.FirstParamType<C['compute_']>} dependencies
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {ReturnType<C['compute_']>}
+   */
+  const request = (dependencies, context) => {
+    const pickedDependencies = keys ?
+      Object.fromEntries(keys.map(key => [key, dependencies[key]])) :
+      dependencies;
+
+    // NOTE: break immutability solely for this caching-controller function.
+    const computedCache = /** @type {Map<string, ArbitraryEqualityMap>} */ (context.computedCache);
+    const computedName = computableArtifact.name;
+
+    const cache = computedCache.get(computedName) || new ArbitraryEqualityMap();
+    computedCache.set(computedName, cache);
+
+    /** @type {ReturnType<C['compute_']>|undefined} */
+    const computed = cache.get(pickedDependencies);
+    if (computed) {
+      return computed;
+    }
+
+    const status = {msg: `Computing artifact: ${computedName}`, id: `lh:computed:${computedName}`};
+    log.time(status, 'verbose');
+
+    const artifactPromise = /** @type {ReturnType<C['compute_']>} */
+        (computableArtifact.compute_(pickedDependencies, context));
+    cache.set(pickedDependencies, artifactPromise);
+
+    artifactPromise.then(() => log.timeEnd(status)).catch(() => log.timeEnd(status));
+
+    return artifactPromise;
+  };
+
+  return Object.assign(computableArtifact, {request});
+}
+
+export {makeComputedArtifact};

package/core/computed/critical-request-chains.d.ts

@@ -0,0 +1,40 @@
+export { CriticalRequestChainsComputed as CriticalRequestChains };
+declare const CriticalRequestChainsComputed: typeof CriticalRequestChains & {
+    request: (dependencies: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        trace: LH.Trace;
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.CriticalRequestNode>;
+};
+declare class CriticalRequestChains {
+    /**
+     * For now, we use network priorities as a proxy for "render-blocking"/critical-ness.
+     * It's imperfect, but there is not a higher-fidelity signal available yet.
+     * @see https://docs.google.com/document/d/1bCDuq9H1ih9iNjgzyAL0gpwNFiEP4TZS-YLRp_RuMlc
+     * @param {LH.Artifacts.NetworkRequest} request
+     * @param {LH.Artifacts.NetworkRequest} mainResource
+     * @return {boolean}
+     */
+    static isCritical(request: LH.Artifacts.NetworkRequest, mainResource: LH.Artifacts.NetworkRequest): boolean;
+    /**
+     * Create a tree of critical requests.
+     * @param {LH.Artifacts.NetworkRequest} mainResource
+     * @param {LH.Gatherer.Simulation.GraphNode} graph
+     * @return {LH.Artifacts.CriticalRequestNode}
+     */
+    static extractChainsFromGraph(mainResource: LH.Artifacts.NetworkRequest, graph: LH.Gatherer.Simulation.GraphNode): LH.Artifacts.CriticalRequestNode;
+    /**
+     * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, trace: LH.Trace}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.CriticalRequestNode>}
+     */
+    static compute_(data: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        trace: LH.Trace;
+    }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.CriticalRequestNode>;
+}
+import { NetworkRequest } from "../lib/network-request.js";
+//# sourceMappingURL=critical-request-chains.d.ts.map

package/core/computed/critical-request-chains.js

@@ -0,0 +1,143 @@
+/**
+ * @license Copyright 2016 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 {makeComputedArtifact} from './computed-artifact.js';
+import {NetworkRequest} from '../lib/network-request.js';
+import {MainResource} from './main-resource.js';
+import {PageDependencyGraph} from './page-dependency-graph.js';
+
+class CriticalRequestChains {
+  /**
+   * For now, we use network priorities as a proxy for "render-blocking"/critical-ness.
+   * It's imperfect, but there is not a higher-fidelity signal available yet.
+   * @see https://docs.google.com/document/d/1bCDuq9H1ih9iNjgzyAL0gpwNFiEP4TZS-YLRp_RuMlc
+   * @param {LH.Artifacts.NetworkRequest} request
+   * @param {LH.Artifacts.NetworkRequest} mainResource
+   * @return {boolean}
+   */
+  static isCritical(request, mainResource) {
+    if (!mainResource) {
+      throw new Error('mainResource not provided');
+    }
+
+    // The main resource is always critical.
+    if (request.requestId === mainResource.requestId) return true;
+
+    // Treat any preloaded resource as non-critical
+    if (request.isLinkPreload) {
+      return false;
+    }
+
+    // Whenever a request is a redirect, we don't know if it's critical until we resolve the final
+    // destination. At that point we can assign all the properties (priority, resourceType) of the
+    // final request back to the redirect(s) that led to it.
+    // See https://github.com/GoogleChrome/lighthouse/pull/6704
+    while (request.redirectDestination) {
+      request = request.redirectDestination;
+    }
+
+    // Iframes are considered High Priority but they are not render blocking
+    const isIframe = request.resourceType === NetworkRequest.TYPES.Document &&
+      request.frameId !== mainResource.frameId;
+    // XHRs are fetched at High priority, but we exclude them, as they are unlikely to be critical
+    // Images are also non-critical.
+    // Treat any missed images, primarily favicons, as non-critical resources
+    /** @type {Array<LH.Crdp.Network.ResourceType>} */
+    const nonCriticalResourceTypes = [
+      NetworkRequest.TYPES.Image,
+      NetworkRequest.TYPES.XHR,
+      NetworkRequest.TYPES.Fetch,
+      NetworkRequest.TYPES.EventSource,
+    ];
+    if (nonCriticalResourceTypes.includes(request.resourceType || 'Other') ||
+        isIframe ||
+        request.mimeType && request.mimeType.startsWith('image/')) {
+      return false;
+    }
+
+    // Requests that have no initiatorRequest are typically ambiguous late-load assets.
+    // Even on the off chance they were important, we don't have any parent to display for them.
+    if (!request.initiatorRequest) return false;
+
+    return ['VeryHigh', 'High', 'Medium'].includes(request.priority);
+  }
+
+  /**
+   * Create a tree of critical requests.
+   * @param {LH.Artifacts.NetworkRequest} mainResource
+   * @param {LH.Gatherer.Simulation.GraphNode} graph
+   * @return {LH.Artifacts.CriticalRequestNode}
+   */
+  static extractChainsFromGraph(mainResource, graph) {
+    /** @type {LH.Artifacts.CriticalRequestNode} */
+    const rootNode = {};
+
+    /**
+     * @param {LH.Artifacts.NetworkRequest[]} path
+     */
+    function addChain(path) {
+      let currentNode = rootNode;
+
+      for (const record of path) {
+        if (!currentNode[record.requestId]) {
+          currentNode[record.requestId] = {
+            request: record,
+            children: {},
+          };
+        }
+
+        currentNode = currentNode[record.requestId].children;
+      }
+    }
+
+    // By default `traverse` will discover nodes in BFS-order regardless of dependencies, but
+    // here we need traversal in a topological sort order. We'll visit a node only when its
+    // dependencies have been met.
+    const seenNodes = new Set();
+    /** @param {LH.Gatherer.Simulation.GraphNode} node */
+    function getNextNodes(node) {
+      return node.getDependents().filter(n => n.getDependencies().every(d => seenNodes.has(d)));
+    }
+
+    graph.traverse((node, traversalPath) => {
+      seenNodes.add(node);
+      if (node.type !== 'network') return;
+      if (!CriticalRequestChains.isCritical(node.record, mainResource)) return;
+
+      const networkPath = traversalPath
+        .filter(/** @return {n is LH.Gatherer.Simulation.GraphNetworkNode} */
+          n => n.type === 'network')
+        .reverse()
+        .map(node => node.record);
+
+      // Ignore if some ancestor is not a critical request.
+      if (networkPath.some(r => !CriticalRequestChains.isCritical(r, mainResource))) return;
+
+      // Ignore non-network things (like data urls).
+      if (NetworkRequest.isNonNetworkRequest(node.record)) return;
+
+      addChain(networkPath);
+    }, getNextNodes);
+
+    return rootNode;
+  }
+
+  /**
+   * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, trace: LH.Trace}} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.CriticalRequestNode>}
+   */
+  static async compute_(data, context) {
+    const mainResource = await MainResource.request(data, context);
+    const graph = await PageDependencyGraph.request(data, context);
+
+    return CriticalRequestChains.extractChainsFromGraph(mainResource, graph);
+  }
+}
+
+const CriticalRequestChainsComputed =
+  makeComputedArtifact(CriticalRequestChains, ['URL', 'devtoolsLog', 'trace']);
+export {CriticalRequestChainsComputed as CriticalRequestChains};

package/core/computed/entity-classification.d.ts

@@ -0,0 +1,29 @@
+export { EntityClassificationComputed as EntityClassification };
+export type EntityCache = Map<string, LH.Artifacts.Entity>;
+declare const EntityClassificationComputed: typeof EntityClassification & {
+    request: (dependencies: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.EntityClassification>;
+};
+/** @typedef {Map<string, LH.Artifacts.Entity>} EntityCache */
+declare class EntityClassification {
+    /**
+     * @param {EntityCache} entityCache
+     * @param {string} url
+     * @return {LH.Artifacts.Entity | undefined}
+     */
+    static makeUpAnEntity(entityCache: EntityCache, url: string): LH.Artifacts.Entity | undefined;
+    /**
+     * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.EntityClassification>}
+     */
+    static compute_(data: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.EntityClassification>;
+}
+//# sourceMappingURL=entity-classification.d.ts.map

package/core/computed/entity-classification.js

@@ -0,0 +1,103 @@
+/**
+ * @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.
+ */
+
+import {makeComputedArtifact} from './computed-artifact.js';
+import {NetworkRecords} from './network-records.js';
+import {Util} from '../../shared/util.js';
+import UrlUtils from '../lib/url-utils.js';
+import thirdPartyWeb from '../lib/third-party-web.js';
+
+/** @typedef {Map<string, LH.Artifacts.Entity>} EntityCache */
+
+class EntityClassification {
+  /**
+   * @param {EntityCache} entityCache
+   * @param {string} url
+   * @return {LH.Artifacts.Entity | undefined}
+   */
+  static makeUpAnEntity(entityCache, url) {
+    if (!UrlUtils.isValid(url)) return;
+    // We can make up an entity only for those URLs with a valid domain attached.
+    // So we further restrict from allowed URLs to (http/https).
+    if (!Util.createOrReturnURL(url).protocol.startsWith('http')) return;
+
+    const rootDomain = Util.getRootDomain(url);
+    if (!rootDomain) return;
+    if (entityCache.has(rootDomain)) return entityCache.get(rootDomain);
+
+    const unrecognizedEntity = {
+      name: rootDomain,
+      company: rootDomain,
+      category: '',
+      categories: [],
+      domains: [rootDomain],
+      averageExecutionTime: 0,
+      totalExecutionTime: 0,
+      totalOccurrences: 0,
+      isUnrecognized: true,
+    };
+    entityCache.set(rootDomain, unrecognizedEntity);
+    return unrecognizedEntity;
+  }
+
+  /**
+   * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog}} data
+   * @param {LH.Artifacts.ComputedContext} context
+   * @return {Promise<LH.Artifacts.EntityClassification>}
+   */
+  static async compute_(data, context) {
+    const networkRecords = await NetworkRecords.request(data.devtoolsLog, context);
+    /** @type {EntityCache} */
+    const madeUpEntityCache = new Map();
+    /** @type {Map<string, LH.Artifacts.Entity>} */
+    const entityByUrl = new Map();
+    /** @type {Map<LH.Artifacts.Entity, Set<string>>} */
+    const urlsByEntity = new Map();
+
+    for (const record of networkRecords) {
+      const {url} = record;
+      if (entityByUrl.has(url)) continue;
+
+      const entity = thirdPartyWeb.getEntity(url) ||
+        EntityClassification.makeUpAnEntity(madeUpEntityCache, url);
+      if (!entity) continue;
+
+      const entityURLs = urlsByEntity.get(entity) || new Set();
+      entityURLs.add(url);
+      urlsByEntity.set(entity, entityURLs);
+      entityByUrl.set(url, entity);
+    }
+
+    // When available, first party identification will be done via
+    // `mainDocumentUrl` (for navigations), and falls back to `finalDisplayedUrl` (for timespan/snapshot).
+    // See https://github.com/GoogleChrome/lighthouse/issues/13706
+    const firstPartyUrl = data.URL.mainDocumentUrl || data.URL.finalDisplayedUrl;
+    const firstParty = thirdPartyWeb.getEntity(firstPartyUrl) ||
+      EntityClassification.makeUpAnEntity(madeUpEntityCache, firstPartyUrl);
+
+    /**
+     * Convenience function to check if a URL belongs to first party.
+     * @param {string} url
+     * @return {boolean}
+     */
+    function isFirstParty(url) {
+      const entityUrl = entityByUrl.get(url);
+      if (!entityUrl) throw new Error('A url not in devtoolsLog was used for first-party check.');
+      return entityUrl === firstParty;
+    }
+
+    return {
+      entityByUrl,
+      urlsByEntity,
+      firstParty,
+      isFirstParty,
+    };
+  }
+}
+
+const EntityClassificationComputed = makeComputedArtifact(EntityClassification,
+  ['URL', 'devtoolsLog']);
+export {EntityClassificationComputed as EntityClassification};

package/core/computed/image-records.d.ts

@@ -0,0 +1,24 @@
+export { ImageRecordsComputed as ImageRecords };
+declare const ImageRecordsComputed: typeof ImageRecords & {
+    request: (dependencies: {
+        ImageElements: LH.Artifacts['ImageElements'];
+        networkRecords: LH.Artifacts.NetworkRequest[];
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.ImageElementRecord[]>;
+};
+declare class ImageRecords {
+    /**
+     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+     */
+    static indexNetworkRecords(networkRecords: LH.Artifacts.NetworkRequest[]): Record<string, import("../lib/network-request.js").NetworkRequest>;
+    /**
+     * @param {{ImageElements: LH.Artifacts['ImageElements'], networkRecords: LH.Artifacts.NetworkRequest[]}} data
+     * @return {Promise<LH.Artifacts.ImageElementRecord[]>}
+     */
+    static compute_(data: {
+        ImageElements: LH.Artifacts['ImageElements'];
+        networkRecords: LH.Artifacts.NetworkRequest[];
+    }): Promise<LH.Artifacts.ImageElementRecord[]>;
+}
+//# sourceMappingURL=image-records.d.ts.map

package/core/computed/image-records.js

@@ -0,0 +1,64 @@
+/**
+ * @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 UrlUtils from '../lib/url-utils.js';
+import {makeComputedArtifact} from './computed-artifact.js';
+
+class ImageRecords {
+  /**
+   * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+   */
+  static indexNetworkRecords(networkRecords) {
+    return networkRecords.reduce((map, record) => {
+      // An image response in newer formats is sometimes incorrectly marked as "application/octet-stream",
+      // so respect the extension too.
+      const isImage = /^image/.test(record.mimeType) || /\.(avif|webp)$/i.test(record.url);
+      // The network record is only valid for size information if it finished with a successful status
+      // code that indicates a complete image response.
+      if (isImage && record.finished && record.statusCode === 200) {
+        map[record.url] = record;
+      }
+
+      return map;
+    }, /** @type {Record<string, LH.Artifacts.NetworkRequest>} */ ({}));
+  }
+
+  /**
+   * @param {{ImageElements: LH.Artifacts['ImageElements'], networkRecords: LH.Artifacts.NetworkRequest[]}} data
+   * @return {Promise<LH.Artifacts.ImageElementRecord[]>}
+   */
+  static async compute_(data) {
+    const indexedNetworkRecords = ImageRecords.indexNetworkRecords(data.networkRecords);
+
+    /** @type {LH.Artifacts.ImageElementRecord[]} */
+    const imageRecords = [];
+
+    for (const element of data.ImageElements) {
+      const networkRecord = indexedNetworkRecords[element.src];
+      const mimeType = networkRecord?.mimeType;
+
+      // Don't change the guessed mime type if no mime type was found.
+      imageRecords.push({
+        ...element,
+        mimeType: mimeType ? mimeType : UrlUtils.guessMimeType(element.src),
+      });
+    }
+
+    // Sort (in-place) as largest images descending.
+    imageRecords.sort((a, b) => {
+      const aRecord = indexedNetworkRecords[a.src] || {};
+      const bRecord = indexedNetworkRecords[b.src] || {};
+      return bRecord.resourceSize - aRecord.resourceSize;
+    });
+
+    return imageRecords;
+  }
+}
+
+const ImageRecordsComputed =
+  makeComputedArtifact(ImageRecords, ['ImageElements', 'networkRecords']);
+export {ImageRecordsComputed as ImageRecords};
+

package/core/computed/js-bundles.d.ts

@@ -0,0 +1,13 @@
+export { JSBundlesComputed as JSBundles };
+declare const JSBundlesComputed: typeof JSBundles & {
+    request: (dependencies: Pick<import("../index.js").Artifacts, "Scripts" | "SourceMaps">, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.Bundle[]>;
+};
+declare class JSBundles {
+    /**
+     * @param {Pick<LH.Artifacts, 'SourceMaps'|'Scripts'>} artifacts
+     */
+    static compute_(artifacts: Pick<LH.Artifacts, 'SourceMaps' | 'Scripts'>): Promise<import("../index.js").Artifacts.Bundle[]>;
+}
+//# sourceMappingURL=js-bundles.d.ts.map

package/core/computed/js-bundles.js

@@ -0,0 +1,120 @@
+/**
+ * @license Copyright 2020 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 {makeComputedArtifact} from './computed-artifact.js';
+import SDK from '../lib/cdt/SDK.js';
+
+/**
+ * Calculate the number of bytes contributed by each source file
+ * @param {LH.Artifacts.Bundle['map']} map
+ * @param {number} contentLength
+ * @param {string} content
+ * @return {LH.Artifacts.Bundle['sizes']}
+ */
+function computeGeneratedFileSizes(map, contentLength, content) {
+  const lines = content.split('\n');
+  /** @type {Record<string, number>} */
+  const files = {};
+  const totalBytes = contentLength;
+  let unmappedBytes = totalBytes;
+
+  // @ts-expect-error: This function is added in SDK.js. This will eventually be added to CDT.
+  map.computeLastGeneratedColumns();
+
+  for (const mapping of map.mappings()) {
+    const source = mapping.sourceURL;
+    const lineNum = mapping.lineNumber;
+    const colNum = mapping.columnNumber;
+    const lastColNum = mapping.lastColumnNumber;
+
+    // Webpack sometimes emits null mappings.
+    // https://github.com/mozilla/source-map/pull/303
+    if (!source) continue;
+
+    // Lines and columns are zero-based indices. Visually, lines are shown as a 1-based index.
+
+    const line = lines[lineNum];
+    if (line === null || line === undefined) {
+      const errorMessage = `${map.url()} mapping for line out of bounds: ${lineNum + 1}`;
+      log.error('JSBundles', errorMessage);
+      return {errorMessage};
+    }
+
+    if (colNum > line.length) {
+      const errorMessage =
+        `${map.url()} mapping for column out of bounds: ${lineNum + 1}:${colNum}`;
+      log.error('JSBundles', errorMessage);
+      return {errorMessage};
+    }
+
+    let mappingLength = 0;
+    if (lastColNum !== undefined) {
+      if (lastColNum > line.length) {
+        // eslint-disable-next-line max-len
+        const errorMessage =
+          `${map.url()} mapping for last column out of bounds: ${lineNum + 1}:${lastColNum}`;
+        log.error('JSBundles', errorMessage);
+        return {errorMessage};
+      }
+      mappingLength = lastColNum - colNum;
+    } else {
+      // Add +1 to account for the newline.
+      mappingLength = line.length - colNum + 1;
+    }
+    files[source] = (files[source] || 0) + mappingLength;
+    unmappedBytes -= mappingLength;
+  }
+
+  return {
+    files,
+    unmappedBytes,
+    totalBytes,
+  };
+}
+
+class JSBundles {
+  /**
+   * @param {Pick<LH.Artifacts, 'SourceMaps'|'Scripts'>} artifacts
+   */
+  static async compute_(artifacts) {
+    const {SourceMaps, Scripts} = artifacts;
+
+    /** @type {LH.Artifacts.Bundle[]} */
+    const bundles = [];
+
+    // Collate map and script, compute file sizes.
+    for (const SourceMap of SourceMaps) {
+      if (!SourceMap.map) continue;
+      const {scriptId, map: rawMap} = SourceMap;
+
+      if (!rawMap.mappings) continue;
+
+      const script = Scripts.find(s => s.scriptId === scriptId);
+      if (!script) continue;
+
+      const compiledUrl = SourceMap.scriptUrl || 'compiled.js';
+      const mapUrl = SourceMap.sourceMapUrl || 'compiled.js.map';
+      const map = new SDK.TextSourceMap(compiledUrl, mapUrl, rawMap);
+
+      const sizes = computeGeneratedFileSizes(map, script.length || 0, script.content || '');
+
+      const bundle = {
+        rawMap,
+        script,
+        map,
+        sizes,
+      };
+      bundles.push(bundle);
+    }
+
+    return bundles;
+  }
+}
+
+const JSBundlesComputed = makeComputedArtifact(JSBundles, ['Scripts', 'SourceMaps']);
+export {JSBundlesComputed as JSBundles};

package/core/computed/load-simulator.d.ts

@@ -0,0 +1,28 @@
+export { LoadSimulatorComputed as LoadSimulator };
+declare const LoadSimulatorComputed: typeof LoadSimulator & {
+    request: (dependencies: {
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        settings: LH.Audit.Context['settings'];
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<Simulator>;
+};
+declare class LoadSimulator {
+    /**
+     * @param {{devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings']}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<Simulator>}
+     */
+    static compute_(data: {
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        settings: LH.Audit.Context['settings'];
+    }, context: LH.Artifacts.ComputedContext): Promise<Simulator>;
+    /**
+     * @param {LH.Artifacts.NetworkAnalysis} networkAnalysis
+     * @return {LH.PrecomputedLanternData}
+     */
+    static convertAnalysisToSaveableLanternData(networkAnalysis: LH.Artifacts.NetworkAnalysis): LH.PrecomputedLanternData;
+}
+import { Simulator } from "../lib/dependency-graph/simulator/simulator.js";
+import { NetworkAnalysis } from "./network-analysis.js";
+//# sourceMappingURL=load-simulator.d.ts.map