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

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

@@ -1,172 +0,0 @@
-import { display } from './display'
-import { callMonitored, monitor, monitored, startMonitorErrorCollection, resetMonitor, setDebugMode } from './monitor'
-
-describe('monitor', () => {
-  let onMonitorErrorCollectedSpy: jasmine.Spy<(error: unknown) => void>
-
-  beforeEach(() => {
-    onMonitorErrorCollectedSpy = jasmine.createSpy()
-  })
-  afterEach(() => {
-    resetMonitor()
-  })
-
-  describe('decorator', () => {
-    class Candidate {
-      @monitored
-      monitoredThrowing() {
-        throw new Error('monitored')
-      }
-
-      @monitored
-      monitoredStringErrorThrowing() {
-        // eslint-disable-next-line @typescript-eslint/only-throw-error
-        throw 'string error'
-      }
-
-      @monitored
-      monitoredObjectErrorThrowing() {
-        // eslint-disable-next-line @typescript-eslint/only-throw-error
-        throw { foo: 'bar' }
-      }
-
-      @monitored
-      monitoredNotThrowing() {
-        return 1
-      }
-
-      notMonitoredThrowing() {
-        throw new Error('not monitored')
-      }
-    }
-
-    let candidate: Candidate
-    beforeEach(() => {
-      candidate = new Candidate()
-    })
-
-    describe('before initialization', () => {
-      it('should not monitor', () => {
-        expect(() => candidate.notMonitoredThrowing()).toThrowError('not monitored')
-        expect(() => candidate.monitoredThrowing()).toThrowError('monitored')
-        expect(candidate.monitoredNotThrowing()).toEqual(1)
-      })
-    })
-
-    describe('after initialization', () => {
-      beforeEach(() => {
-        startMonitorErrorCollection(onMonitorErrorCollectedSpy)
-      })
-
-      it('should preserve original behavior', () => {
-        expect(candidate.monitoredNotThrowing()).toEqual(1)
-      })
-
-      it('should catch error', () => {
-        expect(() => candidate.notMonitoredThrowing()).toThrowError()
-        expect(() => candidate.monitoredThrowing()).not.toThrowError()
-      })
-
-      it('should report error', () => {
-        candidate.monitoredThrowing()
-
-        expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith(new Error('monitored'))
-      })
-
-      it('should report string error', () => {
-        candidate.monitoredStringErrorThrowing()
-
-        expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith('string error')
-      })
-
-      it('should report object error', () => {
-        candidate.monitoredObjectErrorThrowing()
-
-        expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith({ foo: 'bar' })
-      })
-    })
-  })
-
-  describe('function', () => {
-    const notThrowing = () => 1
-    const throwing = () => {
-      throw new Error('error')
-    }
-
-    beforeEach(() => {
-      startMonitorErrorCollection(onMonitorErrorCollectedSpy)
-    })
-
-    describe('direct call', () => {
-      it('should preserve original behavior', () => {
-        expect(callMonitored(notThrowing)).toEqual(1)
-      })
-
-      it('should catch error', () => {
-        expect(() => callMonitored(throwing)).not.toThrowError()
-      })
-
-      it('should report error', () => {
-        callMonitored(throwing)
-
-        expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith(new Error('error'))
-      })
-    })
-
-    describe('wrapper', () => {
-      it('should preserve original behavior', () => {
-        const decorated = monitor(notThrowing)
-        expect(decorated()).toEqual(1)
-      })
-
-      it('should catch error', () => {
-        const decorated = monitor(throwing)
-        expect(() => decorated()).not.toThrowError()
-      })
-
-      it('should report error', () => {
-        monitor(throwing)()
-
-        expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith(new Error('error'))
-      })
-    })
-  })
-
-  describe('setDebugMode', () => {
-    let displaySpy: jasmine.Spy
-
-    beforeEach(() => {
-      displaySpy = spyOn(display, 'error')
-    })
-
-    it('when not called, should not display error', () => {
-      callMonitored(() => {
-        throw new Error('message')
-      })
-
-      expect(displaySpy).not.toHaveBeenCalled()
-    })
-
-    it('when called, should display error', () => {
-      setDebugMode(true)
-
-      callMonitored(() => {
-        throw new Error('message')
-      })
-
-      expect(displaySpy).toHaveBeenCalledOnceWith('[MONITOR]', new Error('message'))
-    })
-
-    it('displays errors thrown by the onMonitorErrorCollected callback', () => {
-      setDebugMode(true)
-      onMonitorErrorCollectedSpy.and.throwError(new Error('unexpected'))
-      startMonitorErrorCollection(onMonitorErrorCollectedSpy)
-
-      callMonitored(() => {
-        throw new Error('message')
-      })
-      expect(displaySpy).toHaveBeenCalledWith('[MONITOR]', new Error('message'))
-      expect(displaySpy).toHaveBeenCalledWith('[MONITOR]', new Error('unexpected'))
-    })
-  })
-})

package/src/tools/observable.spec.ts

@@ -1,259 +0,0 @@
-import { waitNextMicrotask } from '../../test'
-import { BufferedObservable, mergeObservables, Observable } from './observable'
-
-describe('observable', () => {
-  let observable: Observable<void>
-  let subscriber: jasmine.Spy<jasmine.Func>
-
-  beforeEach(() => {
-    observable = new Observable()
-    subscriber = jasmine.createSpy('sub')
-  })
-
-  it('should allow to subscribe and be notified', () => {
-    observable.subscribe(subscriber)
-    expect(subscriber).not.toHaveBeenCalled()
-
-    observable.notify()
-    expect(subscriber).toHaveBeenCalledTimes(1)
-
-    observable.notify()
-    expect(subscriber).toHaveBeenCalledTimes(2)
-  })
-
-  it('should notify multiple clients', () => {
-    const otherSubscriber = jasmine.createSpy('sub2')
-    observable.subscribe(subscriber)
-    observable.subscribe(otherSubscriber)
-
-    observable.notify()
-
-    expect(subscriber).toHaveBeenCalled()
-    expect(otherSubscriber).toHaveBeenCalled()
-  })
-
-  it('should allow to unsubscribe', () => {
-    const subscription = observable.subscribe(subscriber)
-
-    subscription.unsubscribe()
-    observable.notify()
-
-    expect(subscriber).not.toHaveBeenCalled()
-  })
-
-  it('should execute onFirstSubscribe callback', () => {
-    const onFirstSubscribe = jasmine.createSpy('callback')
-    const otherSubscriber = jasmine.createSpy('sub2')
-    observable = new Observable(onFirstSubscribe)
-    expect(onFirstSubscribe).not.toHaveBeenCalled()
-
-    observable.subscribe(subscriber)
-    expect(onFirstSubscribe).toHaveBeenCalledTimes(1)
-
-    observable.subscribe(otherSubscriber)
-    expect(onFirstSubscribe).toHaveBeenCalledTimes(1)
-  })
-
-  it('should notify the first subscriber if the onFirstSubscribe callback notifies synchronously ', () => {
-    const onFirstSubscribe = jasmine.createSpy('callback').and.callFake((observable: Observable<void>) => {
-      observable.notify()
-    })
-    observable = new Observable(onFirstSubscribe)
-    observable.subscribe(subscriber)
-
-    expect(onFirstSubscribe).toHaveBeenCalledTimes(1)
-    expect(subscriber).toHaveBeenCalledTimes(1)
-  })
-
-  it('should pass the observable instance to the onFirstSubscribe callback', () => {
-    const onFirstSubscribe = jasmine.createSpy('callback')
-    observable = new Observable(onFirstSubscribe)
-    observable.subscribe(subscriber)
-
-    expect(onFirstSubscribe).toHaveBeenCalledWith(observable)
-  })
-
-  it('should execute onLastUnsubscribe callback', () => {
-    const onLastUnsubscribe = jasmine.createSpy('callback')
-    const otherSubscriber = jasmine.createSpy('sub2')
-    observable = new Observable(() => onLastUnsubscribe)
-    const subscription = observable.subscribe(subscriber)
-    const otherSubscription = observable.subscribe(otherSubscriber)
-    expect(onLastUnsubscribe).not.toHaveBeenCalled()
-
-    subscription.unsubscribe()
-    expect(onLastUnsubscribe).not.toHaveBeenCalled()
-
-    otherSubscription.unsubscribe()
-    expect(onLastUnsubscribe).toHaveBeenCalled()
-  })
-})
-
-describe('mergeObservables', () => {
-  let observableOne: Observable<void>
-  let observableTwo: Observable<void>
-  let mergedObservable: Observable<void>
-  let subscriber: jasmine.Spy<jasmine.Func>
-
-  beforeEach(() => {
-    observableOne = new Observable<void>()
-    observableTwo = new Observable<void>()
-    mergedObservable = mergeObservables(observableOne, observableTwo)
-    subscriber = jasmine.createSpy('subscriber')
-  })
-
-  it('should notify when one of the merged observable notifies', () => {
-    mergedObservable.subscribe(subscriber)
-    observableOne.notify()
-    observableTwo.notify()
-
-    expect(subscriber).toHaveBeenCalledTimes(2)
-  })
-
-  it('should allow to unsubscribe to all merged observables', () => {
-    const subscription = mergedObservable.subscribe(subscriber)
-
-    subscription.unsubscribe()
-    observableOne.notify()
-    observableTwo.notify()
-
-    expect(subscriber).not.toHaveBeenCalled()
-  })
-})
-
-describe('BufferedObservable', () => {
-  it('invokes the observer with buffered data', async () => {
-    const observable = new BufferedObservable<string>(100)
-    observable.notify('first')
-    observable.notify('second')
-
-    const observer = jasmine.createSpy('observer')
-    observable.subscribe(observer)
-
-    await waitNextMicrotask()
-
-    expect(observer).toHaveBeenCalledTimes(2)
-  })
-
-  it('invokes the observer asynchronously', async () => {
-    const observable = new BufferedObservable<string>(100)
-    observable.notify('first')
-
-    const observer = jasmine.createSpy('observer')
-    observable.subscribe(observer)
-
-    expect(observer).not.toHaveBeenCalled()
-
-    await waitNextMicrotask()
-
-    expect(observer).toHaveBeenCalledWith('first')
-  })
-
-  it('invokes the observer when new data is notified after subscription', async () => {
-    const observable = new BufferedObservable<string>(100)
-
-    const observer = jasmine.createSpy('observer')
-    observable.subscribe(observer)
-
-    observable.notify('first')
-
-    await waitNextMicrotask()
-
-    observable.notify('second')
-
-    expect(observer).toHaveBeenCalledTimes(2)
-    expect(observer).toHaveBeenCalledWith('first')
-    expect(observer).toHaveBeenCalledWith('second')
-  })
-
-  it('drops data when the buffer is full', async () => {
-    const observable = new BufferedObservable<string>(2)
-    observable.notify('first') // This should be dropped
-    observable.notify('second')
-    observable.notify('third')
-
-    const observer = jasmine.createSpy('observer')
-    observable.subscribe(observer)
-
-    await waitNextMicrotask()
-
-    expect(observer).toHaveBeenCalledTimes(2)
-    expect(observer).toHaveBeenCalledWith('second')
-    expect(observer).toHaveBeenCalledWith('third')
-  })
-
-  it('allows to unsubscribe from the observer, the middle of buffered data', async () => {
-    const observable = new BufferedObservable<string>(100)
-    observable.notify('first')
-    observable.notify('second')
-
-    const observer = jasmine.createSpy('observer').and.callFake(() => {
-      subscription.unsubscribe()
-    })
-    const subscription = observable.subscribe(observer)
-
-    await waitNextMicrotask()
-
-    expect(observer).toHaveBeenCalledTimes(1)
-  })
-
-  it('allows to unsubscribe before the buffered data', async () => {
-    const observable = new BufferedObservable<string>(100)
-    observable.notify('first')
-
-    const observer = jasmine.createSpy('observer')
-    const subscription = observable.subscribe(observer)
-
-    subscription.unsubscribe()
-
-    await waitNextMicrotask()
-
-    expect(observer).not.toHaveBeenCalled()
-  })
-
-  it('allows to unsubscribe after the buffered data', async () => {
-    const observable = new BufferedObservable<string>(100)
-
-    const observer = jasmine.createSpy('observer')
-    const subscription = observable.subscribe(observer)
-
-    await waitNextMicrotask()
-
-    subscription.unsubscribe()
-
-    observable.notify('first')
-
-    expect(observer).not.toHaveBeenCalled()
-  })
-
-  it('calling unbuffer() removes buffered data', async () => {
-    const observable = new BufferedObservable<string>(2)
-    observable.notify('first')
-    observable.notify('second')
-
-    observable.unbuffer()
-    await waitNextMicrotask()
-
-    const observer = jasmine.createSpy('observer')
-    observable.subscribe(observer)
-    await waitNextMicrotask()
-
-    expect(observer).not.toHaveBeenCalled()
-  })
-
-  it('when calling unbuffer() right after subscription, buffered data should still be notified', async () => {
-    const observable = new BufferedObservable<string>(2)
-    observable.notify('first')
-    observable.notify('second')
-
-    const observer = jasmine.createSpy('observer')
-    observable.subscribe(observer)
-
-    observable.unbuffer()
-    await waitNextMicrotask()
-
-    expect(observer).toHaveBeenCalledTimes(2)
-    expect(observer).toHaveBeenCalledWith('first')
-    expect(observer).toHaveBeenCalledWith('second')
-  })
-})

package/src/tools/queueMicrotask.spec.ts

@@ -1,24 +0,0 @@
-import { startMockTelemetry, waitNextMicrotask } from '../../test'
-import { queueMicrotask } from './queueMicrotask'
-
-describe('queueMicrotask', () => {
-  it('calls the callback in a microtask', async () => {
-    let called = false
-    queueMicrotask(() => {
-      called = true
-    })
-    expect(called).toBe(false)
-    await waitNextMicrotask()
-    expect(called).toBe(true)
-  })
-
-  it('monitors the callback', async () => {
-    const telemetry = startMockTelemetry()
-    queueMicrotask(() => {
-      throw new Error('test error')
-    })
-    await waitNextMicrotask()
-
-    expect(await telemetry.hasEvents()).toBe(true)
-  })
-})

package/src/tools/readBytesFromStream.spec.ts

@@ -1,62 +0,0 @@
-import { readBytesFromStream } from './readBytesFromStream'
-
-describe('readBytesFromStream', () => {
-  const str = 'Lorem ipsum dolor sit amet.'
-  let stream: ReadableStream
-
-  beforeEach(() => {
-    stream = new ReadableStream({
-      start: (controller) => {
-        controller.enqueue(new TextEncoder().encode(str))
-        controller.close()
-      },
-    })
-  })
-
-  it('should read full stream', async () => {
-    const bytes = await readBytesFromStream(stream, {
-      collectStreamBody: true,
-    })
-
-    expect(bytes?.length).toBe(27)
-  })
-
-  it('should read full stream without body', async () => {
-    const bytes = await readBytesFromStream(stream, {
-      collectStreamBody: false,
-    })
-    expect(bytes).toBeUndefined()
-  })
-
-  it('should handle rejection error on read', async () => {
-    const stream = new ReadableStream({
-      start: (controller) => {
-        controller.error(new Error('foo'))
-      },
-    })
-
-    try {
-      await readBytesFromStream(stream, {
-        collectStreamBody: true,
-      })
-      fail('Should have thrown an error')
-    } catch (error) {
-      expect(error).toEqual(jasmine.any(Error))
-    }
-  })
-
-  it('should handle rejection error on cancel', async () => {
-    const stream = new ReadableStream({
-      start: (controller) => {
-        controller.enqueue(new TextEncoder().encode('f'))
-        controller.close()
-      },
-      cancel: () => Promise.reject(new Error('foo')),
-    })
-
-    const bytes = await readBytesFromStream(stream, {
-      collectStreamBody: true,
-    })
-    expect(bytes).toBeDefined()
-  })
-})