airborne-react-native 0.1.0 → 0.3.0

package/AirborneReact.podspec

@@ -33,7 +33,10 @@ Pod::Spec.new do |s|
   }
 
   s.source_files = "ios/**/*.{h,m,mm,cpp}"
-  s.private_header_files = "ios/**/*.h"
+  s.public_header_files = "ios/**/*.h"
+  s.static_framework = false
+
+  s.dependency "Airborne", "0.0.4"
 
  install_modules_dependencies(s)
 end

package/README.md

@@ -53,9 +53,9 @@ This implementation provides a React Native module for Airborne that:
 
 ## API Methods
 
-1. **readReleaseConfig()** - Returns the release configuration as a stringified JSON
-2. **getFileContent(filePath)** - Reads content from a file in the OTA bundle
-3. **getBundlePath()** - Returns the path to the JavaScript bundle
+1. **readReleaseConfig(namespace/appId)** - Returns the release configuration as a stringified JSON
+2. **getFileContent(namespace/appId, filePath)** - Reads content from a file in the OTA bundle
+3. **getBundlePath(namespace/appId)** - Returns the path to the JavaScript bundle
 
 ## Usage
 
@@ -68,13 +68,13 @@ This implementation provides a React Native module for Airborne that:
 import { readReleaseConfig, getFileContent, getBundlePath } from 'airborne-react-native';
 
 // Read configuration
-const config = await readReleaseConfig();
+const config = await readReleaseConfig(namespace/appId);
 
 // Get file content
-const content = await getFileContent('path/to/file.json');
+const content = await getFileContent(namespace/appId, 'path/to/file.json');
 
 // Get bundle path
-const bundlePath = await getBundlePath();
+const bundlePath = await getBundlePath(namespace/appId);
 ```
 
 ## Implementation Notes

package/android/build.gradle

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 import com.android.Version
+import groovy.json.JsonSlurper
 
 buildscript {
     ext.getExtOrDefault = { name ->
@@ -35,6 +36,22 @@ def isNewArchitectureEnabled() {
     return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
 
+def findReactNativeVersion() {
+    // Locate app's node_modules/react-native/package.json
+    def packageJson = file("${rootProject.projectDir}/../node_modules/react-native/package.json")
+    if (!packageJson.exists()) {
+        packageJson = file("${rootProject.projectDir}/node_modules/react-native/package.json")
+    }
+
+    if (!packageJson.exists()) {
+        println("[AirborneReact] Could not find react-native/package.json. Defaulting to latest.")
+        return "999.0.0"
+    }
+
+    def json = new JsonSlurper().parseText(packageJson.text)
+    return json.version
+}
+
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
 
@@ -67,6 +84,18 @@ android {
         buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
     }
 
+    sourceSets {
+        main {
+            java.srcDirs = ["src/main/java"]
+        }
+    }
+
+    if (findReactNativeVersion().tokenize('.')[1].toInteger() >= 78) {
+        sourceSets.main.java.srcDirs += "src/latest/java"
+    } else {
+        sourceSets.main.java.srcDirs += "src/rn77/java"
+    }
+
     buildFeatures {
         buildConfig true
     }
@@ -114,7 +143,7 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 
     // Airborne SDK dependency
-    api "in.juspay:airborne:0.0.1-xota.15"
+    api "in.juspay:airborne:2.2.5-xota.03"
 }
 
 react {

package/android/gradle.properties

@@ -14,6 +14,6 @@
 
 Airborne_kotlinVersion=2.0.21
 Airborne_minSdkVersion=24
-Airborne_targetSdkVersion=34
+Airborne_targetSdkVersion=35
 Airborne_compileSdkVersion=35
 Airborne_ndkVersion=27.1.12297006

package/android/src/latest/java/in/juspay/airborneplugin/AirborneReactHostDelegate.kt

@@ -0,0 +1,65 @@
+package `in`.juspay.airborneplugin
+
+import android.content.Context
+import android.util.Log
+import com.facebook.react.JSEngineResolutionAlgorithm
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.ReactPackageTurboModuleManagerDelegate
+import com.facebook.react.bridge.JSBundleLoader
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.defaults.DefaultTurboModuleManagerDelegate
+import com.facebook.react.runtime.BindingsInstaller
+import com.facebook.react.runtime.JSCInstance
+import com.facebook.react.runtime.JSRuntimeFactory
+import com.facebook.react.runtime.ReactHostDelegate
+import com.facebook.react.runtime.hermes.HermesInstance
+import java.lang.ref.WeakReference
+
+@OptIn(UnstableReactNativeAPI::class)
+class AirborneReactHostDelegate(
+    private val weakContext: WeakReference<Context>,
+    private val reactNativeHostWrapper: ReactNativeHost,
+    override val bindingsInstaller: BindingsInstaller? = null,
+    override val turboModuleManagerDelegateBuilder: ReactPackageTurboModuleManagerDelegate.Builder =
+        DefaultTurboModuleManagerDelegate.Builder()
+) : ReactHostDelegate {
+
+    override val jsBundleLoader: JSBundleLoader
+        get() {
+            val bundleName =
+                (reactNativeHostWrapper as AirborneReactNativeHost).jsBundleFile
+            bundleName?.let {
+                return if (bundleName.startsWith("assets://")) {
+                    JSBundleLoader.createAssetLoader(
+                        weakContext.get(),
+                        bundleName,
+                        false
+                    )
+                } else {
+                    JSBundleLoader.createFileLoader(bundleName)
+                }
+            }
+            return JSBundleLoader.createAssetLoader(
+                weakContext.get(),
+                "assets://index.android.bundle",
+                false
+            )
+        }
+
+    override val jsMainModulePath: String
+        get() = (reactNativeHostWrapper as AirborneReactNativeHost).jsMainModuleName
+
+    override val jsRuntimeFactory: JSRuntimeFactory
+        get() = if ((reactNativeHostWrapper as AirborneReactNativeHost).jsEngineResolutionAlgorithm == JSEngineResolutionAlgorithm.HERMES) {
+            HermesInstance()
+        } else {
+            JSCInstance()
+        }
+
+    override val reactPackages: List<ReactPackage>
+        get() = (reactNativeHostWrapper as AirborneReactNativeHost).packages
+
+    override fun handleInstanceException(error: Exception) {
+    }
+}

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,4 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-</manifest>
+<?xml version="1.0" encoding="utf-8"?>
+<manifest>
+
+</manifest>

package/android/src/main/java/in/juspay/airborneplugin/Airborne.kt

@@ -5,11 +5,11 @@ import androidx.annotation.Keep
 import `in`.juspay.airborne.HyperOTAServices
 import `in`.juspay.airborne.LazyDownloadCallback
 import `in`.juspay.airborne.TrackerCallback
-import `in`.juspay.airborne.constants.LogLevel
+import `in`.juspay.hyperutil.constants.LogLevel
 import org.json.JSONObject
 
 @Keep
-class Airborne (
+class Airborne(
     context: Context,
     releaseConfigUrl: String,
     private val airborneInterface: AirborneInterface
@@ -50,23 +50,27 @@ class Airborne (
         "",
         releaseConfigUrl,
         trackerCallback,
-        airborneInterface::onBootComplete
+        this::bootComplete
     )
 
     private val applicationManager = hyperOTAServices.createApplicationManager(airborneInterface.getDimensions())
 
     init {
-        initializer = { this }
+        airborneObjectMap.put(airborneInterface.getNamespace(), this)
         applicationManager.loadApplication(airborneInterface.getNamespace(), airborneInterface.getLazyDownloadCallback())
     }
 
+    private fun bootComplete(filePath: String) {
+        airborneInterface.startApp(filePath.ifEmpty { "assets://${applicationManager.getBundledIndexPath().ifEmpty { "index.android.bundle" }}" })
+    }
+
     /**
      * @return The path of the index bundle, or asset path fallback if empty.
      */
     @Keep
     fun getBundlePath(): String {
         val filePath = applicationManager.getIndexBundlePath()
-        return filePath.ifEmpty { "assets://${airborneInterface.getIndexBundlePath()}" }
+        return filePath.ifEmpty { "assets://${applicationManager.getBundledIndexPath().ifEmpty { "index.android.bundle" }}" }
     }
 
     /**
@@ -88,16 +92,46 @@ class Airborne (
     }
 
     companion object {
-        private var initializer: (() -> Airborne)? = null
-
-        /**
-         * Lazily initialized singleton instance.
-         */
-        @JvmStatic
-        val instance: Airborne by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
-            initializer?.invoke()
-                ?: throw IllegalStateException("Airborne initializer not set. Call init() first.")
-        }
+//        private var initializer: (() -> Airborne)? = null
+//
+//        /**
+//         * Lazily initialized singleton instance.
+//         */
+//        @JvmStatic
+//        val instance: Airborne by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
+//            initializer?.invoke()
+//                ?: throw IllegalStateException("AirborneReact initializer not set. Call init() first.")
+//        }
+//
+//        /**
+//         * Initializes the AirborneReact singleton.
+//         */
+//        @JvmStatic
+//        fun init(
+//            context: Context,
+//            appId: String,
+//            indexFileName: String,
+//            appVersion: String,
+//            releaseConfigTemplateUrl: String,
+//            headers: Map<String, String>? = null,
+//            lazyDownloadCallback: LazyDownloadCallback? = null,
+//            trackerCallback: TrackerCallback? = null
+//        ) {
+//            initializer = {
+//                Airborne(
+//                    context,
+//                    appId,
+//                    indexFileName,
+//                    appVersion,
+//                    releaseConfigTemplateUrl,
+//                    headers,
+//                    lazyDownloadCallback ?: defaultLazyCallback,
+//                    trackerCallback ?: defaultTrackerCallback
+//                )
+//            }
+//        }
+
+        public val airborneObjectMap: MutableMap<String, Airborne> = mutableMapOf()
 
         /**
          * Default LazyDownloadCallback implementation.
@@ -106,18 +140,18 @@ class Airborne (
             override fun fileInstalled(filePath: String, success: Boolean) {
                 // Default implementation: log the file installation status
                 if (success) {
-                    println("HyperOTAReact: File installed successfully: $filePath")
+                    println("AirborneReact: File installed successfully: $filePath")
                 } else {
-                    println("HyperOTAReact: File installation failed: $filePath")
+                    println("AirborneReact: File installation failed: $filePath")
                 }
             }
 
             override fun lazySplitsInstalled(success: Boolean) {
                 // Default implementation: log the lazy splits installation status
                 if (success) {
-                    println("HyperOTAReact: Lazy splits installed successfully")
+                    println("AirborneReact: Lazy splits installed successfully")
                 } else {
-                    println("HyperOTAReact: Lazy splits installation failed")
+                    println("AirborneReact: Lazy splits installation failed")
                 }
             }
         }

package/android/src/main/java/in/juspay/airborneplugin/AirborneInterface.kt

@@ -6,18 +6,14 @@ import org.json.JSONObject
 
 abstract class AirborneInterface {
     open fun getNamespace(): String {
-        return "default"
-    }
-
-    open fun getIndexBundlePath(): String {
-        return "index.android.bundle"
+        return "airborne-example"
     }
 
     open fun getDimensions(): HashMap<String, String> {
         return hashMapOf()
     }
 
-    open fun onBootComplete(indexPath: String) {
+    open fun startApp(indexPath: String) {
     }
 
     open fun onEvent(level: String, label: String, key: String, value: JSONObject, category: String, subCategory: String) {

package/android/src/main/java/in/juspay/airborneplugin/AirborneModule.kt

@@ -17,18 +17,18 @@ class AirborneModule(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun readReleaseConfig(promise: Promise) {
-    implementation.readReleaseConfig(promise)
+  fun readReleaseConfig(namespace: String, promise: Promise) {
+    implementation.readReleaseConfig(namespace, promise)
   }
 
   @ReactMethod
-  fun getFileContent(filePath: String, promise: Promise) {
-    implementation.getFileContent(filePath, promise)
+  fun getFileContent(namespace: String, filePath: String, promise: Promise) {
+    implementation.getFileContent(namespace, filePath, promise)
   }
 
   @ReactMethod
-  fun getBundlePath(promise: Promise) {
-    implementation.getBundlePath(promise)
+  fun getBundlePath(namespace: String, promise: Promise) {
+    implementation.getBundlePath(namespace, promise)
   }
 
   companion object {

package/android/src/main/java/in/juspay/airborneplugin/AirborneModuleImpl.kt

@@ -42,27 +42,27 @@ class AirborneModuleImpl(private val reactContext: ReactApplicationContext) {
 //        }
     }
 
-    fun readReleaseConfig(promise: Promise) {
+    fun readReleaseConfig(namespace: String, promise: Promise) {
         try {
-            val config = Airborne.instance.getReleaseConfig()
+            val config = Airborne.airborneObjectMap[namespace]?.getReleaseConfig()
             promise.resolve(config)
         } catch (e: Exception) {
             promise.reject("AIRBORNE_ERROR", "Failed to read release config: ${e.message}", e)
         }
     }
 
-    fun getFileContent(filePath: String, promise: Promise) {
+    fun getFileContent(namespace: String, filePath: String, promise: Promise) {
         try {
-            val content = Airborne.instance.getFileContent(filePath)
+            val content = Airborne.airborneObjectMap[namespace]?.getFileContent(filePath)
             promise.resolve(content)
         } catch (e: Exception) {
             promise.reject("AIRBORNE_ERROR", "Failed to read file content: ${e.message}", e)
         }
     }
 
-    fun getBundlePath(promise: Promise) {
+    fun getBundlePath(namespace: String, promise: Promise) {
         try {
-            val path = Airborne.instance.getBundlePath()
+            val path = Airborne.airborneObjectMap[namespace]?.getBundlePath()
             promise.resolve(path)
         } catch (e: Exception) {
             promise.reject("AIRBORNE_ERROR", "Failed to get bundle path: ${e.message}", e)

package/android/src/main/java/in/juspay/airborneplugin/AirbornePackage.kt

@@ -8,32 +8,32 @@ import com.facebook.react.module.model.ReactModuleInfoProvider
 import java.util.HashMap
 
 class AirbornePackage : TurboReactPackage() {
-  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == AirborneModule.NAME) {
-      if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
-        AirborneTurboModule(reactContext)
-      } else {
-        AirborneModule(reactContext)
-      }
-    } else {
-      null
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == AirborneModule.NAME) {
+            if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+                AirborneTurboModule(reactContext)
+            } else {
+                AirborneModule(reactContext)
+            }
+        } else {
+            null
+        }
     }
-  }
 
-  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
-    return ReactModuleInfoProvider {
-      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
-      moduleInfos[AirborneModule.NAME] = ReactModuleInfo(
-          AirborneModule.NAME,
-        if (isTurboModule) AirborneTurboModule::class.java.name else AirborneModule::class.java.name,
-        false,  // canOverrideExistingModule
-        false,  // needsEagerInit
-        true,   // hasConstants
-        false,  // isCxxModule
-        isTurboModule // isTurboModule
-      )
-      moduleInfos
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+            val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+            moduleInfos[AirborneModule.NAME] = ReactModuleInfo(
+                AirborneModule.NAME,
+                if (isTurboModule) AirborneTurboModule::class.java.name else AirborneModule::class.java.name,
+                false,  // canOverrideExistingModule
+                false,  // needsEagerInit
+                true,   // hasConstants
+                false,  // isCxxModule
+                isTurboModule // isTurboModule
+            )
+            moduleInfos
+        }
     }
-  }
 }

package/android/src/main/java/in/juspay/airborneplugin/AirborneReactActivityDelegate.kt

@@ -0,0 +1,81 @@
+package `in`.juspay.airborneplugin
+
+import android.util.Log
+import com.facebook.react.ReactActivity
+import com.facebook.react.defaults.DefaultReactActivityDelegate
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class AirborneReactActivityDelegate(
+    activity: ReactActivity,
+    mainComponentName: String,
+    fabricEnabled: Boolean
+) : DefaultReactActivityDelegate(activity, mainComponentName, fabricEnabled) {
+
+    private var appState = AppState.BEFORE_APPLOAD;
+    override fun loadApp(appKey: String) {
+        if (reactNativeHost is AirborneReactNativeHost) {
+            CoroutineScope(Dispatchers.Default).launch {
+
+                // The wait for bundle update
+                (reactNativeHost as AirborneReactNativeHost).jsBundleFile
+
+                CoroutineScope(Dispatchers.Main).launch {
+                    callLoadApp(appKey)
+                }
+            }
+        } else {
+            callLoadApp(appKey)
+        }
+    }
+
+    private fun callLoadApp(appKey: String) {
+        super.loadApp(appKey)
+        appState = AppState.APP_LOADED
+        onResume()
+    }
+
+    override fun onPause() {
+        try {
+            if (appState == AppState.ONRESUME_CALLED) {
+                super.onPause()
+            } else {
+                Log.d(AirborneReactNativeHost.toString(), "skipping onPause as onResume is not yet called")
+            }
+        } catch (e: Exception) {
+            Log.e( AirborneReactNativeHost.toString(), "Exception in onPause: ${e.message}")
+        }
+    }
+
+    override fun onResume() {
+        try {
+            if (appState == AppState.APP_LOADED) {
+                super.onResume()
+                appState = AppState.ONRESUME_CALLED
+            } else {
+                Log.d(AirborneReactNativeHost.toString(), "skipping onResume as app is not yet loaded")
+            }
+        } catch (e: Exception) {
+            Log.e(AirborneReactNativeHost.toString(), "Exception in onResume: ${e.message}")
+        }
+    }
+
+    override fun onDestroy() {
+        try {
+            if (appState == AppState.ONRESUME_CALLED) {
+                super.onDestroy()
+            } else {
+                Log.d(AirborneReactNativeHost.toString(), "skipping onDestroy as onResume is not yet called")
+            }
+        } catch (e: Exception) {
+            Log.e(AirborneReactNativeHost.toString(), "Exception in onDestroy: ${e.message}")
+        }
+    }
+
+    enum class AppState {
+        BEFORE_APPLOAD,
+        APP_LOADED,
+        ONRESUME_CALLED
+    }
+}

package/android/src/main/java/in/juspay/airborneplugin/AirborneReactNativeHost.kt

@@ -0,0 +1,49 @@
+package `in`.juspay.airborneplugin
+
+import android.app.Application
+import android.content.Context
+import android.util.Log
+import com.facebook.react.JSEngineResolutionAlgorithm
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.JSExceptionHandler
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.defaults.DefaultComponentsRegistry
+import com.facebook.react.defaults.DefaultReactNativeHost
+import com.facebook.react.fabric.ComponentFactory
+import com.facebook.react.runtime.ReactHostImpl
+import java.lang.ref.WeakReference
+
+abstract class AirborneReactNativeHost(application: Application) :
+    DefaultReactNativeHost(application) {
+
+    public override fun getPackages(): List<ReactPackage> {
+        return this.packages
+    }
+
+    public override fun getJSBundleFile(): String? {
+        return super.getJSBundleFile()
+    }
+
+    public override fun getJSEngineResolutionAlgorithm(): JSEngineResolutionAlgorithm? {
+        return super.getJSEngineResolutionAlgorithm()
+    }
+
+    public override fun getJSMainModuleName(): String {
+        return super.getJSMainModuleName()
+    }
+
+    companion object {
+        @OptIn(UnstableReactNativeAPI::class)
+        fun getReactHost(context: Context, reactNativeHost: ReactNativeHost): ReactHost {
+            val reactHostDelegate =
+                AirborneReactHostDelegate(WeakReference(context), reactNativeHost)
+            val componentFactory = ComponentFactory()
+            DefaultComponentsRegistry.register(componentFactory)
+            val reactHostImpl =
+                ReactHostImpl(context, reactHostDelegate, componentFactory, true, true)
+            return reactHostImpl
+        }
+    }
+}

package/android/src/main/java/in/juspay/airborneplugin/AirborneTurboModule.kt

@@ -14,19 +14,19 @@ class AirborneTurboModule(reactContext: ReactApplicationContext) :
     return NAME
   }
 
-  override fun readReleaseConfig(promise: Promise) {
-    implementation.readReleaseConfig(promise)
+  override fun readReleaseConfig(nameSpace: String, promise: Promise) {
+    implementation.readReleaseConfig(nameSpace, promise)
   }
 
-  override fun getFileContent(filePath: String, promise: Promise) {
-    implementation.getFileContent(filePath, promise)
+  override fun getFileContent(nameSpace: String, filePath: String, promise: Promise) {
+    implementation.getFileContent(nameSpace, filePath, promise)
   }
 
-  override fun getBundlePath(promise: Promise) {
-    implementation.getBundlePath(promise)
+  override fun getBundlePath(nameSpace: String, promise: Promise) {
+    implementation.getBundlePath(nameSpace, promise)
   }
 
   companion object {
-    const val NAME = "HyperOta"
+    const val NAME = "AirborneReact"
   }
 }

package/android/src/main/res/raw/juspay_airborne_react_res.xml

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="utf-8"?><resources xmlns:tools="http://schemas.android.com/tools" tools:keep="@string/airborne_react_version,@string/airborne_react_build_version" />

package/android/src/rn77/java/in/juspay/airborneplugin/AirborneReactHostDelegate.kt

@@ -0,0 +1,71 @@
+package `in`.juspay.airborneplugin
+
+import android.content.Context
+import android.util.Log
+import com.facebook.react.JSEngineResolutionAlgorithm
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.ReactPackageTurboModuleManagerDelegate
+import com.facebook.react.bridge.JSBundleLoader
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.defaults.DefaultTurboModuleManagerDelegate
+import com.facebook.react.fabric.ReactNativeConfig
+import com.facebook.react.runtime.BindingsInstaller
+import com.facebook.react.runtime.JSCInstance
+import com.facebook.react.runtime.JSRuntimeFactory
+import com.facebook.react.runtime.ReactHostDelegate
+import com.facebook.react.runtime.hermes.HermesInstance
+import java.lang.ref.WeakReference
+
+@OptIn(UnstableReactNativeAPI::class)
+class AirborneReactHostDelegate(
+    private val weakContext: WeakReference<Context>,
+    private val reactNativeHostWrapper: ReactNativeHost,
+    override val bindingsInstaller: BindingsInstaller? = null,
+    private val reactNativeConfig: ReactNativeConfig = ReactNativeConfig.DEFAULT_CONFIG,
+    override val turboModuleManagerDelegateBuilder: ReactPackageTurboModuleManagerDelegate.Builder =
+        DefaultTurboModuleManagerDelegate.Builder()
+) : ReactHostDelegate {
+
+    override val jsBundleLoader: JSBundleLoader
+        get() {
+            val bundleName =
+                (reactNativeHostWrapper as AirborneReactNativeHost).jsBundleFile
+            bundleName?.let {
+                return if (bundleName.startsWith("assets://")) {
+                    JSBundleLoader.createAssetLoader(
+                        weakContext.get(),
+                        bundleName,
+                        false
+                    )
+                } else {
+                    JSBundleLoader.createFileLoader(bundleName)
+                }
+            }
+            return JSBundleLoader.createAssetLoader(
+                weakContext.get(),
+                "assets://index.android.bundle",
+                false
+            )
+        }
+
+    override val jsMainModulePath: String
+        get() = (reactNativeHostWrapper as AirborneReactNativeHost).jsMainModuleName
+
+    override val jsRuntimeFactory: JSRuntimeFactory
+        get() = if ((reactNativeHostWrapper as AirborneReactNativeHost).jsEngineResolutionAlgorithm == JSEngineResolutionAlgorithm.HERMES) {
+            HermesInstance()
+        } else {
+            JSCInstance()
+        }
+
+    override val reactPackages: List<ReactPackage>
+        get() = (reactNativeHostWrapper as AirborneReactNativeHost).packages
+
+    override fun getReactNativeConfig(): ReactNativeConfig {
+        return reactNativeConfig
+    }
+
+    override fun handleInstanceException(error: Exception) {
+    }
+}

package/ios/Airborne.h

@@ -1,3 +1,4 @@
+#import "AirborneiOS.h"
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <AirborneSpec/AirborneSpec.h>
 
@@ -5,13 +6,20 @@
 #else
 #import <React/RCTBridgeModule.h>
 
+
 @interface Airborne : NSObject <RCTBridgeModule>
 #endif
 
-+ (void)initializeAirborneWithAppId:(NSString *)appId
-                       indexFileName:(NSString *)indexFileName
-                          appVersion:(NSString *)appVersion
-             releaseConfigTemplateUrl:(NSString *)releaseConfigTemplateUrl
-                             headers:(nullable NSDictionary<NSString *, NSString *> *)headers;
++ (void)initializeAirborneWithReleaseConfigUrl:(NSString *) releaseConfigUrl;
+
++ (void)initializeAirborneWithReleaseConfigUrl:(NSString *) releaseConfigUrl
+                                   inNamespace:(NSString *) ns;
+
++ (void)initializeAirborneWithReleaseConfigUrl:(NSString *)releaseConfigUrl
+                                      delegate:delegate;
+
++ (void)initializeAirborneWithReleaseConfigUrl:(NSString *) releaseConfigUrl
+                                   inNamespace:(NSString *) ns
+                                      delegate:(id<AirborneReactDelegate>) delegate;
 
 @end

package/ios/Airborne.mm

@@ -1,34 +1,39 @@
 #import "Airborne.h"
 #import "AirborneiOS.h"
 #import <React/RCTLog.h>
+#import <Airborne/Airborne.h>
+#import <Airborne/Airborne-Swift.h>
 
 @implementation Airborne
 
 RCT_EXPORT_MODULE(Airborne)
 
-+ (void)initializeAirborneWithAppId:(NSString *)appId
-                       indexFileName:(NSString *)indexFileName
-                          appVersion:(NSString *)appVersion
-             releaseConfigTemplateUrl:(NSString *)releaseConfigTemplateUrl
-                             headers:(nullable NSDictionary<NSString *, NSString *> *)headers {
-    [[AirborneiOS sharedInstance] initializeWithAppId:appId
-                                         indexFileName:indexFileName
-                                            appVersion:appVersion
-                               releaseConfigTemplateUrl:releaseConfigTemplateUrl
-                                               headers:headers
-                                  lazyDownloadCallback:^(NSString *filePath, BOOL success) {
-                                      RCTLogInfo(@"Airborne: File %@ - %@", filePath, success ? @"installed" : @"failed");
-                                  }
-                                   lazySplitsCallback:^(BOOL success) {
-                                      RCTLogInfo(@"Airborne: Lazy splits - %@", success ? @"installed" : @"failed");
-                                  }];
+static NSString * const defaultNamespace = @"default";
+
++ (void)initializeAirborneWithReleaseConfigUrl:(NSString *)releaseConfigUrl {
+    [self initializeAirborneWithReleaseConfigUrl:releaseConfigUrl inNamespace:defaultNamespace];
+}
+
++ (void)initializeAirborneWithReleaseConfigUrl:(NSString *)releaseConfigUrl inNamespace:ns {
+    AirborneiOS* air = [AirborneiOS sharedInstanceWithNamespace:ns];
+    [air loadWithReleaseConfig:releaseConfigUrl delegate:nil];
+}
+
++ (void)initializeAirborneWithReleaseConfigUrl:(NSString *)releaseConfigUrl delegate:delegate {
+    AirborneiOS* air = [AirborneiOS sharedInstanceWithNamespace:defaultNamespace];
+    [air loadWithReleaseConfig:releaseConfigUrl delegate:delegate];
+}
+
++ (void)initializeAirborneWithReleaseConfigUrl:(NSString *)releaseConfigUrl inNamespace:ns delegate:delegate {
+    AirborneiOS* air = [AirborneiOS sharedInstanceWithNamespace:ns];
+    [air loadWithReleaseConfig:releaseConfigUrl delegate:delegate];
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
 - (void)readReleaseConfig:(RCTPromiseResolveBlock)resolve
                    reject:(RCTPromiseRejectBlock)reject {
     @try {
-        NSString *config = [[AirborneiOS sharedInstance] getReleaseConfig];
+        NSString *config = [[AirborneiOS sharedInstanceWithNamespace:defaultNamespace] getReleaseConfig];
         resolve(config);
     } @catch (NSException *exception) {
         reject(@"AIRBORNE_ERROR", exception.reason, nil);
@@ -39,7 +44,7 @@ RCT_EXPORT_MODULE(Airborne)
                resolve:(RCTPromiseResolveBlock)resolve
                 reject:(RCTPromiseRejectBlock)reject {
     @try {
-        NSString *content = [[AirborneiOS sharedInstance] getFileContent:filePath];
+        NSString *content = [[AirborneiOS sharedInstanceWithNamespace:defaultNamespace] getFileContent:filePath];
         resolve(content);
     } @catch (NSException *exception) {
         reject(@"AIRBORNE_ERROR", exception.reason, nil);
@@ -49,7 +54,7 @@ RCT_EXPORT_MODULE(Airborne)
 - (void)getBundlePath:(RCTPromiseResolveBlock)resolve
                reject:(RCTPromiseRejectBlock)reject {
     @try {
-        NSString *bundlePath = [[AirborneiOS sharedInstance] getBundlePath];
+        NSString *bundlePath = [[AirborneiOS sharedInstanceWithNamespace:defaultNamespace] getBundlePath];
         resolve(bundlePath);
     } @catch (NSException *exception) {
         reject(@"AIRBORNE_ERROR", exception.reason, nil);
@@ -59,7 +64,7 @@ RCT_EXPORT_MODULE(Airborne)
 RCT_EXPORT_METHOD(readReleaseConfig:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     @try {
-        NSString *config = [[AirborneiOS sharedInstance] getReleaseConfig];
+        NSString *config = [[AirborneiOS sharedInstanceWithNamespace:defaultNamespace] getReleaseConfig];
         resolve(config);
     } @catch (NSException *exception) {
         reject(@"AIRBORNE_ERROR", exception.reason, nil);
@@ -70,7 +75,7 @@ RCT_EXPORT_METHOD(getFileContent:(NSString *)filePath
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     @try {
-        NSString *content = [[AirborneiOS sharedInstance] getFileContent:filePath];
+        NSString *content = [[AirborneiOS sharedInstanceWithNamespace:defaultNamespace] getFileContent:filePath];
         resolve(content);
     } @catch (NSException *exception) {
         reject(@"AIRBORNE_ERROR", exception.reason, nil);
@@ -80,7 +85,7 @@ RCT_EXPORT_METHOD(getFileContent:(NSString *)filePath
 RCT_EXPORT_METHOD(getBundlePath:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject) {
     @try {
-        NSString *bundlePath = [[AirborneiOS sharedInstance] getBundlePath];
+        NSString *bundlePath = [[AirborneiOS sharedInstanceWithNamespace:defaultNamespace] getBundlePath];
         resolve(bundlePath);
     } @catch (NSException *exception) {
         reject(@"AIRBORNE_ERROR", exception.reason, nil);

package/ios/AirborneiOS.h

@@ -2,21 +2,84 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+@protocol AirborneReactDelegate <NSObject>
+
+/**
+ * Returns custom dimensions/metadata to include with release configuration requests.
+ *
+ * These dimensions are sent as HTTP headers when fetching the release configuration
+ * and can be used for:
+ * - A/B testing and feature flags
+ * - Device-specific configurations
+ * - User segmentation
+ * - Analytics and debugging context
+ *
+ * @return A dictionary of header field names and values to include in network requests.
+ *         If not implemented, defaults to an empty dictionary.
+ */
+- (NSDictionary<NSString *, NSString *> *)getDimensions;
+
+/**
+ * Returns the namespace, an unique identifier of the app/sdk.
+ *
+ * This namespace is used to store the files in the internal storage.
+ * and also to read the bundled release config.
+ *
+ * @return the namespace, an unique identifier of the app/sdk.
+ *         If not implemented, defaults to an default.
+ */
+- (NSString *)getNamespace;
+
+
+- (NSBundle *)getBundle;
+
+/**
+ * Called when the OTA boot process has completed successfully.
+ *
+ * This callback indicates that the application is ready to load the packages & resources
+ *
+ * @note This method is called on a background queue. Dispatch UI updates
+ *       to the main queue if needed.
+ * @note Boot completion occurs even if some downloads failed or timed out.
+ *       Check the release configuration for actual status.
+ */
+- (void)startApp:(NSString *) bundlePath;
+
+/**
+ * Called when significant events occur during the OTA update process.
+ *
+ * This callback provides detailed information about:
+ * - Download progress and completion
+ * - Error conditions and failures
+ * - Performance metrics and timing
+ * - State transitions in the update process
+ *
+ * @param level The severity level of the event ("info", "error", "warning")
+ * @param label A category label for the event (e.g., "ota_update")
+ * @param key A specific identifier for the event type
+ * @param value Additional structured data about the event
+ * @param category The broad category of the event (e.g., "lifecycle")
+ * @param subcategory The specific subcategory (e.g., "hyperota")
+ *
+ * @note Use this for logging, analytics, debugging, and monitoring OTA performance.
+ */
+- (void)onEventWithLevel:(NSString *)level
+                   label:(NSString *)label
+                     key:(NSString *)key
+                   value:(NSDictionary<NSString *, id> *)value
+                category:(NSString *)category
+             subcategory:(NSString *)subcategory;
+
+@end
+
 typedef void (^HyperOTALazyDownloadCallback)(NSString *filePath, BOOL success);
 typedef void (^HyperOTALazySplitsCallback)(BOOL success);
 
 @interface AirborneiOS : NSObject
 
-+ (instancetype)sharedInstance;
-
-- (void)initializeWithAppId:(NSString *)appId
-              indexFileName:(NSString *)indexFileName
-                 appVersion:(NSString *)appVersion
-    releaseConfigTemplateUrl:(NSString *)releaseConfigTemplateUrl
-                    headers:(nullable NSDictionary<NSString *, NSString *> *)headers
-       lazyDownloadCallback:(nullable HyperOTALazyDownloadCallback)lazyDownloadCallback
-        lazySplitsCallback:(nullable HyperOTALazySplitsCallback)lazySplitsCallback;
++ (instancetype)sharedInstanceWithNamespace:(NSString *)ns;
 
+- (void) loadWithReleaseConfig:(NSString *) rcurl delegate:(id<AirborneReactDelegate>) delegate;
 - (NSString *)getBundlePath;
 - (NSString *)getFileContent:(NSString *)filePath;
 - (NSString *)getReleaseConfig;

package/ios/AirborneiOS.m

@@ -1,128 +1,120 @@
 #import "AirborneiOS.h"
+#import "Airborne/Airborne.h"
+
+
+@interface AirborneLocalDelegate : NSObject<AirborneDelegate>
+@property (nonatomic, weak) NSString* ns;
+@property (nonatomic, weak) id<AirborneReactDelegate> delegate;
+-(instancetype)initWithNamespace:(NSString*) ns
+                        delegate:(id<AirborneReactDelegate>) delegate;
+@end
+
+@implementation AirborneLocalDelegate
+
+-(instancetype)initWithNamespace:(NSString*) ns delegate:(id<AirborneReactDelegate>) del {
+    self = [super init];
+    if (self) {
+        _ns = ns;
+        _delegate = del;
+    }
+    return self;
+}
+
+- (NSString *)namespace{
+    if(_delegate == nil) return @"default";
+    return [_delegate getNamespace];
+}
+
+- (NSBundle *)bundle{
+    if(_delegate == nil) return NSBundle.mainBundle;
+    return [_delegate getBundle];
+}
+
+- (NSDictionary *)dimensions{
+    if(_delegate == nil) return @{};
+    return [_delegate getDimensions];
+}
+
+- (void)onBootCompleteWithIndexBundlePath:(NSString *)indexBundlePath{
+    if (_delegate == nil) return;
+    [_delegate startApp:indexBundlePath];
+}
+
+-(void)onEventWithLevel:(NSString *)level label:(NSString *)label key:(NSString *)key value:(NSDictionary<NSString *,id> *)value category:(NSString *)category subcategory:(NSString *)subcategory{
+    if (_delegate == nil) return;
+    [_delegate onEventWithLevel:level label:label key:key value:value category:category subcategory:subcategory];
+}
+
+@end
+
 
 @interface AirborneiOS ()
-@property (nonatomic, assign) BOOL isInitialized;
-@property (nonatomic, strong) NSString *indexFileName;
-// In a real implementation, you would have references to the actual Airborne SDK objects here
+@property (nonatomic, strong) NSString* ns;
+@property (nonatomic, strong) AirborneServices* air;
+@property (nonatomic, strong) id<AirborneDelegate> delegate;
+@property (nonatomic, strong) AirborneLocalDelegate* delegateproxy;
+
 @end
 
 @implementation AirborneiOS
 
-+ (instancetype)sharedInstance {
-    static AirborneiOS *sharedInstance = nil;
++ (instancetype)sharedInstanceWithNamespace:(NSString *)namespace{
+    static NSMutableDictionary<NSString *, AirborneiOS *> *instances = nil;
+    static dispatch_queue_t syncQueue;
     static dispatch_once_t onceToken;
+
+    // Initialize dictionary and queue once
     dispatch_once(&onceToken, ^{
-        sharedInstance = [[self alloc] init];
+        instances = [NSMutableDictionary dictionary];
+        syncQueue = dispatch_queue_create("in.juspay.Airborne.singleton", DISPATCH_QUEUE_CONCURRENT);
     });
-    return sharedInstance;
+
+    __block AirborneiOS *instance = nil;
+
+    // Read existing instance (concurrent)
+    dispatch_sync(syncQueue, ^{
+        instance = instances[namespace];
+    });
+
+    if (instance == nil) {
+        // Write new instance (barrier to prevent concurrent writes)
+        dispatch_barrier_sync(syncQueue, ^{
+            if (!instances[namespace]) {
+                instances[namespace] = [[self alloc] initWithNamespace:namespace];
+            }
+            instance = instances[namespace];
+        });
+    }
+
+    return instance;
 }
 
-- (instancetype)init {
+
+- (instancetype)initWithNamespace:(NSString *) ns{
     self = [super init];
     if (self) {
-        _isInitialized = NO;
+        _ns = ns;
+        
     }
     return self;
 }
 
-- (void)initializeWithAppId:(NSString *)appId
-              indexFileName:(NSString *)indexFileName
-                 appVersion:(NSString *)appVersion
-    releaseConfigTemplateUrl:(NSString *)releaseConfigTemplateUrl
-                    headers:(nullable NSDictionary<NSString *, NSString *> *)headers
-       lazyDownloadCallback:(nullable HyperOTALazyDownloadCallback)lazyDownloadCallback
-        lazySplitsCallback:(nullable HyperOTALazySplitsCallback)lazySplitsCallback {
-    
-    if (self.isInitialized) {
-        NSLog(@"AirborneiOS: Already initialized");
-        return;
-    }
-    
-    self.indexFileName = indexFileName;
-    
-    // TODO: Initialize the actual Airborne SDK here
-    // This is a placeholder implementation
-    // In a real implementation, you would:
-    // 1. Import the HyperOTA iOS SDK
-    // 2. Initialize HyperOTAServices with the provided parameters
-    // 3. Create an ApplicationManager
-    // 4. Load the application
-    
-    NSLog(@"AirborneiOS: Initializing with appId: %@, indexFileName: %@, appVersion: %@",
-          appId, indexFileName, appVersion);
-    
-    self.isInitialized = YES;
-    
-    // Simulate callbacks for demo purposes
-    if (lazyDownloadCallback) {
-        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-            lazyDownloadCallback(@"demo/file.js", YES);
-        });
-    }
-    
-    if (lazySplitsCallback) {
-        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-            lazySplitsCallback(YES);
-        });
-    }
+- (void)loadWithReleaseConfig:(NSString *) rcurl delegate:(id<AirborneReactDelegate>) delegate{
+    _delegateproxy = [[AirborneLocalDelegate alloc] initWithNamespace: self.ns delegate:delegate];
+    _air = [[AirborneServices alloc] initWithReleaseConfigURL:rcurl delegate:_delegateproxy];
 }
 
 - (NSString *)getBundlePath {
-//    if (!self.isInitialized) {
-//        @throw [NSException exceptionWithName:@"HyperOTANotInitialized" 
-//                                       reason:@"HyperOTA is not initialized. Call initialize first." 
-//                                     userInfo:nil];
-//    }
-//    
-//    // TODO: Get the actual bundle path from HyperOTA SDK //
-//    // This is a placeholder implementation
-//    NSString *bundlePath = [[NSBundle mainBundle] pathForResource:self.indexFileName ofType:nil];
-//    if (!bundlePath) {
-//        bundlePath = [NSString stringWithFormat:@"assets://%@", self.indexFileName];
-//    }
-//    
-//    return bundlePath;
-  return @"";
+    return [_air getIndexBundlePath] ;
 }
 
 - (NSString *)getFileContent:(NSString *)filePath {
-//    if (!self.isInitialized) {
-//        @throw [NSException exceptionWithName:@"HyperOTANotInitialized" 
-//                                       reason:@"HyperOTA is not initialized. Call initialize first." 
-//                                     userInfo:nil];
-//    }
-//    
-//    // TODO: Read the actual file content from HyperOTA SDK //
-//    // This is a placeholder implementation
-//    return [NSString stringWithFormat:@"File content for: %@", filePath];
-  return @"";
+    return [_air getFileContentAtPath:filePath];
 }
 
 - (NSString *)getReleaseConfig {
-//    if (!self.isInitialized) {
-//        @throw [NSException exceptionWithName:@"HyperOTANotInitialized" 
-//                                       reason:@"HyperOTA is not initialized. Call initialize first." 
-//                                     userInfo:nil];
-//    }
-//    
-//    // TODO: Get the actual release config from HyperOTA SDK //
-//    // This is a placeholder implementation
-//    NSDictionary *config = @{
-//        @"version": @"1.0.0",
-//        @"environment": @"production",
-//        @"features": @{
-//            @"featureA": @YES,
-//            @"featureB": @NO
-//        }
-//    };
-//    
-//    NSError *error;
-//    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:config options:0 error:&error];
-//    if (jsonData) {
-//        return [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
-//    }
-    
-    return @"{}";
+    return [_air getReleaseConfig];
 }
 
 @end
+

package/lib/module/index.js

@@ -28,14 +28,14 @@ const Airborne = AirborneModule ? AirborneModule : new Proxy({}, {
     throw new Error(LINKING_ERROR);
   }
 });
-export function readReleaseConfig() {
-  return Airborne.readReleaseConfig();
+export function readReleaseConfig(nameSpace) {
+  return Airborne.readReleaseConfig(nameSpace);
 }
-export function getFileContent(filePath) {
-  return Airborne.getFileContent(filePath);
+export function getFileContent(nameSpace, filePath) {
+  return Airborne.getFileContent(nameSpace, filePath);
 }
-export function getBundlePath() {
-  return Airborne.getBundlePath();
+export function getBundlePath(nameSpace) {
+  return Airborne.getBundlePath(nameSpace);
 }
 export default Airborne;
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NativeModules","Platform","LINKING_ERROR","select","ios","default","isTurboModuleEnabled","global","__turboModuleProxy","AirborneModule","require","Airborne","Proxy","get","Error","readReleaseConfig","getFileContent","filePath","getBundlePath"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,aAAa,EAAEC,QAAQ,QAAQ,cAAc;AAEtD,MAAMC,aAAa,GACjB,gFAAgF,GAChFD,QAAQ,CAACE,MAAM,CAAC;EAAEC,GAAG,EAAE,gCAAgC;EAAEC,OAAO,EAAE;AAAG,CAAC,CAAC,GACvE,sDAAsD,GACtD,+BAA+B;;AAEjC;AACA,MAAMC,oBAAoB,GAAGC,MAAM,CAACC,kBAAkB,IAAI,IAAI;AAE9D,MAAMC,cAAc,GAAGH,oBAAoB,GACvCI,OAAO,CAAC,kBAAkB,CAAC,CAACL,OAAO,GACnCL,aAAa,CAACW,QAAQ;AAE1B,MAAMA,QAAQ,GAAGF,cAAc,GAC3BA,cAAc,GACd,IAAIG,KAAK,CACP,CAAC,CAAC,EACF;EACEC,GAAGA,CAAA,EAAG;IACJ,MAAM,IAAIC,KAAK,CAACZ,aAAa,CAAC;EAChC;AACF,CACF,CAAC;AAEL,OAAO,SAASa,iBAAiBA,CAAA,EAAoB;EACnD,OAAOJ,QAAQ,CAACI,iBAAiB,CAAC,CAAC;AACrC;AAEA,OAAO,SAASC,cAAcA,CAACC,QAAgB,EAAmB;EAChE,OAAON,QAAQ,CAACK,cAAc,CAACC,QAAQ,CAAC;AAC1C;AAEA,OAAO,SAASC,aAAaA,CAAA,EAAoB;EAC/C,OAAOP,QAAQ,CAACO,aAAa,CAAC,CAAC;AACjC;AAEA,eAAeP,QAAQ","ignoreList":[]}
+{"version":3,"names":["NativeModules","Platform","LINKING_ERROR","select","ios","default","isTurboModuleEnabled","global","__turboModuleProxy","AirborneModule","require","Airborne","Proxy","get","Error","readReleaseConfig","nameSpace","getFileContent","filePath","getBundlePath"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,aAAa,EAAEC,QAAQ,QAAQ,cAAc;AAEtD,MAAMC,aAAa,GACjB,gFAAgF,GAChFD,QAAQ,CAACE,MAAM,CAAC;EAAEC,GAAG,EAAE,gCAAgC;EAAEC,OAAO,EAAE;AAAG,CAAC,CAAC,GACvE,sDAAsD,GACtD,+BAA+B;;AAEjC;AACA,MAAMC,oBAAoB,GAAGC,MAAM,CAACC,kBAAkB,IAAI,IAAI;AAE9D,MAAMC,cAAc,GAAGH,oBAAoB,GACvCI,OAAO,CAAC,kBAAkB,CAAC,CAACL,OAAO,GACnCL,aAAa,CAACW,QAAQ;AAE1B,MAAMA,QAAQ,GAAGF,cAAc,GAC3BA,cAAc,GACd,IAAIG,KAAK,CACP,CAAC,CAAC,EACF;EACEC,GAAGA,CAAA,EAAG;IACJ,MAAM,IAAIC,KAAK,CAACZ,aAAa,CAAC;EAChC;AACF,CACF,CAAC;AAEL,OAAO,SAASa,iBAAiBA,CAACC,SAAiB,EAAmB;EACpE,OAAOL,QAAQ,CAACI,iBAAiB,CAACC,SAAS,CAAC;AAC9C;AAEA,OAAO,SAASC,cAAcA,CAACD,SAAiB,EAAEE,QAAgB,EAAmB;EACnF,OAAOP,QAAQ,CAACM,cAAc,CAACD,SAAS,EAAEE,QAAQ,CAAC;AACrD;AAEA,OAAO,SAASC,aAAaA,CAACH,SAAiB,EAAmB;EAChE,OAAOL,QAAQ,CAACQ,aAAa,CAACH,SAAS,CAAC;AAC1C;AAEA,eAAeL,QAAQ","ignoreList":[]}

package/lib/typescript/src/NativeAirborne.d.ts

@@ -1,8 +1,8 @@
 import type { TurboModule } from 'react-native';
 export interface Spec extends TurboModule {
-    readReleaseConfig(): Promise<string>;
-    getFileContent(filePath: string): Promise<string>;
-    getBundlePath(): Promise<string>;
+    readReleaseConfig(nameSpace: string): Promise<string>;
+    getFileContent(nameSpace: string, filePath: string): Promise<string>;
+    getBundlePath(nameSpace: string): Promise<string>;
 }
 declare const _default: Spec;
 export default _default;

package/lib/typescript/src/NativeAirborne.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeAirborne.d.ts","sourceRoot":"","sources":["../../../src/NativeAirborne.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACrC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAClD,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAClC;;AAED,wBAAkE"}
+{"version":3,"file":"NativeAirborne.d.ts","sourceRoot":"","sources":["../../../src/NativeAirborne.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACtD,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrE,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACnD;;AAED,wBAAkE"}

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

@@ -1,6 +1,6 @@
 declare const Airborne: any;
-export declare function readReleaseConfig(): Promise<string>;
-export declare function getFileContent(filePath: string): Promise<string>;
-export declare function getBundlePath(): Promise<string>;
+export declare function readReleaseConfig(nameSpace: string): Promise<string>;
+export declare function getFileContent(nameSpace: string, filePath: string): Promise<string>;
+export declare function getBundlePath(nameSpace: string): Promise<string>;
 export default Airborne;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AA6BA,QAAA,MAAM,QAAQ,KAST,CAAC;AAEN,wBAAgB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC,CAEnD;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEhE;AAED,wBAAgB,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,CAE/C;AAED,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AA6BA,QAAA,MAAM,QAAQ,KAST,CAAC;AAEN,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEpE;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEnF;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEhE;AAED,eAAe,QAAQ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airborne-react-native",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Airborne",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -58,6 +58,9 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
+  "dependencies": {
+    "airborne-cli-react-native": "file:../airborne_cli"
+  },
   "devDependencies": {
     "@commitlint/config-conventional": "^19.6.0",
     "@eslint/compat": "^1.2.7",

package/src/NativeAirborne.ts

@@ -16,9 +16,9 @@ import type { TurboModule } from 'react-native';
 import { TurboModuleRegistry } from 'react-native';
 
 export interface Spec extends TurboModule {
-  readReleaseConfig(): Promise<string>;
-  getFileContent(filePath: string): Promise<string>;
-  getBundlePath(): Promise<string>;
+  readReleaseConfig(nameSpace: string): Promise<string>;
+  getFileContent(nameSpace: string, filePath: string): Promise<string>;
+  getBundlePath(nameSpace: string): Promise<string>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('Airborne');

package/src/index.tsx

@@ -38,16 +38,16 @@ const Airborne = AirborneModule
       }
     );
 
-export function readReleaseConfig(): Promise<string> {
-  return Airborne.readReleaseConfig();
+export function readReleaseConfig(nameSpace: string): Promise<string> {
+  return Airborne.readReleaseConfig(nameSpace);
 }
 
-export function getFileContent(filePath: string): Promise<string> {
-  return Airborne.getFileContent(filePath);
+export function getFileContent(nameSpace: string, filePath: string): Promise<string> {
+  return Airborne.getFileContent(nameSpace, filePath);
 }
 
-export function getBundlePath(): Promise<string> {
-  return Airborne.getBundlePath();
+export function getBundlePath(nameSpace: string): Promise<string> {
+  return Airborne.getBundlePath(nameSpace);
 }
 
 export default Airborne;

package/lib/typescript/ExampleOldArch/App.d.ts

@@ -1,4 +0,0 @@
-import React from 'react';
-declare function App(): React.JSX.Element;
-export default App;
-//# sourceMappingURL=App.d.ts.map

package/lib/typescript/ExampleOldArch/App.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"App.d.ts","sourceRoot":"","sources":["../../../ExampleOldArch/App.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAYnD,iBAAS,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,OAAO,CAuFhC;AA+ED,eAAe,GAAG,CAAC"}