@socure-inc/docv-react-native 5.2.7 → 5.2.8

package/android/src/main/java/com/socure/docv/reactnative/SocureDocVReactNativeModule.kt

@@ -13,84 +13,127 @@ import com.socure.docv.capturesdk.api.SocureSdk.getResult
 import com.socure.docv.capturesdk.api.SocureSdk.initSdk
 import com.socure.docv.capturesdk.common.utils.SocureDocVFailure
 import com.socure.docv.capturesdk.common.utils.SocureDocVSuccess
-import com.socure.docv.capturesdk.common.utils.SocureResult
 
 class SocureDocVReactNativeModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
+    NativeSocureDocVReactNativeSpec(reactContext), ActivityEventListener {
 
-    private val TAG = "SDLT_RN"
-    private val SOCURE_SDK_REQUEST_CODE = 753
-    private var onSuccessCallback: Callback? = null
-    private var onErrorCallback: Callback? = null
-
-    override fun getName(): String {
-        return "SocureDocVReactNative"
+    companion object {
+        const val NAME = "SocureDocVReactNative"
+        private const val TAG = "SDLT_RN"
+        private const val SOCURE_SDK_REQUEST_CODE = 753
     }
 
+    // One of these will be set per in-flight session; never both.
+    private var pendingPromise: Promise? = null
+    private var pendingSuccessCallback: Callback? = null
+    private var pendingErrorCallback: Callback? = null
+
+    override fun getName(): String = NAME
+
+    // ── Experimental two-step API ────────────────────────────────────────────
+
     @OptIn(SocureExperimentalApi::class)
     @ReactMethod
     fun initDocVSdk(verificationToken: String, publicKey: String, useSocureGov: Boolean) {
         Log.d(TAG, "initDocVSdk - init native sdk")
-        initSdk(
-            SocureDocVContext(verificationToken, publicKey, useSocureGov, null, null)
-        )
+        initSdk(SocureDocVContext(verificationToken, publicKey, useSocureGov, null, null))
     }
 
+
     @OptIn(SocureExperimentalApi::class)
     @ReactMethod
     fun launchDocVSdk(onSuccess: Callback, onError: Callback) {
         Log.d(TAG, "launchDocVSdk - launch using experimental api")
-        setupLaunch(onSuccess, onError)
+        if (pendingPromise != null || pendingSuccessCallback != null) {
+            onError.invoke(buildErrorMap("ERR_ALREADY_IN_PROGRESS", "A DocV session is already in progress", null))
+            return
+        }
+        pendingSuccessCallback = onSuccess
+        pendingErrorCallback = onError
+        reactApplicationContext.addActivityEventListener(this)
+        SocureSdk.setSource(REACT_NATIVE)
         val activity = reactApplicationContext.currentActivity
         if (activity == null) {
             Log.e(TAG, "Aborting since app activity object is null")
+            reactApplicationContext.removeActivityEventListener(this)
+            onError.invoke(buildErrorMap("ERR_NO_ACTIVITY", "App activity is null", null))
+            pendingSuccessCallback = null
+            pendingErrorCallback = null
             return
         }
-        activity.run {
-            startActivityForResult(SocureSdk.getIntent(this), SOCURE_SDK_REQUEST_CODE)
-        }
+        activity.startActivityForResult(SocureSdk.getIntent(activity), SOCURE_SDK_REQUEST_CODE)
     }
 
+    // ── Callback-based API (legacy, preserved for easy migration) ────────────
+
     @ReactMethod
     fun launchSocureDocV(
-        verificationToken: String,
+        docVTransactionToken: String,
         publicKey: String,
         useSocureGov: Boolean,
         onSuccess: Callback,
         onError: Callback
     ) {
-        Log.d(TAG, "launchSocureDocV - launch Socure SDK")
-        setupLaunch(onSuccess, onError)
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) {
-            Log.e(TAG, "Aborting since app activity object is null")
+        if (pendingPromise != null || pendingSuccessCallback != null) {
+            onError.invoke(buildErrorMap("ERR_ALREADY_IN_PROGRESS", "A DocV session is already in progress", null))
             return
         }
+        Log.d(TAG, "launchSocureDocV (Callback) - launch Socure SDK")
+        pendingSuccessCallback = onSuccess
+        pendingErrorCallback = onError
+        startSdk(docVTransactionToken, publicKey, useSocureGov) {
+            onError.invoke(buildErrorMap("ERR_NO_ACTIVITY", "App activity is null", null))
+            pendingSuccessCallback = null
+            pendingErrorCallback = null
+        }
+    }
 
-        activity.run {
-            startActivityForResult(
-                SocureSdk.getIntent(
-                    this,
-                    SocureDocVContext(
-                        verificationToken,
-                        publicKey,
-                        useSocureGov,
-                        null,
-                        null
-                    )
-                ),
-                SOCURE_SDK_REQUEST_CODE
-            )
+    // ── Promise-based API (new) ───────────────────────────────────────────────
+
+    override fun launchSocureDocVWithPromise(
+        docVTransactionToken: String,
+        publicKey: String,
+        useSocureGov: Boolean,
+        promise: Promise
+    ) {
+        if (pendingPromise != null || pendingSuccessCallback != null) {
+            promise.reject("ERR_ALREADY_IN_PROGRESS", "A DocV session is already in progress")
+            return
+        }
+        Log.d(TAG, "launchSocureDocVWithPromise - launch Socure SDK")
+        pendingPromise = promise
+        startSdk(docVTransactionToken, publicKey, useSocureGov) {
+            promise.reject("ERR_NO_ACTIVITY", "App activity is null")
+            pendingPromise = null
         }
     }
 
-    private fun setupLaunch(onSuccess: Callback, onError: Callback) {
-        this.onSuccessCallback = onSuccess
-        this.onErrorCallback = onError
+    // ── Shared launch logic ──────────────────────────────────────────────────
 
-        Log.d(TAG, "launchSocureDocV - registering activity event listener")
+    private fun startSdk(
+        docVTransactionToken: String,
+        publicKey: String,
+        useSocureGov: Boolean,
+        onNoActivity: () -> Unit
+    ) {
         reactApplicationContext.addActivityEventListener(this)
         SocureSdk.setSource(REACT_NATIVE)
+
+        val activity = reactApplicationContext.currentActivity
+        if (activity == null) {
+            Log.e(TAG, "Aborting since app activity object is null")
+            reactApplicationContext.removeActivityEventListener(this)
+            onNoActivity()
+            return
+        }
+
+        activity.startActivityForResult(
+            SocureSdk.getIntent(
+                activity,
+                SocureDocVContext(docVTransactionToken, publicKey, useSocureGov, null, null)
+            ),
+            SOCURE_SDK_REQUEST_CODE
+        )
     }
 
     override fun onActivityResult(
@@ -99,54 +142,81 @@ class SocureDocVReactNativeModule(reactContext: ReactApplicationContext) :
         resultCode: Int,
         data: Intent?
     ) {
-        if (requestCode == SOCURE_SDK_REQUEST_CODE) {
-            data?.let {
-                getResult(it) { result ->
-                    Log.d(TAG, "onResult called: $result")
-                    if (result is SocureDocVSuccess) {
-                        onSuccessCallback?.invoke(convertResultToReadbleMap(result))
-                    } else {
-                        onErrorCallback?.invoke(convertResultToReadbleMap(result))
+        if (requestCode != SOCURE_SDK_REQUEST_CODE) {
+            Log.d(TAG, "onActivityResult - requestCode does not match: $requestCode")
+            return
+        }
+
+        data?.let {
+            getResult(it) { result ->
+                Log.d(TAG, "onResult called: $result")
+                if (result is SocureDocVSuccess) {
+                    val map = Arguments.createMap().apply {
+                        putString("deviceSessionToken", result.deviceSessionToken)
                     }
+                    pendingPromise?.resolve(map)
+                    pendingSuccessCallback?.invoke(map)
+                } else {
+                    val failure = result as SocureDocVFailure
+                    val code = getErrorCode(failure.error)
+                    val message = getErrorMessage(failure.error)
+                    pendingPromise?.reject(code, message)
+                    pendingErrorCallback?.invoke(buildErrorMap(code, message, failure.deviceSessionToken))
                 }
+                clearPending()
             }
-            Log.d(TAG, "onActivityResult - requestCode matched, removing activity event listener")
-            reactApplicationContext.removeActivityEventListener(this)
-        } else {
-            Log.d(
-                TAG,
-                "onActivityResult - requestCode does not match: $requestCode, not removing activity event listener"
-            )
+        } ?: run {
+            pendingPromise?.reject("ERR_NO_DATA", "No result data returned from SDK")
+            pendingErrorCallback?.invoke(buildErrorMap("ERR_NO_DATA", "No result data returned from SDK", null))
+            clearPending()
         }
+
+        Log.d(TAG, "onActivityResult - removing activity event listener")
+        reactApplicationContext.removeActivityEventListener(this)
     }
 
     override fun onNewIntent(intent: Intent) {}
 
-    private fun convertResultToReadbleMap(result: SocureResult): ReadableMap {
-        val docVResponse: WritableMap = Arguments.createMap()
-        if (result is SocureDocVSuccess) {
-            docVResponse.putString("deviceSessionToken", result.deviceSessionToken)
-        } else {
-            docVResponse.putString("deviceSessionToken", result.deviceSessionToken)
-            docVResponse.putString("error", getErrorMessage((result as SocureDocVFailure).error))
-        }
-        return docVResponse
+    private fun clearPending() {
+        pendingPromise = null
+        pendingSuccessCallback = null
+        pendingErrorCallback = null
     }
 
-    private fun getErrorMessage(socureDocVError: SocureDocVError): String{
-        when(socureDocVError){
+    private fun buildErrorMap(code: String, message: String, deviceSessionToken: String?): ReadableMap =
+        Arguments.createMap().apply {
+            putString("code", code)
+            putString("error", message)
+            deviceSessionToken?.let { putString("deviceSessionToken", it) }
+        }
 
-            SocureDocVError.NO_INTERNET_CONNECTION -> { return "No internet connection"}
-            SocureDocVError.SESSION_INITIATION_FAILURE -> {return "Failed to initiate the session"}
-            SocureDocVError.CAMERA_PERMISSION_DECLINED -> {return "Permissions to open the camera declined by the user"}
-            SocureDocVError.CONSENT_DECLINED -> {return "Consent declined by the user"}
-            SocureDocVError.DOCUMENT_UPLOAD_FAILURE -> {return "Failed to upload the documents"}
-            SocureDocVError.INVALID_DOCV_TRANSACTION_TOKEN -> {return "Invalid transaction token"}
-            SocureDocVError.INVALID_PUBLIC_KEY -> {return "Invalid or missing SDK key"}
-            SocureDocVError.SESSION_EXPIRED -> {return "Session expired"}
-            SocureDocVError.USER_CANCELED -> {return "Scan canceled by the user"}
-            else -> {return "Unknown error"}
+    private fun getErrorCode(socureDocVError: SocureDocVError): String {
+        return when (socureDocVError) {
+            SocureDocVError.NO_INTERNET_CONNECTION -> "ERR_NO_INTERNET"
+            SocureDocVError.SESSION_INITIATION_FAILURE -> "ERR_SESSION_INITIATION"
+            SocureDocVError.CAMERA_PERMISSION_DECLINED -> "ERR_CAMERA_PERMISSION"
+            SocureDocVError.CONSENT_DECLINED -> "ERR_CONSENT_DECLINED"
+            SocureDocVError.DOCUMENT_UPLOAD_FAILURE -> "ERR_UPLOAD_FAILURE"
+            SocureDocVError.INVALID_DOCV_TRANSACTION_TOKEN -> "ERR_INVALID_TOKEN"
+            SocureDocVError.INVALID_PUBLIC_KEY -> "ERR_INVALID_KEY"
+            SocureDocVError.SESSION_EXPIRED -> "ERR_SESSION_EXPIRED"
+            SocureDocVError.USER_CANCELED -> "ERR_USER_CANCELED"
+            else -> "ERR_UNKNOWN"
+        }
+    }
 
+    private fun getErrorMessage(socureDocVError: SocureDocVError): String {
+        return when (socureDocVError) {
+            SocureDocVError.NO_INTERNET_CONNECTION -> "No internet connection"
+            SocureDocVError.SESSION_INITIATION_FAILURE -> "Failed to initiate the session"
+            SocureDocVError.CAMERA_PERMISSION_DECLINED -> "Permissions to open the camera declined by the user"
+            SocureDocVError.CONSENT_DECLINED -> "Consent declined by the user"
+            SocureDocVError.DOCUMENT_UPLOAD_FAILURE -> "Failed to upload the documents"
+            SocureDocVError.INVALID_DOCV_TRANSACTION_TOKEN -> "Invalid transaction token"
+            SocureDocVError.INVALID_PUBLIC_KEY -> "Invalid or missing SDK key"
+            SocureDocVError.SESSION_EXPIRED -> "Session expired"
+            SocureDocVError.USER_CANCELED -> "Scan canceled by the user"
+            else -> "Unknown error"
         }
     }
-}
+}

package/android/src/main/java/com/socure/docv/reactnative/SocureDocVReactNativePackage.kt

@@ -1,17 +1,31 @@
 package com.socure.docv.reactnative
 
-import com.facebook.react.ReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
 
+class SocureDocVReactNativePackage : BaseReactPackage() {
+    override fun getModule(name: String, context: ReactApplicationContext): NativeModule? =
+        if (name == SocureDocVReactNativeModule.NAME)
+            SocureDocVReactNativeModule(context)
+        else null
 
-class SocureDocVReactNativePackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(SocureDocVReactNativeModule(reactContext))
+    override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+        mapOf(
+            SocureDocVReactNativeModule.NAME to ReactModuleInfo(
+                SocureDocVReactNativeModule.NAME,
+                SocureDocVReactNativeModule.NAME,
+                false,
+                false,
+                false,
+                BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+            )
+        )
     }
 
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
-    }
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
 }

package/android/src/oldarch/com/socure/docv/reactnative/NativeSocureDocVReactNativeSpec.kt

@@ -0,0 +1,17 @@
+package com.socure.docv.reactnative
+
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+
+abstract class NativeSocureDocVReactNativeSpec(context: ReactApplicationContext) :
+    ReactContextBaseJavaModule(context) {
+
+    abstract fun launchSocureDocVWithPromise(
+        docVTransactionToken: String,
+        publicKey: String,
+        useSocureGov: Boolean,
+        promise: Promise,
+    )
+}

package/ios/SocureDocVReactNative-Bridging-Header.h

@@ -3,3 +3,4 @@
 #import <React/RCTBridge.h>
 #import <React/RCTEventDispatcher.h>
 #import <React/RCTUtils.h>
+#import <ReactCommon/RCTTurboModule.h>

package/ios/SocureDocVReactNative.mm

@@ -0,0 +1,68 @@
+#import <React/RCTBridgeModule.h>
+#import "socure_docv_react_native-Swift.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <ReactCommon/RCTTurboModule.h>
+#import <SocureDocVReactNative/SocureDocVReactNative.h>
+
+@interface SocureDocVReactNative : NSObject <NativeSocureDocVReactNativeSpec>
+@end
+
+@implementation SocureDocVReactNative
+
+RCT_EXPORT_MODULE()
+
+// Promise-based API (new)
+- (void)launchSocureDocVWithPromise:(NSString *)docVTransactionToken
+                          publicKey:(NSString *)publicKey
+                       useSocureGov:(BOOL)useSocureGov
+                            resolve:(RCTPromiseResolveBlock)resolve
+                             reject:(RCTPromiseRejectBlock)reject {
+  [SocureDocVHelper launchWithPromiseToken:docVTransactionToken
+                                    apiKey:publicKey
+                              useSocureGov:useSocureGov
+                                   resolve:resolve
+                                    reject:reject];
+}
+
+// Callback-based API (legacy)
+RCT_EXPORT_METHOD(launchSocureDocV:(NSString *)docVTransactionToken
+                  publicKey:(NSString *)publicKey
+                  useSocureGov:(BOOL)useSocureGov
+                  onSuccess:(RCTResponseSenderBlock)onSuccess
+                  onError:(RCTResponseSenderBlock)onError) {
+  [SocureDocVHelper launchWithToken:docVTransactionToken
+                             apiKey:publicKey
+                       useSocureGov:useSocureGov
+                          onSuccess:onSuccess
+                            onError:onError];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeSocureDocVReactNativeSpecJSI>(params);
+}
+
+@end
+
+#else // Old Architecture
+
+@interface RCT_EXTERN_MODULE(SocureDocVReactNative, NSObject)
+
+// Promise-based API (new)
+RCT_EXTERN_METHOD(launchSocureDocVWithPromise:(NSString)docVTransactionToken
+                  publicKey:(NSString)publicKey
+                  useSocureGov:(BOOL)useSocureGov
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+// Callback-based API (legacy)
+RCT_EXTERN_METHOD(launchSocureDocV:(NSString)docVTransactionToken
+                  publicKey:(NSString)publicKey
+                  useSocureGov:(BOOL)useSocureGov
+                  onSuccess:(RCTResponseSenderBlock)onSuccess
+                  onError:(RCTResponseSenderBlock)onError)
+
+@end
+
+#endif

package/ios/SocureDocVReactNative.swift

@@ -1,75 +1,109 @@
 import SocureDocV
 
-@objc(SocureDocVReactNative)
-class SocureDocVReactNative: NSObject, RCTBridgeModule {
+@objc(SocureDocVHelper)
+class SocureDocVHelper: NSObject {
 
-    @objc(launchSocureDocV:socureApiKey:useSocureGov:onSuccess:onError:)
-    func launchSocureDocV(docVTransactionToken: String,
-                          socureApiKey: String,
-                          useSocureGov: Bool,
-                          onSuccess: @escaping RCTResponseSenderBlock,
-                          onError: @escaping RCTResponseSenderBlock) -> Void {
+  // Promise-based API (new)
+  @objc static func launch(
+    withPromiseToken docVTransactionToken: String,
+    apiKey socureApiKey: String,
+    useSocureGov: Bool,
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    DispatchQueue.main.async {
+      guard let root = RCTPresentedViewController() else {
+        reject("ERR_NO_VIEW_CONTROLLER", "Failed to get root view controller", nil)
+        return
+      }
 
-        DispatchQueue.main.async {
-            guard let root = RCTPresentedViewController() else {
-                onError([["error": "Failed to get the root view controller"]])
-                return
-            }
-
-            let options = SocureDocVOptions(
-                publicKey: socureApiKey,
-                docvTransactionToken: docVTransactionToken,
-                presentingViewController: root,
-                useSocureGov: useSocureGov
-            )
+      let options = SocureDocVOptions(
+        publicKey: socureApiKey,
+        docvTransactionToken: docVTransactionToken,
+        presentingViewController: root,
+        useSocureGov: useSocureGov
+      )
 
-            SocureDocVSDK.launch(options) { result in
-                DispatchQueue.main.async {
-                    switch result {
-                    case .success(let success):
-                        onSuccess([["deviceSessionToken": success.deviceSessionToken]])
-                    case .failure(let failure):
-                        let errorMessage = self.getErrorMessage(from: failure.error)
-                        onError([["error": errorMessage,
-                                  "deviceSessionToken": failure.deviceSessionToken]])
-                    }
-                }
-            }
+      SocureDocVSDK.launch(options) { result in
+        DispatchQueue.main.async {
+          switch result {
+          case .success(let success):
+            resolve(["deviceSessionToken": success.deviceSessionToken])
+          case .failure(let failure):
+            let code = SocureDocVHelper.errorCode(from: failure.error)
+            let message = SocureDocVHelper.errorMessage(from: failure.error)
+            reject(code, message, nil)
+          }
         }
+      }
     }
+  }
+
+  // Callback-based API (legacy)
+  @objc static func launch(
+    withToken docVTransactionToken: String,
+    apiKey socureApiKey: String,
+    useSocureGov: Bool,
+    onSuccess: @escaping RCTResponseSenderBlock,
+    onError: @escaping RCTResponseSenderBlock
+  ) {
+    DispatchQueue.main.async {
+      guard let root = RCTPresentedViewController() else {
+        onError([["code": "ERR_NO_VIEW_CONTROLLER", "error": "Failed to get root view controller"]])
+        return
+      }
 
-    static func requiresMainQueueSetup() -> Bool {
-        return true
+      let options = SocureDocVOptions(
+        publicKey: socureApiKey,
+        docvTransactionToken: docVTransactionToken,
+        presentingViewController: root,
+        useSocureGov: useSocureGov
+      )
+
+      SocureDocVSDK.launch(options) { result in
+        DispatchQueue.main.async {
+          switch result {
+          case .success(let success):
+            onSuccess([["deviceSessionToken": success.deviceSessionToken]])
+          case .failure(let failure):
+            let code = SocureDocVHelper.errorCode(from: failure.error)
+            let message = SocureDocVHelper.errorMessage(from: failure.error)
+            onError([["code": code, "error": message, "deviceSessionToken": failure.deviceSessionToken]])
+          }
+        }
+      }
     }
+  }
 
-    static func moduleName() -> String! {
-        return "SocureDocVReactNative"
+  private static func errorCode(from error: SocureDocVError) -> String {
+    switch error {
+    case .noInternetConnection: return "ERR_NO_INTERNET"
+    case .sessionInitiationFailure: return "ERR_SESSION_INITIATION"
+    case .cameraPermissionDeclined: return "ERR_CAMERA_PERMISSION"
+    case .consentDeclined: return "ERR_CONSENT_DECLINED"
+    case .documentUploadFailure: return "ERR_UPLOAD_FAILURE"
+    case .invalidDocvTransactionToken: return "ERR_INVALID_TOKEN"
+    case .invalidPublicKey: return "ERR_INVALID_KEY"
+    case .sessionExpired: return "ERR_SESSION_EXPIRED"
+    case .userCanceled: return "ERR_USER_CANCELED"
+    case .unknown: fallthrough
+    @unknown default: return "ERR_UNKNOWN"
     }
+  }
 
-    func getErrorMessage(from error: SocureDocVError) -> String {
-        switch error {
-        case .noInternetConnection:
-            return "No internet connection"
-        case .sessionInitiationFailure:
-            return "Failed to initiate the session"
-        case .cameraPermissionDeclined:
-            return "Permissions to open the camera declined by the user"
-        case .consentDeclined:
-            return "Consent declined by the user"
-        case .documentUploadFailure:
-            return "Failed to upload the documents"
-        case .invalidDocvTransactionToken:
-            return "Invalid transaction token"
-        case .invalidPublicKey:
-            return "Invalid or missing SDK key"
-        case .sessionExpired:
-            return "Session expired"
-        case .userCanceled:
-            return "Scan canceled by the user"
-        case .unknown:
-            fallthrough
-        @unknown default:
-            return "Unknown error"
-        }
+  private static func errorMessage(from error: SocureDocVError) -> String {
+    switch error {
+    case .noInternetConnection: return "No internet connection"
+    case .sessionInitiationFailure: return "Failed to initiate the session"
+    case .cameraPermissionDeclined: return "Permissions to open the camera declined by the user"
+    case .consentDeclined: return "Consent declined by the user"
+    case .documentUploadFailure: return "Failed to upload the documents"
+    case .invalidDocvTransactionToken: return "Invalid transaction token"
+    case .invalidPublicKey: return "Invalid or missing SDK key"
+    case .sessionExpired: return "Session expired"
+    case .userCanceled: return "Scan canceled by the user"
+    case .unknown: fallthrough
+    @unknown default: return "Unknown error"
     }
+  }
 }

package/lib/commonjs/NativeSocureDocVReactNative.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('SocureDocVReactNative');
+//# sourceMappingURL=NativeSocureDocVReactNative.js.map

package/lib/commonjs/NativeSocureDocVReactNative.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sources":["NativeSocureDocVReactNative.ts"],"sourcesContent":["import type { TurboModule } from 'react-native';\nimport { TurboModuleRegistry } from 'react-native';\n\nexport type DocVResult = {\n  deviceSessionToken: string;\n};\n\nexport interface Spec extends TurboModule {\n  launchSocureDocVWithPromise(\n    docVTransactionToken: string,\n    publicKey: string,\n    useSocureGov: boolean\n  ): Promise<DocVResult>;\n}\n\nexport default TurboModuleRegistry.getEnforcing<Spec>('SocureDocVReactNative');\n"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAcpCC,gCAAmB,CAACC,YAAY,CAAO,uBAAuB,CAAC","ignoreList":[]}

package/lib/commonjs/index.js

@@ -4,7 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.launchSocureDocV = launchSocureDocV;
+exports.launchSocureDocVWithPromise = launchSocureDocVWithPromise;
 var _reactNative = require("react-native");
+var _NativeSocureDocVReactNative = _interopRequireDefault(require("./NativeSocureDocVReactNative"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// ── Callback-based API (legacy, preserved for easy migration) ────────────────
+
 const LINKING_ERROR = `The package '@socure-inc/docv-react-native' doesn't seem to be linked.\n\n` + '- Rebuilt the app after installing the package';
 const SocureDocVReactNative = _reactNative.NativeModules.SocureDocVReactNative ? _reactNative.NativeModules.SocureDocVReactNative : new Proxy({}, {
   get() {
@@ -12,6 +17,20 @@ const SocureDocVReactNative = _reactNative.NativeModules.SocureDocVReactNative ?
   }
 });
 function launchSocureDocV(docVTransactionToken, publicKey, useSocureGov, onSuccess, onError) {
-  return SocureDocVReactNative.launchSocureDocV(docVTransactionToken, publicKey, useSocureGov, onSuccess, onError);
+  // Under New Architecture, NativeModules may not expose the callback method.
+  // Fall back to the TurboModule promise API so callbacks still work.
+  if (typeof SocureDocVReactNative.launchSocureDocV === 'function') {
+    return SocureDocVReactNative.launchSocureDocV(docVTransactionToken, publicKey, useSocureGov, onSuccess, onError);
+  }
+  _NativeSocureDocVReactNative.default.launchSocureDocVWithPromise(docVTransactionToken, publicKey, useSocureGov).then(result => onSuccess(result)).catch(err => onError({
+    code: err.code,
+    error: err.message
+  }));
+}
+
+// ── Promise-based API (new) ──────────────────────────────────────────────────
+
+function launchSocureDocVWithPromise(docVTransactionToken, publicKey, useSocureGov) {
+  return _NativeSocureDocVReactNative.default.launchSocureDocVWithPromise(docVTransactionToken, publicKey, useSocureGov);
 }
 //# sourceMappingURL=index.js.map