@trustchex/react-native-sdk 1.250.0 → 1.266.0

package/lib/module/Shared/Services/AnalyticsService.js

@@ -0,0 +1,404 @@
+"use strict";
+
+/**
+ * Analytics Service - GDPR/KVKK/PCI-DSS Compliant
+ * Sends events immediately when they occur, sanitizes PII
+ */
+
+import { AppState } from 'react-native';
+import DeviceInfo from 'react-native-device-info';
+import RNFS from 'react-native-fs';
+import 'react-native-get-random-values';
+import { v4 as uuidv4 } from 'uuid';
+import packageJson from '../../../package.json';
+import { AnalyticsEventName } from "../Types/analytics.types.js";
+class AnalyticsService {
+  config = null;
+  sessionId = null;
+  deviceInfo = null;
+  isDemoSession = false;
+
+  // Batching configuration
+  queue = [];
+  BATCH_SIZE = 10;
+  MAX_QUEUE_SIZE = 100; // Prevent memory issues
+  FLUSH_INTERVAL = 5000; // 5 seconds
+  QUEUE_FILE_PATH = `${RNFS.CachesDirectoryPath}/trustchex_analytics_queue.json`;
+  flushTimer = null;
+  isFlushing = false;
+  appStateSubscription = null;
+
+  // Critical events that should flush immediately
+  CRITICAL_EVENTS = [AnalyticsEventName.SESSION_END, AnalyticsEventName.VERIFICATION_SUCCESS, AnalyticsEventName.VERIFICATION_FAILED];
+
+  /**
+   * Set demo session flag to disable analytics for demo sessions
+   */
+  setDemoSession(isDemoSession) {
+    this.isDemoSession = isDemoSession;
+  }
+
+  /**
+   * Initialize the analytics service
+   * @param config Analytics configuration with required verification sessionId
+   */
+  async initialize(config) {
+    // Prevent double initialization
+    if (this.config) {
+      return;
+    }
+
+    // Validate required verificationSessionId
+    if (!config.verificationSessionId) {
+      throw new Error('Analytics initialization failed: verificationSessionId is required (must be verification session ID from backend)');
+    }
+
+    // Merge with defaults
+    this.config = {
+      enabled: config.enabled ?? true,
+      baseUrl: config.baseUrl,
+      verificationSessionId: config.verificationSessionId
+    };
+    this.sessionId = config.verificationSessionId;
+
+    // Load persisted queue
+    await this.loadPersistedQueue();
+
+    // Collect anonymized device information
+    await this.collectDeviceInfo();
+
+    // Start flush timer
+    this.startFlushTimer();
+
+    // Listen for app state changes to flush before backgrounding
+    this.appStateSubscription = AppState.addEventListener('change', this.handleAppStateChange.bind(this));
+  }
+
+  /**
+   * Handle app state changes - flush when going to background
+   */
+  handleAppStateChange(nextAppState) {
+    if (nextAppState === 'background' || nextAppState === 'inactive') {
+      // Persist queue first to ensure data safety, then flush
+      // Note: We don't await here as AppState callbacks are sync,
+      // but the operations are queued and will complete
+      this.persistQueue().then(() => this.flush());
+    }
+  }
+
+  /**
+   * Load persisted queue from disk
+   */
+  async loadPersistedQueue() {
+    try {
+      if (await RNFS.exists(this.QUEUE_FILE_PATH)) {
+        const content = await RNFS.readFile(this.QUEUE_FILE_PATH, 'utf8');
+        const persistedQueue = JSON.parse(content);
+        if (Array.isArray(persistedQueue) && persistedQueue.length > 0) {
+          // Merge with existing queue, prioritizing persisted events
+          this.queue = [...persistedQueue, ...this.queue];
+          if (__DEV__) console.log(`[Analytics] Loaded ${persistedQueue.length} events from disk`);
+        }
+        // Clear the file after loading to prevent duplicate loads
+        await RNFS.unlink(this.QUEUE_FILE_PATH);
+      }
+    } catch (error) {
+      if (__DEV__) console.warn('[Analytics] Failed to load persisted queue:', error);
+    }
+  }
+
+  /**
+   * Persist queue to disk
+   */
+  async persistQueue() {
+    try {
+      if (this.queue.length === 0) {
+        if (await RNFS.exists(this.QUEUE_FILE_PATH)) {
+          await RNFS.unlink(this.QUEUE_FILE_PATH);
+        }
+        return;
+      }
+      await RNFS.writeFile(this.QUEUE_FILE_PATH, JSON.stringify(this.queue), 'utf8');
+    } catch (error) {
+      if (__DEV__) console.warn('[Analytics] Failed to persist queue:', error);
+    }
+  }
+
+  /**
+   * Track an analytics event - adds to queue and flushes if full
+   */
+  async trackEvent(eventName, category, metadata) {
+    // Skip analytics for demo sessions
+    if (this.isDemoSession) {
+      return;
+    }
+
+    // Skip if not initialized or disabled
+    if (!this.config?.enabled || !this.sessionId) {
+      return;
+    }
+
+    // Collect device info on first event if not already done
+    if (!this.deviceInfo) {
+      await this.collectDeviceInfo();
+    }
+
+    // Sanitize metadata to remove any potential PII
+    const sanitizedMetadata = this.sanitizeMetadata({
+      ...metadata,
+      deviceModel: DeviceInfo.getModel()
+    });
+    const event = {
+      eventId: uuidv4(),
+      verificationSessionId: this.sessionId,
+      eventName,
+      category,
+      timestamp: new Date().toISOString(),
+      deviceInfo: this.deviceInfo,
+      metadata: sanitizedMetadata
+    };
+
+    // Check if this is a critical event that should flush immediately
+    const isCriticalEvent = this.CRITICAL_EVENTS.includes(eventName);
+
+    // Add to queue
+    this.queue.push(event);
+
+    // Drop oldest events if queue exceeds max size (prevent memory issues)
+    if (this.queue.length > this.MAX_QUEUE_SIZE) {
+      const dropped = this.queue.length - this.MAX_QUEUE_SIZE;
+      this.queue = this.queue.slice(dropped);
+      if (__DEV__) console.warn(`[Analytics] Queue overflow, dropped ${dropped} oldest events`);
+    }
+
+    // Flush immediately for critical events or if batch size reached
+    if (isCriticalEvent || this.queue.length >= this.BATCH_SIZE) {
+      await this.flush();
+    }
+  }
+
+  /**
+   * Start the periodic flush timer
+   */
+  startFlushTimer() {
+    if (this.flushTimer) return;
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.FLUSH_INTERVAL);
+  }
+
+  /**
+   * Stop the flush timer
+   */
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+
+  /**
+   * Flush the event queue
+   */
+  async flush() {
+    // Early return checks - must be atomic with setting isFlushing
+    if (this.queue.length === 0 || this.isFlushing || !this.config) {
+      return;
+    }
+
+    // Set flag immediately to prevent race conditions
+    this.isFlushing = true;
+
+    // Take a batch, but don't remove from queue yet until success
+    const batchSize = Math.min(this.queue.length, this.BATCH_SIZE);
+    const batch = this.queue.slice(0, batchSize);
+
+    // Double-check batch has items (defensive programming)
+    if (batch.length === 0) {
+      this.isFlushing = false;
+      return;
+    }
+    try {
+      await this.sendBatchWithRetry(batch);
+
+      // Remove sent events
+      this.queue = this.queue.slice(batchSize);
+
+      // Update persistence
+      await this.persistQueue();
+    } catch (error) {
+      // On failure, we keep events in the queue
+      if (__DEV__) console.warn('[Analytics] Failed to flush batch, keeping events:', error);
+
+      // Ensure they are persisted
+      await this.persistQueue();
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+
+  /**
+   * Send batch with retry logic (exponential backoff: 1s, 2s, 4s)
+   */
+  async sendBatchWithRetry(events, maxRetries = 3, attempt = 1) {
+    if (!this.config || events.length === 0) return;
+    try {
+      const response = await fetch(`${this.config.baseUrl}/api/app/mobile/analytics`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(events)
+      });
+      if (!response.ok) {
+        if (attempt <= maxRetries && response.status >= 500) {
+          // Retry on server errors with exponential backoff
+          const delay = Math.pow(2, attempt - 1) * 1000; // 1s, 2s, 4s
+          await new Promise(resolve => setTimeout(resolve, delay));
+          return this.sendBatchWithRetry(events, maxRetries, attempt + 1);
+        }
+        // For 429 (Too Many Requests), throw to retry
+        if (response.status === 429) {
+          throw new Error('Rate limit exceeded');
+        }
+
+        // For other 4xx errors (Bad Request, Unauthorized, etc.), do NOT retry.
+        // We return successfully so the bad events are removed from the queue.
+        if (response.status >= 400 && response.status < 500) {
+          if (__DEV__) console.warn(`[Analytics] Dropping batch due to ${response.status} error`);
+          return;
+        }
+        if (__DEV__) console.warn('[Analytics] Failed to send batch:', response.status);
+      }
+    } catch (error) {
+      if (attempt <= maxRetries) {
+        // Retry on network errors with exponential backoff
+        const delay = Math.pow(2, attempt - 1) * 1000;
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return this.sendBatchWithRetry(events, maxRetries, attempt + 1);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Clear analytics session and reset all state
+   */
+  async clear() {
+    // Flush any pending events before clearing
+    await this.flush();
+    this.stopFlushTimer();
+
+    // Remove AppState listener
+    if (this.appStateSubscription) {
+      this.appStateSubscription.remove();
+      this.appStateSubscription = null;
+    }
+    this.queue = [];
+    this.sessionId = null;
+    this.deviceInfo = null;
+    this.config = null;
+  }
+
+  /**
+   * Check if analytics is enabled
+   */
+  isEnabled() {
+    return this.config?.enabled === true && this.sessionId !== null;
+  }
+
+  /**
+   * Private: Collect anonymized device information
+   */
+  async collectDeviceInfo() {
+    try {
+      const platform = DeviceInfo.getSystemName().toLowerCase();
+      this.deviceInfo = {
+        platform: platform,
+        osVersion: DeviceInfo.getSystemVersion(),
+        appVersion: DeviceInfo.getVersion(),
+        sdkVersion: packageJson.version,
+        locale: 'en',
+        // Will be set from app context
+        timezone: new Date().toTimeString().split(' ')[1] || 'UTC',
+        screenResolution: `${DeviceInfo.getDeviceType()}`
+      };
+    } catch (error) {
+      if (__DEV__) console.warn('[Analytics] Error collecting device info:', error);
+      // Fallback device info
+      this.deviceInfo = {
+        platform: 'android',
+        osVersion: 'unknown',
+        appVersion: 'unknown',
+        sdkVersion: packageJson.version,
+        locale: 'en',
+        timezone: 'UTC',
+        screenResolution: 'unknown'
+      };
+    }
+  }
+
+  /**
+   * Update device locale from app context
+   */
+  setLocale(locale) {
+    if (this.deviceInfo) {
+      this.deviceInfo.locale = locale;
+    }
+  }
+
+  /**
+   * Private: Sanitize metadata to remove PII
+   */
+  sanitizeMetadata(metadata) {
+    if (!metadata) return undefined;
+    const sanitized = {};
+    const forbiddenKeys = ['email', 'emailaddress', 'phone', 'phonenumber', 'firstname', 'lastname', 'fullname', 'address', 'streetaddress', 'ssn', 'socialsecurity', 'passport', 'passportnumber', 'driverlicense', 'creditcard', 'cardnumber', 'cvv', 'password', 'apikey', 'accesstoken'];
+    for (const [key, value] of Object.entries(metadata)) {
+      const lowerKey = key.toLowerCase();
+
+      // Skip if key is exactly a forbidden key or contains it as a word boundary
+      // But allow compound words like "buttonName", "screenName"
+      const isForbidden = forbiddenKeys.some(forbidden => {
+        // Check for exact match
+        if (lowerKey === forbidden) return true;
+
+        // Check if forbidden word appears at start followed by non-letter
+        if (lowerKey.startsWith(forbidden) && lowerKey.length > forbidden.length) {
+          const nextChar = lowerKey[forbidden.length];
+          if (!/[a-z]/.test(nextChar)) return true;
+        }
+
+        // Check if forbidden word appears at end preceded by non-letter
+        if (lowerKey.endsWith(forbidden) && lowerKey.length > forbidden.length) {
+          const prevChar = lowerKey[lowerKey.length - forbidden.length - 1];
+          if (!/[a-z]/.test(prevChar)) return true;
+        }
+        return false;
+      });
+      if (isForbidden) {
+        continue;
+      }
+
+      // Skip if value looks like email
+      if (typeof value === 'string' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+        continue;
+      }
+
+      // Skip if value looks like phone number
+      if (typeof value === 'string' && /^\+?[\d\s\-()]{10,}$/.test(value)) {
+        continue;
+      }
+
+      // Skip if value looks like credit card
+      if (typeof value === 'string' && /^\d{13,19}$/.test(value)) {
+        continue;
+      }
+      sanitized[key] = value;
+    }
+    return sanitized;
+  }
+}
+
+// Singleton instance
+export const analyticsService = new AnalyticsService();

package/lib/module/Shared/Types/analytics.types.js

@@ -0,0 +1,111 @@
+"use strict";
+
+/**
+ * Analytics Types for Trustchex React Native SDK
+ * GDPR, KVKK, and PCI-DSS Compliant Analytics System
+ */
+
+/**
+ * Categories of analytics events
+ */
+export let AnalyticsEventCategory = /*#__PURE__*/function (AnalyticsEventCategory) {
+  AnalyticsEventCategory["SESSION"] = "session";
+  AnalyticsEventCategory["NAVIGATION"] = "navigation";
+  AnalyticsEventCategory["USER_ACTION"] = "user_action";
+  AnalyticsEventCategory["ERROR"] = "error";
+  AnalyticsEventCategory["PERFORMANCE"] = "performance";
+  AnalyticsEventCategory["VERIFICATION"] = "verification";
+  return AnalyticsEventCategory;
+}({});
+
+/**
+ * Error severity levels for analytics tracking
+ */
+
+/**
+ * Error categories for grouping similar errors
+ */
+export let ErrorCategory = /*#__PURE__*/function (ErrorCategory) {
+  ErrorCategory["NETWORK"] = "network";
+  ErrorCategory["PERMISSION"] = "permission";
+  ErrorCategory["CAMERA"] = "camera";
+  ErrorCategory["NFC"] = "nfc";
+  ErrorCategory["VALIDATION"] = "validation";
+  ErrorCategory["API"] = "api";
+  ErrorCategory["STORAGE"] = "storage";
+  ErrorCategory["DEVICE"] = "device";
+  ErrorCategory["USER_INPUT"] = "user_input";
+  ErrorCategory["SYSTEM"] = "system";
+  ErrorCategory["UNKNOWN"] = "unknown";
+  return ErrorCategory;
+}({});
+
+/**
+ * Context information for error tracking
+ */
+
+/**
+ * Event names for different analytics events
+ */
+export let AnalyticsEventName = /*#__PURE__*/function (AnalyticsEventName) {
+  // Session Events
+  AnalyticsEventName["SESSION_START"] = "session_start";
+  AnalyticsEventName["SESSION_END"] = "session_end";
+  // Navigation Events
+  AnalyticsEventName["SCREEN_VIEW"] = "screen_view";
+  AnalyticsEventName["SCREEN_EXIT"] = "screen_exit";
+  // User Action Events
+  AnalyticsEventName["BUTTON_CLICK"] = "button_click";
+  AnalyticsEventName["CONSENT_GIVEN"] = "consent_given";
+  AnalyticsEventName["STEP_SKIPPED"] = "step_skipped";
+  AnalyticsEventName["STEP_ABANDONED"] = "step_abandoned";
+  // Workflow Step Events (started/completed)
+  AnalyticsEventName["CONTRACT_ACCEPTANCE_STARTED"] = "contract_acceptance_started";
+  AnalyticsEventName["CONTRACT_ACCEPTANCE_COMPLETED"] = "contract_acceptance_completed";
+  AnalyticsEventName["DOCUMENT_SCAN_STARTED"] = "identity_document_scan_started";
+  AnalyticsEventName["DOCUMENT_SCAN_COMPLETED"] = "identity_document_scan_completed";
+  AnalyticsEventName["IDENTITY_DOCUMENT_EID_SCAN_STARTED"] = "identity_document_eid_scan_started";
+  AnalyticsEventName["IDENTITY_DOCUMENT_EID_SCAN_COMPLETED"] = "identity_document_eid_scan_completed";
+  AnalyticsEventName["LIVENESS_CHECK_STARTED"] = "liveness_check_started";
+  AnalyticsEventName["LIVENESS_CHECK_COMPLETED"] = "liveness_check_completed";
+  // NFC Scan Events (used by trackNFCScan* helpers)
+  AnalyticsEventName["NFC_SCAN_STARTED"] = "nfc_scan_started";
+  AnalyticsEventName["NFC_SCAN_COMPLETED"] = "nfc_scan_completed";
+  // NFC Error Events (specific error types for NFC failures)
+  AnalyticsEventName["NFC_SCAN_FAILED"] = "nfc_scan_failed";
+  AnalyticsEventName["NFC_DEVICE_UNSUPPORTED"] = "nfc_device_unsupported";
+  AnalyticsEventName["NFC_READING_ERROR"] = "nfc_reading_error";
+  AnalyticsEventName["NFC_USER_CANCELLED"] = "nfc_user_cancelled";
+  // EID Error Events
+  AnalyticsEventName["IDENTITY_DOCUMENT_EID_SCAN_FAILED"] = "identity_document_eid_scan_failed";
+  // Performance Events
+  AnalyticsEventName["API_CALL_DURATION"] = "api_call_duration";
+  // Verification Outcome Events
+  AnalyticsEventName["VERIFICATION_SUCCESS"] = "verification_success";
+  AnalyticsEventName["VERIFICATION_FAILED"] = "verification_failed";
+  return AnalyticsEventName;
+}({});
+
+/**
+ * Device information (anonymized and privacy-compliant)
+ */
+
+/**
+ * Analytics event metadata
+ */
+
+/**
+ * Base analytics event structure
+ */
+
+/**
+ * Analytics configuration
+ */
+
+/**
+ * Analytics service interface
+ */
+
+/**
+ * Enhanced error event metadata
+ */

package/lib/module/Shared/VisionCameraPlugins/BarcodeScanner/hooks/useCameraPermissions.js

@@ -15,6 +15,7 @@ export const useCameraPermissions = () => {
   const requestPermission = async () => {
     const permission = await requestCameraPermission();
     if (!permission) {
+      // Camera permission denied by user - their choice, not actionable
       Alert.alert('Camera Permission Required', 'This app needs camera access to scan barcodes. Please enable camera permissions in your device settings.', [{
         text: 'Cancel',
         style: 'cancel'

package/lib/module/Translation/index.js

@@ -3,13 +3,25 @@
 import i18n from 'i18next';
 import { initReactI18next } from 'react-i18next';
 import * as resources from "./Resources/index.js";
-import { Platform, NativeModules } from 'react-native';
+import { trackError } from "../Shared/Libs/analytics.utils.js";
 const getCurrentLanguage = () => {
-  let deviceLanguage = Platform.OS === 'ios' ? NativeModules?.SettingsManager?.settings?.AppleLocale : NativeModules?.I18nManager?.localeIdentifier;
-  if (!deviceLanguage) {
-    deviceLanguage = NativeModules?.SettingsManager?.settings?.AppleLanguages[0];
+  try {
+    if (typeof Intl !== 'undefined' && Intl.DateTimeFormat) {
+      const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+      if (locale) {
+        // Extract language code from locale (e.g., "en-US" -> "en", "tr-TR" -> "tr")
+        return locale.split(/[-_]/)[0].toLowerCase();
+      }
+    }
+    return 'en';
+  } catch (error) {
+    console.error('Error detecting language:', error);
+    trackError('LANGUAGE_DETECTION_ERROR', error instanceof Error ? error.message : 'Unknown error', 'translation_init', 'low', {
+      recoverable: true,
+      userAction: 'detect_language'
+    }).catch(() => {});
+    return 'en';
   }
-  return deviceLanguage;
 };
 i18n.use(initReactI18next).init({
   compatibilityJSON: 'v4',

package/lib/module/Trustchex.js

@@ -4,8 +4,8 @@ import React, { useEffect, useState, useMemo } from 'react';
 import { NavigationContainer } from '@react-navigation/native';
 import { createNativeStackNavigator } from '@react-navigation/native-stack';
 import { View, ActivityIndicator, StyleSheet } from 'react-native';
-import { MD3LightTheme, PaperProvider } from 'react-native-paper';
 import 'react-native-get-random-values';
+import { ThemeProvider } from "./Shared/Contexts/ThemeContext.js";
 import IdentityDocumentEIDScanningScreen from "./Screens/Dynamic/IdentityDocumentEIDScanningScreen.js";
 import IdentityDocumentScanningScreen from "./Screens/Dynamic/IdentityDocumentScanningScreen.js";
 import LivenessDetectionScreen from "./Screens/Dynamic/LivenessDetectionScreen.js";
@@ -16,6 +16,8 @@ import QrCodeScanningScreen from "./Screens/Static/QrCodeScanningScreen.js";
 import AppContext from "./Shared/Contexts/AppContext.js";
 import i18n from "./Translation/index.js";
 import { initializeTTS } from "./Shared/Libs/tts.utils.js";
+import { analyticsService } from "./Shared/Services/AnalyticsService.js";
+import { AnalyticsEventCategory, AnalyticsEventName } from "./Shared/Types/analytics.types.js";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const Stack = createNativeStackNavigator();
 const DEFAULT_BRANDING = {
@@ -30,32 +32,32 @@ const Trustchex = ({
   branding: propBranding,
   locale: propLocale,
   onCompleted,
-  onError
+  onError,
+  enableAnalytics = true
 }) => {
+  useEffect(() => {
+    console.log('[Trustchex] Props updated:', {
+      baseUrl: propBaseUrl,
+      sessionId: propSessionId,
+      enableAnalytics
+    });
+  }, [propBaseUrl, propSessionId, enableAnalytics]);
   const [baseUrl, setBaseUrl] = useState(null);
   const [sessionId, setSessionId] = useState(null);
   const [locale, setLocale] = useState(propLocale || i18n.language);
   const [isInitialized, setIsInitialized] = useState(false);
+  const [analyticsInitialized, setAnalyticsInitialized] = useState(false);
   const branding = useMemo(() => ({
     ...DEFAULT_BRANDING,
     ...propBranding
   }), [propBranding]);
-  const theme = useMemo(() => ({
-    ...MD3LightTheme,
-    colors: {
-      ...MD3LightTheme.colors,
-      primary: branding.primaryColor,
-      secondary: branding.secondaryColor,
-      tertiary: branding.tertiaryColor
-    }
-  }), [branding]);
   const contextValue = useMemo(() => ({
     isDemoSession: false,
-    baseUrl,
+    baseUrl: baseUrl || '',
     locale,
     branding,
     identificationInfo: {
-      sessionId,
+      sessionId: sessionId || '',
       identificationId: '',
       consent: {
         contractIds: [],
@@ -64,8 +66,39 @@ const Trustchex = ({
       locale: propLocale || i18n.language
     },
     onCompleted,
-    onError
+    onError,
+    setSessionId,
+    setBaseUrl
   }), [baseUrl, locale, branding, sessionId, propLocale, onCompleted, onError]);
+
+  // Initialize analytics IMMEDIATELY when SDK mounts or session ID changes
+  useEffect(() => {
+    console.log('[Trustchex] Analytics check:', {
+      enableAnalytics,
+      hasBaseUrl: !!baseUrl,
+      hasSessionId: !!sessionId,
+      analyticsInitialized,
+      sessionId: sessionId?.substring(0, 8) + '...'
+    });
+    if (enableAnalytics && baseUrl && sessionId && !analyticsInitialized) {
+      console.log('[Trustchex] Initializing analytics...');
+      // Initialize analytics synchronously with the verification sessionId
+      analyticsService.initialize({
+        enabled: true,
+        baseUrl: baseUrl,
+        verificationSessionId: sessionId // Pass the verification session ID from backend
+      }).then(() => {
+        console.log('[Trustchex] Analytics initialized successfully');
+        setAnalyticsInitialized(true);
+        // Track session start as the very first event
+        analyticsService.trackEvent(AnalyticsEventName.SESSION_START, AnalyticsEventCategory.SESSION, {
+          source: 'sdk_init'
+        });
+      }).catch(error => {
+        console.warn('[Trustchex] Failed to initialize analytics:', error);
+      });
+    }
+  }, [enableAnalytics, baseUrl, sessionId, analyticsInitialized]);
   useEffect(() => {
     initializeTTS();
   }, []);
@@ -85,6 +118,7 @@ const Trustchex = ({
     if (propLocale) {
       setLocale(propLocale);
       i18n.changeLanguage(propLocale);
+      analyticsService.setLocale(propLocale);
     }
   }, [propLocale]);
   if (!baseUrl || !isInitialized) {
@@ -96,8 +130,10 @@ const Trustchex = ({
       })
     });
   }
-  return /*#__PURE__*/_jsx(PaperProvider, {
-    theme: theme,
+  return /*#__PURE__*/_jsx(ThemeProvider, {
+    primaryColor: branding.primaryColor,
+    secondaryColor: branding.secondaryColor,
+    tertiaryColor: branding.tertiaryColor,
     children: /*#__PURE__*/_jsx(AppContext.Provider, {
       value: contextValue,
       children: /*#__PURE__*/_jsx(NavigationContainer, {

package/lib/module/index.js

@@ -2,4 +2,7 @@
 
 import Trustchex from "./Trustchex.js";
 export { handleDeepLink } from "./Shared/Libs/deeplink.utils.js";
+export { analyticsService } from "./Shared/Services/AnalyticsService.js";
+export { trackScreenView, trackScreenExit, trackButtonClick, trackError, trackErrorWithDetails, trackApiCall, trackVerificationStart, trackVerificationComplete, trackConsentGiven, trackSessionStart, trackSessionEnd, trackNFCScanStart, trackNFCScanComplete, trackNFCScanFailed, trackFunnelStep, trackStepAbandoned, trackStepSkipped, useScreenTracking } from "./Shared/Libs/analytics.utils.js";
+export { AnalyticsEventCategory, AnalyticsEventName, ErrorCategory } from "./Shared/Types/analytics.types.js";
 export default Trustchex;

package/lib/typescript/src/Screens/Dynamic/ContractAcceptanceScreen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContractAcceptanceScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/ContractAcceptanceScreen.tsx"],"names":[],"mappings":"AAkBA,QAAA,MAAM,wBAAwB,+CAyH7B,CAAC;AA4BF,eAAe,wBAAwB,CAAC"}
+{"version":3,"file":"ContractAcceptanceScreen.d.ts","sourceRoot":"","sources":["../../../../../src/Screens/Dynamic/ContractAcceptanceScreen.tsx"],"names":[],"mappings":"AA0BA,QAAA,MAAM,wBAAwB,+CAmJ7B,CAAC;AA4BF,eAAe,wBAAwB,CAAC"}