airborne-react-native 0.1.0

package/AirborneReact.podspec

@@ -0,0 +1,39 @@
+# Copyright 2025 Juspay Technologies
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "AirborneReact"
+  s.requires_arc = true
+  s.module_name  = "AirborneReact"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  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.private_header_files = "ios/**/*.h"
+
+ install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 juspay
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# airborne-react-native
+
+airborne
+
+## Installation
+
+```sh
+npm install airborne-react-native
+```
+
+# React Native Airborne Implementation Summary
+
+This implementation provides a React Native module for Airborne that:
+1. Initializes Airborne in native code (iOS/Android)
+2. Provides React Native methods to access the native Airborne instance
+3. Is compatible with both old and new React Native architectures
+
+## Key Features
+
+### Native Initialization
+- Airborne should be initialized once in native code when the app starts
+- The instance should be created before React Native initializes
+- This ensures the Airborne instance is ready when React Native needs it
+
+### Architecture Compatibility
+- **Old Architecture**: Uses traditional React Native bridge (`AirborneModule`)
+- **New Architecture**: Uses TurboModules with JSI (`AirborneTurboModule`)
+- Automatically detects and uses the appropriate implementation
+
+### Shared Implementation
+- Android uses `AirborneModuleImpl` to share logic between architectures
+- iOS uses `AirborneiOS` wrapper to manage the native instance
+- Both platforms follow the same initialization pattern
+
+## File Structure
+
+### Android
+- `Airborne.kt` - Integration class for Airborne SDK
+- `AirborneInterface.kt` - The interface that has to be implemented by the consumer for providing all the necessary integration params.
+- `AirborneModuleImpl.kt` - Shared implementation logic
+- `AirborneModule.kt` - Old architecture module
+- `AirborneTurboModule.kt` - New architecture module
+- `NativeAirborneSpec.java` - TurboModule spec
+
+### iOS
+- `AirborneiOS.h/m` - Integration class for Airborne SDK
+- `Airborne.h/mm` - React Native module implementation
+- Supports both architectures with conditional compilation
+
+### JavaScript/TypeScript
+- `NativeAirborne.ts` - TurboModule TypeScript spec
+- `index.tsx` - Module exports with architecture detection
+
+## 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
+
+## Usage
+
+### Native Initialization
+
+
+
+### React Native Usage
+```typescript
+import { readReleaseConfig, getFileContent, getBundlePath } from 'airborne-react-native';
+
+// Read configuration
+const config = await readReleaseConfig();
+
+// Get file content
+const content = await getFileContent('path/to/file.json');
+
+// Get bundle path
+const bundlePath = await getBundlePath();
+```
+
+## Implementation Notes
+
+1. **Thread Safety**: Both Android and iOS implementations are thread-safe
+2. **Error Handling**: All methods return promises that reject with descriptive errors
+3. **Placeholder Implementation**: The iOS implementation includes placeholders for the actual Airborne SDK integration
+
+## Next Steps
+
+To complete the integration:
+1. Implement additional Airborne features as needed
+2. Add event emitters for callbacks if required
+
+## Testing
+
+The example app demonstrates:
+- Native initialization in MainApplication/AppDelegate
+- Using all three API methods
+- Status indicator showing initialization state
+- Error handling for failed operations

package/android/build.gradle

@@ -0,0 +1,124 @@
+// Copyright 2025 Juspay Technologies
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import com.android.Version
+
+buildscript {
+    ext.getExtOrDefault = { name ->
+        return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Airborne_' + name]
+    }
+
+    repositories {
+        google()
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "com.android.tools.build:gradle:8.7.2"
+        // noinspection DifferentKotlinGradleVersion
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+    }
+}
+
+def isNewArchitectureEnabled() {
+    return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+
+apply plugin: "com.facebook.react"
+
+def getExtOrDefault(name) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Airborne_' + name]
+}
+
+def getExtOrIntegerDefault(name) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Airborne_" + name]).toInteger()
+}
+
+android {
+
+    def agpVersion = Version.ANDROID_GRADLE_PLUGIN_VERSION
+    // Check AGP version for backward compatibility w/react-native versions still on gradle plugin 6
+    if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
+        namespace = "in.juspay.airborneplugin"
+    }
+
+    compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+    defaultConfig {
+        minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+        targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    }
+
+    buildFeatures {
+        buildConfig true
+    }
+
+    buildTypes {
+        debug {
+            initWith release
+        }
+
+        release {
+            minifyEnabled false
+        }
+    }
+
+    lintOptions {
+        disable "GradleCompatible"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs += [
+                "generated/java",
+                "generated/jni"
+            ]
+        }
+    }
+}
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+    google()
+    maven { url "https://maven.juspay.in/hyper-sdk/" }
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+    implementation "com.facebook.react:react-android"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    // Airborne SDK dependency
+    api "in.juspay:airborne:0.0.1-xota.15"
+}
+
+react {
+    jsRootDir = file("../src/")
+    libraryName = "AirbornePlugin"
+    codegenJavaPackageName = "in.juspay.airborneplugin"
+}

package/android/gradle.properties

@@ -0,0 +1,19 @@
+# Copyright 2025 Juspay Technologies
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+Airborne_kotlinVersion=2.0.21
+Airborne_minSdkVersion=24
+Airborne_targetSdkVersion=34
+Airborne_compileSdkVersion=35
+Airborne_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,125 @@
+package `in`.juspay.airborneplugin
+
+import android.content.Context
+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 org.json.JSONObject
+
+@Keep
+class Airborne (
+    context: Context,
+    releaseConfigUrl: String,
+    private val airborneInterface: AirborneInterface
+) {
+
+    constructor(context: Context, releaseConfigUrl: String) : this(context, releaseConfigUrl, object : AirborneInterface() {})
+
+    /**
+     * Default no-op TrackerCallback.
+     */
+    private val trackerCallback = object : TrackerCallback() {
+
+        override fun track(
+            category: String,
+            subCategory: String,
+            level: String,
+            label: String,
+            key: String,
+            value: JSONObject
+        ) {
+            airborneInterface.onEvent(level, label, key, value, category, subCategory)
+        }
+
+        override fun trackException(
+            category: String,
+            subCategory: String,
+            label: String,
+            description: String,
+            e: Throwable
+        ) {
+            airborneInterface.onEvent(LogLevel.EXCEPTION, label, description, JSONObject().put("throwable", e), category, subCategory)
+        }
+    }
+
+    private val hyperOTAServices = HyperOTAServices(
+        context,
+        airborneInterface.getNamespace(),
+        "",
+        releaseConfigUrl,
+        trackerCallback,
+        airborneInterface::onBootComplete
+    )
+
+    private val applicationManager = hyperOTAServices.createApplicationManager(airborneInterface.getDimensions())
+
+    init {
+        initializer = { this }
+        applicationManager.loadApplication(airborneInterface.getNamespace(), airborneInterface.getLazyDownloadCallback())
+    }
+
+    /**
+     * @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()}" }
+    }
+
+    /**
+     * Reads the content of the given file.
+     * @param filePath The relative path of the file.
+     * @return The content of the file as String.
+     */
+    @Keep
+    fun getFileContent(filePath: String): String {
+        return applicationManager.readSplit(filePath)
+    }
+
+    /**
+     * @return Stringified JSON of the release config.
+     */
+    @Keep
+    fun getReleaseConfig(): String {
+        return applicationManager.readReleaseConfig()
+    }
+
+    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.")
+        }
+
+        /**
+         * Default LazyDownloadCallback implementation.
+         */
+        val defaultLazyCallback = object : LazyDownloadCallback {
+            override fun fileInstalled(filePath: String, success: Boolean) {
+                // Default implementation: log the file installation status
+                if (success) {
+                    println("HyperOTAReact: File installed successfully: $filePath")
+                } else {
+                    println("HyperOTAReact: 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")
+                } else {
+                    println("HyperOTAReact: Lazy splits installation failed")
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+package `in`.juspay.airborneplugin
+
+import `in`.juspay.airborne.LazyDownloadCallback
+import `in`.juspay.airborneplugin.Airborne.Companion.defaultLazyCallback
+import org.json.JSONObject
+
+abstract class AirborneInterface {
+    open fun getNamespace(): String {
+        return "default"
+    }
+
+    open fun getIndexBundlePath(): String {
+        return "index.android.bundle"
+    }
+
+    open fun getDimensions(): HashMap<String, String> {
+        return hashMapOf()
+    }
+
+    open fun onBootComplete(indexPath: String) {
+    }
+
+    open fun onEvent(level: String, label: String, key: String, value: JSONObject, category: String, subCategory: String) {
+    }
+
+    open fun getLazyDownloadCallback(): LazyDownloadCallback {
+        return defaultLazyCallback
+    }
+}

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

@@ -0,0 +1,37 @@
+package `in`.juspay.airborneplugin
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = AirborneModule.NAME)
+class AirborneModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val implementation = AirborneModuleImpl(reactContext)
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod
+  fun readReleaseConfig(promise: Promise) {
+    implementation.readReleaseConfig(promise)
+  }
+
+  @ReactMethod
+  fun getFileContent(filePath: String, promise: Promise) {
+    implementation.getFileContent(filePath, promise)
+  }
+
+  @ReactMethod
+  fun getBundlePath(promise: Promise) {
+    implementation.getBundlePath(promise)
+  }
+
+  companion object {
+    const val NAME = "Airborne"
+  }
+}

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

@@ -0,0 +1,71 @@
+package `in`.juspay.airborneplugin
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.Promise
+
+/**
+ * Implementation class that handles the actual Airborne operations.
+ * This class is shared between old and new architecture modules.
+ */
+class AirborneModuleImpl(private val reactContext: ReactApplicationContext) {
+
+    companion object {
+//        private var isInitialized = false
+
+//        /**
+//         * Initialize Airborne from native code (typically from MainApplication)
+//         */
+//        @JvmStatic
+//        fun initializeHyperOTA(
+//          context: Context,
+//          appId: String,
+//          indexFileName: String,
+//          appVersion: String,
+//          releaseConfigTemplateUrl: String,
+//          headers: Map<String, String>? = null,
+//          lazyDownloadCallback: LazyDownloadCallback? = null,
+//          trackerCallback: TrackerCallback? = null
+//        ) {
+//            if (!isInitialized) {
+//              Airborne.init(
+//                context,
+//                appId,
+//                indexFileName,
+//                appVersion,
+//                releaseConfigTemplateUrl,
+//                headers,
+//                lazyDownloadCallback,
+//                trackerCallback
+//              )
+//                isInitialized = true
+//            }
+//        }
+    }
+
+    fun readReleaseConfig(promise: Promise) {
+        try {
+            val config = Airborne.instance.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) {
+        try {
+            val content = Airborne.instance.getFileContent(filePath)
+            promise.resolve(content)
+        } catch (e: Exception) {
+            promise.reject("AIRBORNE_ERROR", "Failed to read file content: ${e.message}", e)
+        }
+    }
+
+    fun getBundlePath(promise: Promise) {
+        try {
+            val path = Airborne.instance.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

@@ -0,0 +1,39 @@
+package `in`.juspay.airborneplugin
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import 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 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/AirborneTurboModule.kt

@@ -0,0 +1,32 @@
+package `in`.juspay.airborneplugin
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.Promise
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = AirborneTurboModule.NAME)
+class AirborneTurboModule(reactContext: ReactApplicationContext) :
+  NativeAirborneSpec(reactContext) {
+
+  private val implementation = AirborneModuleImpl(reactContext)
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun readReleaseConfig(promise: Promise) {
+    implementation.readReleaseConfig(promise)
+  }
+
+  override fun getFileContent(filePath: String, promise: Promise) {
+    implementation.getFileContent(filePath, promise)
+  }
+
+  override fun getBundlePath(promise: Promise) {
+    implementation.getBundlePath(promise)
+  }
+
+  companion object {
+    const val NAME = "HyperOta"
+  }
+}

package/ios/Airborne.h

@@ -0,0 +1,17 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <AirborneSpec/AirborneSpec.h>
+
+@interface Airborne : NSObject <NativeAirborneSpec>
+#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;
+
+@end

package/ios/Airborne.mm

@@ -0,0 +1,99 @@
+#import "Airborne.h"
+#import "AirborneiOS.h"
+#import <React/RCTLog.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");
+                                  }];
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)readReleaseConfig:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject {
+    @try {
+        NSString *config = [[AirborneiOS sharedInstance] getReleaseConfig];
+        resolve(config);
+    } @catch (NSException *exception) {
+        reject(@"AIRBORNE_ERROR", exception.reason, nil);
+    }
+}
+
+- (void)getFileContent:(NSString *)filePath
+               resolve:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject {
+    @try {
+        NSString *content = [[AirborneiOS sharedInstance] getFileContent:filePath];
+        resolve(content);
+    } @catch (NSException *exception) {
+        reject(@"AIRBORNE_ERROR", exception.reason, nil);
+    }
+}
+
+- (void)getBundlePath:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject {
+    @try {
+        NSString *bundlePath = [[AirborneiOS sharedInstance] getBundlePath];
+        resolve(bundlePath);
+    } @catch (NSException *exception) {
+        reject(@"AIRBORNE_ERROR", exception.reason, nil);
+    }
+}
+#else
+RCT_EXPORT_METHOD(readReleaseConfig:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        NSString *config = [[AirborneiOS sharedInstance] getReleaseConfig];
+        resolve(config);
+    } @catch (NSException *exception) {
+        reject(@"AIRBORNE_ERROR", exception.reason, nil);
+    }
+}
+
+RCT_EXPORT_METHOD(getFileContent:(NSString *)filePath
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        NSString *content = [[AirborneiOS sharedInstance] getFileContent:filePath];
+        resolve(content);
+    } @catch (NSException *exception) {
+        reject(@"AIRBORNE_ERROR", exception.reason, nil);
+    }
+}
+
+RCT_EXPORT_METHOD(getBundlePath:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        NSString *bundlePath = [[AirborneiOS sharedInstance] getBundlePath];
+        resolve(bundlePath);
+    } @catch (NSException *exception) {
+        reject(@"AIRBORNE_ERROR", exception.reason, nil);
+    }
+}
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeAirborneSpecJSI>(params);
+}
+#endif
+
+@end

package/ios/AirborneiOS.h

@@ -0,0 +1,26 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+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;
+
+- (NSString *)getBundlePath;
+- (NSString *)getFileContent:(NSString *)filePath;
+- (NSString *)getReleaseConfig;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/AirborneiOS.m

@@ -0,0 +1,128 @@
+#import "AirborneiOS.h"
+
+@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
+@end
+
+@implementation AirborneiOS
+
++ (instancetype)sharedInstance {
+    static AirborneiOS *sharedInstance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        sharedInstance = [[self alloc] init];
+    });
+    return sharedInstance;
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _isInitialized = NO;
+    }
+    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);
+        });
+    }
+}
+
+- (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 @"";
+}
+
+- (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 @"";
+}
+
+- (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 @"{}";
+}
+
+@end

package/lib/module/NativeAirborne.js

@@ -0,0 +1,19 @@
+"use strict";
+
+// Copyright 2025 Juspay Technologies
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('Airborne');
+//# sourceMappingURL=NativeAirborne.js.map

package/lib/module/NativeAirborne.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeAirborne.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,SAASA,mBAAmB,QAAQ,cAAc;AAQlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,UAAU,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+// Copyright 2025 Juspay Technologies
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { NativeModules, Platform } from 'react-native';
+const LINKING_ERROR = `The package 'airborne-react-native' doesn't seem to be linked. Make sure: \n\n` + Platform.select({
+  ios: "- You have run 'pod install'\n",
+  default: ''
+}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
+
+// @ts-expect-error
+const isTurboModuleEnabled = global.__turboModuleProxy != null;
+const AirborneModule = isTurboModuleEnabled ? require('./NativeAirborne').default : NativeModules.Airborne;
+const Airborne = AirborneModule ? AirborneModule : new Proxy({}, {
+  get() {
+    throw new Error(LINKING_ERROR);
+  }
+});
+export function readReleaseConfig() {
+  return Airborne.readReleaseConfig();
+}
+export function getFileContent(filePath) {
+  return Airborne.getFileContent(filePath);
+}
+export function getBundlePath() {
+  return Airborne.getBundlePath();
+}
+export default Airborne;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +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":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

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

@@ -0,0 +1,9 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    readReleaseConfig(): Promise<string>;
+    getFileContent(filePath: string): Promise<string>;
+    getBundlePath(): Promise<string>;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeAirborne.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +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 default Airborne;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/package.json

@@ -0,0 +1,164 @@
+{
+  "name": "airborne-react-native",
+  "version": "0.1.0",
+  "description": "Airborne",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace airborne-react-native-example",
+    "test": "jest",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "release": "release-it --only-version"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/juspay/airborne.git"
+  },
+  "author": "juspay <kuntimaddi.manideep@juspay.in> (https://github.com/juspay)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/juspay/airborne/issues"
+  },
+  "homepage": "https://github.com/juspay/airborne#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.6.0",
+    "@eslint/compat": "^1.2.7",
+    "@eslint/eslintrc": "^3.3.0",
+    "@eslint/js": "^9.22.0",
+    "@evilmartians/lefthook": "^1.5.0",
+    "@react-native-community/cli": "15.0.0-alpha.2",
+    "@react-native/babel-preset": "0.79.2",
+    "@react-native/eslint-config": "^0.78.0",
+    "@release-it/conventional-changelog": "^9.0.2",
+    "@types/jest": "^29.5.5",
+    "@types/react": "^19.0.0",
+    "commitlint": "^19.6.1",
+    "del-cli": "^5.1.0",
+    "eslint": "^9.22.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-prettier": "^5.2.3",
+    "jest": "^29.7.0",
+    "prettier": "^3.0.3",
+    "react": "19.0.0",
+    "react-native": "0.79.2",
+    "react-native-builder-bob": "^0.40.11",
+    "release-it": "^17.10.0",
+    "turbo": "^1.10.7",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@3.6.1",
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "AirborneSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "in.juspay.airborneplugin"
+    }
+  },
+  "create-react-native-library": {
+    "languages": "kotlin-objc",
+    "type": "turbo-module",
+    "version": "0.50.3"
+  }
+}

package/src/NativeAirborne.ts

@@ -0,0 +1,24 @@
+// Copyright 2025 Juspay Technologies
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+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>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Airborne');

package/src/index.tsx

@@ -0,0 +1,53 @@
+// Copyright 2025 Juspay Technologies
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { NativeModules, Platform } from 'react-native';
+
+const LINKING_ERROR =
+  `The package 'airborne-react-native' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go\n';
+
+// @ts-expect-error
+const isTurboModuleEnabled = global.__turboModuleProxy != null;
+
+const AirborneModule = isTurboModuleEnabled
+  ? require('./NativeAirborne').default
+  : NativeModules.Airborne;
+
+const Airborne = AirborneModule
+  ? AirborneModule
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+export function readReleaseConfig(): Promise<string> {
+  return Airborne.readReleaseConfig();
+}
+
+export function getFileContent(filePath: string): Promise<string> {
+  return Airborne.getFileContent(filePath);
+}
+
+export function getBundlePath(): Promise<string> {
+  return Airborne.getBundlePath();
+}
+
+export default Airborne;