react-native-rectangle-doc-scanner 3.66.0 → 3.68.0

package/dist/DocScanner.js

@@ -88,6 +88,18 @@ 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) => {
+        const captureError = event?.error;
+        if (captureError) {
+            console.error('[DocScanner] Native capture error received:', captureError);
+            captureOriginRef.current = 'auto';
+            setIsAutoCapturing(false);
+            setDetectedRectangle(null);
+            if (captureResolvers.current) {
+                captureResolvers.current.reject(new Error(String(captureError)));
+                captureResolvers.current = null;
+            }
+            return;
+        }
         console.log('[DocScanner] handlePictureTaken called with event:', {
             hasInitialImage: !!event.initialImage,
             hasCroppedImage: !!event.croppedImage,
@@ -156,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-rectangle-doc-scanner",
-  "version": "3.66.0",
+  "version": "3.68.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,21 @@ export const DocScanner = forwardRef<DocScannerHandle, Props>(
 
     const handlePictureTaken = useCallback(
       (event: PictureEvent) => {
+        const captureError = (event as any)?.error;
+        if (captureError) {
+          console.error('[DocScanner] Native capture error received:', captureError);
+          captureOriginRef.current = 'auto';
+          setIsAutoCapturing(false);
+          setDetectedRectangle(null);
+
+          if (captureResolvers.current) {
+            captureResolvers.current.reject(new Error(String(captureError)));
+            captureResolvers.current = null;
+          }
+
+          return;
+        }
+
         console.log('[DocScanner] handlePictureTaken called with event:', {
           hasInitialImage: !!event.initialImage,
           hasCroppedImage: !!event.croppedImage,
@@ -232,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/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,55 +124,118 @@
     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) {
-      NSLog(@"[DocumentScanner] captureImageWithCompletionHander callback - croppedImage: %@, initialImage: %@", croppedImage ? @"YES" : @"NO", initialImage ? @"YES" : @"NO");
+    NSLog(@"[DocumentScanner] captureImageWithCompletionHander callback - croppedImage: %@, initialImage: %@", croppedImage ? @"YES" : @"NO", initialImage ? @"YES" : @"NO");
+
+      if (!croppedImage && initialImage) {
+        // Use initial image when cropping is not available
+        croppedImage = initialImage;
+      } else if (!initialImage && croppedImage) {
+        // Mirror cropped image so downstream logic continues to work
+        initialImage = croppedImage;
+      }
+
+      if (!croppedImage || !initialImage) {
+        NSLog(@"[DocumentScanner] capture failed - missing image data");
+        if (self.onPictureTaken) {
+          self.onPictureTaken(@{ @"error": @"capture_failed" });
+        }
+
+        if (!self.captureMultiple) {
+          [self stop];
+        }
+        return;
+      }
+
       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

@@ -15,13 +15,25 @@
 #import <ImageIO/ImageIO.h>
 #import <GLKit/GLKit.h>
 
+static inline void dispatch_async_main_queue(dispatch_block_t block)
+{
+    if (!block) {
+        return;
+    }
+
+    if ([NSThread isMainThread]) {
+        block();
+    } else {
+        dispatch_async(dispatch_get_main_queue(), block);
+    }
+}
+
 @interface IPDFCameraViewController () <AVCaptureVideoDataOutputSampleBufferDelegate, AVCapturePhotoCaptureDelegate>
 
 @property (nonatomic,strong) AVCaptureSession *captureSession;
 @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;
@@ -47,6 +59,39 @@
     BOOL _isCapturing;
 }
 
+- (void)completeCaptureWithCroppedImage:(UIImage *)croppedImage
+                            initialImage:(UIImage *)initialImage
+                               rectangle:(CIRectangleFeature *)rectangleFeature
+                                   error:(NSError *)error
+{
+    void (^completionHandler)(UIImage *, UIImage *, CIRectangleFeature *) = self.captureCompletionHandler;
+
+    dispatch_async_main_queue(^{
+        if (error) {
+            NSLog(@"[IPDFCameraViewController] Completing capture with error: %@", error.localizedDescription);
+            if (completionHandler) {
+                completionHandler(nil, nil, nil);
+            }
+        } else {
+            UIImage *resolvedInitial = initialImage ?: croppedImage;
+            UIImage *resolvedCropped = croppedImage ?: resolvedInitial;
+
+            if (!resolvedInitial || !resolvedCropped) {
+                NSLog(@"[IPDFCameraViewController] Missing images during completion, sending failure to JS");
+                if (completionHandler) {
+                    completionHandler(nil, nil, nil);
+                }
+            } else if (completionHandler) {
+                completionHandler(resolvedCropped, resolvedInitial, rectangleFeature);
+            }
+        }
+
+        self.captureCompletionHandler = nil;
+        self->_isCapturing = NO;
+        [self hideGLKView:NO completion:nil];
+    });
+}
+
 - (void)awakeFromNib
 {
     [super awakeFromNib];
@@ -146,29 +191,14 @@
     [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];
@@ -452,7 +482,10 @@
 
     if (!self.captureSession || !self.captureSession.isRunning) {
         NSLog(@"[IPDFCameraViewController] ERROR: captureSession is not running");
-        _isCapturing = NO;
+        NSError *error = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                             code:-200
+                                         userInfo:@{ NSLocalizedDescriptionKey: @"capture_session_not_running" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
         return;
     }
 
@@ -471,137 +504,64 @@
     // 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");
-            _isCapturing = NO;
-            self.captureCompletionHandler = nil;
-            [weakSelf hideGLKView:NO completion:nil];
-            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");
-            _isCapturing = NO;
-            self.captureCompletionHandler = nil;
-            [weakSelf hideGLKView:NO completion:nil];
-            return;
         }
-
-        NSLog(@"[IPDFCameraViewController] Using AVCaptureStillImageOutput (legacy)");
-        [self.stillImageOutput captureStillImageAsynchronouslyFromConnection:videoConnection completionHandler: ^(CMSampleBufferRef imageSampleBuffer, NSError *error)
-        {
-            [weakSelf handleCapturedImageData:imageSampleBuffer error:error];
-        }];
+        if (videoConnection) break;
     }
-}
-
-// 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);
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
+    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;
     }
 
-    // iOS 11+ uses fileDataRepresentation
-    NSData *imageData = [photo fileDataRepresentation];
-    if (!imageData) {
-        NSLog(@"[IPDFCameraViewController] ERROR: Failed to get image data from photo");
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
-        return;
+    if (videoConnection.isVideoOrientationSupported) {
+        videoConnection.videoOrientation = AVCaptureVideoOrientationPortrait;
     }
 
-    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);
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
-        return;
-    }
-
-    if (!photoSampleBuffer) {
-        NSLog(@"[IPDFCameraViewController] ERROR: photoSampleBuffer is nil");
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
-        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");
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
-        return;
-    }
-
-    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");
 
     if (error) {
         NSLog(@"[IPDFCameraViewController] ERROR capturing image: %@", error);
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:error];
         return;
     }
 
     if (!sampleBuffer) {
         NSLog(@"[IPDFCameraViewController] ERROR: sampleBuffer is nil");
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
+        NSError *bufferError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                  code:-206
+                                              userInfo:@{ NSLocalizedDescriptionKey: @"sample_buffer_nil" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:bufferError];
         return;
     }
 
@@ -610,9 +570,10 @@
 
     if (!imageData) {
         NSLog(@"[IPDFCameraViewController] ERROR: Failed to create image data from sample buffer (legacy)");
-        _isCapturing = NO;
-        self.captureCompletionHandler = nil;
-        [self hideGLKView:NO completion:nil];
+        NSError *dataError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                code:-207
+                                            userInfo:@{ NSLocalizedDescriptionKey: @"legacy_sample_conversion_failed" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:dataError];
         return;
     }
 
@@ -623,67 +584,63 @@
 - (void)processImageData:(NSData *)imageData {
     NSLog(@"[IPDFCameraViewController] processImageData called, imageData size: %lu bytes", (unsigned long)imageData.length);
 
-    __weak typeof(self) weakSelf = self;
-    void (^completionHandler)(UIImage *, UIImage *, CIRectangleFeature *) = self.captureCompletionHandler;
-
-    if (!completionHandler) {
-        NSLog(@"[IPDFCameraViewController] ERROR: completionHandler is nil");
-        _isCapturing = NO;
-        [self hideGLKView:NO completion:nil];
+    if (!imageData || imageData.length == 0) {
+        NSError *dataError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                code:-208
+                                            userInfo:@{ NSLocalizedDescriptionKey: @"empty_image_data" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:dataError];
         return;
     }
 
-    if (self.cameraViewType == IPDFCameraViewTypeBlackAndWhite || self.isBorderDetectionEnabled)
-    {
-        CIImage *enhancedImage = [CIImage imageWithData:imageData];
-
-        if (self.cameraViewType == IPDFCameraViewTypeBlackAndWhite)
-        {
-            enhancedImage = [self filteredImageUsingEnhanceFilterOnImage:enhancedImage];
-        }
-        else
-        {
-            enhancedImage = [self filteredImageUsingContrastFilterOnImage:enhancedImage];
-        }
-
-        if (self.isBorderDetectionEnabled && rectangleDetectionConfidenceHighEnough(_imageDedectionConfidence))
-        {
-            CIRectangleFeature *rectangleFeature = [self biggestRectangleInRectangles:[[self highAccuracyRectangleDetector] featuresInImage:enhancedImage]];
-
-            if (rectangleFeature)
-            {
-                enhancedImage = [self correctPerspectiveForImage:enhancedImage withFeatures:rectangleFeature];
+    UIImage *initialImage = [UIImage imageWithData:imageData];
+    if (!initialImage) {
+        NSError *conversionError = [NSError errorWithDomain:@"IPDFCameraViewController"
+                                                       code:-209
+                                                   userInfo:@{ NSLocalizedDescriptionKey: @"initial_image_conversion_failed" }];
+        [self completeCaptureWithCroppedImage:nil initialImage:nil rectangle:nil error:conversionError];
+        return;
+    }
 
-                UIGraphicsBeginImageContext(CGSizeMake(enhancedImage.extent.size.height, enhancedImage.extent.size.width));
-                [[UIImage imageWithCIImage:enhancedImage scale:1.0 orientation:UIImageOrientationRight] drawInRect:CGRectMake(0,0, enhancedImage.extent.size.height, enhancedImage.extent.size.width)];
-                UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
-                UIImage *initialImage = [UIImage imageWithData:imageData];
-                UIGraphicsEndImageContext();
+    UIImage *croppedImage = initialImage;
+    CIRectangleFeature *rectangleFeature = nil;
 
-                [weakSelf hideGLKView:NO completion:nil];
-                completionHandler(image, initialImage, rectangleFeature);
+    BOOL shouldEnhance = (self.cameraViewType == IPDFCameraViewTypeBlackAndWhite) || self.isBorderDetectionEnabled;
+    if (shouldEnhance) {
+        CIImage *processedImage = [CIImage imageWithData:imageData];
+        if (!processedImage) {
+            NSLog(@"[IPDFCameraViewController] Unable to create CIImage from data, returning original image");
+        } else {
+            if (self.cameraViewType == IPDFCameraViewTypeBlackAndWhite) {
+                processedImage = [self filteredImageUsingEnhanceFilterOnImage:processedImage];
             } else {
-                // No rectangle detected, return original image
-                NSLog(@"[IPDFCameraViewController] No rectangle detected during manual capture, returning original image");
-                [weakSelf hideGLKView:NO completion:nil];
-                UIImage *initialImage = [UIImage imageWithData:imageData];
-                completionHandler(initialImage, initialImage, nil);
+                processedImage = [self filteredImageUsingContrastFilterOnImage:processedImage];
+            }
+
+            if (self.isBorderDetectionEnabled && rectangleDetectionConfidenceHighEnough(_imageDedectionConfidence)) {
+                CIRectangleFeature *detectedRectangle = [self biggestRectangleInRectangles:[[self highAccuracyRectangleDetector] featuresInImage:processedImage]];
+
+                if (detectedRectangle) {
+                    rectangleFeature = detectedRectangle;
+                    CIImage *correctedImage = [self correctPerspectiveForImage:processedImage withFeatures:detectedRectangle];
+
+                    UIGraphicsBeginImageContext(CGSizeMake(correctedImage.extent.size.height, correctedImage.extent.size.width));
+                    [[UIImage imageWithCIImage:correctedImage scale:1.0 orientation:UIImageOrientationRight] drawInRect:CGRectMake(0, 0, correctedImage.extent.size.height, correctedImage.extent.size.width)];
+                    UIImage *perspectiveCorrectedImage = UIGraphicsGetImageFromCurrentImageContext();
+                    UIGraphicsEndImageContext();
+
+                    if (perspectiveCorrectedImage) {
+                        croppedImage = perspectiveCorrectedImage;
+                    } else {
+                        NSLog(@"[IPDFCameraViewController] Failed to create perspective corrected image, using original");
+                    }
+                } else {
+                    NSLog(@"[IPDFCameraViewController] No rectangle detected during manual capture, returning original image");
+                }
             }
-        } else {
-            [weakSelf hideGLKView:NO completion:nil];
-            UIImage *initialImage = [UIImage imageWithData:imageData];
-            completionHandler(initialImage, initialImage, nil);
         }
     }
-    else
-    {
-        [weakSelf hideGLKView:NO completion:nil];
-        UIImage *initialImage = [UIImage imageWithData:imageData];
-        completionHandler(initialImage, initialImage, nil);
-    }
 
-    _isCapturing = NO;
-    self.captureCompletionHandler = nil;
+    [self completeCaptureWithCroppedImage:croppedImage initialImage:initialImage rectangle:rectangleFeature error:nil];
 }
 
 - (void)hideGLKView:(BOOL)hidden completion:(void(^)())completion

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

@@ -34,31 +34,39 @@ 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) {
-    NSLog(@"[RNPdfScannerManager] capture called, scannerView: %@", _scannerView ? @"YES" : @"NO");
+// Main capture method - returns a Promise
+RCT_EXPORT_METHOD(capture:(nullable NSNumber *)reactTag
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    NSLog(@"[RNPdfScannerManager] capture called with reactTag: %@", reactTag);
     dispatch_async(dispatch_get_main_queue(), ^{
-        if (!self->_scannerView) {
-            NSLog(@"[RNPdfScannerManager] ERROR: No scanner view available");
-            return;
+        DocumentScannerView *targetView = nil;
+
+        if (reactTag) {
+            UIView *view = [self.bridge.uiManager viewForReactTag:reactTag];
+            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));
+            } else {
+                NSLog(@"[RNPdfScannerManager] No view found for tag %@", reactTag);
+            }
         }
-        NSLog(@"[RNPdfScannerManager] Calling capture on view: %@", self->_scannerView);
-        [self->_scannerView capture];
-    });
-}
 
-// Alternative method that takes reactTag - for future use
-RCT_EXPORT_METHOD(captureWithTag:(nonnull NSNumber *)reactTag) {
-    NSLog(@"[RNPdfScannerManager] captureWithTag called with reactTag: %@", reactTag);
-    dispatch_async(dispatch_get_main_queue(), ^{
-        UIView *view = [self.bridge.uiManager viewForReactTag:reactTag];
-        if (!view || ![view isKindOfClass:[DocumentScannerView class]]) {
-            NSLog(@"[RNPdfScannerManager] Cannot find DocumentScannerView with tag #%@", reactTag);
+        if (!targetView && self->_scannerView) {
+            NSLog(@"[RNPdfScannerManager] Falling back to last known scanner view");
+            targetView = self->_scannerView;
+        }
+
+        if (!targetView) {
+            NSLog(@"[RNPdfScannerManager] ERROR: No scanner view available for capture");
+            reject(@"NO_VIEW", @"No scanner view available for capture", nil);
             return;
         }
-        DocumentScannerView *scannerView = (DocumentScannerView *)view;
-        NSLog(@"[RNPdfScannerManager] Calling capture on view: %@", scannerView);
-        [scannerView capture];
+
+        NSLog(@"[RNPdfScannerManager] Calling capture on view: %@", targetView);
+        [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() {