@pratham.raval/browser-core 6.22.3

package/src/boot/init.ts

@@ -0,0 +1,55 @@
+import { catchUserErrors } from '../tools/catchUserErrors'
+import { setDebugMode } from '../tools/monitor'
+import { display } from '../tools/display'
+
+// replaced at build time
+declare const __BUILD_ENV__SDK_VERSION__: string
+
+export interface PublicApi {
+  /**
+   * Version of the Logs browser SDK
+   */
+  version: string
+
+  /**
+   * For CDN async setup: Early RUM API calls must be wrapped in the `window.DD_RUM.onReady()` callback. This ensures the code only gets executed once the SDK is properly loaded.
+   *
+   * See [CDN async setup](https://docs.datadoghq.com/real_user_monitoring/browser/#cdn-async) for further information.
+   */
+  onReady: (callback: () => void) => void
+}
+
+export function makePublicApi<T extends PublicApi>(stub: Omit<T, keyof PublicApi>): T {
+  const publicApi = {
+    version: __BUILD_ENV__SDK_VERSION__,
+    // This API method is intentionally not monitored, since the only thing executed is the
+    // user-provided 'callback'.  All SDK usages executed in the callback should be monitored, and
+    // we don't want to interfere with the user uncaught exceptions.
+    onReady(callback: () => void) {
+      callback()
+    },
+    ...stub,
+  }
+
+  // Add a "hidden" property to set debug mode. We define it that way to hide it
+  // as much as possible but of course it's not a real protection.
+  Object.defineProperty(publicApi, '_setDebug', {
+    get() {
+      return setDebugMode
+    },
+    enumerable: false,
+  })
+
+  return publicApi as T
+}
+
+export function defineGlobal<Global, Name extends keyof Global>(global: Global, name: Name, api: Global[Name]) {
+  const existingGlobalVariable = global[name] as { q?: Array<() => void>; version?: string } | undefined
+  if (existingGlobalVariable && !existingGlobalVariable.q && existingGlobalVariable.version) {
+    display.warn('SDK is loaded more than once. This is unsupported and might have unexpected behavior.')
+  }
+  global[name] = api
+  if (existingGlobalVariable && existingGlobalVariable.q) {
+    existingGlobalVariable.q.forEach((fn) => catchUserErrors(fn, 'onReady callback threw an error:')())
+  }
+}

package/src/browser/addEventListener.ts

@@ -0,0 +1,145 @@
+import { monitor } from '../tools/monitor'
+import { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'
+import type { CookieStore, CookieStoreEventMap, VisualViewport, VisualViewportEventMap } from './browser.types'
+
+export type TrustableEvent<E extends Event = Event> = E & { __ddIsTrusted?: boolean }
+
+export const enum DOM_EVENT {
+  BEFORE_UNLOAD = 'beforeunload',
+  CLICK = 'click',
+  DBL_CLICK = 'dblclick',
+  KEY_DOWN = 'keydown',
+  LOAD = 'load',
+  POP_STATE = 'popstate',
+  SCROLL = 'scroll',
+  TOUCH_START = 'touchstart',
+  TOUCH_END = 'touchend',
+  TOUCH_MOVE = 'touchmove',
+  VISIBILITY_CHANGE = 'visibilitychange',
+  PAGE_SHOW = 'pageshow',
+  FREEZE = 'freeze',
+  RESUME = 'resume',
+  DOM_CONTENT_LOADED = 'DOMContentLoaded',
+  POINTER_DOWN = 'pointerdown',
+  POINTER_UP = 'pointerup',
+  POINTER_CANCEL = 'pointercancel',
+  HASH_CHANGE = 'hashchange',
+  PAGE_HIDE = 'pagehide',
+  MOUSE_DOWN = 'mousedown',
+  MOUSE_UP = 'mouseup',
+  MOUSE_MOVE = 'mousemove',
+  FOCUS = 'focus',
+  BLUR = 'blur',
+  CONTEXT_MENU = 'contextmenu',
+  RESIZE = 'resize',
+  CHANGE = 'change',
+  INPUT = 'input',
+  PLAY = 'play',
+  PAUSE = 'pause',
+  SECURITY_POLICY_VIOLATION = 'securitypolicyviolation',
+  SELECTION_CHANGE = 'selectionchange',
+  STORAGE = 'storage',
+}
+
+interface AddEventListenerOptions {
+  once?: boolean
+  capture?: boolean
+  passive?: boolean
+}
+
+type EventMapFor<T> = T extends Window
+  ? WindowEventMap & {
+      // TS 4.9.5 does not support `freeze` and `resume` events yet
+      freeze: Event
+      resume: Event
+      // TS 4.9.5 does not define `visibilitychange` on Window (only Document)
+      visibilitychange: Event
+    }
+  : T extends Document
+    ? DocumentEventMap
+    : T extends HTMLElement
+      ? HTMLElementEventMap
+      : T extends VisualViewport
+        ? VisualViewportEventMap
+        : T extends ShadowRoot
+          ? // ShadowRootEventMap is not yet defined in our supported TS version. Instead, use
+            // GlobalEventHandlersEventMap which is more than enough as we only need to listen for events bubbling
+            // through the ShadowRoot like "change" or "input"
+            GlobalEventHandlersEventMap
+          : T extends XMLHttpRequest
+            ? XMLHttpRequestEventMap
+            : T extends Performance
+              ? PerformanceEventMap
+              : T extends Worker
+                ? WorkerEventMap
+                : T extends CookieStore
+                  ? CookieStoreEventMap
+                  : Record<never, never>
+
+/**
+ * Add an event listener to an event target object (Window, Element, mock object...).  This provides
+ * a few conveniences compared to using `element.addEventListener` directly:
+ *
+ * * supports IE11 by: using an option object only if needed and emulating the `once` option
+ *
+ * * wraps the listener with a `monitor` function
+ *
+ * * returns a `stop` function to remove the listener
+ */
+export function addEventListener<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(
+  configuration: { allowUntrustedEvents?: boolean | undefined },
+  eventTarget: Target,
+  eventName: EventName,
+  listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,
+  options?: AddEventListenerOptions
+) {
+  return addEventListeners(configuration, eventTarget, [eventName], listener, options)
+}
+
+/**
+ * Add event listeners to an event target object (Window, Element, mock object...).  This provides
+ * a few conveniences compared to using `element.addEventListener` directly:
+ *
+ * * supports IE11 by: using an option object only if needed and emulating the `once` option
+ *
+ * * wraps the listener with a `monitor` function
+ *
+ * * returns a `stop` function to remove the listener
+ *
+ * * with `once: true`, the listener will be called at most once, even if different events are listened
+ */
+export function addEventListeners<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(
+  configuration: { allowUntrustedEvents?: boolean | undefined },
+  eventTarget: Target,
+  eventNames: EventName[],
+  listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,
+  { once, capture, passive }: AddEventListenerOptions = {}
+) {
+  const listenerWithMonitor = monitor((event: TrustableEvent) => {
+    if (!event.isTrusted && !event.__ddIsTrusted && !configuration.allowUntrustedEvents) {
+      return
+    }
+    if (once) {
+      stop()
+    }
+    listener(event as unknown as EventMapFor<Target>[EventName] & { type: EventName })
+  })
+
+  const options = passive ? { capture, passive } : capture
+
+  // Use the window.EventTarget.prototype when possible to avoid wrong overrides (e.g: https://github.com/salesforce/lwc/issues/1824)
+  const listenerTarget =
+    window.EventTarget && eventTarget instanceof EventTarget ? window.EventTarget.prototype : eventTarget
+
+  const add = getZoneJsOriginalValue(listenerTarget, 'addEventListener')
+  eventNames.forEach((eventName) => add.call(eventTarget, eventName, listenerWithMonitor, options))
+
+  function stop() {
+    const remove = getZoneJsOriginalValue(listenerTarget, 'removeEventListener')
+    eventNames.forEach((eventName) => remove.call(eventTarget, eventName, listenerWithMonitor, options))
+  }
+
+  return {
+    stop,
+  }
+}

package/src/browser/browser.types.ts

@@ -0,0 +1,82 @@
+// Those types come from the official TypeScript DOM library, but are not included in our minimal
+// supported TS version.
+// https://github.com/microsoft/TypeScript/blob/13c374a868c926f6a907666a5599992c1351b773/src/lib/dom.generated.d.ts#L15399-L15418
+
+export interface VisualViewportEventMap {
+  resize: Event
+  scroll: Event
+}
+
+export interface VisualViewport extends EventTarget {
+  readonly height: number
+  readonly offsetLeft: number
+  readonly offsetTop: number
+  onresize: ((this: VisualViewport, ev: Event) => any) | null
+  onscroll: ((this: VisualViewport, ev: Event) => any) | null
+  readonly pageLeft: number
+  readonly pageTop: number
+  readonly scale: number
+  readonly width: number
+  addEventListener<K extends keyof VisualViewportEventMap>(
+    type: K,
+    listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  removeEventListener<K extends keyof VisualViewportEventMap>(
+    type: K,
+    listener: (this: VisualViewport, ev: VisualViewportEventMap[K]) => any,
+    options?: boolean | EventListenerOptions
+  ): void
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions
+  ): void
+}
+
+export interface WeakRef<T extends object> {
+  readonly [Symbol.toStringTag]: 'WeakRef'
+
+  deref(): T | undefined
+}
+
+export interface WeakRefConstructor {
+  readonly prototype: WeakRef<any>
+
+  new <T extends object>(target: T): WeakRef<T>
+}
+
+export interface CookieStore extends EventTarget {
+  get(name: string): Promise<unknown>
+  getAll(name?: string): Promise<
+    Array<{
+      name: string
+      value: string
+      domain?: string
+      path?: string
+      expires?: number
+      secure?: boolean
+      sameSite?: 'strict' | 'lax' | 'none'
+      partitioned?: boolean
+    }>
+  >
+}
+
+export interface CookieStoreEventMap {
+  change: CookieChangeEvent
+}
+
+export interface CookieChangeItem {
+  name: string
+  value: string | undefined
+}
+
+export type CookieChangeEvent = Event & {
+  changed: CookieChangeItem[]
+  deleted: CookieChangeItem[]
+}

package/src/browser/cookie.ts

@@ -0,0 +1,107 @@
+import { display } from '../tools/display'
+import { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils'
+import { findCommaSeparatedValue, findCommaSeparatedValues, generateUUID } from '../tools/utils/stringUtils'
+import { buildUrl } from '../tools/utils/urlPolyfill'
+
+export interface CookieOptions {
+  secure?: boolean
+  crossSite?: boolean
+  partitioned?: boolean
+  domain?: string
+}
+
+export function setCookie(name: string, value: string, expireDelay: number = 0, options?: CookieOptions) {
+  const date = new Date()
+  date.setTime(date.getTime() + expireDelay)
+  const expires = `expires=${date.toUTCString()}`
+  const sameSite = options && options.crossSite ? 'none' : 'strict'
+  const domain = options && options.domain ? `;domain=${options.domain}` : ''
+  const secure = options && options.secure ? ';secure' : ''
+  const partitioned = options && options.partitioned ? ';partitioned' : ''
+  document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}${partitioned}`
+}
+
+export function getCookie(name: string) {
+  return findCommaSeparatedValue(document.cookie, name)
+}
+
+let initCookieParsed: Map<string, string> | undefined
+
+/**
+ * Returns a cached value of the cookie. Use this during SDK initialization (and whenever possible)
+ * to avoid accessing document.cookie multiple times.
+ */
+export function getInitCookie(name: string) {
+  if (!initCookieParsed) {
+    initCookieParsed = findCommaSeparatedValues(document.cookie)
+  }
+  return initCookieParsed.get(name)
+}
+
+export function resetInitCookies() {
+  initCookieParsed = undefined
+}
+
+export function deleteCookie(name: string, options?: CookieOptions) {
+  setCookie(name, '', 0, options)
+}
+
+export function areCookiesAuthorized(options: CookieOptions): boolean {
+  if (document.cookie === undefined || document.cookie === null) {
+    return false
+  }
+  try {
+    // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during
+    // the test cookie lifetime
+    const testCookieName = `dd_cookie_test_${generateUUID()}`
+    const testCookieValue = 'test'
+    setCookie(testCookieName, testCookieValue, ONE_MINUTE, options)
+    const isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue
+    deleteCookie(testCookieName, options)
+    return isCookieCorrectlySet
+  } catch (error) {
+    display.error(error)
+    return false
+  }
+}
+
+/**
+ * No API to retrieve it, number of levels for subdomain and suffix are unknown
+ * strategy: find the minimal domain on which cookies are allowed to be set
+ * https://web.dev/same-site-same-origin/#site
+ */
+let getCurrentSiteCache: string | undefined
+export function getCurrentSite(hostname = location.hostname, referrer = document.referrer): string | undefined {
+  if (getCurrentSiteCache === undefined) {
+    const defaultHostName = getCookieDefaultHostName(hostname, referrer)
+    if (defaultHostName) {
+      // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during
+      // the test cookie lifetime
+      const testCookieName = `dd_site_test_${generateUUID()}`
+      const testCookieValue = 'test'
+
+      const domainLevels = defaultHostName.split('.')
+      let candidateDomain = domainLevels.pop()!
+      while (domainLevels.length && !getCookie(testCookieName)) {
+        candidateDomain = `${domainLevels.pop()!}.${candidateDomain}`
+        setCookie(testCookieName, testCookieValue, ONE_SECOND, { domain: candidateDomain })
+      }
+      deleteCookie(testCookieName, { domain: candidateDomain })
+      getCurrentSiteCache = candidateDomain
+    }
+  }
+
+  return getCurrentSiteCache
+}
+
+function getCookieDefaultHostName(hostname: string, referrer: string) {
+  try {
+    return hostname || buildUrl(referrer).hostname
+  } catch {
+    // Ignore
+  }
+}
+
+export function resetGetCurrentSite() {
+  getCurrentSiteCache = undefined
+}

package/src/browser/fetchObservable.ts

@@ -0,0 +1,127 @@
+import type { InstrumentedMethodCall } from '../tools/instrumentMethod'
+import { instrumentMethod } from '../tools/instrumentMethod'
+import { monitor } from '../tools/monitor'
+import { Observable } from '../tools/observable'
+import type { ClocksState } from '../tools/utils/timeUtils'
+import { clocksNow } from '../tools/utils/timeUtils'
+import { normalizeUrl } from '../tools/utils/urlPolyfill'
+import type { GlobalObject } from '../tools/globalObject'
+import { globalObject } from '../tools/globalObject'
+
+interface FetchContextBase {
+  method: string
+  startClocks: ClocksState
+  input: unknown
+  init?: RequestInit
+  url: string
+  handlingStack?: string
+}
+
+export interface FetchStartContext extends FetchContextBase {
+  state: 'start'
+}
+
+export interface FetchResolveContext extends FetchContextBase {
+  state: 'resolve'
+  status: number
+  response?: Response
+  responseType?: string
+  isAborted: boolean
+  error?: Error
+}
+
+export type FetchContext = FetchStartContext | FetchResolveContext
+
+let fetchObservable: Observable<FetchContext> | undefined
+
+export function initFetchObservable() {
+  if (!fetchObservable) {
+    fetchObservable = createFetchObservable()
+  }
+  return fetchObservable
+}
+
+export function resetFetchObservable() {
+  fetchObservable = undefined
+}
+
+function createFetchObservable() {
+  return new Observable<FetchContext>((observable) => {
+    if (!globalObject.fetch) {
+      return
+    }
+
+    const { stop } = instrumentMethod(globalObject, 'fetch', (call) => beforeSend(call, observable), {
+      computeHandlingStack: true,
+    })
+
+    return stop
+  })
+}
+
+function beforeSend(
+  { parameters, onPostCall, handlingStack }: InstrumentedMethodCall<GlobalObject, 'fetch'>,
+  observable: Observable<FetchContext>
+) {
+  const [input, init] = parameters
+  let methodFromParams = init && init.method
+
+  if (methodFromParams === undefined && input instanceof Request) {
+    methodFromParams = input.method
+  }
+
+  const method = methodFromParams !== undefined ? String(methodFromParams).toUpperCase() : 'GET'
+  const url = input instanceof Request ? input.url : normalizeUrl(String(input))
+  const startClocks = clocksNow()
+
+  const context: FetchStartContext = {
+    state: 'start',
+    init,
+    input,
+    method,
+    startClocks,
+    url,
+    handlingStack,
+  }
+
+  observable.notify(context)
+
+  // Those properties can be changed by observable subscribers
+  parameters[0] = context.input as RequestInfo | URL
+  parameters[1] = context.init
+
+  onPostCall((responsePromise) => afterSend(observable, responsePromise, context))
+}
+
+function afterSend(
+  observable: Observable<FetchContext>,
+  responsePromise: Promise<Response>,
+  startContext: FetchStartContext
+) {
+  const context = startContext as unknown as FetchResolveContext
+
+  function reportFetch(partialContext: Partial<FetchResolveContext>) {
+    context.state = 'resolve'
+    Object.assign(context, partialContext)
+    observable.notify(context)
+  }
+
+  responsePromise.then(
+    monitor((response) => {
+      reportFetch({
+        response,
+        responseType: response.type,
+        status: response.status,
+        isAborted: false,
+      })
+    }),
+    monitor((error: Error) => {
+      reportFetch({
+        status: 0,
+        isAborted:
+          context.init?.signal?.aborted || (error instanceof DOMException && error.code === DOMException.ABORT_ERR),
+        error,
+      })
+    })
+  )
+}

package/src/browser/pageMayExitObservable.ts

@@ -0,0 +1,56 @@
+import { Observable } from '../tools/observable'
+import { objectValues } from '../tools/utils/polyfills'
+import type { Configuration } from '../domain/configuration'
+import { addEventListeners, addEventListener, DOM_EVENT } from './addEventListener'
+
+export const PageExitReason = {
+  HIDDEN: 'visibility_hidden',
+  UNLOADING: 'before_unload',
+  PAGEHIDE: 'page_hide',
+  FROZEN: 'page_frozen',
+} as const
+
+export type PageExitReason = (typeof PageExitReason)[keyof typeof PageExitReason]
+
+export interface PageMayExitEvent {
+  reason: PageExitReason
+}
+
+export function createPageMayExitObservable(configuration: Configuration): Observable<PageMayExitEvent> {
+  return new Observable<PageMayExitEvent>((observable) => {
+    const { stop: stopListeners } = addEventListeners(
+      configuration,
+      window,
+      [DOM_EVENT.VISIBILITY_CHANGE, DOM_EVENT.FREEZE],
+      (event) => {
+        if (event.type === DOM_EVENT.VISIBILITY_CHANGE && document.visibilityState === 'hidden') {
+          /**
+           * Only event that guarantee to fire on mobile devices when the page transitions to background state
+           * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.
+           */
+          observable.notify({ reason: PageExitReason.HIDDEN })
+        } else if (event.type === DOM_EVENT.FREEZE) {
+          /**
+           * After transitioning in background a tab can be freezed to preserve resources. (cf: https://developer.chrome.com/blog/page-lifecycle-api)
+           * Allow to collect events happening between hidden and frozen state.
+           */
+          observable.notify({ reason: PageExitReason.FROZEN })
+        }
+      },
+      { capture: true }
+    )
+
+    const stopBeforeUnloadListener = addEventListener(configuration, window, DOM_EVENT.BEFORE_UNLOAD, () => {
+      observable.notify({ reason: PageExitReason.UNLOADING })
+    }).stop
+
+    return () => {
+      stopListeners()
+      stopBeforeUnloadListener()
+    }
+  })
+}
+
+export function isPageExitReason(reason: string): reason is PageExitReason {
+  return objectValues(PageExitReason).includes(reason as PageExitReason)
+}

package/src/browser/runOnReadyState.ts

@@ -0,0 +1,25 @@
+import type { Configuration } from '../domain/configuration'
+import { noop } from '../tools/utils/functionUtils'
+import { DOM_EVENT, addEventListener } from './addEventListener'
+
+export function runOnReadyState(
+  configuration: Configuration,
+  expectedReadyState: 'complete' | 'interactive',
+  callback: () => void
+): { stop: () => void } {
+  if (document.readyState === expectedReadyState || document.readyState === 'complete') {
+    callback()
+    return { stop: noop }
+  }
+  const eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED
+  return addEventListener(configuration, window, eventName, callback, { once: true })
+}
+
+export function asyncRunOnReadyState(
+  configuration: Configuration,
+  expectedReadyState: 'complete' | 'interactive'
+): Promise<void> {
+  return new Promise((resolve) => {
+    runOnReadyState(configuration, expectedReadyState, resolve)
+  })
+}