airborne-react-native 0.2.0 → 0.3.2

package/AirborneReact.podspec

@@ -28,15 +28,12 @@ Pod::Spec.new do |s|
 
   s.platforms    = { :ios => "12.0"}
   s.source       = { :git => "https://github.com/juspay/airborne.git", :tag => "#{s.version}" }
-  s.resource_bundles = {
-    'AirborneReactResources' => ['ios/**/*.{xib,storyboard,xcassets,json}']
-  }
 
   s.source_files = "ios/**/*.{h,m,mm,cpp}"
   s.public_header_files = "ios/**/*.h"
   s.static_framework = false
-
-  s.dependency "Airborne", "0.0.4"
-
- install_modules_dependencies(s)
+  
+  s.dependency "Airborne", "0.3.2"
+  
+  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,25 +1,18 @@
-#import "AirborneiOS.h"
-#ifdef RCT_NEW_ARCH_ENABLED
-#import <AirborneSpec/AirborneSpec.h>
+#import <Foundation/Foundation.h>
+#import <Airborne/Airborne-Swift.h>
 
-@interface Airborne : NSObject <NativeAirborneSpec>
-#else
-#import <React/RCTBridgeModule.h>
+NS_ASSUME_NONNULL_BEGIN
 
+@interface Airborne : NSObject
 
-@interface Airborne : NSObject <RCTBridgeModule>
-#endif
++ (instancetype)sharedInstanceWithNamespace:(NSString *)aNamespace;
 
-+ (void)initializeAirborneWithReleaseConfigUrl:(NSString *) releaseConfigUrl;
+- (instancetype)initWithReleaseConfigURL:(NSString *)releaseConfigURL delegate:(id<AirborneDelegate>)delegate;
 
-+ (void)initializeAirborneWithReleaseConfigUrl:(NSString *) releaseConfigUrl
-                                   inNamespace:(NSString *) ns;
-
-+ (void)initializeAirborneWithReleaseConfigUrl:(NSString *)releaseConfigUrl
-                                      delegate:delegate;
-
-+ (void)initializeAirborneWithReleaseConfigUrl:(NSString *) releaseConfigUrl
-                                   inNamespace:(NSString *) ns
-                                      delegate:(id<AirborneReactDelegate>) delegate;
+- (NSString *)getBundlePath;
+- (NSString *)getFileContent:(NSString *)filePath;
+- (NSString *)getReleaseConfig;
 
 @end
+
+NS_ASSUME_NONNULL_END

package/ios/Airborne.m

@@ -0,0 +1,80 @@
+
+#import "Airborne.h"
+
+@interface Airborne() <AirborneDelegate>
+
+@property (nonatomic, strong) NSString* namespace;
+@property (nonatomic, strong) AirborneServices* airborne;
+@property (nonatomic, weak) id <AirborneDelegate> delegate;
+
+@end
+
+@implementation Airborne
+
++ (instancetype)sharedInstanceWithNamespace:(NSString *)aNamespace {
+    static NSMutableDictionary<NSString *, Airborne *> *instances = nil;
+    static dispatch_queue_t syncQueue;
+    static dispatch_once_t onceToken;
+    
+    // Initialize dictionary and queue once
+    dispatch_once(&onceToken, ^{
+        instances = [NSMutableDictionary dictionary];
+        syncQueue = dispatch_queue_create("in.juspay.Airborne.singleton", DISPATCH_QUEUE_CONCURRENT);
+    });
+    
+    __block Airborne *instance = nil;
+    
+    // Read existing instance (concurrent)
+    dispatch_sync(syncQueue, ^{
+        instance = instances[aNamespace];
+    });
+    
+    if (instance == nil) {
+        // Write new instance (barrier to prevent concurrent writes)
+        dispatch_barrier_sync(syncQueue, ^{
+            if (!instances[aNamespace]) {
+                instances[aNamespace] = [[self alloc] initWithNamespace:aNamespace];
+            }
+            instance = instances[aNamespace];
+        });
+    }
+    
+    return instance;
+}
+
+- (instancetype)initWithNamespace:(NSString *)namespace {
+    self = [super init];
+    if (self) {
+        self.namespace = namespace;
+    }
+    return self;
+}
+
+- (instancetype)initWithReleaseConfigURL:(NSString *)releaseConfigURL delegate:(id<AirborneDelegate>)delegate {
+    self = [super init];
+    if (self) {
+        self.airborne = [[AirborneServices alloc] initWithReleaseConfigURL:releaseConfigURL delegate:delegate ?: self];
+    }
+    return self;
+}
+
+- (NSString *)getBundlePath {
+    return [self.airborne getIndexBundlePath].absoluteString;
+}
+
+- (NSString *)getFileContent:(NSString *)filePath {
+    return [self.airborne getFileContentAtPath:filePath];
+}
+
+- (NSString *)getReleaseConfig {
+    return [self.airborne getReleaseConfig];
+}
+
+#pragma mark - AirborneDelegate
+
+- (NSString *)namespace {
+    return @"default";
+}
+
+@end
+

package/ios/AirborneReact.h

@@ -0,0 +1,26 @@
+#import "Airborne.h"
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <AirborneSpec/AirborneSpec.h>
+#import <Airborne/Airborne-Swift.h>
+
+@interface AirborneReact : NSObject <NativeAirborneSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+
+@interface AirborneReact : NSObject <RCTBridgeModule>
+#endif
+
++ (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<AirborneDelegate>) delegate;
+
+@end

package/ios/{Airborne.mm → AirborneReact.mm}

@@ -1,10 +1,11 @@
+#import "AirborneReact.h"
 #import "Airborne.h"
-#import "AirborneiOS.h"
 #import <React/RCTLog.h>
-#import <Airborne/Airborne.h>
+#import <Airborne/AJPLoggerDelegate.h>
+#import <Airborne/AJPApplicationManager.h>
 #import <Airborne/Airborne-Swift.h>
 
-@implementation Airborne
+@implementation AirborneReact
 
 RCT_EXPORT_MODULE(Airborne)
 
@@ -15,25 +16,22 @@ static NSString * const defaultNamespace = @"default";
 }
 
 + (void)initializeAirborneWithReleaseConfigUrl:(NSString *)releaseConfigUrl inNamespace:ns {
-    AirborneiOS* air = [AirborneiOS sharedInstanceWithNamespace:ns];
-    [air loadWithReleaseConfig:releaseConfigUrl delegate:nil];
+    AJPApplicationManager* manager = [AJPApplicationManager getSharedInstanceWithWorkspace:ns delegate:nil logger:nil];
 }
 
 + (void)initializeAirborneWithReleaseConfigUrl:(NSString *)releaseConfigUrl delegate:delegate {
-    AirborneiOS* air = [AirborneiOS sharedInstanceWithNamespace:defaultNamespace];
-    [air loadWithReleaseConfig:releaseConfigUrl delegate:delegate];
+    AJPApplicationManager* manager = [AJPApplicationManager getSharedInstanceWithWorkspace:defaultNamespace delegate:delegate logger:nil];
 }
 
 + (void)initializeAirborneWithReleaseConfigUrl:(NSString *)releaseConfigUrl inNamespace:ns delegate:delegate {
-    AirborneiOS* air = [AirborneiOS sharedInstanceWithNamespace:ns];
-    [air loadWithReleaseConfig:releaseConfigUrl delegate:delegate];
+    AJPApplicationManager* manager = [AJPApplicationManager getSharedInstanceWithWorkspace:ns delegate:delegate logger:nil];
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
 - (void)readReleaseConfig:(RCTPromiseResolveBlock)resolve
                    reject:(RCTPromiseRejectBlock)reject {
     @try {
-        NSString *config = [[AirborneiOS sharedInstanceWithNamespace:defaultNamespace] getReleaseConfig];
+        NSString *config = [[Airborne sharedInstanceWithNamespace:defaultNamespace] getReleaseConfig];
         resolve(config);
     } @catch (NSException *exception) {
         reject(@"AIRBORNE_ERROR", exception.reason, nil);
@@ -44,7 +42,7 @@ static NSString * const defaultNamespace = @"default";
                resolve:(RCTPromiseResolveBlock)resolve
                 reject:(RCTPromiseRejectBlock)reject {
     @try {
-        NSString *content = [[AirborneiOS sharedInstanceWithNamespace:defaultNamespace] getFileContent:filePath];
+        NSString *content = [[Airborne sharedInstanceWithNamespace:defaultNamespace] getFileContent:filePath];
         resolve(content);
     } @catch (NSException *exception) {
         reject(@"AIRBORNE_ERROR", exception.reason, nil);
@@ -54,7 +52,7 @@ static NSString * const defaultNamespace = @"default";
 - (void)getBundlePath:(RCTPromiseResolveBlock)resolve
                reject:(RCTPromiseRejectBlock)reject {
     @try {
-        NSString *bundlePath = [[AirborneiOS sharedInstanceWithNamespace:defaultNamespace] getBundlePath];
+        NSString *bundlePath = [[Airborne sharedInstanceWithNamespace:defaultNamespace] getBundlePath];
         resolve(bundlePath);
     } @catch (NSException *exception) {
         reject(@"AIRBORNE_ERROR", exception.reason, nil);

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.2.0",
+  "version": "0.3.2",
   "description": "Airborne",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

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/ios/AirborneiOS.h

@@ -1,75 +0,0 @@
-#import <Foundation/Foundation.h>
-
-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;
-
-/**
- * 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)onBootComplete:(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)sharedInstanceWithNamespace:(NSString *)ns;
-
-- (void) loadWithReleaseConfig:(NSString *) rcurl delegate:(id<AirborneReactDelegate>) delegate;
-- (NSString *)getBundlePath;
-- (NSString *)getFileContent:(NSString *)filePath;
-- (NSString *)getReleaseConfig;
-
-@end
-
-NS_ASSUME_NONNULL_END

package/ios/AirborneiOS.m

@@ -1,114 +0,0 @@
-#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{
-    return self.ns;
-}
-
-- (NSDictionary *)dimensions{
-    if(_delegate == nil) return @{};
-    return [_delegate getDimensions];
-}
-
-- (void)onBootCompleteWithIndexBundlePath:(NSString *)indexBundlePath{
-    if (_delegate == nil) return;
-    [_delegate onBootComplete: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, strong) NSString* ns;
-@property (nonatomic, strong) AirborneServices* air;
-@property (nonatomic, strong) id<AirborneDelegate> delegate;
-@property (nonatomic, strong) AirborneLocalDelegate* delegateproxy;
-
-@end
-
-@implementation AirborneiOS
-
-+ (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, ^{
-        instances = [NSMutableDictionary dictionary];
-        syncQueue = dispatch_queue_create("in.juspay.Airborne.singleton", DISPATCH_QUEUE_CONCURRENT);
-    });
-
-    __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)initWithNamespace:(NSString *) ns{
-    self = [super init];
-    if (self) {
-        _ns = ns;
-        
-    }
-    return self;
-}
-
-- (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 {
-    return [_air getIndexBundlePath] ;
-}
-
-- (NSString *)getFileContent:(NSString *)filePath {
-    return [_air getFileContentAtPath:filePath];
-}
-
-- (NSString *)getReleaseConfig {
-    return [_air getReleaseConfig];
-}
-
-@end
-

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"}