@trustchex/react-native-sdk 1.253.0 → 1.266.0

package/src/Shared/Libs/camera.utils.ts

@@ -1,5 +1,15 @@
 import type { Frame } from 'react-native-vision-camera';
 
+interface Rect {
+  minX: number;
+  minY: number;
+  width: number;
+  height: number;
+}
+
+/**
+ * Get average brightness for entire frame (center area)
+ */
 const getAverageBrightness = (frame: Frame): number => {
   'worklet';
   const buffer = frame.toArrayBuffer();
@@ -26,9 +36,71 @@ const getAverageBrightness = (frame: Frame): number => {
   return luminanceSum / pixelCount;
 };
 
+/**
+ * Get average brightness for a specific circular region (for face detection)
+ * Calculates brightness only for pixels inside the circle defined by centerX, centerY, and radius
+ */
+const getCircularRegionBrightness = (
+  frame: Frame,
+  circleRect: Rect
+): number => {
+  'worklet';
+  const buffer = frame.toArrayBuffer();
+  const data = new Uint8Array(buffer);
+  const width = frame.width;
+  const height = frame.height;
+
+  // Calculate circle parameters from rect
+  const centerX = Math.floor(circleRect.minX + circleRect.width / 2);
+  const centerY = Math.floor(circleRect.minY + circleRect.height / 2);
+  const radius = Math.floor(Math.min(circleRect.width, circleRect.height) / 2);
+
+  let luminanceSum = 0;
+  let pixelCount = 0;
+
+  // Calculate bounding box for the circle to optimize iteration
+  const minX = Math.max(0, centerX - radius);
+  const maxX = Math.min(width - 1, centerX + radius);
+  const minY = Math.max(0, centerY - radius);
+  const maxY = Math.min(height - 1, centerY + radius);
+
+  // Iterate only over pixels in the bounding box
+  for (let y = minY; y <= maxY; y++) {
+    for (let x = minX; x <= maxX; x++) {
+      // Check if pixel is inside the circle
+      const dx = x - centerX;
+      const dy = y - centerY;
+      const distanceSquared = dx * dx + dy * dy;
+
+      if (distanceSquared <= radius * radius) {
+        const index = y * width + x;
+        if (data[index] !== undefined) {
+          luminanceSum += data[index];
+          pixelCount++;
+        }
+      }
+    }
+  }
+
+  return pixelCount > 0 ? luminanceSum / pixelCount : 0;
+};
+
 const isFrameBright = (frame: Frame): boolean => {
   'worklet';
-  return getAverageBrightness(frame) > 80;
+  return getAverageBrightness(frame) > 60;
 };
 
-export { isFrameBright, getAverageBrightness };
+/**
+ * Check if a circular region in the frame is bright enough
+ */
+const isCircularRegionBright = (frame: Frame, circleRect: Rect, threshold: number = 60): boolean => {
+  'worklet';
+  return getCircularRegionBrightness(frame, circleRect) > threshold;
+};
+
+export {
+  isFrameBright,
+  getAverageBrightness,
+  getCircularRegionBrightness,
+  isCircularRegionBright
+};

package/src/Shared/Libs/deeplink.utils.ts

@@ -1,18 +1,23 @@
 const handleDeepLink = ({ url }: { url: string }) => {
+  console.log('[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);
   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);
     } else if (segments[i] === 'app-url') {
       baseUrl = `${isHttps ? 'https' : 'http'}://${segments[i + 1]}`;
+      console.log('[handleDeepLink] Found baseUrl:', baseUrl);
     }
   }
 
+  console.log('[handleDeepLink] Returning:', { baseUrl, sessionId });
   return [baseUrl, sessionId];
 };
 

package/src/Shared/Libs/http-client.ts

@@ -1,3 +1,5 @@
+import { trackApiCall, trackError } from './analytics.utils';
+
 interface ErrorResponse {
   message: string;
 }
@@ -52,49 +54,121 @@ const request = async <TResponse, TBody>(
     });
   }
 
-  const response = await fetch(url, {
-    method: httpMethod,
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: body ? JSON.stringify(body) : undefined,
-  });
-
-  let responseJson = null;
+  const startTime = Date.now();
+  let statusCode = 0;
+  let success = false;
 
   try {
-    responseJson = await response.json();
-  } catch (error) {
-    // throw new Error("Invalid response");
-  }
-
-  if (response && !response.ok && responseJson) {
-    const message = (responseJson as unknown as ErrorResponse).message;
+    const response = await fetch(url, {
+      method: httpMethod,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
 
-    if (response.status === 401) {
-      throw new UnauthorizedError(message);
-    }
+    statusCode = response.status;
+    success = response.ok;
 
-    if (response.status === 403) {
-      throw new ForbiddenError(message);
-    }
+    let responseJson = null;
 
-    if (response.status === 404) {
-      throw new NotFoundError(message);
+    try {
+      responseJson = await response.json();
+    } catch (error) {
+      // Invalid JSON response
     }
 
-    if (response.status >= 500) {
-      throw new InternalServerError(message);
+    // Track API call performance (non-blocking)
+    // Wrap in try-catch to ensure analytics failures never mask HTTP errors
+    try {
+      const duration = Date.now() - startTime;
+      trackApiCall(url, duration, statusCode, success).catch(() => { });
+    } catch { }
+
+    if (response && !response.ok && responseJson) {
+      const message = (responseJson as unknown as ErrorResponse).message;
+
+      const getErrorCodeFromStatus = (status: number): string => {
+        switch (status) {
+          case 400:
+            return 'BAD_REQUEST';
+          case 401:
+            return 'UNAUTHORIZED';
+          case 403:
+            return 'FORBIDDEN';
+          case 404:
+            return 'NOT_FOUND';
+          case 500:
+            return 'INTERNAL_SERVER_ERROR';
+          case 502:
+            return 'BAD_GATEWAY';
+          case 503:
+            return 'SERVICE_UNAVAILABLE';
+          case 504:
+            return 'GATEWAY_TIMEOUT';
+          default:
+            return `API_ERROR_${status}`;
+        }
+      };
+
+      const getSeverityFromStatus = (status: number): 'low' | 'medium' | 'high' | 'critical' => {
+        if (status >= 500) return 'high';
+        if (status === 401 || status === 403) return 'medium';
+        if (status === 400 || status === 404) return 'low';
+        return 'medium';
+      };
+
+      // Track API error (non-blocking)
+      // Wrap in try-catch to ensure analytics failures never mask HTTP errors
+      try {
+        trackError(
+          getErrorCodeFromStatus(statusCode),
+          message || 'API request failed',
+          'http_client',
+          getSeverityFromStatus(statusCode)
+        ).catch(() => { });
+      } catch { }
+
+      if (response.status === 401) {
+        throw new UnauthorizedError(message);
+      }
+
+      if (response.status === 403) {
+        throw new ForbiddenError(message);
+      }
+
+      if (response.status === 404) {
+        throw new NotFoundError(message);
+      }
+
+      if (response.status >= 500) {
+        throw new InternalServerError(message);
+      }
+
+      if (response.status >= 400) {
+        throw new BadRequestError(message);
+      }
+
+      throw new Error(message);
     }
 
-    if (response.status >= 400) {
-      throw new BadRequestError(message);
+    return responseJson as Promise<TResponse>;
+  } catch (error) {
+    // Only track network errors for actual network failures, not HTTP errors
+    // HTTP errors (4xx, 5xx) are already tracked above before throwing
+    if (!(error instanceof HttpClientError)) {
+      try {
+        const duration = Date.now() - startTime;
+        const errorMessage =
+          error instanceof Error ? error.message : 'Unknown error';
+
+        trackApiCall(url, duration, statusCode, false).catch(() => { });
+        trackError('NETWORK_ERROR', errorMessage, 'http_client', 'high').catch(() => { });
+      } catch { }
     }
 
-    throw new Error(message);
+    throw error;
   }
-
-  return responseJson as Promise<TResponse>;
 };
 
 const get = <TResponse>(url: string, simulatedResponse?: TResponse) => {