@wireai/activation 0.1.1 → 0.3.0

package/dist/analytics/index.d.mts

@@ -1,12 +1,13 @@
 export { R as ReportAppEventOptions, r as reportAppEvent } from '../transport-BeO_Brcu.mjs';
-export { A as AnalyticsEvent, C as ClientEvent, a as ClientEventTarget, b as ClientEventType, W as WIRE_ONBOARDING_EVENTS, c as WireOnboardingEventName, m as makeSessionId, r as reportClientEvent, d as reportClientEvents, t as toAnalyticsEvent } from '../analyticsEvent-B8v3BZjM.mjs';
+import { E as EventQueueOptions } from '../eventQueue-CA1d8Fmn.mjs';
+export { A as AnalyticsEvent, C as ClientEvent, a as ClientEventTarget, b as ClientEventType, c as ContextEnvelope, d as ContextEnvelopeInput, e as EnvelopeSource, f as EventQueue, W as WIRE_ONBOARDING_EVENTS, g as WireOnboardingEventName, h as buildContextEnvelope, i as createEventQueue, m as makeSessionId, r as reportClientEvent, j as reportClientEvents, t as toAnalyticsEvent } from '../eventQueue-CA1d8Fmn.mjs';
 import '../types-A6pTxIZV.mjs';
 import '../types-BKfpdZzX.mjs';
 import '../types-GL_hQ0TN.mjs';
 import '../types-CMuOexw0.mjs';
-import 'react-native';
 import 'react';
 import 'wireai-rn';
+import 'react-native';
 
 /** A single route inside a React-Navigation-shaped state (structural — no `@react-navigation`). */
 interface NavigationRouteLike {
@@ -89,4 +90,70 @@ interface NavigationRefLike {
  */
 declare const useScreenTracking: (navigationRef: NavigationRefLike | undefined, options?: ScreenTrackerOptions) => void;
 
-export { type NavigationRefLike, type NavigationRouteLike, type NavigationStateLike, type ScreenTracker, type ScreenTrackerOptions, createScreenTracker, getActiveRouteName, screenTrackingHandler, useScreenTracking };
+/** Arbitrary non-PII event properties. Serialized to the event's `meta` (a JSON string) on the wire. */
+type AnalyticsProps = Record<string, unknown>;
+/**
+ * Tenant transport + context inputs for {@link createAnalytics}. `serverUrl`/`apiKey` are the
+ * SAME creds as onboarding (never a second key). The rest feed the context envelope + the queue's
+ * offline persistence — all optional.
+ */
+type CreateAnalyticsConfig = {
+    /** Base server URL (same as `WireOnboardingConfig.serverUrl`); `/v1/events` is appended. */
+    serverUrl: string;
+    /** Tenant API key; sent as `Authorization: Bearer`. */
+    apiKey: string;
+    /**
+     * Correlation id shared by every event from this instance (and the `identify` event). Defaults
+     * to a fresh `makeSessionId()` at creation so all events agree on one id per analytics instance.
+     */
+    sessionId?: string;
+    /** Tenant/app id used to namespace the queue's default storage key (`wireai:evtq:<appId>`). */
+    appId?: string;
+    /**
+     * Host persistence (AsyncStorage-compatible subset) for offline-first durability. When omitted,
+     * the queue runs in the documented in-memory mode (survives re-renders, not app kills).
+     */
+    storage?: EventQueueOptions["storage"];
+    /** Host app version, e.g. "1.4.2" (host-injected; stamped onto every event's context). */
+    appVersion?: string;
+    /** Host native build number, e.g. "412" (host-injected). */
+    appBuild?: string;
+    /** Host connectivity signal, e.g. "wifi" | "cellular" — read fresh per event via the provider. */
+    networkType?: string;
+};
+/** Optional queue tuning knobs, forwarded verbatim to {@link createEventQueue}. */
+type AnalyticsOptions = Partial<Pick<EventQueueOptions, "maxSize" | "batchSize" | "baseBackoffMs" | "maxBackoffMs" | "maxRetries">>;
+/**
+ * The developer-facing analytics surface. `track`/`screen`/`identify` are the Segment/PostHog-shaped
+ * API; `flush`/`notifyOnline`/`size` expose the underlying queue so a host can drive reconnect
+ * draining (load-bearing for offline-first) and inspect the pending buffer.
+ */
+type Analytics = {
+    /** Record an in-app event: `event_type='app_event'`, `question_key=<event>`, `props`→`meta`. */
+    track(event: string, props?: AnalyticsProps): void;
+    /** Record a screen view: `event_type='app_event'`, `question_key='screen'`, `meta={ screen, ...props }`. */
+    screen(name: string, props?: AnalyticsProps): void;
+    /** Bind the host's opaque user id (per-session, in-memory) and emit an `identify` event. */
+    identify(userId: string, traits?: AnalyticsProps): void;
+    /** Attempt an immediate drain of the pending buffer. Fire-and-forget. */
+    flush(): void;
+    /** Host reconnect signal: reset backoff and drain now. Fire-and-forget. */
+    notifyOnline(): void;
+    /** Current pending (in-memory) count. */
+    size(): number;
+};
+/**
+ * Create a bound analytics instance. Seeds one correlation `sessionId`, builds an offline-first
+ * queue over the tenant transport, and passes a fresh-per-event context envelope PROVIDER so the
+ * connectivity type is read at enqueue time. The bound user id starts unset (see `identify`).
+ */
+declare const createAnalytics: (config: CreateAnalyticsConfig, options?: AnalyticsOptions) => Analytics;
+
+/**
+ * Build a per-mount analytics instance. `config`/`options` are read once at first render (the
+ * instance is stable for the component's lifetime, held in a ref). Returns the {@link Analytics}
+ * surface so the component can `track` / `screen` / `identify` and drive `notifyOnline` on reconnect.
+ */
+declare const useAnalytics: (config: CreateAnalyticsConfig, options?: AnalyticsOptions) => Analytics;
+
+export { type Analytics, type AnalyticsOptions, type AnalyticsProps, type CreateAnalyticsConfig, EventQueueOptions, type NavigationRefLike, type NavigationRouteLike, type NavigationStateLike, type ScreenTracker, type ScreenTrackerOptions, createAnalytics, createScreenTracker, getActiveRouteName, screenTrackingHandler, useAnalytics, useScreenTracking };

package/dist/analytics/index.d.ts

@@ -1,12 +1,13 @@
 export { R as ReportAppEventOptions, r as reportAppEvent } from '../transport-DLpd1v5_.js';
-export { A as AnalyticsEvent, C as ClientEvent, a as ClientEventTarget, b as ClientEventType, W as WIRE_ONBOARDING_EVENTS, c as WireOnboardingEventName, m as makeSessionId, r as reportClientEvent, d as reportClientEvents, t as toAnalyticsEvent } from '../analyticsEvent-DvjB92kK.js';
+import { E as EventQueueOptions } from '../eventQueue-CrNB9gzH.js';
+export { A as AnalyticsEvent, C as ClientEvent, a as ClientEventTarget, b as ClientEventType, c as ContextEnvelope, d as ContextEnvelopeInput, e as EnvelopeSource, f as EventQueue, W as WIRE_ONBOARDING_EVENTS, g as WireOnboardingEventName, h as buildContextEnvelope, i as createEventQueue, m as makeSessionId, r as reportClientEvent, j as reportClientEvents, t as toAnalyticsEvent } from '../eventQueue-CrNB9gzH.js';
 import '../types-BhpXJGlg.js';
 import '../types-BKfpdZzX.js';
 import '../types-GL_hQ0TN.js';
 import '../types-CMuOexw0.js';
-import 'react-native';
 import 'react';
 import 'wireai-rn';
+import 'react-native';
 
 /** A single route inside a React-Navigation-shaped state (structural — no `@react-navigation`). */
 interface NavigationRouteLike {
@@ -89,4 +90,70 @@ interface NavigationRefLike {
  */
 declare const useScreenTracking: (navigationRef: NavigationRefLike | undefined, options?: ScreenTrackerOptions) => void;
 
-export { type NavigationRefLike, type NavigationRouteLike, type NavigationStateLike, type ScreenTracker, type ScreenTrackerOptions, createScreenTracker, getActiveRouteName, screenTrackingHandler, useScreenTracking };
+/** Arbitrary non-PII event properties. Serialized to the event's `meta` (a JSON string) on the wire. */
+type AnalyticsProps = Record<string, unknown>;
+/**
+ * Tenant transport + context inputs for {@link createAnalytics}. `serverUrl`/`apiKey` are the
+ * SAME creds as onboarding (never a second key). The rest feed the context envelope + the queue's
+ * offline persistence — all optional.
+ */
+type CreateAnalyticsConfig = {
+    /** Base server URL (same as `WireOnboardingConfig.serverUrl`); `/v1/events` is appended. */
+    serverUrl: string;
+    /** Tenant API key; sent as `Authorization: Bearer`. */
+    apiKey: string;
+    /**
+     * Correlation id shared by every event from this instance (and the `identify` event). Defaults
+     * to a fresh `makeSessionId()` at creation so all events agree on one id per analytics instance.
+     */
+    sessionId?: string;
+    /** Tenant/app id used to namespace the queue's default storage key (`wireai:evtq:<appId>`). */
+    appId?: string;
+    /**
+     * Host persistence (AsyncStorage-compatible subset) for offline-first durability. When omitted,
+     * the queue runs in the documented in-memory mode (survives re-renders, not app kills).
+     */
+    storage?: EventQueueOptions["storage"];
+    /** Host app version, e.g. "1.4.2" (host-injected; stamped onto every event's context). */
+    appVersion?: string;
+    /** Host native build number, e.g. "412" (host-injected). */
+    appBuild?: string;
+    /** Host connectivity signal, e.g. "wifi" | "cellular" — read fresh per event via the provider. */
+    networkType?: string;
+};
+/** Optional queue tuning knobs, forwarded verbatim to {@link createEventQueue}. */
+type AnalyticsOptions = Partial<Pick<EventQueueOptions, "maxSize" | "batchSize" | "baseBackoffMs" | "maxBackoffMs" | "maxRetries">>;
+/**
+ * The developer-facing analytics surface. `track`/`screen`/`identify` are the Segment/PostHog-shaped
+ * API; `flush`/`notifyOnline`/`size` expose the underlying queue so a host can drive reconnect
+ * draining (load-bearing for offline-first) and inspect the pending buffer.
+ */
+type Analytics = {
+    /** Record an in-app event: `event_type='app_event'`, `question_key=<event>`, `props`→`meta`. */
+    track(event: string, props?: AnalyticsProps): void;
+    /** Record a screen view: `event_type='app_event'`, `question_key='screen'`, `meta={ screen, ...props }`. */
+    screen(name: string, props?: AnalyticsProps): void;
+    /** Bind the host's opaque user id (per-session, in-memory) and emit an `identify` event. */
+    identify(userId: string, traits?: AnalyticsProps): void;
+    /** Attempt an immediate drain of the pending buffer. Fire-and-forget. */
+    flush(): void;
+    /** Host reconnect signal: reset backoff and drain now. Fire-and-forget. */
+    notifyOnline(): void;
+    /** Current pending (in-memory) count. */
+    size(): number;
+};
+/**
+ * Create a bound analytics instance. Seeds one correlation `sessionId`, builds an offline-first
+ * queue over the tenant transport, and passes a fresh-per-event context envelope PROVIDER so the
+ * connectivity type is read at enqueue time. The bound user id starts unset (see `identify`).
+ */
+declare const createAnalytics: (config: CreateAnalyticsConfig, options?: AnalyticsOptions) => Analytics;
+
+/**
+ * Build a per-mount analytics instance. `config`/`options` are read once at first render (the
+ * instance is stable for the component's lifetime, held in a ref). Returns the {@link Analytics}
+ * surface so the component can `track` / `screen` / `identify` and drive `notifyOnline` on reconnect.
+ */
+declare const useAnalytics: (config: CreateAnalyticsConfig, options?: AnalyticsOptions) => Analytics;
+
+export { type Analytics, type AnalyticsOptions, type AnalyticsProps, type CreateAnalyticsConfig, EventQueueOptions, type NavigationRefLike, type NavigationRouteLike, type NavigationStateLike, type ScreenTracker, type ScreenTrackerOptions, createAnalytics, createScreenTracker, getActiveRouteName, screenTrackingHandler, useAnalytics, useScreenTracking };

package/dist/analytics/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var react = require('react');
+var reactNative = require('react-native');
 
 // src/reviews/transport.ts
 var reportAppEvent = (target, name, options = {}) => {
@@ -135,8 +136,374 @@ var toAnalyticsEvent = (event) => {
     }
   }
 };
+var deriveFormFactor = (iosIdiom, width, height) => {
+  if (iosIdiom === "pad") return "tablet";
+  if (iosIdiom === "phone") return "phone";
+  if (typeof width === "number" && typeof height === "number") {
+    return Math.min(width, height) >= 600 ? "tablet" : "phone";
+  }
+  return void 0;
+};
+var collectDeviceContext = () => {
+  var _a;
+  const ctx = { platform: reactNative.Platform.OS };
+  try {
+    const version = reactNative.Platform.Version;
+    if (version !== void 0 && version !== null && String(version)) {
+      ctx.osVersion = String(version);
+    }
+  } catch {
+  }
+  let constants = {};
+  try {
+    constants = (_a = reactNative.Platform.constants) != null ? _a : {};
+  } catch {
+    constants = {};
+  }
+  let iosIdiom;
+  try {
+    if (reactNative.Platform.OS === "android") {
+      const brand = constants.Brand;
+      const model = constants.Model;
+      const release = constants.Release;
+      if (typeof brand === "string" && brand) ctx.brand = brand;
+      if (typeof model === "string" && model) ctx.model = model;
+      if (release !== void 0 && release !== null && String(release)) {
+        ctx.osVersion = String(release);
+      }
+    } else if (reactNative.Platform.OS === "ios") {
+      const osVersion = constants.osVersion;
+      const idiom = constants.interfaceIdiom;
+      if (osVersion !== void 0 && osVersion !== null && String(osVersion)) {
+        ctx.osVersion = String(osVersion);
+      }
+      if (typeof idiom === "string" && idiom) {
+        ctx.interfaceIdiom = idiom;
+        iosIdiom = idiom;
+      }
+    }
+  } catch {
+  }
+  try {
+    const screen = reactNative.Dimensions.get("screen");
+    if (screen) {
+      if (typeof screen.width === "number") ctx.screenWidth = screen.width;
+      if (typeof screen.height === "number") ctx.screenHeight = screen.height;
+      if (typeof screen.scale === "number") ctx.screenScale = screen.scale;
+      const formFactor = deriveFormFactor(iosIdiom, screen.width, screen.height);
+      if (formFactor) ctx.formFactor = formFactor;
+    }
+  } catch {
+  }
+  try {
+    ctx.isRTL = reactNative.I18nManager.isRTL;
+  } catch {
+  }
+  try {
+    const resolved = Intl.DateTimeFormat().resolvedOptions();
+    if (resolved.locale) ctx.locale = resolved.locale;
+    if (resolved.timeZone) ctx.timeZone = resolved.timeZone;
+  } catch {
+  }
+  return ctx;
+};
+
+// src/analytics/contextEnvelope.ts
+var buildContextEnvelope = (input = {}) => {
+  const device = { ...collectDeviceContext() };
+  if (input.appVersion && !device.appVersion) device.appVersion = input.appVersion;
+  const envelope = { device };
+  if (input.sessionId) envelope.sessionId = input.sessionId;
+  if (input.appVersion) envelope.appVersion = input.appVersion;
+  if (input.appBuild) envelope.appBuild = input.appBuild;
+  if (input.networkType) envelope.networkType = input.networkType;
+  return envelope;
+};
+
+// src/analytics/eventQueue.ts
+var DEFAULTS = {
+  maxSize: 200,
+  batchSize: 20,
+  baseBackoffMs: 1e3,
+  maxBackoffMs: 3e4,
+  maxRetries: 6
+};
+var READ_TIMEOUT_MS = 1500;
+var withTimeout = (p, ms) => {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(void 0), ms);
+  });
+  return Promise.race([p, timeout]).finally(() => clearTimeout(timer));
+};
+var unrefTimer = (timer) => {
+  const t = timer;
+  if (typeof t.unref === "function") t.unref();
+};
+var parsePersisted = (raw) => {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    const items = [];
+    for (const entry of parsed) {
+      if (entry && typeof entry === "object" && typeof entry.id === "number" && entry.event && typeof entry.event === "object") {
+        items.push(entry);
+      }
+    }
+    return items;
+  } catch {
+    return [];
+  }
+};
+var createEventQueue = (options) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const target = options.target;
+  const storage = options.storage;
+  const key = (_b = options.storageKey) != null ? _b : `wireai:evtq:${(_a = options.appId) != null ? _a : "default"}`;
+  const maxSize = (_c = options.maxSize) != null ? _c : DEFAULTS.maxSize;
+  const batchSize = (_d = options.batchSize) != null ? _d : DEFAULTS.batchSize;
+  const baseBackoffMs = (_e = options.baseBackoffMs) != null ? _e : DEFAULTS.baseBackoffMs;
+  const maxBackoffMs = (_f = options.maxBackoffMs) != null ? _f : DEFAULTS.maxBackoffMs;
+  const maxRetries = (_g = options.maxRetries) != null ? _g : DEFAULTS.maxRetries;
+  let pending = [];
+  let nextId = 0;
+  let flushing = false;
+  let attempt = 0;
+  let retryTimer;
+  const resolveEnvelope = () => {
+    try {
+      return typeof options.envelope === "function" ? options.envelope() : options.envelope;
+    } catch {
+      return void 0;
+    }
+  };
+  const stamp = (event) => {
+    var _a2;
+    const env = resolveEnvelope();
+    const stamped = { ...event };
+    if (!env) return stamped;
+    if (!stamped.device && env.device) stamped.device = env.device;
+    if (!stamped.session_id && env.sessionId) stamped.session_id = env.sessionId;
+    const uc = { ...(_a2 = stamped.user_context) != null ? _a2 : {} };
+    if (env.appVersion && uc.app_version === void 0) uc.app_version = env.appVersion;
+    if (env.appBuild && uc.app_build === void 0) uc.app_build = env.appBuild;
+    if (env.networkType && uc.network_type === void 0) uc.network_type = env.networkType;
+    if (Object.keys(uc).length > 0) stamped.user_context = uc;
+    return stamped;
+  };
+  const persist = () => {
+    if (!storage) return;
+    try {
+      if (pending.length === 0) {
+        void storage.removeItem(key).catch(() => {
+        });
+        return;
+      }
+      const payload = pending.map((item) => ({ id: item.id, event: item.event }));
+      void storage.setItem(key, JSON.stringify(payload)).catch(() => {
+      });
+    } catch {
+    }
+  };
+  const enforceSizeCap = () => {
+    if (pending.length > maxSize) pending.splice(0, pending.length - maxSize);
+  };
+  const safeSig = (event) => {
+    try {
+      return JSON.stringify(event);
+    } catch {
+      return `__nosig_${nextId}_${Math.random()}`;
+    }
+  };
+  const loadPromise = (async () => {
+    if (!storage) return;
+    try {
+      const persistedItems = parsePersisted(await withTimeout(storage.getItem(key), READ_TIMEOUT_MS));
+      if (persistedItems.length === 0) return;
+      const events = [...persistedItems.map((p) => p.event), ...pending.map((p) => p.event)];
+      pending = [];
+      nextId = 0;
+      const seen = /* @__PURE__ */ new Set();
+      for (const event of events) {
+        const sig = safeSig(event);
+        if (seen.has(sig)) continue;
+        seen.add(sig);
+        pending.push({ id: nextId++, event, sig });
+      }
+      enforceSizeCap();
+      persist();
+    } catch {
+    }
+  })();
+  const postBatch = async (events) => {
+    if (!(target == null ? void 0 : target.serverUrl) || events.length === 0) return false;
+    try {
+      const url = `${target.serverUrl.replace(/\/$/, "")}/v1/events`;
+      const headers = { "Content-Type": "application/json" };
+      if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ events })
+      });
+      return !!(res && res.ok);
+    } catch {
+      return false;
+    }
+  };
+  const clearRetry = () => {
+    if (retryTimer !== void 0) {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+    }
+  };
+  const scheduleRetry = () => {
+    if (attempt >= maxRetries) return;
+    const delay = Math.min(baseBackoffMs * 2 ** attempt, maxBackoffMs);
+    attempt++;
+    clearRetry();
+    retryTimer = setTimeout(() => {
+      retryTimer = void 0;
+      void drain();
+    }, delay);
+    unrefTimer(retryTimer);
+  };
+  const drain = async () => {
+    try {
+      await loadPromise;
+    } catch {
+    }
+    if (flushing) return;
+    flushing = true;
+    try {
+      while (pending.length > 0) {
+        const batch = pending.slice(0, batchSize);
+        const ok = await postBatch(batch.map((item) => item.event));
+        if (!ok) {
+          scheduleRetry();
+          return;
+        }
+        const acked = new Set(batch.map((item) => item.id));
+        pending = pending.filter((item) => !acked.has(item.id));
+        persist();
+        attempt = 0;
+        clearRetry();
+      }
+    } finally {
+      flushing = false;
+    }
+  };
+  const flush = () => {
+    try {
+      void drain();
+    } catch {
+    }
+  };
+  const enqueue = (event) => {
+    try {
+      const stamped = stamp(event);
+      const sig = safeSig(stamped);
+      for (const item of pending) {
+        if (item.sig === sig) return;
+      }
+      pending.push({ id: nextId++, event: stamped, sig });
+      enforceSizeCap();
+      persist();
+      if (retryTimer === void 0) flush();
+    } catch {
+    }
+  };
+  const notifyOnline = () => {
+    attempt = 0;
+    clearRetry();
+    flush();
+  };
+  const size = () => pending.length;
+  return { enqueue, flush, notifyOnline, size };
+};
+
+// src/identity/userIdentity.ts
+var USER_ID_MAX_LENGTH = 128;
+var sanitizeUserId = (raw) => {
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  return trimmed.length > USER_ID_MAX_LENGTH ? trimmed.slice(0, USER_ID_MAX_LENGTH) : trimmed;
+};
+
+// src/analytics/analyticsFacade.ts
+var createAnalytics = (config, options = {}) => {
+  var _a;
+  const sessionId = (_a = config.sessionId) != null ? _a : makeSessionId();
+  const envelope = () => buildContextEnvelope({
+    sessionId,
+    appVersion: config.appVersion,
+    appBuild: config.appBuild,
+    networkType: config.networkType
+  });
+  const queue = createEventQueue({
+    target: { serverUrl: config.serverUrl, apiKey: config.apiKey },
+    storage: config.storage,
+    appId: config.appId,
+    envelope,
+    ...options
+  });
+  let boundUserId;
+  const track = (event, props) => {
+    if (!event) return;
+    const clientEvent = {
+      event_type: "app_event",
+      session_id: sessionId,
+      question_key: event
+    };
+    if (props && Object.keys(props).length > 0) clientEvent.meta = JSON.stringify(props);
+    if (boundUserId) clientEvent.user_id = boundUserId;
+    queue.enqueue(clientEvent);
+  };
+  const screen = (name, props) => {
+    if (!name) return;
+    const meta = { screen: name, ...props != null ? props : {} };
+    const clientEvent = {
+      event_type: "app_event",
+      session_id: sessionId,
+      question_key: "screen",
+      meta: JSON.stringify(meta)
+    };
+    if (boundUserId) clientEvent.user_id = boundUserId;
+    queue.enqueue(clientEvent);
+  };
+  const identify = (userId, traits) => {
+    const clean = sanitizeUserId(userId);
+    if (!clean) return;
+    boundUserId = clean;
+    const clientEvent = {
+      event_type: "identify",
+      session_id: sessionId,
+      user_id: clean
+    };
+    if (traits && Object.keys(traits).length > 0) clientEvent.meta = JSON.stringify(traits);
+    queue.enqueue(clientEvent);
+  };
+  return {
+    track,
+    screen,
+    identify,
+    flush: queue.flush,
+    notifyOnline: queue.notifyOnline,
+    size: queue.size
+  };
+};
+var useAnalytics = (config, options = {}) => {
+  const ref = react.useRef(void 0);
+  if (!ref.current) ref.current = createAnalytics(config, options);
+  return ref.current;
+};
 
 exports.WIRE_ONBOARDING_EVENTS = WIRE_ONBOARDING_EVENTS;
+exports.buildContextEnvelope = buildContextEnvelope;
+exports.createAnalytics = createAnalytics;
+exports.createEventQueue = createEventQueue;
 exports.createScreenTracker = createScreenTracker;
 exports.getActiveRouteName = getActiveRouteName;
 exports.makeSessionId = makeSessionId;
@@ -145,6 +512,7 @@ exports.reportClientEvent = reportClientEvent;
 exports.reportClientEvents = reportClientEvents;
 exports.screenTrackingHandler = screenTrackingHandler;
 exports.toAnalyticsEvent = toAnalyticsEvent;
+exports.useAnalytics = useAnalytics;
 exports.useScreenTracking = useScreenTracking;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map