@mrrocket/sdk 0.2.0 → 0.4.0

package/dist/react-native/index.js

@@ -0,0 +1,922 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/native/index.tsx
+var native_exports = {};
+__export(native_exports, {
+  MRRocketProvider: () => MRRocketProvider,
+  SDK_VERSION: () => SDK_VERSION,
+  activeRouteName: () => activeRouteName,
+  createMRRocket: () => createMRRocket,
+  getMRRocket: () => getMRRocket,
+  useExpoRouterTracking: () => useExpoRouterTracking,
+  useFlag: () => useFlag,
+  useFlagVariant: () => useFlagVariant,
+  useMRRocket: () => useMRRocket,
+  useNavigationTracking: () => useNavigationTracking,
+  useVariant: () => useVariant
+});
+module.exports = __toCommonJS(native_exports);
+var import_react = require("react");
+
+// src/core.ts
+var SDK_VERSION = "0.4.0";
+var propOf = (person, name) => {
+  const want = name.trim().toLowerCase();
+  for (const [k, v] of Object.entries(person)) if (k.toLowerCase() === want) return v;
+  return void 0;
+};
+var same = (actual, value) => {
+  const a = actual.trim().toLowerCase();
+  const v = value.trim().toLowerCase();
+  return v.startsWith("@") ? a.endsWith(v) : a === v;
+};
+var matchesCondition = (c, person) => {
+  if (c.op === "in cohort") return false;
+  const raw = propOf(person, c.property);
+  const actual = raw === void 0 || raw === null ? "" : String(raw);
+  if (c.op === "\u2265") {
+    const a = Number(actual);
+    const b = Number(c.values[0]);
+    return actual !== "" && Number.isFinite(a) && Number.isFinite(b) && a >= b;
+  }
+  const hit = actual !== "" && c.values.some((v) => same(actual, v));
+  return c.op === "is" || c.op === "in" ? hit : !hit;
+};
+var evaluateFlag = (flag, distinctId, person = {}) => {
+  if (!flag.on) return false;
+  const subject = { id: distinctId, ...person };
+  const set = flag.sets.length ? flag.sets.find((s) => s.conditions.every((c) => matchesCondition(c, subject))) : { conditions: [], rollout: 100 };
+  if (!set) return false;
+  if (flagUnit(`${flag.key}:rollout:${distinctId}`) * 100 >= set.rollout) return false;
+  if (!flag.variants?.length) return true;
+  const u = flagUnit(`${flag.key}:variant:${distinctId}`) * 100;
+  let acc = 0;
+  for (const v of flag.variants) {
+    acc += v.split;
+    if (u < acc) return v.key;
+  }
+  return flag.variants[flag.variants.length - 1].key;
+};
+var flagFor = (key, config, distinctId, person = {}) => {
+  const flag = config?.flags?.find((f) => f.key === key);
+  return flag ? evaluateFlag(flag, distinctId, person) : false;
+};
+var UTM_KEYS = ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"];
+var SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+var utmFrom = (get) => {
+  const out = {};
+  for (const key of UTM_KEYS) {
+    const value = get(key)?.trim();
+    if (value) out[key] = value.slice(0, 150);
+  }
+  return out;
+};
+var parseQuery = (url) => {
+  const out = {};
+  const q = url.split("#")[0];
+  const at = q.indexOf("?");
+  if (at < 0) return out;
+  const dec = (s) => {
+    try {
+      return decodeURIComponent(s.replace(/\+/g, " "));
+    } catch {
+      return s;
+    }
+  };
+  for (const pair of q.slice(at + 1).split("&")) {
+    if (!pair) continue;
+    const eq = pair.indexOf("=");
+    const k = dec(eq < 0 ? pair : pair.slice(0, eq));
+    if (k && !(k in out)) out[k] = eq < 0 ? "" : dec(pair.slice(eq + 1));
+  }
+  return out;
+};
+var hashUnit = (input) => {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0) / 4294967296;
+};
+var flagUnit = (input) => {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  h ^= h >>> 16;
+  h = Math.imul(h, 2246822507);
+  h ^= h >>> 13;
+  h = Math.imul(h, 3266489909);
+  h ^= h >>> 16;
+  return (h >>> 0) / 4294967296;
+};
+var assign = (experiment, distinctId) => {
+  const control = experiment.variants[0]?.id ?? "control";
+  if (experiment.winner) return experiment.winner;
+  if (experiment.status !== "running") return control;
+  const u = hashUnit(`${experiment.key}:${distinctId}`);
+  let acc = 0;
+  for (const v of experiment.variants) {
+    acc += v.weight;
+    if (u < acc) return v.id;
+  }
+  return experiment.variants[experiment.variants.length - 1]?.id ?? control;
+};
+var resolveVariant = (key, config, distinctId, preview) => {
+  if (preview[key]) return preview[key];
+  const experiment = config?.experiments.find((e) => e.key === key);
+  return experiment ? assign(experiment, distinctId) : "control";
+};
+var newDistinctId = () => typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `ck_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+
+// src/batch.ts
+var MAX_BATCH = 100;
+var MAX_BYTES = 6e4;
+var byteLength = (s) => {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 128) n += 1;
+    else if (c < 2048) n += 2;
+    else if (c >= 55296 && c <= 56319 && i + 1 < s.length && (s.charCodeAt(i + 1) & 64512) === 56320) {
+      n += 4;
+      i++;
+    } else n += 3;
+  }
+  return n;
+};
+var batchRequests = (key, events, sdk) => {
+  const head = `{"key":${JSON.stringify(key)},"sdk":${JSON.stringify(sdk)},"events":[`;
+  const empty = byteLength(head) + 2;
+  const out = [];
+  let chunk = [];
+  let items = [];
+  let size = empty;
+  const close = () => {
+    if (chunk.length) out.push({ body: `${head}${chunk.join(",")}]}`, events: items });
+    chunk = [];
+    items = [];
+    size = empty;
+  };
+  for (const event of events) {
+    const json = JSON.stringify(event);
+    const n = byteLength(json) + 1;
+    if (empty + n > MAX_BYTES) continue;
+    if (chunk.length === MAX_BATCH || size + n > MAX_BYTES) close();
+    chunk.push(json);
+    items.push(event);
+    size += n;
+  }
+  close();
+  return out;
+};
+
+// src/errors.ts
+var MAX_STACK = 8 * 1024;
+var clip = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+var describeError = (error) => {
+  if (error instanceof Error) return { type: error.name || "Error", message: clip(error.message || String(error), 1e3), stack: error.stack ? clip(error.stack, MAX_STACK) : void 0 };
+  if (typeof error === "string") return { type: "Error", message: clip(error, 1e3) };
+  try {
+    return { type: "Error", message: clip(JSON.stringify(error) ?? String(error), 1e3) };
+  } catch {
+    return { type: "Error", message: String(error) };
+  }
+};
+
+// src/referral.ts
+var REF_PARAM = "mrr_ref";
+var CLICK_PARAM = "mrr_click";
+var CODE = /^[A-Za-z0-9_-]{1,64}$/;
+var referralFrom = (get, param = "ref") => {
+  const marked = get(REF_PARAM);
+  if (marked && CODE.test(marked)) {
+    const click = get(CLICK_PARAM);
+    return { code: marked, clickId: click && CODE.test(click) ? click : null, direct: false };
+  }
+  const direct = get(param);
+  return direct && CODE.test(direct) ? { code: direct, clickId: null, direct: true } : null;
+};
+var carriesReferral = (event) => event === "$identify" || !event.startsWith("$");
+
+// src/native/client.ts
+var DEFAULT_HOST = "https://app.mrrocket.dev";
+var KEYS = {
+  id: "mrrocket:id",
+  queue: "mrrocket:queue",
+  config: "mrrocket:config",
+  installed: "mrrocket:installed",
+  referral: "mrrocket:referral"
+};
+var MAX_ERRORS = 20;
+var MAX_CRUMBS = 20;
+var MAX_BACKOFF_MS = 5 * 60 * 1e3;
+var REQUEST_TIMEOUT_MS = 15e3;
+var EAGER_COUNT = 20;
+var clip2 = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+var createClient = (options, deps) => {
+  const apiKey = (options.apiKey ?? "").trim();
+  const host = (options.host ?? DEFAULT_HOST).trim().replace(/\/+$/, "");
+  const now = deps.now ?? (() => Date.now());
+  const setIntervalFn = deps.setInterval ?? ((fn, ms) => setInterval(fn, ms));
+  const clearIntervalFn = deps.clearInterval ?? ((id) => clearInterval(id));
+  const setTimeoutFn = deps.setTimeout ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimeoutFn = deps.clearTimeout ?? ((id) => clearTimeout(id));
+  const flushEvery = Math.max(1e3, options.flushIntervalMs ?? 1e4);
+  const maxQueue = Math.max(10, options.maxQueue ?? 1e3);
+  const errorsOn = options.errors !== false;
+  const storage = deps.storage;
+  const warned = /* @__PURE__ */ new Set();
+  const warn = (message) => {
+    if (warned.has(message)) return;
+    warned.add(message);
+    (deps.log ?? ((m) => console.warn(m)))(`[MRRocket] ${message}`);
+  };
+  const debug = (message) => {
+    if (options.debug) (deps.log ?? ((m) => console.log(m)))(`[MRRocket] ${message}`);
+  };
+  if (!apiKey) warn("No public key. Pass apiKey to MRRocketProvider; nothing is sent until then.");
+  let context = { platform: "unknown" };
+  try {
+    context = deps.context();
+  } catch {
+  }
+  const appId = (deps.appId || "app").replace(/[^A-Za-z0-9._-]/g, "") || "app";
+  const release = options.release ?? (context.appVersion ? `${context.appVersion}${context.build ? ` (${context.build})` : ""}` : void 0);
+  const sdk = { v: SDK_VERSION, errors: errorsOn, platform: context.platform };
+  let consent = options.consent ?? "anonymous";
+  let installId = null;
+  let memoryId = newDistinctId();
+  let identified;
+  let person;
+  let config = null;
+  let queue = [];
+  let session = null;
+  let utm = null;
+  let referral = null;
+  let currentScreen;
+  let loaded = false;
+  let closed = false;
+  let isReady = false;
+  let version = 0;
+  let failures = 0;
+  let backoffUntil = 0;
+  let inFlight = null;
+  let persistTimer = null;
+  let flushTimer = null;
+  let errorTimer = null;
+  let appState = deps.appState?.currentState ?? "active";
+  let backgroundSince = null;
+  const early = [];
+  const exposed = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const crumbs = [];
+  const errorQueue = [];
+  const errorsSeen = /* @__PURE__ */ new Set();
+  let errorsSent = 0;
+  const changed = () => {
+    version++;
+    for (const l of [...listeners]) {
+      try {
+        l();
+      } catch {
+      }
+    }
+  };
+  const crumb = (type, message) => {
+    crumbs.push({ ts: now(), type, message: clip2(message, 120) });
+    if (crumbs.length > MAX_CRUMBS) crumbs.shift();
+  };
+  const get = async (key) => {
+    if (!storage) return null;
+    try {
+      return await storage.getItem(key);
+    } catch {
+      return null;
+    }
+  };
+  const set = async (key, value) => {
+    if (!storage) return;
+    try {
+      await storage.setItem(key, value);
+    } catch {
+      warn("Could not write to the device storage; events wait in memory only.");
+    }
+  };
+  const remove = async (key) => {
+    if (!storage) return;
+    try {
+      await storage.removeItem(key);
+    } catch {
+    }
+  };
+  const persistQueue = async () => {
+    if (persistTimer !== null) {
+      clearTimeoutFn(persistTimer);
+      persistTimer = null;
+    }
+    if (!storage || consent === "off") return;
+    if (queue.length) await set(KEYS.queue, JSON.stringify(queue));
+    else await remove(KEYS.queue);
+  };
+  const schedulePersist = () => {
+    if (!storage || persistTimer !== null) return;
+    persistTimer = setTimeoutFn(() => {
+      persistTimer = null;
+      void persistQueue();
+    }, 1e3);
+  };
+  const distinctId = () => identified ?? (consent === "persistent" && installId ? installId : memoryId);
+  const sendId = () => consent === "persistent" ? distinctId() : identified;
+  const touchSession = () => {
+    const t = now();
+    if (!session || t - session.last >= SESSION_TIMEOUT_MS) session = { id: newDistinctId(), last: t };
+    else session.last = t;
+    return session.id;
+  };
+  const urlOf = (path = currentScreen) => `app://${appId}${path ?? "/"}`;
+  const record = (event, props, ts = now()) => {
+    if (closed) return;
+    if (!loaded) {
+      early.push(() => record(event, props, ts));
+      return;
+    }
+    if (consent === "off" || !apiKey) return;
+    const sessionId = touchSession();
+    const ref = referral && carriesReferral(event) ? referral : null;
+    const size = deps.screen?.();
+    queue.push({
+      event,
+      props: ref ? { ...props, $referral: ref } : props,
+      distinctId: sendId(),
+      sessionId,
+      ts,
+      url: urlOf(),
+      ...utm && utm.session === sessionId ? utm.values : {},
+      ...size ? { screen: { w: Math.round(size.w), h: Math.round(size.h) } } : {},
+      app: context
+    });
+    if (queue.length > maxQueue) queue.splice(0, queue.length - maxQueue);
+    schedulePersist();
+    if (queue.length >= EAGER_COUNT) void flush();
+  };
+  const post = async (path, body) => {
+    const ctl = typeof AbortController !== "undefined" ? new AbortController() : null;
+    const timer = ctl ? setTimeoutFn(() => ctl.abort(), REQUEST_TIMEOUT_MS) : null;
+    try {
+      const r = await deps.fetch(`${host}${path}`, { method: "POST", headers: { "content-type": "application/json" }, body, signal: ctl?.signal });
+      return r.status;
+    } catch {
+      return 0;
+    } finally {
+      if (timer !== null) clearTimeoutFn(timer);
+    }
+  };
+  const sendQueue = async () => {
+    if (!queue.length || consent === "off" || !apiKey) return;
+    if (now() < backoffUntil) return;
+    const snapshot = queue.slice();
+    const requests = batchRequests(apiKey, snapshot, sdk);
+    const included = new Set(requests.flatMap((r) => r.events));
+    const done = /* @__PURE__ */ new Set();
+    for (const r of requests) {
+      const status = await post("/api/sdk/events", r.body);
+      if (status >= 200 && status < 300) {
+        r.events.forEach((e) => done.add(e));
+        failures = 0;
+        backoffUntil = 0;
+      } else if (status >= 400 && status < 500 && status !== 408 && status !== 429) {
+        r.events.forEach((e) => done.add(e));
+        warn(`Events were rejected with ${status}. Check the public key (MRRocket \u203A Settings \u203A Products) and the host.`);
+      } else {
+        failures++;
+        backoffUntil = now() + Math.min(MAX_BACKOFF_MS, 1e3 * 2 ** failures);
+        debug(`Sending failed (${status || "offline"}); next try in ${Math.round((backoffUntil - now()) / 1e3)} s.`);
+        break;
+      }
+    }
+    queue = queue.filter((e) => !done.has(e) && (included.has(e) || !snapshot.includes(e)));
+    await persistQueue();
+  };
+  let nextFlush = null;
+  const flush = () => {
+    if (inFlight)
+      return nextFlush ?? (nextFlush = inFlight.then(() => {
+        nextFlush = null;
+        return flush();
+      }));
+    inFlight = sendQueue().finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  };
+  const startTimer = () => {
+    if (flushTimer !== null || closed) return;
+    flushTimer = setIntervalFn(() => void flush(), flushEvery);
+  };
+  const stopTimer = () => {
+    if (flushTimer === null) return;
+    clearIntervalFn(flushTimer);
+    flushTimer = null;
+  };
+  const sendErrors = async () => {
+    if (errorTimer !== null) {
+      clearTimeoutFn(errorTimer);
+      errorTimer = null;
+    }
+    while (errorQueue.length) {
+      const batch = errorQueue.splice(0, 4);
+      const status = await post("/api/sdk/errors", JSON.stringify({ key: apiKey, sdk, errors: batch }));
+      if (status >= 400 && status < 500 && status !== 429) warn(`Error reports were rejected with ${status}. Check the public key and the host.`);
+    }
+  };
+  const capture = (error, mechanism, fatal = false) => {
+    if (!errorsOn || closed || consent === "off" || !apiKey || errorsSent >= MAX_ERRORS) return;
+    const d = describeError(error);
+    if (/\/api\/sdk\/errors/.test(d.message)) return;
+    const mark = `${d.type}:${d.message}`;
+    if (errorsSeen.has(mark)) return;
+    errorsSeen.add(mark);
+    errorsSent++;
+    const who = sendId();
+    errorQueue.push({
+      ...d,
+      mechanism,
+      handled: mechanism === "manual",
+      url: urlOf(),
+      ts: now(),
+      crumbs: crumbs.slice(),
+      ...release ? { release } : {},
+      ...who ? { distinctId: who } : {},
+      ...session ? { sessionId: session.id } : {}
+    });
+    if (fatal) void sendErrors();
+    else if (errorTimer === null) errorTimer = setTimeoutFn(() => void sendErrors(), 2e3);
+  };
+  let previousHandler;
+  let handlerInstalled = false;
+  const installErrorHandler = () => {
+    if (!errorsOn || !deps.errorUtils || handlerInstalled) return;
+    handlerInstalled = true;
+    previousHandler = deps.errorUtils.getGlobalHandler();
+    deps.errorUtils.setGlobalHandler((error, isFatal) => {
+      try {
+        capture(error, "onerror", !!isFatal);
+      } catch {
+      }
+      previousHandler?.(error, isFatal);
+    });
+  };
+  let appStateSub;
+  const onAppState = (next) => {
+    if (closed) return;
+    const prev = appState;
+    appState = next;
+    if (next === "active" && prev !== "active") {
+      startTimer();
+      if (backgroundSince !== null) {
+        backgroundSince = null;
+        crumb("lifecycle", "app_open");
+        if (options.lifecycle !== false) record("$app_open", { cold: false });
+      }
+    } else if (next === "background" && prev !== "background") {
+      backgroundSince = now();
+      crumb("lifecycle", "app_background");
+      if (options.lifecycle !== false) record("$app_background");
+      stopTimer();
+      void persistQueue();
+      void flush();
+      if (errorQueue.length) void sendErrors();
+    }
+  };
+  const fetchConfig = async () => {
+    if (!apiKey) return;
+    try {
+      const r = await deps.fetch(`${host}/api/sdk/config?key=${encodeURIComponent(apiKey)}`, { method: "GET" });
+      if (!r.ok) {
+        warn(`Config request answered ${r.status}. Check the public key and the host.`);
+        return;
+      }
+      const c = await r.json();
+      if (c && Array.isArray(c.experiments)) {
+        config = c;
+        if (consent !== "off") await set(KEYS.config, JSON.stringify(c));
+        changed();
+      }
+    } catch {
+      debug("Config not reachable; using the cached one.");
+    }
+  };
+  let resolveReady = () => {
+  };
+  const ready = new Promise((r) => {
+    resolveReady = r;
+  });
+  const markReady = () => {
+    if (isReady) return;
+    isReady = true;
+    resolveReady();
+    changed();
+  };
+  const start = async () => {
+    let firstOpen = false;
+    if (consent !== "off") {
+      const [id, stored, cached, installed, ref] = await Promise.all([
+        get(KEYS.id),
+        get(KEYS.queue),
+        get(KEYS.config),
+        get(KEYS.installed),
+        get(KEYS.referral)
+      ]);
+      if (consent === "persistent") {
+        installId = id || newDistinctId();
+        if (!id) await set(KEYS.id, installId);
+      } else if (id) await remove(KEYS.id);
+      try {
+        const old = stored ? JSON.parse(stored) : [];
+        if (Array.isArray(old)) queue = [...old.filter((e) => e && typeof e.event === "string"), ...queue].slice(-maxQueue);
+      } catch {
+        await remove(KEYS.queue);
+      }
+      try {
+        const c = cached ? JSON.parse(cached) : null;
+        if (c && Array.isArray(c.experiments) && !config) config = c;
+      } catch {
+        await remove(KEYS.config);
+      }
+      try {
+        const r = ref && consent === "persistent" ? JSON.parse(ref) : null;
+        if (r && typeof r.code === "string") referral = r;
+      } catch {
+      }
+      firstOpen = !!storage && !installed;
+      if (firstOpen) await set(KEYS.installed, String(now()));
+    } else {
+      await Promise.all(Object.values(KEYS).map(remove));
+    }
+    if (closed) return;
+    loaded = true;
+    if (config) markReady();
+    let install = null;
+    if (firstOpen) {
+      install = {};
+      if (options.attribution !== false && deps.initialUrl) {
+        const url = await deps.initialUrl().catch(() => null);
+        if (url) {
+          const q = parseQuery(url);
+          const values = utmFrom((k) => q[k]);
+          if (Object.keys(values).length) utm = { session: touchSession(), values };
+          const found = referralFrom((k) => q[k]);
+          if (found) {
+            referral = { code: found.code, clickId: found.clickId };
+            install.$referral = referral;
+            if (consent === "persistent") await set(KEYS.referral, JSON.stringify(referral));
+          }
+          install.link = clip2(url.split("?")[0], 300);
+        }
+      }
+    }
+    crumb("lifecycle", "app_open");
+    if (options.lifecycle !== false) record("$app_open", { cold: true });
+    if (install) record("$install", install);
+    for (const run of early.splice(0)) run();
+    if (deps.appState) appStateSub = deps.appState.addEventListener("change", onAppState);
+    installErrorHandler();
+    if (appState === "active" || !deps.appState) startTimer();
+    if (queue.length) void flush();
+    await fetchConfig();
+    markReady();
+  };
+  void start().catch(() => {
+    loaded = true;
+    markReady();
+  });
+  const client = {
+    track: (event, props) => {
+      if (typeof event !== "string" || !event) return;
+      record(event, props);
+    },
+    screen: (name, props) => {
+      if (typeof name !== "string" || !name.trim()) return;
+      const path = (name.startsWith("/") ? name : `/${name}`).slice(0, 300);
+      if (path === currentScreen && !props) return;
+      const previous = currentScreen;
+      currentScreen = path;
+      crumb("navigation", path);
+      record("$screen", { ...props, path, screen: name, ...previous ? { previous } : {} });
+    },
+    identify: (id, props) => {
+      if (typeof id !== "string" || !id) return;
+      if (!loaded) {
+        early.push(() => client.identify(id, props));
+        return;
+      }
+      const previous = sendId();
+      identified = id;
+      person = { ...props, id };
+      record("$identify", { ...props, id, ...previous && previous !== id ? { previousId: previous } : {} });
+      if (consent === "persistent") void set(KEYS.id, id);
+      changed();
+    },
+    reset: () => {
+      if (!loaded) {
+        early.push(() => client.reset());
+        return;
+      }
+      identified = void 0;
+      person = void 0;
+      session = null;
+      utm = null;
+      exposed.clear();
+      memoryId = newDistinctId();
+      if (consent === "persistent") {
+        installId = newDistinctId();
+        void set(KEYS.id, installId);
+      }
+      changed();
+    },
+    setConsent: (next) => {
+      if (next !== "anonymous" && next !== "persistent" && next !== "off") {
+        warn(`setConsent: "${String(next)}" is not a consent mode. Use "anonymous", "persistent" or "off".`);
+        return;
+      }
+      if (!loaded) {
+        early.push(() => client.setConsent(next));
+        return;
+      }
+      if (next === consent) return;
+      const before = consent;
+      consent = next;
+      if (next === "off") {
+        queue = [];
+        session = null;
+        errorQueue.length = 0;
+        void Promise.all(Object.values(KEYS).map(remove));
+      } else if (next === "anonymous") {
+        installId = null;
+        void remove(KEYS.id);
+        void remove(KEYS.referral);
+      } else {
+        installId = identified ?? newDistinctId();
+        void set(KEYS.id, installId);
+        if (referral) void set(KEYS.referral, JSON.stringify(referral));
+      }
+      if (before === "off" && currentScreen && loaded) record("$screen", { path: currentScreen, screen: currentScreen });
+      changed();
+    },
+    captureError: (error) => capture(error, "manual"),
+    getFlag: (key) => flagFor(key, config, distinctId(), { ...person }) !== false,
+    getFlagVariant: (key) => {
+      const v = flagFor(key, config, distinctId(), { ...person });
+      return typeof v === "string" ? v : null;
+    },
+    getVariant: (key) => {
+      const variant = resolveVariant(key, config, distinctId(), {});
+      client.expose(key, variant);
+      return variant;
+    },
+    peekVariant: (key) => resolveVariant(key, config, distinctId(), {}),
+    expose: (key, variant) => {
+      if (!config || consent === "off") return;
+      const mark = `${currentScreen ?? "/"}|${key}`;
+      if (exposed.has(mark)) return;
+      exposed.add(mark);
+      record("$exposure", { experiment: key, variant });
+    },
+    flush,
+    ready,
+    isReady: () => isReady,
+    getDistinctId: distinctId,
+    getConsent: () => consent,
+    getConfig: () => config,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getVersion: () => version,
+    close: async () => {
+      if (closed) return;
+      stopTimer();
+      appStateSub?.remove();
+      if (handlerInstalled && deps.errorUtils && previousHandler) deps.errorUtils.setGlobalHandler(previousHandler);
+      await flush();
+      await sendErrors();
+      await persistQueue();
+      closed = true;
+    },
+    queued: () => queue
+  };
+  return client;
+};
+var activeRouteName = (state) => {
+  let s = state;
+  let name;
+  for (let depth = 0; s && Array.isArray(s.routes) && s.routes.length && depth < 20; depth++) {
+    const route = s.routes[typeof s.index === "number" ? s.index : s.routes.length - 1];
+    if (!route) break;
+    name = route.name ?? name;
+    s = route.state;
+  }
+  return name;
+};
+
+// src/native/platform.ts
+var RN = require("react-native");
+var asyncStorageModule = null;
+try {
+  asyncStorageModule = require("@react-native-async-storage/async-storage");
+} catch {
+  asyncStorageModule = null;
+}
+var expoDevice = null;
+try {
+  expoDevice = require("expo-device");
+} catch {
+  expoDevice = null;
+}
+var expoApplication = null;
+try {
+  expoApplication = require("expo-application");
+} catch {
+  expoApplication = null;
+}
+var expoLocalization = null;
+try {
+  expoLocalization = require("expo-localization");
+} catch {
+  expoLocalization = null;
+}
+var asyncStorage = () => {
+  const m = asyncStorageModule;
+  const s = m?.default ?? m;
+  return s && typeof s.getItem === "function" && typeof s.setItem === "function" && typeof s.removeItem === "function" ? s : null;
+};
+var DEVICE_TYPES = { 1: "phone", 2: "tablet", 3: "desktop", 4: "tv" };
+var text = (v, max = 80) => typeof v === "string" && v.trim() ? v.trim().slice(0, max) : typeof v === "number" ? String(v) : void 0;
+var readContext = () => {
+  const p = RN.Platform;
+  let locale;
+  try {
+    locale = text(expoLocalization?.getLocales?.()[0]?.languageTag, 35);
+  } catch {
+    locale = void 0;
+  }
+  if (!locale) {
+    try {
+      locale = text(Intl.DateTimeFormat().resolvedOptions().locale, 35);
+    } catch {
+      locale = void 0;
+    }
+  }
+  const ctx = {
+    platform: p.OS,
+    appVersion: text(expoApplication?.nativeApplicationVersion),
+    build: text(expoApplication?.nativeBuildVersion),
+    osVersion: text(expoDevice?.osVersion) ?? text(p.Version),
+    deviceModel: text(expoDevice?.modelName) ?? text(p.constants?.Model),
+    deviceType: (expoDevice?.deviceType ? DEVICE_TYPES[expoDevice.deviceType] : void 0) ?? (p.isPad ? "tablet" : void 0),
+    locale
+  };
+  for (const k of Object.keys(ctx)) if (ctx[k] === void 0) delete ctx[k];
+  return ctx;
+};
+var nativeDeps = (overrides = {}) => ({
+  storage: overrides.storage !== void 0 ? overrides.storage : asyncStorage(),
+  fetch: ((url, init) => fetch(url, init)),
+  appState: RN.AppState,
+  errorUtils: globalThis.ErrorUtils ?? null,
+  context: readContext,
+  appId: text(expoApplication?.applicationId, 150),
+  screen: () => {
+    const s = RN.Dimensions.get("screen");
+    return s ? { w: s.width, h: s.height } : void 0;
+  },
+  initialUrl: () => RN.Linking.getInitialURL()
+});
+var optionalModules = () => ({
+  asyncStorage: !!asyncStorage(),
+  expoDevice: !!expoDevice,
+  expoApplication: !!expoApplication,
+  expoLocalization: !!expoLocalization
+});
+
+// src/native/index.tsx
+var shared = null;
+var sharedKey = "";
+var createMRRocket = (options) => {
+  if (shared) {
+    if (sharedKey !== options.apiKey) console.warn("[MRRocket] The SDK is already running with another key; keeping the first one.");
+    return shared;
+  }
+  const { storage, ...rest } = options;
+  const deps = nativeDeps({ storage });
+  shared = createClient(rest, deps);
+  sharedKey = options.apiKey;
+  if (options.debug) console.log("[MRRocket] optional modules", JSON.stringify(optionalModules()));
+  return shared;
+};
+var getMRRocket = () => shared;
+var Ctx = (0, import_react.createContext)(null);
+var MRRocketProvider = ({ client: given, children, consent, ...options }) => {
+  const [client] = (0, import_react.useState)(() => given ?? createMRRocket({ ...options, consent }));
+  (0, import_react.useEffect)(() => {
+    if (consent) client.setConsent(consent);
+  }, [client, consent]);
+  return (0, import_react.createElement)(Ctx.Provider, { value: client }, children);
+};
+var useClient = () => {
+  const c = (0, import_react.useContext)(Ctx);
+  if (!c) throw new Error("MRRocket: wrap your app in <MRRocketProvider apiKey=\u2026>.");
+  return c;
+};
+var useVersion = (client) => (0, import_react.useSyncExternalStore)(client.subscribe, client.getVersion, client.getVersion);
+var useMRRocket = () => {
+  const client = useClient();
+  useVersion(client);
+  return {
+    track: client.track,
+    screen: client.screen,
+    identify: client.identify,
+    reset: client.reset,
+    setConsent: client.setConsent,
+    captureError: client.captureError,
+    flush: client.flush,
+    distinctId: client.getDistinctId(),
+    consent: client.getConsent(),
+    ready: client.isReady()
+  };
+};
+var useFlag = (key) => {
+  const client = useClient();
+  useVersion(client);
+  return client.getFlag(key);
+};
+var useFlagVariant = (key) => {
+  const client = useClient();
+  useVersion(client);
+  return client.getFlagVariant(key);
+};
+var useVariant = (key) => {
+  const client = useClient();
+  useVersion(client);
+  const config = client.getConfig();
+  const variant = client.peekVariant(key);
+  (0, import_react.useEffect)(() => {
+    if (config) client.expose(key, variant);
+  }, [client, config, key, variant]);
+  return variant;
+};
+var expoRouter;
+var loadExpoRouter = () => {
+  if (expoRouter !== void 0) return expoRouter;
+  try {
+    expoRouter = require("expo-router");
+  } catch {
+    expoRouter = null;
+  }
+  return expoRouter;
+};
+var noPathname = () => void 0;
+var routerWarned = false;
+var useExpoRouterTracking = () => {
+  const client = useClient();
+  const router = loadExpoRouter();
+  if (router === null && !routerWarned) {
+    routerWarned = true;
+    console.warn("[MRRocket] useExpoRouterTracking needs expo-router. With React Navigation use useNavigationTracking.");
+  }
+  const pathname = (router?.usePathname ?? noPathname)();
+  (0, import_react.useEffect)(() => {
+    if (pathname) client.screen(pathname);
+  }, [client, pathname]);
+};
+var useNavigationTracking = () => {
+  const client = useClient();
+  return (0, import_react.useCallback)(
+    (state) => {
+      const name = activeRouteName(state);
+      if (name) client.screen(name);
+    },
+    [client]
+  );
+};
+//# sourceMappingURL=index.js.map