@openobserve/browser-core 0.2.11-rc1 → 0.2.12-beta.1

package/src/domain/contexts/globalContext.ts

@@ -0,0 +1,30 @@
+import type { AbstractHooks } from '../../tools/abstractHooks'
+import { CustomerDataType } from '../context/contextConstants'
+import { storeContextManager } from '../context/storeContextManager'
+import { HookNames } from '../../tools/abstractHooks'
+import { createContextManager } from '../context/contextManager'
+import type { Configuration } from '../configuration'
+
+export function startGlobalContext(
+  hooks: AbstractHooks,
+  configuration: Configuration,
+  productKey: string,
+  useContextNamespace: boolean
+) {
+  const globalContextManager = buildGlobalContextManager()
+
+  if (configuration.storeContextsAcrossPages) {
+    storeContextManager(configuration, globalContextManager, productKey, CustomerDataType.GlobalContext)
+  }
+
+  hooks.register(HookNames.Assemble, () => {
+    const context = globalContextManager.getContext()
+    return useContextNamespace ? { context } : context
+  })
+
+  return globalContextManager
+}
+
+export function buildGlobalContextManager() {
+  return createContextManager('global context')
+}

package/src/domain/contexts/rumInternalContext.type.ts

@@ -0,0 +1,15 @@
+import type { Context } from '../../tools/serialisation/context'
+
+export interface RumInternalContext extends Context {
+  application_id: string
+  session_id: string | undefined
+  view?: {
+    id: string
+    url: string
+    referrer: string
+    name?: string
+  }
+  user_action?: {
+    id: string | string[]
+  }
+}

package/src/domain/contexts/userContext.ts

@@ -0,0 +1,64 @@
+import type { AbstractHooks } from '../../tools/abstractHooks'
+import { CustomerDataType } from '../context/contextConstants'
+import { storeContextManager } from '../context/storeContextManager'
+import { HookNames, SKIPPED } from '../../tools/abstractHooks'
+import { createContextManager } from '../context/contextManager'
+import type { Configuration } from '../configuration'
+import { isEmptyObject } from '../../tools/utils/objectUtils'
+import type { RelativeTime } from '../../tools/utils/timeUtils'
+
+export interface User {
+  id?: string | undefined
+  email?: string | undefined
+  name?: string | undefined
+  [key: string]: unknown
+}
+
+export function startUserContext(
+  hooks: AbstractHooks,
+  configuration: Configuration,
+  sessionManager: {
+    findTrackedSession: (startTime?: RelativeTime) => { anonymousId?: string } | undefined
+  },
+  productKey: string
+) {
+  const userContextManager = buildUserContextManager()
+
+  if (configuration.storeContextsAcrossPages) {
+    storeContextManager(configuration, userContextManager, productKey, CustomerDataType.User)
+  }
+
+  hooks.register(HookNames.Assemble, ({ eventType, startTime }) => {
+    const user = userContextManager.getContext()
+    const session = sessionManager.findTrackedSession(startTime)
+
+    if (session && session.anonymousId && !user.anonymous_id && !!configuration.trackAnonymousUser) {
+      user.anonymous_id = session.anonymousId
+    }
+
+    if (isEmptyObject(user)) {
+      return SKIPPED
+    }
+
+    return {
+      type: eventType,
+      usr: user,
+    }
+  })
+
+  hooks.register(HookNames.AssembleTelemetry, ({ startTime }) => ({
+    anonymous_id: sessionManager.findTrackedSession(startTime)?.anonymousId,
+  }))
+
+  return userContextManager
+}
+
+export function buildUserContextManager() {
+  return createContextManager('user', {
+    propertiesConfig: {
+      id: { type: 'string' },
+      name: { type: 'string' },
+      email: { type: 'string' },
+    },
+  })
+}

package/src/domain/deflate/{types.ts → deflate.types.ts}

@@ -1,4 +1,5 @@
 import type { Encoder } from '../../tools/encoder'
+import type { Uint8ArrayBuffer } from '../../tools/utils/byteUtils'
 
 export type DeflateWorkerAction =
   // Action to send when creating the worker to check if the communication is working correctly.
@@ -31,8 +32,8 @@ export type DeflateWorkerResponse =
       type: 'wrote'
       id: number
       streamId: number
-      result: Uint8Array
-      trailer: Uint8Array
+      result: Uint8ArrayBuffer
+      trailer: Uint8ArrayBuffer
       additionalBytesCount: number
     }
   // Could happen at any time when something goes wrong in the worker
@@ -46,10 +47,11 @@ export interface DeflateWorker extends Worker {
   postMessage(message: DeflateWorkerAction): void
 }
 
-export type DeflateEncoder = Encoder<Uint8Array> & { stop: () => void }
+export type DeflateEncoder = Encoder<Uint8ArrayBuffer> & { stop: () => void }
 
 export const enum DeflateEncoderStreamId {
   REPLAY = 1,
   RUM = 2,
-  RUM_REPLICA = 3,
+  TELEMETRY = 4,
+  PROFILING = 6,
 }

package/src/domain/deflate/index.ts

@@ -1 +1 @@
-export * from './types'
+export * from './deflate.types'

package/src/domain/error/error.ts

@@ -1,21 +1,22 @@
-import { callMonitored } from '../../tools/monitor'
 import { sanitize } from '../../tools/serialisation/sanitize'
 import type { ClocksState } from '../../tools/utils/timeUtils'
-import { noop } from '../../tools/utils/functionUtils'
+import type { Context } from '../../tools/serialisation/context'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
+import type { StackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { toStackTraceString } from '../../tools/stackTrace/handlingStack'
 import type { ErrorSource, ErrorHandling, RawError, RawErrorCause, ErrorWithCause, NonErrorPrefix } from './error.types'
-import type { StackTrace } from './computeStackTrace'
-import { computeStackTrace } from './computeStackTrace'
 
 export const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error'
 
-type RawErrorParams = {
+interface RawErrorParams {
   stackTrace?: StackTrace
   originalError: unknown
-
   handlingStack?: string
+  componentStack?: string
   startClocks: ClocksState
   nonErrorPrefix: NonErrorPrefix
+  useFallbackStack?: boolean
   source: ErrorSource
   handling: ErrorHandling
 }
@@ -24,32 +25,31 @@ export function computeRawError({
   stackTrace,
   originalError,
   handlingStack,
+  componentStack,
   startClocks,
   nonErrorPrefix,
+  useFallbackStack = true,
   source,
   handling,
 }: RawErrorParams): RawError {
-  const isErrorInstance = originalError instanceof Error
-
-  const message = computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError)
-  const stack = hasUsableStack(isErrorInstance, stackTrace)
-    ? toStackTraceString(stackTrace)
-    : NO_ERROR_STACK_PRESENT_MESSAGE
-  const causes = isErrorInstance ? flattenErrorCauses(originalError as ErrorWithCause, source) : undefined
-  const type = stackTrace?.name
-  const fingerprint = tryToGetFingerprint(originalError)
+  const isErrorInstance = isError(originalError)
+  if (!stackTrace && isErrorInstance) {
+    stackTrace = computeStackTrace(originalError)
+  }
 
   return {
     startClocks,
     source,
     handling,
     handlingStack,
+    componentStack,
     originalError,
-    type,
-    message,
-    stack,
-    causes,
-    fingerprint,
+    type: stackTrace ? stackTrace.name : undefined,
+    message: computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError),
+    stack: stackTrace ? toStackTraceString(stackTrace) : useFallbackStack ? NO_ERROR_STACK_PRESENT_MESSAGE : undefined,
+    causes: isErrorInstance ? flattenErrorCauses(originalError as ErrorWithCause, source) : undefined,
+    fingerprint: tryToGetFingerprint(originalError),
+    context: tryToGetErrorContext(originalError),
   }
 }
 
@@ -68,84 +68,28 @@ function computeMessage(
       : 'Empty message'
 }
 
-function hasUsableStack(isErrorInstance: boolean, stackTrace?: StackTrace): stackTrace is StackTrace {
-  if (stackTrace === undefined) {
-    return false
-  }
-  if (isErrorInstance) {
-    return true
-  }
-  // handle cases where tracekit return stack = [] or stack = [{url: undefined, line: undefined, column: undefined}]
-  // TODO rework tracekit integration to avoid generating those unusable stack
-  return stackTrace.stack.length > 0 && (stackTrace.stack.length > 1 || stackTrace.stack[0].url !== undefined)
-}
-
 export function tryToGetFingerprint(originalError: unknown) {
-  return originalError instanceof Error && 'oo_fingerprint' in originalError
-    ? String(originalError.oo_fingerprint)
-    : undefined
+  return isError(originalError) && 'oo_fingerprint' in originalError ? String(originalError.oo_fingerprint) : undefined
 }
 
-export function toStackTraceString(stack: StackTrace) {
-  let result = formatErrorMessage(stack)
-  stack.stack.forEach((frame) => {
-    const func = frame.func === '?' ? '<anonymous>' : frame.func
-    const args = frame.args && frame.args.length > 0 ? `(${frame.args.join(', ')})` : ''
-    const line = frame.line ? `:${frame.line}` : ''
-    const column = frame.line && frame.column ? `:${frame.column}` : ''
-    result += `\n  at ${func!}${args} @ ${frame.url!}${line}${column}`
-  })
-  return result
+export function tryToGetErrorContext(originalError: unknown) {
+  if (originalError !== null && typeof originalError === 'object' && 'dd_context' in originalError) {
+    return originalError.dd_context as Context
+  }
 }
 
 export function getFileFromStackTraceString(stack: string) {
   return /@ (.+)/.exec(stack)?.[1]
 }
 
-export function formatErrorMessage(stack: StackTrace) {
-  return `${stack.name || 'Error'}: ${stack.message!}`
-}
-
-/**
- Creates a stacktrace without SDK internal frames.
- 
- Constraints:
- - Has to be called at the utmost position of the call stack.
- - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.
- */
-export function createHandlingStack(): string {
-  /**
-   * Skip the two internal frames:
-   * - SDK API (console.error, ...)
-   * - this function
-   * in order to keep only the user calls
-   */
-  const internalFramesToSkip = 2
-  const error = new Error()
-  let formattedStack: string
-
-  // IE needs to throw the error to fill in the stack trace
-  if (!error.stack) {
-    try {
-      throw error
-    } catch (e) {
-      noop()
-    }
-  }
-
-  callMonitored(() => {
-    const stackTrace = computeStackTrace(error)
-    stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip)
-    formattedStack = toStackTraceString(stackTrace)
-  })
-
-  return formattedStack!
+export function isError(error: unknown): error is Error {
+  return error instanceof Error || Object.prototype.toString.call(error) === '[object Error]'
 }
 
 export function flattenErrorCauses(error: ErrorWithCause, parentSource: ErrorSource): RawErrorCause[] | undefined {
   let currentError = error
   const causes: RawErrorCause[] = []
-  while (currentError?.cause instanceof Error && causes.length < 10) {
+  while (isError(currentError?.cause) && causes.length < 10) {
     const stackTrace = computeStackTrace(currentError.cause)
     causes.push({
       message: currentError.cause.message,

package/src/domain/error/error.types.ts

@@ -1,3 +1,4 @@
+import type { Context } from '../../tools/serialisation/context'
 import type { ClocksState } from '../../tools/utils/timeUtils'
 
 // TS v4.6 introduced Error.cause[1] typed as `Error`. TS v4.8 changed Error.cause to be
@@ -13,13 +14,17 @@ export interface ErrorWithCause extends Omit<Error, 'cause'> {
   cause?: unknown
 }
 
-export type RawErrorCause = {
+export interface RawErrorCause {
   message: string
-  source: string
+  source: ErrorSource
   type?: string
   stack?: string
 }
 
+export interface Csp {
+  disposition: 'enforce' | 'report'
+}
+
 export interface RawError {
   startClocks: ClocksState
   message: string
@@ -29,8 +34,11 @@ export interface RawError {
   originalError?: unknown
   handling?: ErrorHandling
   handlingStack?: string
+  componentStack?: string
   causes?: RawErrorCause[]
   fingerprint?: string
+  csp?: Csp
+  context?: Context
 }
 
 export const ErrorSource = {

package/src/domain/error/trackRuntimeError.ts

@@ -1,53 +1,50 @@
 import { instrumentMethod } from '../../tools/instrumentMethod'
-import type { Observable } from '../../tools/observable'
+import { Observable } from '../../tools/observable'
 import { clocksNow } from '../../tools/utils/timeUtils'
-import type { StackTrace } from './computeStackTrace'
-import { computeStackTrace, computeStackTraceFromOnErrorMessage } from './computeStackTrace'
-import { computeRawError } from './error'
+import type { StackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { computeStackTraceFromOnErrorMessage } from '../../tools/stackTrace/computeStackTrace'
+import { getGlobalObject } from '../../tools/globalObject'
+import { computeRawError, isError } from './error'
 import type { RawError } from './error.types'
 import { ErrorHandling, ErrorSource, NonErrorPrefix } from './error.types'
 
-export type UnhandledErrorCallback = (stackTrace: StackTrace, originalError?: any) => any
+export type UnhandledErrorCallback = (originalError: unknown, stackTrace?: StackTrace) => any
 
-export function trackRuntimeError(errorObservable: Observable<RawError>) {
-  const handleRuntimeError = (stackTrace: StackTrace, originalError?: any) => {
-    const test = computeRawError({
-      stackTrace,
-      originalError,
-      startClocks: clocksNow(),
-      nonErrorPrefix: NonErrorPrefix.UNCAUGHT,
-      source: ErrorSource.SOURCE,
-      handling: ErrorHandling.UNHANDLED,
-    })
-    errorObservable.notify(test)
-  }
-  const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError)
-  const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError)
+export function trackRuntimeError() {
+  return new Observable<RawError>((observer) => {
+    const handleRuntimeError = (originalError: unknown, stackTrace?: StackTrace) => {
+      const rawError = computeRawError({
+        stackTrace,
+        originalError,
+        startClocks: clocksNow(),
+        nonErrorPrefix: NonErrorPrefix.UNCAUGHT,
+        source: ErrorSource.SOURCE,
+        handling: ErrorHandling.UNHANDLED,
+      })
+      observer.notify(rawError)
+    }
+    const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError)
+    const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError)
 
-  return {
-    stop: () => {
+    return () => {
       stopInstrumentingOnError()
       stopInstrumentingOnUnhandledRejection()
-    },
-  }
+    }
+  })
 }
 
 export function instrumentOnError(callback: UnhandledErrorCallback) {
-  return instrumentMethod(window, 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {
+  return instrumentMethod(getGlobalObject(), 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {
     let stackTrace
-    if (errorObj instanceof Error) {
-      stackTrace = computeStackTrace(errorObj)
-    } else {
+    if (!isError(errorObj)) {
       stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column)
     }
-    callback(stackTrace, errorObj ?? messageObj)
+    callback(errorObj ?? messageObj, stackTrace)
   })
 }
 
 export function instrumentUnhandledRejection(callback: UnhandledErrorCallback) {
-  return instrumentMethod(window, 'onunhandledrejection', ({ parameters: [e] }) => {
-    const reason = e.reason || 'Empty reason'
-    const stack = computeStackTrace(reason)
-    callback(stack, reason)
+  return instrumentMethod(getGlobalObject(), 'onunhandledrejection', ({ parameters: [e] }) => {
+    callback(e.reason || 'Empty reason')
   })
 }

package/src/domain/eventRateLimiter/createEventRateLimiter.ts

@@ -5,10 +5,13 @@ import { ErrorSource } from '../error/error.types'
 
 export type EventRateLimiter = ReturnType<typeof createEventRateLimiter>
 
+// Limit the maximum number of actions, errors and logs per minutes
+const EVENT_RATE_LIMIT = 3000
+
 export function createEventRateLimiter(
   eventType: string,
-  limit: number,
-  onLimitReached: (limitError: RawError) => void
+  onLimitReached: (limitError: RawError) => void,
+  limit = EVENT_RATE_LIMIT
 ) {
   let eventCount = 0
   let allowNextEvent = false

package/src/domain/extension/extensionUtils.ts

@@ -0,0 +1,28 @@
+export const EXTENSION_PREFIXES = ['chrome-extension://', 'moz-extension://']
+
+export function containsExtensionUrl(str: string): boolean {
+  return EXTENSION_PREFIXES.some((prefix) => str.includes(prefix))
+}
+
+/**
+ * Utility function to detect if the SDK is being initialized in an unsupported browser extension environment.
+ *
+ * @param windowLocation - The current window location to check
+ * @param stack - The error stack to check for extension URLs
+ * @returns true if running in an unsupported browser extension environment
+ */
+export function isUnsupportedExtensionEnvironment(windowLocation: string, stack: string = '') {
+  // If the page itself is an extension page.
+  if (containsExtensionUrl(windowLocation)) {
+    return false
+  }
+
+  // Since we generate the error on the init, we check the 2nd frame line.
+  const frameLines = stack.split('\n').filter((line) => {
+    const trimmedLine = line.trim()
+    return trimmedLine.length && /^at\s+|@/.test(trimmedLine)
+  })
+  const target = frameLines[1] || ''
+
+  return containsExtensionUrl(target)
+}

package/src/domain/intakeSites.ts

@@ -0,0 +1,18 @@
+export type Site =
+  | 'datadoghq.com'
+  | 'us3.datadoghq.com'
+  | 'us5.datadoghq.com'
+  | 'datadoghq.eu'
+  | 'ddog-gov.com'
+  | 'ap1.datadoghq.com'
+  | 'ap2.datadoghq.com'
+  | (string & {})
+
+export const INTAKE_SITE_STAGING: Site = 'datad0g.com'
+export const INTAKE_SITE_FED_STAGING: Site = 'dd0g-gov.com'
+export const INTAKE_SITE_US1: Site = 'datadoghq.com'
+export const INTAKE_SITE_EU1: Site = 'datadoghq.eu'
+export const INTAKE_SITE_US1_FED: Site = 'ddog-gov.com'
+
+export const PCI_INTAKE_HOST_US1 = 'pci.browser-intake-datadoghq.com'
+export const INTAKE_URL_PARAMETERS = ['ddsource', 'dd-api-key', 'dd-request-id']

package/src/domain/report/reportObservable.ts

@@ -1,10 +1,12 @@
-import { toStackTraceString } from '../error/error'
+import { toStackTraceString } from '../../tools/stackTrace/handlingStack'
 import { monitor } from '../../tools/monitor'
 import { mergeObservables, Observable } from '../../tools/observable'
 import { addEventListener, DOM_EVENT } from '../../browser/addEventListener'
-import { includes } from '../../tools/utils/polyfills'
 import { safeTruncate } from '../../tools/utils/stringUtils'
 import type { Configuration } from '../configuration'
+import type { RawError } from '../error/error.types'
+import { ErrorHandling, ErrorSource } from '../error/error.types'
+import { clocksNow } from '../../tools/utils/timeUtils'
 import type { ReportType, InterventionReport, DeprecationReport } from './browser.types'
 
 export const RawReportType = {
@@ -15,18 +17,14 @@ export const RawReportType = {
 
 export type RawReportType = (typeof RawReportType)[keyof typeof RawReportType]
 
-export interface RawReport {
-  type: RawReportType
-  subtype: string
-  message: string
-  originalReport: SecurityPolicyViolationEvent | DeprecationReport | InterventionReport
-  stack?: string
+export type RawReportError = RawError & {
+  originalError: SecurityPolicyViolationEvent | DeprecationReport | InterventionReport
 }
 
 export function initReportObservable(configuration: Configuration, apis: RawReportType[]) {
-  const observables: Array<Observable<RawReport>> = []
+  const observables: Array<Observable<RawReportError>> = []
 
-  if (includes(apis, RawReportType.cspViolation)) {
+  if (apis.includes(RawReportType.cspViolation)) {
     observables.push(createCspViolationReportObservable(configuration))
   }
 
@@ -35,19 +33,17 @@ export function initReportObservable(configuration: Configuration, apis: RawRepo
     observables.push(createReportObservable(reportTypes))
   }
 
-  return mergeObservables<RawReport>(...observables)
+  return mergeObservables(...observables)
 }
 
 function createReportObservable(reportTypes: ReportType[]) {
-  return new Observable<RawReport>((observable) => {
+  return new Observable<RawReportError>((observable) => {
     if (!window.ReportingObserver) {
       return
     }
 
     const handleReports = monitor((reports: Array<DeprecationReport | InterventionReport>, _: ReportingObserver) =>
-      reports.forEach((report) => {
-        observable.notify(buildRawReportFromReport(report))
-      })
+      reports.forEach((report) => observable.notify(buildRawReportErrorFromReport(report)))
     ) as ReportingObserverCallback
 
     const observer = new window.ReportingObserver(handleReports, {
@@ -63,34 +59,35 @@ function createReportObservable(reportTypes: ReportType[]) {
 }
 
 function createCspViolationReportObservable(configuration: Configuration) {
-  return new Observable<RawReport>((observable) => {
+  return new Observable<RawReportError>((observable) => {
     const { stop } = addEventListener(configuration, document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {
-      observable.notify(buildRawReportFromCspViolation(event))
+      observable.notify(buildRawReportErrorFromCspViolation(event))
     })
 
     return stop
   })
 }
 
-function buildRawReportFromReport(report: DeprecationReport | InterventionReport): RawReport {
+function buildRawReportErrorFromReport(report: DeprecationReport | InterventionReport): RawReportError {
   const { type, body } = report
 
-  return {
-    type,
-    subtype: body.id,
+  return buildRawReportError({
+    type: body.id,
     message: `${type}: ${body.message}`,
-    originalReport: report,
+    originalError: report,
     stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),
-  }
+  })
 }
 
-function buildRawReportFromCspViolation(event: SecurityPolicyViolationEvent): RawReport {
-  const type = RawReportType.cspViolation
+function buildRawReportErrorFromCspViolation(event: SecurityPolicyViolationEvent): RawReportError {
   const message = `'${event.blockedURI}' blocked by '${event.effectiveDirective}' directive`
-  return {
-    type: RawReportType.cspViolation,
-    subtype: event.effectiveDirective,
-    message: `${type}: ${message}`,
+  return buildRawReportError({
+    type: event.effectiveDirective,
+    message: `${RawReportType.cspViolation}: ${message}`,
+    originalError: event,
+    csp: {
+      disposition: event.disposition,
+    },
     stack: buildStack(
       event.effectiveDirective,
       event.originalPolicy
@@ -100,7 +97,15 @@ function buildRawReportFromCspViolation(event: SecurityPolicyViolationEvent): Ra
       event.lineNumber,
       event.columnNumber
     ),
-    originalReport: event,
+  })
+}
+
+function buildRawReportError(partial: Omit<RawReportError, 'startClocks' | 'source' | 'handling'>): RawReportError {
+  return {
+    startClocks: clocksNow(),
+    source: ErrorSource.REPORT,
+    handling: ErrorHandling.UNHANDLED,
+    ...partial,
   }
 }
 

package/src/domain/resourceUtils.ts

@@ -1,17 +1,21 @@
-export const enum ResourceType {
-  DOCUMENT = 'document',
-  XHR = 'xhr',
-  BEACON = 'beacon',
-  FETCH = 'fetch',
-  CSS = 'css',
-  JS = 'js',
-  IMAGE = 'image',
-  FONT = 'font',
-  MEDIA = 'media',
-  OTHER = 'other',
-}
+export const ResourceType = {
+  DOCUMENT: 'document',
+  XHR: 'xhr',
+  BEACON: 'beacon',
+  FETCH: 'fetch',
+  CSS: 'css',
+  JS: 'js',
+  IMAGE: 'image',
+  FONT: 'font',
+  MEDIA: 'media',
+  OTHER: 'other',
+} as const
 
-export const enum RequestType {
-  FETCH = ResourceType.FETCH,
-  XHR = ResourceType.XHR,
-}
+export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType]
+
+export const RequestType = {
+  FETCH: ResourceType.FETCH,
+  XHR: ResourceType.XHR,
+} as const
+
+export type RequestType = (typeof RequestType)[keyof typeof RequestType]