@posthog/core 1.1.0 → 1.2.0

package/src/__tests__/posthog.listeners.spec.ts

@@ -0,0 +1,51 @@
+import { waitForPromises, createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  let mocks: PostHogCoreTestClientMocks
+
+  jest.useFakeTimers()
+  jest.setSystemTime(new Date('2022-01-01'))
+
+  beforeEach(() => {
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 10 })
+  })
+
+  describe('on', () => {
+    it('should listen to various events', () => {
+      const mock = jest.fn()
+      const mockOther = jest.fn()
+      posthog.on('identify', mock)
+      posthog.on('identify', mockOther)
+
+      posthog.identify('user-1')
+      expect(mock).toHaveBeenCalledTimes(1)
+      expect(mockOther).toHaveBeenCalledTimes(1)
+      expect(mock.mock.lastCall[0]).toMatchObject({ type: 'identify' })
+    })
+
+    it('should unsubscribe when called', () => {
+      const mock = jest.fn()
+      const unsubscribe = posthog.on('identify', mock)
+
+      posthog.identify('user-1')
+      expect(mock).toHaveBeenCalledTimes(1)
+      posthog.identify('user-1')
+      expect(mock).toHaveBeenCalledTimes(2)
+      unsubscribe()
+      posthog.identify('user-1')
+      expect(mock).toHaveBeenCalledTimes(2)
+    })
+
+    it('should subscribe to flush events', async () => {
+      const mock = jest.fn()
+      posthog.on('flush', mock)
+      posthog.capture('event')
+      expect(mock).toHaveBeenCalledTimes(0)
+      jest.runOnlyPendingTimers()
+      await waitForPromises()
+      expect(mock).toHaveBeenCalledTimes(1)
+    })
+  })
+})

package/src/__tests__/posthog.register.spec.ts

@@ -0,0 +1,47 @@
+import { PostHogPersistedProperty } from '@/types'
+import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  let mocks: PostHogCoreTestClientMocks
+
+  const getEnrichedProperties = (): any => {
+    // NOTE: Hacky override so we can just test the props functionality
+    return (posthog as any).enrichProperties()
+  }
+
+  beforeEach(() => {
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', {})
+  })
+
+  describe('register', () => {
+    it('should register properties to storage', () => {
+      posthog.register({ foo: 'bar' })
+      expect(getEnrichedProperties()).toMatchObject({ foo: 'bar' })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Props)).toEqual({ foo: 'bar' })
+      posthog.register({ foo2: 'bar2' })
+      expect(getEnrichedProperties()).toMatchObject({ foo: 'bar', foo2: 'bar2' })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Props)).toEqual({ foo: 'bar', foo2: 'bar2' })
+    })
+
+    it('should unregister properties from storage', () => {
+      posthog.register({ foo: 'bar', foo2: 'bar2' })
+      posthog.unregister('foo')
+      expect(getEnrichedProperties().foo).toBeUndefined()
+      expect(getEnrichedProperties().foo2).toEqual('bar2')
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Props)).toEqual({ foo2: 'bar2' })
+    })
+
+    it('should register properties only for the session', () => {
+      posthog.registerForSession({ foo: 'bar' })
+      expect(getEnrichedProperties()).toMatchObject({ foo: 'bar' })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Props)).toEqual(undefined)
+
+      posthog.register({ foo: 'bar2' })
+      expect(getEnrichedProperties()).toMatchObject({ foo: 'bar' })
+      posthog.unregisterForSession('foo')
+      expect(getEnrichedProperties()).toMatchObject({ foo: 'bar2' })
+    })
+  })
+})

package/src/__tests__/posthog.reset.spec.ts

@@ -0,0 +1,76 @@
+import { PostHogPersistedProperty } from '@/types'
+import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  let mocks: PostHogCoreTestClientMocks
+
+  beforeEach(() => {
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', {})
+  })
+
+  describe('reset', () => {
+    it('should reset the storage when called', () => {
+      const distinctId = posthog.getDistinctId()
+      posthog.overrideFeatureFlag({
+        foo: 'bar',
+      })
+      posthog.register({
+        prop: 1,
+      })
+
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.AnonymousId)).toEqual(distinctId)
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags)).toEqual({ foo: 'bar' })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Props)).toEqual({ prop: 1 })
+
+      posthog.reset()
+
+      expect(posthog.getDistinctId()).not.toEqual(distinctId)
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags)).toEqual(undefined)
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Props)).toEqual(undefined)
+    })
+
+    it("shouldn't reset the events capture queue", async () => {
+      posthog.getDistinctId()
+      posthog.capture('custom-event')
+
+      const expectedQueue = [
+        {
+          message: expect.objectContaining({
+            event: 'custom-event',
+            library: 'posthog-core-tests',
+          }),
+        },
+      ]
+
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Queue)).toEqual(expectedQueue)
+      posthog.reset()
+
+      const newDistinctId = posthog.getDistinctId()
+
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Queue)).toEqual(expectedQueue)
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.AnonymousId)).toEqual(newDistinctId)
+    })
+
+    it('should not reset specific props when set', () => {
+      const distinctId = posthog.getDistinctId()
+      posthog.overrideFeatureFlag({
+        foo: 'bar',
+      })
+      posthog.register({
+        prop: 1,
+      })
+
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.AnonymousId)).toEqual(distinctId)
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags)).toEqual({ foo: 'bar' })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Props)).toEqual({ prop: 1 })
+
+      posthog.reset([PostHogPersistedProperty.OverrideFeatureFlags])
+
+      expect(posthog.getDistinctId()).not.toEqual(distinctId)
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags)).toEqual({ foo: 'bar' })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.Props)).toEqual(undefined)
+    })
+  })
+})

package/src/__tests__/posthog.sessions.spec.ts

@@ -0,0 +1,63 @@
+import { PostHogPersistedProperty } from '@/types'
+import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  let mocks: PostHogCoreTestClientMocks
+
+  jest.useFakeTimers()
+  jest.setSystemTime(new Date('2022-01-01T12:00:00'))
+
+  beforeEach(() => {
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 1 })
+  })
+
+  describe('sessions', () => {
+    it('should create a sessionId if not set', () => {
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.SessionId)).toEqual(undefined)
+      posthog.capture('test')
+      expect(mocks.storage.setItem).toHaveBeenCalledWith(PostHogPersistedProperty.SessionId, expect.any(String))
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.SessionId)).toEqual(expect.any(String))
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp)).toEqual(Date.now())
+    })
+
+    it('should re-use existing sessionId', () => {
+      posthog.setPersistedProperty(PostHogPersistedProperty.SessionId, 'test-session-id')
+      const now = Date.now()
+      posthog.setPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp, now)
+      posthog.setPersistedProperty(PostHogPersistedProperty.SessionStartTimestamp, now)
+      posthog.capture('test')
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.SessionId)).toEqual('test-session-id')
+    })
+
+    it('should generate new sessionId if expired', () => {
+      jest.setSystemTime(new Date('2022-01-01T12:00:00'))
+      posthog.capture('test')
+      const sessionId = posthog.getPersistedProperty(PostHogPersistedProperty.SessionId)
+
+      // Check 29 minutes later
+      jest.setSystemTime(new Date('2022-01-01T12:29:00'))
+      posthog.capture('test')
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.SessionId)).toEqual(sessionId)
+
+      // Check another 29 minutes later
+      jest.setSystemTime(new Date('2022-01-01T12:58:00'))
+      posthog.capture('test')
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.SessionId)).toEqual(sessionId)
+
+      // Check more than 30 minutes later
+      jest.setSystemTime(new Date('2022-01-01T13:30:00'))
+      posthog.capture('test')
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.SessionId)).not.toEqual(sessionId)
+    })
+
+    it('should reset sessionId if called', () => {
+      posthog.capture('test')
+      const sessionId = posthog.getPersistedProperty(PostHogPersistedProperty.SessionId)
+
+      posthog.resetSessionId()
+      posthog.capture('test2')
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.SessionId)).not.toEqual(sessionId)
+    })
+  })
+})

package/src/__tests__/posthog.setProperties.spec.ts

@@ -0,0 +1,102 @@
+import { PostHogPersistedProperty } from '@/types'
+import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  let mocks: PostHogCoreTestClientMocks
+
+  jest.useFakeTimers()
+  jest.setSystemTime(new Date('2022-01-01'))
+
+  beforeEach(() => {
+    ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 1 })
+  })
+
+  describe('setGroupPropertiesForFlags', () => {
+    it('should store setGroupPropertiesForFlags as persisted with group_properties key', () => {
+      const props = { organisation: { name: 'bar' }, project: { name: 'baz' } }
+      posthog.setGroupPropertiesForFlags(props)
+
+      expect(mocks.storage.setItem).toHaveBeenCalledWith('group_properties', props)
+
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.GroupProperties)).toEqual(props)
+    })
+
+    it('should update setGroupPropertiesForFlags appropriately', () => {
+      const props = { organisation: { name: 'bar' }, project: { name: 'baz' } }
+      posthog.setGroupPropertiesForFlags(props)
+
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.GroupProperties)).toEqual(props)
+
+      posthog.setGroupPropertiesForFlags({ organisation: { name: 'bar2' }, project: { name2: 'baz' } })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.GroupProperties)).toEqual({
+        organisation: { name: 'bar2' },
+        project: { name: 'baz', name2: 'baz' },
+      })
+
+      posthog.setGroupPropertiesForFlags({ organisation2: { name: 'bar' } })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.GroupProperties)).toEqual({
+        organisation: { name: 'bar2' },
+        project: { name: 'baz', name2: 'baz' },
+        organisation2: { name: 'bar' },
+      })
+    })
+
+    it('should clear setGroupPropertiesForFlags on reset', () => {
+      const props = { organisation: { name: 'bar' }, project: { name: 'baz' } }
+      posthog.setGroupPropertiesForFlags(props)
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.GroupProperties)).toEqual(props)
+
+      posthog.reset()
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.GroupProperties)).toEqual(undefined)
+
+      posthog.setGroupPropertiesForFlags(props)
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.GroupProperties)).toEqual(props)
+    })
+  })
+
+  describe('setPersonPropertiesForFlags', () => {
+    it('should store setPersonPropertiesForFlags as persisted with person_properties key', () => {
+      const props = { organisation: 'bar', project: 'baz' }
+      posthog.setPersonPropertiesForFlags(props)
+
+      expect(mocks.storage.setItem).toHaveBeenCalledWith('person_properties', props)
+
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.PersonProperties)).toEqual(props)
+    })
+
+    it('should update setPersonPropertiesForFlags appropriately', () => {
+      const props = { organisation: 'bar', project: 'baz' }
+      posthog.setPersonPropertiesForFlags(props)
+
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.PersonProperties)).toEqual(props)
+
+      posthog.setPersonPropertiesForFlags({ organisation: 'bar2', project2: 'baz' })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.PersonProperties)).toEqual({
+        organisation: 'bar2',
+        project: 'baz',
+        project2: 'baz',
+      })
+
+      posthog.setPersonPropertiesForFlags({ organisation2: 'bar' })
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.PersonProperties)).toEqual({
+        organisation: 'bar2',
+        project: 'baz',
+        project2: 'baz',
+        organisation2: 'bar',
+      })
+    })
+
+    it('should clear setPersonPropertiesForFlags on reset', () => {
+      const props = { organisation: 'bar', project: 'baz' }
+      posthog.setPersonPropertiesForFlags(props)
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.PersonProperties)).toEqual(props)
+
+      posthog.reset()
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.PersonProperties)).toEqual(undefined)
+
+      posthog.setPersonPropertiesForFlags(props)
+      expect(posthog.getPersistedProperty(PostHogPersistedProperty.PersonProperties)).toEqual(props)
+    })
+  })
+})

package/src/__tests__/posthog.shutdown.spec.ts

@@ -0,0 +1,88 @@
+import { createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
+
+describe('PostHog Core', () => {
+  let posthog: PostHogCoreTestClient
+  let mocks: PostHogCoreTestClientMocks
+
+  describe('shutdown', () => {
+    beforeEach(() => {
+      jest.useRealTimers()
+      ;[posthog, mocks] = createTestClient('TEST_API_KEY', {
+        flushAt: 10,
+        preloadFeatureFlags: false,
+      })
+    })
+
+    it('flush messsages once called', async () => {
+      for (let i = 0; i < 5; i++) {
+        posthog.capture('test-event')
+      }
+
+      await posthog.shutdown()
+      expect(mocks.fetch).toHaveBeenCalledTimes(1)
+    })
+
+    it('respects timeout', async () => {
+      mocks.fetch.mockImplementation(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1000))
+        console.log('FETCH RETURNED')
+        return {
+          status: 200,
+          text: () => Promise.resolve('ok'),
+          json: () => Promise.resolve({ status: 'ok' }),
+        }
+      })
+
+      posthog.capture('test-event')
+
+      await posthog
+        .shutdown(100)
+        .then(() => {
+          throw new Error('Should not resolve')
+        })
+        .catch((e) => {
+          expect(e).toEqual('Timeout while shutting down PostHog. Some events may not have been sent.')
+        })
+      expect(mocks.fetch).toHaveBeenCalledTimes(1)
+    })
+
+    it('return the same promise if called multiple times in parallel', async () => {
+      mocks.fetch.mockImplementation(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 1000))
+        return {
+          status: 200,
+          text: () => Promise.resolve('ok'),
+          json: () => Promise.resolve({ status: 'ok' }),
+        }
+      })
+
+      posthog.capture('test-event')
+
+      const p1 = posthog.shutdown(100)
+      const p2 = posthog.shutdown(100)
+      expect(p1).toEqual(p2)
+      await Promise.allSettled([p1, p2])
+      expect(mocks.fetch).toHaveBeenCalledTimes(1)
+    })
+
+    it('can handle being called multiple times in series (discouraged but some users will do this)', async () => {
+      mocks.fetch.mockImplementation(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        console.log('FETCH RETURNED')
+        return {
+          status: 200,
+          text: () => Promise.resolve('ok'),
+          json: () => Promise.resolve({ status: 'ok' }),
+        }
+      })
+
+      posthog.capture('test-event')
+      await posthog.shutdown()
+
+      posthog.capture('test-event')
+      await posthog.shutdown()
+
+      expect(mocks.fetch).toHaveBeenCalledTimes(2)
+    })
+  })
+})

package/src/__tests__/utils.spec.ts

@@ -0,0 +1,36 @@
+import { assert, removeTrailingSlash, currentISOTime, currentTimestamp } from '@/utils'
+
+describe('utils', () => {
+  describe('assert', () => {
+    it('should throw on falsey values', () => {
+      ;[false, '', null, undefined, 0, {}, []].forEach((x) => {
+        expect(() => assert(x, 'error')).toThrow('error')
+      })
+    })
+    it('should not throw on truthy value', () => {
+      expect(() => assert('string', 'error')).not.toThrow('error')
+    })
+  })
+  describe('removeTrailingSlash', () => {
+    it('should removeSlashes', () => {
+      expect(removeTrailingSlash('me////')).toEqual('me')
+      expect(removeTrailingSlash('me/wat///')).toEqual('me/wat')
+      expect(removeTrailingSlash('me/')).toEqual('me')
+      expect(removeTrailingSlash('/me')).toEqual('/me')
+    })
+  })
+  describe.skip('retriable', () => {
+    it('should do something', () => {})
+  })
+  describe('currentTimestamp', () => {
+    it('should get the timestamp', () => {
+      expect(currentTimestamp()).toEqual(Date.now())
+    })
+  })
+  describe('currentISOTime', () => {
+    it('should get the iso time', () => {
+      jest.setSystemTime(new Date('2022-01-01'))
+      expect(currentISOTime()).toEqual('2022-01-01T00:00:00.000Z')
+    })
+  })
+})

package/src/error-tracking/chunk-ids.ts

@@ -0,0 +1,58 @@
+// Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
+// Licensed under the MIT License
+
+import type { StackParser } from './types'
+
+type StackString = string
+type CachedResult = [string, string]
+
+type ChunkIdMapType = Record<string, string>
+
+let parsedStackResults: Record<StackString, CachedResult> | undefined
+let lastKeysCount: number | undefined
+let cachedFilenameChunkIds: ChunkIdMapType | undefined
+
+export function getFilenameToChunkIdMap(stackParser: StackParser): ChunkIdMapType | undefined {
+  const chunkIdMap = (globalThis as any)._posthogChunkIds as ChunkIdMapType | undefined
+  if (!chunkIdMap) {
+    return undefined
+  }
+
+  const chunkIdKeys = Object.keys(chunkIdMap)
+
+  if (cachedFilenameChunkIds && chunkIdKeys.length === lastKeysCount) {
+    return cachedFilenameChunkIds
+  }
+
+  lastKeysCount = chunkIdKeys.length
+
+  cachedFilenameChunkIds = chunkIdKeys.reduce<Record<string, string>>((acc, stackKey) => {
+    if (!parsedStackResults) {
+      parsedStackResults = {}
+    }
+
+    const result = parsedStackResults[stackKey]
+
+    if (result) {
+      acc[result[0]] = result[1]
+    } else {
+      const parsedStack = stackParser(stackKey)
+
+      for (let i = parsedStack.length - 1; i >= 0; i--) {
+        const stackFrame = parsedStack[i]
+        const filename = stackFrame?.filename
+        const chunkId = chunkIdMap[stackKey]
+
+        if (filename && chunkId) {
+          acc[filename] = chunkId
+          parsedStackResults[stackKey] = [filename, chunkId]
+          break
+        }
+      }
+    }
+
+    return acc
+  }, {})
+
+  return cachedFilenameChunkIds
+}

package/src/error-tracking/coercers/dom-exception-coercer.ts

@@ -0,0 +1,38 @@
+import { CoercingContext, ErrorTrackingCoercer, ExceptionLike } from '@/error-tracking/types'
+import { isBuiltin, isString } from '@/utils'
+
+export class DOMExceptionCoercer implements ErrorTrackingCoercer<DOMException> {
+  match(err: unknown): err is DOMException {
+    return this.isDOMException(err) || this.isDOMError(err)
+  }
+
+  coerce(err: DOMException, ctx: CoercingContext): ExceptionLike {
+    const hasStack = isString(err.stack)
+
+    return {
+      type: this.getType(err),
+      value: this.getValue(err),
+      stack: hasStack ? err.stack : undefined,
+      cause: err.cause ? ctx.next(err.cause) : undefined,
+      synthetic: false,
+    }
+  }
+
+  private getType(candidate: DOMException) {
+    return this.isDOMError(candidate) ? 'DOMError' : 'DOMException'
+  }
+
+  private getValue(err: DOMException) {
+    const name = err.name || (this.isDOMError(err) ? 'DOMError' : 'DOMException')
+    const message = err.message ? `${name}: ${err.message}` : name
+    return message
+  }
+
+  private isDOMException(err: unknown): err is DOMException {
+    return isBuiltin(err, 'DOMException')
+  }
+
+  private isDOMError(err: unknown): err is DOMException {
+    return isBuiltin(err, 'DOMError')
+  }
+}

package/src/error-tracking/coercers/error-coercer.ts

@@ -0,0 +1,36 @@
+import { isPlainError } from '@/utils'
+import { CoercingContext, ErrorTrackingCoercer, ExceptionLike } from '../types'
+
+export class ErrorCoercer implements ErrorTrackingCoercer<Error> {
+  match(err: unknown): err is Error {
+    return isPlainError(err)
+  }
+
+  coerce(err: Error, ctx: CoercingContext): ExceptionLike {
+    return {
+      type: this.getType(err),
+      value: this.getMessage(err, ctx),
+      stack: this.getStack(err),
+      cause: err.cause ? ctx.next(err.cause) : undefined,
+      synthetic: false,
+    }
+  }
+
+  private getType(err: Error): string {
+    return err.name || err.constructor.name
+  }
+
+  private getMessage(err: Error & { message: { error?: Error } }, _ctx: CoercingContext): string {
+    const message = err.message
+
+    if (message.error && typeof message.error.message === 'string') {
+      return String(message.error.message)
+    }
+
+    return String(message)
+  }
+
+  private getStack(err: Error & { stacktrace?: string }): string | undefined {
+    return err.stacktrace || err.stack || undefined
+  }
+}

package/src/error-tracking/coercers/error-event-coercer.ts

@@ -0,0 +1,24 @@
+import { CoercingContext, ErrorTrackingCoercer, ExceptionLike } from '../types'
+import { isErrorEvent } from '@/utils'
+
+export class ErrorEventCoercer implements ErrorTrackingCoercer<ErrorEvent> {
+  constructor() {}
+
+  match(err: unknown): err is ErrorEvent {
+    return isErrorEvent(err) && (err as ErrorEvent).error != undefined
+  }
+
+  coerce(err: ErrorEvent, ctx: CoercingContext): ExceptionLike {
+    const exceptionLike = ctx.apply(err.error)
+    if (!exceptionLike) {
+      return {
+        type: 'ErrorEvent',
+        value: err.message,
+        stack: ctx.syntheticException?.stack,
+        synthetic: true,
+      }
+    } else {
+      return exceptionLike
+    }
+  }
+}

package/src/error-tracking/coercers/event-coercer.ts

@@ -0,0 +1,19 @@
+import { isEvent } from '@/utils'
+import { CoercingContext, ErrorTrackingCoercer, ExceptionLike } from '../types'
+import { extractExceptionKeysForMessage } from './utils'
+
+export class EventCoercer implements ErrorTrackingCoercer<Event> {
+  match(err: unknown): err is Event {
+    return isEvent(err)
+  }
+
+  coerce(evt: Event, ctx: CoercingContext): ExceptionLike {
+    const constructorName = evt.constructor.name
+    return {
+      type: constructorName,
+      value: `${constructorName} captured as exception with keys: ${extractExceptionKeysForMessage(evt)}`,
+      stack: ctx.syntheticException?.stack,
+      synthetic: true,
+    }
+  }
+}

package/src/error-tracking/coercers/index.ts

@@ -0,0 +1,8 @@
+export * from './dom-exception-coercer'
+export * from './error-coercer'
+export * from './error-event-coercer'
+export * from './string-coercer'
+export * from './object-coercer'
+export * from './event-coercer'
+export * from './primitive-coercer'
+export * from './promise-rejection-event'