@pratham.raval/browser-core 6.22.3

package/src/tools/timer.ts

@@ -0,0 +1,21 @@
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+import { monitor } from './monitor'
+import { getGlobalObject } from './globalObject'
+
+export type TimeoutId = ReturnType<typeof globalThis.setTimeout>
+
+export function setTimeout(callback: () => void, delay?: number): TimeoutId {
+  return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(monitor(callback), delay)
+}
+
+export function clearTimeout(timeoutId: TimeoutId | undefined) {
+  getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId)
+}
+
+export function setInterval(callback: () => void, delay?: number): TimeoutId {
+  return getZoneJsOriginalValue(getGlobalObject(), 'setInterval')(monitor(callback), delay)
+}
+
+export function clearInterval(timeoutId: TimeoutId | undefined) {
+  getZoneJsOriginalValue(getGlobalObject(), 'clearInterval')(timeoutId)
+}

package/src/tools/utils/arrayUtils.ts

@@ -0,0 +1,15 @@
+export function removeDuplicates<T>(array: T[]) {
+  const set = new Set<T>()
+  array.forEach((item) => set.add(item))
+  return Array.from(set)
+}
+
+export function removeItem<T>(array: T[], item: T) {
+  const index = array.indexOf(item)
+  if (index >= 0) {
+    array.splice(index, 1)
+  }
+}
+export function isNonEmptyArray<T>(value: unknown): value is T[] {
+  return Array.isArray(value) && value.length > 0
+}

package/src/tools/utils/browserDetection.ts

@@ -0,0 +1,39 @@
+// Exported only for tests
+export const enum Browser {
+  CHROMIUM,
+  SAFARI,
+  OTHER,
+}
+
+export function isChromium() {
+  return detectBrowserCached() === Browser.CHROMIUM
+}
+
+export function isSafari() {
+  return detectBrowserCached() === Browser.SAFARI
+}
+
+let browserCache: Browser | undefined
+function detectBrowserCached() {
+  return browserCache ?? (browserCache = detectBrowser())
+}
+
+// Exported only for tests
+export function detectBrowser(browserWindow: Window = window) {
+  const userAgent = browserWindow.navigator.userAgent
+  if ((browserWindow as any).chrome || /HeadlessChrome/.test(userAgent)) {
+    return Browser.CHROMIUM
+  }
+
+  if (
+    // navigator.vendor is deprecated, but it is the most resilient way we found to detect
+    // "Apple maintained browsers" (AKA Safari). If one day it gets removed, we still have the
+    // useragent test as a semi-working fallback.
+    browserWindow.navigator.vendor?.indexOf('Apple') === 0 ||
+    (/safari/i.test(userAgent) && !/chrome|android/i.test(userAgent))
+  ) {
+    return Browser.SAFARI
+  }
+
+  return Browser.OTHER
+}

package/src/tools/utils/byteUtils.ts

@@ -0,0 +1,35 @@
+export const ONE_KIBI_BYTE = 1024
+export const ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE
+
+// eslint-disable-next-line no-control-regex
+const HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/
+
+export interface Uint8ArrayBuffer extends Uint8Array {
+  readonly buffer: ArrayBuffer
+
+  subarray(begin?: number, end?: number): Uint8ArrayBuffer
+}
+
+export function computeBytesCount(candidate: string): number {
+  // Accurate bytes count computations can degrade performances when there is a lot of events to process
+  if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {
+    return candidate.length
+  }
+
+  if (window.TextEncoder !== undefined) {
+    return new TextEncoder().encode(candidate).length
+  }
+
+  return new Blob([candidate]).size
+}
+
+export function concatBuffers(buffers: Uint8ArrayBuffer[]): Uint8ArrayBuffer {
+  const length = buffers.reduce((total, buffer) => total + buffer.length, 0)
+  const result: Uint8ArrayBuffer = new Uint8Array(length)
+  let offset = 0
+  for (const buffer of buffers) {
+    result.set(buffer, offset)
+    offset += buffer.length
+  }
+  return result
+}

package/src/tools/utils/functionUtils.ts

@@ -0,0 +1,45 @@
+import type { TimeoutId } from '../timer'
+import { setTimeout, clearTimeout } from '../timer'
+
+// use lodash API
+export function throttle<T extends (...args: any[]) => void>(
+  fn: T,
+  wait: number,
+  options?: { leading?: boolean; trailing?: boolean }
+) {
+  const needLeadingExecution = options && options.leading !== undefined ? options.leading : true
+  const needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true
+  let inWaitPeriod = false
+  let pendingExecutionWithParameters: Parameters<T> | undefined
+  let pendingTimeoutId: TimeoutId
+
+  return {
+    throttled: (...parameters: Parameters<T>) => {
+      if (inWaitPeriod) {
+        pendingExecutionWithParameters = parameters
+        return
+      }
+      if (needLeadingExecution) {
+        fn(...parameters)
+      } else {
+        pendingExecutionWithParameters = parameters
+      }
+      inWaitPeriod = true
+      pendingTimeoutId = setTimeout(() => {
+        if (needTrailingExecution && pendingExecutionWithParameters) {
+          fn(...pendingExecutionWithParameters)
+        }
+        inWaitPeriod = false
+        pendingExecutionWithParameters = undefined
+      }, wait)
+    },
+    cancel: () => {
+      clearTimeout(pendingTimeoutId)
+      inWaitPeriod = false
+      pendingExecutionWithParameters = undefined
+    },
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function noop() {}

package/src/tools/utils/numberUtils.ts

@@ -0,0 +1,20 @@
+/**
+ * Return true if the draw is successful
+ *
+ * @param threshold - Threshold between 0 and 100
+ */
+export function performDraw(threshold: number): boolean {
+  return threshold !== 0 && Math.random() * 100 <= threshold
+}
+
+export function round(num: number, decimals: 0 | 1 | 2 | 3 | 4) {
+  return +num.toFixed(decimals)
+}
+
+export function isPercentage(value: unknown) {
+  return isNumber(value) && value >= 0 && value <= 100
+}
+
+export function isNumber(value: unknown): value is number {
+  return typeof value === 'number'
+}

package/src/tools/utils/objectUtils.ts

@@ -0,0 +1,19 @@
+export function shallowClone<T>(object: T): T & Record<string, never> {
+  return { ...object } as T & Record<string, never>
+}
+
+export function objectHasValue<T extends { [key: string]: unknown }>(object: T, value: unknown): value is T[keyof T] {
+  return Object.keys(object).some((key) => object[key] === value)
+}
+
+export function isEmptyObject(object: object) {
+  return Object.keys(object).length === 0
+}
+
+export function mapValues<A, B>(object: { [key: string]: A }, fn: (arg: A) => B) {
+  const newObject: { [key: string]: B } = {}
+  for (const key of Object.keys(object)) {
+    newObject[key] = fn(object[key])
+  }
+  return newObject
+}

package/src/tools/utils/polyfills.ts

@@ -0,0 +1,23 @@
+export function findLast<T, S extends T>(
+  array: readonly T[],
+  predicate: (item: T, index: number, array: readonly T[]) => item is S
+): S | undefined {
+  for (let i = array.length - 1; i >= 0; i -= 1) {
+    const item = array[i]
+    if (predicate(item, i, array)) {
+      return item
+    }
+  }
+  return undefined
+}
+
+// Keep the following wrapper functions as it can be mangled and will result in smaller bundle size that using
+// the native Object.values and Object.entries directly
+
+export function objectValues<T = unknown>(object: { [key: string]: T }) {
+  return Object.values(object)
+}
+
+export function objectEntries<T = unknown>(object: { [key: string]: T }): Array<[string, T]> {
+  return Object.entries(object)
+}

package/src/tools/utils/responseUtils.ts

@@ -0,0 +1,12 @@
+export function isServerError(status: number) {
+  return status >= 500
+}
+
+export function tryToClone(response: Response): Response | undefined {
+  try {
+    return response.clone()
+  } catch {
+    // clone can throw if the response has already been used by another instrumentation or is disturbed
+    return
+  }
+}

package/src/tools/utils/stringUtils.ts

@@ -0,0 +1,52 @@
+/**
+ * UUID v4
+ * from https://gist.github.com/jed/982883
+ */
+export function generateUUID(placeholder?: string): string {
+  return placeholder
+    ? // eslint-disable-next-line  no-bitwise
+      (parseInt(placeholder, 10) ^ ((Math.random() * 16) >> (parseInt(placeholder, 10) / 4))).toString(16)
+    : `${1e7}-${1e3}-${4e3}-${8e3}-${1e11}`.replace(/[018]/g, generateUUID)
+}
+
+const COMMA_SEPARATED_KEY_VALUE = /([\w-]+)\s*=\s*([^;]+)/g
+
+export function findCommaSeparatedValue(rawString: string, name: string): string | undefined {
+  COMMA_SEPARATED_KEY_VALUE.lastIndex = 0
+  while (true) {
+    const match = COMMA_SEPARATED_KEY_VALUE.exec(rawString)
+    if (match) {
+      if (match[1] === name) {
+        return match[2]
+      }
+    } else {
+      break
+    }
+  }
+}
+
+export function findCommaSeparatedValues(rawString: string): Map<string, string> {
+  const result = new Map<string, string>()
+  COMMA_SEPARATED_KEY_VALUE.lastIndex = 0
+  while (true) {
+    const match = COMMA_SEPARATED_KEY_VALUE.exec(rawString)
+    if (match) {
+      result.set(match[1], match[2])
+    } else {
+      break
+    }
+  }
+  return result
+}
+
+export function safeTruncate(candidate: string, length: number, suffix = '') {
+  const lastChar = candidate.charCodeAt(length - 1)
+  const isLastCharSurrogatePair = lastChar >= 0xd800 && lastChar <= 0xdbff
+  const correctedLength = isLastCharSurrogatePair ? length + 1 : length
+
+  if (candidate.length <= correctedLength) {
+    return candidate
+  }
+
+  return `${candidate.slice(0, correctedLength)}${suffix}`
+}

package/src/tools/utils/timeUtils.ts

@@ -0,0 +1,117 @@
+import { isNumber, round } from './numberUtils'
+
+export const ONE_SECOND = 1000
+export const ONE_MINUTE = 60 * ONE_SECOND
+export const ONE_HOUR = 60 * ONE_MINUTE
+export const ONE_DAY = 24 * ONE_HOUR
+export const ONE_YEAR = 365 * ONE_DAY
+
+export type Duration = number & { d: 'Duration in ms' }
+export type ServerDuration = number & { s: 'Duration in ns' }
+export type TimeStamp = number & { t: 'Epoch time' }
+export type RelativeTime = number & { r: 'Time relative to navigation start' } & { d: 'Duration in ms' }
+export interface ClocksState {
+  relative: RelativeTime
+  timeStamp: TimeStamp
+}
+
+export function relativeToClocks(relative: RelativeTime) {
+  return { relative, timeStamp: getCorrectedTimeStamp(relative) }
+}
+
+export function timeStampToClocks(timeStamp: TimeStamp) {
+  return { relative: getRelativeTime(timeStamp), timeStamp }
+}
+
+function getCorrectedTimeStamp(relativeTime: RelativeTime) {
+  const correctedOrigin = (dateNow() - performance.now()) as TimeStamp
+  // apply correction only for positive drift
+  if (correctedOrigin > getNavigationStart()) {
+    return Math.round(addDuration(correctedOrigin, relativeTime)) as TimeStamp
+  }
+  return getTimeStamp(relativeTime)
+}
+
+export function currentDrift() {
+  return Math.round(dateNow() - addDuration(getNavigationStart(), performance.now() as Duration))
+}
+
+export function toServerDuration(duration: Duration): ServerDuration
+export function toServerDuration(duration: Duration | undefined): ServerDuration | undefined
+export function toServerDuration(duration: Duration | undefined) {
+  if (!isNumber(duration)) {
+    return duration
+  }
+  return round(duration * 1e6, 0) as ServerDuration
+}
+
+export function dateNow() {
+  // Do not use `Date.now` because sometimes websites are wrongly "polyfilling" it. For example, we
+  // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date
+  // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this
+  // case ourselves.
+  // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16
+  return new Date().getTime()
+}
+
+export function timeStampNow() {
+  return dateNow() as TimeStamp
+}
+
+export function relativeNow() {
+  return performance.now() as RelativeTime
+}
+
+export function clocksNow() {
+  return { relative: relativeNow(), timeStamp: timeStampNow() }
+}
+
+export function clocksOrigin() {
+  return { relative: 0 as RelativeTime, timeStamp: getNavigationStart() }
+}
+
+export function elapsed(start: TimeStamp, end: TimeStamp): Duration
+export function elapsed(start: RelativeTime, end: RelativeTime): Duration
+export function elapsed(start: number, end: number) {
+  return (end - start) as Duration
+}
+
+export function addDuration(a: TimeStamp, b: Duration): TimeStamp
+export function addDuration(a: RelativeTime, b: Duration): RelativeTime
+export function addDuration(a: Duration, b: Duration): Duration
+export function addDuration(a: number, b: number) {
+  return a + b
+}
+
+// Get the time since the navigation was started.
+export function getRelativeTime(timestamp: TimeStamp) {
+  return (timestamp - getNavigationStart()) as RelativeTime
+}
+
+export function getTimeStamp(relativeTime: RelativeTime) {
+  return Math.round(addDuration(getNavigationStart(), relativeTime)) as TimeStamp
+}
+
+export function looksLikeRelativeTime(time: RelativeTime | TimeStamp): time is RelativeTime {
+  return time < ONE_YEAR
+}
+
+/**
+ * Navigation start slightly change on some rare cases
+ */
+let navigationStart: TimeStamp | undefined
+
+/**
+ * Notes: this does not use `performance.timeOrigin` because:
+ * - It doesn't seem to reflect the actual time on which the navigation has started: it may be much farther in the past,
+ * at least in Firefox 71. (see: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926)
+ * - It is not supported in Safari <15
+ */
+function getNavigationStart() {
+  if (navigationStart === undefined) {
+    // ServiceWorkers do not support navigationStart (it's deprecated), so we fallback to timeOrigin
+    navigationStart = (performance.timing?.navigationStart ?? performance.timeOrigin) as TimeStamp
+  }
+
+  return navigationStart
+}

package/src/tools/utils/timezone.ts

@@ -0,0 +1,9 @@
+export function getTimeZone() {
+  try {
+    const intl = new Intl.DateTimeFormat()
+
+    return intl.resolvedOptions().timeZone
+  } catch {
+    return undefined
+  }
+}

package/src/tools/utils/typeUtils.ts

@@ -0,0 +1,12 @@
+/**
+ * Similar to `typeof`, but distinguish plain objects from `null` and arrays
+ */
+export function getType(value: unknown) {
+  if (value === null) {
+    return 'null'
+  }
+  if (Array.isArray(value)) {
+    return 'array'
+  }
+  return typeof value
+}

package/src/tools/utils/urlPolyfill.ts

@@ -0,0 +1,56 @@
+import { globalObject } from '../globalObject'
+
+export function normalizeUrl(url: string) {
+  return buildUrl(url, location.href).href
+}
+
+export function isValidUrl(url: string) {
+  try {
+    return !!buildUrl(url)
+  } catch {
+    return false
+  }
+}
+
+export function getPathName(url: string) {
+  const pathname = buildUrl(url).pathname
+  return pathname[0] === '/' ? pathname : `/${pathname}`
+}
+
+export function buildUrl(url: string, base?: string) {
+  const { URL } = getPristineWindow()
+
+  try {
+    return base !== undefined ? new URL(url, base) : new URL(url)
+  } catch (error) {
+    throw new Error(`Failed to construct URL: ${String(error)}`)
+  }
+}
+
+/**
+ * Get native URL constructor from a clean iframe
+ * This avoids polyfill issues by getting the native implementation from a fresh iframe context
+ * Falls back to the original URL constructor if iframe approach fails
+ */
+let getPristineGlobalObjectCache: Pick<typeof window, 'URL'> | undefined
+
+export function getPristineWindow() {
+  if (!getPristineGlobalObjectCache) {
+    let iframe: HTMLIFrameElement | undefined
+    let pristineWindow: Window & typeof globalThis
+    try {
+      iframe = document.createElement('iframe')
+      iframe.style.display = 'none'
+      document.body.appendChild(iframe)
+      pristineWindow = iframe.contentWindow as Window & typeof globalThis
+    } catch {
+      pristineWindow = globalObject as unknown as Window & typeof globalThis
+    }
+    getPristineGlobalObjectCache = {
+      URL: pristineWindow.URL,
+    }
+    iframe?.remove()
+  }
+
+  return getPristineGlobalObjectCache
+}

package/src/tools/valueHistory.ts

@@ -0,0 +1,151 @@
+import { setInterval, clearInterval } from './timer'
+import type { TimeoutId } from './timer'
+import { removeItem } from './utils/arrayUtils'
+import type { Duration, RelativeTime } from './utils/timeUtils'
+import { addDuration, relativeNow, ONE_MINUTE } from './utils/timeUtils'
+
+const END_OF_TIMES = Infinity as RelativeTime
+
+export interface ValueHistoryEntry<T> {
+  startTime: RelativeTime
+  endTime: RelativeTime
+  value: T
+  remove(): void
+  close(endTime: RelativeTime): void
+}
+
+export const CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE
+
+/**
+ * Store and keep track of values spans. This whole cache assumes that values are added in
+ * chronological order (i.e. all entries have an increasing start time).
+ */
+export interface ValueHistory<Value> {
+  add: (value: Value, startTime: RelativeTime) => ValueHistoryEntry<Value>
+  find: (startTime?: RelativeTime, options?: { returnInactive: boolean }) => Value | undefined
+
+  closeActive: (endTime: RelativeTime) => void
+  findAll: (startTime?: RelativeTime, duration?: Duration) => Value[]
+  reset: () => void
+  stop: () => void
+}
+
+let cleanupHistoriesInterval: TimeoutId | null = null
+
+const cleanupTasks: Set<() => void> = new Set()
+
+function cleanupHistories() {
+  cleanupTasks.forEach((task) => task())
+}
+
+export function createValueHistory<Value>({
+  expireDelay,
+  maxEntries,
+}: {
+  expireDelay: number
+  maxEntries?: number
+}): ValueHistory<Value> {
+  let entries: Array<ValueHistoryEntry<Value>> = []
+
+  if (!cleanupHistoriesInterval) {
+    cleanupHistoriesInterval = setInterval(() => cleanupHistories(), CLEAR_OLD_VALUES_INTERVAL)
+  }
+
+  const clearExpiredValues = () => {
+    const oldTimeThreshold = relativeNow() - expireDelay
+    while (entries.length > 0 && entries[entries.length - 1].endTime < oldTimeThreshold) {
+      entries.pop()
+    }
+  }
+
+  cleanupTasks.add(clearExpiredValues)
+
+  /**
+   * Add a value to the history associated with a start time. Returns a reference to this newly
+   * added entry that can be removed or closed.
+   */
+  function add(value: Value, startTime: RelativeTime): ValueHistoryEntry<Value> {
+    const entry: ValueHistoryEntry<Value> = {
+      value,
+      startTime,
+      endTime: END_OF_TIMES,
+      remove: () => {
+        removeItem(entries, entry)
+      },
+      close: (endTime: RelativeTime) => {
+        entry.endTime = endTime
+      },
+    }
+
+    if (maxEntries && entries.length >= maxEntries) {
+      entries.pop()
+    }
+
+    entries.unshift(entry)
+
+    return entry
+  }
+
+  /**
+   * Return the latest value that was active during `startTime`, or the currently active value
+   * if no `startTime` is provided. This method assumes that entries are not overlapping.
+   *
+   * If `option.returnInactive` is true, returns the value at `startTime` (active or not).
+   */
+  function find(
+    startTime: RelativeTime = END_OF_TIMES,
+    options: { returnInactive: boolean } = { returnInactive: false }
+  ): Value | undefined {
+    for (const entry of entries) {
+      if (entry.startTime <= startTime) {
+        if (options.returnInactive || startTime <= entry.endTime) {
+          return entry.value
+        }
+        break
+      }
+    }
+  }
+
+  /**
+   * Helper function to close the currently active value, if any. This method assumes that entries
+   * are not overlapping.
+   */
+  function closeActive(endTime: RelativeTime) {
+    const latestEntry = entries[0]
+    if (latestEntry && latestEntry.endTime === END_OF_TIMES) {
+      latestEntry.close(endTime)
+    }
+  }
+
+  /**
+   * Return all values with an active period overlapping with the duration,
+   * or all values that were active during `startTime` if no duration is provided,
+   * or all currently active values if no `startTime` is provided.
+   */
+  function findAll(startTime: RelativeTime = END_OF_TIMES, duration = 0 as Duration): Value[] {
+    const endTime = addDuration(startTime, duration)
+    return entries
+      .filter((entry) => entry.startTime <= endTime && startTime <= entry.endTime)
+      .map((entry) => entry.value)
+  }
+
+  /**
+   * Remove all entries from this collection.
+   */
+  function reset() {
+    entries = []
+  }
+
+  /**
+   * Stop internal garbage collection of past entries.
+   */
+  function stop() {
+    cleanupTasks.delete(clearExpiredValues)
+    if (cleanupTasks.size === 0 && cleanupHistoriesInterval) {
+      clearInterval(cleanupHistoriesInterval)
+      cleanupHistoriesInterval = null
+    }
+  }
+
+  return { add, find, closeActive, findAll, reset, stop }
+}