rn-document-scanner-vision 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hoang Thien
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,258 @@
+# React Native Document Scanner
+
+A React Native library for scanning documents on iOS and Android. This library provides a native document scanning experience using VisionKit for iOS and a document scanner library for Android.
+
+## Features
+
+- 📷 Native document scanning on iOS (VisionKit) and Android
+- 🔲 Automatic document detection and edge detection
+- ✂️ Automatic cropping and perspective correction
+- 📄 Support for scanning multiple documents (Android)
+- 🎨 Adjustable image quality
+- 📤 Export as base64 or file paths
+- 🎯 User-friendly interface with native look and feel
+- ⚡ Full TypeScript support
+
+## Installation
+
+```sh
+npm install react-native-document-scanner
+```
+
+or
+
+```sh
+yarn add react-native-document-scanner
+```
+
+### iOS Setup
+
+1. **Minimum iOS Version**: iOS 13.0+
+
+2. **Install CocoaPods dependencies**:
+   ```sh
+   cd ios && pod install
+   ```
+
+3. **Add Camera Permission**: Add the following to your `ios/YourApp/Info.plist`:
+   ```xml
+   <key>NSCameraUsageDescription</key>
+   <string>We need camera access to scan documents</string>
+   ```
+
+### Android Setup
+
+1. **Minimum SDK**: 21
+
+2. **Add Camera Permission**: The library already includes the necessary permissions in its AndroidManifest.xml, but make sure your app requests runtime permissions. Add the following to your `android/app/src/main/AndroidManifest.xml` if not already present:
+   ```xml
+   <uses-permission android:name="android.permission.CAMERA" />
+   ```
+
+3. **Request Runtime Permissions**: In your React Native component, request camera permission before scanning:
+   ```javascript
+   import { PermissionsAndroid, Platform } from 'react-native';
+
+   async function requestCameraPermission() {
+     if (Platform.OS === 'android') {
+       try {
+         const granted = await PermissionsAndroid.request(
+           PermissionsAndroid.PERMISSIONS.CAMERA,
+           {
+             title: 'Camera Permission',
+             message: 'App needs camera permission to scan documents',
+             buttonNeutral: 'Ask Me Later',
+             buttonNegative: 'Cancel',
+             buttonPositive: 'OK',
+           }
+         );
+         return granted === PermissionsAndroid.RESULTS.GRANTED;
+       } catch (err) {
+         console.warn(err);
+         return false;
+       }
+     }
+     return true;
+   }
+   ```
+
+## Usage
+
+### Basic Example
+
+```typescript
+import React from 'react';
+import { Button, View, Text, Image } from 'react-native';
+import { DocumentScanner } from 'react-native-document-scanner';
+
+function App() {
+  const [scannedImages, setScannedImages] = React.useState<string[]>([]);
+
+  const handleScan = async () => {
+    try {
+      const result = await DocumentScanner.scanDocument({
+        croppedImageQuality: 100,
+        responseType: 'imageFilePath',
+      });
+
+      if (result.status === 'success') {
+        setScannedImages(result.scannedImages);
+        console.log('Scanned images:', result.scannedImages);
+      } else {
+        console.log('User cancelled the scan');
+      }
+    } catch (error) {
+      console.error('Error scanning document:', error);
+    }
+  };
+
+  return (
+    <View>
+      <Button title="Scan Document" onPress={handleScan} />
+      {scannedImages.map((image, index) => (
+        <Image key={index} source={{ uri: image }} style={{ width: 200, height: 300 }} />
+      ))}
+    </View>
+  );
+}
+```
+
+### Advanced Example with All Options
+
+```typescript
+import { DocumentScanner } from 'react-native-document-scanner';
+
+async function scanMultipleDocuments() {
+  try {
+    const result = await DocumentScanner.scanDocument({
+      maxNumDocuments: 3,              // Android only: max number of documents to scan
+      letUserAdjustCrop: true,         // Android only: allow manual crop adjustment
+      croppedImageQuality: 100,        // Image quality (0-100)
+      responseType: 'base64',          // 'base64' or 'imageFilePath'
+    });
+
+    if (result.status === 'success') {
+      // Process scanned images
+      result.scannedImages.forEach((image, index) => {
+        console.log(`Image ${index + 1}:`, image.substring(0, 50) + '...');
+      });
+    }
+  } catch (error) {
+    console.error('Scan failed:', error);
+  }
+}
+```
+
+## API Reference
+
+### `DocumentScanner.scanDocument(options?)`
+
+Starts the document scanning process.
+
+#### Parameters
+
+- `options` (optional): Configuration object
+
+| Option | Type | Default | Platform | Description |
+|--------|------|---------|----------|-------------|
+| `maxNumDocuments` | `number` | `1` | Android | Maximum number of documents to scan |
+| `letUserAdjustCrop` | `boolean` | `true` | Android | Allow user to manually adjust crop |
+| `croppedImageQuality` | `number` | `100` | Both | Image quality from 0 to 100 |
+| `responseType` | `'base64' \| 'imageFilePath'` | `'imageFilePath'` | Both | Format of returned images |
+
+#### Returns
+
+`Promise<ScanDocumentResponse>`
+
+```typescript
+interface ScanDocumentResponse {
+  scannedImages: string[];  // Array of base64 strings or file paths
+  status: 'success' | 'cancel';
+}
+```
+
+#### Errors
+
+The promise will be rejected with an error if:
+- Camera permission is denied
+- Document scanning is not supported on the device
+- An error occurs during scanning
+- Device is running iOS < 13.0
+
+## TypeScript Support
+
+This library is written in TypeScript and includes type definitions out of the box.
+
+```typescript
+import { 
+  DocumentScanner, 
+  ScanDocumentOptions, 
+  ScanDocumentResponse 
+} from 'react-native-document-scanner';
+```
+
+## Platform Differences
+
+### iOS
+- Uses VisionKit's `VNDocumentCameraViewController`
+- Automatically detects document edges
+- Provides built-in crop and perspective correction
+- Returns multiple pages if user scans multiple documents
+- Options `maxNumDocuments` and `letUserAdjustCrop` are ignored
+
+### Android
+- Uses `com.websitebeaver:documentscanner` library
+- Supports configurable maximum number of documents
+- Allows user to adjust crop boundaries
+- Supports all configuration options
+
+## Troubleshooting
+
+### iOS Issues
+
+**Problem**: "Document scanning is not supported on this device"
+- **Solution**: VisionKit document scanning requires iOS 13.0 or later. Ensure your deployment target is iOS 13.0+.
+
+**Problem**: Camera permission denied
+- **Solution**: Make sure you've added `NSCameraUsageDescription` to your Info.plist.
+
+**Problem**: Module not found
+- **Solution**: Run `cd ios && pod install && cd ..` and rebuild your app.
+
+### Android Issues
+
+**Problem**: Camera permission denied
+- **Solution**: Request camera permission at runtime using `PermissionsAndroid`.
+
+**Problem**: Build errors with Gradle
+- **Solution**: Ensure your `android/build.gradle` has `minSdkVersion` 21 or higher.
+
+**Problem**: "Failed to initialize document scanner"
+- **Solution**: Make sure the camera permission is granted before calling `scanDocument`.
+
+### General Issues
+
+**Problem**: "The package doesn't seem to be linked"
+- **Solution**: 
+  - For React Native 0.60+: Autolinking should work automatically. Try cleaning and rebuilding.
+  - iOS: Run `cd ios && pod install && cd ..`
+  - Android: Clean gradle cache `cd android && ./gradlew clean && cd ..`
+  - Rebuild the app completely
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Credits
+
+This library is based on the Capacitor Document Scanner plugin and uses:
+- iOS: VisionKit framework by Apple
+- Android: [Document Scanner Library](https://github.com/websitebeaver/documentscanner) by WebsiteBeaver
+
+## Support
+
+For issues and feature requests, please use the [GitHub issue tracker](https://github.com/hoangthien123/react-native-document-scanner/issues).

package/android/build.gradle

@@ -0,0 +1,43 @@
+plugins {
+    id 'com.android.library'
+}
+
+android {
+    compileSdk 34
+
+    namespace "com.rndocumentscanner"
+
+    defaultConfig {
+        minSdk 21
+        targetSdk 34
+        versionCode 1
+        versionName "1.0"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_11
+        targetCompatibility JavaVersion.VERSION_11
+    }
+
+    lint {
+        abortOnError false
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-android'
+    implementation "androidx.appcompat:appcompat:1.7.0"
+    implementation "com.websitebeaver:documentscanner:1.3.4"
+}

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/android/gradlew

@@ -0,0 +1,248 @@
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-feature android:name="android.hardware.camera" android:required="false" />
+    <uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
+</manifest>

package/android/src/main/java/com/rndocumentscanner/RNDocumentScannerModule.java

@@ -0,0 +1,126 @@
+package com.rndocumentscanner;
+
+import android.app.Activity;
+import android.content.Intent;
+import androidx.activity.result.ActivityResult;
+
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.BaseActivityEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+import com.websitebeaver.documentscanner.DocumentScanner;
+import com.websitebeaver.documentscanner.constants.DocumentScannerExtra;
+
+import java.util.ArrayList;
+
+public class RNDocumentScannerModule extends ReactContextBaseJavaModule {
+
+    private static final int DOCUMENT_SCAN_REQUEST = 1;
+    private Promise scanPromise;
+    private DocumentScanner documentScanner;
+
+    private final ActivityEventListener activityEventListener = new BaseActivityEventListener() {
+        @Override
+        public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+            if (requestCode == DOCUMENT_SCAN_REQUEST) {
+                if (documentScanner != null) {
+                    // Use a wrapper ActivityResult object
+                    ActivityResult result = new ActivityResult(resultCode, data);
+                    documentScanner.handleDocumentScanIntentResult(result);
+                }
+            }
+        }
+    };
+
+    public RNDocumentScannerModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        reactContext.addActivityEventListener(activityEventListener);
+    }
+
+    @Override
+    public String getName() {
+        return "RNDocumentScanner";
+    }
+
+    @ReactMethod
+    public void scanDocument(ReadableMap options, Promise promise) {
+        Activity activity = getCurrentActivity();
+        
+        if (activity == null) {
+            promise.reject("NO_ACTIVITY", "Activity doesn't exist");
+            return;
+        }
+
+        scanPromise = promise;
+
+        // Get options with defaults
+        String responseType = options.hasKey("responseType") ? options.getString("responseType") : "imageFilePath";
+        Boolean letUserAdjustCrop = options.hasKey("letUserAdjustCrop") ? options.getBoolean("letUserAdjustCrop") : true;
+        Integer maxNumDocuments = options.hasKey("maxNumDocuments") ? options.getInt("maxNumDocuments") : 1;
+        Integer croppedImageQuality = options.hasKey("croppedImageQuality") ? options.getInt("croppedImageQuality") : 100;
+
+        try {
+            // Create document scanner with callbacks
+            documentScanner = new DocumentScanner(
+                activity,
+                (ArrayList<String> documentScanResults) -> {
+                    // Success callback
+                    WritableMap response = Arguments.createMap();
+                    WritableArray scannedImages = Arguments.createArray();
+                    
+                    for (String imagePath : documentScanResults) {
+                        scannedImages.pushString(imagePath);
+                    }
+                    
+                    response.putArray("scannedImages", scannedImages);
+                    response.putString("status", "success");
+                    
+                    if (scanPromise != null) {
+                        scanPromise.resolve(response);
+                        scanPromise = null;
+                    }
+                    return null;
+                },
+                (String errorMessage) -> {
+                    // Error callback
+                    if (scanPromise != null) {
+                        scanPromise.reject("SCAN_ERROR", errorMessage);
+                        scanPromise = null;
+                    }
+                    return null;
+                },
+                () -> {
+                    // Cancel callback
+                    WritableMap response = Arguments.createMap();
+                    WritableArray emptyArray = Arguments.createArray();
+                    response.putArray("scannedImages", emptyArray);
+                    response.putString("status", "cancel");
+                    
+                    if (scanPromise != null) {
+                        scanPromise.resolve(response);
+                        scanPromise = null;
+                    }
+                    return null;
+                },
+                responseType,
+                letUserAdjustCrop,
+                maxNumDocuments,
+                croppedImageQuality
+            );
+
+            // Launch the document scanner
+            Intent scanIntent = documentScanner.createDocumentScanIntent();
+            activity.startActivityForResult(scanIntent, DOCUMENT_SCAN_REQUEST);
+
+        } catch (Exception e) {
+            promise.reject("INITIALIZATION_ERROR", "Failed to initialize document scanner: " + e.getMessage());
+        }
+    }
+}

package/android/src/main/java/com/rndocumentscanner/RNDocumentScannerPackage.java

@@ -0,0 +1,25 @@
+package com.rndocumentscanner;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class RNDocumentScannerPackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new RNDocumentScannerModule(reactContext));
+        return modules;
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/ios/RNDocumentScanner.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RNDocumentScanner : NSObject <RCTBridgeModule>
+
+@end

package/ios/RNDocumentScanner.m

@@ -0,0 +1,156 @@
+#import "RNDocumentScanner.h"
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#import <VisionKit/VisionKit.h>
+
+@interface RNDocumentScanner () <VNDocumentCameraViewControllerDelegate>
+
+@property (nonatomic, strong) RCTPromiseResolveBlock resolveBlock;
+@property (nonatomic, strong) RCTPromiseRejectBlock rejectBlock;
+@property (nonatomic, assign) NSInteger croppedImageQuality;
+@property (nonatomic, strong) NSString *responseType;
+
+@end
+
+@implementation RNDocumentScanner
+
+RCT_EXPORT_MODULE();
+
++ (BOOL)requiresMainQueueSetup
+{
+    return YES;
+}
+
+RCT_EXPORT_METHOD(scanDocument:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    // Check iOS version
+    if (@available(iOS 13.0, *)) {
+        // Check if document scanning is supported
+        if (![VNDocumentCameraViewController isSupported]) {
+            reject(@"NOT_SUPPORTED", @"Document scanning is not supported on this device", nil);
+            return;
+        }
+        
+        // Store promise handlers
+        self.resolveBlock = resolve;
+        self.rejectBlock = reject;
+        
+        // Get options
+        self.croppedImageQuality = options[@"croppedImageQuality"] ? [options[@"croppedImageQuality"] integerValue] : 100;
+        self.responseType = options[@"responseType"] ?: @"imageFilePath";
+        
+        // Present document scanner on main thread
+        dispatch_async(dispatch_get_main_queue(), ^{
+            VNDocumentCameraViewController *documentCameraViewController = [[VNDocumentCameraViewController alloc] init];
+            documentCameraViewController.delegate = self;
+            
+            UIViewController *rootViewController = RCTPresentedViewController();
+            if (rootViewController) {
+                [rootViewController presentViewController:documentCameraViewController animated:YES completion:nil];
+            } else {
+                reject(@"NO_VIEWCONTROLLER", @"No view controller available to present scanner", nil);
+            }
+        });
+    } else {
+        reject(@"IOS_VERSION", @"Document scanning requires iOS 13.0 or later", nil);
+    }
+}
+
+#pragma mark - VNDocumentCameraViewControllerDelegate
+
+- (void)documentCameraViewController:(VNDocumentCameraViewController *)controller didFinishWithScan:(VNDocumentCameraScan *)scan API_AVAILABLE(ios(13.0))
+{
+    NSMutableArray *scannedImages = [NSMutableArray array];
+    
+    // Process each scanned page
+    for (NSUInteger i = 0; i < scan.pageCount; i++) {
+        UIImage *image = [scan imageOfPageAtIndex:i];
+        
+        // Convert to JPEG with quality
+        CGFloat quality = (CGFloat)self.croppedImageQuality / 100.0;
+        NSData *imageData = UIImageJPEGRepresentation(image, quality);
+        
+        if (!imageData) {
+            [controller dismissViewControllerAnimated:YES completion:^{
+                if (self.rejectBlock) {
+                    self.rejectBlock(@"IMAGE_ERROR", @"Failed to convert scanned image to JPEG", nil);
+                    self.rejectBlock = nil;
+                    self.resolveBlock = nil;
+                }
+            }];
+            return;
+        }
+        
+        if ([self.responseType isEqualToString:@"base64"]) {
+            // Return base64 encoded image
+            NSString *base64String = [imageData base64EncodedStringWithOptions:0];
+            [scannedImages addObject:base64String];
+        } else {
+            // Save to temporary directory and return file path
+            NSString *timestamp = [NSString stringWithFormat:@"%.0f", [[NSDate date] timeIntervalSince1970] * 1000];
+            NSString *fileName = [NSString stringWithFormat:@"scanned_doc_%@_%lu.jpg", timestamp, (unsigned long)i];
+            NSString *filePath = [NSTemporaryDirectory() stringByAppendingPathComponent:fileName];
+            
+            NSError *error = nil;
+            BOOL success = [imageData writeToFile:filePath options:NSDataWritingAtomic error:&error];
+            
+            if (!success) {
+                [controller dismissViewControllerAnimated:YES completion:^{
+                    if (self.rejectBlock) {
+                        self.rejectBlock(@"FILE_ERROR", [NSString stringWithFormat:@"Failed to save image: %@", error.localizedDescription], error);
+                        self.rejectBlock = nil;
+                        self.resolveBlock = nil;
+                    }
+                }];
+                return;
+            }
+            
+            // Return file:// URL
+            NSString *fileURL = [NSURL fileURLWithPath:filePath].absoluteString;
+            [scannedImages addObject:fileURL];
+        }
+    }
+    
+    // Dismiss and resolve
+    [controller dismissViewControllerAnimated:YES completion:^{
+        if (self.resolveBlock) {
+            NSDictionary *response = @{
+                @"scannedImages": scannedImages,
+                @"status": @"success"
+            };
+            self.resolveBlock(response);
+            self.resolveBlock = nil;
+            self.rejectBlock = nil;
+        }
+    }];
+}
+
+- (void)documentCameraViewControllerDidCancel:(VNDocumentCameraViewController *)controller API_AVAILABLE(ios(13.0))
+{
+    [controller dismissViewControllerAnimated:YES completion:^{
+        if (self.resolveBlock) {
+            NSDictionary *response = @{
+                @"scannedImages": @[],
+                @"status": @"cancel"
+            };
+            self.resolveBlock(response);
+            self.resolveBlock = nil;
+            self.rejectBlock = nil;
+        }
+    }];
+}
+
+- (void)documentCameraViewController:(VNDocumentCameraViewController *)controller didFailWithError:(NSError *)error API_AVAILABLE(ios(13.0))
+{
+    [controller dismissViewControllerAnimated:YES completion:^{
+        if (self.rejectBlock) {
+            self.rejectBlock(@"SCAN_ERROR", error.localizedDescription, error);
+            self.rejectBlock = nil;
+            self.resolveBlock = nil;
+        }
+    }];
+}
+
+@end

package/lib/commonjs/index.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.DocumentScanner = void 0;
+var _reactNative = require("react-native");
+const LINKING_ERROR = 'The package \'react-native-document-scanner\' doesn\'t seem to be linked. Make sure: \n\n' + _reactNative.Platform.select({
+  ios: "- You have run 'pod install'\n",
+  default: ''
+}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
+const RNDocumentScanner = _reactNative.NativeModules.RNDocumentScanner ? _reactNative.NativeModules.RNDocumentScanner : new Proxy({}, {
+  get() {
+    throw new Error(LINKING_ERROR);
+  }
+});
+
+/**
+ * Options for document scanning
+ */
+
+/**
+ * Response from document scanning
+ */
+
+/**
+ * Document Scanner module
+ */
+const DocumentScanner = exports.DocumentScanner = {
+  /**
+   * Start document scanning
+   *
+   * @param options - Optional configuration for the document scanner
+   * @returns Promise that resolves with scanned document data or rejects with error
+   *
+   * @example
+   * ```typescript
+   * import { DocumentScanner } from 'react-native-document-scanner';
+   *
+   * try {
+   *   const result = await DocumentScanner.scanDocument({
+   *     maxNumDocuments: 3,
+   *     letUserAdjustCrop: true,
+   *     croppedImageQuality: 100,
+   *     responseType: 'base64'
+   *   });
+   *
+   *   if (result.status === 'success') {
+   *     console.log('Scanned images:', result.scannedImages);
+   *   } else {
+   *     console.log('User cancelled');
+   *   }
+   * } catch (error) {
+   *   console.error('Scan error:', error);
+   * }
+   * ```
+   */
+  scanDocument(options) {
+    const defaultOptions = {
+      maxNumDocuments: 1,
+      letUserAdjustCrop: true,
+      croppedImageQuality: 100,
+      responseType: 'imageFilePath'
+    };
+    const finalOptions = {
+      ...defaultOptions,
+      ...options
+    };
+    return RNDocumentScanner.scanDocument(finalOptions);
+  }
+};
+var _default = exports.default = DocumentScanner;
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","LINKING_ERROR","Platform","select","ios","default","RNDocumentScanner","NativeModules","Proxy","get","Error","DocumentScanner","exports","scanDocument","options","defaultOptions","maxNumDocuments","letUserAdjustCrop","croppedImageQuality","responseType","finalOptions","_default"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,MAAMC,aAAa,GACjB,2FAA2F,GAC3FC,qBAAQ,CAACC,MAAM,CAAC;EAAEC,GAAG,EAAE,gCAAgC;EAAEC,OAAO,EAAE;AAAG,CAAC,CAAC,GACvE,sDAAsD,GACtD,+BAA+B;AAEjC,MAAMC,iBAAiB,GAAGC,0BAAa,CAACD,iBAAiB,GACrDC,0BAAa,CAACD,iBAAiB,GAC/B,IAAIE,KAAK,CACP,CAAC,CAAC,EACF;EACEC,GAAGA,CAAA,EAAG;IACJ,MAAM,IAAIC,KAAK,CAACT,aAAa,CAAC;EAChC;AACF,CACF,CAAC;;AAEL;AACA;AACA;;AA6BA;AACA;AACA;;AAaA;AACA;AACA;AACO,MAAMU,eAAe,GAAAC,OAAA,CAAAD,eAAA,GAAG;EAC7B;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEE,YAAYA,CAACC,OAA6B,EAAiC;IACzE,MAAMC,cAAmC,GAAG;MAC1CC,eAAe,EAAE,CAAC;MAClBC,iBAAiB,EAAE,IAAI;MACvBC,mBAAmB,EAAE,GAAG;MACxBC,YAAY,EAAE;IAChB,CAAC;IAED,MAAMC,YAAY,GAAG;MAAE,GAAGL,cAAc;MAAE,GAAGD;IAAQ,CAAC;IAEtD,OAAOR,iBAAiB,CAACO,YAAY,CAACO,YAAY,CAAC;EACrD;AACF,CAAC;AAAC,IAAAC,QAAA,GAAAT,OAAA,CAAAP,OAAA,GAEaM,eAAe","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,67 @@
+import { NativeModules, Platform } from 'react-native';
+const LINKING_ERROR = 'The package \'react-native-document-scanner\' doesn\'t seem to be linked. Make sure: \n\n' + Platform.select({
+  ios: "- You have run 'pod install'\n",
+  default: ''
+}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
+const RNDocumentScanner = NativeModules.RNDocumentScanner ? NativeModules.RNDocumentScanner : new Proxy({}, {
+  get() {
+    throw new Error(LINKING_ERROR);
+  }
+});
+
+/**
+ * Options for document scanning
+ */
+
+/**
+ * Response from document scanning
+ */
+
+/**
+ * Document Scanner module
+ */
+export const DocumentScanner = {
+  /**
+   * Start document scanning
+   *
+   * @param options - Optional configuration for the document scanner
+   * @returns Promise that resolves with scanned document data or rejects with error
+   *
+   * @example
+   * ```typescript
+   * import { DocumentScanner } from 'react-native-document-scanner';
+   *
+   * try {
+   *   const result = await DocumentScanner.scanDocument({
+   *     maxNumDocuments: 3,
+   *     letUserAdjustCrop: true,
+   *     croppedImageQuality: 100,
+   *     responseType: 'base64'
+   *   });
+   *
+   *   if (result.status === 'success') {
+   *     console.log('Scanned images:', result.scannedImages);
+   *   } else {
+   *     console.log('User cancelled');
+   *   }
+   * } catch (error) {
+   *   console.error('Scan error:', error);
+   * }
+   * ```
+   */
+  scanDocument(options) {
+    const defaultOptions = {
+      maxNumDocuments: 1,
+      letUserAdjustCrop: true,
+      croppedImageQuality: 100,
+      responseType: 'imageFilePath'
+    };
+    const finalOptions = {
+      ...defaultOptions,
+      ...options
+    };
+    return RNDocumentScanner.scanDocument(finalOptions);
+  }
+};
+export default DocumentScanner;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeModules","Platform","LINKING_ERROR","select","ios","default","RNDocumentScanner","Proxy","get","Error","DocumentScanner","scanDocument","options","defaultOptions","maxNumDocuments","letUserAdjustCrop","croppedImageQuality","responseType","finalOptions"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA,SAASA,aAAa,EAAEC,QAAQ,QAAQ,cAAc;AAEtD,MAAMC,aAAa,GACjB,2FAA2F,GAC3FD,QAAQ,CAACE,MAAM,CAAC;EAAEC,GAAG,EAAE,gCAAgC;EAAEC,OAAO,EAAE;AAAG,CAAC,CAAC,GACvE,sDAAsD,GACtD,+BAA+B;AAEjC,MAAMC,iBAAiB,GAAGN,aAAa,CAACM,iBAAiB,GACrDN,aAAa,CAACM,iBAAiB,GAC/B,IAAIC,KAAK,CACP,CAAC,CAAC,EACF;EACEC,GAAGA,CAAA,EAAG;IACJ,MAAM,IAAIC,KAAK,CAACP,aAAa,CAAC;EAChC;AACF,CACF,CAAC;;AAEL;AACA;AACA;;AA6BA;AACA;AACA;;AAaA;AACA;AACA;AACA,OAAO,MAAMQ,eAAe,GAAG;EAC7B;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEC,YAAYA,CAACC,OAA6B,EAAiC;IACzE,MAAMC,cAAmC,GAAG;MAC1CC,eAAe,EAAE,CAAC;MAClBC,iBAAiB,EAAE,IAAI;MACvBC,mBAAmB,EAAE,GAAG;MACxBC,YAAY,EAAE;IAChB,CAAC;IAED,MAAMC,YAAY,GAAG;MAAE,GAAGL,cAAc;MAAE,GAAGD;IAAQ,CAAC;IAEtD,OAAON,iBAAiB,CAACK,YAAY,CAACO,YAAY,CAAC;EACrD;AACF,CAAC;AAED,eAAeR,eAAe","ignoreList":[]}

package/lib/typescript/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Options for document scanning
+ */
+export interface ScanDocumentOptions {
+    /**
+     * Maximum number of documents to scan (Android only)
+     * @default 1
+     * @platform android
+     */
+    maxNumDocuments?: number;
+    /**
+     * Allow user to adjust crop manually (Android only)
+     * @default true
+     * @platform android
+     */
+    letUserAdjustCrop?: boolean;
+    /**
+     * Quality of the cropped image (0-100)
+     * @default 100
+     */
+    croppedImageQuality?: number;
+    /**
+     * Response type for scanned images
+     * @default 'imageFilePath'
+     */
+    responseType?: 'base64' | 'imageFilePath';
+}
+/**
+ * Response from document scanning
+ */
+export interface ScanDocumentResponse {
+    /**
+     * Array of scanned images (base64 strings or file paths)
+     */
+    scannedImages: string[];
+    /**
+     * Status of the scan operation
+     */
+    status: 'success' | 'cancel';
+}
+/**
+ * Document Scanner module
+ */
+export declare const DocumentScanner: {
+    /**
+     * Start document scanning
+     *
+     * @param options - Optional configuration for the document scanner
+     * @returns Promise that resolves with scanned document data or rejects with error
+     *
+     * @example
+     * ```typescript
+     * import { DocumentScanner } from 'react-native-document-scanner';
+     *
+     * try {
+     *   const result = await DocumentScanner.scanDocument({
+     *     maxNumDocuments: 3,
+     *     letUserAdjustCrop: true,
+     *     croppedImageQuality: 100,
+     *     responseType: 'base64'
+     *   });
+     *
+     *   if (result.status === 'success') {
+     *     console.log('Scanned images:', result.scannedImages);
+     *   } else {
+     *     console.log('User cancelled');
+     *   }
+     * } catch (error) {
+     *   console.error('Scan error:', error);
+     * }
+     * ```
+     */
+    scanDocument(options?: ScanDocumentOptions): Promise<ScanDocumentResponse>;
+};
+export default DocumentScanner;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAmBA;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B;;;OAGG;IACH,YAAY,CAAC,EAAE,QAAQ,GAAG,eAAe,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,aAAa,EAAE,MAAM,EAAE,CAAC;IAExB;;OAEG;IACH,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;CAC9B;AAED;;GAEG;AACH,eAAO,MAAM,eAAe;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;2BACoB,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAY3E,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "rn-document-scanner-vision",
+  "version": "1.0.0",
+  "description": "A React Native library for scanning documents on iOS and Android",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index.tsx",
+  "source": "src/index.tsx",
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "react-native-document-scanner.podspec",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "typescript": "tsc --noEmit",
+    "build": "bob build",
+    "prepare": "bob build",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "lint:fix": "eslint \"**/*.{js,ts,tsx}\" --fix"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "document-scanner",
+    "scanner",
+    "ocr",
+    "document",
+    "scan",
+    "camera",
+    "visionkit",
+    "mlkit"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hoangthien123/react-native-document-scanner.git"
+  },
+  "author": "Hoang Thien <hoangthien123@example.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/hoangthien123/react-native-document-scanner/issues"
+  },
+  "homepage": "https://github.com/hoangthien123/react-native-document-scanner#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "@react-native/eslint-config": "^0.74.0",
+    "@types/react": "^18.2.44",
+    "@types/react-native": "^0.72.8",
+    "eslint": "^8.19.0",
+    "prettier": "^3.0.0",
+    "react": "^18.2.0",
+    "react-native": "^0.74.0",
+    "react-native-builder-bob": "^0.23.2",
+    "typescript": "^5.3.3"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  }
+}

package/react-native-document-scanner.podspec

@@ -0,0 +1,21 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-document-scanner"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => package["repository"]["url"], :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+
+  s.dependency "React-Core"
+  
+  # VisionKit is required for document scanning
+  s.frameworks = "VisionKit"
+end

package/src/index.tsx

@@ -0,0 +1,112 @@
+import { NativeModules, Platform } from 'react-native';
+
+const LINKING_ERROR =
+  'The package \'react-native-document-scanner\' doesn\'t seem to be linked. Make sure: \n\n' +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+const RNDocumentScanner = NativeModules.RNDocumentScanner
+  ? NativeModules.RNDocumentScanner
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+/**
+ * Options for document scanning
+ */
+export interface ScanDocumentOptions {
+  /**
+   * Maximum number of documents to scan (Android only)
+   * @default 1
+   * @platform android
+   */
+  maxNumDocuments?: number;
+
+  /**
+   * Allow user to adjust crop manually (Android only)
+   * @default true
+   * @platform android
+   */
+  letUserAdjustCrop?: boolean;
+
+  /**
+   * Quality of the cropped image (0-100)
+   * @default 100
+   */
+  croppedImageQuality?: number;
+
+  /**
+   * Response type for scanned images
+   * @default 'imageFilePath'
+   */
+  responseType?: 'base64' | 'imageFilePath';
+}
+
+/**
+ * Response from document scanning
+ */
+export interface ScanDocumentResponse {
+  /**
+   * Array of scanned images (base64 strings or file paths)
+   */
+  scannedImages: string[];
+
+  /**
+   * Status of the scan operation
+   */
+  status: 'success' | 'cancel';
+}
+
+/**
+ * Document Scanner module
+ */
+export const DocumentScanner = {
+  /**
+   * Start document scanning
+   *
+   * @param options - Optional configuration for the document scanner
+   * @returns Promise that resolves with scanned document data or rejects with error
+   *
+   * @example
+   * ```typescript
+   * import { DocumentScanner } from 'react-native-document-scanner';
+   *
+   * try {
+   *   const result = await DocumentScanner.scanDocument({
+   *     maxNumDocuments: 3,
+   *     letUserAdjustCrop: true,
+   *     croppedImageQuality: 100,
+   *     responseType: 'base64'
+   *   });
+   *
+   *   if (result.status === 'success') {
+   *     console.log('Scanned images:', result.scannedImages);
+   *   } else {
+   *     console.log('User cancelled');
+   *   }
+   * } catch (error) {
+   *   console.error('Scan error:', error);
+   * }
+   * ```
+   */
+  scanDocument(options?: ScanDocumentOptions): Promise<ScanDocumentResponse> {
+    const defaultOptions: ScanDocumentOptions = {
+      maxNumDocuments: 1,
+      letUserAdjustCrop: true,
+      croppedImageQuality: 100,
+      responseType: 'imageFilePath',
+    };
+
+    const finalOptions = { ...defaultOptions, ...options };
+
+    return RNDocumentScanner.scanDocument(finalOptions);
+  },
+};
+
+export default DocumentScanner;