react-native-rectangle-doc-scanner 3.60.0 → 3.62.0

package/dist/DocScanner.js

@@ -88,6 +88,13 @@ exports.DocScanner = (0, react_1.forwardRef)(({ onCapture, overlayColor = DEFAUL
         return Math.min(100, Math.max(0, quality));
     }, [quality]);
     const handlePictureTaken = (0, react_1.useCallback)((event) => {
+        console.log('[DocScanner] handlePictureTaken called with event:', {
+            hasInitialImage: !!event.initialImage,
+            hasCroppedImage: !!event.croppedImage,
+            hasRectangleCoordinates: !!event.rectangleCoordinates,
+            width: event.width,
+            height: event.height,
+        });
         setIsAutoCapturing(false);
         const normalizedRectangle = normalizeRectangle(event.rectangleCoordinates ?? null) ?? lastRectangleRef.current;
         const quad = normalizedRectangle ? (0, coordinate_1.rectangleToQuad)(normalizedRectangle) : null;
@@ -96,7 +103,15 @@ exports.DocScanner = (0, react_1.forwardRef)(({ onCapture, overlayColor = DEFAUL
         const initialPath = event.initialImage ?? null;
         const croppedPath = event.croppedImage ?? null;
         const editablePath = initialPath ?? croppedPath;
+        console.log('[DocScanner] Processing captured image:', {
+            origin,
+            initialPath,
+            croppedPath,
+            editablePath,
+            hasQuad: !!quad,
+        });
         if (editablePath) {
+            console.log('[DocScanner] Calling onCapture callback');
             onCapture?.({
                 path: editablePath,
                 initialPath,
@@ -108,8 +123,12 @@ exports.DocScanner = (0, react_1.forwardRef)(({ onCapture, overlayColor = DEFAUL
                 origin,
             });
         }
+        else {
+            console.warn('[DocScanner] No editable path available, skipping onCapture');
+        }
         setDetectedRectangle(null);
         if (captureResolvers.current) {
+            console.log('[DocScanner] Resolving capture promise');
             captureResolvers.current.resolve(event);
             captureResolvers.current = null;
         }
@@ -121,42 +140,57 @@ exports.DocScanner = (0, react_1.forwardRef)(({ onCapture, overlayColor = DEFAUL
         }
     }, []);
     const capture = (0, react_1.useCallback)(() => {
+        console.log('[DocScanner] capture() called');
         captureOriginRef.current = 'manual';
         const instance = scannerRef.current;
         if (!instance || typeof instance.capture !== 'function') {
+            console.error('[DocScanner] Native instance not ready:', {
+                hasInstance: !!instance,
+                hasCaptureMethod: instance ? typeof instance.capture : 'no instance',
+            });
             captureOriginRef.current = 'auto';
             return Promise.reject(new Error('DocumentScanner native instance is not ready'));
         }
         if (captureResolvers.current) {
+            console.warn('[DocScanner] Capture already in progress');
             captureOriginRef.current = 'auto';
             return Promise.reject(new Error('capture_in_progress'));
         }
+        console.log('[DocScanner] Calling native capture method...');
         let result;
         try {
             result = instance.capture();
+            console.log('[DocScanner] Native capture method called, result type:', typeof result, 'isPromise:', !!(result && typeof result.then === 'function'));
         }
         catch (error) {
+            console.error('[DocScanner] Native capture threw error:', error);
             captureOriginRef.current = 'auto';
             return Promise.reject(error);
         }
         if (result && typeof result.then === 'function') {
+            console.log('[DocScanner] Native returned a promise, waiting for resolution...');
             return result
                 .then((payload) => {
+                console.log('[DocScanner] Native promise resolved with payload:', payload);
                 handlePictureTaken(payload);
                 return payload;
             })
                 .catch((error) => {
+                console.error('[DocScanner] Native promise rejected:', error);
                 captureOriginRef.current = 'auto';
                 throw error;
             });
         }
+        console.log('[DocScanner] Native did not return a promise, using callback-based approach');
         return new Promise((resolve, reject) => {
             captureResolvers.current = {
                 resolve: (value) => {
+                    console.log('[DocScanner] Callback resolver called with:', value);
                     captureOriginRef.current = 'auto';
                     resolve(value);
                 },
                 reject: (reason) => {
+                    console.error('[DocScanner] Callback rejector called with:', reason);
                     captureOriginRef.current = 'auto';
                     reject(reason);
                 },

package/dist/FullDocScanner.js

@@ -83,12 +83,15 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
         try {
             console.log('[FullDocScanner] openCropper called with path:', imagePath);
             setProcessing(true);
-            // Normalize path - ensure file:// prefix for iOS
-            const normalizedPath = imagePath.startsWith('file://') ? imagePath : `file://${imagePath}`;
-            console.log('[FullDocScanner] Normalized path:', normalizedPath);
-            // Add timeout to prevent hanging
-            const cropperPromise = react_native_image_crop_picker_1.default.openCropper({
-                path: normalizedPath,
+            // Clean path - remove file:// prefix for react-native-image-crop-picker
+            // The library handles the prefix internally and double prefixing causes issues
+            let cleanPath = imagePath;
+            if (cleanPath.startsWith('file://')) {
+                cleanPath = cleanPath.replace('file://', '');
+            }
+            console.log('[FullDocScanner] Clean path for cropper:', cleanPath);
+            const croppedImage = await react_native_image_crop_picker_1.default.openCropper({
+                path: cleanPath,
                 mediaType: 'photo',
                 width: cropWidth,
                 height: cropHeight,
@@ -98,10 +101,6 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
                 includeBase64: true,
                 compressImageQuality: 0.9,
             });
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('Cropper timeout after 30 seconds')), 30000);
-            });
-            const croppedImage = await Promise.race([cropperPromise, timeoutPromise]);
             console.log('[FullDocScanner] Cropper returned:', {
                 path: croppedImage.path,
                 hasBase64: !!croppedImage.data,
@@ -134,14 +133,16 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
             croppedPath: document.croppedPath,
             initialPath: document.initialPath,
             captureMode: captureModeRef.current,
+            captureInProgress: captureInProgressRef.current,
         });
-        captureInProgressRef.current = false;
         const captureMode = captureModeRef.current;
+        // Reset capture state
+        captureInProgressRef.current = false;
+        captureModeRef.current = null;
         if (!captureMode) {
             console.warn('[FullDocScanner] Missing capture mode for capture result, ignoring');
             return;
         }
-        captureModeRef.current = null;
         const normalizedDoc = normalizeCapturedDocument(document);
         if (captureMode === 'no-grid') {
             console.log('[FullDocScanner] No grid at capture button press: opening cropper for manual selection');
@@ -184,12 +185,27 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
         const captureMode = rectangleDetected ? 'grid' : 'no-grid';
         captureModeRef.current = captureMode;
         captureInProgressRef.current = true;
+        // Add timeout to reset state if capture hangs
+        const captureTimeout = setTimeout(() => {
+            if (captureInProgressRef.current) {
+                console.error('[FullDocScanner] Capture timeout - resetting state');
+                captureModeRef.current = null;
+                captureInProgressRef.current = false;
+                emitError(new Error('Capture timeout'), 'Capture timed out. Please try again.');
+            }
+        }, 10000);
         scannerInstance.capture()
             .then((result) => {
-            console.log('[FullDocScanner] Manual capture success:', result);
-            captureInProgressRef.current = false;
+            clearTimeout(captureTimeout);
+            console.log('[FullDocScanner] Manual capture promise resolved:', {
+                hasResult: !!result,
+                croppedImage: result?.croppedImage,
+                initialImage: result?.initialImage,
+            });
+            // Note: captureInProgressRef is reset in handleCapture
         })
             .catch((error) => {
+            clearTimeout(captureTimeout);
             const errorMessage = error instanceof Error ? error.message : String(error);
             console.error('[FullDocScanner] Manual capture failed:', errorMessage, error);
             captureModeRef.current = null;
@@ -265,29 +281,33 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
         const stableCounter = event.stableCounter ?? 0;
         const hasRectangle = Boolean(event.rectangleOnScreen ?? event.rectangleCoordinates);
         const isGoodRectangle = hasRectangle && event.lastDetectionType === 0;
-        if (hasRectangle) {
+        // Clear timeout immediately when rectangle is lost
+        if (!hasRectangle || !isGoodRectangle) {
+            if (rectangleTimeoutRef.current) {
+                clearTimeout(rectangleTimeoutRef.current);
+                rectangleTimeoutRef.current = null;
+            }
+            setRectangleDetected(false);
+        }
+        else {
+            // Rectangle detected - clear any existing timeout
             if (rectangleTimeoutRef.current) {
                 clearTimeout(rectangleTimeoutRef.current);
             }
+            setRectangleDetected(true);
+            // Set timeout to clear rectangle after brief period of no updates
             rectangleTimeoutRef.current = setTimeout(() => {
                 rectangleTimeoutRef.current = null;
                 setRectangleDetected(false);
+                console.log('[FullDocScanner] Rectangle timeout - clearing detection');
             }, 300);
         }
-        else if (rectangleTimeoutRef.current) {
-            clearTimeout(rectangleTimeoutRef.current);
-            rectangleTimeoutRef.current = null;
-        }
-        setRectangleDetected((prev) => {
-            if (prev !== isGoodRectangle) {
-                console.log('[FullDocScanner] Rectangle detection update', {
-                    lastDetectionType: event.lastDetectionType,
-                    stableCounter,
-                    hasRectangle,
-                    isGoodRectangle,
-                });
-            }
-            return isGoodRectangle;
+        console.log('[FullDocScanner] Rectangle detection update', {
+            lastDetectionType: event.lastDetectionType,
+            stableCounter,
+            hasRectangle,
+            isGoodRectangle,
+            rectangleDetected: isGoodRectangle,
         });
     }, []);
     (0, react_1.useEffect)(() => () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-rectangle-doc-scanner",
-  "version": "3.60.0",
+  "version": "3.62.0",
   "description": "Native-backed document scanner for React Native with customizable overlays.",
   "license": "MIT",
   "main": "dist/index.js",

package/src/DocScanner.tsx

@@ -150,6 +150,14 @@ export const DocScanner = forwardRef<DocScannerHandle, Props>(
 
     const handlePictureTaken = useCallback(
       (event: PictureEvent) => {
+        console.log('[DocScanner] handlePictureTaken called with event:', {
+          hasInitialImage: !!event.initialImage,
+          hasCroppedImage: !!event.croppedImage,
+          hasRectangleCoordinates: !!event.rectangleCoordinates,
+          width: event.width,
+          height: event.height,
+        });
+
         setIsAutoCapturing(false);
 
         const normalizedRectangle =
@@ -162,7 +170,16 @@ export const DocScanner = forwardRef<DocScannerHandle, Props>(
         const croppedPath = event.croppedImage ?? null;
         const editablePath = initialPath ?? croppedPath;
 
+        console.log('[DocScanner] Processing captured image:', {
+          origin,
+          initialPath,
+          croppedPath,
+          editablePath,
+          hasQuad: !!quad,
+        });
+
         if (editablePath) {
+          console.log('[DocScanner] Calling onCapture callback');
           onCapture?.({
             path: editablePath,
             initialPath,
@@ -173,11 +190,14 @@ export const DocScanner = forwardRef<DocScannerHandle, Props>(
             height: event.height ?? 0,
             origin,
           });
+        } else {
+          console.warn('[DocScanner] No editable path available, skipping onCapture');
         }
 
         setDetectedRectangle(null);
 
         if (captureResolvers.current) {
+          console.log('[DocScanner] Resolving capture promise');
           captureResolvers.current.resolve(event);
           captureResolvers.current = null;
         }
@@ -193,43 +213,61 @@ export const DocScanner = forwardRef<DocScannerHandle, Props>(
     }, []);
 
     const capture = useCallback((): Promise<PictureEvent> => {
+      console.log('[DocScanner] capture() called');
       captureOriginRef.current = 'manual';
       const instance = scannerRef.current;
+
       if (!instance || typeof instance.capture !== 'function') {
+        console.error('[DocScanner] Native instance not ready:', {
+          hasInstance: !!instance,
+          hasCaptureMethod: instance ? typeof instance.capture : 'no instance',
+        });
         captureOriginRef.current = 'auto';
         return Promise.reject(new Error('DocumentScanner native instance is not ready'));
       }
+
       if (captureResolvers.current) {
+        console.warn('[DocScanner] Capture already in progress');
         captureOriginRef.current = 'auto';
         return Promise.reject(new Error('capture_in_progress'));
       }
 
+      console.log('[DocScanner] Calling native capture method...');
       let result: any;
       try {
         result = instance.capture();
+        console.log('[DocScanner] Native capture method called, result type:', typeof result, 'isPromise:', !!(result && typeof result.then === 'function'));
       } catch (error) {
+        console.error('[DocScanner] Native capture threw error:', error);
         captureOriginRef.current = 'auto';
         return Promise.reject(error);
       }
+
       if (result && typeof result.then === 'function') {
+        console.log('[DocScanner] Native returned a promise, waiting for resolution...');
         return result
           .then((payload: PictureEvent) => {
+            console.log('[DocScanner] Native promise resolved with payload:', payload);
             handlePictureTaken(payload);
             return payload;
           })
           .catch((error: unknown) => {
+            console.error('[DocScanner] Native promise rejected:', error);
             captureOriginRef.current = 'auto';
             throw error;
           });
       }
 
+      console.log('[DocScanner] Native did not return a promise, using callback-based approach');
       return new Promise<PictureEvent>((resolve, reject) => {
         captureResolvers.current = {
           resolve: (value) => {
+            console.log('[DocScanner] Callback resolver called with:', value);
             captureOriginRef.current = 'auto';
             resolve(value);
           },
           reject: (reason) => {
+            console.error('[DocScanner] Callback rejector called with:', reason);
             captureOriginRef.current = 'auto';
             reject(reason);
           },

package/src/FullDocScanner.tsx

@@ -122,13 +122,16 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
         console.log('[FullDocScanner] openCropper called with path:', imagePath);
         setProcessing(true);
 
-        // Normalize path - ensure file:// prefix for iOS
-        const normalizedPath = imagePath.startsWith('file://') ? imagePath : `file://${imagePath}`;
-        console.log('[FullDocScanner] Normalized path:', normalizedPath);
+        // Clean path - remove file:// prefix for react-native-image-crop-picker
+        // The library handles the prefix internally and double prefixing causes issues
+        let cleanPath = imagePath;
+        if (cleanPath.startsWith('file://')) {
+          cleanPath = cleanPath.replace('file://', '');
+        }
+        console.log('[FullDocScanner] Clean path for cropper:', cleanPath);
 
-        // Add timeout to prevent hanging
-        const cropperPromise = ImageCropPicker.openCropper({
-          path: normalizedPath,
+        const croppedImage = await ImageCropPicker.openCropper({
+          path: cleanPath,
           mediaType: 'photo',
           width: cropWidth,
           height: cropHeight,
@@ -139,12 +142,6 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
           compressImageQuality: 0.9,
         });
 
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error('Cropper timeout after 30 seconds')), 30000);
-        });
-
-        const croppedImage = await Promise.race([cropperPromise, timeoutPromise]) as any;
-
         console.log('[FullDocScanner] Cropper returned:', {
           path: croppedImage.path,
           hasBase64: !!croppedImage.data,
@@ -186,19 +183,20 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
         croppedPath: document.croppedPath,
         initialPath: document.initialPath,
         captureMode: captureModeRef.current,
+        captureInProgress: captureInProgressRef.current,
       });
 
-      captureInProgressRef.current = false;
-
       const captureMode = captureModeRef.current;
 
+      // Reset capture state
+      captureInProgressRef.current = false;
+      captureModeRef.current = null;
+
       if (!captureMode) {
         console.warn('[FullDocScanner] Missing capture mode for capture result, ignoring');
         return;
       }
 
-      captureModeRef.current = null;
-
       const normalizedDoc = normalizeCapturedDocument(document);
 
       if (captureMode === 'no-grid') {
@@ -253,12 +251,31 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
     captureModeRef.current = captureMode;
     captureInProgressRef.current = true;
 
+    // Add timeout to reset state if capture hangs
+    const captureTimeout = setTimeout(() => {
+      if (captureInProgressRef.current) {
+        console.error('[FullDocScanner] Capture timeout - resetting state');
+        captureModeRef.current = null;
+        captureInProgressRef.current = false;
+        emitError(
+          new Error('Capture timeout'),
+          'Capture timed out. Please try again.',
+        );
+      }
+    }, 10000);
+
     scannerInstance.capture()
       .then((result) => {
-        console.log('[FullDocScanner] Manual capture success:', result);
-        captureInProgressRef.current = false;
+        clearTimeout(captureTimeout);
+        console.log('[FullDocScanner] Manual capture promise resolved:', {
+          hasResult: !!result,
+          croppedImage: result?.croppedImage,
+          initialImage: result?.initialImage,
+        });
+        // Note: captureInProgressRef is reset in handleCapture
       })
       .catch((error: unknown) => {
+        clearTimeout(captureTimeout);
         const errorMessage = error instanceof Error ? error.message : String(error);
         console.error('[FullDocScanner] Manual capture failed:', errorMessage, error);
         captureModeRef.current = null;
@@ -353,29 +370,34 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
     const hasRectangle = Boolean(event.rectangleOnScreen ?? event.rectangleCoordinates);
     const isGoodRectangle = hasRectangle && event.lastDetectionType === 0;
 
-    if (hasRectangle) {
+    // Clear timeout immediately when rectangle is lost
+    if (!hasRectangle || !isGoodRectangle) {
       if (rectangleTimeoutRef.current) {
         clearTimeout(rectangleTimeoutRef.current);
+        rectangleTimeoutRef.current = null;
       }
+      setRectangleDetected(false);
+    } else {
+      // Rectangle detected - clear any existing timeout
+      if (rectangleTimeoutRef.current) {
+        clearTimeout(rectangleTimeoutRef.current);
+      }
+      setRectangleDetected(true);
+
+      // Set timeout to clear rectangle after brief period of no updates
       rectangleTimeoutRef.current = setTimeout(() => {
         rectangleTimeoutRef.current = null;
         setRectangleDetected(false);
+        console.log('[FullDocScanner] Rectangle timeout - clearing detection');
       }, 300);
-    } else if (rectangleTimeoutRef.current) {
-      clearTimeout(rectangleTimeoutRef.current);
-      rectangleTimeoutRef.current = null;
     }
 
-    setRectangleDetected((prev) => {
-      if (prev !== isGoodRectangle) {
-        console.log('[FullDocScanner] Rectangle detection update', {
-          lastDetectionType: event.lastDetectionType,
-          stableCounter,
-          hasRectangle,
-          isGoodRectangle,
-        });
-      }
-      return isGoodRectangle;
+    console.log('[FullDocScanner] Rectangle detection update', {
+      lastDetectionType: event.lastDetectionType,
+      stableCounter,
+      hasRectangle,
+      isGoodRectangle,
+      rectangleDetected: isGoodRectangle,
     });
   }, []);