@wireai/activation 0.1.0 → 0.2.0

package/dist/analytics/index.d.ts

@@ -0,0 +1,92 @@
+export { R as ReportAppEventOptions, r as reportAppEvent } from '../transport-DLpd1v5_.js';
+export { A as AnalyticsEvent, C as ClientEvent, a as ClientEventTarget, b as ClientEventType, c as ContextEnvelope, d as ContextEnvelopeInput, E as EnvelopeSource, e as EventQueue, f as EventQueueOptions, 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-rV1dtJJR.js';
+import '../types-BhpXJGlg.js';
+import '../types-BKfpdZzX.js';
+import '../types-GL_hQ0TN.js';
+import '../types-CMuOexw0.js';
+import 'react';
+import 'wireai-rn';
+import 'react-native';
+
+/** A single route inside a React-Navigation-shaped state (structural — no `@react-navigation`). */
+interface NavigationRouteLike {
+    name: string;
+    /** A nested navigator's own state, when this route hosts one. */
+    state?: NavigationStateLike;
+    /** Route params are intentionally left `unknown` — this helper never reads them. */
+    params?: unknown;
+}
+/** A React-Navigation-shaped navigator state (structural type; no library import). */
+interface NavigationStateLike {
+    /** Index of the active route within `routes`. */
+    index?: number;
+    routes?: NavigationRouteLike[];
+}
+/** Options for {@link createScreenTracker}. */
+interface ScreenTrackerOptions {
+    /**
+     * Where to POST. `{ serverUrl, apiKey }` — same shape the kit's review/analytics config
+     * exposes. When omitted, the tracker still de-dups and fires `onScreen`, but sends nothing.
+     */
+    target?: {
+        serverUrl: string;
+        apiKey: string;
+    };
+    /** The onboarding/session id to correlate screen views with, when known. */
+    sessionId?: string;
+    /** A stable, non-PII device id — groups a device's sessions server-side. */
+    deviceKey?: string;
+    /** Called on every REAL screen change (after de-dup), before the network emit. */
+    onScreen?: (screen: string) => void;
+    /**
+     * Per-screen filter. Return `false` to skip the NETWORK emit for a screen (last-screen memory
+     * is still advanced + `onScreen` still fires) — e.g. to keep a sensitive route out of analytics.
+     */
+    shouldTrack?: (screen: string) => boolean;
+}
+/** The screen tracker returned by {@link createScreenTracker}. */
+interface ScreenTracker {
+    /** Report the active screen. Ignores `undefined`/empty and de-dups repeats of the last screen. */
+    track: (screen: string | undefined) => void;
+    /** Clear the last-screen memory (e.g. on logout) so the next `track` always emits. */
+    reset: () => void;
+}
+/**
+ * Walk a React-Navigation-shaped state to the DEEPEST active route and return its NAME (never
+ * its params). Recurses `routes[index]` while a nested `.state` exists. Returns `undefined` for
+ * a missing/empty/malformed state — the caller treats that as "nothing to report".
+ */
+declare const getActiveRouteName: (state: NavigationStateLike | undefined) => string | undefined;
+/**
+ * Build a stateful screen tracker. `track` de-dups against the last reported screen so only a
+ * REAL change emits; `reset` clears that memory. Fire-and-forget throughout — a missing `target`
+ * skips the network but keeps the de-dup + `onScreen` behaviour intact.
+ */
+declare const createScreenTracker: (options?: ScreenTrackerOptions) => ScreenTracker;
+/**
+ * Adapt a tracker into a React-Navigation `onStateChange` handler — the one-place wiring:
+ *
+ *   <NavigationContainer onStateChange={screenTrackingHandler(tracker)}>
+ *
+ * It resolves the deepest active route name and hands it to `tracker.track` (which de-dups).
+ */
+declare const screenTrackingHandler: (tracker: ScreenTracker) => (state: NavigationStateLike | undefined) => void;
+
+/**
+ * The structural slice of a React-Navigation container ref this hook needs — no
+ * `@react-navigation` import. `getCurrentRoute` yields the active route; `addListener("state", …)`
+ * fires on every navigation state change and returns its own unsubscribe.
+ */
+interface NavigationRefLike {
+    getCurrentRoute?: () => {
+        name?: string;
+    } | undefined;
+    addListener?: (type: "state", callback: () => void) => () => void;
+}
+/**
+ * Subscribe screen tracking to a host navigation ref. Safe to call with a not-yet-ready ref
+ * (the effect no-ops until `addListener` exists). Returns nothing — it wires side effects only.
+ */
+declare const useScreenTracking: (navigationRef: NavigationRefLike | undefined, options?: ScreenTrackerOptions) => void;
+
+export { type NavigationRefLike, type NavigationRouteLike, type NavigationStateLike, type ScreenTracker, type ScreenTrackerOptions, createScreenTracker, getActiveRouteName, screenTrackingHandler, useScreenTracking };

package/dist/analytics/index.js

@@ -0,0 +1,439 @@
+'use strict';
+
+var react = require('react');
+var reactNative = require('react-native');
+
+// src/reviews/transport.ts
+var reportAppEvent = (target, name, options = {}) => {
+  if (!(target == null ? void 0 : target.serverUrl) || !name) return;
+  try {
+    const url = `${target.serverUrl.replace(/\/$/, "")}/v1/events`;
+    const headers = { "Content-Type": "application/json" };
+    if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
+    const event = {
+      event_type: "app_event",
+      question_key: name
+    };
+    if (options.sessionId) event.session_id = options.sessionId;
+    if (options.deviceKey) event.user_context = { device_key: options.deviceKey };
+    if (options.meta && Object.keys(options.meta).length > 0) {
+      event.meta = JSON.stringify(options.meta);
+    }
+    void fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ events: [event] })
+    }).catch(() => {
+    });
+  } catch {
+  }
+};
+
+// src/analytics/screenTracking.ts
+var getActiveRouteName = (state) => {
+  let current = state;
+  let name;
+  while (current && Array.isArray(current.routes) && current.routes.length > 0) {
+    const index = typeof current.index === "number" ? current.index : 0;
+    const route = current.routes[index];
+    if (!route) break;
+    name = route.name;
+    current = route.state;
+  }
+  return name;
+};
+var createScreenTracker = (options = {}) => {
+  let lastScreen;
+  return {
+    track: (screen) => {
+      var _a;
+      if (!screen || screen === lastScreen) return;
+      lastScreen = screen;
+      (_a = options.onScreen) == null ? void 0 : _a.call(options, screen);
+      if (options.shouldTrack && !options.shouldTrack(screen)) return;
+      reportAppEvent(options.target, "screen", {
+        sessionId: options.sessionId,
+        deviceKey: options.deviceKey,
+        meta: { screen }
+      });
+    },
+    reset: () => {
+      lastScreen = void 0;
+    }
+  };
+};
+var screenTrackingHandler = (tracker) => (state) => tracker.track(getActiveRouteName(state));
+var useScreenTracking = (navigationRef, options = {}) => {
+  const trackerRef = react.useRef(void 0);
+  if (!trackerRef.current) trackerRef.current = createScreenTracker(options);
+  react.useEffect(() => {
+    const tracker = trackerRef.current;
+    if (!tracker || !(navigationRef == null ? void 0 : navigationRef.addListener)) return;
+    const report = () => {
+      var _a, _b;
+      return tracker.track((_b = (_a = navigationRef.getCurrentRoute) == null ? void 0 : _a.call(navigationRef)) == null ? void 0 : _b.name);
+    };
+    report();
+    const unsubscribe = navigationRef.addListener("state", report);
+    return unsubscribe;
+  }, [navigationRef]);
+};
+
+// src/analytics/reportClientEvent.ts
+var makeSessionId = () => `wire_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+var reportClientEvents = (target, events) => {
+  if (!(target == null ? void 0 : target.serverUrl) || events.length === 0) return;
+  try {
+    const url = `${target.serverUrl.replace(/\/$/, "")}/v1/events`;
+    const headers = { "Content-Type": "application/json" };
+    if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
+    void fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ events })
+    }).catch(() => {
+    });
+  } catch {
+  }
+};
+var reportClientEvent = (target, event) => reportClientEvents(target, [event]);
+
+// src/analytics/analyticsEvent.ts
+var WIRE_ONBOARDING_EVENTS = {
+  started: "wire_onboarding_started",
+  /** A persisted session was restored after an app kill (fires instead of `started`). */
+  resumed: "wire_onboarding_resumed",
+  turn: "wire_onboarding_turn",
+  error: "wire_onboarding_error",
+  retry: "wire_onboarding_retry",
+  fallback: "wire_onboarding_fallback",
+  /** Logged by the host on `onComplete` (no matching kit `OnboardingEvent`). */
+  completed: "wire_onboarding_completed"
+};
+var toAnalyticsEvent = (event) => {
+  switch (event.type) {
+    case "started":
+      return { name: WIRE_ONBOARDING_EVENTS.started };
+    case "resumed":
+      return { name: WIRE_ONBOARDING_EVENTS.resumed };
+    case "turn":
+      return {
+        name: WIRE_ONBOARDING_EVENTS.turn,
+        params: { step: event.step, component: event.component }
+      };
+    case "error":
+      return { name: WIRE_ONBOARDING_EVENTS.error, params: { reason: event.reason } };
+    case "retry":
+      return {
+        name: WIRE_ONBOARDING_EVENTS.retry,
+        params: { reason: event.reason, attempt: event.attempt }
+      };
+    case "fallback":
+      return { name: WIRE_ONBOARDING_EVENTS.fallback, params: { reason: event.reason } };
+    default: {
+      const _exhaustive = event;
+      return _exhaustive;
+    }
+  }
+};
+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 };
+};
+
+exports.WIRE_ONBOARDING_EVENTS = WIRE_ONBOARDING_EVENTS;
+exports.buildContextEnvelope = buildContextEnvelope;
+exports.createEventQueue = createEventQueue;
+exports.createScreenTracker = createScreenTracker;
+exports.getActiveRouteName = getActiveRouteName;
+exports.makeSessionId = makeSessionId;
+exports.reportAppEvent = reportAppEvent;
+exports.reportClientEvent = reportClientEvent;
+exports.reportClientEvents = reportClientEvents;
+exports.screenTrackingHandler = screenTrackingHandler;
+exports.toAnalyticsEvent = toAnalyticsEvent;
+exports.useScreenTracking = useScreenTracking;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map