@transfergratis/react-native-sdk 0.1.29 → 0.1.31

package/src/modules/api/CardAuthentification.ts

@@ -71,18 +71,47 @@ export async function frontVerification(
             ? detected.card_obb[0] 
             : null;
 
-        // --- STRICT FRAMING CHECK ---
-        if (cardData && typeof cardData.card_in_frame !== 'undefined') {
-            const isCardInFrame = cardData.card_in_frame === true;
-            const hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
-
-            // If it is NOT in the frame, OR if any side is cropped, block progression
-            if (!isCardInFrame || hasCroppedSides) {
-                logger.log(`Framing failed. Cropped sides: ${hasCroppedSides ? cardData.cropped_sides?.join(', ') : 'none'}`);
-                throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        let points = null;
+        let isCardInFrame = true;
+        let hasCroppedSides = false;
+
+        // Extract data safely
+        if (cardData) {
+            points = cardData.obb;
+            if (typeof cardData.card_in_frame !== 'undefined') {
+                isCardInFrame = cardData.card_in_frame === true;
+                hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
             }
         }
 
+        // --- 1. STRICT FRAMING CHECK (MUST HAPPEN FIRST) ---
+        if (!isCardInFrame || hasCroppedSides) {
+            logger.log(`Front Framing failed. Cropped sides detected.`);
+            throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        }
+
+        // --- 2. STRICT DISTANCE CHECK (ONLY RUNS IF FULLY IN FRAME) ---
+        if (points && points.length === 4) {
+            const getDistance = (p1: number[], p2: number[]) => Math.sqrt(Math.pow(p2[0] - p1[0], 2) + Math.pow(p2[1] - p1[1], 2));
+            const longestCardEdge = Math.max(getDistance(points[0], points[1]), getDistance(points[1], points[2]));
+
+            const maxX = Math.max(points[0][0], points[1][0], points[2][0], points[3][0]);
+            const maxY = Math.max(points[0][1], points[1][1], points[2][1], points[3][1]);
+            const estimatedImageScale = Math.max(maxX, maxY);
+
+            const fillPercentage = longestCardEdge / estimatedImageScale;
+            logger.log(`Front Card Fill Percentage: ${(fillPercentage * 100).toFixed(1)}%`);
+
+            if (fillPercentage < 0.50) { 
+                logger.log("🛑 Front Image rejected: Document is too far away.");
+                throw new Error("TOO_FAR_AWAY"); 
+            }
+        }
+
+    
+
+        
+
         // Check Confidence Threshold
         const obbConfidence = getObbConfidence(detected.card_obb);
         if (obbConfidence !== null && obbConfidence < OBB_CONFIDENCE_THRESHOLD) {
@@ -101,7 +130,7 @@ export async function frontVerification(
 
         // MRZ Extraction
         if (result.regionMapping?.authMethod?.length > 0 && result.regionMapping.authMethod.includes('MRZ')) {
-            mrz = await kycService.extractMrzText(
+            const mrzResponse = await kycService.extractMrzText(
                 {
                     fileUri: result.path || '',
                     docType: result?.selectedDocumentType || '',
@@ -113,11 +142,20 @@ export async function frontVerification(
                 },
                 env
             );
+
+            // Safety check: parse if it was returned as a raw string
+            mrz = typeof mrzResponse === 'string' ? JSON.parse(mrzResponse) : mrzResponse;
+
+            if (mrz && (!mrz.success || mrz.parsed_data?.status === 'FAILURE')) {
+                logger.log("🛑 Front MRZ Extraction Failed:", mrz.parsed_data?.status_message);
+                throw new Error(`MRZ illisible: ${mrz.parsed_data?.status_message || 'Veuillez nettoyer l\'objectif et réessayer'}`);
+            }
         }
 
         return { ...detected, croppedBase64, bbox, ...(mrz ? { mrz } : {}) };
     } catch (e: any) {
-        logger.error('Error front verification:', JSON.stringify(errorMessage(e), null, 2));
+        logger.error('Error front verification:', e?.message);
+        // Do not use LogBox for background silent errors
         throw new Error(e?.message || 'Erreur de détection du visage');
     }
 }
@@ -250,7 +288,6 @@ export async function backVerification(
         if (!result.path) throw new Error('No path provided');
         logger.log("result.regionMapping", result.regionMapping, result.currentSide, result.code);
         
-    
         if (env === 'SANDBOX') {
             console.log("SANDBOX mode: Skipping AI verification for back document");
             
@@ -265,27 +302,30 @@ export async function backVerification(
             if (result.regionMapping?.authMethod?.includes('MRZ')) {
                 return {
                     success: true,
-                    parsed_data: {
-                        status: 'success',
-                        document_type: result.selectedDocumentType,
-                        mrz_type: result.mrzType || 'TD1'
+                    mrz: { 
+                        success: true,
+                        parsed_data: {
+                            status: 'SUCCESS', 
+                            document_type: result.selectedDocumentType,
+                            mrz_type: result.mrzType || 'TD1'
+                        }
                     },
                     bbox: mockBbox,
                     card_obb: mockCardObb
                 };
             } else if (result.regionMapping?.authMethod?.includes('2D_barcode')) {
                 return {
-                    barcode_data: 'SANDBOX_MOCK_BARCODE',
+                    success: true,
+                    barcode: { barcode_data: 'SANDBOX_MOCK_BARCODE' },
                     bbox: mockBbox,
                     card_obb: mockCardObb
                 };
             }
-            return { bbox: mockBbox };
+            return { success: true, bbox: mockBbox, card_obb: mockCardObb };
         }
         
         const token = await authentification();
 
-      
         logger.log("1. Checking template and framing for back document...");
         
         const templateResponse = await kycService.checkTemplateType({
@@ -296,18 +336,66 @@ export async function backVerification(
             token: token
         }, env) as ApiVerificationResponse;
 
-        // STRICT FRAMING CHECK
+        if (templateResponse.success === false || templateResponse.Error) {
+            logger.log("Backend returned an error:", templateResponse.Error);
+            throw new Error('Impossible de lire le document. Veuillez vous rapprocher et stabiliser la caméra.');
+        }
+
         const cardData = templateResponse?.card_obb && Array.isArray(templateResponse.card_obb) && templateResponse.card_obb.length > 0 
             ? templateResponse.card_obb[0] 
             : null;
 
-        if (cardData && typeof cardData.card_in_frame !== 'undefined') {
-            const isCardInFrame = cardData.card_in_frame === true;
-            const hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
+        if (!cardData) {
+            throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        }
+
+        let points = null;
+        let isCardInFrame = false; 
+        let hasCroppedSides = true; 
 
-            if (!isCardInFrame || hasCroppedSides) {
-                logger.log(`Back Framing failed. Cropped sides: ${hasCroppedSides ? cardData.cropped_sides?.join(', ') : 'none'}`);
-                throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        // Safely extract coordinates and frame status
+        if (cardData.obb) { 
+            points = cardData.obb;
+            if (typeof cardData.card_in_frame !== 'undefined') {
+                isCardInFrame = cardData.card_in_frame === true;
+                hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
+            }
+        } else if (Array.isArray(cardData) && Array.isArray(cardData[0])) { 
+            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;
+                }
+            }
+        }
+
+        // --- 2. STRICT FRAMING CHECK (MUST HAPPEN FIRST) ---
+        if (!isCardInFrame || hasCroppedSides) {
+            logger.log(`Back Framing failed. Coordinates hit image boundary.`);
+            throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        }
+
+        // --- 3. STRICT DISTANCE CHECK (ONLY RUNS IF FULLY IN FRAME) ---
+        if (points && points.length === 4) {
+            const getDistance = (p1: number[], p2: number[]) => Math.sqrt(Math.pow(p2[0] - p1[0], 2) + Math.pow(p2[1] - p1[1], 2));
+            const longestCardEdge = Math.max(getDistance(points[0], points[1]), getDistance(points[1], points[2]));
+
+            const maxX = Math.max(points[0][0], points[1][0], points[2][0], points[3][0]);
+            const maxY = Math.max(points[0][1], points[1][1], points[2][1], points[3][1]);
+            const estimatedImageScale = Math.max(maxX, maxY);
+
+            const fillPercentage = longestCardEdge / estimatedImageScale;
+            logger.log(`Back Card Fill Percentage: ${(fillPercentage * 100).toFixed(1)}%`);
+
+            if (fillPercentage < 0.50) { 
+                logger.log("🛑 Back Image rejected: Document is too far away.");
+                throw new Error("TOO_FAR_AWAY"); 
             }
         }
         
@@ -316,12 +404,10 @@ export async function backVerification(
             throw new Error('Carte non entièrement visible. Positionnez toute la carte dans le cadre.');
         }
 
-
         const activeTemplatePath = templateResponse.template_path || result.templatePath || '';
         
         if (activeTemplatePath) {
             const expectedCountryName = countryData[result.code]?.name_en || '';
-            
             const hasCodeMatch = activeTemplatePath.includes(`_${result.code}_`);
             const hasNameMatch = expectedCountryName && activeTemplatePath.toLowerCase().includes(expectedCountryName.toLowerCase());
 
@@ -333,88 +419,80 @@ export async function backVerification(
 
         logger.log("Framing and Country Template verified successfully. Proceeding to Data Extraction.");
 
-     
-        const tryMrzWithBarcodeFallback = async () => {
+        const hasMrz = result.regionMapping?.authMethod?.includes('MRZ') || !result.regionMapping?.authMethod?.length;
+        const hasBarcode = result.regionMapping?.authMethod?.includes('2D_barcode');
+
+        let extractionResult: any = {};
+
+        // --- 4. Try MRZ First (If required or default) ---
+        if (hasMrz) {
             try {
                 logger.log("Tentative d'extraction MRZ");
-                const mrz = await kycService.extractMrzText({
+                const mrzResponse = await kycService.extractMrzText({
                     fileUri: result.path!,
                     docType: result?.selectedDocumentType || '',
                     docRegion: result?.code || '',
                     postfix: 'back',
                     token: token,
-                    template_path: activeTemplatePath, // Use the verified template
-                    mrz_type: result?.mrzType || ''
+                    template_path: activeTemplatePath, 
+                    mrz_type: result?.mrzType || '' // Safe to send empty string
                 }, env);
                 
-                let bbox: IBbox | undefined;
-                let croppedBase64: string | undefined;
-
-                try {
-                    // We use the OBB from our template check to ensure clean cropping
-                    const crop = await cropByObb(result?.path || '', templateResponse.card_obb);
-                    bbox = crop.bbox;
-                    croppedBase64 = crop.base64;
-                } catch { }
-                return { ...mrz, bbox, croppedBase64 }
+                const mrz = typeof mrzResponse === 'string' ? JSON.parse(mrzResponse) : mrzResponse;
                 
-            } catch (mrzError: any) {
-                logger.log("MRZ échoué, tentative d'extraction barcode");
-                try {
-                    const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
-                    return barcode;
-                } catch (barcodeError: any) {
-                    throw new Error(`MRZ et barcode ont échoué. MRZ: ${mrzError?.message}, Barcode: ${barcodeError?.message}`);
+                if (!mrz || !mrz.success || mrz.parsed_data?.status === 'FAILURE') {
+                    throw new Error(mrz?.parsed_data?.status_message || 'Lecture MRZ échouée');
                 }
-            }
-        };
-
-        if (result.regionMapping?.authMethod?.length > 2 && (!result?.mrzType || result?.mrzType.length === 0)) {
-            return await tryMrzWithBarcodeFallback();
-        }
-
-        if (result.regionMapping?.authMethod?.length > 0 && result.regionMapping.authMethod.includes('MRZ') && result?.mrzType && result?.mrzType.length > 0) {
-            try {
-                const mrz = await kycService.extractMrzText({
-                    fileUri: result.path!,
-                    docType: result?.selectedDocumentType || '',
-                    docRegion: result?.code || '',
-                    postfix: 'back',
-                    token: token,
-                    template_path: activeTemplatePath,
-                    mrz_type: result?.mrzType || ''
-                }, env);
                 
-                let bbox: IBbox | undefined;
-                try {
-                    const crop = await cropByObb(result?.path || '', templateResponse.card_obb);
-                    bbox = crop.bbox;
-                } catch { }
-                return { ...mrz, bbox };
+                extractionResult = { mrz };
+
             } catch (mrzError: any) {
-                throw new Error(`MRZ et barcode ont échoué. MRZ: ${mrzError?.message}, Barcode: ${mrzError?.message}`);
+                if (hasBarcode) {
+                    logger.log(`MRZ échoué (${mrzError?.message}), tentative d'extraction barcode...`);
+                    try {
+                        const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
+                        extractionResult = { barcode };
+                    } catch (barcodeError: any) {
+                        throw new Error(`MRZ et Barcode ont échoué. Veuillez stabiliser la carte.`);
+                    }
+                } else {
+                    throw new Error(`Lecture MRZ invalide: ${mrzError?.message}`);
+                }
             }
-        }
-
-        if (result.regionMapping?.authMethod?.length > 0 && result.regionMapping.authMethod.includes('2D_barcode')) {
-            try {
-                logger.log("Tentative d'extraction barcode");
+        } 
+        // --- 5. Try Barcode Only ---
+        else if (hasBarcode) {
+             try {
+                logger.log("Tentative d'extraction barcode seule");
                 const barcode = await kycService.extractBarcode({ fileUri: result.path!, token: token }, env);
-                
-                let bbox: IBbox | undefined;
-                try {
-                    const crop = await cropByObb(result?.path || '', templateResponse.card_obb);
-                    bbox = crop.bbox;
-                } catch { }
-                return { ...barcode, bbox };
-            } catch (barcodeError: any) {
-                throw new Error(`Barcode et MRZ ont échoué. Barcode: ${barcodeError?.message}, MRZ: ${barcodeError?.message}`);
-            }
+                extractionResult = { barcode };
+             } catch (e: any) {
+                 throw new Error(`Lecture Barcode échouée: ${e?.message}`);
+             }
         }
-        return null;
+
+        let bbox: IBbox | undefined;
+        let croppedBase64: string | undefined;
+
+        try {
+            const crop = await cropByObb(result?.path || '', templateResponse.card_obb);
+            bbox = crop.bbox;
+            croppedBase64 = crop.base64;
+        } catch { }
+
+        return { 
+            success: true,
+            ...extractionResult, 
+            bbox, 
+            croppedBase64, 
+            card_obb: templateResponse.card_obb 
+        };
+
     } catch (e: any) {
-        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME') throw e; // Bubble the strict framing error specifically
-        throw new Error(e?.message || 'Erreur de détection du MRZ ou barcode');
+        if (e?.message === 'CARD_NOT_FULLY_IN_FRAME' || e?.message === 'TOO_FAR_AWAY') {
+            throw e; 
+        }
+        throw new Error(e?.message || 'Erreur de détection des données');
     }
 }
 
@@ -441,18 +519,52 @@ export async function checkTemplateType(result: { path?: string, docType: string
         const token = await authentification();
         const templateType = await kycService.checkTemplateType({ fileUri: result.path || '', docType: result?.docType as GovernmentDocumentType, docRegion: result?.docRegion || "", postfix: result?.postfix, token: token }, env);
 
+        if (templateType.success === false || templateType.Error) {
+            logger.log("Backend returned an error:", templateType.Error);
+            throw new Error('Impossible de lire le document. Veuillez vous rapprocher et stabiliser la caméra.');
+        }
+
         const cardData = templateType.card_obb && Array.isArray(templateType.card_obb) && templateType.card_obb.length > 0 
             ? templateType.card_obb[0] 
             : null;
 
-        if (cardData && typeof cardData.card_in_frame !== 'undefined') {
-            const isCardInFrame = cardData.card_in_frame === true;
-            const hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
+        if (!cardData) {
+            throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        }
 
-            if (!isCardInFrame || hasCroppedSides) {
-                logger.log(`Template Framing failed. Cropped sides: ${hasCroppedSides ? cardData.cropped_sides?.join(', ') : 'none'}`);
-                throw new Error('CARD_NOT_FULLY_IN_FRAME');
+        // Default to FALSE so it must prove it is in the frame
+        let points = null;
+        let isCardInFrame = false; 
+        let hasCroppedSides = true; 
+
+        // Extract data safely based on API response format
+        if (cardData.obb) { 
+            points = cardData.obb;
+            if (typeof cardData.card_in_frame !== 'undefined') {
+                isCardInFrame = cardData.card_in_frame === true;
+                hasCroppedSides = Array.isArray(cardData.cropped_sides) && cardData.cropped_sides.length > 0;
             }
+        } else if (Array.isArray(cardData) && Array.isArray(cardData[0])) { 
+            points = cardData[0];
+            isCardInFrame = true; // Passed initial existence check
+            hasCroppedSides = false;
+            
+            // MATH FALLBACK: Check if the coordinates are touching the absolute edge of the photo.
+            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 any corner is within 15 pixels of the edge, it is physically cut off!
+                if (minX <= 15 || minY <= 15) {
+                    isCardInFrame = false;
+                    hasCroppedSides = true;
+                }
+            }
+        }
+
+        // --- 3. STRICT FRAMING CHECK (MUST HAPPEN FIRST) ---
+        if (!isCardInFrame || hasCroppedSides) {
+            logger.log(`Template Framing failed. Coordinates hit image boundary.`);
+            throw new Error('CARD_NOT_FULLY_IN_FRAME');
         }
 
       

package/src/modules/api/KYCService.ts

@@ -355,7 +355,18 @@ export class KYCService {
   }
 
   // STEP 3 - MRZ TEXT EXTRACTION
-  async extractMrzText(params: { fileUri: string; docType: string; docRegion: string; postfix?: string; token: string; template_path: string; mrz_type: string }, env: KycEnvironment = 'PRODUCTION'): Promise<any> {
+  async extractMrzText(
+    params: { 
+      fileUri: string; 
+      docType: string; 
+      docRegion: string; 
+      postfix?: string; 
+      token: string; 
+      template_path: string; 
+      mrz_type?: string; 
+    }, 
+    env: KycEnvironment = 'PRODUCTION'
+  ): Promise<any> {
     // SANDBOX mode
     if (env === 'SANDBOX') {
       console.log("SANDBOX mode: Skipping AI MRZ extraction");
@@ -377,29 +388,39 @@ export class KYCService {
     const { fileUri, docType, docRegion, postfix = 'back', token, template_path, mrz_type } = params;
     const formData = new FormData();
     
-    // ✅ FIX: Dynamic filename to prevent passports from crashing (since their MRZ is on the front)
+    // ✅ Dynamic filename to prevent passports from crashing (since their MRZ is on the front)
     await appendFileToFormData(formData, 'file', fileUri, `id_card_${postfix}.jpg`, 'image/jpeg');
 
-    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType];
+    const docTypeShorted = GovernmentDocumentTypeShorted[docType as GovernmentDocumentType] || docType;
     logger.log("docTypeShorted", docTypeShorted, docRegion, postfix);
 
-    const url = `${this.mrzServiceURL}/extract_mrz_text/?doc_type=${docTypeShorted}&doc_region=${docRegion}&postfix=${postfix}&template_path=${template_path}&mrz_type=${mrz_type}`;
+    let url = `${this.mrzServiceURL}/extract_mrz_text/?doc_type=${encodeURIComponent(docTypeShorted)}&doc_region=${encodeURIComponent(docRegion)}&postfix=${encodeURIComponent(postfix)}&template_path=${encodeURIComponent(template_path)}`;
+    
+    if (mrz_type && mrz_type.trim() !== '') {
+        url += `&mrz_type=${encodeURIComponent(mrz_type)}`;
+    }
+    
     logger.log("url", url);
 
     const attempt = async () => {
       try {
         const res = await axios.post<ExtractMrzTextResponse>(url, formData, {
-          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}`, },
-          timeout: 60000,
+          headers: { 'Content-Type': 'multipart/form-data', 'Authorization': `Bearer ${token}` },
+          // Note: Reduced timeout to 10000ms (10s) based on our earlier network fix to prevent infinite hanging!
+          timeout: 10000, 
         });
+        
         logger.log('extractMrzText res', JSON.stringify(res.data, null, 2));
+        
         if (Object.keys(res.data).length === 0) throw new Error('No data found');
-        if (res.data?.success === false) throw new Error(res.data.parsed_data.status);
+        if (res.data?.success === false) throw new Error(res.data.parsed_data?.status || 'Échec de l\'extraction MRZ');
+        
         return res.data;
       } catch (e: any) {
         throw new Error(e?.message || 'Erreur de détection du MRZ');
       }
     };
+
     try {
       return await attempt();
     } catch (e) {