@simplr-ai/react-native 1.1.0

package/dist/hooks/index.cjs

@@ -0,0 +1,1104 @@
+'use strict';
+
+var react = require('react');
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/errors.ts
+var SimplrError = class _SimplrError extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.name = "SimplrError";
+    this.status = status;
+    this.body = body;
+    Object.setPrototypeOf(this, _SimplrError.prototype);
+  }
+};
+
+// src/http.ts
+async function apiRequest(cfg, method, path, body) {
+  const fetchImpl = cfg.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new SimplrError("global fetch is not available in this environment", 0, null);
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), cfg.timeoutMs);
+  try {
+    const res = await fetchImpl(`${cfg.baseUrl}${path}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...cfg.authHeaders
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
+      signal: controller.signal
+    });
+    const text = await res.text();
+    let parsed;
+    try {
+      parsed = text ? JSON.parse(text) : void 0;
+    } catch {
+      parsed = text;
+    }
+    if (!res.ok) {
+      const message = parsed && (parsed.message || parsed.error) || `Simplr API error ${res.status}`;
+      throw new SimplrError(message, res.status, parsed);
+    }
+    return parsed && typeof parsed === "object" && "content" in parsed ? parsed.content : parsed;
+  } catch (err) {
+    if (err instanceof SimplrError) throw err;
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new SimplrError(`Request to ${path} timed out after ${cfg.timeoutMs}ms`, 0, null);
+    }
+    throw new SimplrError(err instanceof Error ? err.message : "Network error", 0, null);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function normalizeBaseUrl(url) {
+  return url.replace(/\/+$/, "");
+}
+
+// src/hash.ts
+function murmurHash3(input, seed = 0) {
+  let h1 = seed;
+  const c1 = 3432918353;
+  const c2 = 461845907;
+  for (let i = 0; i < input.length; i++) {
+    let k1 = input.charCodeAt(i);
+    k1 = Math.imul(k1, c1);
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = Math.imul(k1, c2);
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1 = Math.imul(h1, 5) + 3864292196;
+  }
+  h1 ^= input.length;
+  h1 ^= h1 >>> 16;
+  h1 = Math.imul(h1, 2246822507);
+  h1 ^= h1 >>> 13;
+  h1 = Math.imul(h1, 3266489909);
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+function createFingerprintHash(components) {
+  const sortedKeys = Object.keys(components).sort();
+  const values = sortedKeys.map((key) => `${key}:${components[key] ?? "null"}`);
+  return murmurHash3(values.join("|")).toString(16).padStart(8, "0");
+}
+
+// src/device/storage.ts
+var STORAGE_KEY = "simplr_device_id";
+var STORAGE_TIMESTAMP_KEY = "simplr_device_id_ts";
+var asyncStorage;
+function getAsyncStorage() {
+  if (asyncStorage !== void 0) return asyncStorage;
+  try {
+    const mod = __require("@react-native-async-storage/async-storage");
+    const candidate = mod && (mod.default || mod);
+    asyncStorage = candidate && typeof candidate.getItem === "function" ? candidate : null;
+  } catch {
+    asyncStorage = null;
+  }
+  return asyncStorage;
+}
+var memoryDeviceId = null;
+var memoryCreatedAt = null;
+function generateDeviceId() {
+  const timestamp = Date.now().toString(36);
+  const r1 = Math.random().toString(36).substring(2, 15);
+  const r2 = Math.random().toString(36).substring(2, 15);
+  return `${timestamp}-${r1}-${r2}`;
+}
+async function getDeviceId() {
+  const store = getAsyncStorage();
+  if (store) {
+    try {
+      let id = await store.getItem(STORAGE_KEY);
+      let createdAt = await store.getItem(STORAGE_TIMESTAMP_KEY);
+      if (!id) {
+        id = generateDeviceId();
+        createdAt = (/* @__PURE__ */ new Date()).toISOString();
+        await store.setItem(STORAGE_KEY, id);
+        await store.setItem(STORAGE_TIMESTAMP_KEY, createdAt);
+      }
+      return { id, createdAt: createdAt ?? null };
+    } catch {
+    }
+  }
+  if (!memoryDeviceId) {
+    memoryDeviceId = generateDeviceId();
+    memoryCreatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  return { id: memoryDeviceId, createdAt: memoryCreatedAt };
+}
+function getReactNative() {
+  try {
+    const rn = __require("react-native");
+    return rn?.default || rn || {};
+  } catch {
+    return {};
+  }
+}
+function safeTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+function safeLocale() {
+  try {
+    const opts = Intl.DateTimeFormat().resolvedOptions();
+    const lang = opts.locale || "en";
+    return { language: lang, languages: [lang] };
+  } catch {
+    return { language: "en", languages: ["en"] };
+  }
+}
+async function collectDeviceSignals() {
+  const rn = getReactNative();
+  const Platform = rn.Platform;
+  const Dimensions = rn.Dimensions;
+  const PixelRatio = rn.PixelRatio;
+  const osRaw = (Platform?.OS || "unknown").toLowerCase();
+  const platform = osRaw === "ios" ? "ios" : "android";
+  const osVersion = Platform?.Version !== void 0 && Platform?.Version !== null ? String(Platform.Version) : null;
+  const constants = Platform?.constants || {};
+  const model = constants.Model || constants.uiMode || constants.Brand ? String(constants.Model || constants.uiMode || "") : null;
+  const brand = constants.Brand ? String(constants.Brand) : null;
+  const isEmulator = typeof constants.isTesting === "boolean" ? constants.isTesting : null;
+  let width = 0;
+  let height = 0;
+  try {
+    const screen = Dimensions?.get("screen") || Dimensions?.get("window");
+    if (screen) {
+      width = Math.round(screen.width);
+      height = Math.round(screen.height);
+    }
+  } catch {
+  }
+  let pixelRatio = 1;
+  let fontScale = 1;
+  try {
+    pixelRatio = PixelRatio?.get() ?? 1;
+    fontScale = PixelRatio?.getFontScale() ?? 1;
+  } catch {
+  }
+  const timezone = safeTimezone();
+  const timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+  const { language, languages } = safeLocale();
+  const screenResolution = `${width}x${height}`;
+  const deviceSignature = createFingerprintHash({
+    os: platform,
+    os_version: osVersion,
+    model,
+    brand
+  });
+  const screenSignature = createFingerprintHash({
+    resolution: screenResolution,
+    pixel_ratio: pixelRatio,
+    font_scale: fontScale
+  });
+  const localeSignature = createFingerprintHash({
+    timezone,
+    timezone_offset: timezoneOffset,
+    language
+  });
+  const fingerprint = createFingerprintHash({
+    device: deviceSignature,
+    screen: screenSignature,
+    locale: localeSignature
+  });
+  const { id: deviceId, createdAt } = await getDeviceId();
+  return {
+    fingerprint,
+    fingerprint_components: {
+      device_signature: deviceSignature,
+      screen_signature: screenSignature,
+      locale_signature: localeSignature
+    },
+    device_id: deviceId,
+    device_id_created_at: createdAt,
+    platform,
+    os: platform,
+    os_version: osVersion,
+    model,
+    brand,
+    screen_resolution: screenResolution,
+    device_pixel_ratio: pixelRatio,
+    font_scale: fontScale,
+    timezone,
+    timezone_offset: timezoneOffset,
+    language,
+    languages,
+    is_emulator: isEmulator
+  };
+}
+
+// src/biometrics/touch.ts
+function now() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function mean(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((s, v) => s + v, 0) / values.length;
+}
+function stdDev(values) {
+  if (values.length < 2) return 0;
+  const m = mean(values);
+  return Math.sqrt(mean(values.map((v) => (v - m) ** 2)));
+}
+var TouchTracker = class {
+  constructor() {
+    this.samples = [];
+    this.touchDurations = [];
+    this.tapTimestamps = [];
+    this.activeStart = null;
+    this.multiTouchCount = 0;
+    this.startTime = null;
+    this.tracking = false;
+  }
+  start() {
+    this.tracking = true;
+    this.reset();
+    this.tracking = true;
+  }
+  stop() {
+    this.tracking = false;
+  }
+  reset() {
+    this.samples = [];
+    this.touchDurations = [];
+    this.tapTimestamps = [];
+    this.activeStart = null;
+    this.multiTouchCount = 0;
+    this.startTime = null;
+  }
+  extract(e) {
+    const ne = e?.nativeEvent || {};
+    const x = ne.locationX ?? ne.pageX ?? 0;
+    const y = ne.locationY ?? ne.pageY ?? 0;
+    const ts = ne.timestamp ?? now();
+    return { x, y, timestamp: ts, force: ne.force ?? 0 };
+  }
+  /** Call on touch/gesture start (e.g. onResponderGrant / onTouchStart). */
+  handleTouchStart(e) {
+    if (!this.tracking) return;
+    const touches = e?.nativeEvent?.touches;
+    if (Array.isArray(touches) && touches.length > 1) {
+      this.multiTouchCount++;
+    }
+    const sample = this.extract(e);
+    if (this.startTime === null) this.startTime = sample.timestamp;
+    this.activeStart = sample.timestamp;
+    this.samples.push(sample);
+  }
+  /** Call on touch/gesture move (e.g. onResponderMove / onTouchMove). */
+  handleTouchMove(e) {
+    if (!this.tracking) return;
+    this.samples.push(this.extract(e));
+    if (this.samples.length > 1e3) {
+      this.samples = this.samples.slice(-500);
+    }
+  }
+  /** Call on touch/gesture end (e.g. onResponderRelease / onTouchEnd). */
+  handleTouchEnd(e) {
+    if (!this.tracking) return;
+    const sample = this.extract(e);
+    this.samples.push(sample);
+    if (this.activeStart !== null) {
+      this.touchDurations.push(sample.timestamp - this.activeStart);
+      this.activeStart = null;
+    }
+    this.tapTimestamps.push(sample.timestamp);
+  }
+  /** Handlers ready to spread onto a View's responder/touch props. */
+  getEventHandlers() {
+    return {
+      onTouchStart: this.handleTouchStart.bind(this),
+      onTouchMove: this.handleTouchMove.bind(this),
+      onTouchEnd: this.handleTouchEnd.bind(this)
+    };
+  }
+  getMetrics() {
+    const pressures = this.samples.map((s) => s.force ?? 0).filter((f) => f > 0);
+    const velocities = [];
+    for (let i = 1; i < this.samples.length; i++) {
+      const prev = this.samples[i - 1];
+      const curr = this.samples[i];
+      const dt = (curr.timestamp - prev.timestamp) / 1e3;
+      if (dt > 0 && dt < 1) {
+        const dist = Math.sqrt((curr.x - prev.x) ** 2 + (curr.y - prev.y) ** 2);
+        velocities.push(dist / dt);
+      }
+    }
+    const tapIntervals = [];
+    for (let i = 1; i < this.tapTimestamps.length; i++) {
+      tapIntervals.push(this.tapTimestamps[i] - this.tapTimestamps[i - 1]);
+    }
+    const totalDuration = this.samples.length > 1 ? this.samples[this.samples.length - 1].timestamp - this.samples[0].timestamp : 0;
+    return {
+      avgPressure: mean(pressures),
+      pressureStdDev: stdDev(pressures),
+      avgSwipeVelocity: mean(velocities),
+      touchCount: this.samples.length,
+      tapCount: this.tapTimestamps.length,
+      avgTapInterval: mean(tapIntervals),
+      tapIntervalStdDev: stdDev(tapIntervals),
+      avgTouchDuration: mean(this.touchDurations),
+      multiTouchCount: this.multiTouchCount,
+      totalDuration
+    };
+  }
+  getRawData() {
+    return [...this.samples];
+  }
+};
+function createTouchTracker() {
+  return new TouchTracker();
+}
+
+// src/profiles.ts
+var DEFAULT_BASE_URL = "https://api.simplr.sh";
+var SimplrProfiles = class {
+  constructor(config) {
+    this.apiKey = "";
+    this.baseUrl = DEFAULT_BASE_URL;
+    this.timeoutMs = 15e3;
+    this.configured = false;
+    if (config) this.configure(config);
+  }
+  configure(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ? normalizeBaseUrl(config.baseUrl) : DEFAULT_BASE_URL;
+    if (config.timeoutMs !== void 0) this.timeoutMs = config.timeoutMs;
+    this.fetchImpl = config.fetchImpl;
+    this.configured = true;
+    return this;
+  }
+  /**
+   * Set the device-signal collector so identify()/submitOrder() can auto-attach
+   * a fingerprint. The main client wires this to its own collector.
+   */
+  setDeviceSignalCollector(fn) {
+    this.collectDeviceSignalsFn = fn;
+  }
+  requireConfigured() {
+    if (!this.configured || !this.apiKey) {
+      throw new Error("SimplrProfiles is not configured. Call configure({ apiKey }) first.");
+    }
+  }
+  get httpConfig() {
+    return {
+      authHeaders: { "X-API-Key": this.apiKey },
+      baseUrl: this.baseUrl,
+      timeoutMs: this.timeoutMs,
+      fetchImpl: this.fetchImpl
+    };
+  }
+  /** Create or update an anonymous profile and link the current device. */
+  async identify(externalId, options) {
+    this.requireConfigured();
+    const { profileType, deviceSignals, ...rest } = options ?? {};
+    let signals = deviceSignals;
+    if (!signals && this.collectDeviceSignalsFn) {
+      try {
+        signals = await this.collectDeviceSignalsFn();
+      } catch {
+      }
+    }
+    const body = {
+      external_id: externalId,
+      profile_type: profileType || "customer",
+      ...rest
+    };
+    if (signals) body.fingerprint_hash = signals.fingerprint;
+    return apiRequest(this.httpConfig, "POST", "/v1/profiles", body);
+  }
+  /** Submit an order for real-time fraud scoring; auto-attaches a fingerprint. */
+  async submitOrder(order) {
+    this.requireConfigured();
+    let body = order;
+    if (!order.fingerprint_hash && this.collectDeviceSignalsFn) {
+      try {
+        const signals = await this.collectDeviceSignalsFn();
+        body = { ...order, fingerprint_hash: signals.fingerprint };
+      } catch {
+      }
+    }
+    return apiRequest(this.httpConfig, "POST", "/v1/orders", body);
+  }
+  /** Get the risk profile for a user. */
+  async getProfileRisk(externalId) {
+    this.requireConfigured();
+    return apiRequest(
+      this.httpConfig,
+      "GET",
+      `/v1/profiles/${encodeURIComponent(externalId)}`
+    );
+  }
+  /** Report a profile as fraud or legitimate. */
+  async reportOutcome(externalId, outcome) {
+    this.requireConfigured();
+    await apiRequest(
+      this.httpConfig,
+      "POST",
+      `/v1/profiles/${encodeURIComponent(externalId)}/outcome`,
+      { outcome }
+    );
+  }
+};
+new SimplrProfiles();
+
+// src/rum.ts
+var DEFAULT_BASE_URL2 = "https://api.simplr.sh";
+var DEFAULT_BATCH_SIZE = 30;
+var DEFAULT_FLUSH_INTERVAL = 1e4;
+function genId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
+}
+var SimplrRUM = class {
+  constructor() {
+    this.config = null;
+    this.initialized = false;
+    this.baseUrl = DEFAULT_BASE_URL2;
+    this.timeoutMs = 15e3;
+    this.batchSize = DEFAULT_BATCH_SIZE;
+    this.queue = [];
+    this.timer = null;
+    this.flushing = false;
+    this.sessionId = null;
+    this.currentViewId = null;
+    this.globalAttributes = {};
+  }
+  /** Initialize the SDK, start a session, and begin the flush timer. */
+  initialize(config) {
+    if (this.initialized) return;
+    this.config = config;
+    this.baseUrl = config.baseUrl ? normalizeBaseUrl(config.baseUrl) : DEFAULT_BASE_URL2;
+    if (config.timeoutMs !== void 0) this.timeoutMs = config.timeoutMs;
+    this.fetchImpl = config.fetchImpl;
+    this.batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.sessionId = genId();
+    this.initialized = true;
+    this.trackEvent("session_start");
+    const interval = config.flushInterval ?? DEFAULT_FLUSH_INTERVAL;
+    if (interval > 0 && typeof setInterval !== "undefined") {
+      this.timer = setInterval(() => {
+        void this.flush();
+      }, interval);
+      this.timer?.unref?.();
+    }
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  get httpConfig() {
+    return {
+      authHeaders: { "X-API-Key": this.config.apiKey },
+      baseUrl: this.baseUrl,
+      timeoutMs: this.timeoutMs,
+      fetchImpl: this.fetchImpl
+    };
+  }
+  /** Associate subsequent events with a user. */
+  setUser(userId, attributes) {
+    this.userId = userId;
+    this.userAttributes = attributes;
+  }
+  clearUser() {
+    this.userId = void 0;
+    this.userAttributes = void 0;
+  }
+  addAttribute(key, value) {
+    this.globalAttributes[key] = value;
+  }
+  removeAttribute(key) {
+    delete this.globalAttributes[key];
+  }
+  /** Track a screen view (call from your navigation listener or useTrackView). */
+  trackView(name, attributes) {
+    if (!this.initialized) return;
+    this.currentViewId = genId();
+    this.trackEvent("view", { view: { id: this.currentViewId, name }, attributes });
+  }
+  /** Track a user action (tap, swipe, submit, …). */
+  trackAction(name, attributes) {
+    if (!this.initialized) return;
+    this.trackEvent("action", { action: { name, type: "custom" }, attributes });
+  }
+  /** Track an error. */
+  trackError(error, attributes) {
+    if (!this.initialized) return;
+    const data = error instanceof Error ? { message: error.message, stack: error.stack, type: error.constructor.name } : error;
+    this.trackEvent("error", { error: data, attributes });
+  }
+  /** Emit a log line. */
+  log(level, message, attributes) {
+    if (!this.initialized) return;
+    this.trackEvent("log", { log: { level, message }, attributes });
+  }
+  trackEvent(type, data) {
+    if (!this.initialized || !this.sessionId) return;
+    const event = {
+      type,
+      timestamp: Date.now(),
+      sessionId: this.sessionId,
+      viewId: this.currentViewId || void 0,
+      userId: this.userId,
+      applicationId: this.config.applicationId,
+      applicationVersion: this.config?.applicationVersion,
+      environment: this.config?.environment,
+      platform: "react-native",
+      userAttributes: this.userAttributes,
+      globalAttributes: Object.keys(this.globalAttributes).length > 0 ? this.globalAttributes : void 0,
+      ...data
+    };
+    this.queue.push(event);
+    if (this.queue.length >= this.batchSize) void this.flush();
+  }
+  /** Flush queued events to POST /v1/rum/events. */
+  async flush() {
+    if (this.flushing || this.queue.length === 0 || !this.config) return;
+    this.flushing = true;
+    const events = this.queue;
+    this.queue = [];
+    try {
+      await apiRequest(this.httpConfig, "POST", "/v1/rum/events", {
+        events,
+        sentAt: Date.now()
+      });
+    } catch {
+      this.queue = [...events, ...this.queue];
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /** End the session, flush remaining events, and stop the timer. */
+  async stopSession() {
+    if (!this.initialized) return;
+    this.trackEvent("session_end");
+    await this.flush();
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.initialized = false;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getViewId() {
+    return this.currentViewId;
+  }
+};
+var simplrRUM = new SimplrRUM();
+
+// src/ai.ts
+var DEFAULT_BASE_URL3 = "https://api.simplr.sh";
+function mapDelegation(d) {
+  return {
+    delegationId: d.delegation_id,
+    endUserId: d.end_user_id,
+    bindingMode: d.binding_mode,
+    status: d.status,
+    expiresAt: d.expires_at,
+    useCount: d.use_count,
+    lastUsedAt: d.last_used_at,
+    createdAt: d.created_at
+  };
+}
+var SimplrAI = class {
+  constructor(config) {
+    this.apiKey = "";
+    this.baseUrl = DEFAULT_BASE_URL3;
+    this.timeoutMs = 15e3;
+    this.configured = false;
+    if (config) this.configure(config);
+  }
+  configure(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ? normalizeBaseUrl(config.baseUrl) : DEFAULT_BASE_URL3;
+    if (config.timeoutMs !== void 0) this.timeoutMs = config.timeoutMs;
+    this.fetchImpl = config.fetchImpl;
+    this.configured = true;
+    return this;
+  }
+  requireConfigured() {
+    if (!this.configured || !this.apiKey) {
+      throw new Error("SimplrAI is not configured. Call configure({ apiKey }) first.");
+    }
+  }
+  get httpConfig() {
+    return {
+      authHeaders: { "X-API-Key": this.apiKey },
+      baseUrl: this.baseUrl,
+      timeoutMs: this.timeoutMs,
+      fetchImpl: this.fetchImpl
+    };
+  }
+  /** Create a new AI delegation token for a user. POST /v1/ai/delegations. */
+  async createDelegation(options) {
+    this.requireConfigured();
+    const content = await apiRequest(this.httpConfig, "POST", "/v1/ai/delegations", {
+      end_user_id: options.userId,
+      end_user_email: options.email,
+      binding: options.binding || "any_location",
+      expires_in_days: options.expiresInDays || 7,
+      session_id: options.sessionId,
+      fingerprint_hash: options.fingerprintHash
+    });
+    const d = content.delegation;
+    return {
+      token: d.token,
+      delegationId: d.delegation_id,
+      expiresAt: d.expires_at,
+      bindingMode: d.binding_mode
+    };
+  }
+  /** Validate (introspect) an AI delegation token. POST /v1/ai/validate. */
+  async validate(token, options) {
+    this.requireConfigured();
+    try {
+      const content = await apiRequest(this.httpConfig, "POST", "/v1/ai/validate", {
+        token,
+        fingerprint_hash: options?.fingerprintHash,
+        ai_provider: options?.aiProvider,
+        action: options?.action
+      });
+      return {
+        valid: true,
+        sessionType: content.session_type,
+        endUserId: content.end_user_id,
+        delegation: content.delegation ? {
+          delegationId: content.delegation.delegation_id,
+          bindingMode: content.delegation.binding_mode,
+          expiresAt: content.delegation.expires_at,
+          useCount: content.delegation.use_count
+        } : void 0
+      };
+    } catch (err) {
+      return { valid: false, error: err instanceof Error ? err.message : "Validation failed" };
+    }
+  }
+  /** Revoke a delegation. POST /v1/ai/delegations/{id}/revoke. */
+  async revoke(delegationId, reason) {
+    this.requireConfigured();
+    await apiRequest(
+      this.httpConfig,
+      "POST",
+      `/v1/ai/delegations/${encodeURIComponent(delegationId)}/revoke`,
+      { reason }
+    );
+  }
+  /** List delegations, optionally filtered by user. GET /v1/ai/delegations. */
+  async list(userId) {
+    this.requireConfigured();
+    const path = userId ? `/v1/ai/delegations?end_user_id=${encodeURIComponent(userId)}` : "/v1/ai/delegations";
+    const content = await apiRequest(this.httpConfig, "GET", path);
+    return (content.delegations || []).map(mapDelegation);
+  }
+  /** Get a single delegation. GET /v1/ai/delegations/{id}. */
+  async get(delegationId) {
+    this.requireConfigured();
+    const content = await apiRequest(
+      this.httpConfig,
+      "GET",
+      `/v1/ai/delegations/${encodeURIComponent(delegationId)}`
+    );
+    return mapDelegation(content.delegation);
+  }
+  /** Get delegation statistics. GET /v1/ai/stats. */
+  async stats() {
+    this.requireConfigured();
+    const content = await apiRequest(this.httpConfig, "GET", "/v1/ai/stats");
+    const s = content.stats;
+    return {
+      totalDelegations: s.total_delegations,
+      activeDelegations: s.active_delegations,
+      totalUses: s.total_uses,
+      delegationsByBinding: {
+        verifiedDevice: s.delegations_by_binding.verified_device,
+        anyLocation: s.delegations_by_binding.any_location
+      }
+    };
+  }
+  /** Revoke all delegations for a user (e.g. on logout). POST /v1/ai/revoke-all. */
+  async revokeAllForUser(userId, reason) {
+    this.requireConfigured();
+    const content = await apiRequest(this.httpConfig, "POST", "/v1/ai/revoke-all", {
+      end_user_id: userId,
+      reason
+    });
+    return content.revoked_count;
+  }
+};
+new SimplrAI();
+
+// src/client.ts
+var DEFAULT_BASE_URL4 = "https://api.simplr.sh";
+var SimplrFraud = class {
+  constructor(config) {
+    this.apiKey = "";
+    this.baseUrl = DEFAULT_BASE_URL4;
+    this.timeoutMs = 15e3;
+    this.formStartTime = null;
+    this.configured = false;
+    this.touchTracker = createTouchTracker();
+    this.profiles = new SimplrProfiles();
+    this.rum = new SimplrRUM();
+    this.ai = new SimplrAI();
+    this.profiles.setDeviceSignalCollector(() => this.getDeviceSignals());
+    if (config) this.configure(config);
+  }
+  /** Configure (or re-configure) the client. */
+  configure(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ? normalizeBaseUrl(config.baseUrl) : DEFAULT_BASE_URL4;
+    if (config.timeoutMs !== void 0) this.timeoutMs = config.timeoutMs;
+    this.fetchImpl = config.fetchImpl;
+    this.configured = true;
+    const sub = {
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      timeoutMs: this.timeoutMs,
+      fetchImpl: this.fetchImpl
+    };
+    this.profiles.configure(sub);
+    this.ai.configure(sub);
+    if (config.autoStart ?? true) {
+      this.startTracking();
+    }
+    return this;
+  }
+  requireConfigured() {
+    if (!this.configured || !this.apiKey) {
+      throw new Error("SimplrFraud is not configured. Call configure({ apiKey }) first.");
+    }
+  }
+  get httpConfig() {
+    return {
+      authHeaders: { "X-API-Key": this.apiKey },
+      baseUrl: this.baseUrl,
+      timeoutMs: this.timeoutMs,
+      fetchImpl: this.fetchImpl
+    };
+  }
+  // --- Biometrics ---------------------------------------------------------
+  /** Start collecting touch biometrics and reset the form timer. */
+  startTracking() {
+    this.touchTracker.start();
+    this.formStartTime = nowMs();
+  }
+  stopTracking() {
+    this.touchTracker.stop();
+  }
+  reset() {
+    this.touchTracker.reset();
+    this.formStartTime = nowMs();
+  }
+  /** The shared touch tracker; attach its handlers to your Views. */
+  getTouchTracker() {
+    return this.touchTracker;
+  }
+  collectBehaviorSignals() {
+    const signals = {
+      touch: this.touchTracker.getMetrics()
+    };
+    if (this.formStartTime !== null) {
+      signals.form_fill_time = nowMs() - this.formStartTime;
+    }
+    return signals;
+  }
+  // --- Device signals -----------------------------------------------------
+  /** Collect stable device signals from React Native APIs. */
+  async getDeviceSignals() {
+    return collectDeviceSignals();
+  }
+  /** Collect device + behavior signals together. */
+  async collect() {
+    const device = await this.getDeviceSignals();
+    return {
+      device,
+      behavior: this.collectBehaviorSignals(),
+      collected_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // --- API calls ----------------------------------------------------------
+  /**
+   * Run a fraud check. Device + behavior signals are auto-collected and merged
+   * into the request unless already present on `input`.
+   */
+  async check(input = {}) {
+    this.requireConfigured();
+    const collected = await this.collect();
+    const body = {
+      ...input,
+      device: input.device ?? collected.device,
+      behavior: input.behavior ?? collected.behavior
+    };
+    return apiRequest(this.httpConfig, "POST", "/v1/check", body);
+  }
+  /** Submit an order for scoring (POST /v1/orders). */
+  async submitOrder(order) {
+    this.requireConfigured();
+    let body = order;
+    if (!order.fingerprint_hash) {
+      try {
+        const device = await this.getDeviceSignals();
+        body = { ...order, fingerprint_hash: device.fingerprint };
+      } catch {
+      }
+    }
+    return apiRequest(this.httpConfig, "POST", "/v1/orders", body);
+  }
+  /**
+   * Identify/associate the current device with an external profile id.
+   * Sends a profile check via POST /v1/check with the device signals attached.
+   */
+  async identify(externalId, metadata) {
+    this.requireConfigured();
+    const device = await this.getDeviceSignals();
+    return apiRequest(this.httpConfig, "POST", "/v1/check", {
+      event_type: "identify",
+      event_id: externalId,
+      device,
+      metadata
+    });
+  }
+};
+function nowMs() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+var simplr = new SimplrFraud();
+
+// src/flags.ts
+function matchRule(rule, attributes) {
+  const actual = attributes[rule.attribute];
+  switch (rule.op) {
+    case "eq":
+      return String(actual) === rule.value;
+    case "neq":
+      return String(actual) !== rule.value;
+    case "contains":
+      return String(actual ?? "").includes(rule.value);
+    default:
+      return false;
+  }
+}
+var SimplrFlags = class {
+  constructor() {
+    this.apiKey = "";
+    this.baseUrl = "https://api.simplr.sh";
+    this.environment = "test";
+    this.refreshIntervalMs = 6e4;
+    this.flags = {};
+    this.timer = null;
+    this.ready = false;
+  }
+  async initialize(config) {
+    this.apiKey = config.apiKey;
+    if (config.baseUrl) this.baseUrl = normalizeBaseUrl(config.baseUrl);
+    if (config.environment) this.environment = config.environment;
+    if (config.refreshIntervalMs !== void 0) this.refreshIntervalMs = config.refreshIntervalMs;
+    if (config.defaultUserId) this.defaultUserId = config.defaultUserId;
+    this.fetchImpl = config.fetchImpl;
+    await this.refresh();
+    this.ready = true;
+    if (this.refreshIntervalMs > 0 && typeof setInterval !== "undefined") {
+      this.timer = setInterval(() => this.refresh(), this.refreshIntervalMs);
+      this.timer?.unref?.();
+    }
+  }
+  setUser(userId) {
+    this.userId = userId;
+  }
+  /** Sets the fallback identity (typically the persisted device_id). */
+  setDefaultUser(userId) {
+    this.defaultUserId = userId;
+  }
+  async refresh() {
+    const fetchImpl = this.fetchImpl ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") return;
+    try {
+      const res = await fetchImpl(
+        `${this.baseUrl}/v1/flags?environment=${this.environment}`,
+        { headers: { "X-API-Key": this.apiKey } }
+      );
+      if (!res.ok) return;
+      const json = await res.json();
+      const list = json?.content?.flags || json?.flags || [];
+      const map = {};
+      for (const f of list) map[f.key] = f;
+      this.flags = map;
+    } catch {
+    }
+  }
+  isEnabled(key, ctx) {
+    const f = this.flags[key];
+    if (!f || !f.enabled) return false;
+    const uid = ctx?.userId || this.userId || this.defaultUserId || "anonymous";
+    if (f.target_user_ids && f.target_user_ids.includes(uid)) return true;
+    if (ctx?.attributes && f.rules?.length && f.rules.some((r) => matchRule(r, ctx.attributes)))
+      return true;
+    if (f.rollout_percentage >= 100) return true;
+    if (f.rollout_percentage <= 0) return false;
+    const bucket = murmurHash3(`${key}:${uid}`) % 100;
+    return bucket < f.rollout_percentage;
+  }
+  getAll() {
+    return { ...this.flags };
+  }
+  /** Replace the in-memory flag set directly (useful for testing/SSR). */
+  setFlags(list) {
+    const map = {};
+    for (const f of list) map[f.key] = f;
+    this.flags = map;
+    this.ready = true;
+  }
+  isReady() {
+    return this.ready;
+  }
+  dispose() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+  }
+};
+var simplrFlags = new SimplrFlags();
+
+// src/hooks/index.ts
+function useSimplr(config) {
+  const client = react.useMemo(() => simplr, []);
+  react.useEffect(() => {
+    if (config?.apiKey) {
+      client.configure(config);
+    }
+  }, [config?.apiKey, config?.baseUrl]);
+  return client;
+}
+function useDeviceSignals(client) {
+  const sdk = client ?? simplr;
+  const [signals, setSignals] = react.useState(null);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [tick, setTick] = react.useState(0);
+  react.useEffect(() => {
+    let mounted = true;
+    setLoading(true);
+    sdk.getDeviceSignals().then((s) => {
+      if (mounted) {
+        setSignals(s);
+        setError(null);
+      }
+    }).catch((e) => {
+      if (mounted) setError(e instanceof Error ? e : new Error(String(e)));
+    }).finally(() => {
+      if (mounted) setLoading(false);
+    });
+    return () => {
+      mounted = false;
+    };
+  }, [tick]);
+  const refresh = react.useCallback(() => setTick((t) => t + 1), []);
+  return { signals, loading, error, refresh };
+}
+function useFeatureFlag(key, ctx, flags = simplrFlags) {
+  const ctxKey = JSON.stringify(ctx ?? null);
+  const [enabled, setEnabled] = react.useState(() => {
+    try {
+      return flags.isEnabled(key, ctx);
+    } catch {
+      return false;
+    }
+  });
+  react.useEffect(() => {
+    let mounted = true;
+    const evaluate = () => {
+      if (!mounted) return;
+      try {
+        setEnabled(flags.isEnabled(key, ctx));
+      } catch {
+        setEnabled(false);
+      }
+    };
+    evaluate();
+    const t = typeof setTimeout !== "undefined" ? setTimeout(evaluate, 0) : null;
+    return () => {
+      mounted = false;
+      if (t) clearTimeout(t);
+    };
+  }, [key, ctxKey, flags]);
+  return enabled;
+}
+function useTouchBiometrics(client) {
+  const trackerRef = react.useRef(null);
+  if (!trackerRef.current) {
+    trackerRef.current = client ? client.getTouchTracker() : new TouchTracker();
+  }
+  const tracker = trackerRef.current;
+  react.useEffect(() => {
+    tracker.start();
+    return () => tracker.stop();
+  }, []);
+  const handlers = react.useMemo(() => tracker.getEventHandlers(), [tracker]);
+  const getMetrics = react.useCallback(() => tracker.getMetrics(), [tracker]);
+  return { tracker, handlers, getMetrics };
+}
+function useRum(config) {
+  const rum = react.useMemo(() => simplrRUM, []);
+  react.useEffect(() => {
+    if (config && !rum.isInitialized()) {
+      rum.initialize(config);
+    }
+  }, [config?.apiKey, config?.applicationId, config?.baseUrl]);
+  return rum;
+}
+function useTrackView(name, attributes, rum = simplrRUM) {
+  const attrsKey = JSON.stringify(attributes ?? null);
+  react.useEffect(() => {
+    if (!name) return;
+    try {
+      rum.trackView(name, attributes);
+    } catch {
+    }
+  }, [name, attrsKey, rum]);
+}
+function useTrackAction(rum = simplrRUM) {
+  return react.useCallback(
+    (name, attributes) => {
+      try {
+        rum.trackAction(name, attributes);
+      } catch {
+      }
+    },
+    [rum]
+  );
+}
+function useTrackError(rum = simplrRUM) {
+  return react.useCallback(
+    (error, attributes) => {
+      try {
+        rum.trackError(error, attributes);
+      } catch {
+      }
+    },
+    [rum]
+  );
+}
+
+exports.useDeviceSignals = useDeviceSignals;
+exports.useFeatureFlag = useFeatureFlag;
+exports.useRum = useRum;
+exports.useSimplr = useSimplr;
+exports.useTouchBiometrics = useTouchBiometrics;
+exports.useTrackAction = useTrackAction;
+exports.useTrackError = useTrackError;
+exports.useTrackView = useTrackView;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map