@sanctum-key/react-native-sdk 1.0.15 → 1.0.17

package/src/modules/api/CardAuthentification.ts

@@ -22,50 +22,6 @@ interface ApiVerificationResponse {
     [key: string]: any;
 }
 
-function getDistance(p1: number[], p2: number[]): number {
-    return Math.sqrt(Math.pow(p2[0] - p1[0], 2) + Math.pow(p2[1] - p1[1], 2));
-}
-
-function getPolygonArea(points: number[][]): number {
-    const n = points.length;
-    let area = 0;
-    for (let i = 0; i < n; i++) {
-        const j = (i + 1) % n;
-        area += points[i][0] * points[j][1];
-        area -= points[j][0] * points[i][1];
-    }
-    return Math.abs(area) / 2;
-}
-
-function assertCardNotTooFar(points: number[][]): void {
-    if (!points || points.length < 3) return;
-
-    const longestCardEdge = Math.max(
-        getDistance(points[0], points[1]),
-        getDistance(points[1], points[2]),
-        getDistance(points[2], points[3] ?? points[0]),
-    );
-
-    const cardArea = getPolygonArea(points);
-
-    logger.log(
-        `Card distance check – longest edge: ${Math.round(longestCardEdge)} px, ` +
-        `OBB area: ${Math.round(cardArea)} px²`
-    );
-
-    if (longestCardEdge < 700) {
-        logger.log(`🛑 Rejected: longest edge too short (${Math.round(longestCardEdge)} px < 700 px)`);
-        throw new Error('TOO_FAR_AWAY');
-    }
-
-    if (cardArea < 400_000) {
-        logger.log(`🛑 Rejected: card area too small (${Math.round(cardArea)} px² < 400 000 px²)`);
-        throw new Error('TOO_FAR_AWAY');
-    }
-}
-
-// ─── frontVerification ────────────────────────────────────────────────────────
-
 export async function frontVerification(
     result: {
         path?: string,
@@ -82,8 +38,8 @@ export async function frontVerification(
         console.log("Front verification START", JSON.stringify({ result }, null, 2));
         logger.log("Front verification", JSON.stringify({ result }, null, 2));
 
-        const authMethods = Array.isArray(result.regionMapping?.authMethod) 
-            ? result.regionMapping.authMethod.map(m => String(m).toUpperCase()) 
+        const authMethods = Array.isArray(result.regionMapping?.authMethod)
+            ? result.regionMapping.authMethod.map(m => String(m).toUpperCase())
             : [];
         const hasMrz = authMethods.some(m => m.includes('MRZ'));
 
@@ -130,6 +86,7 @@ export async function frontVerification(
         let points: number[][] | null = null;
         let isCardInFrame = true;
         let hasCroppedSides = false;
+        console.log(points)
 
         if (cardData) {
             points = cardData.obb;
@@ -140,14 +97,10 @@ export async function frontVerification(
         }
 
         if (!isCardInFrame || hasCroppedSides) {
-            logger.log(`Front Framing failed. Cropped sides detected.`);
+            logger.log(`Front Framing failed. Cropped sides detected by backend.`);
             throw new Error('CARD_NOT_FULLY_IN_FRAME');
         }
 
-        if (points && points.length >= 3) {
-            assertCardNotTooFar(points);
-        }
-
         const obbConfidence = getObbConfidence(detected.card_obb);
         if (obbConfidence !== null && obbConfidence < OBB_CONFIDENCE_THRESHOLD) {
             throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
@@ -174,11 +127,11 @@ export async function frontVerification(
                         postfix: result?.currentSide || 'front',
                         token: token,
                         template_path: result?.templatePath || '',
-                        mrz_type: result?.mrzType || 'TD1' 
+                        mrz_type: result?.mrzType || 'TD1'
                     },
                     env
                 );
-                
+
                 mrz = typeof mrzResponse === 'string' ? JSON.parse(mrzResponse) : mrzResponse;
 
                 if (mrz?.parsed_data?.status === 'FAILURE' || mrz?.success === false) {
@@ -186,7 +139,7 @@ export async function frontVerification(
                     throw new Error(`MRZ illisible: ${mrz?.parsed_data?.status_message || 'Veuillez nettoyer l\'objectif et réessayer'}`);
                 }
             } catch (err: any) {
-                logger.error("MRZ Extraction Error:", err);
+                logger.log("MRZ Extraction Error:", err);
                 throw new Error(err?.message || "Erreur lors de l'extraction MRZ. Veuillez reprendre la photo.");
             }
         }
@@ -194,12 +147,11 @@ export async function frontVerification(
         return { ...detected, croppedBase64, bbox, ...(mrz ? { mrz } : {}) };
 
     } catch (e: any) {
-        logger.error('Error front verification:', e?.message);
+        logger.log('Error front verification:', e?.message);
         throw new Error(e?.message || 'Erreur de détection du visage');
     }
 }
 
-
 export async function backVerification(
     result: {
         path?: string,
@@ -218,8 +170,8 @@ export async function backVerification(
         logger.log("result.regionMapping", result.regionMapping, result.currentSide, result.code);
         logger.log('result object', result)
 
-        const authMethods = Array.isArray(result.regionMapping?.authMethod) 
-            ? result.regionMapping.authMethod.map(m => String(m).toUpperCase()) 
+        const authMethods = Array.isArray(result.regionMapping?.authMethod)
+            ? result.regionMapping.authMethod.map(m => String(m).toUpperCase())
             : [];
 
         const hasMrz = authMethods.some(m => m.includes('MRZ'))
@@ -285,6 +237,7 @@ export async function backVerification(
         let points: number[][] | null = null;
         let isCardInFrame = false;
         let hasCroppedSides = true;
+        console.log(points)
 
         if (cardData.obb) {
             points = cardData.obb;
@@ -296,25 +249,14 @@ export async function backVerification(
             points = cardData[0];
             isCardInFrame = true;
             hasCroppedSides = false;
-            if (points && points.length === 4) {
-                const minX = Math.min(...points.map((p: number[]) => p[0]));
-                const minY = Math.min(...points.map((p: number[]) => p[1]));
-                if (minX <= 15 || minY <= 15) {
-                    isCardInFrame = false;
-                    hasCroppedSides = true;
-                }
-            }
+            // 🚨 ARTIFICIAL CHECK REMOVED HERE
         }
 
         if (!isCardInFrame || hasCroppedSides) {
-            logger.log(`Back Framing failed. Coordinates hit image boundary.`);
+            logger.log(`Back Framing failed. Backend reported document out of bounds.`);
             throw new Error('CARD_NOT_FULLY_IN_FRAME');
         }
 
-        if (points && points.length >= 3) {
-            assertCardNotTooFar(points);
-        }
-
         const obbConf = getObbConfidence(templateResponse?.card_obb);
         if (obbConf !== null && obbConf < OBB_CONFIDENCE_THRESHOLD) {
             throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
@@ -354,9 +296,9 @@ export async function backVerification(
                 if (mrz?.parsed_data?.status === 'FAILURE' || mrz?.success === false) {
                     throw new Error(mrz?.parsed_data?.status_message || 'Lecture MRZ échouée');
                 }
-                
+
                 extractionResult.mrz = mrz; // Attaching securely to result object
-                
+
             } catch (mrzError: any) {
                 logger.log(`MRZ échoué: ${mrzError?.message}`);
                 // If MRZ fails, we MUST throw an error so the user is forced to retake it!
@@ -394,7 +336,7 @@ export async function backVerification(
         };
 
     } catch (e: any) {
-        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME' || e?.message === 'TOO_FAR_AWAY') throw e;
+        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME') throw e; 
         throw new Error(e?.message || 'Erreur de détection des données');
     }
 }
@@ -439,6 +381,7 @@ export async function checkTemplateType(
         let points: number[][] | null = null;
         let isCardInFrame = false;
         let hasCroppedSides = true;
+        console.log(points)
 
         if (cardData.obb) {
             points = cardData.obb;
@@ -450,25 +393,14 @@ export async function checkTemplateType(
             points = cardData[0];
             isCardInFrame = true;
             hasCroppedSides = false;
-            if (points && points.length === 4) {
-                const minX = Math.min(...points.map((p: number[]) => p[0]));
-                const minY = Math.min(...points.map((p: number[]) => p[1]));
-                if (minX <= 15 || minY <= 15) {
-                    isCardInFrame = false;
-                    hasCroppedSides = true;
-                }
-            }
+            // 🚨 ARTIFICIAL CHECK REMOVED HERE
         }
 
         if (!isCardInFrame || hasCroppedSides) {
-            logger.log(`Template Framing failed.`);
+            logger.log(`Template Framing failed by backend check.`);
             throw new Error('CARD_NOT_FULLY_IN_FRAME');
         }
 
-        if (points && points.length >= 3) {
-            assertCardNotTooFar(points);
-        }
-
         const LPIPS_THRESHOLD = 0.75;
         if (templateType.lpips_score !== undefined && templateType.lpips_score > LPIPS_THRESHOLD) {
             logger.log(`🛑 Country Mismatch! LPIPS: ${templateType.lpips_score}`);
@@ -478,8 +410,8 @@ export async function checkTemplateType(
         logger.log("templateType result", JSON.stringify(truncateFields(templateType), null, 2));
         return templateType;
     } catch (e: any) {
-        logger.error('Errorrr checking template type:', JSON.stringify(errorMessage(e), null, 2));
-        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME' || e?.message === 'TOO_FAR_AWAY' || e?.message?.includes('ne correspond pas')) throw e;
+        logger.log('Errorrr checking template type:', JSON.stringify(errorMessage(e), null, 2));
+        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME' || e?.message?.includes('ne correspond pas')) throw e; 
         throw new Error(e?.message || 'Erreur de vérification du template');
     }
 }

package/src/utils/cropByObb.ts

@@ -1,24 +1,18 @@
-import { Image as RNImage, Platform } from 'react-native';
+import { Platform } from 'react-native';
 import * as ImageManipulator from "expo-image-manipulator";
 
 
 type Point = [number, number];
 
-/** OBB confidence below this = card not fully in frame; don't crop, give user feedback. */
 export const OBB_CONFIDENCE_THRESHOLD = 0.85;
 
-/**
- * card_obb format from API:
- * - Legacy: [ [ [p1,p2,p3,p4], confidence ] ]
- * - New:    [ { obb: [p1,p2,p3,p4], confidence, card_in_frame?, cropped_sides? } ]
- * Returns confidence in [0,1] or null if not present.
- */
+
 export function getObbConfidence(cardObb: any): number | null {
   if (!cardObb || !Array.isArray(cardObb) || cardObb.length === 0) return null;
   const first = cardObb[0];
 
   // New format: first is an object with a confidence field
-  if (first && typeof first === 'object' && 'confidence' in first) {
+  if (first && typeof first === 'object' && !Array.isArray(first) && 'confidence' in first) {
     const score = (first as any).confidence;
     return typeof score === 'number' ? score : null;
   }
@@ -36,14 +30,12 @@ export function getObbConfidence(cardObb: any): number | null {
 export function getCardInFrame(cardObb: any): boolean | null {
   if (!cardObb) return null;
   
-  // card_obb can be an array of objects or a single object
   const first = Array.isArray(cardObb) ? cardObb[0] : cardObb;
 
   if (first && typeof first === 'object' && 'card_in_frame' in first) {
     const isCardInFrame = first.card_in_frame === true;
     const hasCroppedSides = Array.isArray(first.cropped_sides) && first.cropped_sides.length > 0;
 
-    // If the API explicitly says it's not in frame, OR if it lists cropped edges, reject it.
     if (!isCardInFrame || hasCroppedSides) {
       if (hasCroppedSides) {
         console.warn(`Card is cropped on sides: ${first.cropped_sides.join(', ')}`);
@@ -51,11 +43,9 @@ export function getCardInFrame(cardObb: any): boolean | null {
       return false;
     }
 
-    // If we made it here, card_in_frame is true AND cropped_sides is empty.
     return true;
   }
 
-  // Backward compatibility check
   if (cardObb && typeof cardObb === 'object' && 'card_in_frame' in cardObb) {
     const value = (cardObb as any).card_in_frame;
     return typeof value === 'boolean' ? value : null;
@@ -64,6 +54,25 @@ export function getCardInFrame(cardObb: any): boolean | null {
   return null;
 }
 
+
+function extractObbPoints(cardObb: any): Point[] | null {
+  if (!cardObb) return null;
+  const first = Array.isArray(cardObb) ? cardObb[0] : cardObb;
+
+  // New format: { obb: [...], confidence, ... }
+  if (first && typeof first === 'object' && !Array.isArray(first) && 'obb' in first) {
+    const pts = (first as any).obb;
+    if (Array.isArray(pts) && pts.length === 4) return pts as Point[];
+  }
+
+  // Legacy format: [ [p1,p2,p3,p4], confidence ]
+  if (Array.isArray(first) && Array.isArray(first[0]) && first[0].length === 4) {
+    return first[0] as Point[];
+  }
+
+  return null;
+}
+
 // Compute axis-aligned bounding box from oriented quadrilateral
 function computeAabb(points: Point[]) {
   const xs = points.map(p => p[0]);
@@ -75,7 +84,6 @@ function computeAabb(points: Point[]) {
   return { minX, minY, maxX, maxY, width: maxX - minX, height: maxY - minY };
 }
 
-// Web-only crop using Canvas; returns dataURL (base64)
 async function cropWeb(uri: string, points: Point[]): Promise<string> {
   return new Promise((resolve, reject) => {
     const img = new Image();
@@ -89,7 +97,7 @@ async function cropWeb(uri: string, points: Point[]): Promise<string> {
       if (!ctx) return reject(new Error('Canvas context not available'));
       ctx.drawImage(
         img,
-        minX, minY, width, height, // Source 
+        minX, minY, width, height, // Source
         0, 0, canvas.width, canvas.height // Destination
       );
       resolve(canvas.toDataURL('image/jpeg', 0.92));
@@ -99,15 +107,17 @@ async function cropWeb(uri: string, points: Point[]): Promise<string> {
   });
 }
 
-// Fallback: return original for native
 export async function cropByObb(uri: string, cardObb: any): Promise<{ base64?: string; bbox?: { minX: number; minY: number; width: number; height: number } }> {
   try {
     const confidence = getObbConfidence(cardObb);
     if (confidence !== null && confidence < OBB_CONFIDENCE_THRESHOLD) {
       return {};
     }
-    const first = Array.isArray(cardObb) ? cardObb[0] : null;
-    const points = Array.isArray(first?.[0]) ? (first[0] as Point[]) : null;
+
+    // FIX: Use extractObbPoints() which handles both legacy and new API formats.
+    // The old code used `Array.isArray(first?.[0]) ? first[0] : null`, which
+    // returned null for new-format responses like [{obb:[...], confidence}].
+    const points = extractObbPoints(cardObb);
     if (!points || points.length !== 4) return {};
 
     const { minX, minY, width, height } = computeAabb(points);
@@ -124,28 +134,58 @@ export async function cropByObb(uri: string, cardObb: any): Promise<{ base64?: s
 }
 
 
+async function normalizeOrientationAndGetDimensions(
+  uri: string
+): Promise<{ normalizedUri: string; width: number; height: number }> {
+  // Web: canvas already handles EXIF; skip normalization
+  if (Platform.OS === 'web') {
+    return new Promise((resolve, reject) => {
+      const img = new Image();
+      img.onload = () => resolve({ normalizedUri: uri, width: img.naturalWidth, height: img.naturalHeight });
+      img.onerror = reject;
+      img.src = uri;
+    });
+  }
+
+  // Native: re-encode to bake EXIF rotation into actual pixels
+  const result = await ImageManipulator.manipulateAsync(
+    uri,
+    [], // No transforms — just re-encode to normalize
+    { compress: 1, format: ImageManipulator.SaveFormat.JPEG }
+  );
+  return { normalizedUri: result.uri, width: result.width, height: result.height };
+}
+
+
 export async function cropImageWithBBoxWithTolerance(uri: string, bbox: any, tolerance: number = 0.02): Promise<string> {
   return new Promise<string>((resolve) => {
     let isResolved = false;
 
-    // Safety Timeout (10 seconds)
+    // Safety Timeout (15 seconds — slightly longer to account for normalization step)
     const timeout = setTimeout(() => {
       if (!isResolved) {
         isResolved = true;
         console.warn("Crop timeout, returning original.");
         resolve(uri);
       }
-    }, 10000);
+    }, 15000);
+
+    (async () => {
+      try {
+        // STEP 1: Normalize EXIF orientation.
+        // This is the core fix — on Android the raw photo pixels may be stored
+        // rotated. After this call, normalizedUri has pixels matching the on-screen
+        // orientation and actualWidth/actualHeight are the display-space dimensions.
+        const { normalizedUri, width: actualWidth, height: actualHeight } =
+          await normalizeOrientationAndGetDimensions(uri);
 
-    try {
-      RNImage.getSize(uri, async (actualWidth, actualHeight) => {
         if (isResolved) return;
 
-        // 1. Detect if bbox is percentage (e.g., 0.15) or absolute pixels (e.g., 800)
-        // Since we pass UI percentages, this will be true.
+        // STEP 2: Resolve bbox to pixel coordinates.
+        // Detect if bbox is percentage (e.g., 0.90) or absolute pixels (e.g., 800).
         const isPercentageBased = bbox.width <= 1.5 && bbox.height <= 1.5;
 
-        let pixelMinX, pixelMinY, pixelWidth, pixelHeight;
+        let pixelMinX: number, pixelMinY: number, pixelWidth: number, pixelHeight: number;
 
         if (isPercentageBased) {
           pixelMinX = bbox.minX * actualWidth;
@@ -153,18 +193,16 @@ export async function cropImageWithBBoxWithTolerance(uri: string, bbox: any, tol
           pixelWidth = bbox.width * actualWidth;
           pixelHeight = bbox.height * actualHeight;
         } else {
-          // Fallback if backend pixels somehow bypass the check
           pixelMinX = bbox.minX;
           pixelMinY = bbox.minY;
           pixelWidth = bbox.width;
           pixelHeight = bbox.height;
         }
 
-        // 2. Add Tolerance (Expands the box slightly to avoid cutting off physical card edges)
+        // STEP 3: Add tolerance and clamp to image bounds.
         const toleranceX = pixelWidth * tolerance;
         const toleranceY = pixelHeight * tolerance;
 
-        // Clamp values to ensure we don't try to crop outside the image bounds
         const newMinX = Math.max(0, pixelMinX - toleranceX);
         const newMinY = Math.max(0, pixelMinY - toleranceY);
         const newMaxX = Math.min(actualWidth, pixelMinX + pixelWidth + toleranceX);
@@ -173,19 +211,18 @@ export async function cropImageWithBBoxWithTolerance(uri: string, bbox: any, tol
         const finalCrop = {
           originX: Math.floor(newMinX),
           originY: Math.floor(newMinY),
-          width: Math.floor(newMaxX - newMinX),
-          height: Math.floor(newMaxY - newMinY),
+          width: Math.max(1, Math.floor(newMaxX - newMinX)),
+          height: Math.max(1, Math.floor(newMaxY - newMinY)),
         };
 
-        // 3. Perform Final Crop
+        // STEP 4: Perform final crop on the already-normalized image.
         try {
-          // @ts-ignore - Required for utility functions outside React components
           const result = await ImageManipulator.manipulateAsync(
-            uri,
+            normalizedUri,
             [{ crop: finalCrop }],
             { compress: 0.95, format: ImageManipulator.SaveFormat.JPEG }
           );
-          
+
           if (!isResolved) {
             isResolved = true;
             clearTimeout(timeout);
@@ -195,23 +232,79 @@ export async function cropImageWithBBoxWithTolerance(uri: string, bbox: any, tol
           if (!isResolved) {
             isResolved = true;
             clearTimeout(timeout);
-            console.error("ImageManipulator failed, returning raw image", err);
-            resolve(uri);
+            console.error("ImageManipulator crop failed, returning normalized image", err);
+
+            resolve(normalizedUri);
           }
         }
-      }, () => {
+      } catch (e) {
         if (!isResolved) {
           isResolved = true;
           clearTimeout(timeout);
+          console.error("normalizeOrientationAndGetDimensions failed, returning original", e);
           resolve(uri);
         }
-      });
-    } catch (e) {
+      }
+    })();
+  });
+}
+
+export async function cropToCenterScanArea(
+  uri: string, 
+  scanWidthRatio: number = 0.91, // Match Kotlin's 0.91f
+  scanAreaAspectRatio: number = 1.59 // Standard ID Card ratio
+): Promise<string> {
+  return new Promise<string>((resolve) => {
+    let isResolved = false;
+
+    const timeout = setTimeout(() => {
       if (!isResolved) {
         isResolved = true;
-        clearTimeout(timeout);
         resolve(uri);
       }
-    }
+    }, 10000);
+
+    (async () => {
+      try {
+        // 1. Use Claude's brilliant EXIF normalization first!
+        const { normalizedUri, width: actualWidth, height: actualHeight } = 
+          await normalizeOrientationAndGetDimensions(uri);
+
+        if (isResolved) return;
+
+        // 2. Apply the Kotlin mathematical centering
+        const scanWidth = actualWidth * scanWidthRatio;
+        const scanHeight = scanWidth / scanAreaAspectRatio;
+        const left = (actualWidth - scanWidth) / 2;
+        const top = (actualHeight - scanHeight) / 2;
+
+        const finalCrop = {
+          originX: Math.max(0, Math.floor(left)),
+          originY: Math.max(0, Math.floor(top)),
+          width: Math.max(1, Math.floor(scanWidth)),
+          height: Math.max(1, Math.floor(scanHeight)),
+        };
+
+        // 3. Perform the final centered crop
+        const result = await ImageManipulator.manipulateAsync(
+          normalizedUri,
+          [{ crop: finalCrop }],
+          { compress: 0.95, format: ImageManipulator.SaveFormat.JPEG }
+        );
+          
+        if (!isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          resolve(result.uri);
+        }
+      } catch (err) {
+        if (!isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          console.error("Center crop failed, returning original", err);
+          resolve(uri); // Fallback to raw image
+        }
+      }
+    })();
   });
 }