@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/src/domain/configuration/transportConfiguration.ts

@@ -1,86 +0,0 @@
-import type { InitConfiguration } from './configuration'
-import type { EndpointBuilder } from './endpointBuilder'
-import { createEndpointBuilder } from './endpointBuilder'
-// import { buildTags } from './tags'
-import type { Site } from '../intakeSites'
-import { INTAKE_SITE_PROD, INTAKE_URL_PARAMETERS } from '../intakeSites'
-
-export interface TransportConfiguration {
-  logsEndpointBuilder: EndpointBuilder
-  rumEndpointBuilder: EndpointBuilder
-  sessionReplayEndpointBuilder: EndpointBuilder
-  profilingEndpointBuilder: EndpointBuilder
-  exposuresEndpointBuilder: EndpointBuilder
-  flagEvaluationEndpointBuilder: EndpointBuilder
-  datacenter?: string | undefined
-  replica?: ReplicaConfiguration
-  kubesenseRumEndpoint: Site
-  source: 'browser' | 'flutter' | 'unity'
-}
-
-export interface ReplicaConfiguration {
-  logsEndpointBuilder: EndpointBuilder
-  rumEndpointBuilder: EndpointBuilder
-}
-
-export function computeTransportConfiguration(initConfiguration: InitConfiguration): TransportConfiguration {
-  const site = initConfiguration.kubesenseRumEndpoint || INTAKE_SITE_PROD
-  const source = validateSource(initConfiguration.source)
-
-  // const tags = buildTags(initConfiguration)
-
-  // const endpointBuilders = computeEndpointBuilders(initConfiguration, tags)
-  // const replicaConfiguration = computeReplicaConfiguration(initConfiguration, tags)
-
-  const endpointBuilders = computeEndpointBuilders({ ...initConfiguration, kubesenseRumEndpoint: site, source })
-  const replicaConfiguration = computeReplicaConfiguration({ ...initConfiguration, kubesenseRumEndpoint: site, source })
-
-  return {
-    replica: replicaConfiguration,
-    kubesenseRumEndpoint: site,
-    source,
-    ...endpointBuilders,
-  }
-}
-
-function validateSource(source: string | undefined) {
-  if (source === 'flutter' || source === 'unity') {
-    return source
-  }
-  return 'browser'
-}
-
-function computeEndpointBuilders(initConfiguration: InitConfiguration) {
-  return {
-    logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs'),
-    rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum'),
-    profilingEndpointBuilder: createEndpointBuilder(initConfiguration, 'profile'),
-    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay'),
-    exposuresEndpointBuilder: createEndpointBuilder(initConfiguration, 'exposures'),
-    flagEvaluationEndpointBuilder: createEndpointBuilder(initConfiguration, 'flagevaluation'),
-  }
-}
-
-function computeReplicaConfiguration(initConfiguration: InitConfiguration): ReplicaConfiguration | undefined {
-  if (!initConfiguration.replica) {
-    return
-  }
-
-  const replicaConfiguration: InitConfiguration = {
-    ...initConfiguration,
-    kubesenseRumEndpoint: INTAKE_SITE_PROD,
-    clientToken: initConfiguration.replica.clientToken,
-  }
-
-  return {
-    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs'),
-    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', [
-      `application.id=${initConfiguration.replica.applicationId}`,
-    ]),
-  }
-}
-
-export function isIntakeUrl(url: string): boolean {
-  // check if tags is present in the query string
-  return INTAKE_URL_PARAMETERS.every((param) => url.includes(param))
-}

package/src/domain/intakeSites.ts

@@ -1,6 +0,0 @@
-export type Site = string
-
-export const INTAKE_SITE_STAGING: Site = 'rum.tyke.ai'
-export const INTAKE_SITE_PROD: Site =  'us2.kubesense.ai'
-
-export const INTAKE_URL_PARAMETERS = ['ksource', 'kubesense-api-key', 'kubesense-request-id']

package/src/domain/session/oldCookiesMigration.ts

@@ -1,42 +0,0 @@
-import { getInitCookie } from '../../browser/cookie'
-import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
-import { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy'
-import type { SessionState } from './sessionState'
-import { expandSessionState, isSessionStarted } from './sessionState'
-
-export const OLD_SESSION_COOKIE_NAME = '_kubesense'
-export const OLD_RUM_COOKIE_NAME = '_kubesense_r'
-export const OLD_LOGS_COOKIE_NAME = '_kubesense_l'
-
-// duplicate values to avoid dependency issues
-export const RUM_SESSION_KEY = 'rum'
-export const LOGS_SESSION_KEY = 'logs'
-
-/**
- * This migration should remain in the codebase as long as older versions are available/live
- * to allow older sdk versions to be upgraded to newer versions without compatibility issues.
- */
-export function tryOldCookiesMigration(cookieStoreStrategy: SessionStoreStrategy) {
-  const sessionString = getInitCookie(SESSION_STORE_KEY)
-  if (!sessionString) {
-    const oldSessionId = getInitCookie(OLD_SESSION_COOKIE_NAME)
-    const oldRumType = getInitCookie(OLD_RUM_COOKIE_NAME)
-    const oldLogsType = getInitCookie(OLD_LOGS_COOKIE_NAME)
-    const session: SessionState = {}
-
-    if (oldSessionId) {
-      session.id = oldSessionId
-    }
-    if (oldLogsType && /^[01]$/.test(oldLogsType)) {
-      session[LOGS_SESSION_KEY] = oldLogsType
-    }
-    if (oldRumType && /^[012]$/.test(oldRumType)) {
-      session[RUM_SESSION_KEY] = oldRumType
-    }
-
-    if (isSessionStarted(session)) {
-      expandSessionState(session)
-      cookieStoreStrategy.persistSession(session)
-    }
-  }
-}

package/src/domain/session/sessionStoreOperations.ts

@@ -1,131 +0,0 @@
-import { setTimeout } from '../../tools/timer'
-import { generateUUID } from '../../tools/utils/stringUtils'
-import type { TimeStamp } from '../../tools/utils/timeUtils'
-import { elapsed, ONE_SECOND, timeStampNow } from '../../tools/utils/timeUtils'
-import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
-import type { SessionState } from './sessionState'
-import { expandSessionState, isSessionInExpiredState } from './sessionState'
-
-interface Operations {
-  process: (sessionState: SessionState) => SessionState | undefined
-  after?: (sessionState: SessionState) => void
-}
-
-export const LOCK_RETRY_DELAY = 10
-export const LOCK_MAX_TRIES = 100
-
-// Locks should be hold for a few milliseconds top, just the time it takes to read and write a
-// cookie. Using one second should be enough in most situations.
-export const LOCK_EXPIRATION_DELAY = ONE_SECOND
-const LOCK_SEPARATOR = '--'
-
-const bufferedOperations: Operations[] = []
-let ongoingOperations: Operations | undefined
-
-export function processSessionStoreOperations(
-  operations: Operations,
-  sessionStoreStrategy: SessionStoreStrategy,
-  numberOfRetries = 0
-) {
-  const { isLockEnabled, persistSession, expireSession } = sessionStoreStrategy
-  const persistWithLock = (session: SessionState) => persistSession({ ...session, lock: currentLock })
-  const retrieveStore = () => {
-    const { lock, ...session } = sessionStoreStrategy.retrieveSession()
-    return {
-      session,
-      lock: lock && !isLockExpired(lock) ? lock : undefined,
-    }
-  }
-
-  if (!ongoingOperations) {
-    ongoingOperations = operations
-  }
-  if (operations !== ongoingOperations) {
-    bufferedOperations.push(operations)
-    return
-  }
-  if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
-    next(sessionStoreStrategy)
-    return
-  }
-  let currentLock: string
-  let currentStore = retrieveStore()
-  if (isLockEnabled) {
-    // if someone has lock, retry later
-    if (currentStore.lock) {
-      retryLater(operations, sessionStoreStrategy, numberOfRetries)
-      return
-    }
-    // acquire lock
-    currentLock = createLock()
-    persistWithLock(currentStore.session)
-    // if lock is not acquired, retry later
-    currentStore = retrieveStore()
-    if (currentStore.lock !== currentLock) {
-      retryLater(operations, sessionStoreStrategy, numberOfRetries)
-      return
-    }
-  }
-  let processedSession = operations.process(currentStore.session)
-  if (isLockEnabled) {
-    // if lock corrupted after process, retry later
-    currentStore = retrieveStore()
-    if (currentStore.lock !== currentLock!) {
-      retryLater(operations, sessionStoreStrategy, numberOfRetries)
-      return
-    }
-  }
-  if (processedSession) {
-    if (isSessionInExpiredState(processedSession)) {
-      expireSession(processedSession)
-    } else {
-      expandSessionState(processedSession)
-      if (isLockEnabled) {
-        persistWithLock(processedSession)
-      } else {
-        persistSession(processedSession)
-      }
-    }
-  }
-  if (isLockEnabled) {
-    // correctly handle lock around expiration would require to handle this case properly at several levels
-    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
-    if (!(processedSession && isSessionInExpiredState(processedSession))) {
-      // if lock corrupted after persist, retry later
-      currentStore = retrieveStore()
-      if (currentStore.lock !== currentLock!) {
-        retryLater(operations, sessionStoreStrategy, numberOfRetries)
-        return
-      }
-      persistSession(currentStore.session)
-      processedSession = currentStore.session
-    }
-  }
-  // call after even if session is not persisted in order to perform operations on
-  // up-to-date session state value => the value could have been modified by another tab
-  operations.after?.(processedSession || currentStore.session)
-  next(sessionStoreStrategy)
-}
-
-function retryLater(operations: Operations, sessionStore: SessionStoreStrategy, currentNumberOfRetries: number) {
-  setTimeout(() => {
-    processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1)
-  }, LOCK_RETRY_DELAY)
-}
-
-function next(sessionStore: SessionStoreStrategy) {
-  ongoingOperations = undefined
-  const nextOperations = bufferedOperations.shift()
-  if (nextOperations) {
-    processSessionStoreOperations(nextOperations, sessionStore)
-  }
-}
-
-export function createLock(): string {
-  return generateUUID() + LOCK_SEPARATOR + timeStampNow()
-}
-
-function isLockExpired(lock: string) {
-  const [, timeStamp] = lock.split(LOCK_SEPARATOR)
-  return !timeStamp || elapsed(Number(timeStamp) as TimeStamp, timeStampNow()) > LOCK_EXPIRATION_DELAY
-}

package/src/tools/abstractHooks.ts

@@ -1,72 +0,0 @@
-import { combine } from './mergeInto'
-
-export const enum HookNames {
-  Assemble,
-  AssembleTelemetry,
-}
-
-// This is a workaround for an issue occurring when the Browser SDK is included in a TypeScript
-// project configured with `isolatedModules: true`. Even if the const enum is declared in this
-// module, we cannot use it directly to define the EventMap interface keys (TS error: "Cannot access
-// ambient const enums when the '--isolatedModules' flag is provided.").
-export declare const HookNamesAsConst: {
-  ASSEMBLE: HookNames.Assemble
-  ASSEMBLE_TELEMETRY: HookNames.AssembleTelemetry
-}
-
-export type RecursivePartial<T> = {
-  [P in keyof T]?: T[P] extends Array<infer U>
-    ? Array<RecursivePartial<U>>
-    : T[P] extends object | undefined
-      ? RecursivePartial<T[P]>
-      : T[P]
-}
-
-// Discards the event from being sent
-export const DISCARDED = 'DISCARDED'
-// Skips from the assembly of the event
-export const SKIPPED = 'SKIPPED'
-
-export type DISCARDED = typeof DISCARDED
-export type SKIPPED = typeof SKIPPED
-
-export type AbstractHooks = ReturnType<typeof abstractHooks>
-
-export function abstractHooks<T extends { [K in HookNames]: (...args: any[]) => unknown }>() {
-  const callbacks: { [K in HookNames]?: Array<T[K]> } = {}
-
-  return {
-    register<K extends HookNames>(hookName: K, callback: T[K]) {
-      if (!callbacks[hookName]) {
-        callbacks[hookName] = []
-      }
-      callbacks[hookName]!.push(callback)
-      return {
-        unregister: () => {
-          callbacks[hookName] = callbacks[hookName]!.filter((cb) => cb !== callback)
-        },
-      }
-    },
-    triggerHook<K extends HookNames>(
-      hookName: K,
-      param: Parameters<T[K]>[0]
-    ): Exclude<ReturnType<T[K]>, SKIPPED> | DISCARDED | undefined {
-      const hookCallbacks = callbacks[hookName] || []
-      const results: any[] = []
-
-      for (const callback of hookCallbacks) {
-        const result = callback(param)
-        if (result === DISCARDED) {
-          return DISCARDED
-        }
-        if (result === SKIPPED) {
-          continue
-        }
-
-        results.push(result)
-      }
-
-      return combine(...(results as [any, any])) as Exclude<ReturnType<T[K]>, SKIPPED>
-    },
-  }
-}

package/src/tools/boundedBuffer.ts

@@ -1,44 +0,0 @@
-import { removeItem } from './utils/arrayUtils'
-
-const BUFFER_LIMIT = 500
-/**
- * BoundedBuffer is a deprecated interface.
- *
- * @deprecated Use `BufferedObservable` instead.
- */
-export interface BoundedBuffer<T = void> {
-  add: (callback: (arg: T) => void) => void
-  remove: (callback: (arg: T) => void) => void
-  drain: (arg: T) => void
-}
-
-/**
- * createBoundedBuffer creates a BoundedBuffer.
- *
- * @deprecated Use `BufferedObservable` instead.
- */
-export function createBoundedBuffer<T = void>(): BoundedBuffer<T> {
-  const buffer: Array<(arg: T) => void> = []
-
-  const add: BoundedBuffer<T>['add'] = (callback: (arg: T) => void) => {
-    const length = buffer.push(callback)
-    if (length > BUFFER_LIMIT) {
-      buffer.splice(0, 1)
-    }
-  }
-
-  const remove: BoundedBuffer<T>['remove'] = (callback: (arg: T) => void) => {
-    removeItem(buffer, callback)
-  }
-
-  const drain = (arg: T) => {
-    buffer.forEach((callback) => callback(arg))
-    buffer.length = 0
-  }
-
-  return {
-    add,
-    remove,
-    drain,
-  }
-}

package/src/tools/globalObject.ts

@@ -1,51 +0,0 @@
-/**
- * inspired by https://mathiasbynens.be/notes/globalthis
- */
-
-// Extend/Create the WorkerGlobalScope interface to avoid issues when used in a non-browser tsconfig environment
-interface WorkerGlobalScope {
-  empty: never
-}
-
-// Utility type to enforce that exactly one of the two types is used
-type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never }
-type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U
-
-export type GlobalObject = XOR<Window, WorkerGlobalScope>
-
-export function getGlobalObject<T = typeof globalThis>(): T {
-  if (typeof globalThis === 'object') {
-    return globalThis as unknown as T
-  }
-  Object.defineProperty(Object.prototype, '_kubesense_temp_', {
-    get() {
-      return this as object
-    },
-    configurable: true,
-  })
-  // @ts-ignore _kubesense_temp is defined using defineProperty
-  let globalObject: unknown = _kubesense_temp_
-  // @ts-ignore _kubesense_temp is defined using defineProperty
-  delete Object.prototype._kubesense_temp_
-  if (typeof globalObject !== 'object') {
-    // on safari _kubesense_temp_ is available on window but not globally
-    // fallback on other browser globals check
-    if (typeof self === 'object') {
-      globalObject = self
-    } else if (typeof window === 'object') {
-      globalObject = window
-    } else {
-      globalObject = {}
-    }
-  }
-  return globalObject as T
-}
-
-/**
- * Cached reference to the global object so it can be imported and re-used without
- * re-evaluating the heavyweight fallback logic in `getGlobalObject()`.
- */
-// eslint-disable-next-line local-rules/disallow-side-effects
-export const globalObject = getGlobalObject<GlobalObject>()
-
-export const isWorkerEnvironment = 'WorkerGlobalScope' in globalObject

package/src/tools/mergeInto.ts

@@ -1,177 +0,0 @@
-import { getType } from './utils/typeUtils'
-
-type Merged<TDestination, TSource> =
-  // case 1 - source is undefined - return destination
-  TSource extends undefined
-    ? TDestination
-    : // case 2 - destination is undefined - return source
-      TDestination extends undefined
-      ? TSource
-      : // case 3 - source is an array - see if it merges or overwrites
-        TSource extends any[]
-        ? TDestination extends any[]
-          ? TDestination & TSource
-          : TSource
-        : // case 4 - source is an object - see if it merges or overwrites
-          TSource extends object
-          ? TDestination extends object
-            ? TDestination extends any[]
-              ? TSource
-              : TDestination & TSource
-            : TSource
-          : // case 5 - cannot merge - return source
-            TSource
-
-/**
- * Iterate over source and affect its sub values into destination, recursively.
- * If the source and destination can't be merged, return source.
- */
-export function mergeInto<D, S>(
-  destination: D,
-  source: S,
-  circularReferenceChecker = createCircularReferenceChecker()
-): Merged<D, S> {
-  // ignore the source if it is undefined
-  if (source === undefined) {
-    return destination as Merged<D, S>
-  }
-
-  if (typeof source !== 'object' || source === null) {
-    // primitive values - just return source
-    return source as Merged<D, S>
-  } else if (source instanceof Date) {
-    return new Date(source.getTime()) as unknown as Merged<D, S>
-  } else if (source instanceof RegExp) {
-    const flags =
-      source.flags ||
-      // old browsers compatibility
-      [
-        source.global ? 'g' : '',
-        source.ignoreCase ? 'i' : '',
-        source.multiline ? 'm' : '',
-        source.sticky ? 'y' : '',
-        source.unicode ? 'u' : '',
-      ].join('')
-    return new RegExp(source.source, flags) as unknown as Merged<D, S>
-  }
-
-  if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {
-    // remove circular references
-    return undefined as unknown as Merged<D, S>
-  } else if (Array.isArray(source)) {
-    const merged: any[] = Array.isArray(destination) ? destination : []
-    for (let i = 0; i < source.length; ++i) {
-      merged[i] = mergeInto(merged[i], source[i], circularReferenceChecker)
-    }
-    return merged as unknown as Merged<D, S>
-  }
-
-  const merged = getType(destination) === 'object' ? (destination as Record<any, any>) : {}
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker)
-    }
-  }
-  return merged as unknown as Merged<D, S>
-}
-
-/**
- * A simplistic implementation of a deep clone algorithm.
- * Caveats:
- * - It doesn't maintain prototype chains - don't use with instances of custom classes.
- * - It doesn't handle Map and Set
- */
-export function deepClone<T>(value: T): T {
-  return mergeInto(undefined, value) as T
-}
-
-type Combined<A, B> = A extends null ? B : B extends null ? A : Merged<A, B>
-
-/*
- * Performs a deep merge of objects and arrays.
- * - Arguments won't be mutated
- * - Object and arrays in the output value are de-referenced ("deep cloned")
- * - Arrays values are merged index by index
- * - Objects are merged by keys
- * - Values get replaced, unless undefined
- */
-export function combine<A, B>(a: A, b: B): Combined<A, B>
-export function combine<A, B, C>(a: A, b: B, c: C): Combined<Combined<A, B>, C>
-export function combine<A, B, C, D>(a: A, b: B, c: C, d: D): Combined<Combined<Combined<A, B>, C>, D>
-export function combine<A, B, C, D, E>(
-  a: A,
-  b: B,
-  c: C,
-  d: D,
-  e: E
-): Combined<Combined<Combined<Combined<A, B>, C>, D>, E>
-export function combine<A, B, C, D, E, F>(
-  a: A,
-  b: B,
-  c: C,
-  d: D,
-  e: E,
-  f: F
-): Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>
-export function combine<A, B, C, D, E, F, G>(
-  a: A,
-  b: B,
-  c: C,
-  d: D,
-  e: E,
-  f: F,
-  g: G
-): Combined<Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>, G>
-export function combine<A, B, C, D, E, F, G, H>(
-  a: A,
-  b: B,
-  c: C,
-  d: D,
-  e: E,
-  f: F,
-  g: G,
-  h: H
-): Combined<Combined<Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>, G>, H>
-export function combine(...sources: any[]): unknown {
-  let destination: any
-
-  for (const source of sources) {
-    // Ignore any undefined or null sources.
-    if (source === undefined || source === null) {
-      continue
-    }
-
-    destination = mergeInto(destination, source)
-  }
-
-  return destination as unknown
-}
-
-interface CircularReferenceChecker {
-  hasAlreadyBeenSeen(value: any): boolean
-}
-
-function createCircularReferenceChecker(): CircularReferenceChecker {
-  if (typeof WeakSet !== 'undefined') {
-    const set: WeakSet<any> = new WeakSet()
-    return {
-      hasAlreadyBeenSeen(value) {
-        const has = set.has(value)
-        if (!has) {
-          set.add(value)
-        }
-        return has
-      },
-    }
-  }
-  const array: any[] = []
-  return {
-    hasAlreadyBeenSeen(value) {
-      const has = array.indexOf(value) >= 0
-      if (!has) {
-        array.push(value)
-      }
-      return has
-    },
-  }
-}

package/src/tools/monitor.ts

@@ -1,71 +0,0 @@
-import { display } from './display'
-
-let onMonitorErrorCollected: undefined | ((error: unknown) => void)
-let debugMode = false
-
-export function startMonitorErrorCollection(newOnMonitorErrorCollected: (error: unknown) => void) {
-  onMonitorErrorCollected = newOnMonitorErrorCollected
-}
-
-export function setDebugMode(newDebugMode: boolean) {
-  debugMode = newDebugMode
-}
-
-export function resetMonitor() {
-  onMonitorErrorCollected = undefined
-  debugMode = false
-}
-
-export function monitored<T extends (...params: any[]) => unknown>(
-  _: any,
-  __: string,
-  descriptor: TypedPropertyDescriptor<T>
-) {
-  const originalMethod = descriptor.value!
-  descriptor.value = function (this: ThisParameterType<T>, ...args: Parameters<T>) {
-    const decorated = onMonitorErrorCollected ? monitor(originalMethod) : originalMethod
-    return decorated.apply(this, args) as ReturnType<T>
-  } as T
-}
-
-export function monitor<T extends (...args: any[]) => unknown>(fn: T): T {
-  return function (this: ThisParameterType<T>, ...args: Parameters<T>) {
-    return callMonitored(fn, this, args)
-  } as unknown as T // consider output type has input type
-}
-
-export function callMonitored<T extends (...args: any[]) => unknown>(
-  fn: T,
-  context: ThisParameterType<T>,
-  args: Parameters<T>
-): ReturnType<T> | undefined
-export function callMonitored<T extends (this: void) => unknown>(fn: T): ReturnType<T> | undefined
-export function callMonitored<T extends (...args: any[]) => unknown>(
-  fn: T,
-  context?: any,
-  args?: any
-): ReturnType<T> | undefined {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return fn.apply(context, args) as ReturnType<T>
-  } catch (e) {
-    monitorError(e)
-  }
-}
-
-export function monitorError(e: unknown) {
-  displayIfDebugEnabled(e)
-  if (onMonitorErrorCollected) {
-    try {
-      onMonitorErrorCollected(e)
-    } catch (e) {
-      displayIfDebugEnabled(e)
-    }
-  }
-}
-
-export function displayIfDebugEnabled(...args: unknown[]) {
-  if (debugMode) {
-    display.error('[MONITOR]', ...args)
-  }
-}