lighthouse 12.1.0 → 12.2.0

package/core/lib/lantern/TBTUtils.d.ts

@@ -1,44 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-export const BLOCKING_TIME_THRESHOLD: 50;
-/**
- * @param {Array<{start: number, end: number, duration: number}>} topLevelEvents
- * @param {number} startTimeMs
- * @param {number} endTimeMs
- * @return {number}
- */
-export function calculateSumOfBlockingTime(topLevelEvents: Array<{
-    start: number;
-    end: number;
-    duration: number;
-}>, startTimeMs: number, endTimeMs: number): number;
-/**
- * For TBT, We only want to consider tasks that fall in our time range
- * - FCP and TTI for navigation mode
- * - Trace start and trace end for timespan mode
- *
- * FCP is picked as `startTimeMs` because there is little risk of user input happening
- * before FCP so Long Queuing Qelay regions do not harm user experience. Developers should be
- * optimizing to reach FCP as fast as possible without having to worry about task lengths.
- *
- * TTI is picked as `endTimeMs` because we want a well defined end point for page load.
- *
- * @param {{start: number, end: number, duration: number}} event
- * @param {number} startTimeMs Should be FCP in navigation mode and the trace start time in timespan mode
- * @param {number} endTimeMs Should be TTI in navigation mode and the trace end time in timespan mode
- * @param {{start: number, end: number, duration: number}} [topLevelEvent] Leave unset if `event` is top level. Has no effect if `event` has the same duration as `topLevelEvent`.
- * @return {number}
- */
-export function calculateTbtImpactForEvent(event: {
-    start: number;
-    end: number;
-    duration: number;
-}, startTimeMs: number, endTimeMs: number, topLevelEvent?: {
-    start: number;
-    end: number;
-    duration: number;
-} | undefined): number;
-//# sourceMappingURL=TBTUtils.d.ts.map

package/core/lib/lantern/TBTUtils.js

@@ -1,76 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-const BLOCKING_TIME_THRESHOLD = 50;
-
-/**
- * For TBT, We only want to consider tasks that fall in our time range
- * - FCP and TTI for navigation mode
- * - Trace start and trace end for timespan mode
- *
- * FCP is picked as `startTimeMs` because there is little risk of user input happening
- * before FCP so Long Queuing Qelay regions do not harm user experience. Developers should be
- * optimizing to reach FCP as fast as possible without having to worry about task lengths.
- *
- * TTI is picked as `endTimeMs` because we want a well defined end point for page load.
- *
- * @param {{start: number, end: number, duration: number}} event
- * @param {number} startTimeMs Should be FCP in navigation mode and the trace start time in timespan mode
- * @param {number} endTimeMs Should be TTI in navigation mode and the trace end time in timespan mode
- * @param {{start: number, end: number, duration: number}} [topLevelEvent] Leave unset if `event` is top level. Has no effect if `event` has the same duration as `topLevelEvent`.
- * @return {number}
- */
-function calculateTbtImpactForEvent(event, startTimeMs, endTimeMs, topLevelEvent) {
-  let threshold = BLOCKING_TIME_THRESHOLD;
-
-  // If a task is not top level, it doesn't make sense to subtract the entire 50ms
-  // blocking threshold from the event.
-  //
-  // e.g. A 80ms top level task with two 40ms children should attribute some blocking
-  // time to the 40ms tasks even though they do not meet the 50ms threshold.
-  //
-  // The solution is to scale the threshold for child events to be considered blocking.
-  if (topLevelEvent) threshold *= (event.duration / topLevelEvent.duration);
-
-  if (event.duration < threshold) return 0;
-  if (event.end < startTimeMs) return 0;
-  if (event.start > endTimeMs) return 0;
-
-  // Perform the clipping and then calculate Blocking Region. So if we have a 150ms task
-  // [0, 150] and `startTimeMs` is at 50ms, we first clip the task to [50, 150], and then
-  // calculate the Blocking Region to be [100, 150]. The rational here is that tasks before
-  // the start time are unimportant, so we care whether the main thread is busy more than
-  // 50ms at a time only after the start time.
-  const clippedStart = Math.max(event.start, startTimeMs);
-  const clippedEnd = Math.min(event.end, endTimeMs);
-  const clippedDuration = clippedEnd - clippedStart;
-  if (clippedDuration < threshold) return 0;
-
-  return clippedDuration - threshold;
-}
-
-/**
- * @param {Array<{start: number, end: number, duration: number}>} topLevelEvents
- * @param {number} startTimeMs
- * @param {number} endTimeMs
- * @return {number}
- */
-function calculateSumOfBlockingTime(topLevelEvents, startTimeMs, endTimeMs) {
-  if (endTimeMs <= startTimeMs) return 0;
-
-  let sumBlockingTime = 0;
-  for (const event of topLevelEvents) {
-    sumBlockingTime += calculateTbtImpactForEvent(event, startTimeMs, endTimeMs);
-  }
-
-  return sumBlockingTime;
-}
-
-export {
-  BLOCKING_TIME_THRESHOLD,
-  calculateSumOfBlockingTime,
-  calculateTbtImpactForEvent,
-};

package/core/lib/lantern/TBTUtils.test.d.ts

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

package/core/lib/lantern/TBTUtils.test.js

@@ -1,130 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from './lantern.js';
-
-const {calculateSumOfBlockingTime} = Lantern.TBTUtils;
-
-describe('TotalBlockingTime utils', () => {
-  it('reports 0 when no task is longer than 50ms', () => {
-    const events = [
-      {start: 1000, end: 1050, duration: 50},
-      {start: 2000, end: 2010, duration: 10},
-    ];
-
-    const fcpTimeMs = 500;
-    const interactiveTimeMs = 4000;
-
-    expect(
-      calculateSumOfBlockingTime(events, fcpTimeMs, interactiveTimeMs)
-    ).toBe(0);
-  });
-
-  it('only looks at tasks within FCP and TTI', () => {
-    const events = [
-      {start: 1000, end: 1060, duration: 60},
-      {start: 2000, end: 2100, duration: 100},
-      {start: 2300, end: 2450, duration: 150},
-      {start: 2600, end: 2800, duration: 200},
-    ];
-
-    const fcpTimeMs = 1500;
-    const interactiveTimeMs = 2500;
-
-    expect(
-      calculateSumOfBlockingTime(events, fcpTimeMs, interactiveTimeMs)
-    ).toBe(150);
-  });
-
-  it('clips before finding blocking regions', () => {
-    const fcpTimeMs = 150;
-    const interactiveTimeMs = 300;
-
-    const events = [
-      // The clipping is done first, so the task becomes [150, 200] after clipping and contributes
-      // 0ms of blocking time. This is in contrast to first calculating the blocking region ([100,
-      // 200]) and then clipping at FCP (150ms), which yields 50ms blocking time.
-      {start: 50, end: 200, duration: 150},
-      // Similarly, the task is first clipped above to be [240, 300], and then contributes 10ms
-      // blocking time.
-      {start: 240, end: 460, duration: 120},
-    ];
-
-    expect(
-      calculateSumOfBlockingTime(events, fcpTimeMs, interactiveTimeMs)
-    ).toBe(10); // 0ms + 10ms.
-  });
-
-  // TTI can happen in the middle of a task, for example, if TTI is at FMP which occurs as part
-  // of a larger task, or in the lantern case where we use estimate TTI using a different graph
-  // from the one used to estimate TBT.
-  it('clips properly if TTI falls in the middle of a task', () => {
-    const fcpTimeMs = 1000;
-    const interactiveTimeMs = 2000;
-
-    expect(
-      calculateSumOfBlockingTime(
-        [{start: 1951, end: 2100, duration: 149}],
-        fcpTimeMs,
-        interactiveTimeMs
-      )
-    ).toBe(0); // Duration after clipping is 49, which is < 50.
-    expect(
-      calculateSumOfBlockingTime(
-        [{start: 1950, end: 2100, duration: 150}],
-        fcpTimeMs,
-        interactiveTimeMs
-      )
-    ).toBe(0); // Duration after clipping is 50, so time after 50ms is 0ms.
-    expect(
-      calculateSumOfBlockingTime(
-        [{start: 1949, end: 2100, duration: 151}],
-        fcpTimeMs,
-        interactiveTimeMs
-      )
-    ).toBe(1); // Duration after clipping is 51, so time after 50ms is 1ms.
-  });
-
-  it('clips properly if FCP falls in the middle of a task', () => {
-    const fcpTimeMs = 1000;
-    const interactiveTimeMs = 2000;
-
-    expect(
-      calculateSumOfBlockingTime(
-        [{start: 900, end: 1049, duration: 149}],
-        fcpTimeMs,
-        interactiveTimeMs
-      )
-    ).toBe(0); // Duration after clipping is 49, which is < 50.
-    expect(
-      calculateSumOfBlockingTime(
-        [{start: 900, end: 1050, duration: 150}],
-        fcpTimeMs,
-        interactiveTimeMs
-      )
-    ).toBe(0); // Duration after clipping is 50, so time after 50ms is 0ms.
-    expect(
-      calculateSumOfBlockingTime(
-        [{start: 900, end: 1051, duration: 151}],
-        fcpTimeMs,
-        interactiveTimeMs
-      )
-    ).toBe(1); // Duration after clipping is 51, so time after 50ms is 1ms.
-  });
-
-  // This can happen in the lantern metric case, where we use the optimistic
-  // TTI and pessimistic FCP.
-  it('returns 0 if interactiveTime is earlier than FCP', () => {
-    const fcpTimeMs = 2050;
-    const interactiveTimeMs = 1050;
-
-    const events = [{start: 500, end: 3000, duration: 2500}];
-
-    expect(
-      calculateSumOfBlockingTime(events, fcpTimeMs, interactiveTimeMs)
-    ).toBe(0);
-  });
-});

package/core/lib/lantern/TraceEngineComputationData.d.ts

@@ -1,25 +0,0 @@
-export type MetricName = import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricName;
-export type MetricScore = import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricScore;
-/** @typedef {import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricName} MetricName */
-/** @typedef {import('@paulirish/trace_engine/models/trace/handlers/PageLoadMetricsHandler.js').MetricScore} MetricScore */
-/**
- * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
- * @return {Lantern.Simulation.ProcessedNavigation}
- */
-export function createProcessedNavigation(traceEngineData: TraceEngine.Handlers.Types.TraceParseData): Lantern.Simulation.ProcessedNavigation;
-/**
- * @param {Lantern.Trace} trace
- * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
- * @return {Lantern.NetworkRequest[]}
- */
-export function createNetworkRequests(trace: Lantern.Trace, traceEngineData: TraceEngine.Handlers.Types.TraceParseData): Lantern.NetworkRequest[];
-/**
- * @param {Lantern.NetworkRequest[]} requests
- * @param {Lantern.Trace} trace
- * @param {TraceEngine.Handlers.Types.TraceParseData} traceEngineData
- * @param {Lantern.Simulation.URL=} URL
- */
-export function createGraph(requests: Lantern.NetworkRequest[], trace: Lantern.Trace, traceEngineData: TraceEngine.Handlers.Types.TraceParseData, URL?: Lantern.Simulation.URL | undefined): import("./PageDependencyGraph.js").Node;
-import * as TraceEngine from '@paulirish/trace_engine';
-import * as Lantern from './lantern.js';
-//# sourceMappingURL=TraceEngineComputationData.d.ts.map