lighthouse 9.6.8 → 10.0.0-dev.20230209

package/lighthouse-core/audits/work-during-interaction.js

@@ -1,280 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const Audit = require('./audit.js');
-const ComputedResponsivenes = require('../computed/metrics/responsiveness.js');
-const ProcessedTrace = require('../computed/processed-trace.js');
-const i18n = require('../lib/i18n/i18n.js');
-const NetworkRecords = require('../computed/network-records.js');
-const MainThreadTasks = require('../lib/tracehouse/main-thread-tasks.js');
-const {taskGroups} = require('../lib/tracehouse/task-groups.js');
-const TraceProcessor = require('../lib/tracehouse/trace-processor.js');
-const {getExecutionTimingsByURL} = require('../lib/tracehouse/task-summary.js');
-const inpThresholds = require('./metrics/experimental-interaction-to-next-paint.js').defaultOptions;
-const LHError = require('../lib/lh-error.js');
-
-/** @typedef {import('../computed/metrics/responsiveness.js').EventTimingEvent} EventTimingEvent */
-/** @typedef {import('../lib/tracehouse/main-thread-tasks.js').TaskNode} TaskNode */
-
-const TASK_THRESHOLD = 1;
-
-const UIStrings = {
-  /** Title of a diagnostic audit that provides detail on the main thread work the browser did during a key user interaction. This descriptive title is shown to users when the amount is acceptable and no user action is required. */
-  title: 'Minimizes work during key interaction',
-  /** Title of a diagnostic audit that provides detail on the main thread work the browser did during a key user interaction. This imperative title is shown to users when there is a significant amount of execution time that could be reduced. */
-  failureTitle: 'Minimize work during key interaction',
-  /** Description of the work-during-interaction metric. This description is displayed within a tooltip when the user hovers on the metric name to see more. No character length limits. 'Learn More' becomes link text to additional documentation. */
-  description: 'This is the thread-blocking work occurring during the Interaction to Next Paint measurement. [Learn more](https://web.dev/inp/).',
-  /** Label for a column in a data table; entries will be information on the time that the browser is delayed before responding to user input. Ideally fits within a ~40 character limit. */
-  inputDelay: 'Input delay',
-  /** Label for a column in a data table; entries will be information on the time taken by code processing user input that delays a response to the user. Ideally fits within a ~40 character limit. */
-  processingDelay: 'Processing delay',
-  /** Label for a column in a data table; entries will be information on the time that the browser is delayed before presenting a response to user input on screen. Ideally fits within a ~40 character limit. */
-  presentationDelay: 'Presentation delay',
-  /**
-   * @description Summary text that identifies the time the browser took to process a user interaction.
-   * @example {mousedown} interactionType
-   */
-  displayValue: `{timeInMs, number, milliseconds}\xa0ms spent on event '{interactionType}'`,
-  /** Label for a column in a data table; entries will the UI element that was the target of a user interaction (for example, a button that was clicked on). Ideally fits within a ~40 character limit. */
-  eventTarget: 'Event target',
-};
-
-const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings);
-
-/**
- * @fileoverview This metric gives a high-percentile measure of responsiveness to input.
- */
-class WorkDuringInteraction extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'work-during-interaction',
-      title: str_(UIStrings.title),
-      failureTitle: str_(UIStrings.failureTitle),
-      description: str_(UIStrings.description),
-      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
-      supportedModes: ['timespan'],
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'TraceElements'],
-    };
-  }
-
-  /**
-   * @param {TaskNode} task
-   * @param {TaskNode|undefined} parent
-   * @param {number} startTs
-   * @param {number} endTs
-   * @return {number}
-   */
-  static recursivelyClipTasks(task, parent, startTs, endTs) {
-    const taskEventStart = task.event.ts;
-    const taskEventEnd = task.endEvent?.ts ?? task.event.ts + Number(task.event.dur || 0);
-
-    task.startTime = Math.max(startTs, Math.min(endTs, taskEventStart)) / 1000;
-    task.endTime = Math.max(startTs, Math.min(endTs, taskEventEnd)) / 1000;
-    task.duration = task.endTime - task.startTime;
-
-    const childTime = task.children
-      .map(child => WorkDuringInteraction.recursivelyClipTasks(child, task, startTs, endTs))
-      .reduce((sum, child) => sum + child, 0);
-    task.selfTime = task.duration - childTime;
-    return task.duration;
-  }
-
-  /**
-   * Clip the tasks by the start and end points. Take the easy route and drop
-   * to duration 0 if out of bounds, since only durations are needed in the
-   * end (for now).
-   * Assumes owned tasks, so modifies in place. Can be called multiple times on
-   * the same `tasks` because always computed from original event timing.
-   * @param {Array<TaskNode>} tasks
-   * @param {number} startTs
-   * @param {number} endTs
-   */
-  static clipTasksByTs(tasks, startTs, endTs) {
-    for (const task of tasks) {
-      if (task.parent) continue;
-      WorkDuringInteraction.recursivelyClipTasks(task, undefined, startTs, endTs);
-    }
-  }
-
-  /**
-   * @param {EventTimingEvent} interactionEvent
-   */
-  static getPhaseTimes(interactionEvent) {
-    const interactionData = interactionEvent.args.data;
-    const startTs = interactionEvent.ts;
-    const navStart = startTs - interactionData.timeStamp * 1000;
-    const processingStartTs = navStart + interactionData.processingStart * 1000;
-    const processingEndTs = navStart + interactionData.processingEnd * 1000;
-    const endTs = startTs + interactionData.duration * 1000;
-    return {
-      inputDelay: {startTs, endTs: processingStartTs},
-      processingDelay: {startTs: processingStartTs, endTs: processingEndTs},
-      presentationDelay: {startTs: processingEndTs, endTs},
-    };
-  }
-
-  /**
-   * @param {EventTimingEvent} interactionEvent
-   * @param {LH.Trace} trace
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
-   * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   * @return {{table: LH.Audit.Details.Table, phases: Record<string, {startTs: number, endTs: number}>}}
-   */
-  static getThreadBreakdownTable(interactionEvent, trace, processedTrace, networkRecords) {
-    // Limit to interactionEvent's thread.
-    // TODO(bckenny): limit to interactionEvent's navigation.
-    const threadEvents = TraceProcessor.filteredTraceSort(trace.traceEvents, evt => {
-      return evt.pid === interactionEvent.pid && evt.tid === interactionEvent.tid;
-    });
-    const traceEndTs = threadEvents.reduce((endTs, evt) => {
-      return Math.max(evt.ts + (evt.dur || 0), endTs);
-    }, 0);
-    // frames is only used for URL attribution, so can include all frames, even if OOPIF.
-    const {frames} = processedTrace;
-    const threadTasks = MainThreadTasks.getMainThreadTasks(threadEvents, frames, traceEndTs);
-
-    const phases = WorkDuringInteraction.getPhaseTimes(interactionEvent);
-
-    /** @type {LH.Audit.Details.TableItem[]} */
-    const items = [];
-    for (const [phaseName, phaseTimes] of Object.entries(phases)) {
-      // Clip tasks to start and end time.
-      WorkDuringInteraction.clipTasksByTs(threadTasks, phaseTimes.startTs, phaseTimes.endTs);
-      const executionTimings = getExecutionTimingsByURL(threadTasks, networkRecords);
-
-      const results = [];
-      for (const [url, timingByGroupId] of executionTimings) {
-        const totalExecutionTimeForURL = Object.values(timingByGroupId)
-            .reduce((total, timespanMs) => total + timespanMs);
-
-        const scriptingTotal = timingByGroupId[taskGroups.scriptEvaluation.id] || 0;
-        const layoutTotal = timingByGroupId[taskGroups.styleLayout.id] || 0;
-        const renderTotal = timingByGroupId[taskGroups.paintCompositeRender.id] || 0;
-
-        results.push({
-          url: url,
-          total: totalExecutionTimeForURL,
-          scripting: scriptingTotal,
-          layout: layoutTotal,
-          render: renderTotal,
-        });
-      }
-
-      const filteredResults = results
-        .filter(result => result.total > TASK_THRESHOLD)
-        .sort((a, b) => b.total - a.total);
-
-      items.push({
-        phase: str_(UIStrings[/** @type {keyof UIStrings} */ (phaseName)]),
-        total: (phaseTimes.endTs - phaseTimes.startTs) / 1000,
-        subItems: {
-          type: 'subitems',
-          items: filteredResults,
-        },
-      });
-    }
-
-    /** @type {LH.Audit.Details.Table['headings']} */
-    const headings = [
-      /* eslint-disable max-len */
-      {key: 'phase', itemType: 'text', subItemsHeading: {key: 'url', itemType: 'url'}, text: 'Phase'},
-      {key: 'total', itemType: 'ms', subItemsHeading: {key: 'total', granularity: 1, itemType: 'ms'}, granularity: 1, text: 'Total time'},
-      {key: null, itemType: 'ms', subItemsHeading: {key: 'scripting', granularity: 1, itemType: 'ms'}, text: 'Script evaluation'},
-      {key: null, itemType: 'ms', subItemsHeading: {key: 'layout', granularity: 1, itemType: 'ms'}, text: taskGroups.styleLayout.label},
-      {key: null, itemType: 'ms', subItemsHeading: {key: 'render', granularity: 1, itemType: 'ms'}, text: taskGroups.paintCompositeRender.label},
-      /* eslint-enable max-len */
-    ];
-
-    return {
-      table: Audit.makeTableDetails(headings, items),
-      phases,
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts['TraceElements']} traceElements
-   * @return {LH.Audit.Details.Table | undefined}
-   */
-  static getTraceElementTable(traceElements) {
-    const responsivenessElement = traceElements.find(el => el.traceEventType === 'responsiveness');
-    if (!responsivenessElement) return;
-
-    /** @type {LH.Audit.Details.Table['headings']} */
-    const headings = [
-      {key: 'node', itemType: 'node', text: str_(UIStrings.eventTarget)},
-    ];
-    const elementItems = [{node: Audit.makeNodeItem(responsivenessElement.node)}];
-
-    return Audit.makeTableDetails(headings, elementItems);
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit(artifacts, context) {
-    const {settings} = context;
-    // TODO: responsiveness isn't yet supported by lantern.
-    if (settings.throttlingMethod === 'simulate') {
-      return {score: null, notApplicable: true};
-    }
-
-    const trace = artifacts.traces[WorkDuringInteraction.DEFAULT_PASS];
-    const metricData = {trace, settings};
-    const interactionEvent = await ComputedResponsivenes.request(metricData, context);
-    // If no interaction, diagnostic audit is n/a.
-    if (interactionEvent === null) {
-      return {score: null, notApplicable: true};
-    }
-    // TODO: remove workaround once 103.0.5052.0 is sufficiently released.
-    if (interactionEvent.name === 'FallbackTiming') {
-      throw new LHError(
-        LHError.errors.UNSUPPORTED_OLD_CHROME,
-        {featureName: 'detailed EventTiming trace events'}
-      );
-    }
-
-    const auditDetailsItems = [];
-
-    const traceElementItem = WorkDuringInteraction.getTraceElementTable(artifacts.TraceElements);
-    if (traceElementItem) auditDetailsItems.push(traceElementItem);
-
-    const devtoolsLog = artifacts.devtoolsLogs[WorkDuringInteraction.DEFAULT_PASS];
-    // Network records will usually be empty for timespans.
-    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    const processedTrace = await ProcessedTrace.request(trace, context);
-    const {table: breakdownTable, phases} = WorkDuringInteraction.getThreadBreakdownTable(
-        interactionEvent, trace, processedTrace, networkRecords);
-    auditDetailsItems.push(breakdownTable);
-
-    const interactionType = interactionEvent.args.data.type;
-    auditDetailsItems.push({
-      type: /** @type {const} */ ('debugdata'),
-      interactionType,
-      phases,
-    });
-
-    const duration = interactionEvent.args.data.duration;
-    const displayValue = str_(UIStrings.displayValue, {timeInMs: duration, interactionType});
-    return {
-      score: duration < inpThresholds.p10 ? 1 : 0,
-      displayValue,
-      details: {
-        type: 'list',
-        items: auditDetailsItems,
-      },
-    };
-  }
-}
-
-module.exports = WorkDuringInteraction;
-module.exports.UIStrings = UIStrings;

package/lighthouse-core/computed/computed-artifact.js

@@ -1,62 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const ArbitraryEqualityMap = require('../lib/arbitrary-equality-map.js');
-const log = require('lighthouse-logger');
-
-/**
- * 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 FirstParamType<C['compute_']>>} K
- * @param {C} computableArtifact
- * @param {(K & ([keyof 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 {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});
-}
-
-module.exports = makeComputedArtifact;

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

@@ -1,146 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const makeComputedArtifact = require('./computed-artifact.js');
-const NetworkRequest = require('../lib/network-request.js');
-const MainResource = require('./main-resource.js');
-const PageDependencyGraph = require('./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;
-
-      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({
-      URL: data.URL,
-      devtoolsLog: data.devtoolsLog,
-    }, context);
-
-    const graph = await PageDependencyGraph.request({
-      trace: data.trace,
-      devtoolsLog: data.devtoolsLog,
-    }, context);
-
-    return CriticalRequestChains.extractChainsFromGraph(mainResource, graph);
-  }
-}
-
-module.exports = makeComputedArtifact(CriticalRequestChains, ['URL', 'devtoolsLog', 'trace']);

package/lighthouse-core/computed/image-records.js

@@ -1,63 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const URL = require('../lib/url-shim.js');
-const makeComputedArtifact = require('./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 : URL.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;
-  }
-}
-
-module.exports = makeComputedArtifact(ImageRecords, ['ImageElements', 'networkRecords']);
-

package/lighthouse-core/computed/js-bundles.js

@@ -1,119 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const log = require('lighthouse-logger');
-const makeComputedArtifact = require('./computed-artifact.js');
-const SDK = require('../lib/cdt/SDK.js');
-
-/**
- * Calculate the number of bytes contributed by each source file
- * @param {LH.Artifacts.Bundle['map']} map
- * @param {string} content
- * @return {LH.Artifacts.Bundle['sizes']}
- */
-function computeGeneratedFileSizes(map, content) {
-  const lines = content.split('\n');
-  /** @type {Record<string, number>} */
-  const files = {};
-  const totalBytes = content.length;
-  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'|'ScriptElements'>} artifacts
-   */
-  static async compute_(artifacts) {
-    const {SourceMaps, ScriptElements} = artifacts;
-
-    /** @type {LH.Artifacts.Bundle[]} */
-    const bundles = [];
-
-    // Collate map and script, compute file sizes.
-    for (const SourceMap of SourceMaps) {
-      if (!SourceMap.map) continue;
-      const {scriptUrl, map: rawMap} = SourceMap;
-
-      if (!rawMap.mappings) continue;
-
-      const scriptElement = ScriptElements.find(s => s.src === scriptUrl);
-      if (!scriptElement) continue;
-
-      const compiledUrl = SourceMap.scriptUrl || 'compiled.js';
-      const mapUrl = SourceMap.sourceMapUrl || 'compiled.js.map';
-      const map = new SDK.TextSourceMap(compiledUrl, mapUrl, rawMap);
-
-      const content = scriptElement?.content ? scriptElement.content : '';
-      const sizes = computeGeneratedFileSizes(map, content);
-
-      const bundle = {
-        rawMap,
-        script: scriptElement,
-        map,
-        sizes,
-      };
-      bundles.push(bundle);
-    }
-
-    return bundles;
-  }
-}
-
-module.exports = makeComputedArtifact(JSBundles, ['ScriptElements', 'SourceMaps']);