@sentry/browser-utils 10.68.0 → 11.0.0-alpha.0

package/build/types/metrics/cls.d.ts

@@ -1,17 +0,0 @@
-import type { Client } from '@sentry/core';
-import type { WebVitalReportEvent } from './utils';
-/**
- * Starts tracking the Cumulative Layout Shift on the current page and collects the value once
- *
- * - the page visibility is hidden
- * - a navigation span is started (to stop CLS measurement for SPA soft navigations)
- *
- * Once either of these events triggers, the CLS value is sent as a standalone span and we stop
- * measuring CLS.
- */
-export declare function trackClsAsStandaloneSpan(client: Client): void;
-/**
- * Exported only for testing!
- */
-export declare function _sendStandaloneClsSpan(clsValue: number, entry: LayoutShift | undefined, pageloadSpanId: string, reportEvent: WebVitalReportEvent): void;
-//# sourceMappingURL=cls.d.ts.map

package/build/types/metrics/cls.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cls.d.ts","sourceRoot":"","sources":["../../../src/metrics/cls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,cAAc,CAAC;AAe3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGnD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAqB7D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,WAAW,GAAG,SAAS,EAC9B,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,mBAAmB,QA4CjC"}

package/build/types-ts3.8/debug-build.d.ts

@@ -1,7 +0,0 @@
-/**
- * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
- *
- * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
- */
-export declare const DEBUG_BUILD: boolean;
-//# sourceMappingURL=debug-build.d.ts.map

package/build/types-ts3.8/getNativeImplementation.d.ts

@@ -1,69 +0,0 @@
-import { WINDOW } from './types';
-/**
- * We generally want to use window.fetch / window.setTimeout.
- * However, in some cases this may be wrapped (e.g. by Zone.js for Angular),
- * so we try to get an unpatched version of this from a sandboxed iframe.
- */
-interface CacheableImplementations {
-    setTimeout: typeof WINDOW.setTimeout;
-    fetch: typeof WINDOW.fetch;
-}
-/**
- * Get the native implementation of a browser function.
- *
- * This can be used to ensure we get an unwrapped version of a function, in cases where a wrapped function can lead to problems.
- *
- * The following methods can be retrieved:
- * - `setTimeout`: This can be wrapped by e.g. Angular, causing change detection to be triggered.
- * - `fetch`: This can be wrapped by e.g. ad-blockers, causing an infinite loop when a request is blocked.
- */
-export declare function getNativeImplementation<T extends keyof CacheableImplementations>(name: T): CacheableImplementations[T];
-/** Clear a cached implementation. */
-export declare function clearCachedImplementation(name: keyof CacheableImplementations): void;
-/**
- * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.
- * Whenever someone wraps the Fetch API and returns the wrong promise chain,
- * this chain becomes orphaned and there is no possible way to capture it's rejections
- * other than allowing it bubble up to this very handler. eg.
- *
- * const f = window.fetch;
- * window.fetch = function () {
- *   const p = f.apply(this, arguments);
- *
- *   p.then(function() {
- *     console.log('hi.');
- *   });
- *
- *   return p;
- * }
- *
- * `p.then(function () { ... })` is producing a completely separate promise chain,
- * however, what's returned is `p` - the result of original `fetch` call.
- *
- * This mean, that whenever we use the Fetch API to send our own requests, _and_
- * some ad-blocker blocks it, this orphaned chain will _always_ reject,
- * effectively causing another event to be captured.
- * This makes a whole process become an infinite loop, which we need to somehow
- * deal with, and break it in one way or another.
- *
- * To deal with this issue, we are making sure that we _always_ use the real
- * browser Fetch API, instead of relying on what `window.fetch` exposes.
- * The only downside to this would be missing our own requests as breadcrumbs,
- * but because we are already not doing this, it should be just fine.
- *
- * Possible failed fetch error messages per-browser:
- *
- * Chrome:  Failed to fetch
- * Edge:    Failed to Fetch
- * Firefox: NetworkError when attempting to fetch resource
- * Safari:  resource blocked by content blocker
- */
-export declare function fetch(...rest: Parameters<typeof WINDOW.fetch>): ReturnType<typeof WINDOW.fetch>;
-/**
- * Get an unwrapped `setTimeout` method.
- * This ensures that even if e.g. Angular wraps `setTimeout`, we get the native implementation,
- * avoiding triggering change detection.
- */
-export declare function setTimeout(...rest: Parameters<typeof WINDOW.setTimeout>): ReturnType<typeof WINDOW.setTimeout>;
-export {};
-//# sourceMappingURL=getNativeImplementation.d.ts.map

package/build/types-ts3.8/htmlTreeAsString.d.ts

@@ -1,11 +0,0 @@
-/**
- * Given a child DOM element, returns a query-selector statement describing that
- * and its ancestors
- * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
- * @returns generated DOM path
- */
-export declare function htmlTreeAsString(elem: unknown, options?: string[] | {
-    keyAttrs?: string[];
-    maxStringLength?: number;
-}): string;
-//# sourceMappingURL=htmlTreeAsString.d.ts.map

package/build/types-ts3.8/index.d.ts

@@ -1,17 +0,0 @@
-export { addPerformanceInstrumentationHandler, addClsInstrumentationHandler, addTtfbInstrumentationHandler, addLcpInstrumentationHandler, addInpInstrumentationHandler, } from './metrics/instrument';
-export { addPerformanceEntries, addWebVitalsToSpan, startTrackingInteractions, startTrackingLongTasks, startTrackingLongAnimationFrames, startTrackingWebVitals, startTrackingINP, registerInpInteractionListener, } from './metrics/browserMetrics';
-export { elementTimingIntegration, startTrackingElementTiming } from './metrics/elementTiming';
-export { extractNetworkProtocol } from './metrics/utils';
-export { trackClsAsSpan, trackInpAsSpan, trackLcpAsSpan } from './metrics/webVitalSpans';
-export { whenIdleOrHidden } from './metrics/web-vitals/lib/whenIdleOrHidden';
-export { addClickKeypressInstrumentationHandler } from './instrument/dom';
-export { addHistoryInstrumentationHandler } from './instrument/history';
-export { fetch, setTimeout, clearCachedImplementation, getNativeImplementation } from './getNativeImplementation';
-export { addXhrInstrumentationHandler, SENTRY_XHR_DATA_KEY } from './instrument/xhr';
-export { getBodyString, getFetchRequestArgBody, serializeFormData, parseXhrResponseHeaders } from './networkUtils';
-export { resourceTimingToSpanAttributes } from './metrics/resourceTiming';
-export { htmlTreeAsString } from './htmlTreeAsString';
-export { isElement } from './is';
-export { getAbsoluteUrl } from './instrument/location';
-export { FetchHint, NetworkMetaWarning, XhrHint } from './types';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,11 +0,0 @@
-import { HandlerDataDom } from '@sentry/core';
-/**
- * Add an instrumentation handler for when a click or a keypress happens.
- *
- * Use at your own risk, this might break without changelog notice, only used internally.
- * @hidden
- */
-export declare function addClickKeypressInstrumentationHandler(handler: (data: HandlerDataDom) => void): void;
-/** Exported for tests only. */
-export declare function instrumentDOM(): void;
-//# sourceMappingURL=dom.d.ts.map

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

@@ -1,15 +0,0 @@
-import { HandlerDataHistory } from '@sentry/core';
-/**
- * Add an instrumentation handler for when a fetch request happens.
- * The handler function is called once when the request starts and once when it ends,
- * which can be identified by checking if it has an `endTimestamp`.
- *
- * Use at your own risk, this might break without changelog notice, only used internally.
- * @hidden
- */
-export declare function addHistoryInstrumentationHandler(handler: (data: HandlerDataHistory) => void): void;
-/**
- * Exported just for testing
- */
-export declare function instrumentHistory(): void;
-//# sourceMappingURL=history.d.ts.map

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

@@ -1,13 +0,0 @@
-/**
- *
- * @param urlOrPath - The URL or path to convert to an absolute URL.
- *
- * @return the absolute URL when handed a relative URL path, by
- * combining the current `window.location.origin` with param urlOrPath.
- *
- * If param urlOrPath is already a full or an invalid URL,
- * or URL determination fails, the original param urlOrPath is returned unchanged.
- *
- */
-export declare function getAbsoluteUrl(urlOrPath: string): string;
-//# sourceMappingURL=location.d.ts.map

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

@@ -1,14 +0,0 @@
-import { HandlerDataXhr } from '@sentry/core';
-export declare const SENTRY_XHR_DATA_KEY = "__sentry_xhr_v3__";
-/**
- * Add an instrumentation handler for when an XHR request happens.
- * The handler function is called once when the request starts and once when it ends,
- * which can be identified by checking if it has an `endTimestamp`.
- *
- * Use at your own risk, this might break without changelog notice, only used internally.
- * @hidden
- */
-export declare function addXhrInstrumentationHandler(handler: (data: HandlerDataXhr) => void): void;
-/** Exported only for tests. */
-export declare function instrumentXHR(): void;
-//# sourceMappingURL=xhr.d.ts.map

package/build/types-ts3.8/is.d.ts

@@ -1,7 +0,0 @@
-/**
- * Checks whether given value's type is an Element instance.
- *
- * Returns false if `Element` is not available in the current runtime.
- */
-export declare function isElement(wat: unknown): boolean;
-//# sourceMappingURL=is.d.ts.map

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

@@ -1,119 +0,0 @@
-import { Client, Span, SpanAttributes } from '@sentry/core';
-interface StartTrackingWebVitalsOptions {
-    /**
-     * When `true`, CLS is tracked as a standalone span. When `false`, CLS is
-     * recorded as a measurement on the pageload span. When `undefined`, CLS
-     * tracking is skipped entirely (e.g. because span streaming handles it).
-     */
-    recordClsStandaloneSpans: boolean | undefined;
-    /**
-     * When `true`, LCP is tracked as a standalone span. When `false`, LCP is
-     * recorded as a measurement on the pageload span. When `undefined`, LCP
-     * tracking is skipped entirely (e.g. because span streaming handles it).
-     */
-    recordLcpStandaloneSpans: boolean | undefined;
-    client: Client;
-}
-/**
- * Start tracking web vitals.
- * The callback returned by this function can be used to stop tracking & ensure all measurements are final & captured.
- *
- * @deprecated this function will be removed and streamlined once we stop supporting standalone v1
- * @returns A function that forces web vitals collection
- */
-export declare function startTrackingWebVitals({ recordClsStandaloneSpans, recordLcpStandaloneSpans, client, }: StartTrackingWebVitalsOptions): () => void;
-/**
- * Start tracking long tasks.
- */
-export declare function startTrackingLongTasks(): void;
-/**
- * Start tracking long animation frames.
- */
-export declare function startTrackingLongAnimationFrames(): void;
-/**
- * Start tracking interaction events.
- */
-export declare function startTrackingInteractions(): void;
-export { registerInpInteractionListener, startTrackingINP } from './inp';
-interface AddPerformanceEntriesOptions {
-    /**
-     * Resource spans with `op`s matching strings in the array will not be emitted.
-     *
-     * Default: []
-     */
-    ignoreResourceSpans: Array<'resouce.script' | 'resource.css' | 'resource.img' | 'resource.other' | string>;
-    /**
-     * Performance spans created from browser Performance APIs,
-     * `performance.mark(...)` nand `performance.measure(...)`
-     * with `name`s matching strings in the array will not be emitted.
-     *
-     * Default: []
-     */
-    ignorePerformanceApiSpans: Array<string | RegExp>;
-    /**
-     * Whether span streaming is enabled.
-     */
-    spanStreamingEnabled?: boolean;
-}
-interface AddWebVitalsToSpanOptions {
-    /**
-     * Flag to determine if CLS should be recorded as a measurement on the pageload span or
-     * sent as a standalone span instead.
-     * Sending it as a standalone span will yield more accurate LCP values.
-     *
-     * Default: `false` for backwards compatibility.
-     */
-    recordClsOnPageloadSpan: boolean;
-    /**
-     * Flag to determine if LCP should be recorded as a measurement on the pageload span or
-     * sent as a standalone span instead.
-     * Sending it as a standalone span will yield more accurate LCP values.
-     *
-     * Default: `false` for backwards compatibility.
-     */
-    recordLcpOnPageloadSpan: boolean;
-    /**
-     * Whether span streaming is enabled.
-     */
-    spanStreamingEnabled?: boolean;
-}
-/** Add performance related spans to a transaction */
-export declare function addPerformanceEntries(span: Span, options: AddPerformanceEntriesOptions): void;
-/**
- * Writes the collected web vitals (LCP, CLS, INP, TTFB, FP, FCP) onto the pageload span,
- * either as measurements/attributes (v1) or as web vital attributes (span streaming).
- *
- * This should be called when the pageload span ends, after the web vitals have been finalized.
- * It is a no-op for non-pageload spans, but always resets the collected web vital state so it
- * doesn't leak into a subsequent navigation.
- */
-export declare function addWebVitalsToSpan(span: Span, options: AddWebVitalsToSpanOptions): void;
-/**
- * Create measure related spans.
- * Exported only for tests.
- */
-export declare function _addMeasureSpans(span: Span, entry: PerformanceEntry, startTime: number, duration: number, timeOrigin: number, ignorePerformanceApiSpans: AddPerformanceEntriesOptions['ignorePerformanceApiSpans']): void;
-/**
- * Instrument navigation entries
- * exported only for tests
- */
-export declare function _addNavigationSpans(span: Span, entry: PerformanceNavigationTiming, timeOrigin: number): void;
-/**
- * Create resource-related spans.
- * Exported only for tests.
- */
-export declare function _addResourceSpans(span: Span, entry: PerformanceResourceTiming, resourceUrl: string, startTime: number, duration: number, timeOrigin: number, ignoredResourceSpanOps?: Array<string>): void;
-type ExperimentalResourceTimingProperty = 'renderBlockingStatus' | 'deliveryType' | 'responseStatus';
-/**
- * Use this to set any attributes we can take directly form the PerformanceResourceTiming entry.
- *
- * This is just a mapping function for entry->attribute to keep bundle-size minimal.
- * Experimental properties are also accepted (see {@link ExperimentalResourceTimingProperty}).
- * Assumes that all entry properties might be undefined for browser-specific differences.
- * Only accepts string and number values for now and also sets 0-values.
- */
-export declare function _setResourceRequestAttributes(entry: Partial<PerformanceResourceTiming> & Partial<Record<ExperimentalResourceTimingProperty, number | string>>, attributes: SpanAttributes, properties: [
-    keyof PerformanceResourceTiming | ExperimentalResourceTimingProperty,
-    string
-][]): void;
-//# sourceMappingURL=browserMetrics.d.ts.map

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

@@ -1,17 +0,0 @@
-import { Client } from '@sentry/core';
-import { WebVitalReportEvent } from './utils';
-/**
- * Starts tracking the Cumulative Layout Shift on the current page and collects the value once
- *
- * - the page visibility is hidden
- * - a navigation span is started (to stop CLS measurement for SPA soft navigations)
- *
- * Once either of these events triggers, the CLS value is sent as a standalone span and we stop
- * measuring CLS.
- */
-export declare function trackClsAsStandaloneSpan(client: Client): void;
-/**
- * Exported only for testing!
- */
-export declare function _sendStandaloneClsSpan(clsValue: number, entry: LayoutShift | undefined, pageloadSpanId: string, reportEvent: WebVitalReportEvent): void;
-//# sourceMappingURL=cls.d.ts.map

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

@@ -1,21 +0,0 @@
-/**
- * Captures [Element Timing API](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceElementTiming)
- * data as Sentry metrics.
- *
- * To mark an element for tracking, add the `elementtiming` HTML attribute:
- * ```html
- * <img src="hero.jpg" elementtiming="hero-image" />
- * <p elementtiming="hero-text">Welcome!</p>
- * ```
- *
- * This emits `ui.element.render_time` and `ui.element.load_time` (for images)
- * as distribution metrics, tagged with the element's identifier and paint type.
- */
-export declare const elementTimingIntegration: () => import("@sentry/core").Integration & {
-    name: string;
-};
-/**
- * @deprecated Use `elementTimingIntegration` instead. This function is a no-op and will be removed in a future version.
- */
-export declare function startTrackingElementTiming(): () => void;
-//# sourceMappingURL=elementTiming.d.ts.map

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

@@ -1,35 +0,0 @@
-import { Span } from '@sentry/core';
-import { InstrumentationHandlerCallback } from './instrument';
-interface InteractionContext {
-    span: Span | undefined;
-    elementName: string;
-}
-/**
- * 60 seconds is the maximum for a plausible INP value
- * (source: Me)
- */
-export declare const MAX_PLAUSIBLE_INP_DURATION = 60;
-/**
- * Start tracking INP webvital events.
- */
-export declare function startTrackingINP(): () => void;
-export declare const INP_ENTRY_MAP: Record<string, 'click' | 'hover' | 'drag' | 'press'>;
-/** Starts tracking the Interaction to Next Paint on the current page. #
- * exported only for testing
- */
-export declare function _trackINP(): () => void;
-/**
- * exported only for testing
- */
-export declare const _onInp: InstrumentationHandlerCallback;
-/**
- * Look up a cached interaction context (element name + root span) by interactionId.
- * Returns undefined if no context was cached for this interaction.
- */
-export declare function getCachedInteractionContext(interactionId: number | undefined): InteractionContext | undefined;
-/**
- * Register a listener to cache route information for INP interactions.
- */
-export declare function registerInpInteractionListener(): void;
-export {};
-//# sourceMappingURL=inp.d.ts.map

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

@@ -1,121 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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