@sentry/replay 7.67.0 → 7.68.0

package/types-ts3.8/util/createReplayEnvelope.d.ts

@@ -0,0 +1,7 @@
+import { DsnComponents, ReplayEnvelope, ReplayEvent, ReplayRecordingData } from '@sentry/types';
+/**
+ * Create a replay envelope ready to be sent.
+ * This includes both the replay event, as well as the recording data.
+ */
+export declare function createReplayEnvelope(replayEvent: ReplayEvent, recordingData: ReplayRecordingData, dsn: DsnComponents, tunnel?: string): ReplayEnvelope;
+//# sourceMappingURL=createReplayEnvelope.d.ts.map

package/types-ts3.8/util/debounce.d.ts

@@ -0,0 +1,30 @@
+type DebouncedCallback = {
+    (): void | unknown;
+    flush: () => void | unknown;
+    cancel: () => void;
+};
+type CallbackFunction = () => unknown;
+type DebounceOptions = {
+    maxWait?: number;
+};
+/**
+ * Heavily simplified debounce function based on lodash.debounce.
+ *
+ * This function takes a callback function (@param fun) and delays its invocation
+ * by @param wait milliseconds. Optionally, a maxWait can be specified in @param options,
+ * which ensures that the callback is invoked at least once after the specified max. wait time.
+ *
+ * @param func the function whose invocation is to be debounced
+ * @param wait the minimum time until the function is invoked after it was called once
+ * @param options the options object, which can contain the `maxWait` property
+ *
+ * @returns the debounced version of the function, which needs to be called at least once to start the
+ *          debouncing process. Subsequent calls will reset the debouncing timer and, in case @paramfunc
+ *          was already invoked in the meantime, return @param func's return value.
+ *          The debounced function has two additional properties:
+ *          - `flush`: Invokes the debounced function immediately and returns its return value
+ *          - `cancel`: Cancels the debouncing process and resets the debouncing timer
+ */
+export declare function debounce(func: CallbackFunction, wait: number, options?: DebounceOptions): DebouncedCallback;
+export {};
+//# sourceMappingURL=debounce.d.ts.map

package/types-ts3.8/util/dedupePerformanceEntries.d.ts

@@ -0,0 +1,11 @@
+/**
+ * There are some difficulties diagnosing why there are duplicate navigation
+ * entries. We've witnessed several intermittent results:
+ * - duplicate entries have duration = 0
+ * - duplicate entries are the same object reference
+ * - none of the above
+ *
+ * Compare the values of several keys to determine if the entries are duplicates or not.
+ */
+export declare function dedupePerformanceEntries(currentList: PerformanceEntryList, newList: PerformanceEntryList): PerformanceEntryList;
+//# sourceMappingURL=dedupePerformanceEntries.d.ts.map

package/types-ts3.8/util/eventUtils.d.ts

@@ -0,0 +1,8 @@
+import { ErrorEvent, Event, ReplayEvent, TransactionEvent } from '@sentry/types';
+/** If the event is an error event */
+export declare function isErrorEvent(event: Event): event is ErrorEvent;
+/** If the event is a transaction event */
+export declare function isTransactionEvent(event: Event): event is TransactionEvent;
+/** If the event is an replay event */
+export declare function isReplayEvent(event: Event): event is ReplayEvent;
+//# sourceMappingURL=eventUtils.d.ts.map

package/types-ts3.8/util/getPrivacyOptions.d.ts

@@ -0,0 +1,19 @@
+import { DeprecatedPrivacyOptions, ReplayIntegrationPrivacyOptions } from '../types';
+type GetPrivacyOptions = Required<Pick<ReplayIntegrationPrivacyOptions, Exclude<keyof ReplayIntegrationPrivacyOptions, 'maskFn'>>> & Pick<DeprecatedPrivacyOptions, Exclude<keyof DeprecatedPrivacyOptions, 'maskInputOptions'>>;
+interface GetPrivacyReturn {
+    maskTextSelector: string;
+    unmaskTextSelector: string;
+    maskInputSelector: string;
+    unmaskInputSelector: string;
+    blockSelector: string;
+    unblockSelector: string;
+    ignoreSelector: string;
+    blockClass?: RegExp;
+    maskTextClass?: RegExp;
+}
+/**
+ * Returns privacy related configuration for use in rrweb
+ */
+export declare function getPrivacyOptions({ mask, unmask, block, unblock, ignore, blockClass, blockSelector, maskTextClass, maskTextSelector, ignoreClass, }: GetPrivacyOptions): GetPrivacyReturn;
+export {};
+//# sourceMappingURL=getPrivacyOptions.d.ts.map

package/types-ts3.8/util/handleRecordingEmit.d.ts

@@ -0,0 +1,14 @@
+import { RecordingEvent, ReplayContainer, ReplayOptionFrameEvent } from '../types';
+type RecordingEmitCallback = (event: RecordingEvent, isCheckout?: boolean) => void;
+/**
+ * Handler for recording events.
+ *
+ * Adds to event buffer, and has varying flushing behaviors if the event was a checkout.
+ */
+export declare function getHandleRecordingEmit(replay: ReplayContainer): RecordingEmitCallback;
+/**
+ * Exported for tests
+ */
+export declare function createOptionsEvent(replay: ReplayContainer): ReplayOptionFrameEvent;
+export {};
+//# sourceMappingURL=handleRecordingEmit.d.ts.map

package/types-ts3.8/util/hasSessionStorage.d.ts

@@ -0,0 +1,3 @@
+/** If sessionStorage is available. */
+export declare function hasSessionStorage(): boolean;
+//# sourceMappingURL=hasSessionStorage.d.ts.map

package/types-ts3.8/util/isBrowser.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns true if we are in the browser.
+ */
+export declare function isBrowser(): boolean;
+//# sourceMappingURL=isBrowser.d.ts.map

package/types-ts3.8/util/isExpired.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Given an initial timestamp and an expiry duration, checks to see if current
+ * time should be considered as expired.
+ */
+export declare function isExpired(initialTime: null | number, expiry: undefined | number, targetTime?: number): boolean;
+//# sourceMappingURL=isExpired.d.ts.map

package/types-ts3.8/util/isRrwebError.d.ts

@@ -0,0 +1,6 @@
+import { Event, EventHint } from '@sentry/types';
+/**
+ * Returns true if we think the given event is an error originating inside of rrweb.
+ */
+export declare function isRrwebError(event: Event, hint: EventHint): boolean;
+//# sourceMappingURL=isRrwebError.d.ts.map

package/types-ts3.8/util/isSampled.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Given a sample rate, returns true if replay should be sampled.
+ *
+ * 1.0 = 100% sampling
+ * 0.0 = 0% sampling
+ */
+export declare function isSampled(sampleRate?: number): boolean;
+//# sourceMappingURL=isSampled.d.ts.map

package/types-ts3.8/util/isSessionExpired.d.ts

@@ -0,0 +1,10 @@
+import { Session } from '../types';
+/**
+ * Checks to see if session is expired
+ */
+export declare function isSessionExpired(session: Session, { maxReplayDuration, sessionIdleExpire, targetTime, }: {
+    maxReplayDuration: number;
+    sessionIdleExpire: number;
+    targetTime?: number;
+}): boolean;
+//# sourceMappingURL=isSessionExpired.d.ts.map

package/types-ts3.8/util/log.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Log a message in debug mode, and add a breadcrumb when _experiment.traceInternals is enabled.
+ */
+export declare function logInfo(message: string, shouldAddBreadcrumb?: boolean): void;
+/**
+ * Log a message, and add a breadcrumb in the next tick.
+ * This is necessary when the breadcrumb may be added before the replay is initialized.
+ */
+export declare function logInfoNextTick(message: string, shouldAddBreadcrumb?: boolean): void;
+//# sourceMappingURL=log.d.ts.map

package/types-ts3.8/util/prepareRecordingData.d.ts

@@ -0,0 +1,9 @@
+import { ReplayRecordingData } from '@sentry/types';
+/**
+ * Prepare the recording data ready to be sent.
+ */
+export declare function prepareRecordingData({ recordingData, headers, }: {
+    recordingData: ReplayRecordingData;
+    headers: Record<string, unknown>;
+}): ReplayRecordingData;
+//# sourceMappingURL=prepareRecordingData.d.ts.map

package/types-ts3.8/util/prepareReplayEvent.d.ts

@@ -0,0 +1,15 @@
+import { Scope } from '@sentry/core';
+import { IntegrationIndex } from '@sentry/core/build/types/integration';
+import { Client, ReplayEvent } from '@sentry/types';
+/**
+ * Prepare a replay event & enrich it with the SDK metadata.
+ */
+export declare function prepareReplayEvent({ client, scope, replayId: event_id, event, }: {
+    client: Client & {
+        _integrations?: IntegrationIndex;
+    };
+    scope: Scope;
+    replayId: string;
+    event: ReplayEvent;
+}): Promise<ReplayEvent | null>;
+//# sourceMappingURL=prepareReplayEvent.d.ts.map

package/types-ts3.8/util/sendReplay.d.ts

@@ -0,0 +1,9 @@
+import { SendReplayData } from '../types';
+/**
+ * Finalize and send the current replay event to Sentry
+ */
+export declare function sendReplay(replayData: SendReplayData, retryConfig?: {
+    count: number;
+    interval: number;
+}): Promise<unknown>;
+//# sourceMappingURL=sendReplay.d.ts.map

package/types-ts3.8/util/sendReplayRequest.d.ts

@@ -0,0 +1,13 @@
+import { TransportMakeRequestResponse } from '@sentry/types';
+import { SendReplayData } from '../types';
+/**
+ * Send replay attachment using `fetch()`
+ */
+export declare function sendReplayRequest({ recordingData, replayId, segmentId: segment_id, eventContext, timestamp, session, }: SendReplayData): Promise<void | TransportMakeRequestResponse>;
+/**
+ * This error indicates that the transport returned an invalid status code.
+ */
+export declare class TransportStatusCodeError extends Error {
+    constructor(statusCode: number);
+}
+//# sourceMappingURL=sendReplayRequest.d.ts.map

package/types-ts3.8/util/shouldFilterRequest.d.ts

@@ -0,0 +1,7 @@
+import { ReplayContainer } from '../types';
+/**
+ * Check whether a given request URL should be filtered out. This is so we
+ * don't log Sentry ingest requests.
+ */
+export declare function shouldFilterRequest(replay: ReplayContainer, url: string): boolean;
+//# sourceMappingURL=shouldFilterRequest.d.ts.map

package/types-ts3.8/util/throttle.d.ts

@@ -0,0 +1,12 @@
+export declare const THROTTLED = "__THROTTLED";
+export declare const SKIPPED = "__SKIPPED";
+/**
+ * Create a throttled function off a given function.
+ * When calling the throttled function, it will call the original function only
+ * if it hasn't been called more than `maxCount` times in the last `durationSeconds`.
+ *
+ * Returns `THROTTLED` if throttled for the first time, after that `SKIPPED`,
+ * or else the return value of the original function.
+ */
+export declare function throttle<T extends (...rest: any[]) => any>(fn: T, maxCount: number, durationSeconds: number): (...rest: Parameters<T>) => ReturnType<T> | typeof THROTTLED | typeof SKIPPED;
+//# sourceMappingURL=throttle.d.ts.map

package/types-ts3.8/util/timestamp.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Converts a timestamp to ms, if it was in s, or keeps it as ms.
+ */
+export declare function timestampToMs(timestamp: number): number;
+/**
+ * Converts a timestamp to s, if it was in ms, or keeps it as s.
+ */
+export declare function timestampToS(timestamp: number): number;
+//# sourceMappingURL=timestamp.d.ts.map

package/types-ts3.8/util/truncateJson/completeJson.d.ts

@@ -0,0 +1,9 @@
+import { JsonToken } from './constants';
+/**
+ * Complete an incomplete JSON string.
+ * This will ensure that the last element always has a `"~~"` to indicate it was truncated.
+ * For example, `[1,2,` will be completed to `[1,2,"~~"]`
+ * and `{"aa":"b` will be completed to `{"aa":"b~~"}`
+ */
+export declare function completeJson(incompleteJson: string, stack: JsonToken[]): string;
+//# sourceMappingURL=completeJson.d.ts.map

package/types-ts3.8/util/truncateJson/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const OBJ = 10;
+export declare const OBJ_KEY = 11;
+export declare const OBJ_KEY_STR = 12;
+export declare const OBJ_VAL = 13;
+export declare const OBJ_VAL_STR = 14;
+export declare const OBJ_VAL_COMPLETED = 15;
+export declare const ARR = 20;
+export declare const ARR_VAL = 21;
+export declare const ARR_VAL_STR = 22;
+export declare const ARR_VAL_COMPLETED = 23;
+export type JsonToken = typeof OBJ | typeof OBJ_KEY | typeof OBJ_KEY_STR | typeof OBJ_VAL | typeof OBJ_VAL_STR | typeof OBJ_VAL_COMPLETED | typeof ARR | typeof ARR_VAL | typeof ARR_VAL_STR | typeof ARR_VAL_COMPLETED;
+//# sourceMappingURL=constants.d.ts.map

package/types-ts3.8/util/truncateJson/evaluateJson.d.ts

@@ -0,0 +1,6 @@
+import { JsonToken } from './constants';
+/**
+ * Evaluate an (incomplete) JSON string.
+ */
+export declare function evaluateJson(json: string): JsonToken[];
+//# sourceMappingURL=evaluateJson.d.ts.map

package/types-ts3.8/util/truncateJson/fixJson.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Takes an incomplete JSON string, and returns a hopefully valid JSON string.
+ * Note that this _can_ fail, so you should check the return value is valid JSON.
+ */
+export declare function fixJson(incompleteJson: string): string;
+//# sourceMappingURL=fixJson.d.ts.map