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

package/src/tools/utils/polyfills.ts

@@ -1,48 +1,6 @@
-export function includes(candidate: string, search: string): boolean
-export function includes<T>(candidate: T[], search: T): boolean
-export function includes(candidate: string | unknown[], search: any) {
-  return candidate.indexOf(search) !== -1
-}
-
-export function arrayFrom<T>(arrayLike: ArrayLike<T> | Set<T>): T[] {
-  if (Array.from) {
-    return Array.from(arrayLike)
-  }
-
-  const array = []
-
-  if (arrayLike instanceof Set) {
-    arrayLike.forEach((item) => array.push(item))
-  } else {
-    for (let i = 0; i < arrayLike.length; i++) {
-      array.push(arrayLike[i])
-    }
-  }
-
-  return array
-}
-
-export function find<T, S extends T>(
-  array: ArrayLike<T>,
-  predicate: (item: T, index: number) => item is S
-): S | undefined
-export function find<T>(array: ArrayLike<T>, predicate: (item: T, index: number) => boolean): T | undefined
-export function find(
-  array: ArrayLike<unknown>,
-  predicate: (item: unknown, index: number) => boolean
-): unknown | undefined {
-  for (let i = 0; i < array.length; i += 1) {
-    const item = array[i]
-    if (predicate(item, i)) {
-      return item
-    }
-  }
-  return undefined
-}
-
 export function findLast<T, S extends T>(
-  array: T[],
-  predicate: (item: T, index: number, array: T[]) => item is S
+  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]
@@ -53,75 +11,13 @@ export function findLast<T, S extends T>(
   return undefined
 }
 
-export function forEach<List extends { [index: number]: any }>(
-  list: List,
-  callback: (value: List[number], index: number, parent: List) => void
-) {
-  Array.prototype.forEach.call(list, callback as any)
-}
+// 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.keys(object).map((key) => object[key])
+  return Object.values(object)
 }
 
 export function objectEntries<T = unknown>(object: { [key: string]: T }): Array<[string, T]> {
-  return Object.keys(object).map((key) => [key, object[key]])
-}
-
-export function startsWith(candidate: string, search: string) {
-  return candidate.slice(0, search.length) === search
-}
-
-export function endsWith(candidate: string, search: string) {
-  return candidate.slice(-search.length) === search
-}
-
-export function elementMatches(element: Element & { msMatchesSelector?(selector: string): boolean }, selector: string) {
-  if (element.matches) {
-    return element.matches(selector)
-  }
-  // IE11 support
-  if (element.msMatchesSelector) {
-    return element.msMatchesSelector(selector)
-  }
-  return false
-}
-
-// https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js
-export function cssEscape(str: string) {
-  if (window.CSS && window.CSS.escape) {
-    return window.CSS.escape(str)
-  }
-
-  // eslint-disable-next-line no-control-regex
-  return str.replace(/([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g, function (ch, asCodePoint) {
-    if (asCodePoint) {
-      // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
-      if (ch === '\0') {
-        return '\uFFFD'
-      }
-      // Control characters and (dependent upon position) numbers get escaped as code points
-      return `${ch.slice(0, -1)}\\${ch.charCodeAt(ch.length - 1).toString(16)} `
-    }
-    // Other potentially-special ASCII characters get backslash-escaped
-    return `\\${ch}`
-  })
-}
-
-interface Assignable {
-  [key: string]: any
-}
-
-export function assign<T, U>(target: T, source: U): T & U
-export function assign<T, U, V>(target: T, source1: U, source2: V): T & U & V
-export function assign<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W
-export function assign(target: Assignable, ...toAssign: Assignable[]) {
-  toAssign.forEach((source: Assignable) => {
-    for (const key in source) {
-      if (Object.prototype.hasOwnProperty.call(source, key)) {
-        target[key] = source[key]
-      }
-    }
-  })
-  return target
+  return Object.entries(object)
 }

package/src/tools/utils/responseUtils.ts

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

package/src/tools/utils/stringUtils.ts

@@ -9,10 +9,68 @@ export function generateUUID(placeholder?: string): string {
     : `${1e7}-${1e3}-${4e3}-${8e3}-${1e11}`.replace(/[018]/g, generateUUID)
 }
 
-export function findCommaSeparatedValue(rawString: string, name: string) {
-  const regex = new RegExp(`(?:^|;)\\s*${name}\\s*=\\s*([^;]+)`)
-  const matches = regex.exec(rawString)
-  return matches ? matches[1] : undefined
+const COMMA_SEPARATED_KEY_VALUE = /([\w-]+)\s*=\s*([^;]+)/g
+
+/**
+ * Returns the value of the key with the given name
+ * If there are multiple values with the same key, returns the first one
+ */
+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
+    }
+  }
+}
+
+/**
+ * Returns a map of all the values with the given key
+ * If there are multiple values with the same key, returns all the values
+ */
+export function findAllCommaSeparatedValues(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) {
+      const key = match[1]
+      const value = match[2]
+      if (result.has(key)) {
+        result.get(key)!.push(value)
+      } else {
+        result.set(key, [value])
+      }
+    } else {
+      break
+    }
+  }
+  return result
+}
+
+/**
+ * Returns a map of the values with the given key
+ * ⚠️ If there are multiple values with the same key, returns the LAST one
+ *
+ * @deprecated use `findAllCommaSeparatedValues()` instead
+ */
+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 = '') {

package/src/tools/utils/timeUtils.ts

@@ -10,12 +10,19 @@ 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 type ClocksState = { relative: RelativeTime; timeStamp: TimeStamp }
+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
@@ -76,13 +83,7 @@ export function addDuration(a: number, b: number) {
   return a + b
 }
 
-/**
- * Get the time since the navigation was started.
- *
- * Note: 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.
- * Related issue in Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926
- */
+// Get the time since the navigation was started.
 export function getRelativeTime(timestamp: TimeStamp) {
   return (timestamp - getNavigationStart()) as RelativeTime
 }
@@ -100,13 +101,17 @@ export function looksLikeRelativeTime(time: RelativeTime | TimeStamp): time is R
  */
 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) {
-    navigationStart = performance.timing.navigationStart as TimeStamp
+    // ServiceWorkers do not support navigationStart (it's deprecated), so we fallback to timeOrigin
+    navigationStart = (performance.timing?.navigationStart ?? performance.timeOrigin) as TimeStamp
   }
-  return navigationStart
-}
 
-export function resetNavigationStart() {
-  navigationStart = undefined
+  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/urlPolyfill.ts

@@ -1,7 +1,7 @@
-import { jsonStringify } from '../serialisation/jsonStringify'
+import { globalObject } from '../globalObject'
 
 export function normalizeUrl(url: string) {
-  return buildUrl(url, getLocationOrigin()).href
+  return buildUrl(url, location.href).href
 }
 
 export function isValidUrl(url: string) {
@@ -12,75 +12,45 @@ export function isValidUrl(url: string) {
   }
 }
 
-export function getOrigin(url: string) {
-  return getLinkElementOrigin(buildUrl(url))
-}
-
 export function getPathName(url: string) {
   const pathname = buildUrl(url).pathname
   return pathname[0] === '/' ? pathname : `/${pathname}`
 }
 
-export function getSearch(url: string) {
-  return buildUrl(url).search
-}
-
-export function getHash(url: string) {
-  return buildUrl(url).hash
-}
-
 export function buildUrl(url: string, base?: string) {
-  const supportedURL = getSupportedUrl()
-  if (supportedURL) {
-    try {
-      return base !== undefined ? new supportedURL(url, base) : new supportedURL(url)
-    } catch (error) {
-      throw new Error(`Failed to construct URL: ${String(error)} ${jsonStringify({ url, base })!}`)
-    }
-  }
-  if (base === undefined && !/:/.test(url)) {
-    throw new Error(`Invalid URL: '${url}'`)
-  }
-  let doc = document
-  const anchorElement = doc.createElement('a')
-  if (base !== undefined) {
-    doc = document.implementation.createHTMLDocument('')
-    const baseElement = doc.createElement('base')
-    baseElement.href = base
-    doc.head.appendChild(baseElement)
-    doc.body.appendChild(anchorElement)
+  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)}`)
   }
-  anchorElement.href = url
-  return anchorElement
 }
 
-const originalURL = URL
-let isURLSupported: boolean | undefined
-function getSupportedUrl(): typeof URL | undefined {
-  if (isURLSupported === undefined) {
+/**
+ * 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 {
-      const url = new originalURL('http://test/path')
-      isURLSupported = url.href === 'http://test/path'
+      iframe = document.createElement('iframe')
+      iframe.style.display = 'none'
+      document.body.appendChild(iframe)
+      pristineWindow = iframe.contentWindow as Window & typeof globalThis
     } catch {
-      isURLSupported = false
+      pristineWindow = globalObject as unknown as Window & typeof globalThis
+    }
+    getPristineGlobalObjectCache = {
+      URL: pristineWindow.URL,
     }
+    iframe?.remove()
   }
-  return isURLSupported ? originalURL : undefined
-}
 
-export function getLocationOrigin() {
-  return getLinkElementOrigin(window.location)
-}
-
-/**
- * Fallback
- * On IE HTMLAnchorElement origin is not supported: https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/origin
- * On Firefox window.location.origin is "null" for file: URIs: https://bugzilla.mozilla.org/show_bug.cgi?id=878297
- */
-export function getLinkElementOrigin(element: Location | HTMLAnchorElement | URL) {
-  if (element.origin && element.origin !== 'null') {
-    return element.origin
-  }
-  const sanitizedHost = element.host.replace(/(:80|:443)$/, '')
-  return `${element.protocol}//${sanitizedHost}`
+  return getPristineGlobalObjectCache
 }

package/src/tools/valueHistory.ts

@@ -1,5 +1,6 @@
 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'
 
@@ -16,45 +17,71 @@ export interface ValueHistoryEntry<T> {
 export const CLEAR_OLD_VALUES_INTERVAL = ONE_MINUTE
 
 /**
- * Store and keep track of values spans. This whole class assumes that values are added in
+ * 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 class ValueHistory<Value> {
-  private entries: Array<ValueHistoryEntry<Value>> = []
-  private clearOldValuesInterval: TimeoutId
-
-  constructor(
-    private expireDelay: number,
-    private maxEntries?: number
-  ) {
-    this.clearOldValuesInterval = setInterval(() => this.clearOldValues(), CLEAR_OLD_VALUES_INTERVAL)
+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.
    */
-  add(value: Value, startTime: RelativeTime): ValueHistoryEntry<Value> {
+  function add(value: Value, startTime: RelativeTime): ValueHistoryEntry<Value> {
     const entry: ValueHistoryEntry<Value> = {
       value,
       startTime,
       endTime: END_OF_TIMES,
       remove: () => {
-        const index = this.entries.indexOf(entry)
-        if (index >= 0) {
-          this.entries.splice(index, 1)
-        }
+        removeItem(entries, entry)
       },
       close: (endTime: RelativeTime) => {
         entry.endTime = endTime
       },
     }
 
-    if (this.maxEntries && this.entries.length >= this.maxEntries) {
-      this.entries.pop()
+    if (maxEntries && entries.length >= maxEntries) {
+      entries.pop()
     }
 
-    this.entries.unshift(entry)
+    entries.unshift(entry)
 
     return entry
   }
@@ -62,11 +89,16 @@ export class ValueHistory<Value> {
   /**
    * 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).
    */
-  find(startTime: RelativeTime = END_OF_TIMES): Value | undefined {
-    for (const entry of this.entries) {
+  function find(
+    startTime: RelativeTime = END_OF_TIMES,
+    options: { returnInactive: boolean } = { returnInactive: false }
+  ): Value | undefined {
+    for (const entry of entries) {
       if (entry.startTime <= startTime) {
-        if (startTime <= entry.endTime) {
+        if (options.returnInactive || startTime <= entry.endTime) {
           return entry.value
         }
         break
@@ -78,8 +110,8 @@ export class ValueHistory<Value> {
    * Helper function to close the currently active value, if any. This method assumes that entries
    * are not overlapping.
    */
-  closeActive(endTime: RelativeTime) {
-    const latestEntry = this.entries[0]
+  function closeActive(endTime: RelativeTime) {
+    const latestEntry = entries[0]
     if (latestEntry && latestEntry.endTime === END_OF_TIMES) {
       latestEntry.close(endTime)
     }
@@ -90,9 +122,9 @@ export class ValueHistory<Value> {
    * or all values that were active during `startTime` if no duration is provided,
    * or all currently active values if no `startTime` is provided.
    */
-  findAll(startTime: RelativeTime = END_OF_TIMES, duration = 0 as Duration): Value[] {
+  function findAll(startTime: RelativeTime = END_OF_TIMES, duration = 0 as Duration): Value[] {
     const endTime = addDuration(startTime, duration)
-    return this.entries
+    return entries
       .filter((entry) => entry.startTime <= endTime && startTime <= entry.endTime)
       .map((entry) => entry.value)
   }
@@ -100,21 +132,20 @@ export class ValueHistory<Value> {
   /**
    * Remove all entries from this collection.
    */
-  reset() {
-    this.entries = []
+  function reset() {
+    entries = []
   }
 
   /**
    * Stop internal garbage collection of past entries.
    */
-  stop() {
-    clearInterval(this.clearOldValuesInterval)
-  }
-
-  private clearOldValues() {
-    const oldTimeThreshold = relativeNow() - this.expireDelay
-    while (this.entries.length > 0 && this.entries[this.entries.length - 1].endTime < oldTimeThreshold) {
-      this.entries.pop()
+  function stop() {
+    cleanupTasks.delete(clearExpiredValues)
+    if (cleanupTasks.size === 0 && cleanupHistoriesInterval) {
+      clearInterval(cleanupHistoriesInterval)
+      cleanupHistoriesInterval = null
     }
   }
+
+  return { add, find, closeActive, findAll, reset, stop }
 }