posthog-react-native 1.1.5 → 2.0.0-alpha10

package/src/__tests__/configuration.spec.ts

@@ -1,79 +0,0 @@
-import { configure } from '../configuration'
-
-const apiKey = 'test-api-key'
-
-function withIntegrity<T extends {}>(config: T): T & { json: string } {
-	const json = JSON.stringify(config)
-
-	return {
-		...(config as any),
-		json
-	}
-}
-
-it('uses the default configuration', async () => {
-	expect(await configure(apiKey, {})).toEqual(
-		withIntegrity({
-			apiKey,
-			captureApplicationLifecycleEvents: false,
-			captureDeepLinks: false,
-			debug: false,
-			flushAt: 20,
-			flushInterval: 30,
-			host: 'https://app.posthog.com',
-			recordScreenViews: false,
-
-			android: {
-				collectDeviceId: true
-			},
-			ios: {
-				captureInAppPurchases: false,
-				capturePushNotifications: false,
-				maxQueueSize: 1000,
-				shouldUseBluetooth: false,
-				shouldUseLocationServices: false
-			}
-		})
-	)
-})
-
-it('produces a valid configuration', async () => {
-	const config = await configure(apiKey, {
-		captureApplicationLifecycleEvents: true,
-		debug: true,
-		flushAt: 42,
-		flushInterval: 72,
-		recordScreenViews: true,
-
-		android: {
-			collectDeviceId: false
-		},
-		ios: {
-			capturePushNotifications: true
-		}
-	})
-
-	expect(config).toEqual(
-		withIntegrity({
-			apiKey,
-			captureApplicationLifecycleEvents: true,
-			captureDeepLinks: false,
-			debug: true,
-			flushAt: 42,
-			flushInterval: 72,
-			host: 'https://app.posthog.com',
-			recordScreenViews: true,
-
-			android: {
-				collectDeviceId: false
-			},
-			ios: {
-				captureInAppPurchases: false,
-				capturePushNotifications: true,
-				maxQueueSize: 1000,
-				shouldUseBluetooth: false,
-				shouldUseLocationServices: false
-			}
-		})
-	)
-})

package/src/__tests__/index.spec.ts

@@ -1,7 +0,0 @@
-import posthog from '../index'
-import { PostHog } from '../posthog'
-
-jest.mock('../bridge')
-
-it('exports an instance of PostHog.Client', () =>
-	expect(posthog).toBeInstanceOf(PostHog.Client))

package/src/__tests__/posthog.spec.ts

@@ -1,108 +0,0 @@
-import mockConsole, { RestoreConsole } from 'jest-mock-console'
-
-import { PostHog } from '../posthog'
-import Bridge from '../bridge'
-
-jest.mock('../bridge')
-
-const nextTick = () => new Promise(resolve => setImmediate(resolve))
-const getBridgeStub = <K extends keyof typeof Bridge>(name: K): jest.Mock<(typeof Bridge)[K]> => (Bridge as any)[name]
-let posthog: PostHog.Client = null!
-let restoreConsole: RestoreConsole = null!
-
-beforeEach(async () => {
-	restoreConsole = mockConsole()
-	posthog = new PostHog.Client()
-	Object.keys(Bridge).forEach(key => getBridgeStub(key as any).mockClear())
-
-	await posthog.setup('api key')
-})
-
-afterEach(() => {
-	restoreConsole()
-})
-
-it('is ready', () => expect(posthog.ready).toBe(true))
-
-it('catches bridge errors', async () => {
-	const error = new Error('test-error')
-	const onError = jest.fn()
-
-	getBridgeStub('capture').mockImplementationOnce(() => Promise.reject(error) as any)
-	posthog.catch(onError)
-	posthog.capture('test')
-
-	expect(onError).not.toHaveBeenCalled()
-	await new Promise(resolve => setImmediate(resolve))
-	expect(onError).toHaveBeenCalledWith(error)
-})
-
-it('waits for .setup()', async () => {
-	const client = new PostHog.Client()
-
-	client.capture('test 1')
-	client.capture('test 2')
-
-	expect(Bridge.capture).not.toHaveBeenCalled()
-	await client.setup('key')
-
-	expect(Bridge.capture).toHaveBeenNthCalledWith(1, 'test 1')
-	expect(Bridge.capture).toHaveBeenNthCalledWith(2, 'test 2')
-})
-
-it('does .capture()', () => testCall('capture')('Added to cart', { productId: 'azertyuiop' }))
-
-it('does .screen()', () => testCall('screen')('Shopping cart', { from: 'Product page' }))
-
-it('does .identify()', () => testCall('identify')('sloth', { eats: 'leaves' }))
-
-it('does .identify() with null', () => testCall('identify')(null, { eats: 'leaves' }))
-
-it('does .alias()', () => testCall('alias')('new alias'))
-
-it('does .reset()', testCall('reset'))
-it('does .flush()', testCall('flush'))
-it('does .enable()', testCall('enable'))
-it('does .disable()', testCall('disable'))
-
-it('does .getAnonymousId()', testCall('getAnonymousId'))
-
-it('logs uncaught bridge errors', async () => {
-	const error = {
-		message: 'test-error'
-	}
-
-	getBridgeStub('capture').mockImplementationOnce(() => Promise.reject(error) as any)
-
-	expect(posthog.capture('test')).rejects.toBe(error)
-	expect(console.error).not.toHaveBeenCalled()
-	await nextTick()
-	expect(console.error).toHaveBeenCalledWith('Uncaught PostHog error', error)
-})
-
-function testCall<K extends keyof typeof Bridge>(name: K) {
-	return (async (...args: any[]) => {
-		posthog.constructor.prototype[name].call(posthog, ...args)
-		await nextTick()
-		expect(Bridge[name]).toHaveBeenNthCalledWith(1, ...args)
-	}) as (typeof Bridge)[K]
-}
-
-it('enables setting integrations from the middleware', async () => {
-	const integrations = {
-		'Google PostHog': false,
-		Mixpanel: { foo: 'bar' }
-	}
-
-	posthog.middleware(async ({ next, context, data }) =>
-		// @ts-ignore ts is expecting newId for some reasons
-		next(context, { ...data, integrations })
-	)
-
-	const captureSpy = jest.fn()
-	getBridgeStub('capture').mockImplementationOnce(captureSpy)
-	posthog.capture('test')
-	await nextTick()
-
-	expect(captureSpy).toBeCalledWith('test')
-})

package/src/bridge.ts

@@ -1,61 +0,0 @@
-import { NativeModules } from 'react-native'
-
-export interface Context extends JsonMap {
-	$lib: string
-	$lib_version: string
-}
-
-export interface Configuration {
-	apiKey: string
-	host: string
-	recordScreenViews: boolean
-	captureApplicationLifecycleEvents: boolean
-	captureDeepLinks?: boolean
-	flushAt?: number
-	flushInterval?: number
-	debug: boolean
-	json: string
-	context: Context
-	android: {
-		collectDeviceId?: boolean
-	}
-	ios: {
-		capturePushNotifications?: boolean
-		captureInAppPurchases?: boolean
-		maxQueueSize?: number
-		shouldUseBluetooth?: boolean
-		shouldUseLocationServices?: boolean
-	}
-}
-
-export type JsonValue = boolean | number | string | null | JsonList | JsonMap
-export interface JsonMap {
-	[key: string]: JsonValue
-	[index: number]: JsonValue
-}
-export interface JsonList extends Array<JsonValue> {}
-
-export interface Options {
-	context?: Context
-}
-
-export interface Bridge {
-	setup(configuration: Configuration): Promise<void>
-	capture(event: string, properties: JsonMap): Promise<void>
-	identify(distinctId: string | null, properties: JsonMap): Promise<void>
-	screen(screen: string, properties: JsonMap): Promise<void>
-	alias(alias: string): Promise<void>
-	reset(): Promise<void>
-	flush(): Promise<void>
-	enable(): Promise<void>
-	disable(): Promise<void>
-	getAnonymousId(): Promise<string>
-}
-
-const bridge: Bridge = NativeModules.RNPostHog
-
-if (!bridge) {
-	throw new Error('Failed to load PostHog native module.')
-}
-
-export default bridge

package/src/configuration.ts

@@ -1,61 +0,0 @@
-import { Configuration } from './bridge'
-import { PostHog } from './posthog'
-
-const defaults = {
-	android: ({ collectDeviceId = true }: Partial<Configuration['android']>) => ({
-		collectDeviceId
-	}),
-	ios: ({
-		capturePushNotifications = false,
-		captureInAppPurchases = false,
-		shouldUseBluetooth = false,
-		shouldUseLocationServices = false,
-		maxQueueSize = 1000
-	}: Partial<Configuration['ios']>) => ({
-		captureInAppPurchases,
-		capturePushNotifications,
-		maxQueueSize,
-		shouldUseBluetooth,
-		shouldUseLocationServices
-	})
-}
-
-export const configure = async (
-	apiKey: string,
-	{
-		flushAt = 20,
-		flushInterval = 30,
-		debug = false,
-		recordScreenViews = false,
-		captureApplicationLifecycleEvents = false,
-		captureDeepLinks = false,
-		host = 'https://app.posthog.com',
-		ios = {},
-		android = {}
-	}: PostHog.Configuration
-): Promise<Configuration> => {
-	const config = {
-		apiKey,
-		captureApplicationLifecycleEvents,
-		captureDeepLinks,
-		debug,
-		flushAt,
-		flushInterval,
-		host,
-		recordScreenViews,
-
-		context: {
-			$lib: 'posthog-react-native',
-			$lib_version: require('../package.json').version
-		},
-
-		android: defaults.android(android),
-		ios: defaults.ios(ios)
-	}
-	const json = JSON.stringify(config)
-
-	return {
-		...config,
-		json
-	}
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-import { PostHog } from './posthog'
-
-export default new PostHog.Client()
-export { PostHog }
-export { Configuration, JsonMap } from './bridge'

package/src/make-pkg.ts

@@ -1,3 +0,0 @@
-import { version } from '../package.json'
-
-console.log(JSON.stringify({ version }, null, 2))

package/src/middleware.ts

@@ -1,128 +0,0 @@
-import { Context, Options, JsonMap } from './bridge'
-import { assertNever } from './utils'
-import { NativeWrapper } from './wrapper'
-
-export interface MiddlewarePayload<T extends string, D extends {}> {
-	type: T
-	data: D
-	context: Context
-	next(context?: Partial<Context>): void
-	// tslint:disable-next-line:unified-signatures
-	next(context?: Partial<Context>, data?: D): void
-}
-
-export interface CapturePayload
-	extends MiddlewarePayload<
-		'capture',
-		{
-			event: string
-			properties: JsonMap
-		}
-	> {}
-
-export interface ScreenPayload
-	extends MiddlewarePayload<
-		'screen',
-		{
-			screen: string
-			properties: JsonMap
-		}
-	> {}
-
-export interface IdentifyPayload
-	extends MiddlewarePayload<
-		'identify',
-		{
-			distinctId: string | null
-			properties: JsonMap
-		}
-	> {}
-
-export interface AliasPayload
-	extends MiddlewarePayload<
-		'alias',
-		{
-			alias: string
-		}
-	> {}
-
-export type Payload = CapturePayload | IdentifyPayload | ScreenPayload | AliasPayload
-
-export type Middleware = (payload: Payload) => void | Promise<void>
-export type PayloadFromType<T> = Extract<Payload, { type: T }>
-
-export class MiddlewareChain {
-	private readonly middlewares: Middleware[] = []
-
-	constructor(private readonly wrapper: NativeWrapper<any>) {}
-
-	public add(middleware: Middleware) {
-		this.middlewares.push(middleware)
-	}
-
-	public async run<T extends Payload['type'], P extends PayloadFromType<T>>(type: T, data: P['data']) {
-		const payload: Payload = await this.exec(type, data)
-
-		switch (payload.type) {
-			case 'alias':
-				return this.wrapper.run('alias', alias => alias(payload.data.alias))
-			case 'identify':
-				return this.wrapper.run('identify', identify => identify(payload.data.distinctId, payload.data.properties))
-			case 'screen':
-				return this.wrapper.run('screen', screen => screen(payload.data.screen, payload.data.properties))
-			case 'capture':
-				return this.wrapper.run('capture', capture => capture(payload.data.event, payload.data.properties))
-			default:
-				return assertNever(payload)
-		}
-	}
-
-	private async exec<T extends Payload['type'], P extends PayloadFromType<T>>(
-		type: T,
-		data: P['data'],
-		index = 0
-	): Promise<P> {
-		const { middlewares } = this
-		const middleware = middlewares[index]
-		const ctx = {}
-
-		if (index >= middlewares.length || !middleware) {
-			return makePayload(type, data)
-		}
-
-		let called = false
-
-		return new Promise<P>((resolve, reject) =>
-			Promise.resolve(
-				middleware.call(
-					middleware,
-					makePayload(type, data, (nextProps = data) => {
-						if (called) {
-							throw new Error('middleware.payload.next() can only be called one time')
-						}
-
-						called = true
-						this.exec(type, nextProps, index + 1)
-							.then(resolve)
-							.catch(reject)
-					})
-				)
-			).catch(reject)
-		)
-	}
-}
-
-const notImplemented = (name: string) => () => {
-	throw new Error(`.${name}() not implemented`)
-}
-
-const makePayload = <T extends Payload['type'], P extends PayloadFromType<T>>(
-	type: T,
-	data: P['data'],
-	next: (data?: P['data']) => void = notImplemented('next')
-) =>
-	({
-		data,
-		next,
-		type
-	} as P)

package/src/modules.d.ts

@@ -1,2 +0,0 @@
-declare module '*.json'
-declare module 'react-native'