@posthog/core 1.2.1 → 1.2.3

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

@@ -1,237 +0,0 @@
-import { delay, waitForPromises, createTestClient, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
-import { PostHogPersistedProperty } from '@/types'
-
-describe('PostHog Core', () => {
-  let posthog: PostHogCoreTestClient
-  let mocks: PostHogCoreTestClientMocks
-
-  describe('flush', () => {
-    beforeEach(() => {
-      jest.useFakeTimers()
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', {
-        flushAt: 5,
-        fetchRetryCount: 3,
-        fetchRetryDelay: 100,
-        preloadFeatureFlags: false,
-      })
-    })
-
-    it("doesn't fail when queue is empty", async () => {
-      jest.useRealTimers()
-      await expect(posthog.flush()).resolves.not.toThrow()
-      expect(mocks.fetch).not.toHaveBeenCalled()
-    })
-
-    it('flush messages once called', async () => {
-      const successfulMessages: any[] = []
-
-      mocks.fetch.mockImplementation(async (_, options) => {
-        const batch = JSON.parse((options.body || '') as string).batch
-
-        successfulMessages.push(...batch)
-        return Promise.resolve({
-          status: 200,
-          text: () => Promise.resolve('ok'),
-          json: () => Promise.resolve({ status: 'ok' }),
-        })
-      })
-
-      posthog.capture('test-event-1')
-      posthog.capture('test-event-2')
-      posthog.capture('test-event-3')
-      expect(mocks.fetch).not.toHaveBeenCalled()
-      await expect(posthog.flush()).resolves.not.toThrow()
-      expect(mocks.fetch).toHaveBeenCalled()
-      expect(successfulMessages).toMatchObject([
-        { event: 'test-event-1' },
-        { event: 'test-event-2' },
-        { event: 'test-event-3' },
-      ])
-    })
-
-    it.each([400, 500])('responds with an error after retries with %s error', async (status) => {
-      mocks.fetch.mockImplementation(() => {
-        return Promise.resolve({
-          status: status,
-          text: async () => 'err',
-          json: async () => ({ status: 'err' }),
-        })
-      })
-      posthog.capture('test-event-1')
-
-      const time = Date.now()
-      jest.useRealTimers()
-      await expect(posthog.flush()).rejects.toHaveProperty('name', 'PostHogFetchHttpError')
-      expect(mocks.fetch).toHaveBeenCalledTimes(4)
-      expect(Date.now() - time).toBeGreaterThan(300)
-      expect(Date.now() - time).toBeLessThan(500)
-    })
-
-    it('responds with an error after retries with network error ', async () => {
-      mocks.fetch.mockImplementation(() => {
-        return Promise.reject(new Error('network problems'))
-      })
-      posthog.capture('test-event-1')
-
-      const time = Date.now()
-      jest.useRealTimers()
-      await expect(posthog.flush()).rejects.toHaveProperty('name', 'PostHogFetchNetworkError')
-      expect(mocks.fetch).toHaveBeenCalledTimes(4)
-      expect(Date.now() - time).toBeGreaterThan(300)
-      expect(Date.now() - time).toBeLessThan(500)
-    })
-
-    it('skips when client is disabled', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 2 })
-
-      posthog.capture('test-event-1')
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(0)
-      posthog.capture('test-event-2')
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(1)
-      posthog.optOut()
-      posthog.capture('test-event-3')
-      posthog.capture('test-event-4')
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(1)
-    })
-
-    it('does not get stuck in a loop when new events are added while flushing', async () => {
-      jest.useRealTimers()
-      mocks.fetch.mockImplementation(async () => {
-        posthog.capture('another-event')
-        await delay(10)
-        return Promise.resolve({
-          status: 200,
-          text: () => Promise.resolve('ok'),
-          json: () => Promise.resolve({ status: 'ok' }),
-        })
-      })
-
-      posthog.capture('test-event-1')
-      await posthog.flush()
-      expect(mocks.fetch).toHaveBeenCalledTimes(1)
-    })
-
-    it('should flush all events even if larger than batch size', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 10 })
-
-      const successfulMessages: any[] = []
-
-      mocks.fetch.mockImplementation(async (_, options) => {
-        const batch = JSON.parse((options.body || '') as string).batch
-
-        successfulMessages.push(...batch)
-        return Promise.resolve({
-          status: 200,
-          text: () => Promise.resolve('ok'),
-          json: () => Promise.resolve({ status: 'ok' }),
-        })
-      })
-
-      posthog['maxBatchSize'] = 2 // a bit contrived because usually maxBatchSize >= flushAt
-      posthog.capture('test-event-1')
-      posthog.capture('test-event-2')
-      posthog.capture('test-event-3')
-      posthog.capture('test-event-4')
-      await expect(posthog.flush()).resolves.not.toThrow()
-      expect(mocks.fetch).toHaveBeenCalledTimes(2)
-      expect(successfulMessages).toMatchObject([
-        { event: 'test-event-1' },
-        { event: 'test-event-2' },
-        { event: 'test-event-3' },
-        { event: 'test-event-4' },
-      ])
-    })
-
-    it('should reduce the batch size without dropping events if received 413', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 10 })
-      const successfulMessages: any[] = []
-
-      mocks.fetch.mockImplementation(async (_, options) => {
-        const batch = JSON.parse((options.body || '') as string).batch
-
-        if (batch.length > 1) {
-          return Promise.resolve({
-            status: 413,
-            text: () => Promise.resolve('Content Too Large'),
-            json: () => Promise.resolve({ status: 'Content Too Large' }),
-          })
-        } else {
-          successfulMessages.push(...batch)
-          return Promise.resolve({
-            status: 200,
-            text: () => Promise.resolve('ok'),
-            json: () => Promise.resolve({ status: 'ok' }),
-          })
-        }
-      })
-
-      posthog.capture('test-event-1')
-      posthog.capture('test-event-2')
-      posthog.capture('test-event-3')
-      posthog.capture('test-event-4')
-      await expect(posthog.flush()).resolves.not.toThrow()
-      expect(successfulMessages).toMatchObject([
-        { event: 'test-event-1' },
-        { event: 'test-event-2' },
-        { event: 'test-event-3' },
-        { event: 'test-event-4' },
-      ])
-      expect(mocks.fetch).toHaveBeenCalledTimes(6) // 2 failures with size 4 then 2, then 4 successes with size 1
-    })
-
-    it('should treat a 413 at batchSize 1 as a regular error', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 10 })
-
-      mocks.fetch.mockImplementation(async () => {
-        return Promise.resolve({
-          status: 413,
-          text: () => Promise.resolve('Content Too Large'),
-          json: () => Promise.resolve({ status: 'Content Too Large' }),
-        })
-      })
-
-      posthog.capture('test-event-1')
-      await expect(posthog.flush()).rejects.toHaveProperty('name', 'PostHogFetchHttpError')
-      expect(mocks.fetch).toHaveBeenCalledTimes(1)
-    })
-
-    it('should stop at first error', async () => {
-      jest.useRealTimers()
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 10, fetchRetryDelay: 1 })
-      posthog['maxBatchSize'] = 1 // a bit contrived because usually maxBatchSize >= flushAt
-      const successfulMessages: any[] = []
-
-      mocks.fetch.mockImplementation(async (_, options) => {
-        const batch = JSON.parse((options.body || '') as string).batch
-
-        if (batch.some((msg: any) => msg.event.includes('cursed'))) {
-          return Promise.resolve({
-            status: 500,
-            text: () => Promise.resolve('Cursed'),
-            json: () => Promise.resolve({ status: 'Cursed' }),
-          })
-        } else {
-          successfulMessages.push(...batch)
-          return Promise.resolve({
-            status: 200,
-            text: () => Promise.resolve('ok'),
-            json: () => Promise.resolve({ status: 'ok' }),
-          })
-        }
-      })
-
-      posthog.capture('test-event-1')
-      posthog.capture('cursed-event-2')
-      posthog.capture('test-event-3')
-
-      await expect(posthog.flush()).rejects.toHaveProperty('name', 'PostHogFetchHttpError')
-      expect(successfulMessages).toMatchObject([{ event: 'test-event-1' }])
-      expect(mocks.storage.getItem(PostHogPersistedProperty.Queue)).toMatchObject([
-        { message: { event: 'test-event-3' } },
-      ])
-    })
-  })
-})

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

@@ -1,50 +0,0 @@
-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
-
-  jest.useFakeTimers()
-
-  beforeEach(() => {
-    ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 5 })
-  })
-
-  describe('optOut', () => {
-    it('should be optedIn by default', async () => {
-      expect(posthog.optedOut).toEqual(false)
-    })
-
-    it('should be able to init disabled', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { defaultOptIn: false })
-      expect(posthog.optedOut).toEqual(true)
-    })
-
-    it('should opt in/out when called', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { defaultOptIn: false })
-      posthog.optOut()
-      expect(posthog.optedOut).toEqual(true)
-      posthog.optIn()
-      expect(posthog.optedOut).toEqual(false)
-    })
-
-    it('should persist enabled state when called', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { defaultOptIn: false })
-      expect(posthog.getPersistedProperty(PostHogPersistedProperty.OptedOut)).toEqual(undefined)
-      posthog.optOut()
-      expect(posthog.getPersistedProperty(PostHogPersistedProperty.OptedOut)).toEqual(true)
-      posthog.optIn()
-      expect(posthog.getPersistedProperty(PostHogPersistedProperty.OptedOut)).toEqual(false)
-    })
-
-    it('should start in the correct state', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { defaultOptIn: false }, (mocks) => {
-        mocks.storage.setItem(PostHogPersistedProperty.OptedOut, true)
-      })
-
-      expect(posthog.optedOut).toEqual(true)
-    })
-  })
-})

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

@@ -1,96 +0,0 @@
-import {
-  createTestClient,
-  PostHogCoreTestClient,
-  PostHogCoreTestClientMocks,
-  parseBody,
-  waitForPromises,
-} from '@/testing'
-
-describe('PostHog Core', () => {
-  let posthog: PostHogCoreTestClient
-  let mocks: PostHogCoreTestClientMocks
-
-  beforeEach(() => {
-    jest.useFakeTimers()
-    jest.setSystemTime(new Date('2022-01-01'))
-    ;[posthog, mocks] = createTestClient('TEST_API_KEY', { flushAt: 1 })
-  })
-
-  describe('groups', () => {
-    it('should store groups as persisted props', () => {
-      const groups = { posthog: 'team-1', other: 'key-2' }
-      posthog.groups(groups)
-
-      expect(mocks.storage.setItem).toHaveBeenCalledWith('props', {
-        $groups: groups,
-      })
-    })
-  })
-
-  describe('group', () => {
-    it('should store group as persisted props', () => {
-      const groups = { posthog: 'team-1' }
-      posthog.groups(groups)
-      posthog.group('other', 'foo')
-      posthog.group('posthog', 'team-2')
-
-      expect(mocks.storage.setItem).toHaveBeenCalledWith('props', {
-        $groups: {
-          posthog: 'team-2',
-          other: 'foo',
-        },
-      })
-    })
-
-    it('should call groupIdentify if including props', async () => {
-      posthog.group('other', 'team', { foo: 'bar' })
-      await waitForPromises()
-
-      expect(mocks.fetch).toHaveBeenCalledTimes(2) // 1 for flags, 1 for groupIdentify
-      const batchCall = mocks.fetch.mock.calls[1]
-      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
-      expect(parseBody(batchCall)).toMatchObject({
-        batch: [
-          {
-            event: '$groupidentify',
-            distinct_id: posthog.getDistinctId(),
-            properties: {
-              $group_type: 'other',
-              $group_key: 'team',
-              $group_set: { foo: 'bar' },
-            },
-            type: 'capture',
-          },
-        ],
-      })
-    })
-  })
-
-  describe('groupIdentify', () => {
-    it('should identify group', async () => {
-      posthog.groupIdentify('posthog', 'team-1', { analytics: true })
-      await waitForPromises()
-
-      expect(parseBody(mocks.fetch.mock.calls[0])).toMatchObject({
-        api_key: 'TEST_API_KEY',
-        batch: [
-          {
-            event: '$groupidentify',
-            distinct_id: posthog.getDistinctId(),
-            library: 'posthog-core-tests',
-            library_version: '2.0.0-alpha',
-            properties: {
-              $lib: 'posthog-core-tests',
-              $lib_version: '2.0.0-alpha',
-              $group_type: 'posthog',
-              $group_key: 'team-1',
-              $group_set: { analytics: true },
-            },
-            timestamp: '2022-01-01T00:00:00.000Z',
-            type: 'capture',
-          },
-        ],
-      })
-    })
-  })
-})

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

@@ -1,194 +0,0 @@
-import {
-  parseBody,
-  waitForPromises,
-  createTestClient,
-  PostHogCoreTestClient,
-  PostHogCoreTestClientMocks,
-} from '@/testing'
-import { PostHogPersistedProperty } from '@/types'
-
-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('identify', () => {
-    // Identify also triggers a subsequent flags call so we should expect 2 calls
-    it('should send an $identify event', async () => {
-      posthog.identify('id-1', { foo: 'bar' })
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(2)
-      const batchCall = mocks.fetch.mock.calls[1]
-      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
-      expect(parseBody(batchCall)).toMatchObject({
-        api_key: 'TEST_API_KEY',
-        batch: [
-          {
-            event: '$identify',
-            distinct_id: posthog.getDistinctId(),
-            library: 'posthog-core-tests',
-            library_version: '2.0.0-alpha',
-            properties: {
-              $lib: 'posthog-core-tests',
-              $lib_version: '2.0.0-alpha',
-              $anon_distinct_id: expect.any(String),
-              $session_id: expect.any(String),
-              $set: {
-                foo: 'bar',
-              },
-            },
-            timestamp: expect.any(String),
-            uuid: expect.any(String),
-            type: 'identify',
-          },
-        ],
-        sent_at: expect.any(String),
-      })
-    })
-
-    it('should send an $identify with $set and $set_once event', async () => {
-      posthog.identify('id-1', {
-        $set: {
-          foo: 'bar',
-        },
-        $set_once: {
-          vip: true,
-        },
-      })
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(2)
-      const batchCall = mocks.fetch.mock.calls[1]
-      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
-      expect(parseBody(batchCall)).toMatchObject({
-        api_key: 'TEST_API_KEY',
-        batch: [
-          {
-            event: '$identify',
-            distinct_id: posthog.getDistinctId(),
-            library: 'posthog-core-tests',
-            library_version: '2.0.0-alpha',
-            properties: {
-              $lib: 'posthog-core-tests',
-              $lib_version: '2.0.0-alpha',
-              $anon_distinct_id: expect.any(String),
-              $session_id: expect.any(String),
-              $set: {
-                foo: 'bar',
-              },
-              $set_once: {
-                vip: true,
-              },
-            },
-            timestamp: expect.any(String),
-            uuid: expect.any(String),
-            type: 'identify',
-          },
-        ],
-        sent_at: expect.any(String),
-      })
-    })
-
-    it('should send an $identify with $set_once event', async () => {
-      posthog.identify('id-1', {
-        foo: 'bar',
-        $set_once: {
-          vip: true,
-        },
-      })
-      await waitForPromises()
-      expect(mocks.fetch).toHaveBeenCalledTimes(2)
-      const batchCall = mocks.fetch.mock.calls[1]
-      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
-      expect(parseBody(batchCall)).toMatchObject({
-        api_key: 'TEST_API_KEY',
-        batch: [
-          {
-            event: '$identify',
-            distinct_id: posthog.getDistinctId(),
-            library: 'posthog-core-tests',
-            library_version: '2.0.0-alpha',
-            properties: {
-              $lib: 'posthog-core-tests',
-              $lib_version: '2.0.0-alpha',
-              $anon_distinct_id: expect.any(String),
-              $session_id: expect.any(String),
-              $set: {
-                foo: 'bar',
-              },
-              $set_once: {
-                vip: true,
-              },
-            },
-            timestamp: expect.any(String),
-            uuid: expect.any(String),
-            type: 'identify',
-          },
-        ],
-        sent_at: expect.any(String),
-      })
-    })
-
-    it('should include anonymous ID if set', async () => {
-      posthog.identify('id-1', { foo: 'bar' })
-      await waitForPromises()
-
-      expect(mocks.fetch).toHaveBeenCalledTimes(2)
-      const batchCall = mocks.fetch.mock.calls[1]
-      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
-      expect(parseBody(batchCall)).toMatchObject({
-        batch: [
-          {
-            distinct_id: posthog.getDistinctId(),
-            properties: {
-              $anon_distinct_id: expect.any(String),
-            },
-          },
-        ],
-      })
-    })
-
-    it('should update distinctId if different', () => {
-      const distinctId = posthog.getDistinctId()
-      posthog.identify('id-1', { foo: 'bar' })
-
-      expect(mocks.storage.setItem).toHaveBeenCalledWith('anonymous_id', distinctId)
-      expect(mocks.storage.setItem).toHaveBeenCalledWith('distinct_id', 'id-1')
-    })
-
-    it('should use existing distinctId from storage', async () => {
-      mocks.storage.setItem(PostHogPersistedProperty.AnonymousId, 'my-old-value')
-      mocks.storage.setItem.mockClear()
-      posthog.identify('id-1', { foo: 'bar' })
-      await waitForPromises()
-
-      // One call exists for the queueing, one for persisting distinct id
-      expect(mocks.storage.setItem).toHaveBeenCalledWith('distinct_id', 'id-1')
-      expect(mocks.fetch).toHaveBeenCalledTimes(2)
-      const batchCall = mocks.fetch.mock.calls[1]
-      expect(batchCall[0]).toEqual('https://us.i.posthog.com/batch/')
-      expect(parseBody(batchCall)).toMatchObject({
-        batch: [
-          {
-            distinct_id: 'id-1',
-            properties: {
-              $anon_distinct_id: 'my-old-value',
-            },
-          },
-        ],
-      })
-    })
-
-    it('should not update stored properties if distinct_id the same', () => {
-      mocks.storage.setItem(PostHogPersistedProperty.DistinctId, 'id-1')
-      mocks.storage.setItem.mockClear()
-      posthog.identify('id-1', { foo: 'bar' })
-      expect(mocks.storage.setItem).not.toHaveBeenCalledWith('distinct_id', 'id-1')
-    })
-  })
-})

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

@@ -1,110 +0,0 @@
-import { createTestClient, waitForPromises, PostHogCoreTestClient, PostHogCoreTestClientMocks } from '@/testing'
-
-describe('PostHog Core', () => {
-  let posthog: PostHogCoreTestClient
-  let mocks: PostHogCoreTestClientMocks
-
-  beforeEach(() => {
-    ;[posthog, mocks] = createTestClient('TEST_API_KEY', {})
-  })
-
-  describe('init', () => {
-    it('should initialise', () => {
-      expect(posthog.optedOut).toEqual(false)
-    })
-
-    it('should throw if missing api key', () => {
-      expect(() => createTestClient(undefined as unknown as string)).toThrowError(
-        "You must pass your PostHog project's api key."
-      )
-    })
-
-    it('should throw if empty api key', () => {
-      expect(() => createTestClient('   ')).toThrowError("You must pass your PostHog project's api key.")
-    })
-
-    it('should throw if non string api key', () => {
-      expect(() => createTestClient({} as string)).toThrowError("You must pass your PostHog project's api key.")
-    })
-
-    it('should initialise default options', () => {
-      expect(posthog as any).toMatchObject({
-        apiKey: 'TEST_API_KEY',
-        host: 'https://us.i.posthog.com',
-        flushAt: 20,
-        flushInterval: 10000,
-      })
-    })
-
-    it('overwrites defaults with options', () => {
-      ;[posthog, mocks] = createTestClient('key', {
-        host: 'https://a.com',
-        flushAt: 1,
-        flushInterval: 2,
-      })
-
-      expect(posthog).toMatchObject({
-        apiKey: 'key',
-        host: 'https://a.com',
-        flushAt: 1,
-        flushInterval: 2,
-      })
-    })
-
-    it('should keep the flushAt option above zero', () => {
-      ;[posthog, mocks] = createTestClient('key', { flushAt: -2 }) as any
-      expect((posthog as any).flushAt).toEqual(1)
-    })
-
-    it('should remove trailing slashes from `host`', () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { host: 'http://my-posthog.com///' })
-
-      expect((posthog as any).host).toEqual('http://my-posthog.com')
-    })
-
-    it('should use bootstrapped distinct ID when present', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', { bootstrap: { distinctId: 'new_anon_id' } })
-
-      expect((posthog as any).getDistinctId()).toEqual('new_anon_id')
-      expect((posthog as any).getAnonymousId()).toEqual('new_anon_id')
-
-      await posthog.identify('random_id')
-
-      expect((posthog as any).getDistinctId()).toEqual('random_id')
-      expect((posthog as any).getAnonymousId()).toEqual('new_anon_id')
-    })
-
-    it('should use bootstrapped distinct ID as identified ID when present', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', {
-        bootstrap: { distinctId: 'new_id', isIdentifiedId: true },
-      })
-      jest.runOnlyPendingTimers()
-
-      expect((posthog as any).getDistinctId()).toEqual('new_id')
-      expect((posthog as any).getAnonymousId()).not.toEqual('new_id')
-
-      await posthog.identify('random_id')
-
-      expect((posthog as any).getDistinctId()).toEqual('random_id')
-      expect((posthog as any).getAnonymousId()).toEqual('new_id')
-    })
-  })
-
-  describe('disabled', () => {
-    it('should not send events when disabled', async () => {
-      ;[posthog, mocks] = createTestClient('TEST_API_KEY', {
-        disabled: true,
-        flushAt: 1,
-      })
-      jest.runOnlyPendingTimers()
-
-      expect(posthog.getFeatureFlags()).toEqual(undefined)
-      posthog.capture('test')
-      posthog.capture('identify')
-
-      await waitForPromises()
-
-      expect(mocks.fetch).not.toHaveBeenCalled()
-    })
-  })
-})