@trustchex/react-native-sdk 1.355.1 → 1.357.0

package/lib/module/Shared/EIDReader/tlv/tlvOutputState.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import TLVUtil from "./tlv.utils.js";
+import { TLVHelpers } from "./tlv.helpers.js";
 export class TLVOutputState {
   constructor() {
     this.state = [];
@@ -56,7 +56,7 @@ export class TLVOutputState {
     const obj = new TLVStruct(tag);
     if (this.state.length !== 0) {
       const parent = this.state[this.state.length - 1];
-      const tagBytes = TLVUtil.getTagAsBytes(tag);
+      const tagBytes = TLVHelpers.getTagAsBytes(tag);
       parent.write(tagBytes, 0, tagBytes.length);
     }
     this.state.push(obj);
@@ -83,7 +83,7 @@ export class TLVOutputState {
       const obj = this.state.pop();
       if (this.state.length !== 0) {
         const parent = this.state[this.state.length - 1];
-        const lengthBytes = TLVUtil.getLengthAsBytes(length);
+        const lengthBytes = TLVHelpers.getLengthAsBytes(length);
         parent.write(lengthBytes, 0, lengthBytes.length);
       }
       if (obj) {
@@ -102,7 +102,7 @@ export class TLVOutputState {
         currentObject.setLength(byteCount);
         if (currentObject.getValueBytesProcessed() === currentObject.getLength()) {
           this.state.pop();
-          const lengthBytes = TLVUtil.getLengthAsBytes(byteCount);
+          const lengthBytes = TLVHelpers.getLengthAsBytes(byteCount);
           const value = currentObject.getValue();
           this.updateValueBytesProcessed(lengthBytes, 0, lengthBytes.length);
           this.updateValueBytesProcessed(value, 0, value.length);

package/lib/module/Shared/EIDReader/tlv/tlvOutputStream.js

@@ -2,7 +2,7 @@
 
 import { DataOutputStream } from "../java/dataOutputStream.js";
 import { OutputStream } from "../java/outputStream.js";
-import TLVUtil from "./tlv.utils.js";
+import { TLVHelpers } from "./tlv.helpers.js";
 import { TLVOutputState } from "./tlvOutputState.js";
 export class TLVOutputStream extends OutputStream {
   constructor(outputStream) {
@@ -14,7 +14,7 @@ export class TLVOutputStream extends OutputStream {
     if (!this.state.getIsAtStartOfTag()) {
       throw new Error('Cannot write tag, still need length');
     }
-    const tagAsBytes = TLVUtil.getTagAsBytes(tag);
+    const tagAsBytes = TLVHelpers.getTagAsBytes(tag);
     this.outputStream.writeBytes(Uint8Array.from(tagAsBytes));
     this.state.setTagProcessed(tag);
   }
@@ -22,7 +22,7 @@ export class TLVOutputStream extends OutputStream {
     if (!this.state.getIsAtStartOfLength()) {
       throw new Error('Cannot write length');
     }
-    const lengthAsBytes = TLVUtil.getLengthAsBytes(length);
+    const lengthAsBytes = TLVHelpers.getLengthAsBytes(length);
     this.outputStream.writeBytes(Uint8Array.from(lengthAsBytes));
     this.state.setLengthProcessed(length);
   }
@@ -68,7 +68,7 @@ export class TLVOutputStream extends OutputStream {
       const length = bufferedValueBytes.length;
       this.state.updatePreviousLength(length);
       if (this.state.canBeWritten()) {
-        const lengthAsBytes = TLVUtil.getLengthAsBytes(length);
+        const lengthAsBytes = TLVHelpers.getLengthAsBytes(length);
         this.outputStream.writeBytes(Uint8Array.from(lengthAsBytes));
         this.outputStream.writeBytes(Uint8Array.from(bufferedValueBytes));
       }

package/lib/module/Shared/Libs/analytics.utils.js

@@ -89,10 +89,10 @@ const inferErrorCategory = errorCode => {
 /**
  * Track error event with unique event name per error code
  * Event name format: error_{errorCode} (e.g., error_camera_permission_denied)
- * 
+ *
  * Only errors with severity 'medium' or higher are recorded.
  * Low severity errors are ignored to reduce noise.
- * 
+ *
  * @param errorCode - Unique identifier for the error type
  * @param errorMessage - Human-readable error message (sanitized)
  * @param screenName - Screen where the error occurred

package/lib/module/Shared/Libs/debug.utils.js

@@ -0,0 +1,132 @@
+"use strict";
+
+/**
+ * Debug logging utility with log levels for SDK development
+ * Logs are filtered based on the current log level and debug mode
+ *
+ * Log Levels (lower number = more verbose):
+ * 0 - TRACE (all debug information)
+ * 1 - DEBUG (important debug information)
+ * 2 - INFO (informational messages)
+ * 3 - WARN (warnings and important issues)
+ * 4 - ERROR (errors only)
+ * 5 - SILENT (no logging)
+ *
+ * Enable debug mode via:
+ * 1. Environment variable: TRUSTCHEX_DEBUG=true
+ * 2. Global flag: (global as any).TRUSTCHEX_DEBUG = true
+ * 3. TrustchexProvider prop: debug={true}
+ *
+ * Set log level via:
+ * 1. setLogLevel(LogLevel.TRACE)
+ * 2. TRUSTCHEX_LOG_LEVEL environment variable
+ * 3. TrustchexProvider prop: logLevel="trace"
+ */
+
+export let LogLevel = /*#__PURE__*/function (LogLevel) {
+  LogLevel[LogLevel["TRACE"] = 0] = "TRACE";
+  LogLevel[LogLevel["DEBUG"] = 1] = "DEBUG";
+  LogLevel[LogLevel["INFO"] = 2] = "INFO";
+  LogLevel[LogLevel["WARN"] = 3] = "WARN";
+  LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
+  LogLevel[LogLevel["SILENT"] = 5] = "SILENT";
+  return LogLevel;
+}({});
+let debugEnabled = process.env.NODE_ENV === 'development' && (global.TRUSTCHEX_DEBUG === true || process.env.TRUSTCHEX_DEBUG === 'true');
+
+// Default to TRACE level for development debugging
+let currentLogLevel = debugEnabled ? LogLevel.TRACE : LogLevel.WARN;
+
+// Parse log level from env or string
+const parseLogLevel = level => {
+  if (level === undefined) return currentLogLevel;
+  if (typeof level === 'number') return level;
+  const levelMap = {
+    trace: LogLevel.TRACE,
+    debug: LogLevel.DEBUG,
+    info: LogLevel.INFO,
+    warn: LogLevel.WARN,
+    error: LogLevel.ERROR,
+    silent: LogLevel.SILENT
+  };
+  return levelMap[level.toLowerCase()] ?? currentLogLevel;
+};
+export const setDebugMode = enabled => {
+  debugEnabled = enabled;
+  // When debug mode is enabled, default to TRACE level
+  if (enabled && currentLogLevel === LogLevel.WARN) {
+    currentLogLevel = LogLevel.TRACE;
+  }
+};
+export const setLogLevel = level => {
+  currentLogLevel = parseLogLevel(level);
+};
+export const isDebugEnabled = () => {
+  return debugEnabled;
+};
+export const getLogLevel = () => {
+  return currentLogLevel;
+};
+
+// Check if a message at the given level should be logged
+const shouldLog = level => {
+  return debugEnabled && level >= currentLogLevel;
+};
+export const traceLog = (tag, message, data) => {
+  if (!shouldLog(LogLevel.TRACE)) return;
+  if (data !== undefined) {
+    console.log(`[${tag}] TRACE: ${message}`, data);
+  } else {
+    console.log(`[${tag}] TRACE: ${message}`);
+  }
+};
+export const debugLog = (tag, message, data) => {
+  if (!shouldLog(LogLevel.DEBUG)) return;
+  if (data !== undefined) {
+    console.log(`[${tag}] DEBUG: ${message}`, data);
+  } else {
+    console.log(`[${tag}] DEBUG: ${message}`);
+  }
+};
+export const infoLog = (tag, message, data) => {
+  if (!shouldLog(LogLevel.INFO)) return;
+  if (data !== undefined) {
+    console.log(`[${tag}] INFO: ${message}`, data);
+  } else {
+    console.log(`[${tag}] INFO: ${message}`);
+  }
+};
+export const debugWarn = (tag, message, data) => {
+  if (!shouldLog(LogLevel.WARN)) return;
+  if (data !== undefined) {
+    console.warn(`[${tag}] WARN: ${message}`, data);
+  } else {
+    console.warn(`[${tag}] WARN: ${message}`);
+  }
+};
+export const debugError = (tag, message, error) => {
+  if (!shouldLog(LogLevel.ERROR)) return;
+  if (error !== undefined) {
+    console.error(`[${tag}] ERROR: ${message}`, error);
+  } else {
+    console.error(`[${tag}] ERROR: ${message}`);
+  }
+};
+
+// Always log errors regardless of debug mode (critical issues)
+export const logError = (tag, message, error) => {
+  if (error !== undefined) {
+    console.error(`[${tag}] ERROR: ${message}`, error);
+  } else {
+    console.error(`[${tag}] ERROR: ${message}`);
+  }
+};
+
+// Always log warnings for critical issues regardless of debug mode
+export const logWarn = (tag, message, data) => {
+  if (data !== undefined) {
+    console.warn(`[${tag}] WARN: ${message}`, data);
+  } else {
+    console.warn(`[${tag}] WARN: ${message}`);
+  }
+};

package/lib/module/Shared/Libs/deeplink.utils.js

@@ -1,25 +1,26 @@
 "use strict";
 
+import { debugLog } from "./debug.utils.js";
 const handleDeepLink = ({
   url
 }) => {
-  console.log('[handleDeepLink] Received URL:', url);
+  debugLog('handleDeepLink', 'Received URL:', url);
   const isHttps = url.includes('https');
   const route = url.replace(/http(s)?(:)?(\/\/)?/g, '');
   const segments = route.split('/');
-  console.log('[handleDeepLink] Parsed segments:', segments);
+  debugLog('handleDeepLink', 'Parsed segments:', segments);
   let baseUrl = '';
   let sessionId = '';
   for (let i = 0; i < segments.length; i++) {
     if (segments[i] === 'verification-session') {
       sessionId = segments[i + 1] ?? '';
-      console.log('[handleDeepLink] Found sessionId:', sessionId);
+      debugLog('handleDeepLink', 'Found sessionId:', sessionId);
     } else if (segments[i] === 'app-url') {
       baseUrl = `${isHttps ? 'https' : 'http'}://${segments[i + 1]}`;
-      console.log('[handleDeepLink] Found baseUrl:', baseUrl);
+      debugLog('handleDeepLink', 'Found baseUrl:', baseUrl);
     }
   }
-  console.log('[handleDeepLink] Returning:', {
+  debugLog('handleDeepLink', 'Returning:', {
     baseUrl,
     sessionId
   });

package/lib/module/Shared/Libs/demo.utils.js

@@ -14,6 +14,7 @@ const demoSession = {
     type: 'CONTRACT_ACCEPTANCE',
     required: false,
     data: {
+      voiceGuidanceActive: true,
       contracts: {
         en: {
           id: '1',
@@ -29,13 +30,22 @@ const demoSession = {
     }
   }, {
     type: 'IDENTITY_DOCUMENT_SCAN',
-    required: false
+    required: false,
+    data: {
+      voiceGuidanceActive: true
+    }
   }, {
     type: 'IDENTITY_DOCUMENT_EID_SCAN',
-    required: false
+    required: false,
+    data: {
+      voiceGuidanceActive: true
+    }
   }, {
     type: 'LIVENESS_CHECK',
-    required: false
+    required: false,
+    data: {
+      voiceGuidanceActive: true
+    }
   }]
 };
 const isDemoSession = sessionCode => sessionCode.toUpperCase() === 'DEMXCXDE';

package/lib/module/Shared/Libs/mrz.utils.js

@@ -1,195 +1,21 @@
 "use strict";
 
-import { parse } from 'mrz';
-
-/**
- * Fixes the raw text of an MRZ by removing spaces and « characters, and padding lines to the expected length.
- * @param rawText  The raw text to fix
- * @returns  The fixed text
- */
-const fixMRZ = rawText => {
-  if (!rawText) {
-    return rawText;
-  }
-  const FILLER_CHAR = '<';
-  const MRZ_FORMATS = [{
-    lines: 3,
-    length: 30
-  },
-  // TD1
-  {
-    lines: 2,
-    length: 36
-  },
-  // TD2
-  {
-    lines: 2,
-    length: 44
-  } // TD3
-  ];
-  const cleanedText = rawText.replace(/«| /g, '') // Remove « characters and spaces
-  .replace(/<K+|r+K+|<r+K+/g, '') // Remove invalid patterns
-  .replace(/\bI<TUR([A-Z0-9]{3})0([A-Z0-9]{6})\b/g, 'I<TUR$1O$2'); // Fix document number if it contains '0' instead of 'O'
-
-  const lines = cleanedText.split(/\n/).map(line => line.trim()).filter(line => /<+/.test(line));
-  let detectedFormat = MRZ_FORMATS.find(format => {
-    return lines.every(line => line.length <= format.length);
-  });
-  if (!detectedFormat) {
-    return rawText;
-  }
-  const fixedLines = lines.map(line => {
-    if (/<+/.test(line) && line.length < detectedFormat.length) {
-      return line.padEnd(detectedFormat.length, FILLER_CHAR);
-    }
-    return line;
-  });
-  return fixedLines.join('\n');
-};
-const MRZ_REGEX = /^(?:[A-Z0-9<]{44}\n[A-Z0-9<]{44}|[A-Z0-9<]{30}\n[A-Z0-9<]{30}\n[A-Z0-9<]{30}|[A-Z0-9<]{36}\n[A-Z0-9<]{36})$/im;
-const getMRZText = fixedText => {
-  if (MRZ_REGEX.test(fixedText)) {
-    return fixedText.match(MRZ_REGEX)[0];
-  }
-  return null;
-};
-
-/**
- * Apply common OCR corrections for MRZ text
- * Common confusions: 0/O, 1/I, 8/B, 5/S, 2/Z
- */
-const applyOCRCorrections = mrzText => {
-  const corrections = [];
-
-  // Common OCR substitutions to try
-  // In MRZ: letters should be in name fields, numbers in date/checksum fields
-  const substitutions = [
-  // Try replacing O with 0 in numeric positions (dates, checksums)
-  {
-    from: /O/g,
-    to: '0'
-  },
-  // Try replacing 0 with O in alphabetic positions (names, country codes)
-  {
-    from: /0/g,
-    to: 'O'
-  },
-  // I and 1 confusion
-  {
-    from: /I(?=\d)/g,
-    to: '1'
-  },
-  // I followed by digit -> likely 1
-  {
-    from: /1(?=[A-Z])/g,
-    to: 'I'
-  },
-  // 1 followed by letter -> likely I
-  // B and 8 confusion
-  {
-    from: /B(?=\d)/g,
-    to: '8'
-  }, {
-    from: /8(?=[A-Z])/g,
-    to: 'B'
-  },
-  // S and 5 confusion
-  {
-    from: /S(?=\d)/g,
-    to: '5'
-  }, {
-    from: /5(?=[A-Z])/g,
-    to: 'S'
-  },
-  // Z and 2 confusion
-  {
-    from: /Z(?=\d)/g,
-    to: '2'
-  }, {
-    from: /2(?=[A-Z])/g,
-    to: 'Z'
-  }];
-  for (const sub of substitutions) {
-    const corrected = mrzText.replace(sub.from, sub.to);
-    if (corrected !== mrzText) {
-      corrections.push(corrected);
-    }
-  }
-  return corrections;
-};
-const getMRZData = ocrText => {
-  const fixedText = fixMRZ(ocrText);
-  const mrzText = getMRZText(fixedText);
-  if (mrzText) {
-    // First attempt with original text
-    let parsedResult = parse(mrzText, {
-      autocorrect: true
-    });
-
-    // Check if parse is valid with all required fields
-    const isValidParse = result => {
-      return result.valid && result.fields.firstName && result.fields.lastName && result.fields.birthDate && result.fields.expirationDate && result.fields.documentNumber && result.fields.issuingState;
-    };
-    if (isValidParse(parsedResult)) {
-      return {
-        mrzText,
-        parsedResult
-      };
-    }
-
-    // If not valid, try OCR corrections
-    const corrections = applyOCRCorrections(mrzText);
-    for (const correctedMRZ of corrections) {
-      try {
-        const correctedResult = parse(correctedMRZ, {
-          autocorrect: true
-        });
-        if (isValidParse(correctedResult)) {
-          return {
-            mrzText: correctedMRZ,
-            parsedResult: correctedResult
-          };
-        }
-      } catch (e) {
-        // Continue trying other corrections
-      }
-    }
-
-    // Return original result even if not fully valid (for partial matches)
-    if (parsedResult.fields.firstName && parsedResult.fields.lastName && parsedResult.fields.birthDate && parsedResult.fields.expirationDate && parsedResult.fields.documentNumber && parsedResult.fields.issuingState) {
-      return {
-        mrzText,
-        parsedResult
-      };
-    }
-  }
-  return {
-    mrzText: null,
-    parsedResult: null
-  };
-};
-
 /**
  * Converts an MRZ date string to an ISO date string.
- * @param mrzDate  The MRZ date string to convert
+ * @param mrzDate  The MRZ date string to convert (YYMMDD format)
  * @returns  The ISO date string, or null if the input is invalid
  */
 const convertMRZDateToISODate = mrzDate => {
   if (!mrzDate || mrzDate.length !== 6) {
     return null;
   }
-
-  // Extract year, month, and day from the MRZ date string
   let year = parseInt(mrzDate.slice(0, 2), 10);
   let month = parseInt(mrzDate.slice(2, 4), 10) - 1;
   let day = parseInt(mrzDate.slice(4, 6), 10);
-
-  // Handle century assumption (usually 1900 or 2000)
   year += year < 50 ? 2000 : 1900;
   const date = new Date(Date.UTC(year, month, day));
   return date.toISOString();
 };
 export default {
-  getMRZData,
   convertMRZDateToISODate
 };

package/lib/module/Shared/Libs/native-device-info.utils.js

@@ -4,12 +4,18 @@ import { Platform } from 'react-native';
 import DeviceInfo from 'react-native-device-info';
 export const NativeDeviceInfo = {
   generateHumanReadableIdentifier: async () => {
-    const brand = DeviceInfo.getBrand();
-    const model = DeviceInfo.getModel();
-    const systemName = Platform.OS === 'ios' ? 'iOS' : 'Android';
-    const systemVersion = DeviceInfo.getSystemVersion();
-    const uniqueId = await DeviceInfo.getUniqueId();
-    return `${brand} ${model} (${systemName} ${systemVersion}) - ${uniqueId}`;
+    try {
+      const brand = await DeviceInfo.getBrand();
+      const model = await DeviceInfo.getModel();
+      const systemName = Platform.OS === 'ios' ? 'iOS' : 'Android';
+      const systemVersion = await DeviceInfo.getSystemVersion();
+      const uniqueId = await DeviceInfo.getUniqueId();
+      return `${brand} ${model} (${systemName} ${systemVersion}) - ${uniqueId}`;
+    } catch (error) {
+      console.warn('[DeviceInfo] Failed to get device info:', error);
+      const systemName = Platform.OS === 'ios' ? 'iOS' : 'Android';
+      return `Unknown Device (${systemName}) - ${Date.now()}`;
+    }
   }
 };
 export default NativeDeviceInfo;

package/lib/module/Shared/Libs/tts.utils.js

@@ -3,23 +3,57 @@
 import i18n from "../../Translation/index.js";
 import Tts from 'react-native-tts';
 import debounce from "./debounce.utils.js";
+let isSpeaking = false;
+let lastSpokenMessage = '';
+let lastSpeakTime = 0;
+const MIN_SPEAK_INTERVAL = 3000; // Minimum 3 seconds between messages
+
 Tts.addEventListener('tts-start', _event => {
-  // console.log('TTS started', event);
+  isSpeaking = true;
 });
 Tts.addEventListener('tts-finish', _event => {
-  // console.log('TTS finished', event);
+  isSpeaking = false;
 });
 Tts.addEventListener('tts-cancel', _event => {
-  // console.log('TTS cancelled', event);
+  isSpeaking = false;
 });
-const speak = async text => {
+const speak = async (text, bypassInterval = false) => {
+  const now = Date.now();
+
+  // Prevent duplicate message
+  if (text === lastSpokenMessage) {
+    return;
+  }
+
+  // Enforce minimum interval between different messages (unless bypassed)
+  if (!bypassInterval && now - lastSpeakTime < MIN_SPEAK_INTERVAL) {
+    return;
+  }
+
+  // When bypassing interval (e.g., liveness instructions), interrupt current speech
+  // to ensure new instruction is spoken immediately
+  if (bypassInterval && isSpeaking) {
+    await Tts.stop();
+    isSpeaking = false;
+  }
+
+  // Wait for any ongoing speech to finish (unless we just interrupted it)
+  if (isSpeaking) {
+    return;
+  }
   await Tts.setDefaultLanguage(i18n.language);
   await Tts.stop();
   Tts.speak(text);
+  lastSpokenMessage = text;
+  lastSpeakTime = now;
 };
-const speakWithDebounce = debounce(speak, 500);
+const speakWithDebounce = debounce(speak, 1500);
 const stopSpeaking = async () => {
   await Tts.stop();
+  isSpeaking = false;
+};
+const resetLastMessage = () => {
+  lastSpokenMessage = '';
 };
 const initializeTTS = () => {
   Tts.getInitStatus().then(() => {}, err => {
@@ -28,4 +62,4 @@ const initializeTTS = () => {
     }
   });
 };
-export { speak, speakWithDebounce, stopSpeaking, initializeTTS };
+export { speak, speakWithDebounce, stopSpeaking, resetLastMessage, initializeTTS };

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

@@ -12,6 +12,7 @@ import 'react-native-get-random-values';
 import { v4 as uuidv4 } from 'uuid';
 import { SDK_VERSION } from "../../version.js";
 import { AnalyticsEventName } from "../Types/analytics.types.js";
+import { debugLog, debugWarn } from "../Libs/debug.utils.js";
 class AnalyticsService {
   config = null;
   sessionId = null;
@@ -97,13 +98,13 @@ class AnalyticsService {
         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`);
+          if (__DEV__) debugLog('AnalyticsService', `[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);
+      if (__DEV__) debugWarn('[Analytics] Failed to load persisted queue:', error);
     }
   }
 
@@ -120,7 +121,7 @@ class AnalyticsService {
       }
       await RNFS.writeFile(this.QUEUE_FILE_PATH, JSON.stringify(this.queue), 'utf8');
     } catch (error) {
-      if (__DEV__) console.warn('[Analytics] Failed to persist queue:', error);
+      if (__DEV__) debugWarn('[Analytics] Failed to persist queue:', error);
     }
   }
 
@@ -168,7 +169,7 @@ class AnalyticsService {
     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`);
+      if (__DEV__) debugWarn('AnalyticsService', `[Analytics] Queue overflow, dropped ${dropped} oldest events`);
     }
 
     // Flush immediately for critical events or if batch size reached
@@ -228,7 +229,7 @@ class AnalyticsService {
       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);
+      if (__DEV__) debugWarn('AnalyticsService', '[Analytics] Failed to flush batch, keeping events:', error);
 
       // Ensure they are persisted
       await this.persistQueue();
@@ -265,10 +266,10 @@ class AnalyticsService {
         // 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`);
+          if (__DEV__) debugWarn('AnalyticsService', `[Analytics] Dropping batch due to ${response.status} error`);
           return;
         }
-        if (__DEV__) console.warn('[Analytics] Failed to send batch:', response.status);
+        if (__DEV__) debugWarn('AnalyticsService', '[Analytics] Failed to send batch:', response.status);
       }
     } catch (error) {
       if (attempt <= maxRetries) {
@@ -324,7 +325,7 @@ class AnalyticsService {
         screenResolution: `${DeviceInfo.getDeviceType()}`
       };
     } catch (error) {
-      if (__DEV__) console.warn('[Analytics] Error collecting device info:', error);
+      if (__DEV__) debugWarn('AnalyticsService', '[Analytics] Error collecting device info:', error);
       // Fallback device info
       this.deviceInfo = {
         platform: 'android',

package/lib/module/Shared/Types/mrzFields.js

@@ -0,0 +1 @@
+"use strict";