@openobserve/browser-core 0.2.10 → 0.2.11-rc1

package/src/tools/utils/browserDetection.ts

@@ -1,7 +1,48 @@
+// Exported only for tests
+export const enum Browser {
+  IE,
+  CHROMIUM,
+  SAFARI,
+  OTHER,
+}
+
 export function isIE() {
-  return Boolean((document as any).documentMode)
+  return detectBrowserCached() === Browser.IE
 }
 
 export function isChromium() {
-  return !!(window as any).chrome || /HeadlessChrome/.test(window.navigator.userAgent)
+  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
+  }
+
+  if ((browserWindow.document as any).documentMode) {
+    return Browser.IE
+  }
+
+  return Browser.OTHER
 }

package/src/tools/utils/polyfills.ts

@@ -27,10 +27,7 @@ export function find<T, S extends 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 {
+export function find(array: ArrayLike<unknown>, predicate: (item: unknown, index: number) => boolean): unknown {
   for (let i = 0; i < array.length; i += 1) {
     const item = array[i]
     if (predicate(item, i)) {

package/src/tools/utils/stringUtils.ts

@@ -9,10 +9,36 @@ 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
+
+export function findCommaSeparatedValue(rawString: string, name: string): string | undefined {
+  COMMA_SEPARATED_KEY_VALUE.lastIndex = 0
+  // eslint-disable-next-line no-constant-condition
+  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
+  // eslint-disable-next-line no-constant-condition
+  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/transport/batch.ts

@@ -2,21 +2,24 @@ import { display } from '../tools/display'
 import type { Context } from '../tools/serialisation/context'
 import { objectValues } from '../tools/utils/polyfills'
 import { isPageExitReason } from '../browser/pageExitObservable'
-import { computeBytesCount } from '../tools/utils/byteUtils'
 import { jsonStringify } from '../tools/serialisation/jsonStringify'
-import type { HttpRequest } from './httpRequest'
+import type { Subscription } from '../tools/observable'
+import type { Encoder, EncoderResult } from '../tools/encoder'
+import { computeBytesCount } from '../tools/utils/byteUtils'
+import type { HttpRequest, Payload } from './httpRequest'
 import type { FlushController, FlushEvent } from './flushController'
 
 export class Batch {
-  private pushOnlyBuffer: string[] = []
   private upsertBuffer: { [key: string]: string } = {}
+  private flushSubscription: Subscription
 
   constructor(
+    private encoder: Encoder,
     private request: HttpRequest,
     public flushController: FlushController,
     private messageBytesLimit: number
   ) {
-    this.flushController.flushObservable.subscribe((event) => this.flush(event))
+    this.flushSubscription = this.flushController.flushObservable.subscribe((event) => this.flush(event))
   }
 
   add(message: Context) {
@@ -27,24 +30,57 @@ export class Batch {
     this.addOrUpdate(message, key)
   }
 
-  private flush(event: FlushEvent) {
-    const messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer))
+  stop() {
+    this.flushSubscription.unsubscribe()
+  }
 
-    this.pushOnlyBuffer = []
+  private flush(event: FlushEvent) {
+    const upsertMessages = objectValues(this.upsertBuffer).join('\n')
     this.upsertBuffer = {}
 
-    const payload = { data: messages.join('\n'), bytesCount: event.bytesCount, flushReason: event.reason }
-    if (isPageExitReason(event.reason)) {
-      this.request.sendOnExit(payload)
+    const isPageExit = isPageExitReason(event.reason)
+    const send = isPageExit ? this.request.sendOnExit : this.request.send
+
+    if (
+      isPageExit &&
+      // Note: checking that the encoder is async is not strictly needed, but it's an optimization:
+      // if the encoder is async we need to send two requests in some cases (one for encoded data
+      // and the other for non-encoded data). But if it's not async, we don't have to worry about
+      // it and always send a single request.
+      this.encoder.isAsync
+    ) {
+      const encoderResult = this.encoder.finishSync()
+
+      // Send encoded messages
+      if (encoderResult.outputBytesCount) {
+        send(formatPayloadFromEncoder(encoderResult, event))
+      }
+
+      // Send messages that are not yet encoded at this point
+      const pendingMessages = [encoderResult.pendingData, upsertMessages].filter(Boolean).join('\n')
+      if (pendingMessages) {
+        send({
+          data: pendingMessages,
+          bytesCount: computeBytesCount(pendingMessages),
+          flushReason: event.reason,
+        })
+      }
     } else {
-      this.request.send(payload)
+      if (upsertMessages) {
+        this.encoder.write(this.encoder.isEmpty ? upsertMessages : `\n${upsertMessages}`)
+      }
+      this.encoder.finish((encoderResult) => {
+        send(formatPayloadFromEncoder(encoderResult, event))
+      })
     }
   }
 
   private addOrUpdate(message: Context, key?: string) {
-    const { processedMessage, messageBytesCount } = this.process(message)
+    const serializedMessage = jsonStringify(message)!
+
+    const estimatedMessageBytesCount = this.encoder.estimateEncodedBytesCount(serializedMessage)
 
-    if (messageBytesCount >= this.messageBytesLimit) {
+    if (estimatedMessageBytesCount >= this.messageBytesLimit) {
       display.warn(
         `Discarded a message whose size was bigger than the maximum allowed size ${this.messageBytesLimit}KB.`
       )
@@ -55,38 +91,57 @@ export class Batch {
       this.remove(key)
     }
 
-    this.push(processedMessage, messageBytesCount, key)
-  }
-
-  private process(message: Context) {
-    const processedMessage = jsonStringify(message)!
-    const messageBytesCount = computeBytesCount(processedMessage)
-    return { processedMessage, messageBytesCount }
+    this.push(serializedMessage, estimatedMessageBytesCount, key)
   }
 
-  private push(processedMessage: string, messageBytesCount: number, key?: string) {
-    // If there are other messages, a '\n' will be added at serialization
-    const separatorBytesCount = this.flushController.messagesCount > 0 ? 1 : 0
+  private push(serializedMessage: string, estimatedMessageBytesCount: number, key?: string) {
+    this.flushController.notifyBeforeAddMessage(estimatedMessageBytesCount)
 
-    this.flushController.notifyBeforeAddMessage(messageBytesCount + separatorBytesCount)
     if (key !== undefined) {
-      this.upsertBuffer[key] = processedMessage
+      this.upsertBuffer[key] = serializedMessage
+      this.flushController.notifyAfterAddMessage()
     } else {
-      this.pushOnlyBuffer.push(processedMessage)
+      this.encoder.write(
+        this.encoder.isEmpty ? serializedMessage : `\n${serializedMessage}`,
+        (realMessageBytesCount) => {
+          this.flushController.notifyAfterAddMessage(realMessageBytesCount - estimatedMessageBytesCount)
+        }
+      )
     }
-    this.flushController.notifyAfterAddMessage()
   }
 
   private remove(key: string) {
     const removedMessage = this.upsertBuffer[key]
     delete this.upsertBuffer[key]
-    const messageBytesCount = computeBytesCount(removedMessage)
-    // If there are other messages, a '\n' will be added at serialization
-    const separatorBytesCount = this.flushController.messagesCount > 1 ? 1 : 0
-    this.flushController.notifyAfterRemoveMessage(messageBytesCount + separatorBytesCount)
+    const messageBytesCount = this.encoder.estimateEncodedBytesCount(removedMessage)
+    this.flushController.notifyAfterRemoveMessage(messageBytesCount)
   }
 
   private hasMessageFor(key?: string): key is string {
     return key !== undefined && this.upsertBuffer[key] !== undefined
   }
 }
+
+function formatPayloadFromEncoder(encoderResult: EncoderResult, flushEvent: FlushEvent): Payload {
+  let data: string | Blob
+  if (typeof encoderResult.output === 'string') {
+    data = encoderResult.output
+  } else {
+    data = new Blob([encoderResult.output], {
+      // This will set the 'Content-Type: text/plain' header. Reasoning:
+      // * The intake rejects the request if there is no content type.
+      // * The browser will issue CORS preflight requests if we set it to 'application/json', which
+      // could induce higher intake load (and maybe has other impacts).
+      // * Also it's not quite JSON, since we are concatenating multiple JSON objects separated by
+      // new lines.
+      type: 'text/plain',
+    })
+  }
+
+  return {
+    data,
+    bytesCount: encoderResult.outputBytesCount,
+    encoding: encoderResult.encoding,
+    flushReason: flushEvent.reason,
+  }
+}

package/src/transport/flushController.ts

@@ -33,10 +33,13 @@ export function createFlushController({
   pageExitObservable,
   sessionExpireObservable,
 }: FlushControllerOptions) {
-  const flushObservable = new Observable<FlushEvent>()
+  const pageExitSubscription = pageExitObservable.subscribe((event) => flush(event.reason))
+  const sessionExpireSubscription = sessionExpireObservable.subscribe(() => flush('session_expire'))
 
-  pageExitObservable.subscribe((event) => flush(event.reason))
-  sessionExpireObservable.subscribe(() => flush('session_expire'))
+  const flushObservable = new Observable<FlushEvent>(() => () => {
+    pageExitSubscription.unsubscribe()
+    sessionExpireSubscription.unsubscribe()
+  })
 
   let currentBytesCount = 0
   let currentMessagesCount = 0
@@ -85,16 +88,19 @@ export function createFlushController({
      *
      * This function needs to be called synchronously, right before adding the message, so no flush
      * event can happen after `notifyBeforeAddMessage` and before adding the message.
+     *
+     * @param estimatedMessageBytesCount: an estimation of the message bytes count once it is
+     * actually added.
      */
-    notifyBeforeAddMessage(messageBytesCount: number) {
-      if (currentBytesCount + messageBytesCount >= bytesLimit) {
+    notifyBeforeAddMessage(estimatedMessageBytesCount: number) {
+      if (currentBytesCount + estimatedMessageBytesCount >= bytesLimit) {
         flush('bytes_limit')
       }
       // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no
       // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want
       // to notify when a flush is needed (for example on page exit).
       currentMessagesCount += 1
-      currentBytesCount += messageBytesCount
+      currentBytesCount += estimatedMessageBytesCount
       scheduleDurationLimitTimeout()
     },
 
@@ -103,8 +109,13 @@ export function createFlushController({
      *
      * This function can be called asynchronously after the message was added, but in this case it
      * should not be called if a flush event occurred in between.
+     *
+     * @param messageBytesCountDiff: the difference between the estimated message bytes count and
+     * its actual bytes count once added to the pool.
      */
-    notifyAfterAddMessage() {
+    notifyAfterAddMessage(messageBytesCountDiff = 0) {
+      currentBytesCount += messageBytesCountDiff
+
       if (currentMessagesCount >= messagesLimit) {
         flush('messages_limit')
       } else if (currentBytesCount >= bytesLimit) {
@@ -117,6 +128,10 @@ export function createFlushController({
      *
      * This function needs to be called synchronously, right after removing the message, so no flush
      * event can happen after removing the message and before `notifyAfterRemoveMessage`.
+     *
+     * @param messageBytesCount: the message bytes count that was added to the pool. Should
+     * correspond to the sum of bytes counts passed to `notifyBeforeAddMessage` and
+     * `notifyAfterAddMessage`.
      */
     notifyAfterRemoveMessage(messageBytesCount: number) {
       currentBytesCount -= messageBytesCount

package/src/transport/httpRequest.ts

@@ -24,10 +24,11 @@ export interface HttpResponse extends Context {
 }
 
 export interface Payload {
-  data: string | FormData
+  data: string | FormData | Blob
   bytesCount: number
   retry?: RetryInfo
   flushReason?: FlushReason
+  encoding?: 'deflate'
 }
 
 export interface RetryInfo {
@@ -47,7 +48,7 @@ export function createHttpRequest(
 
   return {
     send: (payload: Payload) => {
-      sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.endpointType, reportError)
+      sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, endpointBuilder.trackType, reportError)
     },
     /**
      * Since fetch keepalive behaves like regular fetch on Firefox,
@@ -63,13 +64,13 @@ function sendBeaconStrategy(
   configuration: Configuration,
   endpointBuilder: EndpointBuilder,
   bytesLimit: number,
-  { data, bytesCount, flushReason }: Payload
+  payload: Payload
 ) {
-  const canUseBeacon = !!navigator.sendBeacon && bytesCount < bytesLimit
+  const canUseBeacon = !!navigator.sendBeacon && payload.bytesCount < bytesLimit
   if (canUseBeacon) {
     try {
-      const beaconUrl = endpointBuilder.build('beacon', flushReason)
-      const isQueued = navigator.sendBeacon(beaconUrl, data)
+      const beaconUrl = endpointBuilder.build('beacon', payload)
+      const isQueued = navigator.sendBeacon(beaconUrl, payload.data)
 
       if (isQueued) {
         return
@@ -79,8 +80,8 @@ function sendBeaconStrategy(
     }
   }
 
-  const xhrUrl = endpointBuilder.build('xhr', flushReason)
-  sendXHR(configuration, xhrUrl, data)
+  const xhrUrl = endpointBuilder.build('xhr', payload)
+  sendXHR(configuration, xhrUrl, payload.data)
 }
 
 let hasReportedBeaconError = false
@@ -96,23 +97,23 @@ export function fetchKeepAliveStrategy(
   configuration: Configuration,
   endpointBuilder: EndpointBuilder,
   bytesLimit: number,
-  { data, bytesCount, flushReason, retry }: Payload,
+  payload: Payload,
   onResponse?: (r: HttpResponse) => void
 ) {
-  const canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit
+  const canUseKeepAlive = isKeepAliveSupported() && payload.bytesCount < bytesLimit
   if (canUseKeepAlive) {
-    const fetchUrl = endpointBuilder.build('fetch', flushReason, retry)
-    fetch(fetchUrl, { method: 'POST', body: data, keepalive: true, mode: 'cors' }).then(
+    const fetchUrl = endpointBuilder.build('fetch', payload)
+    fetch(fetchUrl, { method: 'POST', body: payload.data, keepalive: true, mode: 'cors' }).then(
       monitor((response: Response) => onResponse?.({ status: response.status, type: response.type })),
       monitor(() => {
-        const xhrUrl = endpointBuilder.build('xhr', flushReason, retry)
+        const xhrUrl = endpointBuilder.build('xhr', payload)
         // failed to queue the request
-        sendXHR(configuration, xhrUrl, data, onResponse)
+        sendXHR(configuration, xhrUrl, payload.data, onResponse)
       })
     )
   } else {
-    const xhrUrl = endpointBuilder.build('xhr', flushReason, retry)
-    sendXHR(configuration, xhrUrl, data, onResponse)
+    const xhrUrl = endpointBuilder.build('xhr', payload)
+    sendXHR(configuration, xhrUrl, payload.data, onResponse)
   }
 }
 
@@ -133,6 +134,12 @@ export function sendXHR(
 ) {
   const request = new XMLHttpRequest()
   request.open('POST', url, true)
+  if (data instanceof Blob) {
+    // When using a Blob instance, IE does not use its 'type' to define the 'Content-Type' header
+    // automatically, so the intake request ends up being rejected with an HTTP status 415
+    // Defining the header manually fixes this issue.
+    request.setRequestHeader('Content-Type', data.type)
+  }
   addEventListener(
     configuration,
     request,

package/src/transport/sendWithRetryStrategy.ts

@@ -1,4 +1,4 @@
-import type { EndpointType } from '../domain/configuration'
+import type { TrackType } from '../domain/configuration'
 import { setTimeout } from '../tools/timer'
 import { clocksNow, ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils'
 import { ONE_MEBI_BYTE, ONE_KIBI_BYTE } from '../tools/utils/byteUtils'
@@ -38,7 +38,7 @@ export function sendWithRetryStrategy(
   payload: Payload,
   state: RetryState,
   sendStrategy: SendStrategy,
-  endpointType: EndpointType,
+  trackType: TrackType,
   reportError: (error: RawError) => void
 ) {
   if (
@@ -47,10 +47,10 @@ export function sendWithRetryStrategy(
     state.bandwidthMonitor.canHandle(payload)
   ) {
     send(payload, state, sendStrategy, {
-      onSuccess: () => retryQueuedPayloads(RetryReason.AFTER_SUCCESS, state, sendStrategy, endpointType, reportError),
+      onSuccess: () => retryQueuedPayloads(RetryReason.AFTER_SUCCESS, state, sendStrategy, trackType, reportError),
       onFailure: () => {
         state.queuedPayloads.enqueue(payload)
-        scheduleRetry(state, sendStrategy, endpointType, reportError)
+        scheduleRetry(state, sendStrategy, trackType, reportError)
       },
     })
   } else {
@@ -61,7 +61,7 @@ export function sendWithRetryStrategy(
 function scheduleRetry(
   state: RetryState,
   sendStrategy: SendStrategy,
-  endpointType: EndpointType,
+  trackType: TrackType,
   reportError: (error: RawError) => void
 ) {
   if (state.transportStatus !== TransportStatus.DOWN) {
@@ -73,11 +73,11 @@ function scheduleRetry(
       onSuccess: () => {
         state.queuedPayloads.dequeue()
         state.currentBackoffTime = INITIAL_BACKOFF_TIME
-        retryQueuedPayloads(RetryReason.AFTER_RESUME, state, sendStrategy, endpointType, reportError)
+        retryQueuedPayloads(RetryReason.AFTER_RESUME, state, sendStrategy, trackType, reportError)
       },
       onFailure: () => {
         state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2)
-        scheduleRetry(state, sendStrategy, endpointType, reportError)
+        scheduleRetry(state, sendStrategy, trackType, reportError)
       },
     })
   }, state.currentBackoffTime)
@@ -112,12 +112,12 @@ function retryQueuedPayloads(
   reason: RetryReason,
   state: RetryState,
   sendStrategy: SendStrategy,
-  endpointType: EndpointType,
+  trackType: TrackType,
   reportError: (error: RawError) => void
 ) {
   if (reason === RetryReason.AFTER_SUCCESS && state.queuedPayloads.isFull() && !state.queueFullReported) {
     reportError({
-      message: `Reached max ${endpointType} events size queued for upload: ${MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE}MiB`,
+      message: `Reached max ${trackType} events size queued for upload: ${MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE}MiB`,
       source: ErrorSource.AGENT,
       startClocks: clocksNow(),
     })
@@ -126,7 +126,7 @@ function retryQueuedPayloads(
   const previousQueue = state.queuedPayloads
   state.queuedPayloads = newPayloadQueue()
   while (previousQueue.size() > 0) {
-    sendWithRetryStrategy(previousQueue.dequeue()!, state, sendStrategy, endpointType, reportError)
+    sendWithRetryStrategy(previousQueue.dequeue()!, state, sendStrategy, trackType, reportError)
   }
 }
 

package/src/transport/startBatchWithReplica.ts

@@ -3,24 +3,35 @@ import type { Context } from '../tools/serialisation/context'
 import type { Observable } from '../tools/observable'
 import type { PageExitEvent } from '../browser/pageExitObservable'
 import type { RawError } from '../domain/error/error.types'
+import type { Encoder } from '../tools/encoder'
 import { Batch } from './batch'
 import { createHttpRequest } from './httpRequest'
 import { createFlushController } from './flushController'
 
+export interface BatchConfiguration {
+  endpoint: EndpointBuilder
+  encoder: Encoder
+}
+
+interface ReplicaBatchConfiguration<T> extends BatchConfiguration {
+  transformMessage?: (message: T) => T
+}
+
 export function startBatchWithReplica<T extends Context>(
   configuration: Configuration,
-  primary: { endpoint: EndpointBuilder },
-  replica: { endpoint: EndpointBuilder; transformMessage?: (message: T) => T } | undefined,
+  primary: BatchConfiguration,
+  replica: ReplicaBatchConfiguration<T> | undefined,
   reportError: (error: RawError) => void,
   pageExitObservable: Observable<PageExitEvent>,
   sessionExpireObservable: Observable<void>
 ) {
-  const primaryBatch = createBatch(configuration, primary.endpoint)
-  const replicaBatch = replica && createBatch(configuration, replica.endpoint)
+  const primaryBatch = createBatch(configuration, primary)
+  const replicaBatch = replica && createBatch(configuration, replica)
 
-  function createBatch(configuration: Configuration, endpointBuilder: EndpointBuilder) {
+  function createBatch(configuration: Configuration, { endpoint, encoder }: BatchConfiguration) {
     return new Batch(
-      createHttpRequest(configuration, endpointBuilder, configuration.batchBytesLimit, reportError),
+      encoder,
+      createHttpRequest(configuration, endpoint, configuration.batchBytesLimit, reportError),
       createFlushController({
         messagesLimit: configuration.batchMessagesLimit,
         bytesLimit: configuration.batchBytesLimit,
@@ -48,5 +59,10 @@ export function startBatchWithReplica<T extends Context>(
         replicaBatch.upsert(replica.transformMessage ? replica.transformMessage(message) : message, key)
       }
     },
+
+    stop: () => {
+      primaryBatch.stop()
+      replicaBatch?.stop()
+    },
   }
 }

package/cjs/domain/deflate/index.d.ts

@@ -1 +0,0 @@
-export * from './types';

package/cjs/domain/deflate/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/domain/deflate/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAuB"}

package/cjs/domain/tracekit/computeStackTrace.d.ts

@@ -1,5 +0,0 @@
-import type { StackTrace } from './types';
-/**
- * Computes a stack trace for an exception.
- */
-export declare function computeStackTrace(ex: unknown): StackTrace;

package/cjs/domain/tracekit/computeStackTrace.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"computeStackTrace.js","sourceRoot":"","sources":["../../../src/domain/tracekit/computeStackTrace.ts"],"names":[],"mappings":"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"}

package/cjs/domain/tracekit/index.d.ts

@@ -1,3 +0,0 @@
-export { StackTrace, BrowserError } from './types';
-export { computeStackTrace } from './computeStackTrace';
-export { startUnhandledErrorCollection } from './tracekit';

package/cjs/domain/tracekit/index.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startUnhandledErrorCollection = exports.computeStackTrace = void 0;
-var computeStackTrace_1 = require("./computeStackTrace");
-Object.defineProperty(exports, "computeStackTrace", { enumerable: true, get: function () { return computeStackTrace_1.computeStackTrace; } });
-var tracekit_1 = require("./tracekit");
-Object.defineProperty(exports, "startUnhandledErrorCollection", { enumerable: true, get: function () { return tracekit_1.startUnhandledErrorCollection; } });
-//# sourceMappingURL=index.js.map

package/cjs/domain/tracekit/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/domain/tracekit/index.ts"],"names":[],"mappings":";;;AACA,yDAAuD;AAA9C,sHAAA,iBAAiB,OAAA;AAC1B,uCAA0D;AAAjD,yHAAA,6BAA6B,OAAA"}

package/cjs/domain/tracekit/tracekit.d.ts

@@ -1,35 +0,0 @@
-import type { UnhandledErrorCallback } from './types';
-/**
- * Cross-browser collection of unhandled errors
- *
- * Supports:
- * - Firefox: full stack trace with line numbers, plus column number
- * on top frame; column number is not guaranteed
- * - Opera: full stack trace with line and column numbers
- * - Chrome: full stack trace with line and column numbers
- * - Safari: line and column number for the top frame only; some frames
- * may be missing, and column number is not guaranteed
- * - IE: line and column number for the top frame only; some frames
- * may be missing, and column number is not guaranteed
- *
- * In theory, TraceKit should work on all of the following versions:
- * - IE5.5+ (only 8.0 tested)
- * - Firefox 0.9+ (only 3.5+ tested)
- * - Opera 7+ (only 10.50 tested; versions 9 and earlier may require
- * Exceptions Have Stacktrace to be enabled in opera:config)
- * - Safari 3+ (only 4+ tested)
- * - Chrome 1+ (only 5+ tested)
- * - Konqueror 3.5+ (untested)
- *
- * Tries to catch all unhandled errors and report them to the
- * callback.
- *
- * Callbacks receive a StackTrace object as described in the
- * computeStackTrace docs.
- *
- * @memberof TraceKit
- * @namespace
- */
-export declare function startUnhandledErrorCollection(callback: UnhandledErrorCallback): {
-    stop: () => void;
-};