@openobserve/browser-core 0.3.4 → 0.4.0-beta.1

package/src/tools/abstractHooks.spec.ts

@@ -1,76 +0,0 @@
-import type { RelativeTime } from '@datadog/browser-core'
-import { createHooks } from '../../test'
-import { DISCARDED, HookNames } from './abstractHooks'
-
-describe('startHooks', () => {
-  let hooks: ReturnType<typeof createHooks>
-  const hookParams = { eventType: 'error', startTime: 1011 as RelativeTime } as any
-
-  beforeEach(() => {
-    hooks = createHooks()
-  })
-
-  it('unregister a hook callback', () => {
-    const callback = jasmine.createSpy().and.returnValue({ service: 'foo' })
-
-    const { unregister } = hooks.register(HookNames.Assemble, callback)
-    unregister()
-
-    const result = hooks.triggerHook(HookNames.Assemble, hookParams)
-
-    expect(callback).not.toHaveBeenCalled()
-    expect(result).toBeUndefined()
-  })
-
-  describe('assemble hook', () => {
-    it('combines results from multiple callbacks', () => {
-      const callback1 = jasmine.createSpy().and.returnValue({ type: 'action', service: 'foo' })
-      const callback2 = jasmine.createSpy().and.returnValue({ type: 'action', version: 'bar' })
-
-      hooks.register(HookNames.Assemble, callback1)
-      hooks.register(HookNames.Assemble, callback2)
-
-      const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, hookParams)
-
-      expect(defaultRumEventAttributes).toEqual({ type: 'action', service: 'foo', version: 'bar' })
-      expect(callback1).toHaveBeenCalled()
-      expect(callback2).toHaveBeenCalled()
-    })
-
-    it('does not combine undefined results from callbacks', () => {
-      const callback1 = jasmine.createSpy().and.returnValue({ type: 'action', service: 'foo' })
-      const callback2 = jasmine.createSpy().and.returnValue(undefined)
-
-      hooks.register(HookNames.Assemble, callback1)
-      hooks.register(HookNames.Assemble, callback2)
-
-      const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, hookParams)
-
-      expect(defaultRumEventAttributes).toEqual({ type: 'action', service: 'foo' })
-      expect(callback1).toHaveBeenCalled()
-      expect(callback2).toHaveBeenCalled()
-    })
-
-    it('returns DISCARDED if one callbacks returns DISCARDED', () => {
-      const callback1 = jasmine.createSpy().and.returnValue({ type: 'action', service: 'foo' })
-      const callback2 = jasmine.createSpy().and.returnValue(DISCARDED)
-      const callback3 = jasmine.createSpy().and.returnValue({ type: 'action', version: 'bar' })
-
-      hooks.register(HookNames.Assemble, callback1)
-      hooks.register(HookNames.Assemble, callback2)
-      hooks.register(HookNames.Assemble, callback3)
-
-      const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, hookParams)
-
-      expect(defaultRumEventAttributes).toEqual(DISCARDED)
-      expect(callback1).toHaveBeenCalled()
-      expect(callback2).toHaveBeenCalled()
-      expect(callback3).not.toHaveBeenCalled()
-    })
-
-    it('returns undefined when no registered hooks', () => {
-      const result = hooks.triggerHook(HookNames.Assemble, hookParams)
-      expect(result).toBeUndefined()
-    })
-  })
-})

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/abstractLifeCycle.spec.ts

@@ -1,46 +0,0 @@
-import { AbstractLifeCycle } from './abstractLifeCycle'
-
-describe('AbstractLifeCycle', () => {
-  const LifeCycle = AbstractLifeCycle<{
-    foo: 'bar'
-    no_data: void
-  }>
-
-  it('does nothing when notifying without subscribers', () => {
-    const lifeCycle = new LifeCycle()
-    expect(() => lifeCycle.notify('foo', 'bar')).not.toThrow()
-  })
-
-  it('notifies subscribers', () => {
-    const lifeCycle = new LifeCycle()
-    const subscriber1Spy = jasmine.createSpy()
-    const subscriber2Spy = jasmine.createSpy()
-    lifeCycle.subscribe('foo', subscriber1Spy)
-    lifeCycle.subscribe('foo', subscriber2Spy)
-
-    lifeCycle.notify('foo', 'bar')
-
-    expect(subscriber1Spy).toHaveBeenCalledOnceWith('bar')
-    expect(subscriber2Spy).toHaveBeenCalledOnceWith('bar')
-  })
-
-  it('notifies subscribers for events without data', () => {
-    const lifeCycle = new LifeCycle()
-    const subscriberSpy = jasmine.createSpy()
-    lifeCycle.subscribe('no_data', subscriberSpy)
-
-    lifeCycle.notify('no_data')
-
-    expect(subscriberSpy).toHaveBeenCalledOnceWith(undefined)
-  })
-
-  it('does not notify unsubscribed subscribers', () => {
-    const lifeCycle = new LifeCycle()
-    const subscriberSpy = jasmine.createSpy()
-    lifeCycle.subscribe('foo', subscriberSpy).unsubscribe()
-
-    lifeCycle.notify('foo', 'bar')
-
-    expect(subscriberSpy).not.toHaveBeenCalled()
-  })
-})

package/src/tools/boundedBuffer.spec.ts

@@ -1,40 +0,0 @@
-import { createBoundedBuffer } from './boundedBuffer'
-
-describe('BoundedBuffer', () => {
-  it('collect and drain the callbacks', () => {
-    const spy = jasmine.createSpy<() => void>()
-    const buffered = createBoundedBuffer()
-
-    buffered.add(spy)
-    expect(spy.calls.count()).toBe(0)
-
-    buffered.drain()
-    expect(spy.calls.count()).toBe(1)
-
-    buffered.drain()
-    expect(spy.calls.count()).toBe(1)
-  })
-
-  it('store at most 500 callbacks', () => {
-    const spy = jasmine.createSpy<() => void>()
-    const buffered = createBoundedBuffer()
-    const limit = 500
-
-    for (let i = 0; i < limit + 1; i += 1) {
-      buffered.add(spy)
-    }
-
-    buffered.drain()
-    expect(spy.calls.count()).toEqual(limit)
-  })
-
-  it('removes a callback', () => {
-    const spy = jasmine.createSpy<() => void>()
-    const buffered = createBoundedBuffer()
-
-    buffered.add(spy)
-    buffered.remove(spy)
-    buffered.drain()
-    expect(spy).not.toHaveBeenCalled()
-  })
-})

package/src/tools/boundedBuffer.ts

@@ -1,45 +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/catchUserErrors.spec.ts

@@ -1,20 +0,0 @@
-import { catchUserErrors } from './catchUserErrors'
-import { display } from './display'
-
-describe('catchUserErrors', () => {
-  it('returns the same result as the original function', () => {
-    const wrappedFn = catchUserErrors((a: number, b: number) => a + b, 'Error during callback')
-    expect(wrappedFn(10, 2)).toBe(12)
-  })
-
-  it('logs errors using console.error and returns undefined', () => {
-    const displaySpy = spyOn(display, 'error')
-    const myError = 'Ooops!'
-    const wrappedFn = catchUserErrors(() => {
-      // eslint-disable-next-line @typescript-eslint/only-throw-error
-      throw myError
-    }, 'Error during callback')
-    expect(wrappedFn()).toBe(undefined)
-    expect(displaySpy).toHaveBeenCalledWith('Error during callback', myError)
-  })
-})

package/src/tools/encoder.spec.ts

@@ -1,112 +0,0 @@
-import { createIdentityEncoder } from './encoder'
-import { noop } from './utils/functionUtils'
-
-describe('createIdentityEncoder', () => {
-  it('creates an encoder with initial values', () => {
-    const encoder = createIdentityEncoder()
-
-    expect(encoder.isEmpty).toBe(true)
-    expect(encoder.finishSync()).toEqual({
-      output: '',
-      outputBytesCount: 0,
-      rawBytesCount: 0,
-      pendingData: '',
-    })
-  })
-
-  describe('write()', () => {
-    it('writes data to the encoder', () => {
-      const encoder = createIdentityEncoder()
-      const data = 'Hello, world!'
-
-      encoder.write(data)
-
-      expect(encoder.isEmpty).toBe(false)
-    })
-
-    it('calls the callback when writing data with a callback', () => {
-      const encoder = createIdentityEncoder()
-      const data = 'Callback test'
-      const callbackSpy = jasmine.createSpy()
-
-      encoder.write(data, callbackSpy)
-
-      expect(callbackSpy).toHaveBeenCalledOnceWith(data.length)
-    })
-  })
-
-  describe('finish()', () => {
-    it('calls the callback with the result', () => {
-      const encoder = createIdentityEncoder()
-      const data = 'Final data'
-      encoder.write(data)
-      const callbackSpy = jasmine.createSpy()
-
-      encoder.finish(callbackSpy)
-
-      expect(callbackSpy).toHaveBeenCalledWith({
-        output: data,
-        outputBytesCount: data.length,
-        rawBytesCount: data.length,
-        pendingData: '',
-      })
-    })
-
-    it('after calling finish(), the encoder should be considered empty', () => {
-      const encoder = createIdentityEncoder()
-      encoder.write('Some data')
-
-      encoder.finish(noop)
-
-      expect(encoder.isEmpty).toBe(true)
-      expect(encoder.finishSync()).toEqual({
-        output: '',
-        outputBytesCount: 0,
-        rawBytesCount: 0,
-        pendingData: '',
-      })
-    })
-  })
-
-  describe('finishSync()', () => {
-    it('returns the encoder result', () => {
-      const encoder = createIdentityEncoder()
-      const data = 'Hello, world!'
-
-      encoder.write(data)
-
-      expect(encoder.finishSync()).toEqual({
-        output: data,
-        outputBytesCount: data.length,
-        rawBytesCount: data.length,
-        pendingData: '',
-      })
-    })
-
-    it('after calling finish(), the encoder should be considered empty', () => {
-      const encoder = createIdentityEncoder()
-      encoder.write('Some data')
-
-      encoder.finishSync()
-
-      expect(encoder.isEmpty).toBe(true)
-      expect(encoder.finishSync()).toEqual({
-        output: '',
-        outputBytesCount: 0,
-        rawBytesCount: 0,
-        pendingData: '',
-      })
-    })
-  })
-
-  describe('estimateEncodedBytesCount()', () => {
-    it('estimates encoded bytes count accurately', () => {
-      const encoder = createIdentityEncoder()
-      const data = 'Estimation test'
-
-      const estimatedBytes = encoder.estimateEncodedBytesCount(data)
-
-      expect(estimatedBytes).toBe(data.length)
-    })
-  })
-})

package/src/tools/experimentalFeatures.spec.ts

@@ -1,60 +0,0 @@
-import {
-  ExperimentalFeature,
-  addExperimentalFeatures,
-  initFeatureFlags,
-  isExperimentalFeatureEnabled,
-  resetExperimentalFeatures,
-} from './experimentalFeatures'
-
-const TEST_FEATURE_FLAG_ONE = 'foo' as ExperimentalFeature
-const TEST_FEATURE_FLAG_TWO = 'bar' as ExperimentalFeature
-
-describe('experimentalFeatures', () => {
-  afterEach(() => {
-    resetExperimentalFeatures()
-  })
-
-  it('initial state is empty', () => {
-    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeFalse()
-    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_TWO)).toBeFalse()
-  })
-
-  it('should define enabled experimental features', () => {
-    addExperimentalFeatures([TEST_FEATURE_FLAG_ONE])
-    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeTrue()
-    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_TWO)).toBeFalse()
-  })
-
-  it('should allow to be shared between products', () => {
-    addExperimentalFeatures([TEST_FEATURE_FLAG_ONE])
-    addExperimentalFeatures([TEST_FEATURE_FLAG_TWO])
-
-    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeTrue()
-    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_TWO)).toBeTrue()
-  })
-})
-
-describe('initFeatureFlags', () => {
-  beforeEach(() => {
-    ;(ExperimentalFeature as any).FOO = TEST_FEATURE_FLAG_ONE
-  })
-
-  afterEach(() => {
-    delete (ExperimentalFeature as any).FOO
-    resetExperimentalFeatures()
-  })
-
-  it('ignores unknown experimental features', () => {
-    initFeatureFlags(['bar', undefined as any, null as any, 11 as any])
-
-    expect(isExperimentalFeatureEnabled('bar' as any)).toBeFalse()
-    expect(isExperimentalFeatureEnabled(undefined as any)).toBeFalse()
-    expect(isExperimentalFeatureEnabled(null as any)).toBeFalse()
-    expect(isExperimentalFeatureEnabled(11 as any)).toBeFalse()
-  })
-
-  it('updates experimental feature flags', () => {
-    initFeatureFlags(['foo'])
-    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeTrue()
-  })
-})

package/src/tools/getZoneJsOriginalValue.spec.ts

@@ -1,36 +0,0 @@
-import { mockZoneJs } from '../../test'
-
-import type { BrowserWindowWithZoneJs } from './getZoneJsOriginalValue'
-import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
-import { noop } from './utils/functionUtils'
-
-describe('getZoneJsOriginalValue', () => {
-  function originalValue() {
-    // just a function that does nothing but different than 'noop' as we'll want to differentiate
-    // them.
-  }
-  const object = {
-    name: originalValue,
-  }
-
-  it('returns the original value directly if Zone is not not defined', () => {
-    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
-  })
-
-  it("returns the original value if Zone is defined but didn't patch that method", () => {
-    mockZoneJs()
-    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
-  })
-
-  it('returns the original value if Zone is defined but does not define the __symbol__ function', () => {
-    mockZoneJs()
-    delete (window as BrowserWindowWithZoneJs).Zone!.__symbol__
-    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
-  })
-
-  it('returns the original value if Zone did patch the method', () => {
-    const zoneJs = mockZoneJs()
-    zoneJs.replaceProperty(object, 'name', noop)
-    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
-  })
-})