@thravic/react-native 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,120 @@
-# Temporary Holding Version
+# @thravic/react-native
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Thravic analytics for React Native and Expo apps. Track screens, sessions, versions and devices, plus your own events, in the same dashboard as your website.
+
+## Install
+
+```bash
+npm install @thravic/react-native @react-native-async-storage/async-storage
+```
+
+With Expo, use `npx expo install @thravic/react-native @react-native-async-storage/async-storage`. You don't need any other native modules or a config plugin, and it works in Expo Go.
+
+On bare React Native, run `npx pod-install` after installing.
+
+## Start tracking
+
+Add the app in your Thravic dashboard (**Add property → Mobile app**) to get its tracking ID. Then call `init` once, as early as you can:
+
+```ts
+import { Thravic } from '@thravic/react-native';
+
+Thravic.init('TF-1A2B3C4D', {
+  bundleId: 'com.acme.shop',
+  appVersion: '1.4.0',
+});
+```
+
+| Option | Default | |
+| --- | --- | --- |
+| `bundleId` | `'app'` | The host of screen URLs (`app://com.acme.shop/Home`). |
+| `appVersion` | none | Shown under **Versions**. In Expo, use `Application.nativeApplicationVersion` from `expo-application`. |
+| `apiUrl` | `https://api.thravic.com` | |
+| `sessionTimeoutMinutes` | `30` | Time in the background after which the next open starts a new session. |
+| `flushIntervalSeconds` | `10` | How often queued events are sent. |
+| `debug` | `false` | Log every event to the console. |
+
+## Screens
+
+### React Navigation
+
+```tsx
+import { NavigationContainer, createNavigationContainerRef } from '@react-navigation/native';
+import { Thravic } from '@thravic/react-native';
+
+const navigationRef = createNavigationContainerRef();
+
+export default function App() {
+  return (
+    <NavigationContainer ref={navigationRef} onReady={() => Thravic.trackNavigation(navigationRef)}>
+      {/* ... */}
+    </NavigationContainer>
+  );
+}
+```
+
+### Expo Router
+
+```tsx
+// app/_layout.tsx
+import { Stack, useNavigationContainerRef } from 'expo-router';
+import { useEffect } from 'react';
+import { Thravic } from '@thravic/react-native';
+
+Thravic.init('TF-1A2B3C4D', { bundleId: 'com.acme.shop' });
+
+export default function Layout() {
+  const ref = useNavigationContainerRef();
+  useEffect(() => Thravic.trackNavigation(ref), [ref]);
+  return <Stack />;
+}
+```
+
+### By hand
+
+```ts
+Thravic.screen('Checkout');
+```
+
+## Events and users
+
+```ts
+Thravic.track('purchase', { amount: 49, currency: 'USD' });
+Thravic.identify('user-42');
+```
+
+## A/B tests
+
+Create a test under Experiments in the dashboard (Pro plan), start it, then ask for the user's version where the screen changes:
+
+```tsx
+import { Thravic, useVariant } from '@thravic/react-native';
+
+function Paywall() {
+  const version = useVariant('new-paywall'); // undefined while loading
+  if (version === undefined) return null;
+  return version === 'b' ? <NewPaywall /> : <OldPaywall />;
+}
+
+// when the user reaches the test's goal
+Thravic.track('signup');
+```
+
+Outside a component, `await Thravic.variant('new-paywall')` gives the same answer. You get a version id from the dashboard, or `null` for the original: the user isn't in the test, the test isn't running, the user opted out, or the tests couldn't load within 3 seconds. A user always gets the same version, on the app and on your website. The first answer in each session records that the user saw the test, and the dashboard counts the goals they reach after it.
+
+## Privacy
+
+```ts
+Thravic.optOut(); // stops tracking and drops unsent events; remembered across launches
+Thravic.optIn();
+Thravic.isOptedOut();
+```
+
+The SDK stores a random visitor ID in AsyncStorage. It doesn't read the advertising ID, contacts, location or any other permissioned data. The dashboard gets the country from the request IP and then throws the IP away.
+
+## How it works
+
+- Screen views are sent as page views on `app://<bundleId>/<Screen>`, so Pages (shown as Screens), paths and funnels work the same way they do for a website.
+- A session starts when the app opens (`app_open`). It ends when the app goes to the background (`session_end`, with the duration and the last screen). Coming back within `sessionTimeoutMinutes` continues the same session.
+- Events are queued on the device and sent in batches of up to 50. They are sent every `flushIntervalSeconds`, when 10 are waiting, and when the app goes to the background. If a send fails, it is retried with backoff, including after a restart. Up to 1,000 events are kept offline.
+- Every event carries the OS, OS version, device model (manufacturer and model on Android; iPhone or iPad on iOS), app version, screen size and language.

package/dist/client.d.ts

@@ -0,0 +1,96 @@
+import type { Environment, Experiment, NavigationRefLike, ThravicOptions } from './types';
+export declare const VISITOR_KEY = "_tf_vid";
+export declare const QUEUE_KEY = "_tf_queue";
+export declare const OPT_OUT_KEY = "_tf_optout";
+export declare const DEFAULT_API_URL = "https://api.thravic.com";
+/** The collector takes at most 50 events per batch. */
+export declare const MAX_BATCH = 50;
+/** Queued events kept while offline; the oldest go first. */
+export declare const MAX_QUEUE = 1000;
+/** How long `variant` waits for the running tests before answering null. */
+export declare const TESTS_WAIT_MS = 3000;
+/** A v4-shaped id, like the web tracker's. Not cryptographic: ids only need to be unique. */
+export declare function generateId(): string;
+/** FNV-1a, 32-bit, as a number in [0, 1). The web tracker's hash, so both split alike. */
+export declare function unitHash(text: string): number;
+/**
+ * The version of `test` for `visitorId`, or null when they are outside its traffic
+ * share. Worked out from a hash, so the same user always gets the same version,
+ * exactly as the web tracker would give it.
+ */
+export declare function assignVariant(visitorId: string, test: Experiment): string | null;
+/**
+ * The SDK. Screen views are sent as `pageview` events on `app://<bundleId>/<Screen>`
+ * URLs, so the dashboard's pages, paths and funnels work for apps as they do for
+ * websites. Events are queued on the device and sent in batches; a batch the API
+ * has not acknowledged stays queued and is retried, including after a restart.
+ */
+export declare class ThravicClient {
+    private env;
+    private trackingId;
+    private options;
+    private initialized;
+    private ready;
+    /** Calls made before storage has loaded, replayed in order once it has. */
+    private pending;
+    private visitorId;
+    private sessionId;
+    private sessionStart;
+    private backgroundAt;
+    private currentScreen;
+    private optedOut;
+    private queue;
+    private sending;
+    private retryAttempt;
+    private retryScheduled;
+    private persistScheduled;
+    private timer;
+    private unsubscribeAppState;
+    /** This session's running tests, loaded the first time `variant` is asked. */
+    private tests;
+    /** Tests whose `experiment_view` this session has already sent. */
+    private exposed;
+    constructor(env: Environment);
+    /** Start tracking. Call once, when the app starts; later calls are ignored. */
+    init(trackingId: string, options?: ThravicOptions): Promise<void>;
+    /** Record a screen view. Automatic with `trackNavigation`; call it yourself otherwise. */
+    screen(name: string, params?: Record<string, unknown>): void;
+    /** Record a custom event, e.g. `track('purchase', { amount: 49 })`. */
+    track(event: string, properties?: Record<string, unknown>): void;
+    /** Link this device to your own user id. Sent as the web tracker sends it. */
+    identify(userId: string, traits?: Record<string, unknown>): void;
+    /**
+     * The version of A/B test `key` to show this user: a version id from the
+     * dashboard, or null for the original (not in the test, the test is not
+     * running, tracking is off, or the tests could not be loaded in time).
+     * The first answer in a session records that the user saw the test.
+     */
+    variant(key: string): Promise<string | null>;
+    /** Stop tracking this device, and drop anything not yet sent. Remembered across launches. */
+    optOut(): void;
+    /** Resume tracking after `optOut`. */
+    optIn(): void;
+    isOptedOut(): boolean;
+    /**
+     * Record a screen view whenever the focused route changes. Pass the ref from
+     * `createNavigationContainerRef()` / `useNavigationContainerRef()` (React
+     * Navigation or Expo Router). Returns a function that stops it.
+     */
+    trackNavigation(ref: NavigationRefLike): () => void;
+    /** Send everything queued now. Resolves when the attempt is done. */
+    flush(): Promise<void>;
+    /** Stop timers and listeners. For tests and hot reload; apps never need it. */
+    shutdown(): void;
+    private startSession;
+    private background;
+    private foreground;
+    /** The running tests, or none when they fail to load or take too long. */
+    private loadTests;
+    private whenReady;
+    private screenUrl;
+    private enqueue;
+    /** Write the queue to storage, at most once a second. */
+    private persist;
+    private scheduleRetry;
+    private debug;
+}

package/dist/client.js

@@ -0,0 +1,423 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThravicClient = exports.TESTS_WAIT_MS = exports.MAX_QUEUE = exports.MAX_BATCH = exports.DEFAULT_API_URL = exports.OPT_OUT_KEY = exports.QUEUE_KEY = exports.VISITOR_KEY = void 0;
+exports.generateId = generateId;
+exports.unitHash = unitHash;
+exports.assignVariant = assignVariant;
+exports.VISITOR_KEY = '_tf_vid';
+exports.QUEUE_KEY = '_tf_queue';
+exports.OPT_OUT_KEY = '_tf_optout';
+exports.DEFAULT_API_URL = 'https://api.thravic.com';
+/** The collector takes at most 50 events per batch. */
+exports.MAX_BATCH = 50;
+/** Queued events kept while offline; the oldest go first. */
+exports.MAX_QUEUE = 1000;
+/** Send without waiting for the timer once this many are queued. */
+const FLUSH_AT = 10;
+const MAX_RETRY_DELAY_MS = 30000;
+const PERSIST_DELAY_MS = 1000;
+/** How long `variant` waits for the running tests before answering null. */
+exports.TESTS_WAIT_MS = 3000;
+const DEFAULTS = {
+    apiUrl: exports.DEFAULT_API_URL,
+    sessionTimeoutMinutes: 30,
+    flushIntervalSeconds: 10,
+    debug: false,
+};
+/** A v4-shaped id, like the web tracker's. Not cryptographic: ids only need to be unique. */
+function generateId() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        return (c === 'x' ? r : (r & 3) | 8).toString(16);
+    });
+}
+/** FNV-1a, 32-bit, as a number in [0, 1). The web tracker's hash, so both split alike. */
+function unitHash(text) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0) / 4294967296;
+}
+/**
+ * The version of `test` for `visitorId`, or null when they are outside its traffic
+ * share. Worked out from a hash, so the same user always gets the same version,
+ * exactly as the web tracker would give it.
+ */
+function assignVariant(visitorId, test) {
+    if (!test.variants.length)
+        return null;
+    if (unitHash(`${visitorId}:${test.id}:traffic`) >= test.traffic / 100)
+        return null;
+    const weights = test.variants.map((v) => Math.max(v.weight, 0));
+    const total = weights.reduce((sum, w) => sum + w, 0);
+    const pick = unitHash(`${visitorId}:${test.id}:variant`);
+    let edge = 0;
+    for (let i = 0; i < test.variants.length; i++) {
+        edge += total > 0 ? weights[i] / total : 1 / test.variants.length;
+        if (pick < edge)
+            return test.variants[i].id;
+    }
+    return test.variants[test.variants.length - 1].id;
+}
+/**
+ * The SDK. Screen views are sent as `pageview` events on `app://<bundleId>/<Screen>`
+ * URLs, so the dashboard's pages, paths and funnels work for apps as they do for
+ * websites. Events are queued on the device and sent in batches; a batch the API
+ * has not acknowledged stays queued and is retried, including after a restart.
+ */
+class ThravicClient {
+    constructor(env) {
+        this.trackingId = '';
+        this.options = { ...DEFAULTS };
+        this.initialized = false;
+        this.ready = false;
+        /** Calls made before storage has loaded, replayed in order once it has. */
+        this.pending = [];
+        this.visitorId = '';
+        this.sessionId = '';
+        this.sessionStart = 0;
+        this.backgroundAt = null;
+        this.currentScreen = null;
+        this.optedOut = false;
+        this.queue = [];
+        this.sending = false;
+        this.retryAttempt = 0;
+        this.retryScheduled = false;
+        this.persistScheduled = false;
+        this.timer = null;
+        this.unsubscribeAppState = null;
+        /** This session's running tests, loaded the first time `variant` is asked. */
+        this.tests = null;
+        /** Tests whose `experiment_view` this session has already sent. */
+        this.exposed = new Set();
+        this.env = env;
+    }
+    /** Start tracking. Call once, when the app starts; later calls are ignored. */
+    async init(trackingId, options = {}) {
+        if (this.initialized)
+            return;
+        if (!trackingId) {
+            this.env.log('[Thravic] init needs your tracking ID, e.g. Thravic.init("TF-1A2B3C4D").');
+            return;
+        }
+        this.initialized = true;
+        this.trackingId = trackingId;
+        this.options = { ...DEFAULTS, ...stripUndefined(options) };
+        this.options.apiUrl = this.options.apiUrl.replace(/\/+$/, '');
+        const { storage } = this.env;
+        try {
+            this.optedOut = (await storage.getItem(exports.OPT_OUT_KEY)) === '1';
+            this.visitorId = (await storage.getItem(exports.VISITOR_KEY)) || '';
+            if (!this.visitorId) {
+                this.visitorId = generateId();
+                await storage.setItem(exports.VISITOR_KEY, this.visitorId);
+            }
+            this.queue = parseQueue(await storage.getItem(exports.QUEUE_KEY));
+        }
+        catch (err) {
+            // Storage unavailable: track this run only.
+            this.visitorId = this.visitorId || generateId();
+            this.debug('storage unavailable', err);
+        }
+        this.startSession();
+        this.unsubscribeAppState = this.env.onAppStateChange((active) => active ? this.foreground() : this.background());
+        this.timer = this.env.setInterval(() => void this.flush(), this.options.flushIntervalSeconds * 1000);
+        this.ready = true;
+        const pending = this.pending;
+        this.pending = [];
+        pending.forEach((call) => call());
+        void this.flush();
+    }
+    /** Record a screen view. Automatic with `trackNavigation`; call it yourself otherwise. */
+    screen(name, params) {
+        this.whenReady(() => {
+            const screen = String(name || '').trim().replace(/^\/+/, '');
+            if (!screen)
+                return;
+            this.currentScreen = screen;
+            this.enqueue('pageview', params && Object.keys(params).length ? { params } : undefined);
+        });
+    }
+    /** Record a custom event, e.g. `track('purchase', { amount: 49 })`. */
+    track(event, properties) {
+        this.whenReady(() => {
+            if (!event)
+                return;
+            this.enqueue('custom', { ...properties, event });
+        });
+    }
+    /** Link this device to your own user id. Sent as the web tracker sends it. */
+    identify(userId, traits) {
+        this.whenReady(() => {
+            if (!userId)
+                return;
+            this.enqueue('custom', { ...traits, event: 'identify', userId: String(userId) });
+        });
+    }
+    /**
+     * The version of A/B test `key` to show this user: a version id from the
+     * dashboard, or null for the original (not in the test, the test is not
+     * running, tracking is off, or the tests could not be loaded in time).
+     * The first answer in a session records that the user saw the test.
+     */
+    variant(key) {
+        return new Promise((resolve) => {
+            if (!this.initialized) {
+                this.env.log('[Thravic] Call Thravic.init before asking for a variant.');
+                resolve(null);
+                return;
+            }
+            this.whenReady(() => {
+                if (this.optedOut) {
+                    resolve(null);
+                    return;
+                }
+                void this.loadTests().then((tests) => {
+                    const test = tests.find((t) => t.key === key);
+                    const id = test ? assignVariant(this.visitorId, test) : null;
+                    if (test && id && !this.exposed.has(test.id)) {
+                        this.exposed.add(test.id);
+                        this.enqueue('custom', { event: 'experiment_view', experiment: test.id, variant: id });
+                    }
+                    resolve(id);
+                });
+            });
+        });
+    }
+    /** Stop tracking this device, and drop anything not yet sent. Remembered across launches. */
+    optOut() {
+        this.optedOut = true;
+        this.queue = [];
+        void this.env.storage.setItem(exports.OPT_OUT_KEY, '1').catch(() => undefined);
+        void this.env.storage.removeItem(exports.QUEUE_KEY).catch(() => undefined);
+    }
+    /** Resume tracking after `optOut`. */
+    optIn() {
+        this.optedOut = false;
+        void this.env.storage.removeItem(exports.OPT_OUT_KEY).catch(() => undefined);
+    }
+    isOptedOut() {
+        return this.optedOut;
+    }
+    /**
+     * Record a screen view whenever the focused route changes. Pass the ref from
+     * `createNavigationContainerRef()` / `useNavigationContainerRef()` (React
+     * Navigation or Expo Router). Returns a function that stops it.
+     */
+    trackNavigation(ref) {
+        let last = null;
+        const onState = () => {
+            if (ref.isReady && !ref.isReady())
+                return;
+            const route = ref.getCurrentRoute();
+            if (!route || route.name === last)
+                return;
+            last = route.name;
+            this.screen(route.name);
+        };
+        const unsubscribe = ref.addListener('state', onState);
+        onState();
+        return unsubscribe;
+    }
+    /** Send everything queued now. Resolves when the attempt is done. */
+    async flush() {
+        if (!this.ready || this.sending || this.optedOut || this.queue.length === 0)
+            return;
+        this.sending = true;
+        const batch = this.queue.slice(0, exports.MAX_BATCH);
+        const sent = new Set(batch.map((e) => e.eventId));
+        let more = false;
+        try {
+            const response = await this.env.fetch(`${this.options.apiUrl}/api/collect/${encodeURIComponent(this.trackingId)}/batch`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ events: batch }),
+            });
+            // A 4xx other than 429 will never succeed: drop the batch rather than
+            // retrying it forever, as the web tracker does.
+            const rejected = response.status >= 400 && response.status < 500 && response.status !== 429;
+            if (!response.ok && !rejected)
+                throw new Error(`HTTP ${response.status}`);
+            if (rejected)
+                this.debug(`batch rejected with ${response.status}`);
+            this.queue = this.queue.filter((e) => !sent.has(e.eventId));
+            this.retryAttempt = 0;
+            this.persist();
+            more = this.queue.length > 0;
+        }
+        catch (err) {
+            this.debug('send failed, will retry', err);
+            this.scheduleRetry();
+        }
+        finally {
+            this.sending = false;
+        }
+        if (more)
+            await this.flush();
+    }
+    /** Stop timers and listeners. For tests and hot reload; apps never need it. */
+    shutdown() {
+        if (this.timer !== null)
+            this.env.clearInterval(this.timer);
+        this.unsubscribeAppState?.();
+        this.timer = null;
+        this.unsubscribeAppState = null;
+    }
+    // ── Sessions ─────────────────────────────────────────────────────────────
+    startSession() {
+        this.sessionId = generateId();
+        this.sessionStart = this.env.now();
+        this.backgroundAt = null;
+        // A new session picks up tests started or ended since the last one.
+        this.tests = null;
+        this.exposed.clear();
+        this.enqueue('custom', { event: 'app_open' });
+    }
+    background() {
+        if (!this.ready || this.backgroundAt !== null)
+            return;
+        this.backgroundAt = this.env.now();
+        this.enqueue('session_end', {
+            duration: Math.round((this.backgroundAt - this.sessionStart) / 1000),
+            lastPage: this.screenUrl(),
+        });
+        void this.flush();
+    }
+    foreground() {
+        if (!this.ready || this.backgroundAt === null)
+            return;
+        const away = this.env.now() - this.backgroundAt;
+        this.backgroundAt = null;
+        if (away < this.options.sessionTimeoutMinutes * 60000)
+            return;
+        // Long enough away that this is a new visit; it starts on the screen in view.
+        this.startSession();
+        if (this.currentScreen)
+            this.enqueue('pageview');
+    }
+    // ── A/B tests ────────────────────────────────────────────────────────────
+    /** The running tests, or none when they fail to load or take too long. */
+    loadTests() {
+        if (!this.tests) {
+            this.tests = new Promise((resolve) => {
+                let done = false;
+                const settle = (list) => {
+                    if (done)
+                        return;
+                    done = true;
+                    resolve(parseTests(list));
+                };
+                this.env.setTimeout(() => settle([]), exports.TESTS_WAIT_MS);
+                this.env
+                    .fetch(`${this.options.apiUrl}/api/collect/${encodeURIComponent(this.trackingId)}/config`)
+                    .then((response) => (response.ok ? response.json() : null))
+                    .then((config) => settle(config?.experiments))
+                    .catch((err) => {
+                    this.debug('tests could not be loaded', err);
+                    settle([]);
+                });
+            });
+        }
+        return this.tests;
+    }
+    // ── Queue ────────────────────────────────────────────────────────────────
+    whenReady(call) {
+        if (this.ready)
+            call();
+        else if (this.initialized)
+            this.pending.push(call);
+        else
+            this.env.log('[Thravic] Call Thravic.init before tracking.');
+    }
+    screenUrl() {
+        const host = this.options.bundleId || 'app';
+        return `app://${host}/${encodeURI(this.currentScreen || '')}`;
+    }
+    enqueue(type, data) {
+        if (this.optedOut)
+            return;
+        const device = this.env.device();
+        const event = {
+            eventId: generateId(),
+            type,
+            url: this.screenUrl(),
+            visitorId: this.visitorId,
+            sessionId: this.sessionId,
+            ...stripUndefined({
+                os: device.os,
+                osVersion: device.osVersion,
+                deviceModel: device.deviceModel,
+                appVersion: this.options.appVersion,
+                screenWidth: device.screenWidth,
+                screenHeight: device.screenHeight,
+                language: device.language,
+                data,
+            }),
+        };
+        this.queue.push(event);
+        if (this.queue.length > exports.MAX_QUEUE)
+            this.queue = this.queue.slice(-exports.MAX_QUEUE);
+        this.debug(type, event.url, data ?? '');
+        this.persist();
+        if (this.queue.length >= FLUSH_AT)
+            void this.flush();
+    }
+    /** Write the queue to storage, at most once a second. */
+    persist() {
+        if (this.persistScheduled)
+            return;
+        this.persistScheduled = true;
+        this.env.setTimeout(() => {
+            this.persistScheduled = false;
+            const write = this.queue.length === 0
+                ? this.env.storage.removeItem(exports.QUEUE_KEY)
+                : this.env.storage.setItem(exports.QUEUE_KEY, JSON.stringify(this.queue));
+            void write.catch(() => undefined);
+        }, PERSIST_DELAY_MS);
+    }
+    scheduleRetry() {
+        if (this.retryScheduled)
+            return;
+        this.retryScheduled = true;
+        const delay = Math.min(1000 * 2 ** this.retryAttempt, MAX_RETRY_DELAY_MS);
+        this.retryAttempt += 1;
+        this.env.setTimeout(() => {
+            this.retryScheduled = false;
+            void this.flush();
+        }, delay);
+    }
+    debug(...args) {
+        if (this.options.debug)
+            this.env.log('[Thravic]', ...args);
+    }
+}
+exports.ThravicClient = ThravicClient;
+function parseQueue(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .filter((e) => e && typeof e === 'object' && typeof e.eventId === 'string')
+            .slice(-exports.MAX_QUEUE);
+    }
+    catch {
+        return [];
+    }
+}
+function parseTests(list) {
+    if (!Array.isArray(list))
+        return [];
+    return list.filter((t) => !!t &&
+        typeof t.id === 'string' &&
+        typeof t.key === 'string' &&
+        typeof t.traffic === 'number' &&
+        Array.isArray(t.variants));
+}
+function stripUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined && v !== null && v !== ''));
+}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { ThravicClient } from './client';
+export { ThravicClient, assignVariant } from './client';
+export type { CollectEvent, DeviceInfo, Environment, Experiment, NavigationRefLike, Storage, ThravicOptions, } from './types';
+/**
+ * Thravic for React Native.
+ *
+ * ```ts
+ * import { Thravic } from '@thravic/react-native';
+ *
+ * Thravic.init('TF-1A2B3C4D', { appVersion: '1.4.0', bundleId: 'com.acme.shop' });
+ * Thravic.trackNavigation(navigationRef);     // screen views, automatically
+ * Thravic.track('purchase', { amount: 49 });  // your own events
+ * const version = await Thravic.variant('new-paywall');  // A/B tests
+ * ```
+ */
+export declare const Thravic: ThravicClient;
+/**
+ * The version of A/B test `key` to show, for use in a component: `undefined`
+ * while it loads, then a version id or null for the original.
+ *
+ * ```tsx
+ * const version = useVariant('new-paywall');
+ * if (version === undefined) return null;
+ * return version === 'b' ? <NewPaywall /> : <Paywall />;
+ * ```
+ */
+export declare function useVariant(key: string): string | null | undefined;
+export default Thravic;