move to @sentry/types default lib

Author: Valerioageno

playground-ts/src/index.tsx

@@ -3,9 +3,9 @@ import ReactDOM from 'react-dom'
 import './index.css'
 import App from './App'
 import reportWebVitals from './reportWebVitals'
-import { SentryProvider, SentryConfigType } from './component-lib'
+import { SentryProvider } from './component-lib'
 
-const sentryConfig: SentryConfigType = {
+const sentryConfig = {
   dsn: process.env.REACT_APP_SENTRY_DSN ?? '',
   debug: true,
   environment: 'development',

src/SentryProvider.tsx

@@ -1,11 +1,6 @@
 import { createContext, useContext, useLayoutEffect, useState } from 'react'
-import { noop } from './helpers'
-import type {
-  SentryType,
-  Level,
-  SentryConfigType,
-  TracingOptions
-} from './types'
+import type { EventHint, Scope, Options } from '@sentry/types'
+import { SentryType, TracingOptions, SeverityLevels } from './types'
 
 declare global {
   interface Window {
@@ -17,22 +12,28 @@ declare global {
 }
 
 const SentryContext = createContext<SentryType>({
-  onLoad: noop,
-  init: noop,
-  captureMessage: noop,
-  captureException: noop,
-  configureScope: noop,
-  Severity: {},
-  withScope: noop,
+  captureMessage: window?.Sentry?.captureMessage,
+  captureException: window?.Sentry?.captureException,
+  configureScope: window?.Sentry?.configureScope,
+  Severity: {
+    Critical: 'critical',
+    Debug: 'debug',
+    Error: 'error',
+    Fatal: 'fatal',
+    Info: 'info',
+    Log: 'log',
+    Warning: 'warning'
+  },
+  withScope: window?.Sentry?.withScope,
   Integrations: {},
-  setContext: noop,
+  setContext: window?.Sentry?.setContext,
   Scope: undefined
 })
 
 interface ContextProps {
   children: JSX.Element
   url: string
-  config: SentryConfigType
+  config: Options
   integrity?: string
   performance?: boolean
   tracingOptions?: TracingOptions
@@ -48,12 +49,15 @@ export function SentryProvider({
   tracingOptions
 }: ContextProps): JSX.Element {
   const [Sentry, setSentry] = useState<SentryType>({
-    onLoad: (callback) => window?.Sentry?.onLoad(callback),
-    init: (options) => window?.Sentry?.init(options),
-    captureMessage: (msg, lv?: Level) =>
-      window?.Sentry?.captureMessage(msg, lv ?? 'warning'),
-    captureException: (err, lv?: Level) =>
-      window?.Sentry?.captureException(err, lv ?? 'warning'),
+    captureMessage: (
+      message: string,
+      level?: SeverityLevels,
+      hint?: EventHint,
+      scope?: Scope
+    ) => window?.Sentry?.captureMessage(message, level, hint, scope),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    captureException: (exception: any, hint?: EventHint, scope?: Scope) =>
+      window?.Sentry?.captureException(exception, hint, scope),
     configureScope: (callback) => window?.Sentry?.configureScope(callback),
     withScope: (callback) => window?.Sentry?.withScope(callback),
     Severity: {
@@ -105,7 +109,10 @@ export function SentryProvider({
           }
         }
         done = true
-        Sentry.onLoad(() => Sentry.init(config))
+        if (window?.Sentry?.onLoad)
+          window.Sentry.onLoad(
+            () => window?.Sentry?.init && window.Sentry.init(config)
+          )
         if (window.Sentry.Scope) {
           setSentry({
             ...Sentry,

src/helpers.ts

@@ -1,4 +1,3 @@
 import { SentryProvider, useSentry } from './SentryProvider'
-import type { SentryConfigType } from './types'
 
-export { SentryProvider, useSentry, SentryConfigType }
+export { SentryProvider, useSentry }

src/index.ts

@@ -1,6 +1,12 @@
-import type { Scope } from '@sentry/types'
-// TODO: check all "any" types
-export type Level =
+import type {
+  Scope,
+  EventHint,
+  Options,
+  TransactionContext,
+  Transaction
+} from '@sentry/types'
+
+export type SeverityLevels =
   | 'debug'
   | 'info'
   | 'warning'
@@ -11,57 +17,43 @@ export type Level =
 
 export interface TracingOptions {
   tracingOrigins?: string[]
-  // TODO: Check the exact types beforeNavigate()
-  beforeNavigate?: () => void
+  beforeNavigate?: (
+    context: TransactionContext
+  ) => TransactionContext | undefined
+  _metricOptions?: Partial<{ _reportAllChanges: boolean }>
   shouldCreateSpanForRequest?: () => void
   idleTimeout?: number
   startTransactionOnLocationChange?: boolean
   startTransactionOnPageLoad?: boolean
-  maxTransactionDuration?: boolean
+  maxTransactionDuration?: number
   markBackgroundTransactions?: boolean
-}
-
-interface ScopeObject extends Scope {
-  prototype: any
+  routingInstrumentation<T extends Transaction>(
+    customStartTransaction: (context: TransactionContext) => T | undefined,
+    startTransactionOnPageLoad?: boolean,
+    startTransactionOnLocationChange?: boolean
+  ): void
 }
 
 export interface SentryType {
-  onLoad: (callback: () => void) => void
-  init: (options: SentryConfigType) => void
-  captureMessage: (msg: string, lv?: any) => void
-  // TODO: Set the correct parameters for captureException
-  captureException: (err: any, lv?: any) => void
+  onLoad?: (callback: () => void) => void
+  init?: (options: Options) => void
+  captureMessage: (
+    message: string,
+    level?: SeverityLevels,
+    hint?: EventHint,
+    scope?: Scope
+  ) => string | undefined
+  captureException: (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    exception: any,
+    hint?: EventHint,
+    scope?: Scope
+  ) => string | undefined
   configureScope: (callback: () => void) => void
-  Severity: { [key: string]: Level }
+  Severity: { [key: string]: SeverityLevels }
   withScope: (callback: () => void) => void
   Integrations: any
   // TODO: set the correct classes available
   setContext: (str: string, obj: { [k: string]: any }) => void
-  Scope: ScopeObject | undefined
-}
-
-export interface SentryConfigType {
-  dsn: string
-  debug: boolean
-  release: string
-  environment: string
-  tunnel?: string
-  sampleRate?: number
-  maxBreadcrumbs?: number
-  attachStacktrace?: string
-  denyUrls?: string[]
-  allowUrls?: string[]
-  autoSessionTracking?: boolean
-  initialScope?: { [key: string]: any }
-  maxValueLength?: number
-  normalizeDepth?: number
-  // TODO: Integration configurations - https://docs.sentry.io/platforms/javascript/configuration/options/#integration-configuration
-  integrations?: any
-  defaultIntegrations?: boolean
-
-  // TODO: Hooks - https://docs.sentry.io/platforms/javascript/configuration/options/#hooks
-
-  // TODO: transport - https://docs.sentry.io/platforms/javascript/configuration/options/#transport-options
-  tracesSampleRate?: number
-  tracesSampler?: () => void
+  Scope?: Scope & { prototype: any } & EventHint
 }