@sentry/react-native 5.19.3 → 5.20.0

package/ts3.8/dist/js/tracing/reactnavigation.d.ts

@@ -12,9 +12,16 @@ interface ReactNavigationOptions {
      * before the transaction is discarded.
      * Time is in ms.
      *
-     * Default: 1000
+     * @default 1000
      */
     routeChangeTimeoutMs: number;
+    /**
+     * Time to initial display measures the time it takes from
+     * navigation dispatch to the render of the first frame of the new screen.
+     *
+     * @default false
+     */
+    enableTimeToInitialDisplay: boolean;
 }
 /**
  * Instrumentation for React-Navigation V5 and above. See docs or sample app for usage.
@@ -28,9 +35,11 @@ export declare class ReactNavigationInstrumentation extends InternalRoutingInstr
     static instrumentationName: string;
     readonly name: string;
     private _navigationContainer;
+    private _newScreenFrameEventEmitter;
     private readonly _maxRecentRouteLen;
     private _latestRoute?;
     private _latestTransaction?;
+    private _navigationProcessingSpan?;
     private _initialStateHandled;
     private _stateChangeTimeout?;
     private _recentRouteKeys;

package/ts3.8/dist/js/tracing/timetodisplay.d.ts

@@ -0,0 +1,46 @@
+import type { Span, StartSpanOptions } from '@sentry/types';
+import * as React from 'react';
+/**
+ * Flags of active spans with manual initial display.
+ */
+export declare const manualInitialDisplaySpans: WeakMap<Span, true>;
+export type TimeToDisplayProps = {
+    children?: React.ReactNode;
+    spanName?: string;
+    record?: boolean;
+};
+/**
+ * Component to measure time to initial display.
+ *
+ * The initial display is recorded when the component prop `record` is true.
+ *
+ * <TimeToInitialDisplay record />
+ */
+export declare function TimeToInitialDisplay(props: TimeToDisplayProps): React.ReactElement;
+/**
+ * Component to measure time to full display.
+ *
+ * The initial display is recorded when the component prop `record` is true.
+ *
+ * <TimeToInitialDisplay record />
+ */
+export declare function TimeToFullDisplay(props: TimeToDisplayProps): React.ReactElement;
+/**
+ * Starts a new span for the initial display.
+ *
+ * Returns current span if already exists in the currently active span.
+ */
+export declare function startTimeToInitialDisplaySpan(options?: Exclude<StartSpanOptions, 'op' | 'name'> & {
+    name?: string;
+    isAutoInstrumented?: boolean;
+}): Span | undefined;
+/**
+ * Starts a new span for the full display.
+ *
+ * Returns current span if already exists in the currently active span.
+ */
+export declare function startTimeToFullDisplaySpan(options?: Omit<StartSpanOptions, 'op' | 'name'> & {
+    name?: string;
+    timeoutMs?: number;
+}): Span | undefined;
+//# sourceMappingURL=timetodisplay.d.ts.map

package/ts3.8/dist/js/tracing/timetodisplaynative.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import type { HostComponent } from 'react-native';
+import type { RNSentryOnDrawReporterProps } from './timetodisplaynative.types';
+export declare const nativeComponentExists: boolean;
+/**
+ * This is a fallback component for environments where the native component is not available.
+ */
+declare class RNSentryOnDrawReporterNoop extends React.Component<RNSentryOnDrawReporterProps> {
+    render(): React.ReactNode;
+}
+declare let RNSentryOnDrawReporter: HostComponent<RNSentryOnDrawReporterProps> | typeof RNSentryOnDrawReporterNoop;
+/**
+ * Native component that reports the on draw timestamp.
+ */
+export declare const getRNSentryOnDrawReporter: () => typeof RNSentryOnDrawReporter;
+export {};
+//# sourceMappingURL=timetodisplaynative.d.ts.map

package/ts3.8/dist/js/tracing/timetodisplaynative.types.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+export interface RNSentryOnDrawNextFrameEvent {
+    newFrameTimestampInSeconds: number;
+    type: 'initialDisplay' | 'fullDisplay';
+}
+export interface RNSentryOnDrawReporterProps {
+    children?: React.ReactNode;
+    onDrawNextFrame: (event: {
+        nativeEvent: RNSentryOnDrawNextFrameEvent;
+    }) => void;
+    initialDisplay?: boolean;
+    fullDisplay?: boolean;
+}
+//# sourceMappingURL=timetodisplaynative.types.d.ts.map

package/ts3.8/dist/js/tracing/utils.d.ts

@@ -1,5 +1,5 @@
-import type { IdleTransaction, Span, Transaction } from '@sentry/core';
-import type { TransactionContext, TransactionSource } from '@sentry/types';
+import type { IdleTransaction, Span as SpanClass, Transaction } from '@sentry/core';
+import type { Span, TransactionContext, TransactionSource } from '@sentry/types';
 export declare const defaultTransactionSource: TransactionSource;
 export declare const customTransactionSource: TransactionSource;
 export declare const getBlankTransactionContext: (name: string) => TransactionContext;
@@ -19,9 +19,14 @@ export declare function getTimeOriginMilliseconds(): number;
 /**
  * Calls the callback every time a child span of the transaction is finished.
  */
-export declare function instrumentChildSpanFinish(transaction: Transaction, callback: (span: Span, endTimestamp?: number) => void): void;
+export declare function instrumentChildSpanFinish(transaction: Transaction, callback: (span: SpanClass, endTimestamp?: number) => void): void;
 /**
  * Determines if the timestamp is now or within the specified margin of error from now.
  */
 export declare function isNearToNow(timestamp: number): boolean;
+/**
+ * Sets the duration of the span as a measurement.
+ * Uses `setMeasurement` function from @sentry/core.
+ */
+export declare function setSpanDurationAsMeasurement(name: string, span: Span): void;
 //# sourceMappingURL=utils.d.ts.map

package/ts3.8/dist/js/utils/sentryeventemitter.d.ts

@@ -0,0 +1,24 @@
+import type { NativeModule } from 'react-native';
+import { NativeEventEmitter } from 'react-native';
+export declare const NewFrameEventName = "rn_sentry_new_frame";
+export type NewFrameEventName = typeof NewFrameEventName;
+export type NewFrameEvent = {
+    newFrameTimestampInSeconds: number;
+};
+export interface SentryEventEmitter {
+    /**
+     * Initializes the native event emitter
+     * This method is synchronous in JS but the native event emitter starts asynchronously
+     * https://github.com/facebook/react-native/blob/d09c02f9e2d468e4d0bde51890e312ae7003a3e6/packages/react-native/React/Modules/RCTEventEmitter.m#L95
+     */
+    initAsync: (eventType: NewFrameEventName) => void;
+    closeAllAsync: () => void;
+    addListener: (eventType: NewFrameEventName, listener: (event: NewFrameEvent) => void) => void;
+    removeListener: (eventType: NewFrameEventName, listener: (event: NewFrameEvent) => void) => void;
+    once: (eventType: NewFrameEventName, listener: (event: NewFrameEvent) => void) => void;
+}
+/**
+ * Creates emitter that allows to listen to native RNSentry events
+ */
+export declare function createSentryEventEmitter(sentryNativeModule?: NativeModule | undefined, createNativeEventEmitter?: (nativeModule: NativeModule | undefined) => NativeEventEmitter): SentryEventEmitter;
+//# sourceMappingURL=sentryeventemitter.d.ts.map

package/ts3.8/dist/js/version.d.ts

@@ -1,4 +1,4 @@
 export declare const SDK_PACKAGE_NAME = "npm:@sentry/react-native";
 export declare const SDK_NAME = "sentry.javascript.react-native";
-export declare const SDK_VERSION = "5.19.3";
+export declare const SDK_VERSION = "5.20.0";
 //# sourceMappingURL=version.d.ts.map

package/ts3.8/dist/js/wrapper.d.ts

@@ -4,6 +4,10 @@ import type { NativeAppStartResponse, NativeDeviceContextsResponse, NativeFrames
 import type { ReactNativeClientOptions } from './options';
 import type * as Hermes from './profiling/hermes';
 import type { NativeAndroidProfileEvent, NativeProfileEvent } from './profiling/nativeTypes';
+/**
+ * Returns the RNSentry module. Dynamically resolves if NativeModule or TurboModule is used.
+ */
+export declare function getRNSentryModule(): Spec | undefined;
 export interface Screenshot {
     data: Uint8Array;
     contentType: string;
@@ -58,6 +62,7 @@ interface SentryNativeWrapper {
      * Fetches native stack frames and debug images for the instructions addresses.
      */
     fetchNativeStackFramesBy(instructionsAddr: number[]): NativeStackFrames | null;
+    initNativeReactNavigationNewFrameTracking(): Promise<void>;
 }
 /**
  * Our internal interface for calling native functions