@sanctum-key/react-native-sdk 1.0.0

package/ios/TransfergratisSdkModule.swift

@@ -0,0 +1,409 @@
+import ExpoModulesCore
+import AVFoundation
+import UIKit
+import Photos
+
+// Vue caméra native avec logs et interface améliorée
+public final class TransfergratisSdkView: ExpoView {
+  let onCapture = EventDispatcher()
+  let onError = EventDispatcher()
+  
+  private var mainContainer: UIView?
+  private var instructionsLabel: UILabel?
+  private var statusLabel: UILabel?
+  private var captureButton: UIButton?
+  
+  private var currentInstructions: String = ""
+  private var isCameraVisible: Bool = false
+  
+  // Logs pour débogage
+  private func logDebug(_ message: String) {
+    print("🟦 [TransfergratisSdkView] \(message)")
+  }
+  
+  public required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+    logDebug("Initialisation de la vue caméra")
+    print("🟦 [TransfergratisSdkView] Init appelé - Vue créée")
+    setupViews()
+    
+    // Test immédiat pour voir si les événements fonctionnent
+    DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { [weak self] in
+      self?.logDebug("Test d'événement automatique après 2 secondes")
+      self?.onCapture([
+        "action": "init_test",
+        "success": true,
+        "message": "Vue initialisée avec succès"
+      ])
+    }
+  }
+  
+  private func setupViews() {
+    logDebug("Configuration des vues")
+    
+    // Container principal
+    let container = UIView()
+    container.backgroundColor = .systemBlue  // Couleur visible pour tester
+    container.translatesAutoresizingMaskIntoConstraints = false
+    addSubview(container)
+    mainContainer = container
+    
+    // Label d'instructions
+    let instructions = UILabel()
+    instructions.textColor = .white
+    instructions.font = UIFont.systemFont(ofSize: 18, weight: .medium)
+    instructions.textAlignment = .center
+    instructions.numberOfLines = 0
+    instructions.backgroundColor = UIColor.black.withAlphaComponent(0.7)
+    instructions.layer.cornerRadius = 8
+    instructions.layer.masksToBounds = true
+    instructions.translatesAutoresizingMaskIntoConstraints = false
+    instructions.text = "Vue caméra native"
+    container.addSubview(instructions)
+    instructionsLabel = instructions
+    
+    // Label de statut pour débogage
+    let status = UILabel()
+    status.textColor = .green
+    status.font = UIFont.systemFont(ofSize: 14, weight: .regular)
+    status.textAlignment = .center
+    status.numberOfLines = 0
+    status.backgroundColor = UIColor.green.withAlphaComponent(0.2)
+    status.layer.cornerRadius = 4
+    status.layer.masksToBounds = true
+    status.translatesAutoresizingMaskIntoConstraints = false
+    status.text = "Statut: Vue initialisée"
+    container.addSubview(status)
+    statusLabel = status
+    
+    // Bouton de capture pour test
+    let button = UIButton(type: .system)
+    button.setTitle("📸 Test Capture", for: .normal)
+    button.setTitleColor(.white, for: .normal)
+    button.backgroundColor = UIColor(red: 0.3, green: 0.8, blue: 0.3, alpha: 1.0)
+    button.layer.cornerRadius = 8
+    button.titleLabel?.font = UIFont.systemFont(ofSize: 16, weight: .semibold)
+    button.translatesAutoresizingMaskIntoConstraints = false
+    button.addTarget(self, action: #selector(testCaptureButtonTapped), for: .touchUpInside)
+    container.addSubview(button)
+    captureButton = button
+    
+    // Contraintes
+    NSLayoutConstraint.activate([
+      // Container principal
+      container.topAnchor.constraint(equalTo: topAnchor),
+      container.leadingAnchor.constraint(equalTo: leadingAnchor),
+      container.trailingAnchor.constraint(equalTo: trailingAnchor),
+      container.bottomAnchor.constraint(equalTo: bottomAnchor),
+      
+      // Instructions en haut
+      instructions.topAnchor.constraint(equalTo: container.topAnchor, constant: 50),
+      instructions.leadingAnchor.constraint(equalTo: container.leadingAnchor, constant: 20),
+      instructions.trailingAnchor.constraint(equalTo: container.trailingAnchor, constant: -20),
+      instructions.heightAnchor.constraint(greaterThanOrEqualToConstant: 60),
+      
+      // Statut au centre
+      status.centerXAnchor.constraint(equalTo: container.centerXAnchor),
+      status.centerYAnchor.constraint(equalTo: container.centerYAnchor),
+      status.leadingAnchor.constraint(equalTo: container.leadingAnchor, constant: 20),
+      status.trailingAnchor.constraint(equalTo: container.trailingAnchor, constant: -20),
+      status.heightAnchor.constraint(greaterThanOrEqualToConstant: 40),
+      
+      // Bouton en bas
+      button.bottomAnchor.constraint(equalTo: container.bottomAnchor, constant: -50),
+      button.centerXAnchor.constraint(equalTo: container.centerXAnchor),
+      button.widthAnchor.constraint(equalToConstant: 150),
+      button.heightAnchor.constraint(equalToConstant: 50)
+    ])
+    
+    logDebug("Vues configurées avec succès")
+  }
+  
+  @objc private func testCaptureButtonTapped() {
+    logDebug("Bouton test capture pressé")
+    updateStatus("Test capture en cours...")
+    
+    // Simuler une capture après 1 seconde
+    DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in
+      self?.logDebug("Envoi de l'événement onCapture")
+      self?.onCapture([
+        "action": "test_capture",
+        "success": true,
+        "timestamp": Date().timeIntervalSince1970
+      ])
+      self?.updateStatus("Test capture envoyé ✅")
+    }
+  }
+  
+  private func updateStatus(_ message: String) {
+    logDebug("Mise à jour du statut: \(message)")
+    DispatchQueue.main.async { [weak self] in
+      self?.statusLabel?.text = "Statut: \(message)"
+    }
+  }
+  
+  public func setInstructions(_ instructions: String) {
+    logDebug("Nouvelle instruction reçue: \(instructions)")
+    currentInstructions = instructions
+    DispatchQueue.main.async { [weak self] in
+      self?.instructionsLabel?.text = instructions
+      self?.updateStatus("Instructions mises à jour")
+    }
+  }
+  
+  public func showCamera(_ show: Bool) {
+    logDebug("showCamera appelé avec: \(show)")
+    isCameraVisible = show
+    
+    DispatchQueue.main.async { [weak self] in
+      if show {
+        self?.mainContainer?.backgroundColor = .darkGray
+        self?.updateStatus("Caméra activée (mode démo)")
+        self?.captureButton?.isHidden = false
+      } else {
+        self?.mainContainer?.backgroundColor = .black
+        self?.updateStatus("Caméra désactivée")
+        self?.captureButton?.isHidden = true
+      }
+    }
+  }
+  
+  public func showError(_ message: String) {
+    logDebug("Erreur: \(message)")
+    updateStatus("❌ Erreur: \(message)")
+    onError([
+      "message": message,
+      "code": "CAMERA_ERROR"
+    ])
+  }
+}
+
+// Classe déléguée pour gérer les protocoles qui nécessitent NSObject
+class CameraDelegate: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
+  weak var module: TransfergratisSdkModule?
+  
+  init(module: TransfergratisSdkModule) {
+    self.module = module
+    super.init()
+  }
+  
+  func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
+    picker.dismiss(animated: true) {
+      if let image = info[.editedImage] as? UIImage ?? info[.originalImage] as? UIImage {
+        // Sauvegarder l'image
+        if let imageData = image.jpegData(compressionQuality: 0.8) {
+          let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+          let fileName = "photo_\(Date().timeIntervalSince1970).jpg"
+          let fileURL = documentsPath.appendingPathComponent(fileName)
+          
+          do {
+            try imageData.write(to: fileURL)
+            self.module?.currentPhotoPath = fileURL.path
+            
+            self.module?.sendEvent("onCameraCapture", [
+              "status": "captured",
+              "path": fileURL.path
+            ])
+            
+            self.module?.cameraPromise?.resolve([
+              "success": true,
+              "path": fileURL.path
+            ])
+          } catch {
+            self.module?.cameraPromise?.reject(error)
+          }
+        }
+      }
+      self.module?.cameraPromise = nil
+    }
+  }
+  
+  func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
+    picker.dismiss(animated: true) {
+      self.module?.cameraPromise?.reject(NSError(domain: "CameraError", code: 3, userInfo: [NSLocalizedDescriptionKey: "Camera capture cancelled"]))
+      self.module?.cameraPromise = nil
+    }
+  }
+}
+
+// Classe déléguée pour le sélecteur de fichiers
+class FilePickerDelegate: NSObject, UIDocumentPickerDelegate {
+  weak var module: TransfergratisSdkModule?
+  
+  init(module: TransfergratisSdkModule) {
+    self.module = module
+    super.init()
+  }
+  
+  func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
+    guard let selectedURL = urls.first else {
+      module?.filePickerPromise?.reject(NSError(domain: "FilePickerError", code: 2, userInfo: [NSLocalizedDescriptionKey: "No file selected"]))
+      module?.filePickerPromise = nil
+      return
+    }
+    
+    module?.sendEvent("onFileSelected", [
+      "uri": selectedURL.absoluteString,
+      "path": selectedURL.path
+    ])
+    
+    module?.filePickerPromise?.resolve([
+      "success": true,
+      "uri": selectedURL.absoluteString,
+      "path": selectedURL.path
+    ])
+    module?.filePickerPromise = nil
+  }
+  
+  func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
+    module?.filePickerPromise?.reject(NSError(domain: "FilePickerError", code: 3, userInfo: [NSLocalizedDescriptionKey: "File selection cancelled"]))
+    module?.filePickerPromise = nil
+  }
+}
+
+public class TransfergratisSdkModule: Module {
+  var cameraPromise: Promise?
+  var filePickerPromise: Promise?
+  var currentPhotoPath: String?
+  private var cameraDelegate: CameraDelegate?
+  private var filePickerDelegate: FilePickerDelegate?
+  
+  public func definition() -> ModuleDefinition {
+    Name("TransfergratisSdk")
+
+    Constants([
+      "PI": Double.pi
+    ])
+
+
+      
+    Events("onCameraCapture", "onFileSelected", "onError")
+    // Removed print statement to conform to expected type 'AnyDefinition'
+
+    // Fonction pour demander les permissions de caméra
+    AsyncFunction("requestCameraPermission") { (promise: Promise) in
+      switch AVCaptureDevice.authorizationStatus(for: .video) {
+      case .authorized:
+        promise.resolve(true)
+      case .notDetermined:
+        AVCaptureDevice.requestAccess(for: .video) { granted in
+          promise.resolve(granted)
+        }
+      case .denied, .restricted:
+        promise.resolve(false)
+      @unknown default:
+        promise.resolve(false)
+      }
+    }
+
+    // Fonction pour ouvrir la caméra avec instructions
+    AsyncFunction("openCameraWithInstructions") { (instructions: String, promise: Promise) in
+      guard AVCaptureDevice.authorizationStatus(for: .video) == .authorized else {
+        promise.reject(NSError(domain: "CameraError", code: 1, userInfo: [NSLocalizedDescriptionKey: "Camera permission not granted"]))
+        return
+      }
+      
+      // Vérifier si la caméra est disponible (pas le cas sur simulateur)
+      guard UIImagePickerController.isSourceTypeAvailable(.camera) else {
+        // Pour les simulateurs ou appareils sans caméra, utiliser la galerie photo
+        if UIImagePickerController.isSourceTypeAvailable(.photoLibrary) {
+          self.openPhotoLibrary(instructions: instructions, promise: promise)
+        } else {
+          promise.reject(NSError(domain: "CameraError", code: 3, userInfo: [NSLocalizedDescriptionKey: "No camera or photo library available"]))
+        }
+        return
+      }
+      
+      cameraPromise = promise
+      
+      DispatchQueue.main.async {
+        let imagePicker = UIImagePickerController()
+        imagePicker.sourceType = .camera
+        imagePicker.allowsEditing = true
+        
+        // Créer et assigner le délégué
+        self.cameraDelegate = CameraDelegate(module: self)
+        imagePicker.delegate = self.cameraDelegate
+        
+        // Stocker les instructions pour les utiliser dans la vue
+        imagePicker.accessibilityLabel = instructions
+        
+        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+           let rootViewController = windowScene.windows.first?.rootViewController {
+          rootViewController.present(imagePicker, animated: true) {
+            self.sendEvent("onCameraCapture", [
+              "instructions": instructions,
+              "status": "opened"
+            ])
+          }
+        } else {
+          promise.reject(NSError(domain: "CameraError", code: 2, userInfo: [NSLocalizedDescriptionKey: "No root view controller available"]))
+        }
+      }
+    }
+
+    // Fonction pour ouvrir le sélecteur de fichiers
+    AsyncFunction("openFilePicker") { (allowedTypes: [String], promise: Promise) in
+      filePickerPromise = promise
+      
+      DispatchQueue.main.async {
+        let documentPicker = UIDocumentPickerViewController(forOpeningContentTypes: allowedTypes.map { UTType(tag: $0, tagClass: .filenameExtension, conformingTo: nil) ?? UTType.data })
+        documentPicker.allowsMultipleSelection = false
+        
+        // Créer et assigner le délégué
+        self.filePickerDelegate = FilePickerDelegate(module: self)
+        documentPicker.delegate = self.filePickerDelegate
+        
+        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+           let rootViewController = windowScene.windows.first?.rootViewController {
+          rootViewController.present(documentPicker, animated: true)
+        } else {
+          promise.reject(NSError(domain: "FilePickerError", code: 1, userInfo: [NSLocalizedDescriptionKey: "No root view controller available"]))
+        }
+      }
+    }
+
+    // Vue native pour la caméra avec instructions
+    View(TransfergratisSdkView.self) {
+      Prop("instructions") { (view: TransfergratisSdkView, instructions: String) in
+        view.setInstructions(instructions)
+      }
+      
+      Prop("showCamera") { (view: TransfergratisSdkView, show: Bool) in
+        view.showCamera(show)
+      }
+
+      Events("onCapture", "onError")
+    }
+  }
+  
+  // Fonction helper pour ouvrir la galerie photo (fallback pour simulateur)
+  private func openPhotoLibrary(instructions: String, promise: Promise) {
+    cameraPromise = promise
+    
+    DispatchQueue.main.async {
+      let imagePicker = UIImagePickerController()
+      imagePicker.sourceType = .photoLibrary
+      imagePicker.allowsEditing = true
+      
+      // Créer et assigner le délégué
+      self.cameraDelegate = CameraDelegate(module: self)
+      imagePicker.delegate = self.cameraDelegate
+      
+      // Stocker les instructions pour les utiliser dans la vue
+      imagePicker.accessibilityLabel = instructions
+      
+      if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+         let rootViewController = windowScene.windows.first?.rootViewController {
+        rootViewController.present(imagePicker, animated: true) {
+          self.sendEvent("onCameraCapture", [
+            "instructions": instructions,
+            "status": "opened_photo_library"
+          ])
+        }
+      } else {
+        promise.reject(NSError(domain: "CameraError", code: 2, userInfo: [NSLocalizedDescriptionKey: "No root view controller available"]))
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@sanctum-key/react-native-sdk",
+  "version": "1.0.0",
+  "description": "Sanctum Key React Native SDK",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare && bash scripts/copy-assets.sh",
+    "postprepare": "bash scripts/copy-assets.sh",
+    "prepublishOnly": "expo-module prepublishOnly && bash scripts/copy-assets.sh",
+    "prepack": "bash scripts/copy-assets.sh",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "sanctum-key",
+    "sanctum-key-react-native-sdk",
+    "kyc",
+    "identity-verification"
+  ],
+  "repository": "https://github.com/TransfergratisOrg/KYC-User-Frontend",
+  "bugs": {
+    "url": "https://github.com/TransfergratisOrg/KYC-User-Frontend/issues"
+  },
+  "author": "mesha-transfergratis <loic.lontchi@transfergratis.com> (https://github.com/mesha-transfergratis)",
+  "license": "MIT",
+  "homepage": "https://github.com/TransfergratisOrg/KYC-User-Frontend#readme",
+  "files": [
+    "build",
+    "src",
+    "android",
+    "ios",
+    "plugin",
+    "plugin.js",
+    "expo-module.config.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^1.11.0",
+    "i18n-js": "4.5.1",
+    "iconsax-react-nativejs": "^0.0.8",
+    "zustand": "^5.0.8"
+  },
+  "devDependencies": {
+    "@expo/config-plugins": "^8.0.0",
+    "@types/react": "~19.0.0",
+    "expo": "~53.0.0",
+    "expo-module-scripts": "^4.1.10",
+    "react-native": "0.79.1"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "expo-location": "*",
+    "expo-image-manipulator": "*",
+    "react": "*",
+    "react-native": "*",
+    "react-native-svg": "*",
+    "react-native-vision-camera": "^4.7.1"
+  }
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,5 @@
+export { default as withVisionCamera } from './withVisionCamera';
+export type { VisionCameraPluginProps } from './withVisionCamera';
+export { default as withLocation } from './withLocation';
+export type { LocationPluginProps } from './withLocation';
+export { default as withRemovePermissions } from './withRemovePermissions';

package/plugin/build/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRemovePermissions = exports.withLocation = exports.withVisionCamera = void 0;
+var withVisionCamera_1 = require("./withVisionCamera");
+Object.defineProperty(exports, "withVisionCamera", { enumerable: true, get: function () { return __importDefault(withVisionCamera_1).default; } });
+var withLocation_1 = require("./withLocation");
+Object.defineProperty(exports, "withLocation", { enumerable: true, get: function () { return __importDefault(withLocation_1).default; } });
+var withRemovePermissions_1 = require("./withRemovePermissions");
+Object.defineProperty(exports, "withRemovePermissions", { enumerable: true, get: function () { return __importDefault(withRemovePermissions_1).default; } });

package/plugin/build/withLocation.d.ts

@@ -0,0 +1,9 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+export interface LocationPluginProps {
+    locationPermissionText?: string;
+    locationAlwaysPermissionText?: string;
+    locationWhenInUsePermissionText?: string;
+    enableBackgroundLocation?: boolean;
+}
+declare const withLocationPermissions: ConfigPlugin<LocationPluginProps>;
+export default withLocationPermissions;

package/plugin/build/withLocation.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const withLocationPermissions = (config, { locationPermissionText = 'This app uses location to verify your identity and location.', locationAlwaysPermissionText = 'This app uses location in the background to verify your identity and location.', locationWhenInUsePermissionText = 'This app uses location to verify your identity and location.', enableBackgroundLocation = false, } = {}) => {
+    // iOS permissions
+    config = (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        var _a, _b, _c;
+        config.modResults.NSLocationWhenInUseUsageDescription =
+            (_a = config.modResults.NSLocationWhenInUseUsageDescription) !== null && _a !== void 0 ? _a : locationWhenInUsePermissionText;
+        if (enableBackgroundLocation) {
+            config.modResults.NSLocationAlwaysAndWhenInUseUsageDescription =
+                (_b = config.modResults.NSLocationAlwaysAndWhenInUseUsageDescription) !== null && _b !== void 0 ? _b : locationAlwaysPermissionText;
+            config.modResults.NSLocationAlwaysUsageDescription =
+                (_c = config.modResults.NSLocationAlwaysUsageDescription) !== null && _c !== void 0 ? _c : locationAlwaysPermissionText;
+            // Add background modes for location updates
+            config.modResults.UIBackgroundModes = config.modResults.UIBackgroundModes || [];
+            if (!config.modResults.UIBackgroundModes.includes('location')) {
+                config.modResults.UIBackgroundModes.push('location');
+            }
+        }
+        return config;
+    });
+    // Android permissions
+    config = (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const androidManifest = config.modResults;
+        if (!androidManifest.manifest['uses-permission']) {
+            androidManifest.manifest['uses-permission'] = [];
+        }
+        const permissions = [
+            'android.permission.ACCESS_FINE_LOCATION',
+            'android.permission.ACCESS_COARSE_LOCATION',
+        ];
+        // Add background location permission if enabled
+        if (enableBackgroundLocation) {
+            permissions.push('android.permission.ACCESS_BACKGROUND_LOCATION');
+        }
+        for (const permission of permissions) {
+            if (!androidManifest.manifest['uses-permission'].find((perm) => perm.$['android:name'] === permission)) {
+                androidManifest.manifest['uses-permission'].push({
+                    $: { 'android:name': permission },
+                });
+            }
+        }
+        // Add location features
+        if (!androidManifest.manifest['uses-feature']) {
+            androidManifest.manifest['uses-feature'] = [];
+        }
+        const locationFeatures = [
+            {
+                $: {
+                    'android:name': 'android.hardware.location',
+                    'android:required': 'false',
+                },
+            },
+            {
+                $: {
+                    'android:name': 'android.hardware.location.gps',
+                    'android:required': 'false',
+                },
+            },
+            {
+                $: {
+                    'android:name': 'android.hardware.location.network',
+                    'android:required': 'false',
+                },
+            },
+        ];
+        for (const feature of locationFeatures) {
+            if (!androidManifest.manifest['uses-feature'].find((feat) => feat.$['android:name'] === feature.$['android:name'])) {
+                androidManifest.manifest['uses-feature'].push(feature);
+            }
+        }
+        return config;
+    });
+    return config;
+};
+exports.default = withLocationPermissions;

package/plugin/build/withRemovePermissions.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+declare const withRemovePermissions: ConfigPlugin;
+export default withRemovePermissions;

package/plugin/build/withRemovePermissions.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+/**
+ * Plugin to remove unnecessary permissions that cause Google Play Store rejection.
+ *
+ * For KYC apps, we don't need persistent access to media files because:
+ * - Photos are taken directly with the camera
+ * - Photos are saved to app's internal storage (documentDirectory)
+ * - File selection uses Android Photo Picker API (no permissions needed)
+ */
+// Permissions to remove - these cause Play Store rejection for KYC apps
+const PERMISSIONS_TO_REMOVE = [
+    // Media permissions - not needed, causes Play Store rejection
+    'android.permission.READ_MEDIA_IMAGES',
+    'android.permission.READ_MEDIA_VIDEO',
+    'android.permission.READ_MEDIA_AUDIO',
+    // Storage permissions - not needed for KYC
+    'android.permission.READ_EXTERNAL_STORAGE',
+    'android.permission.WRITE_EXTERNAL_STORAGE',
+    // Contacts - not needed for KYC
+    'android.permission.READ_CONTACTS',
+    'android.permission.WRITE_CONTACTS',
+];
+const withRemovePermissions = (config) => {
+    return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        var _a;
+        const androidManifest = config.modResults;
+        if (!androidManifest.manifest['uses-permission']) {
+            return config;
+        }
+        // Filter out unwanted permissions
+        const originalCount = androidManifest.manifest['uses-permission'].length;
+        androidManifest.manifest['uses-permission'] = androidManifest.manifest['uses-permission'].filter((permission) => {
+            var _a;
+            const permissionName = (_a = permission.$) === null || _a === void 0 ? void 0 : _a['android:name'];
+            const shouldRemove = PERMISSIONS_TO_REMOVE.includes(permissionName);
+            if (shouldRemove) {
+                console.log(`[withRemovePermissions] Removing: ${permissionName}`);
+            }
+            return !shouldRemove;
+        });
+        const removedCount = originalCount - androidManifest.manifest['uses-permission'].length;
+        console.log(`[withRemovePermissions] Removed ${removedCount} permissions`);
+        // Also add tools:remove to explicitly block these permissions from being merged
+        // This prevents dependencies from re-adding them
+        // Ensure xmlns:tools is defined (xmlns:android always exists in valid manifests)
+        if (androidManifest.manifest.$) {
+            androidManifest.manifest.$['xmlns:tools'] = 'http://schemas.android.com/tools';
+        }
+        // Add uses-permission with tools:node="remove" for each permission to block
+        for (const permissionName of PERMISSIONS_TO_REMOVE) {
+            // Check if a remove directive already exists
+            const existingRemove = (_a = androidManifest.manifest['uses-permission']) === null || _a === void 0 ? void 0 : _a.find((p) => { var _a, _b; return ((_a = p.$) === null || _a === void 0 ? void 0 : _a['android:name']) === permissionName && ((_b = p.$) === null || _b === void 0 ? void 0 : _b['tools:node']) === 'remove'; });
+            if (!existingRemove) {
+                androidManifest.manifest['uses-permission'].push({
+                    $: {
+                        'android:name': permissionName,
+                        'tools:node': 'remove',
+                    },
+                });
+            }
+        }
+        return config;
+    });
+};
+exports.default = withRemovePermissions;

package/plugin/build/withVisionCamera.d.ts

@@ -0,0 +1,8 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+export interface VisionCameraPluginProps {
+    cameraPermissionText?: string;
+    microphonePermissionText?: string;
+    enableFrameProcessors?: boolean;
+}
+declare const withVisionCameraPermissions: ConfigPlugin<VisionCameraPluginProps>;
+export default withVisionCameraPermissions;