chrome-devtools-frontend 1.0.1664496 → 1.0.1665921

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onFCP.js

@@ -16,40 +16,61 @@
 import { getBFCacheRestoreTime } from '../lib/bfcache.js';
 import { getLoadState } from '../lib/getLoadState.js';
 import { getNavigationEntry } from '../lib/getNavigationEntry.js';
+import { initUnique } from '../lib/initUnique.js';
+import { FCPEntryManager } from '../lib/FCPEntryManager.js';
+import { checkSoftNavsEnabled } from '../lib/softNavs.js';
 import { onFCP as unattributedOnFCP } from '../onFCP.js';
-const attributeFCP = (metric) => {
-    // Use a default object if no other attribution has been set.
-    let attribution = {
-        timeToFirstByte: 0,
-        firstByteToFCP: metric.value,
-        loadState: getLoadState(getBFCacheRestoreTime()),
-    };
-    if (metric.entries.length) {
-        const navigationEntry = getNavigationEntry();
-        const fcpEntry = metric.entries.at(-1);
-        if (navigationEntry) {
-            const activationStart = navigationEntry.activationStart || 0;
-            const ttfb = Math.max(0, navigationEntry.responseStart - activationStart);
-            attribution = {
-                timeToFirstByte: ttfb,
-                firstByteToFCP: metric.value - ttfb,
-                loadState: getLoadState(metric.entries[0].startTime),
-                navigationEntry,
-                fcpEntry,
-            };
-        }
-    }
-    // Use `Object.assign()` to ensure the original metric object is returned.
-    const metricWithAttribution = Object.assign(metric, { attribution });
-    return metricWithAttribution;
-};
-/**
- * Calculates the [FCP](https://web.dev/articles/fcp) value for the current page and
- * calls the `callback` function once the value is ready, along with the
- * relevant `paint` performance entry used to determine the value. The reported
- * value is a `DOMHighResTimeStamp`.
- */
 export const onFCP = (onReport, opts = {}) => {
+    opts = Object.assign({}, opts);
+    // Init the fcpEntryManager (which will already be initialised in the
+    // unattributed onFCP method if soft navigation reporting is enabled
+    // and so will return that fcpEntryManager, rather than a new one)
+    const fcpEntryManager = initUnique(opts, FCPEntryManager);
+    if (checkSoftNavsEnabled(opts)) {
+        fcpEntryManager._softNavigationEntryMap = new Map();
+    }
+    const attributeFCP = (metric) => {
+        // Use a default object if no other attribution has been set.
+        let attribution = {
+            timeToFirstByte: 0,
+            firstByteToFCP: metric.value,
+            loadState: getLoadState(getBFCacheRestoreTime()),
+        };
+        if (metric.navigationType !== 'soft-navigation') {
+            if (metric.entries.length) {
+                const navigationEntry = getNavigationEntry();
+                const fcpEntry = metric.entries.at(-1);
+                if (navigationEntry) {
+                    const responseStart = navigationEntry.responseStart;
+                    const activationStart = navigationEntry.activationStart || 0;
+                    const ttfb = Math.max(0, responseStart - activationStart);
+                    attribution = {
+                        timeToFirstByte: ttfb,
+                        firstByteToFCP: metric.value - ttfb,
+                        loadState: getLoadState(metric.entries[0].startTime),
+                        navigationEntry,
+                        fcpEntry,
+                    };
+                }
+            }
+        }
+        else {
+            // Lookup the soft navigation entry. Do not use getEntriesByType since
+            // that is limited to the first 50 navigation entries due to buffer size.
+            const navigationEntry = fcpEntryManager._softNavigationEntryMap?.get(metric.navigationId);
+            if (navigationEntry) {
+                attribution = {
+                    timeToFirstByte: 0,
+                    firstByteToFCP: metric.value,
+                    loadState: 'complete',
+                    navigationEntry,
+                };
+            }
+        }
+        // Use `Object.assign()` to ensure the original metric object is returned.
+        const metricWithAttribution = Object.assign(metric, { attribution });
+        return metricWithAttribution;
+    };
     unattributedOnFCP((metric) => {
         onReport(attributeFCP(metric));
     }, opts);

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onINP.d.ts

@@ -1,4 +1,4 @@
-import { INPAttributionReportOpts, INPMetricWithAttribution } from '../types.js';
+import type { INPAttributionReportOpts, INPMetricWithAttribution } from '../types.js';
 /**
  * Calculates the [INP](https://web.dev/articles/inp) value for the current
  * page and calls the `callback` function once the value is ready, along with
@@ -16,7 +16,7 @@ import { INPAttributionReportOpts, INPMetricWithAttribution } from '../types.js'
  *
  * A custom `includeProcessedEventEntries` configuration option can optionally
  * be passed to control whether the `processedEventEntries` array in the
- * attribution object is populated. The default value is `true`.
+ * attribution object is populated. The default value is `false`.
  *
  * If the `reportAllChanges` configuration option is set to `true`, the
  * `callback` function will be called as soon as the value is initially

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onINP.js

@@ -16,7 +16,7 @@
 import { getLoadState } from '../lib/getLoadState.js';
 import { getSelector } from '../lib/getSelector.js';
 import { initUnique } from '../lib/initUnique.js';
-import { InteractionManager } from '../lib/InteractionManager.js';
+import { InteractionManager, } from '../lib/InteractionManager.js';
 import { observe } from '../lib/observe.js';
 import { whenIdleOrHidden } from '../lib/whenIdleOrHidden.js';
 import { onINP as unattributedOnINP } from '../onINP.js';
@@ -45,7 +45,7 @@ const MAX_PENDING_FRAMES = 10;
  *
  * A custom `includeProcessedEventEntries` configuration option can optionally
  * be passed to control whether the `processedEventEntries` array in the
- * attribution object is populated. The default value is `true`.
+ * attribution object is populated. The default value is `false`.
  *
  * If the `reportAllChanges` configuration option is set to `true`, the
  * `callback` function will be called as soon as the value is initially
@@ -95,11 +95,19 @@ export const onINP = (onReport, opts = {}) => {
     };
     const saveInteractionTarget = (interaction) => {
         if (!interactionTargetMap.get(interaction)) {
-            const node = interaction.entries[0].target;
+            // Use find to get first selector
+            const node = interaction.entries.find((e) => e.target)?.target;
             if (node) {
                 const customTarget = opts.generateTarget?.(node) ?? getSelector(node);
                 interactionTargetMap.set(interaction, customTarget);
             }
+            else {
+                // Fall back to targetSelector
+                const selector = interaction.entries.find((e) => e.targetSelector)?.targetSelector;
+                if (selector) {
+                    interactionTargetMap.set(interaction, selector);
+                }
+            }
         }
     };
     /**
@@ -129,7 +137,7 @@ export const onINP = (onReport, opts = {}) => {
                 group.processingEnd = Math.max(entry.processingEnd, group.processingEnd);
                 // processedEventEntries can be quite large, so only include them if
                 // the user explicitly requests them (default is to include).
-                if (opts.includeProcessedEventEntries !== false) {
+                if (opts.includeProcessedEventEntries) {
                     group.entries.push(entry);
                 }
                 break;
@@ -144,7 +152,7 @@ export const onINP = (onReport, opts = {}) => {
                 renderTime,
                 // processedEventEntries can be quite large, so only include them if
                 // the user explicitly requests them (default is to include).
-                entries: opts.includeProcessedEventEntries !== false ? [entry] : [],
+                entries: opts.includeProcessedEventEntries ? [entry] : [],
             };
             pendingEntriesGroups.push(group);
         }
@@ -216,6 +224,7 @@ export const onINP = (onReport, opts = {}) => {
             rating: 'good',
             value: entry.duration,
             delta: entry.duration,
+            navigationId: entry.navigationId,
             navigationType: 'navigate',
             id: 'N/A',
         });
@@ -242,11 +251,15 @@ export const onINP = (onReport, opts = {}) => {
         return intersectingLoAFs;
     };
     const attributeLoAFDetails = (attribution) => {
-        // If there is no LoAF data then nothing further to attribute
-        if (!attribution.longAnimationFrameEntries?.length) {
+        const interactionTime = attribution.interactionTime;
+        const nextPaintTime = attribution.nextPaintTime;
+        // If there is no LoAF data, interactionTime or paintTime
+        // then nothing further to attribute here.
+        if (!attribution.longAnimationFrameEntries?.length ||
+            !interactionTime ||
+            !nextPaintTime) {
             return;
         }
-        const interactionTime = attribution.interactionTime;
         const inputDelay = attribution.inputDelay;
         const processingDuration = attribution.processingDuration;
         // Stats across all LoAF entries and scripts.
@@ -302,7 +315,7 @@ export const onINP = (onReport, opts = {}) => {
             ? lastLoAF.startTime + lastLoAF.duration
             : 0;
         if (lastLoAFEndTime >= interactionTime + inputDelay + processingDuration) {
-            totalPaintDuration = attribution.nextPaintTime - lastLoAFEndTime;
+            totalPaintDuration = nextPaintTime - lastLoAFEndTime;
         }
         if (longestScriptEntry && longestScriptSubpart) {
             attribution.longestScript = {
@@ -315,16 +328,34 @@ export const onINP = (onReport, opts = {}) => {
         attribution.totalStyleAndLayoutDuration = totalStyleAndLayoutDuration;
         attribution.totalPaintDuration = totalPaintDuration;
         attribution.totalUnattributedDuration =
-            attribution.nextPaintTime -
+            nextPaintTime -
                 interactionTime -
                 totalScriptDuration -
                 totalStyleAndLayoutDuration -
                 totalPaintDuration;
     };
     const attributeINP = (metric) => {
+        // Soft navs and bfcache can have a dummy INP as no first-input entry to
+        // fall back on so we report dummy values when the interactionCount has
+        // gone up, even if no entry was emitted.
+        // See https://github.com/GoogleChrome/web-vitals/issues/724
+        // All other INPs should have at least one entry, but we'll do same dummy
+        // processing if they don't for some reason.
+        if (metric.entries.length === 0) {
+            const navStartTime = metric.navigationStartTime || 0;
+            const attribution = {
+                processedEventEntries: [],
+                longAnimationFrameEntries: [],
+                inputDelay: 0,
+                processingDuration: 0,
+                presentationDelay: metric.value,
+                loadState: getLoadState(navStartTime),
+            };
+            return Object.assign(metric, { attribution });
+        }
         const firstEntry = metric.entries[0];
         const group = entryToEntriesGroupMap.get(firstEntry);
-        const processingStart = firstEntry.processingStart;
+        const processingStart = group.processingStart;
         // Due to the fact that durations can be rounded down to the nearest 8ms,
         // we have to clamp `nextPaintTime` so it doesn't appear to occur before
         // processing starts. Note: we can't use `processingEnd` since processing
@@ -368,7 +399,7 @@ export const onINP = (onReport, opts = {}) => {
         return Object.assign(metric, { attribution });
     };
     // Start observing LoAF entries for attribution.
-    observe('long-animation-frame', handleLoAFEntries);
+    observe(['long-animation-frame'], handleLoAFEntries, opts);
     unattributedOnINP((metric) => {
         onReport(attributeINP(metric));
     }, opts);

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onLCP.d.ts

@@ -1,4 +1,4 @@
-import { LCPMetricWithAttribution, AttributionReportOpts } from '../types.js';
+import type { LCPMetricWithAttribution, AttributionReportOpts } from '../types.js';
 /**
  * Calculates the [LCP](https://web.dev/articles/lcp) value for the current page and
  * calls the `callback` function once the value is ready (along with the

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onLCP.js

@@ -17,6 +17,7 @@ import { getNavigationEntry } from '../lib/getNavigationEntry.js';
 import { getSelector } from '../lib/getSelector.js';
 import { initUnique } from '../lib/initUnique.js';
 import { LCPEntryManager } from '../lib/LCPEntryManager.js';
+import { checkSoftNavsEnabled } from '../lib/softNavs.js';
 import { onLCP as unattributedOnLCP } from '../onLCP.js';
 /**
  * Calculates the [LCP](https://web.dev/articles/lcp) value for the current page and
@@ -37,6 +38,9 @@ export const onLCP = (onReport, opts = {}) => {
     opts = Object.assign({}, opts);
     const lcpEntryManager = initUnique(opts, LCPEntryManager);
     const lcpTargetMap = new WeakMap();
+    if (checkSoftNavsEnabled(opts)) {
+        lcpEntryManager._softNavigationEntryMap = new Map();
+    }
     lcpEntryManager._onBeforeProcessingEntry = (entry) => {
         const node = entry.element;
         if (node) {
@@ -75,10 +79,24 @@ export const onLCP = (onReport, opts = {}) => {
             }
             // Get subparts from navigation entry. Do this last as occasionally
             // Safari seems to fail to find a navigation entry.
-            const navigationEntry = getNavigationEntry();
+            let navigationEntry;
+            let activationStart = 0;
+            let responseStart = 0;
+            if (metric.navigationType !== 'soft-navigation') {
+                navigationEntry = getNavigationEntry();
+                activationStart = navigationEntry?.activationStart ?? 0;
+                responseStart = navigationEntry?.responseStart ?? 0;
+            }
+            else {
+                // Set activationStart to the navigation start time
+                activationStart = metric.navigationStartTime || 0;
+                // Lookup the soft navigation entry. Do not use getEntriesByType since
+                // that is limited to the first 50 navigation entries due to buffer
+                // size.
+                navigationEntry = lcpEntryManager._softNavigationEntryMap?.get(metric.navigationId);
+            }
             if (navigationEntry) {
-                const activationStart = navigationEntry.activationStart || 0;
-                const ttfb = Math.max(0, navigationEntry.responseStart - activationStart);
+                const ttfb = Math.max(0, responseStart - activationStart);
                 const lcpRequestStart = Math.max(ttfb, 
                 // Prefer `requestStart` (if TOA is set), otherwise use `startTime`.
                 lcpResourceEntry

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onTTFB.d.ts

@@ -1,4 +1,4 @@
-import { TTFBMetricWithAttribution, AttributionReportOpts } from '../types.js';
+import type { TTFBMetricWithAttribution, AttributionReportOpts } from '../types.js';
 /**
  * Calculates the [TTFB](https://web.dev/articles/ttfb) value for the
  * current page and calls the `callback` function once the page has loaded,

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onTTFB.js

@@ -15,6 +15,7 @@
  */
 import { onTTFB as unattributedOnTTFB } from '../onTTFB.js';
 const attributeTTFB = (metric) => {
+    const navigationEntry = metric.entries[0];
     // Use a default object if no other attribution has been set.
     let attribution = {
         waitingDuration: 0,
@@ -22,32 +23,37 @@ const attributeTTFB = (metric) => {
         dnsDuration: 0,
         connectionDuration: 0,
         requestDuration: 0,
+        // There should only be one instance per TTFB metric
+        navigationEntry: navigationEntry,
     };
     if (metric.entries.length) {
-        const navigationEntry = metric.entries[0];
-        const activationStart = navigationEntry.activationStart || 0;
-        // Measure from workerStart or fetchStart so any service worker startup
-        // time is included in cacheDuration (which also includes other sw time
-        // anyway, that cannot be accurately split out cross-browser).
-        const waitEnd = Math.max((navigationEntry.workerStart || navigationEntry.fetchStart) -
-            activationStart, 0);
-        const dnsStart = Math.max(navigationEntry.domainLookupStart - activationStart, 0);
-        const connectStart = Math.max(navigationEntry.connectStart - activationStart, 0);
-        const connectEnd = Math.max(navigationEntry.connectEnd - activationStart, 0);
-        attribution = {
-            waitingDuration: waitEnd,
-            cacheDuration: dnsStart - waitEnd,
-            // dnsEnd usually equals connectStart but use connectStart over dnsEnd
-            // for dnsDuration in case there ever is a gap.
-            dnsDuration: connectStart - dnsStart,
-            connectionDuration: connectEnd - connectStart,
-            // There is often a gap between connectEnd and requestStart. Attribute
-            // that to requestDuration so connectionDuration remains 0 for
-            // service worker controlled requests were connectStart and connectEnd
-            // are the same.
-            requestDuration: metric.value - connectEnd,
-            navigationEntry: navigationEntry,
-        };
+        // If it's the hard nav, then can give attribution.
+        // Otherwise it's 0 so the defaults are fine.
+        if (navigationEntry instanceof PerformanceNavigationTiming) {
+            const activationStart = navigationEntry.activationStart || 0;
+            // Measure from workerStart or fetchStart so any service worker startup
+            // time is included in cacheDuration (which also includes other sw time
+            // anyway, that cannot be accurately split out cross-browser).
+            const waitEnd = Math.max((navigationEntry.workerStart || navigationEntry.fetchStart || 0) -
+                activationStart, 0);
+            const dnsStart = Math.max(navigationEntry.domainLookupStart - activationStart, 0);
+            const connectStart = Math.max(navigationEntry.connectStart - activationStart, 0);
+            const connectEnd = Math.max(navigationEntry.connectEnd - activationStart, 0);
+            attribution = {
+                waitingDuration: waitEnd,
+                cacheDuration: dnsStart - waitEnd,
+                // dnsEnd usually equals connectStart but use connectStart over dnsEnd
+                // for dnsDuration in case there ever is a gap.
+                dnsDuration: connectStart - dnsStart,
+                connectionDuration: connectEnd - connectStart,
+                // There is often a gap between connectEnd and requestStart. Attribute
+                // that to requestDuration so connectionDuration remains 0 for
+                // service worker controlled requests were connectStart and connectEnd
+                // are the same.
+                requestDuration: metric.value - connectEnd,
+                navigationEntry: navigationEntry,
+            };
+        }
     }
     // Use `Object.assign()` to ensure the original metric object is returned.
     const metricWithAttribution = Object.assign(metric, { attribution });

package/front_end/third_party/web-vitals/package/dist/modules/lib/FCPEntryManager.d.ts

@@ -0,0 +1,3 @@
+export declare class FCPEntryManager {
+    _softNavigationEntryMap?: Map<number, PerformanceSoftNavigation>;
+}

package/front_end/third_party/web-vitals/package/dist/modules/lib/FCPEntryManager.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * 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
+ *
+ *     https://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.
+ */
+export class FCPEntryManager {
+    _softNavigationEntryMap;
+}

package/front_end/third_party/web-vitals/package/dist/modules/lib/InteractionManager.d.ts

@@ -1,3 +1,4 @@
+import type { Metric } from '../types.js';
 export interface Interaction {
     _latency: number;
     id: number;
@@ -22,7 +23,7 @@ export declare class InteractionManager {
      * Returns the estimated p98 longest interaction based on the stored
      * interaction candidates and the interaction count for the current page.
      */
-    _estimateP98LongestInteraction(): Interaction;
+    _estimateP98LongestInteraction(navigationType: Metric['navigationType']): Interaction;
     /**
      * Takes a performance entry and adds it to the list of worst interactions
      * if its duration is long enough to make it among the worst. If the

package/front_end/third_party/web-vitals/package/dist/modules/lib/InteractionManager.js

@@ -50,8 +50,24 @@ export class InteractionManager {
      * Returns the estimated p98 longest interaction based on the stored
      * interaction candidates and the interaction count for the current page.
      */
-    _estimateP98LongestInteraction() {
-        const candidateInteractionIndex = Math.min(this._longestInteractionList.length - 1, Math.floor(getInteractionCountForNavigation() / 50));
+    _estimateP98LongestInteraction(navigationType) {
+        const interactionCountForNavigation = getInteractionCountForNavigation();
+        const candidateInteractionIndex = Math.min(this._longestInteractionList.length - 1, Math.floor(interactionCountForNavigation / 50));
+        // If we have a non-zero interactionCountForNavigation but no
+        // candidateInteractionIndex, then it's below the 16ms limit
+        // so report a dummy 8ms interaction. This is only needed for
+        // soft-navs and bfcache restores as `first-input` handles the
+        // rest.
+        if (interactionCountForNavigation &&
+            candidateInteractionIndex === -1 &&
+            (navigationType === 'soft-navigation' ||
+                navigationType === 'back-forward-cache')) {
+            return {
+                _latency: 8,
+                id: -1,
+                entries: [],
+            };
+        }
         return this._longestInteractionList[candidateInteractionIndex];
     }
     /**

package/front_end/third_party/web-vitals/package/dist/modules/lib/LCPEntryManager.d.ts

@@ -1,4 +1,5 @@
 export declare class LCPEntryManager {
     _onBeforeProcessingEntry?: (entry: LargestContentfulPaint) => void;
+    _softNavigationEntryMap?: Map<number, PerformanceSoftNavigation>;
     _processEntry(entry: LargestContentfulPaint): void;
 }

package/front_end/third_party/web-vitals/package/dist/modules/lib/LCPEntryManager.js

@@ -15,6 +15,7 @@
  */
 export class LCPEntryManager {
     _onBeforeProcessingEntry;
+    _softNavigationEntryMap;
     _processEntry(entry) {
         this._onBeforeProcessingEntry?.(entry);
     }

package/front_end/third_party/web-vitals/package/dist/modules/lib/bindReporter.d.ts

@@ -1,4 +1,4 @@
-import { MetricType, MetricRatingThresholds } from '../types.js';
+import type { MetricType, MetricRatingThresholds } from '../types.js';
 export declare const bindReporter: <MetricName extends MetricType["name"]>(callback: (metric: Extract<MetricType, {
     name: MetricName;
 }>) => void, metric: Extract<MetricType, {

package/front_end/third_party/web-vitals/package/dist/modules/lib/generateUniqueID.js

@@ -19,5 +19,5 @@
  * @return {string}
  */
 export const generateUniqueID = () => {
-    return `v5-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;
+    return `v6-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;
 };

package/front_end/third_party/web-vitals/package/dist/modules/lib/getLoadState.d.ts

@@ -1,2 +1,2 @@
-import { LoadState } from '../types.js';
+import type { LoadState } from '../types.js';
 export declare const getLoadState: (timestamp: number) => LoadState;

package/front_end/third_party/web-vitals/package/dist/modules/lib/getLoadState.js

@@ -20,19 +20,19 @@ export const getLoadState = (timestamp) => {
         // since the timestamp has to be the current time or earlier.
         return 'loading';
     }
-    const navigationEntry = getNavigationEntry();
-    if (navigationEntry) {
-        if (timestamp < navigationEntry.domInteractive) {
+    const hardNavEntry = getNavigationEntry();
+    if (hardNavEntry) {
+        if (timestamp < hardNavEntry.domInteractive) {
             return 'loading';
         }
-        if (navigationEntry.domContentLoadedEventStart === 0 ||
-            timestamp < navigationEntry.domContentLoadedEventStart) {
+        else if (hardNavEntry.domContentLoadedEventStart === 0 ||
+            timestamp < hardNavEntry.domContentLoadedEventStart) {
             // If the `domContentLoadedEventStart` timestamp has not yet been
             // set, or if the given timestamp is less than that value.
             return 'dom-interactive';
         }
-        if (navigationEntry.domComplete === 0 ||
-            timestamp < navigationEntry.domComplete) {
+        else if (hardNavEntry.domComplete === 0 ||
+            timestamp < hardNavEntry.domComplete) {
             // If the `domComplete` timestamp has not yet been
             // set, or if the given timestamp is less than that value.
             return 'dom-content-loaded';

package/front_end/third_party/web-vitals/package/dist/modules/lib/getSelector.js

@@ -27,7 +27,7 @@ export const getSelector = (node) => {
             const el = node;
             const part = el.id
                 ? '#' + el.id
-                : [getName(el), ...Array.from(el.classList).sort()].join('.');
+                : [getName(el), ...Array.from(el.classList ?? []).sort()].join('.');
             if (sel.length + part.length > MAX_LEN - 1) {
                 return sel || part;
             }

package/front_end/third_party/web-vitals/package/dist/modules/lib/getVisibilityWatcher.d.ts

@@ -1,4 +1,4 @@
-export declare const getVisibilityWatcher: () => {
+export declare const getVisibilityWatcher: (reset?: boolean) => {
     readonly firstHiddenTime: number;
     onHidden(cb: () => void): void;
 };

package/front_end/third_party/web-vitals/package/dist/modules/lib/getVisibilityWatcher.js

@@ -53,7 +53,10 @@ const onVisibilityUpdate = (event) => {
         }
     }
 };
-export const getVisibilityWatcher = () => {
+export const getVisibilityWatcher = (reset = false) => {
+    if (reset) {
+        firstHiddenTime = Infinity;
+    }
     if (firstHiddenTime < 0) {
         // Check if we have a previous hidden `visibility-state` performance entry.
         const activationStart = getActivationStart();

package/front_end/third_party/web-vitals/package/dist/modules/lib/initMetric.d.ts

@@ -1,5 +1,5 @@
-import { MetricType } from '../types.js';
-export declare const initMetric: <MetricName extends MetricType["name"]>(name: MetricName, value?: number) => {
+import type { MetricType } from '../types.js';
+export declare const initMetric: <MetricName extends MetricType["name"]>(name: MetricName, value?: number, navigationType?: MetricType["navigationType"], navigationId?: number, navigationInteractionId?: number, navigationURL?: string, navigationStartTime?: number) => {
     name: MetricName;
     value: number;
     rating: "good";
@@ -16,5 +16,9 @@ export declare const initMetric: <MetricName extends MetricType["name"]>(name: M
         name: MetricName;
     }>)["entries"];
     id: string;
-    navigationType: "reload" | "navigate" | "back-forward" | "back-forward-cache" | "prerender" | "restore";
+    navigationType: "reload" | "navigate" | "soft-navigation" | "back-forward" | "back-forward-cache" | "prerender" | "restore";
+    navigationId: number;
+    navigationInteractionId: number | undefined;
+    navigationURL: string | undefined;
+    navigationStartTime: number;
 };

package/front_end/third_party/web-vitals/package/dist/modules/lib/initMetric.js

@@ -17,21 +17,26 @@ import { getBFCacheRestoreTime } from './bfcache.js';
 import { generateUniqueID } from './generateUniqueID.js';
 import { getActivationStart } from './getActivationStart.js';
 import { getNavigationEntry } from './getNavigationEntry.js';
-export const initMetric = (name, value = -1) => {
-    const navEntry = getNavigationEntry();
-    let navigationType = 'navigate';
-    if (getBFCacheRestoreTime() >= 0) {
-        navigationType = 'back-forward-cache';
+export const initMetric = (name, value = -1, navigationType, navigationId = 0, navigationInteractionId, navigationURL, navigationStartTime) => {
+    const hardNavEntry = getNavigationEntry();
+    const hardNavId = hardNavEntry?.navigationId || 0;
+    let _navigationType = 'navigate';
+    if (navigationType) {
+        // If it was passed in, then use that
+        _navigationType = navigationType;
     }
-    else if (navEntry) {
+    else if (getBFCacheRestoreTime() >= 0) {
+        _navigationType = 'back-forward-cache';
+    }
+    else if (hardNavEntry) {
         if (document.prerendering || getActivationStart() > 0) {
-            navigationType = 'prerender';
+            _navigationType = 'prerender';
         }
         else if (document.wasDiscarded) {
-            navigationType = 'restore';
+            _navigationType = 'restore';
         }
-        else if (navEntry.type) {
-            navigationType = navEntry.type.replace(/_/g, '-');
+        else if (hardNavEntry.type) {
+            _navigationType = hardNavEntry.type.replace(/_/g, '-');
         }
     }
     // Use `entries` type specific for the metric.
@@ -43,6 +48,10 @@ export const initMetric = (name, value = -1) => {
         delta: 0,
         entries,
         id: generateUniqueID(),
-        navigationType,
+        navigationType: _navigationType,
+        navigationId: navigationId || hardNavId,
+        navigationInteractionId: navigationInteractionId,
+        navigationURL: navigationURL || hardNavEntry?.name,
+        navigationStartTime: navigationStartTime || 0,
     };
 };

package/front_end/third_party/web-vitals/package/dist/modules/lib/initUnique.js

@@ -20,8 +20,13 @@ const instanceMap = new WeakMap();
  * identity object was previously used.
  */
 export function initUnique(identityObj, ClassObj) {
-    if (!instanceMap.get(identityObj)) {
-        instanceMap.set(identityObj, new ClassObj());
+    let classInstances = instanceMap.get(ClassObj);
+    if (!classInstances) {
+        classInstances = new WeakMap();
+        instanceMap.set(ClassObj, classInstances);
     }
-    return instanceMap.get(identityObj);
+    if (!classInstances.get(identityObj)) {
+        classInstances.set(identityObj, new ClassObj());
+    }
+    return classInstances.get(identityObj);
 }