@sentry/browser-utils 10.58.0

package/build/types-ts3.8/metrics/instrument.d.ts

@@ -0,0 +1,121 @@
+type InstrumentHandlerTypePerformanceObserver = 'longtask' | 'event' | 'navigation' | 'paint' | 'resource' | 'element' | 'first-input';
+interface PerformanceEntry {
+    readonly duration: number;
+    readonly entryType: string;
+    readonly name: string;
+    readonly startTime: number;
+    toJSON(): Record<string, unknown>;
+}
+export interface PerformanceEventTiming extends PerformanceEntry {
+    processingStart: number;
+    processingEnd: number;
+    duration: number;
+    cancelable?: boolean;
+    target?: unknown | null;
+    interactionId?: number;
+}
+interface PerformanceScriptTiming extends PerformanceEntry {
+    sourceURL: string;
+    sourceFunctionName: string;
+    sourceCharPosition: number;
+    invoker: string;
+    invokerType: string;
+}
+export interface PerformanceLongAnimationFrameTiming extends PerformanceEntry {
+    scripts: PerformanceScriptTiming[];
+}
+interface Metric {
+    /**
+     * The name of the metric (in acronym form).
+     */
+    name: 'CLS' | 'FCP' | 'INP' | 'LCP' | 'TTFB';
+    /**
+     * The current value of the metric.
+     */
+    value: number;
+    /**
+     * The rating as to whether the metric value is within the "good",
+     * "needs improvement", or "poor" thresholds of the metric.
+     */
+    rating: 'good' | 'needs-improvement' | 'poor';
+    /**
+     * The delta between the current value and the last-reported value.
+     * On the first report, `delta` and `value` will always be the same.
+     */
+    delta: number;
+    /**
+     * A unique ID representing this particular metric instance. This ID can
+     * be used by an analytics tool to dedupe multiple values sent for the same
+     * metric instance, or to group multiple deltas together and calculate a
+     * total. It can also be used to differentiate multiple different metric
+     * instances sent from the same page, which can happen if the page is
+     * restored from the back/forward cache (in that case new metrics object
+     * get created).
+     */
+    id: string;
+    /**
+     * Any performance entries relevant to the metric value calculation.
+     * The array may also be empty if the metric value was not based on any
+     * entries (e.g. a CLS value of 0 given no layout shifts).
+     */
+    entries: PerformanceEntry[];
+    /**
+     * The type of navigation
+     *
+     * Navigation Timing API (or `undefined` if the browser doesn't
+     * support that API). For pages that are restored from the bfcache, this
+     * value will be 'back-forward-cache'.
+     */
+    navigationType: 'navigate' | 'reload' | 'back-forward' | 'back-forward-cache' | 'prerender' | 'restore';
+}
+type CleanupHandlerCallback = () => void;
+/**
+ * Add a callback that will be triggered when a CLS metric is available.
+ * Returns a cleanup callback which can be called to remove the instrumentation handler.
+ *
+ * Pass `stopOnCallback = true` to stop listening for CLS when the cleanup callback is called.
+ * This will lead to the CLS being finalized and frozen.
+ */
+export declare function addClsInstrumentationHandler(callback: (data: {
+    metric: Metric;
+}) => void, stopOnCallback?: boolean): CleanupHandlerCallback;
+/**
+ * Add a callback that will be triggered when a LCP metric is available.
+ * Returns a cleanup callback which can be called to remove the instrumentation handler.
+ *
+ * Pass `stopOnCallback = true` to stop listening for LCP when the cleanup callback is called.
+ * This will lead to the LCP being finalized and frozen.
+ */
+export declare function addLcpInstrumentationHandler(callback: (data: {
+    metric: Metric;
+}) => void, stopOnCallback?: boolean): CleanupHandlerCallback;
+/**
+ * Add a callback that will be triggered when a TTFD metric is available.
+ */
+export declare function addTtfbInstrumentationHandler(callback: (data: {
+    metric: Metric;
+}) => void): CleanupHandlerCallback;
+export type InstrumentationHandlerCallback = (data: {
+    metric: Pick<Metric, Exclude<keyof Metric, 'entries'>> & {
+        entries: PerformanceEventTiming[];
+    };
+}) => void;
+/**
+ * Add a callback that will be triggered when a INP metric is available.
+ * Returns a cleanup callback which can be called to remove the instrumentation handler.
+ */
+export declare function addInpInstrumentationHandler(callback: InstrumentationHandlerCallback): CleanupHandlerCallback;
+export declare function addPerformanceInstrumentationHandler(type: 'event', callback: (data: {
+    entries: ((PerformanceEntry & {
+        target?: unknown | null;
+    }) | PerformanceEventTiming)[];
+}) => void): CleanupHandlerCallback;
+export declare function addPerformanceInstrumentationHandler(type: InstrumentHandlerTypePerformanceObserver, callback: (data: {
+    entries: PerformanceEntry[];
+}) => void): CleanupHandlerCallback;
+/**
+ * Check if a PerformanceEntry is a PerformanceEventTiming by checking for the `duration` property.
+ */
+export declare function isPerformanceEventTiming(entry: PerformanceEntry): entry is PerformanceEventTiming;
+export {};
+//# sourceMappingURL=instrument.d.ts.map

package/build/types-ts3.8/metrics/lcp.d.ts

@@ -0,0 +1,22 @@
+import { Client } from '@sentry/core';
+import { WebVitalReportEvent } from './utils';
+/**
+ * 60 seconds is the maximum for a plausible LCP value.
+ */
+export declare const MAX_PLAUSIBLE_LCP_DURATION = 60000;
+export declare function isValidLcpMetric(lcpValue: number | undefined): lcpValue is number;
+/**
+ * Starts tracking the Largest Contentful Paint on the current page and collects the value once
+ *
+ * - the page visibility is hidden
+ * - a navigation span is started (to stop LCP measurement for SPA soft navigations)
+ *
+ * Once either of these events triggers, the LCP value is sent as a standalone span and we stop
+ * measuring LCP for subsequent routes.
+ */
+export declare function trackLcpAsStandaloneSpan(client: Client): void;
+/**
+ * Exported only for testing!
+ */
+export declare function _sendStandaloneLcpSpan(lcpValue: number, entry: LargestContentfulPaint | undefined, pageloadSpanId: string, reportEvent: WebVitalReportEvent): void;
+//# sourceMappingURL=lcp.d.ts.map

package/build/types-ts3.8/metrics/resourceTiming.d.ts

@@ -0,0 +1,13 @@
+import { SpanAttributes } from '@sentry/core';
+/**
+ * Converts a PerformanceResourceTiming entry to span data for the resource span. Most importantly,
+ * it converts the timing values from timestamps relative to the `performance.timeOrigin` to absolute timestamps
+ * in seconds.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming#timestamps
+ *
+ * @param resourceTiming
+ * @returns An array where the first element is the attribute name and the second element is the attribute value.
+ */
+export declare function resourceTimingToSpanAttributes(resourceTiming: PerformanceResourceTiming): SpanAttributes;
+//# sourceMappingURL=resourceTiming.d.ts.map

package/build/types-ts3.8/metrics/utils.d.ts

@@ -0,0 +1,73 @@
+import { Client, Span, SpanAttributes, SpanTimeInput, StartSpanOptions } from '@sentry/core';
+export type WebVitalReportEvent = 'pagehide' | 'navigation';
+/**
+ * Checks if a given value is a valid measurement value.
+ */
+export declare function isMeasurementValue(value: unknown): value is number;
+/**
+ * Helper function to start child on transactions. This function will make sure that the transaction will
+ * use the start timestamp of the created child span if it is earlier than the transactions actual
+ * start timestamp.
+ */
+export declare function startAndEndSpan(parentSpan: Span, startTimeInSeconds: number, endTime: SpanTimeInput, { ...ctx }: StartSpanOptions): Span | undefined;
+interface StandaloneWebVitalSpanOptions {
+    name: string;
+    transaction?: string;
+    attributes: SpanAttributes;
+    startTime: number;
+}
+/**
+ * Starts an inactive, standalone span used to send web vital values to Sentry.
+ * DO NOT use this for arbitrary spans, as these spans require special handling
+ * during ingestion to extract metrics.
+ *
+ * This function adds a bunch of attributes and data to the span that's shared
+ * by all web vital standalone spans. However, you need to take care of adding
+ * the actual web vital value as an event to the span. Also, you need to assign
+ * a transaction name and some other values that are specific to the web vital.
+ *
+ * Ultimately, you also need to take care of ending the span to send it off.
+ *
+ * @param options
+ *
+ * @returns an inactive, standalone and NOT YET ended span
+ */
+export declare function startStandaloneWebVitalSpan(options: StandaloneWebVitalSpanOptions): Span | undefined;
+/** Get the browser performance API. */
+export declare function getBrowserPerformanceAPI(): Performance | undefined;
+/**
+ * Converts from milliseconds to seconds
+ * @param time time in ms
+ */
+export declare function msToSec(time: number): number;
+/**
+ * Converts ALPN protocol ids to name and version.
+ *
+ * (https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)
+ * @param nextHopProtocol PerformanceResourceTiming.nextHopProtocol
+ */
+export declare function extractNetworkProtocol(nextHopProtocol: string): {
+    name: string;
+    version: string;
+};
+/**
+ * Generic support check for web vitals
+ */
+export declare function supportsWebVital(entryType: 'layout-shift' | 'largest-contentful-paint'): boolean;
+/**
+ * Listens for events on which we want to collect a previously accumulated web vital value.
+ * Currently, this includes:
+ *
+ * - pagehide (i.e. user minimizes browser window, hides tab, etc)
+ * - soft navigation (we only care about the vital of the initially loaded route)
+ *
+ * As a "side-effect", this function will also collect the span id of the pageload span.
+ *
+ * @param collectorCallback the callback to be called when the first of these events is triggered. Parameters:
+ * - event: the event that triggered the reporting of the web vital value.
+ * - pageloadSpanId: the span id of the pageload span. This is used to link the web vital span to the pageload span.
+ * - pageloadSpan: the pageload span instance. This is used for full access to the pageload span for span streaming.
+ */
+export declare function listenForWebVitalReportEvents(client: Client, collectorCallback: (event: WebVitalReportEvent, pageloadSpanId: string, pageloadSpan?: Span) => void): void;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/getCLS.d.ts

@@ -0,0 +1,26 @@
+import { CLSMetric, MetricRatingThresholds, ReportOpts } from './types';
+/** Thresholds for CLS. See https://web.dev/articles/cls#what_is_a_good_cls_score */
+export declare const CLSThresholds: MetricRatingThresholds;
+/**
+ * Calculates the [CLS](https://web.dev/articles/cls) value for the current page and
+ * calls the `callback` function once the value is ready to be reported, along
+ * with all `layout-shift` performance entries that were used in the metric
+ * value calculation. The reported value is a `double` (corresponding to a
+ * [layout shift score](https://web.dev/articles/cls#layout_shift_score)).
+ *
+ * If the `reportAllChanges` configuration option is set to `true`, the
+ * `callback` function will be called as soon as the value is initially
+ * determined as well as any time the value changes throughout the page
+ * lifespan.
+ *
+ * _**Important:** CLS should be continually monitored for changes throughout
+ * the entire lifespan of a page—including if the user returns to the page after
+ * it's been hidden/backgrounded. However, since browsers often [will not fire
+ * additional callbacks once the user has backgrounded a
+ * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),
+ * `callback` is always called when the page's visibility state changes to
+ * hidden. As a result, the `callback` function might be called multiple times
+ * during the same page load._
+ */
+export declare const onCLS: (onReport: (metric: CLSMetric) => void, opts?: ReportOpts) => void;
+//# sourceMappingURL=getCLS.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/getINP.d.ts

@@ -0,0 +1,34 @@
+import { INPMetric, INPReportOpts, MetricRatingThresholds } from './types';
+/** Thresholds for INP. See https://web.dev/articles/inp#what_is_a_good_inp_score */
+export declare const INPThresholds: MetricRatingThresholds;
+/**
+ * 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
+ * the `event` performance entries reported for that interaction. The reported
+ * value is a `DOMHighResTimeStamp`.
+ *
+ * A custom `durationThreshold` configuration option can optionally be passed
+ * to control what `event-timing` entries are considered for INP reporting. The
+ * default threshold is `40`, which means INP scores of less than 40 will not
+ * be reported. To avoid reporting no interactions in these cases, the library
+ * will fall back to the input delay of the first interaction. Note that this
+ * will not affect your 75th percentile INP value unless that value is also
+ * less than 40 (well below the recommended
+ * [good](https://web.dev/articles/inp#what_is_a_good_inp_score) threshold).
+ *
+ * If the `reportAllChanges` configuration option is set to `true`, the
+ * `callback` function will be called as soon as the value is initially
+ * determined as well as any time the value changes throughout the page
+ * lifespan.
+ *
+ * _**Important:** INP should be continually monitored for changes throughout
+ * the entire lifespan of a page—including if the user returns to the page after
+ * it's been hidden/backgrounded. However, since browsers often [will not fire
+ * additional callbacks once the user has backgrounded a
+ * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),
+ * `callback` is always called when the page's visibility state changes to
+ * hidden. As a result, the `callback` function might be called multiple times
+ * during the same page load._
+ */
+export declare const onINP: (onReport: (metric: INPMetric) => void, opts?: INPReportOpts) => void;
+//# sourceMappingURL=getINP.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/getLCP.d.ts

@@ -0,0 +1,16 @@
+import { LCPMetric, MetricRatingThresholds, ReportOpts } from './types';
+/** Thresholds for LCP. See https://web.dev/articles/lcp#what_is_a_good_lcp_score */
+export declare const LCPThresholds: MetricRatingThresholds;
+/**
+ * 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
+ * relevant `largest-contentful-paint` performance entry used to determine the
+ * value). The reported value is a `DOMHighResTimeStamp`.
+ *
+ * If the `reportAllChanges` configuration option is set to `true`, the
+ * `callback` function will be called any time a new `largest-contentful-paint`
+ * performance entry is dispatched, or once the final value of the metric has
+ * been determined.
+ */
+export declare const onLCP: (onReport: (metric: LCPMetric) => void, opts?: ReportOpts) => void;
+//# sourceMappingURL=getLCP.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/InteractionManager.d.ts

@@ -0,0 +1,37 @@
+export interface Interaction {
+    _latency: number;
+    id: number;
+    entries: PerformanceEventTiming[];
+}
+/**
+ *
+ */
+export declare class InteractionManager {
+    /**
+     * A list of longest interactions on the page (by latency) sorted so the
+     * longest one is first. The list is at most MAX_INTERACTIONS_TO_CONSIDER
+     * long.
+     */
+    _longestInteractionList: Interaction[];
+    /**
+     * A mapping of longest interactions by their interaction ID.
+     * This is used for faster lookup.
+     */
+    _longestInteractionMap: Map<number, Interaction>;
+    _onBeforeProcessingEntry?: (entry: PerformanceEventTiming) => void;
+    _onAfterProcessingINPCandidate?: (interaction: Interaction) => void;
+    _resetInteractions(): void;
+    /**
+     * Returns the estimated p98 longest interaction based on the stored
+     * interaction candidates and the interaction count for the current page.
+     */
+    _estimateP98LongestInteraction(): Interaction | undefined;
+    /**
+     * 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
+     * entry is part of an existing interaction, it is merged and the latency
+     * and entries list is updated as needed.
+     */
+    _processEntry(entry: PerformanceEventTiming): void;
+}
+//# sourceMappingURL=InteractionManager.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/LCPEntryManager.d.ts

@@ -0,0 +1,5 @@
+export declare class LCPEntryManager {
+    _onBeforeProcessingEntry?: (entry: LargestContentfulPaint) => void;
+    _processEntry(entry: LargestContentfulPaint): void;
+}
+//# sourceMappingURL=LCPEntryManager.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/LayoutShiftManager.d.ts

@@ -0,0 +1,7 @@
+export declare class LayoutShiftManager {
+    _onAfterProcessingUnexpectedShift?: (entry: LayoutShift) => void;
+    _sessionValue: number;
+    _sessionEntries: LayoutShift[];
+    _processEntry(entry: LayoutShift): void;
+}
+//# sourceMappingURL=LayoutShiftManager.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/bindReporter.d.ts

@@ -0,0 +1,7 @@
+import { MetricRatingThresholds, MetricType } from '../types';
+export declare const bindReporter: <MetricName extends MetricType["name"]>(callback: (metric: Extract<MetricType, {
+    name: MetricName;
+}>) => void, metric: Extract<MetricType, {
+    name: MetricName;
+}>, thresholds: MetricRatingThresholds, reportAllChanges?: boolean) => (forceReport?: boolean) => void;
+//# sourceMappingURL=bindReporter.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/generateUniqueID.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Performantly generate a unique, 30-char string by combining a version
+ * number, the current timestamp with a 13-digit number integer.
+ * @return {string}
+ */
+export declare const generateUniqueID: () => string;
+//# sourceMappingURL=generateUniqueID.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/getActivationStart.d.ts

@@ -0,0 +1,2 @@
+export declare const getActivationStart: () => number;
+//# sourceMappingURL=getActivationStart.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/getNavigationEntry.d.ts

@@ -0,0 +1,2 @@
+export declare const getNavigationEntry: (checkResponseStart?: boolean) => PerformanceNavigationTiming | void;
+//# sourceMappingURL=getNavigationEntry.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/getVisibilityWatcher.d.ts

@@ -0,0 +1,5 @@
+export declare const getVisibilityWatcher: () => {
+    readonly firstHiddenTime: number;
+    onHidden(cb: () => void): void;
+};
+//# sourceMappingURL=getVisibilityWatcher.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/globalListeners.d.ts

@@ -0,0 +1,11 @@
+/**
+ * web-vitals 5.1.0 switched listeners to be added on the window rather than the document.
+ * Instead of having to check for window/document every time we add a listener, we can use this function.
+ */
+export declare function addPageListener(type: string, listener: EventListener, options?: boolean | AddEventListenerOptions): void;
+/**
+ * web-vitals 5.1.0 switched listeners to be removed from the window rather than the document.
+ * Instead of having to check for window/document every time we remove a listener, we can use this function.
+ */
+export declare function removePageListener(type: string, listener: EventListener, options?: boolean | AddEventListenerOptions): void;
+//# sourceMappingURL=globalListeners.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/initMetric.d.ts

@@ -0,0 +1,21 @@
+import { MetricType } from '../types';
+export declare const initMetric: <MetricName extends MetricType["name"]>(name: MetricName, value?: number) => {
+    name: MetricName;
+    value: number;
+    rating: "good";
+    delta: number;
+    entries: (Extract<import("../types").CLSMetric, {
+        name: MetricName;
+    }> | Extract<import("../types").FCPMetric, {
+        name: MetricName;
+    }> | Extract<import("../types").INPMetric, {
+        name: MetricName;
+    }> | Extract<import("../types").LCPMetric, {
+        name: MetricName;
+    }> | Extract<import("../types").TTFBMetric, {
+        name: MetricName;
+    }>)["entries"];
+    id: string;
+    navigationType: "navigate" | "reload" | "back-forward" | "back-forward-cache" | "prerender" | "restore";
+};
+//# sourceMappingURL=initMetric.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/initUnique.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A function that accepts and identity object and a class object and returns
+ * either a new instance of that class or an existing instance, if the
+ * identity object was previously used.
+ */
+export declare function initUnique<T>(identityObj: object, ClassObj: new () => T): T;
+//# sourceMappingURL=initUnique.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/observe.d.ts

@@ -0,0 +1,23 @@
+interface PerformanceEntryMap {
+    event: PerformanceEventTiming[];
+    'first-input': PerformanceEventTiming[];
+    'layout-shift': LayoutShift[];
+    'largest-contentful-paint': LargestContentfulPaint[];
+    'long-animation-frame': PerformanceLongAnimationFrameTiming[];
+    paint: PerformancePaintTiming[];
+    navigation: PerformanceNavigationTiming[];
+    resource: PerformanceResourceTiming[];
+    longtask: PerformanceEntry[];
+    element: PerformanceEntry[];
+}
+/**
+ * Takes a performance entry type and a callback function, and creates a
+ * `PerformanceObserver` instance that will observe the specified entry type
+ * with buffering enabled and call the callback _for each entry_.
+ *
+ * This function also feature-detects entry support and wraps the logic in a
+ * try/catch to avoid errors in unsupporting browsers.
+ */
+export declare const observe: <K extends keyof PerformanceEntryMap>(type: K, callback: (entries: PerformanceEntryMap[K]) => void, opts?: PerformanceObserverInit) => PerformanceObserver | undefined;
+export {};
+//# sourceMappingURL=observe.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/onHidden.d.ts

@@ -0,0 +1,27 @@
+export interface OnHiddenCallback {
+    (event: Event): void;
+}
+/**
+ * Sentry-specific change:
+ *
+ * This function's logic was NOT updated to web-vitals 4.2.4 or 5.x but we continue
+ * to use the web-vitals 3.5.2 version due to having stricter browser support.
+ *
+ * PR with context that made the changes:
+ * https://github.com/GoogleChrome/web-vitals/pull/442/files#r1530492402
+ *
+ * The PR removed listening to the `pagehide` event, in favour of only listening to
+ * the `visibilitychange` event. This is "more correct" but some browsers we still
+ * support (Safari <14.4) don't fully support `visibilitychange` or have known bugs
+ * with respect to the `visibilitychange` event.
+ *
+ * TODO (v11): If we decide to drop support for Safari 14.4, we can use the logic
+ * from web-vitals 4.2.4. In this case, we also need to update the integration tests
+ * that currently trigger the `pagehide` event to simulate the page being hidden.
+ *
+ * @param {OnHiddenCallback} cb - Callback to be executed when the page is hidden or unloaded.
+ *
+ * @deprecated use `whenIdleOrHidden` or `addPageListener('visibilitychange')` instead
+ */
+export declare const onHidden: (cb: OnHiddenCallback) => void;
+//# sourceMappingURL=onHidden.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/polyfills/interactionCountPolyfill.d.ts

@@ -0,0 +1,15 @@
+declare global {
+    interface Performance {
+        interactionCount: number;
+    }
+}
+/**
+ * Returns the `interactionCount` value using the native API (if available)
+ * or the polyfill estimate in this module.
+ */
+export declare const getInteractionCount: () => number;
+/**
+ * Feature detects native support or initializes the polyfill if needed.
+ */
+export declare const initInteractionCountPolyfill: () => void;
+//# sourceMappingURL=interactionCountPolyfill.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/runOnce.d.ts

@@ -0,0 +1,2 @@
+export declare const runOnce: (cb: () => void) => () => void;
+//# sourceMappingURL=runOnce.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/whenActivated.d.ts

@@ -0,0 +1,2 @@
+export declare const whenActivated: (callback: () => void) => void;
+//# sourceMappingURL=whenActivated.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/lib/whenIdleOrHidden.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runs the passed callback during the next idle period, or immediately
+ * if the browser's visibility state is (or becomes) hidden.
+ */
+export declare const whenIdleOrHidden: (cb: () => void) => void;
+//# sourceMappingURL=whenIdleOrHidden.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/onFCP.d.ts

@@ -0,0 +1,11 @@
+import { FCPMetric, MetricRatingThresholds, ReportOpts } from './types';
+/** Thresholds for FCP. See https://web.dev/articles/fcp#what_is_a_good_fcp_score */
+export declare const FCPThresholds: MetricRatingThresholds;
+/**
+ * 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 declare const onFCP: (onReport: (metric: FCPMetric) => void, opts?: ReportOpts) => void;
+//# sourceMappingURL=onFCP.d.ts.map

package/build/types-ts3.8/metrics/web-vitals/onTTFB.d.ts

@@ -0,0 +1,20 @@
+import { MetricRatingThresholds, ReportOpts, TTFBMetric } from './types';
+/** Thresholds for TTFB. See https://web.dev/articles/ttfb#what_is_a_good_ttfb_score */
+export declare const TTFBThresholds: MetricRatingThresholds;
+/**
+ * Calculates the [TTFB](https://web.dev/articles/ttfb) value for the
+ * current page and calls the `callback` function once the page has loaded,
+ * along with the relevant `navigation` performance entry used to determine the
+ * value. The reported value is a `DOMHighResTimeStamp`.
+ *
+ * Note, this function waits until after the page is loaded to call `callback`
+ * in order to ensure all properties of the `navigation` entry are populated.
+ * This is useful if you want to report on other metrics exposed by the
+ * [Navigation Timing API](https://w3c.github.io/navigation-timing/). For
+ * example, the TTFB metric starts from the page's [time
+ * origin](https://www.w3.org/TR/hr-time-2/#sec-time-origin), which means it
+ * includes time spent on DNS lookup, connection negotiation, network latency,
+ * and server processing time.
+ */
+export declare const onTTFB: (onReport: (metric: TTFBMetric) => void, opts?: ReportOpts) => void;
+//# sourceMappingURL=onTTFB.d.ts.map