react-native-nami-sdk 3.3.2-4 → 3.3.2-5

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,16 @@
-<manifest package="com.namiml.reactnative">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.namiml.reactnative">
 
+
+    <application>
+        <activity
+            android:name=".ReactOverlayActivity"
+            android:theme="@style/Theme.TransparentReact"
+            android:exported="false"
+            android:launchMode="singleTop"
+            android:taskAffinity=""
+            android:noHistory="true"
+            android:excludeFromRecents="true"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenSize|uiMode" />
+    </application>
 </manifest>

package/android/src/main/java/com/namiml/reactnative/NamiBridgePackage.java

@@ -29,6 +29,8 @@ public class NamiBridgePackage extends TurboReactPackage {
             case NamiPaywallManagerBridgeModule.NAME -> new NamiPaywallManagerBridgeModule(context);
             case NamiPurchaseManagerBridgeModule.NAME ->
                     new NamiPurchaseManagerBridgeModule(context);
+            case NamiOverlayControlBridgeModule.NAME ->
+                    new NamiOverlayControlBridgeModule(context);
             default -> null;
         };
     }
@@ -129,6 +131,19 @@ public class NamiBridgePackage extends TurboReactPackage {
                             BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
                     )
             );
+
+            moduleInfos.put(
+                    NamiOverlayControlBridgeModule.NAME,
+                    new ReactModuleInfo(
+                            NamiOverlayControlBridgeModule.NAME,
+                            NamiOverlayControlBridgeModule.NAME,
+                            false,
+                            false,
+                            true,
+                            false,
+                            BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+                    )
+            );
             return moduleInfos;
         };
     }

package/android/src/main/java/com/namiml/reactnative/NamiFlowManagerBridge.kt

@@ -4,39 +4,40 @@ import android.os.Handler
 import android.os.Looper
 import android.util.Log
 import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.turbomodule.core.interfaces.TurboModule
 import com.namiml.flow.NamiFlowManager
 
 @ReactModule(name = NamiFlowManagerBridgeModule.NAME)
 class NamiFlowManagerBridgeModule internal constructor(
-    reactContext: ReactApplicationContext
-) : ReactContextBaseJavaModule(reactContext), TurboModule {
-
+    reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext),
+    TurboModule {
     companion object {
         const val NAME = "RNNamiFlowManager"
     }
 
-    override fun getName(): String {
-        return NAME
-    }
+    override fun getName(): String = NAME
 
     @ReactMethod
     fun registerStepHandoff() {
         NamiFlowManager.registerStepHandoff { handoffTag, handoffData ->
-            val payload = Arguments.createMap().apply {
-                putString("handoffTag", handoffTag)
-                if (handoffData != null) {
-                    try {
-                        val map = Arguments.makeNativeMap(handoffData)
-                        putMap("handoffData", map)
-                    } catch (e: Exception) {
-                        Log.d(NAME, "Failed to convert handoffData to NativeMap: ${e.localizedMessage}")
+            val payload =
+                Arguments.createMap().apply {
+                    putString("handoffTag", handoffTag)
+                    if (handoffData != null) {
+                        try {
+                            putMap("handoffData", Arguments.makeNativeMap(handoffData))
+                        } catch (e: Exception) {
+                            Log.d(NAME, "Failed to convert handoffData to NativeMap: ${e.localizedMessage}")
+                        }
                     }
                 }
+
+            reactApplicationContext.runOnUiQueueThread {
+                sendEvent("Handoff", payload)
             }
-            sendEvent("Handoff", payload)
         }
     }
 
@@ -74,7 +75,10 @@ class NamiFlowManagerBridgeModule internal constructor(
         promise.resolve(NamiFlowManager.isFlowOpen())
     }
 
-    private fun sendEvent(eventName: String, params: WritableMap?) {
+    private fun sendEvent(
+        eventName: String,
+        params: WritableMap?,
+    ) {
         reactApplicationContext
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
             .emit(eventName, params)
@@ -82,5 +86,6 @@ class NamiFlowManagerBridgeModule internal constructor(
 
     // Required for RN EventEmitter support
     @ReactMethod fun addListener(eventName: String?) {}
+
     @ReactMethod fun removeListeners(count: Int?) {}
 }

package/android/src/main/java/com/namiml/reactnative/NamiOverlayControlBridge.kt

@@ -0,0 +1,171 @@
+package com.namiml.reactnative
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import com.facebook.react.bridge.UiThreadUtil
+
+@ReactModule(name = NamiOverlayControlBridgeModule.NAME)
+class NamiOverlayControlBridgeModule(private val ctx: ReactApplicationContext)
+  : ReactContextBaseJavaModule(ctx), TurboModule {
+
+  companion object {
+    const val NAME = "RNNamiOverlayControl"
+    var currentOverlayActivity: ReactOverlayActivity? = null
+    var lastValidActivity: Activity? = null
+  }
+
+  override fun getName() = NAME
+
+  @ReactMethod
+  fun presentOverlay(promise: Promise) {
+    var theActivity: Activity? = null
+    if (reactApplicationContext.hasCurrentActivity()) {
+      theActivity = reactApplicationContext.currentActivity
+
+      // Check if it's the overlay activity that's finishing
+      if (theActivity is ReactOverlayActivity) {
+        if (theActivity.isFinishing || theActivity.isDestroyed) {
+          theActivity = lastValidActivity
+          if (theActivity == null || theActivity.isFinishing || theActivity.isDestroyed) {
+            promise.reject("NO_ACTIVITY", "No valid activity available")
+            return
+          }
+        } else {
+          lastValidActivity = theActivity
+        }
+      } else {
+        lastValidActivity = theActivity
+      }
+    } else {
+      theActivity = lastValidActivity
+      if (theActivity == null || theActivity.isFinishing || theActivity.isDestroyed) {
+        promise.reject("NO_ACTIVITY", "No valid activity available")
+        return
+      }
+    }
+
+    if (theActivity == null) {
+      promise.reject("NO_ACTIVITY", "No activity available")
+      return
+    }
+
+    startOverlayActivity(theActivity, promise)
+  }
+
+  private fun startOverlayActivity(activity: Activity, promise: Promise) {
+    try {
+      UiThreadUtil.runOnUiThread {
+        try {
+          val intent = Intent(activity, ReactOverlayActivity::class.java)
+          intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)
+          activity.startActivity(intent)
+          // Use modern transition API for Android 14+ (API 34+)
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            activity.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN, 0, 0)
+          } else {
+            @Suppress("DEPRECATION")
+            activity.overridePendingTransition(0, 0)
+          }
+
+          // Emit ready event after a short delay to ensure activity is started
+          android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+            try {
+              if (ctx.catalystInstance != null) {
+                ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                  .emit("NamiOverlayReady", null)
+              }
+            } catch (e: Exception) {
+              Log.e(NAME, "Failed to emit NamiOverlayReady: ${e.message}")
+            }
+          }, 100)
+
+          promise.resolve(null)
+        } catch (uiError: Exception) {
+          Log.e(NAME, "Error in UI thread: ${uiError.message}", uiError)
+          promise.reject("UI_THREAD_ERROR", "Failed in UI thread: ${uiError.message}", uiError)
+        }
+      }
+    } catch (e: Exception) {
+      Log.e(NAME, "Error presenting overlay: ${e.message}", e)
+      promise.reject("PRESENT_OVERLAY_ERROR", "Failed to present overlay: ${e.message}", e)
+    }
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String?) {
+    // Required for NativeEventEmitter - no-op since we emit events directly
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int?) {
+    // Required for NativeEventEmitter - no-op since we emit events directly
+  }
+
+  @ReactMethod
+  fun finishOverlay(result: ReadableMap?, promise: Promise) {
+    try {
+      // Emit result to main app listeners
+      val payload: WritableMap = Arguments.createMap().apply {
+        if (result != null) {
+          merge(result)
+        }
+      }
+      try {
+        if (ctx.catalystInstance != null) {
+          ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("NamiOverlayResult", payload)
+        }
+      } catch (e: Exception) {
+        Log.e(NAME, "Failed to emit NamiOverlayResult: ${e.message}")
+      }
+
+      UiThreadUtil.runOnUiThread {
+        // Try to finish the tracked overlay activity first
+        currentOverlayActivity?.let { overlay ->
+          overlay.finish()
+          // Use modern transition API for Android 14+ (API 34+)
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            overlay.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE, 0, 0)
+          } else {
+            @Suppress("DEPRECATION")
+            overlay.overridePendingTransition(0, 0)
+          }
+          currentOverlayActivity = null
+
+          // Wait for activity to actually finish before resolving promise
+          android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+            promise.resolve(null)
+          }, 100)
+        } ?: run {
+          // Fallback to current activity if it's an overlay
+          (ctx.currentActivity as? ReactOverlayActivity)?.apply {
+            finish()
+            // Use modern transition API for Android 14+ (API 34+)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+              overrideActivityTransition(Activity.OVERRIDE_TRANSITION_CLOSE, 0, 0)
+            } else {
+              @Suppress("DEPRECATION")
+              overridePendingTransition(0, 0)
+            }
+
+            // Wait for activity to actually finish before resolving promise
+            android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+              promise.resolve(null)
+            }, 100)
+          } ?: run {
+            promise.resolve(null)
+          }
+        }
+      }
+    } catch (e: Exception) {
+      Log.e(NAME, "Failed to finish overlay: ${e.message}", e)
+      promise.reject("FINISH_OVERLAY_ERROR", "Failed to finish overlay", e)
+    }
+  }
+}

package/android/src/main/java/com/namiml/reactnative/ReactOverlayActivity.kt

@@ -0,0 +1,29 @@
+package com.namiml.reactnative
+
+import android.os.Bundle
+import com.facebook.react.ReactActivity
+
+class ReactOverlayActivity : ReactActivity() {
+  override fun getMainComponentName(): String = "NamiOverlayHost"
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    overridePendingTransition(0, 0)
+
+    // Register this activity with the bridge module
+    NamiOverlayControlBridgeModule.currentOverlayActivity = this
+  }
+
+  override fun onBackPressed() {
+    finish()
+    overridePendingTransition(0, 0)
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    // Clear the reference when activity is destroyed
+    if (NamiOverlayControlBridgeModule.currentOverlayActivity == this) {
+      NamiOverlayControlBridgeModule.currentOverlayActivity = null
+    }
+  }
+}

package/android/src/main/res/values/styles.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.TransparentReact" parent="Theme.MaterialComponents.DayNight.NoActionBar">
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowNoTitle">true</item>
+        <item name="android:statusBarColor">@android:color/transparent</item>
+        <item name="android:navigationBarColor">@android:color/transparent</item>
+    </style>
+</resources>

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export { NamiEntitlementManager } from './src/NamiEntitlementManager';
 export { NamiPurchaseManager } from './src/NamiPurchaseManager';
 export { NamiPaywallManager } from './src/NamiPaywallManager';
 export { NamiFlowManager } from './src/NamiFlowManager';
+export { NamiOverlayControl } from './src/NamiOverlayControl';
 export * from './src/types';

package/dist/specs/NativeNamiOverlayControl.d.ts

@@ -0,0 +1,9 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    presentOverlay(): Promise<void>;
+    finishOverlay(result?: {
+        [key: string]: unknown;
+    } | null): Promise<void>;
+}
+declare const _default: Spec;
+export default _default;

package/dist/src/NamiOverlayControl.d.ts

@@ -0,0 +1,9 @@
+import { NativeEventEmitter } from 'react-native';
+export declare const NamiOverlayControl: {
+    emitter: NativeEventEmitter;
+    presentOverlay(): Promise<void>;
+    finishOverlay(result?: any): Promise<void>;
+    onOverlayReady(handler: () => void): () => void;
+    onOverlayResult(handler: (result: any) => void): () => void;
+};
+export default function NamiOverlayHost(): any;

package/dist/src/NamiOverlayHost.d.ts

@@ -0,0 +1 @@
+export default function NamiOverlayHost(): null;

package/dist/src/overlay.d.ts

@@ -0,0 +1,4 @@
+export declare function presentOverlay(): Promise<void>;
+export declare function finishOverlay(result?: any): Promise<void>;
+export declare function onOverlayReady(handler: () => void): () => void;
+export declare function onOverlayResult(handler: (result: any) => void): () => void;

package/dist/src/registerOverlay.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/version.d.ts

@@ -2,4 +2,4 @@
  * Auto-generated file. Do not edit manually.
  * React Native Nami SDK version.
  */
-export declare const NAMI_REACT_NATIVE_VERSION = "3.3.2-4";
+export declare const NAMI_REACT_NATIVE_VERSION = "3.3.2-5";

package/index.ts

@@ -5,4 +5,5 @@ export { NamiEntitlementManager } from './src/NamiEntitlementManager';
 export { NamiPurchaseManager } from './src/NamiPurchaseManager';
 export { NamiPaywallManager } from './src/NamiPaywallManager';
 export { NamiFlowManager } from './src/NamiFlowManager';
+export { NamiOverlayControl } from './src/NamiOverlayControl';
 export * from './src/types';

package/ios/Nami.swift

@@ -8,9 +8,9 @@ import Foundation
 import NamiApple
 import React
 
-// #if RCT_NEW_ARCH_ENABLED
-//    extension RNNami: RCTTurboModule {}
-// #endif
+#if RCT_NEW_ARCH_ENABLED
+    extension RNNami: RCTTurboModule {}
+#endif
 
 @objc(RNNami)
 class RNNami: NSObject {

package/ios/NamiCampaignManagerBridge.swift

@@ -10,9 +10,9 @@ import NamiApple
 import os
 import React
 
-// #if RCT_NEW_ARCH_ENABLED
-//    extension RNNamiCampaignManager: RCTTurboModule {}
-// #endif
+#if RCT_NEW_ARCH_ENABLED
+    extension RNNamiCampaignManager: RCTTurboModule {}
+#endif
 
 @objc(RNNamiCampaignManager)
 class RNNamiCampaignManager: RCTEventEmitter {

package/ios/NamiCustomerManager.swift

@@ -9,9 +9,9 @@ import Foundation
 import NamiApple
 import React
 
-// #if RCT_NEW_ARCH_ENABLED
-//    extension RNNamiCustomerManager: RCTTurboModule {}
-// #endif
+#if RCT_NEW_ARCH_ENABLED
+    extension RNNamiCustomerManager: RCTTurboModule {}
+#endif
 
 @objc(RNNamiCustomerManager)
 class RNNamiCustomerManager: RCTEventEmitter {

package/ios/NamiEntitlementManagerBridge.swift

@@ -9,9 +9,9 @@ import Foundation
 import NamiApple
 import React
 
-// #if RCT_NEW_ARCH_ENABLED
-//     extension RNNamiEntitlementManager: RCTTurboModule {}
-// #endif
+#if RCT_NEW_ARCH_ENABLED
+    extension RNNamiEntitlementManager: RCTTurboModule {}
+#endif
 
 @objc(RNNamiEntitlementManager)
 class RNNamiEntitlementManager: RCTEventEmitter {

package/ios/NamiFlowManagerBridge.swift

@@ -9,9 +9,9 @@ import Foundation
 import NamiApple
 import React
 
-// #if RCT_NEW_ARCH_ENABLED
-//     extension RNNamiFlowManager: RCTTurboModule {}
-// #endif
+#if RCT_NEW_ARCH_ENABLED
+    extension RNNamiFlowManager: RCTTurboModule {}
+#endif
 
 @objc(RNNamiFlowManager)
 class RNNamiFlowManager: RCTEventEmitter {

package/ios/NamiOverlayControlBridge.m

@@ -0,0 +1,17 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(RNNamiOverlayControl, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(presentOverlay:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(finishOverlay:(NSDictionary *)result
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+@end

package/ios/NamiOverlayControlBridge.swift

@@ -0,0 +1,136 @@
+import Foundation
+import React
+import UIKit
+
+#if RCT_NEW_ARCH_ENABLED
+    extension RNNamiPaywallManager: RCTTurboModule {}
+#endif
+
+@objc(RNNamiOverlayControl)
+class NamiOverlayControlBridge: RCTEventEmitter {
+    private var overlayViewController: UIViewController?
+    private var hasListeners = false
+    private var isPresenting = false
+    private var isDismissing = false
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    override func supportedEvents() -> [String]! {
+        return ["NamiOverlayReady", "NamiOverlayResult"]
+    }
+
+    override func startObserving() { hasListeners = true }
+    override func stopObserving() { hasListeners = false }
+
+    private func safeSend(withName name: String, body: Any?) {
+        guard hasListeners else {
+            print("[RNNamiOverlayControl] Warning: no listeners, so event not being sent to JS.")
+            return
+        }
+        sendEvent(withName: name, body: body)
+    }
+
+    @objc func presentOverlay(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            // If we're already presenting or dismissing, wait and retry
+            if self.isPresenting || self.isDismissing {
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+                    self.presentOverlay(resolve, rejecter: reject)
+                }
+                return
+            }
+
+            // Find the root view controller more reliably
+            var rootViewController: UIViewController?
+
+            if #available(iOS 13.0, *) {
+                rootViewController = UIApplication.shared.connectedScenes
+                    .compactMap { $0 as? UIWindowScene }
+                    .flatMap { $0.windows }
+                    .first(where: { $0.isKeyWindow })?.rootViewController
+            } else {
+                rootViewController = UIApplication.shared.keyWindow?.rootViewController
+            }
+
+            guard let rootVC = rootViewController else {
+                reject("NO_ROOT_VIEW_CONTROLLER", "No root view controller available", nil)
+                return
+            }
+
+            // Create a React Native view controller for the overlay
+            guard let bridge = self.bridge else {
+                reject("NO_BRIDGE", "React Native bridge not available", nil)
+                return
+            }
+
+            let rootView = RCTRootView(
+                bridge: bridge,
+                moduleName: "NamiOverlayHost",
+                initialProperties: [:]
+            )
+
+            let overlayViewController = UIViewController()
+            overlayViewController.view = rootView
+            overlayViewController.modalPresentationStyle = .overFullScreen
+            overlayViewController.modalTransitionStyle = .crossDissolve
+            overlayViewController.view.backgroundColor = UIColor.clear
+
+            self.overlayViewController = overlayViewController
+
+            // Find the top-most presented view controller
+            var topController = rootVC
+            while let presented = topController.presentedViewController {
+                topController = presented
+            }
+
+            // Check if the top controller can present (not already in the process of presenting/dismissing)
+            if topController.isBeingPresented || topController.isBeingDismissed {
+                // Wait longer and try again
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                    self.presentOverlay(resolve, rejecter: reject)
+                }
+                return
+            }
+
+            self.isPresenting = true
+
+            topController.present(overlayViewController, animated: false) {
+                self.isPresenting = false
+                // Emit ready event after presentation completes
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+                    if self.hasListeners {
+                        self.safeSend(withName: "NamiOverlayReady", body: nil)
+                    }
+                }
+                resolve(nil)
+            }
+        }
+    }
+
+    @objc func finishOverlay(_ result: NSDictionary?, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter _: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            guard let overlayViewController = self.overlayViewController else {
+                resolve(nil)
+                return
+            }
+
+            // Emit result to listeners
+            if self.hasListeners {
+                self.safeSend(withName: "NamiOverlayResult", body: result)
+            }
+
+            self.isDismissing = true
+
+            overlayViewController.dismiss(animated: false) {
+                self.overlayViewController = nil
+                self.isDismissing = false
+                // Add a longer delay before resolving to ensure the view controller is fully dismissed
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+                    resolve(nil)
+                }
+            }
+        }
+    }
+}

package/ios/NamiPaywallManagerBridge.swift

@@ -9,9 +9,9 @@ import Foundation
 import NamiApple
 import React
 
-// #if RCT_NEW_ARCH_ENABLED
-//     extension RNNamiPaywallManager: RCTTurboModule {}
-// #endif
+#if RCT_NEW_ARCH_ENABLED
+    extension RNNamiPaywallManager: RCTTurboModule {}
+#endif
 
 @objc(RNNamiPaywallManager)
 class RNNamiPaywallManager: RCTEventEmitter {

package/ios/NamiPurchaseManagerBridge.swift

@@ -9,9 +9,9 @@ import Foundation
 import NamiApple
 import React
 
-// #if RCT_NEW_ARCH_ENABLED
-//     extension RNNamiPurchaseManager: RCTTurboModule {}
-// #endif
+#if RCT_NEW_ARCH_ENABLED
+    extension RNNamiPurchaseManager: RCTTurboModule {}
+#endif
 
 @objc(RNNamiPurchaseManager)
 class RNNamiPurchaseManager: RCTEventEmitter {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nami-sdk",
-  "version": "3.3.2-4",
+  "version": "3.3.2-5",
   "description": "React Native Module for Nami - Easy subscriptions & in-app purchases, with powerful built-in paywalls and A/B testing.",
   "main": "index.ts",
   "types": "dist/index.d.ts",
@@ -12,6 +12,13 @@
       "javaPackageName": "com.namiml.reactnative"
     }
   },
+  "react-native": {
+    "android": {
+      "sourceDir": "android",
+      "packageImportPath": "com.namiml.reactnative.NamiBridgePackage",
+      "libraryName": "react-native-nami-sdk"
+    }
+  },
   "scripts": {
     "build": "tsc",
     "generate:version": "ts-node scripts/generate-version.ts",

package/specs/NativeNamiOverlayControl.ts

@@ -0,0 +1,9 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  presentOverlay(): Promise<void>;
+  finishOverlay(result?: { [key: string]: unknown } | null): Promise<void>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNNamiOverlayControl');

package/src/NamiOverlayControl.tsx

@@ -0,0 +1,48 @@
+import { AppRegistry, View, StyleSheet } from 'react-native';
+import {
+  TurboModuleRegistry,
+  NativeModules,
+  NativeEventEmitter,
+} from 'react-native';
+import type { Spec } from '../specs/NativeNamiOverlayControl';
+
+const RNNamiOverlayControl: Spec =
+  TurboModuleRegistry.getEnforcing?.<Spec>('RNNamiOverlayControl') ??
+  NativeModules.RNNamiOverlayControl;
+
+const emitter = new NativeEventEmitter(NativeModules.RNNamiOverlayControl);
+
+export const NamiOverlayControl = {
+  emitter,
+
+  presentOverlay(): Promise<void> {
+    return RNNamiOverlayControl.presentOverlay();
+  },
+
+  finishOverlay(result?: any): Promise<void> {
+    return RNNamiOverlayControl.finishOverlay(result ?? null);
+  },
+
+  onOverlayReady(handler: () => void) {
+    const sub = emitter.addListener('NamiOverlayReady', handler);
+    return () => sub.remove();
+  },
+
+  onOverlayResult(handler: (result: any) => void) {
+    const sub = emitter.addListener('NamiOverlayResult', handler);
+    return () => sub.remove();
+  },
+};
+
+export default function NamiOverlayHost() {
+  return <View style={styles.overlay} />;
+}
+
+const styles = StyleSheet.create({
+  overlay: {
+    flex: 1,
+    backgroundColor: 'transparent',
+  },
+});
+
+AppRegistry.registerComponent('NamiOverlayHost', () => NamiOverlayHost);

package/src/version.ts

@@ -2,4 +2,4 @@
  * Auto-generated file. Do not edit manually.
  * React Native Nami SDK version.
  */
-export const NAMI_REACT_NATIVE_VERSION = '3.3.2-4';
+export const NAMI_REACT_NATIVE_VERSION = '3.3.2-5';