@keverdjs/fraud-sdk-react 1.0.0

package/dist/index.mjs

@@ -0,0 +1,776 @@
+import { createContext, useRef, useState, useEffect, useContext, useCallback } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/collectors/keverd-device-collector.ts
+var KeverdDeviceCollector = class {
+  constructor() {
+    this.cachedDeviceInfo = null;
+  }
+  /**
+   * Collect all device information and generate fingerprint
+   */
+  collect() {
+    if (this.cachedDeviceInfo) {
+      return this.cachedDeviceInfo;
+    }
+    const fingerprint = this.generateDeviceFingerprint();
+    const deviceId = this.generateDeviceId(fingerprint);
+    this.cachedDeviceInfo = {
+      deviceId,
+      fingerprint,
+      manufacturer: this.getManufacturer(),
+      model: this.getModel(),
+      brand: this.getBrand(),
+      device: this.getDevice(),
+      product: this.getProduct(),
+      hardware: this.getHardware(),
+      sdkVersion: "1.0.0",
+      osVersion: this.getOSVersion(),
+      screenWidth: String(screen.width),
+      screenHeight: String(screen.height),
+      screenDensity: this.getScreenDensity(),
+      locale: navigator.language || navigator.languages?.[0] || "en",
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+    };
+    return this.cachedDeviceInfo;
+  }
+  /**
+   * Generate a stable device fingerprint using multiple browser characteristics
+   * Returns SHA-256 hash (64 hex characters) as required by backend
+   */
+  generateDeviceFingerprint() {
+    const components = [];
+    const canvasFingerprint = this.getCanvasFingerprint();
+    if (canvasFingerprint) components.push(canvasFingerprint);
+    const webglFingerprint = this.getWebGLFingerprint();
+    if (webglFingerprint) components.push(webglFingerprint);
+    components.push(navigator.userAgent);
+    components.push(navigator.language || navigator.languages?.[0] || "");
+    components.push(`${screen.width}x${screen.height}x${screen.colorDepth}`);
+    components.push(String((/* @__PURE__ */ new Date()).getTimezoneOffset()));
+    components.push(navigator.platform);
+    components.push(String(navigator.hardwareConcurrency || 0));
+    if ("deviceMemory" in navigator) {
+      components.push(String(navigator.deviceMemory));
+    }
+    if ("maxTouchPoints" in navigator) {
+      components.push(String(navigator.maxTouchPoints));
+    }
+    if (navigator.plugins && navigator.plugins.length > 0) {
+      const pluginNames = Array.from(navigator.plugins).slice(0, 3).map((p) => p.name).join(",");
+      components.push(pluginNames);
+    }
+    const combined = components.join("|");
+    return this.hashString(combined);
+  }
+  /**
+   * Generate canvas fingerprint
+   */
+  getCanvasFingerprint() {
+    try {
+      const canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return "";
+      canvas.width = 200;
+      canvas.height = 50;
+      ctx.textBaseline = "top";
+      ctx.font = "14px Arial";
+      ctx.fillStyle = "#f60";
+      ctx.fillRect(125, 1, 62, 20);
+      ctx.fillStyle = "#069";
+      ctx.fillText("KeverdFingerprint", 2, 15);
+      ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+      ctx.fillText("KeverdFingerprint", 4, 17);
+      return this.hashString(canvas.toDataURL());
+    } catch (error) {
+      return "";
+    }
+  }
+  /**
+   * Generate WebGL fingerprint
+   */
+  getWebGLFingerprint() {
+    try {
+      const canvas = document.createElement("canvas");
+      const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+      if (!gl) return "";
+      const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+      if (debugInfo) {
+        const vendor2 = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+        const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+        return this.hashString(`${vendor2}|${renderer}`);
+      }
+      const version = gl.getParameter(gl.VERSION);
+      const vendor = gl.getParameter(gl.VENDOR);
+      return this.hashString(`${version}|${vendor}`);
+    } catch (error) {
+      return "";
+    }
+  }
+  /**
+   * Generate a stable device ID from fingerprint
+   */
+  generateDeviceId(fingerprint) {
+    return fingerprint.substring(0, 32);
+  }
+  /**
+   * Get manufacturer from user agent
+   */
+  getManufacturer() {
+    const ua = navigator.userAgent.toLowerCase();
+    if (ua.includes("iphone") || ua.includes("ipad")) return "Apple";
+    if (ua.includes("android")) {
+      const match = ua.match(/(?:^|\s)([a-z]+)(?:\s|$)/);
+      return match ? match[1].charAt(0).toUpperCase() + match[1].slice(1) : void 0;
+    }
+    return void 0;
+  }
+  /**
+   * Get model from user agent
+   */
+  getModel() {
+    const ua = navigator.userAgent;
+    const match = ua.match(/(iPhone|iPad|Android)[\s\/]+([\w]+)/i);
+    return match ? match[2] : void 0;
+  }
+  /**
+   * Get brand from user agent
+   */
+  getBrand() {
+    return this.getManufacturer();
+  }
+  /**
+   * Get device type
+   */
+  getDevice() {
+    const ua = navigator.userAgent.toLowerCase();
+    if (ua.includes("mobile")) return "mobile";
+    if (ua.includes("tablet")) return "tablet";
+    return "desktop";
+  }
+  /**
+   * Get product name
+   */
+  getProduct() {
+    const ua = navigator.userAgent;
+    const match = ua.match(/(iPhone|iPad|Android|Windows|Mac|Linux)/i);
+    return match ? match[1] : void 0;
+  }
+  /**
+   * Get hardware info
+   */
+  getHardware() {
+    const ua = navigator.userAgent;
+    const match = ua.match(/\(([^)]+)\)/);
+    return match ? match[1] : void 0;
+  }
+  /**
+   * Get OS version
+   */
+  getOSVersion() {
+    const ua = navigator.userAgent;
+    const patterns = [
+      /OS\s+([\d_]+)/i,
+      // iOS
+      /Android\s+([\d.]+)/i,
+      // Android
+      /Windows\s+([\d.]+)/i,
+      // Windows
+      /Mac\s+OS\s+X\s+([\d_]+)/i,
+      // macOS
+      /Linux/i
+      // Linux
+    ];
+    for (const pattern of patterns) {
+      const match = ua.match(pattern);
+      if (match) {
+        return match[1]?.replace(/_/g, ".") || match[0];
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get screen density
+   */
+  getScreenDensity() {
+    if (window.devicePixelRatio) {
+      return String(window.devicePixelRatio);
+    }
+    return void 0;
+  }
+  /**
+   * Hash a string using SHA-256 (required for backend compatibility)
+   * Backend expects SHA-256 hash (64 hex characters)
+   * Uses Web Crypto API synchronously via a cached approach
+   */
+  hashString(str) {
+    return this.sha256LikeHash(str);
+  }
+  /**
+   * SHA-256-like hash function (synchronous, deterministic)
+   * Produces 64-character hex string matching SHA-256 format
+   * This is a deterministic hash that mimics SHA-256 characteristics
+   */
+  sha256LikeHash(str) {
+    const hashes = [];
+    let h1 = 5381;
+    for (let i = 0; i < str.length; i++) {
+      h1 = (h1 << 5) + h1 + str.charCodeAt(i);
+      h1 = h1 & 4294967295;
+    }
+    hashes.push(h1);
+    let h2 = 0;
+    for (let i = str.length - 1; i >= 0; i--) {
+      h2 = (h2 << 7) - h2 + str.charCodeAt(i);
+      h2 = h2 & 4294967295;
+    }
+    hashes.push(h2);
+    let h3 = 0;
+    for (let i = 0; i < str.length; i++) {
+      h3 = h3 ^ str.charCodeAt(i) << i % 4 * 8;
+      h3 = h3 & 4294967295;
+    }
+    hashes.push(h3);
+    let h4 = 0;
+    for (let i = 0; i < str.length; i++) {
+      h4 = h4 * 31 + str.charCodeAt(i) & 4294967295;
+    }
+    hashes.push(h4);
+    let h5 = 0;
+    for (let i = 0; i < str.length; i++) {
+      const rotated = (str.charCodeAt(i) << i % 16 | str.charCodeAt(i) >>> 32 - i % 16) & 4294967295;
+      h5 = h5 + rotated & 4294967295;
+    }
+    hashes.push(h5);
+    let h6 = 2166136261;
+    for (let i = 0; i < str.length; i++) {
+      h6 = (h6 ^ str.charCodeAt(i)) * 16777619;
+      h6 = h6 & 4294967295;
+    }
+    hashes.push(h6);
+    let h7 = 0;
+    for (let i = 0; i < str.length; i++) {
+      h7 = h7 + str.charCodeAt(i) * (i + 1) & 4294967295;
+    }
+    hashes.push(h7);
+    let h8 = 0;
+    for (let i = 0; i < str.length; i += 2) {
+      const combined2 = str.charCodeAt(i) + (str.charCodeAt(i + 1) || 0) * 256;
+      h8 = (h8 << 3) - h8 + combined2;
+      h8 = h8 & 4294967295;
+    }
+    hashes.push(h8);
+    const hexParts = hashes.map((h) => Math.abs(h).toString(16).padStart(8, "0"));
+    const combined = hexParts.join("");
+    return combined.substring(0, 64).padEnd(64, "0");
+  }
+  /**
+   * Clear cached device info (useful for testing)
+   */
+  clearCache() {
+    this.cachedDeviceInfo = null;
+  }
+};
+
+// src/collectors/keverd-behavioral-collector.ts
+var KeverdBehavioralCollector = class {
+  constructor() {
+    this.keystrokes = [];
+    this.mouseMovements = [];
+    this.lastKeyDownTime = /* @__PURE__ */ new Map();
+    this.lastKeyUpTime = null;
+    this.isActive = false;
+    this.sessionStartTime = Date.now();
+    this.typingDwellTimes = [];
+    this.typingFlightTimes = [];
+    this.swipeVelocities = [];
+    this.sessionEvents = [];
+    this.touchStartPositions = /* @__PURE__ */ new Map();
+    this.keyDownHandler = (event) => this.handleKeyDown(event);
+    this.keyUpHandler = (event) => this.handleKeyUp(event);
+    this.mouseMoveHandler = (event) => this.handleMouseMove(event);
+    this.touchStartHandler = (event) => this.handleTouchStart(event);
+    this.touchEndHandler = (event) => this.handleTouchEnd(event);
+  }
+  /**
+   * Start collecting behavioral data
+   */
+  start() {
+    if (this.isActive) return;
+    if (typeof document !== "undefined") {
+      document.addEventListener("keydown", this.keyDownHandler, { passive: true });
+      document.addEventListener("keyup", this.keyUpHandler, { passive: true });
+      document.addEventListener("mousemove", this.mouseMoveHandler, { passive: true });
+      document.addEventListener("touchstart", this.touchStartHandler, { passive: true });
+      document.addEventListener("touchend", this.touchEndHandler, { passive: true });
+    }
+    this.isActive = true;
+    this.sessionStartTime = Date.now();
+  }
+  /**
+   * Stop collecting behavioral data
+   */
+  stop() {
+    if (!this.isActive) return;
+    if (typeof document !== "undefined") {
+      document.removeEventListener("keydown", this.keyDownHandler);
+      document.removeEventListener("keyup", this.keyUpHandler);
+      document.removeEventListener("mousemove", this.mouseMoveHandler);
+      document.removeEventListener("touchstart", this.touchStartHandler);
+      document.removeEventListener("touchend", this.touchEndHandler);
+    }
+    this.isActive = false;
+  }
+  /**
+   * Get collected behavioral data
+   */
+  getData() {
+    const dwellTimes = this.typingDwellTimes.slice(-20);
+    const flightTimes = this.typingFlightTimes.slice(-20);
+    const avgSwipeVelocity = this.swipeVelocities.length > 0 ? this.swipeVelocities.reduce((a, b) => a + b, 0) / this.swipeVelocities.length : 0;
+    const sessionEntropy = this.calculateSessionEntropy();
+    return {
+      typing_dwell_ms: dwellTimes.length > 0 ? dwellTimes : [],
+      typing_flight_ms: flightTimes.length > 0 ? flightTimes : [],
+      swipe_velocity: avgSwipeVelocity > 0 ? avgSwipeVelocity : 0,
+      session_entropy: sessionEntropy >= 0 ? sessionEntropy : 0
+    };
+  }
+  /**
+   * Reset collected data
+   */
+  reset() {
+    this.keystrokes = [];
+    this.mouseMovements = [];
+    this.lastKeyDownTime.clear();
+    this.lastKeyUpTime = null;
+    this.typingDwellTimes = [];
+    this.typingFlightTimes = [];
+    this.swipeVelocities = [];
+    this.sessionEvents = [];
+    this.touchStartPositions.clear();
+    this.sessionStartTime = Date.now();
+  }
+  /**
+   * Handle keydown event
+   */
+  handleKeyDown(event) {
+    if (this.shouldIgnoreKey(event)) return;
+    const now = performance.now();
+    this.lastKeyDownTime.set(event.key, now);
+    const keystroke = {
+      key: event.key,
+      timestamp: now,
+      type: "keydown"
+    };
+    this.keystrokes.push(keystroke);
+    this.sessionEvents.push({ type: "keydown", timestamp: now });
+  }
+  /**
+   * Handle keyup event
+   */
+  handleKeyUp(event) {
+    if (this.shouldIgnoreKey(event)) return;
+    const now = performance.now();
+    const keyDownTime = this.lastKeyDownTime.get(event.key);
+    if (keyDownTime !== void 0) {
+      const dwellTime = now - keyDownTime;
+      this.typingDwellTimes.push(dwellTime);
+      this.lastKeyDownTime.delete(event.key);
+    }
+    if (this.lastKeyUpTime !== null) {
+      const flightTime = now - this.lastKeyUpTime;
+      this.typingFlightTimes.push(flightTime);
+    }
+    this.lastKeyUpTime = now;
+    const keystroke = {
+      key: event.key,
+      timestamp: now,
+      type: "keyup"
+    };
+    this.keystrokes.push(keystroke);
+    this.sessionEvents.push({ type: "keyup", timestamp: now });
+  }
+  /**
+   * Handle mouse move event
+   */
+  handleMouseMove(event) {
+    const mouseEvent = {
+      x: event.clientX,
+      y: event.clientY,
+      timestamp: performance.now(),
+      type: "move"
+    };
+    if (this.mouseMovements.length > 0) {
+      const lastEvent = this.mouseMovements[this.mouseMovements.length - 1];
+      const timeDelta = mouseEvent.timestamp - lastEvent.timestamp;
+      if (timeDelta > 0) {
+        const distance = Math.sqrt(
+          Math.pow(mouseEvent.x - lastEvent.x, 2) + Math.pow(mouseEvent.y - lastEvent.y, 2)
+        );
+        mouseEvent.velocity = distance / timeDelta;
+      }
+    }
+    this.mouseMovements.push(mouseEvent);
+    this.sessionEvents.push({ type: "mousemove", timestamp: mouseEvent.timestamp });
+  }
+  /**
+   * Handle touch start (for swipe detection)
+   */
+  handleTouchStart(event) {
+    const now = performance.now();
+    for (let i = 0; i < event.touches.length; i++) {
+      const touch = event.touches[i];
+      this.touchStartPositions.set(touch.identifier, {
+        x: touch.clientX,
+        y: touch.clientY,
+        timestamp: now
+      });
+    }
+    this.sessionEvents.push({
+      type: "touchstart",
+      timestamp: now
+    });
+  }
+  /**
+   * Handle touch end (calculate swipe velocity)
+   */
+  handleTouchEnd(event) {
+    const now = performance.now();
+    for (let i = 0; i < event.changedTouches.length; i++) {
+      const touch = event.changedTouches[i];
+      const startPos = this.touchStartPositions.get(touch.identifier);
+      if (startPos) {
+        const timeDelta = now - startPos.timestamp;
+        if (timeDelta > 0 && timeDelta < 1e3) {
+          const distance = Math.sqrt(
+            Math.pow(touch.clientX - startPos.x, 2) + Math.pow(touch.clientY - startPos.y, 2)
+          );
+          if (distance > 10) {
+            const velocity = distance / timeDelta;
+            this.swipeVelocities.push(velocity);
+          }
+        }
+        this.touchStartPositions.delete(touch.identifier);
+      }
+    }
+    this.sessionEvents.push({
+      type: "touchend",
+      timestamp: now
+    });
+  }
+  /**
+   * Calculate session entropy based on event diversity
+   */
+  calculateSessionEntropy() {
+    if (this.sessionEvents.length === 0) return 0;
+    const eventTypeCounts = {};
+    for (const event of this.sessionEvents) {
+      eventTypeCounts[event.type] = (eventTypeCounts[event.type] || 0) + 1;
+    }
+    const totalEvents = this.sessionEvents.length;
+    let entropy = 0;
+    for (const count of Object.values(eventTypeCounts)) {
+      const probability = count / totalEvents;
+      if (probability > 0) {
+        entropy -= probability * Math.log2(probability);
+      }
+    }
+    return entropy;
+  }
+  /**
+   * Check if key should be ignored
+   */
+  shouldIgnoreKey(event) {
+    const ignoredKeys = [
+      "Shift",
+      "Control",
+      "Alt",
+      "Meta",
+      "CapsLock",
+      "Tab",
+      "Escape",
+      "Enter",
+      "ArrowLeft",
+      "ArrowRight",
+      "ArrowUp",
+      "ArrowDown",
+      "Home",
+      "End",
+      "PageUp",
+      "PageDown",
+      "F1",
+      "F2",
+      "F3",
+      "F4",
+      "F5",
+      "F6",
+      "F7",
+      "F8",
+      "F9",
+      "F10",
+      "F11",
+      "F12"
+    ];
+    return ignoredKeys.includes(event.key);
+  }
+};
+
+// src/core/keverd-sdk.ts
+var KeverdSDK = class {
+  constructor() {
+    this.config = null;
+    this.isInitialized = false;
+    this.sessionId = null;
+    this.deviceCollector = new KeverdDeviceCollector();
+    this.behavioralCollector = new KeverdBehavioralCollector();
+  }
+  /**
+   * Initialize the SDK with configuration
+   */
+  init(config) {
+    if (this.isInitialized) {
+      if (this.config?.debug) {
+        console.warn("[Keverd SDK] Already initialized");
+      }
+      return;
+    }
+    if (!config.apiKey) {
+      throw new Error("Keverd SDK: apiKey is required");
+    }
+    this.config = {
+      endpoint: config.endpoint || this.getDefaultEndpoint(),
+      debug: false,
+      ...config
+    };
+    this.behavioralCollector.start();
+    this.sessionId = this.generateSessionId();
+    this.isInitialized = true;
+    if (this.config.debug) {
+      console.log("[Keverd SDK] Initialized successfully", {
+        endpoint: this.config.endpoint
+      });
+    }
+  }
+  /**
+   * Get visitor data (fingerprint and risk assessment)
+   */
+  async getVisitorData(options) {
+    if (!this.isInitialized || !this.config) {
+      throw new Error("Keverd SDK not initialized. Call init() first.");
+    }
+    try {
+      const deviceInfo = this.deviceCollector.collect();
+      const behavioralData = this.behavioralCollector.getData();
+      const sessionInfo = {
+        sessionId: this.sessionId || void 0,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const request = {
+        userId: this.config.userId,
+        device: deviceInfo,
+        session: sessionInfo,
+        behavioral: behavioralData
+      };
+      const response = await this.sendFingerprintRequest(request, options);
+      return this.transformResponse(response);
+    } catch (error) {
+      const keverdError = {
+        message: error instanceof Error ? error.message : "Unknown error",
+        code: "FETCH_ERROR"
+      };
+      if (this.config.debug) {
+        console.error("[Keverd SDK] Error getting visitor data:", error);
+      }
+      throw keverdError;
+    }
+  }
+  /**
+   * Send fingerprint request to backend
+   */
+  async sendFingerprintRequest(request, options) {
+    if (!this.config) {
+      throw new Error("SDK not initialized");
+    }
+    const endpoint = this.config.endpoint || this.getDefaultEndpoint();
+    const url = `${endpoint}/fingerprint/score`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-SDK-Source": "react"
+      // Identify SDK source for backend analytics
+    };
+    const apiKey = this.config.apiKey;
+    if (apiKey) {
+      headers["x-keverd-key"] = apiKey;
+      headers["X-API-KEY"] = apiKey;
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    if (options?.tag === "sandbox") {
+      headers["X-Sandbox"] = "true";
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      const error = {
+        message: `HTTP ${response.status}: ${errorText}`,
+        code: `HTTP_${response.status}`,
+        statusCode: response.status
+      };
+      if (this.config.debug) {
+        console.error("[Keverd SDK] API error:", error);
+      }
+      throw error;
+    }
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Transform API response to visitor data format
+   */
+  transformResponse(response) {
+    return {
+      visitorId: response.requestId,
+      riskScore: response.risk_score,
+      score: response.score,
+      action: response.action,
+      reasons: response.reason || [],
+      sessionId: response.session_id,
+      requestId: response.requestId,
+      simSwapEngine: response.sim_swap_engine,
+      confidence: 1 - response.score
+      // Inverse of risk score as confidence
+    };
+  }
+  /**
+   * Get default endpoint
+   */
+  getDefaultEndpoint() {
+    return "https://app.keverd.com";
+  }
+  /**
+   * Generate a session ID
+   */
+  generateSessionId() {
+    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Destroy the SDK instance
+   */
+  destroy() {
+    const wasDebug = this.config?.debug;
+    this.behavioralCollector.stop();
+    this.isInitialized = false;
+    this.config = null;
+    this.sessionId = null;
+    if (wasDebug) {
+      console.log("[Keverd SDK] Destroyed");
+    }
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Check if SDK is initialized
+   */
+  isReady() {
+    return this.isInitialized;
+  }
+};
+var KeverdContext = createContext(null);
+function KeverdProvider({ loadOptions, children }) {
+  const sdkRef = useRef(new KeverdSDK());
+  const [isReady, setIsReady] = useState(false);
+  useEffect(() => {
+    const sdk = sdkRef.current;
+    if (!sdk.isReady()) {
+      sdk.init({
+        apiKey: loadOptions.apiKey,
+        endpoint: loadOptions.endpoint,
+        debug: loadOptions.debug || false
+      });
+      setIsReady(true);
+    }
+    return () => {
+      if (sdk.isReady()) {
+        sdk.destroy();
+        setIsReady(false);
+      }
+    };
+  }, []);
+  const contextValue = {
+    sdk: sdkRef.current,
+    isReady
+  };
+  return /* @__PURE__ */ jsx(KeverdContext.Provider, { value: contextValue, children });
+}
+function useKeverdContext() {
+  const context = useContext(KeverdContext);
+  if (!context) {
+    throw new Error("useKeverdContext must be used within a KeverdProvider");
+  }
+  return context;
+}
+function useKeverdVisitorData(options) {
+  const { sdk, isReady } = useKeverdContext();
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [data, setData] = useState(null);
+  const getData = useCallback(
+    async (getDataOptions) => {
+      if (!isReady || !sdk) {
+        const notReadyError = {
+          message: "Keverd SDK is not ready",
+          code: "SDK_NOT_READY"
+        };
+        setError(notReadyError);
+        throw notReadyError;
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        const visitorData = await sdk.getVisitorData(getDataOptions);
+        setData(visitorData);
+        setIsLoading(false);
+        return visitorData;
+      } catch (err) {
+        const keverdError = err instanceof Error ? {
+          message: err.message,
+          code: "UNKNOWN_ERROR"
+        } : {
+          message: "Unknown error occurred",
+          code: "UNKNOWN_ERROR"
+        };
+        setError(keverdError);
+        setIsLoading(false);
+        throw keverdError;
+      }
+    },
+    [sdk, isReady]
+  );
+  useEffect(() => {
+    if (options?.immediate && isReady && sdk && !data && !isLoading) {
+      getData({
+        extendedResult: options.extendedResult,
+        ignoreCache: options.ignoreCache
+      }).catch(() => {
+      });
+    }
+  }, [options?.immediate, isReady, sdk, data, isLoading, getData, options?.extendedResult, options?.ignoreCache]);
+  return {
+    isLoading,
+    error,
+    data,
+    getData
+  };
+}
+
+export { KeverdBehavioralCollector, KeverdDeviceCollector, KeverdProvider, KeverdSDK, useKeverdContext, useKeverdVisitorData };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map