react-native-rectangle-doc-scanner 3.67.0 → 3.69.0

package/dist/DocScanner.js

@@ -168,46 +168,49 @@ exports.DocScanner = (0, react_1.forwardRef)(({ onCapture, overlayColor = DEFAUL
             captureOriginRef.current = 'auto';
             return Promise.reject(new Error('capture_in_progress'));
         }
-        console.log('[DocScanner] Calling native capture method...');
-        let result;
+        console.log('[DocScanner] Calling native capture method (now returns Promise)...');
         try {
-            result = instance.capture();
+            const result = instance.capture();
             console.log('[DocScanner] Native capture method called, result type:', typeof result, 'isPromise:', !!(result && typeof result.then === 'function'));
+            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:', {
+                        hasCroppedImage: !!payload.croppedImage,
+                        hasInitialImage: !!payload.initialImage,
+                    });
+                    handlePictureTaken(payload);
+                    return payload;
+                })
+                    .catch((error) => {
+                    console.error('[DocScanner] Native promise rejected:', error);
+                    captureOriginRef.current = 'auto';
+                    throw error;
+                });
+            }
+            // Fallback for legacy event-based approach
+            console.warn('[DocScanner] Native did not return a promise, using callback-based approach (legacy)');
+            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);
+                    },
+                };
+            });
         }
         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);
-                },
-            };
-        });
     }, [handlePictureTaken]);
     const handleManualCapture = (0, react_1.useCallback)(() => {
         captureOriginRef.current = 'manual';

package/dist/FullDocScanner.js

@@ -279,35 +279,44 @@ const FullDocScanner = ({ onResult, onClose, detectionConfig, overlayColor = '#3
     }, []);
     const handleRectangleDetect = (0, react_1.useCallback)((event) => {
         const stableCounter = event.stableCounter ?? 0;
-        const hasRectangle = Boolean(event.rectangleOnScreen ?? event.rectangleCoordinates);
-        const isGoodRectangle = hasRectangle && event.lastDetectionType === 0;
-        // Clear timeout immediately when rectangle is lost
-        if (!hasRectangle || !isGoodRectangle) {
+        const rectangleCoordinates = event.rectangleOnScreen ?? event.rectangleCoordinates;
+        const hasRectangle = Boolean(rectangleCoordinates);
+        const isConfidentRectangle = hasRectangle && (event.lastDetectionType === 0 || stableCounter > 0);
+        const scheduleDetectionClear = () => {
             if (rectangleTimeoutRef.current) {
                 clearTimeout(rectangleTimeoutRef.current);
-                rectangleTimeoutRef.current = null;
             }
-            setRectangleDetected(false);
+            rectangleTimeoutRef.current = setTimeout(() => {
+                rectangleTimeoutRef.current = null;
+                setRectangleDetected((prev) => {
+                    if (!prev) {
+                        return prev;
+                    }
+                    console.log('[FullDocScanner] Rectangle timeout - clearing detection');
+                    return false;
+                });
+            }, 350);
+        };
+        if (isConfidentRectangle) {
+            scheduleDetectionClear();
+            setRectangleDetected((prev) => (prev ? prev : true));
         }
-        else {
-            // Rectangle detected - clear any existing timeout
+        else if (!hasRectangle) {
             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);
+            }
+            setRectangleDetected(false);
+        }
+        else {
+            // Rectangle is present but confidence is low – keep current state but schedule a clear
+            scheduleDetectionClear();
         }
         console.log('[FullDocScanner] Rectangle detection update', {
             lastDetectionType: event.lastDetectionType,
             stableCounter,
             hasRectangle,
-            isGoodRectangle,
-            rectangleDetected: isGoodRectangle,
+            isConfidentRectangle,
         });
     }, []);
     (0, react_1.useEffect)(() => () => {

package/package.json

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

package/src/DocScanner.tsx

@@ -247,47 +247,50 @@ export const DocScanner = forwardRef<DocScannerHandle, Props>(
         return Promise.reject(new Error('capture_in_progress'));
       }
 
-      console.log('[DocScanner] Calling native capture method...');
-      let result: any;
+      console.log('[DocScanner] Calling native capture method (now returns Promise)...');
       try {
-        result = instance.capture();
+        const result = instance.capture();
         console.log('[DocScanner] Native capture method called, result type:', typeof result, 'isPromise:', !!(result && typeof result.then === 'function'));
+
+        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:', {
+                hasCroppedImage: !!payload.croppedImage,
+                hasInitialImage: !!payload.initialImage,
+              });
+              handlePictureTaken(payload);
+              return payload;
+            })
+            .catch((error: unknown) => {
+              console.error('[DocScanner] Native promise rejected:', error);
+              captureOriginRef.current = 'auto';
+              throw error;
+            });
+        }
+
+        // Fallback for legacy event-based approach
+        console.warn('[DocScanner] Native did not return a promise, using callback-based approach (legacy)');
+        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);
+            },
+          };
+        });
       } 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);
-          },
-        };
-      });
     }, [handlePictureTaken]);
 
     const handleManualCapture = useCallback(() => {

package/src/FullDocScanner.tsx

@@ -367,37 +367,46 @@ export const FullDocScanner: React.FC<FullDocScannerProps> = ({
 
   const handleRectangleDetect = useCallback((event: RectangleDetectEvent) => {
     const stableCounter = event.stableCounter ?? 0;
-    const hasRectangle = Boolean(event.rectangleOnScreen ?? event.rectangleCoordinates);
-    const isGoodRectangle = hasRectangle && event.lastDetectionType === 0;
+    const rectangleCoordinates = event.rectangleOnScreen ?? event.rectangleCoordinates;
+    const hasRectangle = Boolean(rectangleCoordinates);
+    const isConfidentRectangle = hasRectangle && (event.lastDetectionType === 0 || stableCounter > 0);
 
-    // Clear timeout immediately when rectangle is lost
-    if (!hasRectangle || !isGoodRectangle) {
+    const scheduleDetectionClear = () => {
       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);
+        setRectangleDetected((prev) => {
+          if (!prev) {
+            return prev;
+          }
+          console.log('[FullDocScanner] Rectangle timeout - clearing detection');
+          return false;
+        });
+      }, 350);
+    };
+
+    if (isConfidentRectangle) {
+      scheduleDetectionClear();
+      setRectangleDetected((prev) => (prev ? prev : true));
+    } else if (!hasRectangle) {
+      if (rectangleTimeoutRef.current) {
+        clearTimeout(rectangleTimeoutRef.current);
+        rectangleTimeoutRef.current = null;
+      }
+      setRectangleDetected(false);
+    } else {
+      // Rectangle is present but confidence is low – keep current state but schedule a clear
+      scheduleDetectionClear();
     }
 
     console.log('[FullDocScanner] Rectangle detection update', {
       lastDetectionType: event.lastDetectionType,
       stableCounter,
       hasRectangle,
-      isGoodRectangle,
-      rectangleDetected: isGoodRectangle,
+      isConfidentRectangle,
     });
   }, []);
 

package/vendor/react-native-document-scanner/ios/DocumentScannerView.h

@@ -1,5 +1,6 @@
 #import "IPDFCameraViewController.h"
 #import <React/RCTViewManager.h>
+#import <React/RCTBridgeModule.h>
 
 @interface DocumentScannerView : IPDFCameraViewController <IPDFCameraViewControllerDelegate>
 
@@ -14,5 +15,6 @@
 @property (nonatomic, assign) BOOL manualOnly;
 
 - (void) capture;
+- (void) captureWithResolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject;
 
 @end

package/vendor/react-native-document-scanner/ios/DocumentScannerView.m

@@ -124,6 +124,87 @@
     self.onRectangleDetect(payload);
 }
 
+// Helper method to process captured images and prepare response data
+- (NSDictionary *)processAndPrepareImageData:(UIImage *)croppedImage
+                                 initialImage:(UIImage *)initialImage
+                             rectangleFeature:(CIRectangleFeature *)rectangleFeature {
+    CGFloat imageQuality = MAX(self.quality, 0.95);
+    NSData *croppedImageData = UIImageJPEGRepresentation(croppedImage, imageQuality);
+
+    if (initialImage.imageOrientation != UIImageOrientationUp) {
+        UIGraphicsBeginImageContextWithOptions(initialImage.size, false, initialImage.scale);
+        [initialImage drawInRect:CGRectMake(0, 0, initialImage.size.width, initialImage.size.height)];
+        initialImage = UIGraphicsGetImageFromCurrentImageContext();
+        UIGraphicsEndImageContext();
+    }
+    NSData *initialImageData = UIImageJPEGRepresentation(initialImage, imageQuality);
+
+    NSDictionary *rectangleCoordinatesDict = [self dictionaryForRectangleFeature:rectangleFeature];
+    id rectangleCoordinates = rectangleCoordinatesDict ? rectangleCoordinatesDict : [NSNull null];
+
+    if (self.useBase64) {
+        return @{
+            @"croppedImage": [croppedImageData base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength],
+            @"initialImage": [initialImageData base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength],
+            @"rectangleCoordinates": rectangleCoordinates
+        };
+    } else {
+        NSString *dir = NSTemporaryDirectory();
+        if (self.saveInAppDocument) {
+            dir = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
+        }
+        NSString *croppedFilePath = [dir stringByAppendingPathComponent:[NSString stringWithFormat:@"cropped_img_%i.jpeg",(int)[NSDate date].timeIntervalSince1970]];
+        NSString *initialFilePath = [dir stringByAppendingPathComponent:[NSString stringWithFormat:@"initial_img_%i.jpeg",(int)[NSDate date].timeIntervalSince1970]];
+
+        [croppedImageData writeToFile:croppedFilePath atomically:YES];
+        [initialImageData writeToFile:initialFilePath atomically:YES];
+
+        return @{
+            @"croppedImage": croppedFilePath,
+            @"initialImage": initialFilePath,
+            @"rectangleCoordinates": rectangleCoordinates
+        };
+    }
+}
+
+// Promise-based capture method - NEW
+- (void)captureWithResolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject {
+    NSLog(@"[DocumentScanner] captureWithResolver called");
+
+    [self captureImageWithCompletionHander:^(UIImage *croppedImage, UIImage *initialImage, CIRectangleFeature *rectangleFeature) {
+        NSLog(@"[DocumentScanner] captureImageWithCompletionHander callback - croppedImage: %@, initialImage: %@", croppedImage ? @"YES" : @"NO", initialImage ? @"YES" : @"NO");
+
+        if (!croppedImage && initialImage) {
+            croppedImage = initialImage;
+        } else if (!initialImage && croppedImage) {
+            initialImage = croppedImage;
+        }
+
+        if (!croppedImage || !initialImage) {
+            NSLog(@"[DocumentScanner] capture failed - missing image data");
+            reject(@"CAPTURE_FAILED", @"Failed to capture image", nil);
+
+            if (!self.captureMultiple) {
+                [self stop];
+            }
+            return;
+        }
+
+        NSLog(@"[DocumentScanner] Processing captured images");
+        NSDictionary *result = [self processAndPrepareImageData:croppedImage
+                                                    initialImage:initialImage
+                                                rectangleFeature:rectangleFeature];
+
+        NSLog(@"[DocumentScanner] Resolving promise with result");
+        resolve(result);
+
+        if (!self.captureMultiple) {
+            [self stop];
+        }
+    }];
+}
+
+// Event-based capture method - LEGACY (for backwards compatibility)
 - (void) capture {
     NSLog(@"[DocumentScanner] capture called");
     [self captureImageWithCompletionHander:^(UIImage *croppedImage, UIImage *initialImage, CIRectangleFeature *rectangleFeature) {
@@ -151,49 +232,10 @@
 
       if (self.onPictureTaken) {
             NSLog(@"[DocumentScanner] Calling onPictureTaken");
-            // Use maximum JPEG quality (1.0) or user's quality setting, whichever is higher
-            // This ensures no quality loss during compression
-            CGFloat imageQuality = MAX(self.quality, 0.95);
-            NSData *croppedImageData = UIImageJPEGRepresentation(croppedImage, imageQuality);
-
-            if (initialImage.imageOrientation != UIImageOrientationUp) {
-                UIGraphicsBeginImageContextWithOptions(initialImage.size, false, initialImage.scale);
-                [initialImage drawInRect:CGRectMake(0, 0, initialImage.size.width
-                                                    , initialImage.size.height)];
-                initialImage = UIGraphicsGetImageFromCurrentImageContext();
-                UIGraphicsEndImageContext();
-            }
-            NSData *initialImageData = UIImageJPEGRepresentation(initialImage, imageQuality);
-
-            /*
-             RectangleCoordinates expects a rectanle viewed from portrait,
-             while rectangleFeature returns a rectangle viewed from landscape, which explains the nonsense of the mapping below.
-             Sorry about that.
-             */
-            NSDictionary *rectangleCoordinatesDict = [self dictionaryForRectangleFeature:rectangleFeature];
-            id rectangleCoordinates = rectangleCoordinatesDict ? rectangleCoordinatesDict : [NSNull null];
-            if (self.useBase64) {
-              self.onPictureTaken(@{
-                                    @"croppedImage": [croppedImageData base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength],
-                                    @"initialImage": [initialImageData base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength],
-                                    @"rectangleCoordinates": rectangleCoordinates });
-            }
-            else {
-                NSString *dir = NSTemporaryDirectory();
-                if (self.saveInAppDocument) {
-                    dir = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
-                }
-               NSString *croppedFilePath = [dir stringByAppendingPathComponent:[NSString stringWithFormat:@"cropped_img_%i.jpeg",(int)[NSDate date].timeIntervalSince1970]];
-               NSString *initialFilePath = [dir stringByAppendingPathComponent:[NSString stringWithFormat:@"initial_img_%i.jpeg",(int)[NSDate date].timeIntervalSince1970]];
-
-              [croppedImageData writeToFile:croppedFilePath atomically:YES];
-              [initialImageData writeToFile:initialFilePath atomically:YES];
-
-               self.onPictureTaken(@{
-                                     @"croppedImage": croppedFilePath,
-                                     @"initialImage": initialFilePath,
-                                     @"rectangleCoordinates": rectangleCoordinates });
-            }
+            NSDictionary *result = [self processAndPrepareImageData:croppedImage
+                                                        initialImage:initialImage
+                                                    rectangleFeature:rectangleFeature];
+            self.onPictureTaken(result);
         }
 
         if (!self.captureMultiple) {

package/vendor/react-native-document-scanner/ios/IPDFCameraViewController.m

@@ -34,7 +34,6 @@ static inline void dispatch_async_main_queue(dispatch_block_t block)
 @property (nonatomic,strong) AVCaptureDevice *captureDevice;
 @property (nonatomic,strong) EAGLContext *context;
 
-@property (nonatomic, strong) AVCapturePhotoOutput* photoOutput;
 @property (nonatomic, strong) AVCaptureStillImageOutput* stillImageOutput; // Kept for backward compatibility
 
 @property (nonatomic, assign) BOOL forceStop;
@@ -192,29 +191,14 @@ static inline void dispatch_async_main_queue(dispatch_block_t block)
     [dataOutput setSampleBufferDelegate:self queue:dispatch_get_main_queue()];
     [session addOutput:dataOutput];
 
-    // Use modern AVCapturePhotoOutput for iOS 10+
-    if (@available(iOS 10.0, *)) {
-        self.photoOutput = [[AVCapturePhotoOutput alloc] init];
-        if ([session canAddOutput:self.photoOutput]) {
-            [session addOutput:self.photoOutput];
-            NSLog(@"[IPDFCamera] Using AVCapturePhotoOutput (modern API)");
-        } else {
-            NSLog(@"[IPDFCamera] WARNING: Cannot add AVCapturePhotoOutput, falling back to AVCaptureStillImageOutput");
-            self.photoOutput = nil;
-            // Fallback to legacy API
-            self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
-            if ([session canAddOutput:self.stillImageOutput]) {
-                [session addOutput:self.stillImageOutput];
-                NSLog(@"[IPDFCamera] Fallback successful: Using AVCaptureStillImageOutput");
-            } else {
-                NSLog(@"[IPDFCamera] CRITICAL ERROR: Cannot add any capture output!");
-            }
-        }
-    } else {
-        // Fallback for older iOS versions (< iOS 10)
-        self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
+    // Use legacy AVCaptureStillImageOutput for reliable manual captures on all supported iOS versions
+    self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
+    if ([session canAddOutput:self.stillImageOutput]) {
         [session addOutput:self.stillImageOutput];
-        NSLog(@"[IPDFCamera] Using AVCaptureStillImageOutput (legacy API)");
+        NSLog(@"[IPDFCamera] Using AVCaptureStillImageOutput (manual capture)");
+    } else {
+        NSLog(@"[IPDFCamera] CRITICAL ERROR: Cannot add AVCaptureStillImageOutput to session");
+        self.stillImageOutput = nil;
     }
 
     AVCaptureConnection *connection = [dataOutput.connections firstObject];
@@ -520,122 +504,49 @@ static inline void dispatch_async_main_queue(dispatch_block_t block)
     // Store completion handler for delegate callback
     self.captureCompletionHandler = completionHandler;
 
-    // Use modern AVCapturePhotoOutput API (iOS 10+)
-    if (@available(iOS 10.0, *)) {
-        if (self.photoOutput) {
-            NSLog(@"[IPDFCameraViewController] Using AVCapturePhotoOutput to capture");
-            AVCapturePhotoSettings *settings = [AVCapturePhotoSettings photoSettings];
-            [self.photoOutput capturePhotoWithSettings:settings delegate:self];
-            return;
-        }
-
-        NSLog(@"[IPDFCameraViewController] photoOutput is nil, trying fallback to stillImageOutput");
-        // Fallback to legacy API if photoOutput is not available
+    if (!self.stillImageOutput) {
+        NSLog(@"[IPDFCameraViewController] ERROR: stillImageOutput is nil");
+        NSError *error = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                             code:-201
+                                         userInfo:@{ NSLocalizedDescriptionKey: @"missing_still_image_output" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
+        return;
     }
 
-    // Fallback: Use legacy AVCaptureStillImageOutput (iOS < 10 or when photoOutput failed)
+    AVCaptureConnection *videoConnection = nil;
+    for (AVCaptureConnection *connection in self.stillImageOutput.connections)
     {
-        if (!self.stillImageOutput) {
-            NSLog(@"[IPDFCameraViewController] ERROR: stillImageOutput is nil");
-            NSError *error = [NSError errorWithDomain:@"IPDFCameraViewController"
-                                                 code:-201
-                                             userInfo:@{ NSLocalizedDescriptionKey: @"missing_still_image_output" }];
-            [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
-            return;
-        }
-
-        AVCaptureConnection *videoConnection = nil;
-        for (AVCaptureConnection *connection in self.stillImageOutput.connections)
+        for (AVCaptureInputPort *port in [connection inputPorts])
         {
-            for (AVCaptureInputPort *port in [connection inputPorts])
+            if ([[port mediaType] isEqual:AVMediaTypeVideo] )
             {
-                if ([[port mediaType] isEqual:AVMediaTypeVideo] )
-                {
-                    videoConnection = connection;
-                    break;
-                }
+                videoConnection = connection;
+                break;
             }
-            if (videoConnection) break;
-        }
-
-        if (!videoConnection) {
-            NSLog(@"[IPDFCameraViewController] ERROR: No video connection found");
-            NSError *error = [NSError errorWithDomain:@"IPDFCameraViewController"
-                                                 code:-202
-                                             userInfo:@{ NSLocalizedDescriptionKey: @"no_video_connection" }];
-            [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
-            return;
         }
-
-        NSLog(@"[IPDFCameraViewController] Using AVCaptureStillImageOutput (legacy)");
-        [self.stillImageOutput captureStillImageAsynchronouslyFromConnection:videoConnection completionHandler: ^(CMSampleBufferRef imageSampleBuffer, NSError *error)
-        {
-            [weakSelf handleCapturedImageData:imageSampleBuffer error:error];
-        }];
-    }
-}
-
-// AVCapturePhotoCaptureDelegate method for iOS 11+
-- (void)captureOutput:(AVCapturePhotoOutput *)output didFinishProcessingPhoto:(AVCapturePhoto *)photo error:(NSError *)error API_AVAILABLE(ios(11.0)) {
-    NSLog(@"[IPDFCameraViewController] didFinishProcessingPhoto called, error=%@", error);
-
-    if (error) {
-        NSLog(@"[IPDFCameraViewController] ERROR in didFinishProcessingPhoto: %@", error);
-        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
-        return;
-    }
-
-    // iOS 11+ uses fileDataRepresentation
-    NSData *imageData = [photo fileDataRepresentation];
-    if (!imageData) {
-        NSLog(@"[IPDFCameraViewController] ERROR: Failed to get image data from photo");
-        NSError *dataError = [NSError errorWithDomain:@"IPDFCameraViewController"
-                                                code:-203
-                                            userInfo:@{ NSLocalizedDescriptionKey: @"no_image_data_from_photo" }];
-        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:dataError];
-        return;
+        if (videoConnection) break;
     }
 
-    NSLog(@"[IPDFCameraViewController] Got image data from AVCapturePhoto, size: %lu bytes", (unsigned long)imageData.length);
-    [self processImageData:imageData];
-}
-
-// AVCapturePhotoCaptureDelegate method for iOS 10
-- (void)captureOutput:(AVCapturePhotoOutput *)output didFinishProcessingPhotoSampleBuffer:(CMSampleBufferRef)photoSampleBuffer previewPhotoSampleBuffer:(CMSampleBufferRef)previewPhotoSampleBuffer resolvedSettings:(AVCaptureResolvedPhotoSettings *)resolvedSettings bracketSettings:(AVCaptureBracketedStillImageSettings *)bracketSettings error:(NSError *)error API_DEPRECATED("Use -captureOutput:didFinishProcessingPhoto:error: instead.", ios(10.0, 11.0)) {
-    NSLog(@"[IPDFCameraViewController] didFinishProcessingPhotoSampleBuffer called (iOS 10)");
-
-    if (error) {
-        NSLog(@"[IPDFCameraViewController] ERROR in didFinishProcessingPhotoSampleBuffer: %@", error);
+    if (!videoConnection) {
+        NSLog(@"[IPDFCameraViewController] ERROR: No video connection found");
+        NSError *error = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                             code:-202
+                                         userInfo:@{ NSLocalizedDescriptionKey: @"no_video_connection" }];
         [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
         return;
     }
 
-    if (!photoSampleBuffer) {
-        NSLog(@"[IPDFCameraViewController] ERROR: photoSampleBuffer is nil");
-        NSError *bufferError = [NSError errorWithDomain:@"IPDFCameraViewController"
-                                                  code:-204
-                                              userInfo:@{ NSLocalizedDescriptionKey: @"photo_sample_buffer_nil" }];
-        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:bufferError];
-        return;
-    }
-
-    // iOS 10: Use AVCapturePhotoOutput's method for converting sample buffer
-    NSData *imageData = [AVCapturePhotoOutput JPEGPhotoDataRepresentationForJPEGSampleBuffer:photoSampleBuffer previewPhotoSampleBuffer:previewPhotoSampleBuffer];
-
-    if (!imageData) {
-        NSLog(@"[IPDFCameraViewController] ERROR: Failed to create JPEG data from photo sample buffer");
-        NSError *dataError = [NSError errorWithDomain:@"IPDFCameraViewController"
-                                                code:-205
-                                            userInfo:@{ NSLocalizedDescriptionKey: @"jpeg_conversion_failed" }];
-        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:dataError];
-        return;
+    if (videoConnection.isVideoOrientationSupported) {
+        videoConnection.videoOrientation = AVCaptureVideoOrientationPortrait;
     }
 
-    NSLog(@"[IPDFCameraViewController] Got image data from photo sample buffer (iOS 10), size: %lu bytes", (unsigned long)imageData.length);
-    [self processImageData:imageData];
+    NSLog(@"[IPDFCameraViewController] Capturing image via AVCaptureStillImageOutput");
+    [self.stillImageOutput captureStillImageAsynchronouslyFromConnection:videoConnection completionHandler:^(CMSampleBufferRef imageSampleBuffer, NSError *error) {
+        [weakSelf handleCapturedImageData:imageSampleBuffer error:error];
+    }];
 }
 
-// Helper method for legacy AVCaptureStillImageOutput (iOS < 10)
+// Helper method for legacy AVCaptureStillImageOutput
 - (void)handleCapturedImageData:(CMSampleBufferRef)sampleBuffer error:(NSError *)error {
     NSLog(@"[IPDFCameraViewController] handleCapturedImageData called (legacy), error=%@, buffer=%@", error, sampleBuffer ? @"YES" : @"NO");
 

package/vendor/react-native-document-scanner/ios/RNPdfScannerManager.m

@@ -34,21 +34,28 @@ RCT_EXPORT_VIEW_PROPERTY(quality, float)
 RCT_EXPORT_VIEW_PROPERTY(brightness, float)
 RCT_EXPORT_VIEW_PROPERTY(contrast, float)
 
-// Main capture method - uses the last created scanner view
-RCT_EXPORT_METHOD(capture:(nullable NSNumber *)reactTag) {
+// Main capture method - returns a Promise
+RCT_EXPORT_METHOD(capture:(nullable id)reactTag
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
     NSLog(@"[RNPdfScannerManager] capture called with reactTag: %@", reactTag);
     dispatch_async(dispatch_get_main_queue(), ^{
         DocumentScannerView *targetView = nil;
+        NSNumber *resolvedTag = ([reactTag isKindOfClass:[NSNumber class]]) ? (NSNumber *)reactTag : nil;
 
-        if (reactTag) {
-            UIView *view = [self.bridge.uiManager viewForReactTag:reactTag];
+        if (!resolvedTag && reactTag) {
+            NSLog(@"[RNPdfScannerManager] Unexpected reactTag type %@ - falling back to last known view", NSStringFromClass([reactTag class]));
+        }
+
+        if (resolvedTag) {
+            UIView *view = [self.bridge.uiManager viewForReactTag:resolvedTag];
             if ([view isKindOfClass:[DocumentScannerView class]]) {
                 targetView = (DocumentScannerView *)view;
                 self->_scannerView = targetView;
             } else if (view) {
-                NSLog(@"[RNPdfScannerManager] View for tag %@ is not DocumentScannerView: %@", reactTag, NSStringFromClass(view.class));
+                NSLog(@"[RNPdfScannerManager] View for tag %@ is not DocumentScannerView: %@", resolvedTag, NSStringFromClass(view.class));
             } else {
-                NSLog(@"[RNPdfScannerManager] No view found for tag %@", reactTag);
+                NSLog(@"[RNPdfScannerManager] No view found for tag %@", resolvedTag);
             }
         }
 
@@ -59,11 +66,12 @@ RCT_EXPORT_METHOD(capture:(nullable NSNumber *)reactTag) {
 
         if (!targetView) {
             NSLog(@"[RNPdfScannerManager] ERROR: No scanner view available for capture");
+            reject(@"NO_VIEW", @"No scanner view available for capture", nil);
             return;
         }
 
         NSLog(@"[RNPdfScannerManager] Calling capture on view: %@", targetView);
-        [targetView capture];
+        [targetView captureWithResolver:resolve rejecter:reject];
     });
 }
 

package/vendor/react-native-document-scanner/ios.js

@@ -30,13 +30,15 @@ class PdfScanner extends React.Component {
     console.log('[PdfScanner/ios.js] capture called, ref:', this.scannerRef.current);
     const handle = findNodeHandle(this.scannerRef.current);
     console.log('[PdfScanner/ios.js] node handle (reactTag):', handle);
-    if (handle) {
-      // Call native method with reactTag
-      return NativeModules.RNPdfScannerManager.capture(handle);
+
+    if (!handle) {
+      console.error('[PdfScanner/ios.js] ERROR: No handle found for scanner ref');
+      return Promise.reject(new Error('No handle found for scanner view'));
     }
-    // Fallback to old method
-    console.log('[PdfScanner/ios.js] No handle, using fallback');
-    return NativeModules.RNPdfScannerManager.captureGlobal();
+
+    // Call native method with reactTag - now returns a Promise
+    console.log('[PdfScanner/ios.js] Calling native capture with handle:', handle);
+    return NativeModules.RNPdfScannerManager.capture(handle);
   }
 
   render() {