react-native-ota-client 0.0.0-stage → 0.1.0

package/android/src/main/java/com/otasdk/OtaUpdateManager.kt

@@ -0,0 +1,384 @@
+package com.otasdk
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.net.Uri
+import android.util.Log
+import java.io.File
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.MessageDigest
+import java.util.UUID
+import org.json.JSONObject
+
+internal class OtaUpdateManager(context: Context, private val config: OtaSdkConfig) {
+  private val appContext = context.applicationContext
+  private val preferences: SharedPreferences =
+      appContext.getSharedPreferences(PREFERENCES_NAME, Context.MODE_PRIVATE)
+  private val stateLock = Any()
+  private val otaRoot = File(appContext.filesDir, "ota")
+  private val updatesDirectory = File(otaRoot, "updates")
+  private val stagingDirectory = File(otaRoot, "staging")
+  private val publicKeyPem: ByteArray = config.publicKeyPem.copyOf()
+
+  @Volatile private var startupBundlePath: String? = null
+
+  /** Called from Application.onCreate before ReactHost is initialized. */
+  fun beginProcess() {
+    if (config.isDebugBuild) {
+      startupBundlePath = null
+      return
+    }
+
+    synchronized(stateLock) {
+      val savedRuntime = preferences.getString(KEY_RUNTIME_VERSION, null)
+      if (savedRuntime != null && savedRuntime != config.runtimeVersion) {
+        // OTA bundles are native-runtime specific. Never boot a bundle from another APK runtime.
+        preferences.edit().clear().putString(KEY_RUNTIME_VERSION, config.runtimeVersion).commit()
+        updatesDirectory.deleteRecursively()
+        stagingDirectory.deleteRecursively()
+      } else if (savedRuntime == null) {
+        preferences.edit().putString(KEY_RUNTIME_VERSION, config.runtimeVersion).commit()
+      }
+
+      val before = readActivationState()
+      val transition = OtaActivationPolicy.beginStartup(before)
+      persistActivationState(transition.state)
+      transition.failedReleaseId?.let { File(updatesDirectory, it).deleteRecursively() }
+
+      val selected = transition.selectedReleaseId?.let(::bundleFile)
+      if (selected != null && selected.isFile) {
+        startupBundlePath = selected.absolutePath
+      } else if (transition.selectedReleaseId != null) {
+        // A missing active bundle must never prevent the APK's embedded bundle from starting.
+        val currentState = readActivationState()
+        val fallback =
+            if (currentState.pendingReleaseId != null) {
+              OtaActivationPolicy.beginStartup(
+                      currentState.copy(pendingLaunchAttempted = true)
+                  )
+                  .state
+            } else {
+              currentState.copy(activeReleaseId = null, activeVersion = config.baseVersion)
+            }
+        persistActivationState(
+            fallback.copy(
+                pendingReleaseId = null,
+                pendingVersion = null,
+                previousReleaseId = null,
+                previousVersion = null,
+                pendingLaunchAttempted = false,
+            )
+        )
+        startupBundlePath = null
+      } else {
+        startupBundlePath = null
+      }
+    }
+  }
+
+  fun bundlePathForReactHost(): String? = startupBundlePath
+
+  fun status(): Map<String, Any?> = synchronized(stateLock) {
+    val state = readActivationState()
+    val pending = state.pendingReleaseId != null
+    mapOf(
+        "enabled" to !config.isDebugBuild,
+        "status" to if (config.isDebugBuild) "debug_build" else if (pending) "restart_required" else "ready",
+        "message" to if (config.isDebugBuild) {
+          "OTA activation is tested with a release APK; debug builds load Metro."
+        } else if (pending) {
+          "A verified update is ready. Close and reopen the app to apply it."
+        } else {
+          "This app is using its active bundle."
+        },
+        "runtimeVersion" to config.runtimeVersion,
+        "channel" to config.channel,
+        "currentVersion" to state.activeVersion,
+        "pendingVersion" to state.pendingVersion,
+        "pendingRestart" to pending,
+        "updateAvailable" to pending,
+        "action" to null,
+    )
+  }
+
+  fun markHealthy(): Map<String, Any?> = synchronized(stateLock) {
+    if (config.isDebugBuild) return status()
+    val before = readActivationState()
+    val after = OtaActivationPolicy.markHealthy(before)
+    if (after != before) {
+      persistActivationState(after)
+      Log.i(TAG, "OTA release ${after.activeReleaseId} confirmed healthy")
+    }
+    status()
+  }
+
+  fun checkForUpdate(): Map<String, Any?> {
+    if (config.isDebugBuild) return status()
+    if (!supportsConfiguredTransport()) {
+      return result(
+          "error",
+          "HTTPS is required unless the host app explicitly allows local development HTTP.",
+      )
+    }
+
+    val currentState = synchronized(stateLock) { readActivationState() }
+    if (currentState.pendingReleaseId != null) return status()
+
+    return try {
+      val response = requestUpdateCheck(currentState.activeVersion)
+      if (!response.has("update_available")) {
+        throw OtaVerificationException("Update server response is missing update_available")
+      }
+      if (!response.getBoolean("update_available")) {
+        return result("up_to_date", "No compatible update is available.")
+      }
+
+      val releaseJson = response.getJSONObject("release")
+      val verified =
+          OtaReleaseVerifier.verify(
+              releaseJson = releaseJson,
+              publicKeyPem = publicKeyPem,
+              expectedAppId = config.appId,
+              expectedRuntimeVersion = config.runtimeVersion,
+              expectedChannel = config.channel,
+              currentVersion = currentState.activeVersion,
+          )
+      validateDownloadUrl(verified.downloadUrl)
+
+      val existingDirectory = OtaBundleInstaller.releaseDirectory(updatesDirectory, verified.manifest.releaseId)
+      if (!OtaBundleInstaller.verifyExisting(existingDirectory, verified)) {
+        val archive = downloadArchive(verified)
+        try {
+          OtaBundleInstaller.install(archive, updatesDirectory, verified)
+        } finally {
+          archive.delete()
+        }
+      }
+
+      synchronized(stateLock) {
+        val latestState = readActivationState()
+        if (latestState.pendingReleaseId != null) return status()
+        val staged = OtaActivationPolicy.stage(
+            latestState,
+            verified.manifest.releaseId,
+            verified.manifest.version,
+        )
+        persistActivationState(staged)
+      }
+      result(
+          "restart_required",
+          "Verified release ${verified.manifest.version} is ready. Close and reopen the app to apply it.",
+          pendingVersion = verified.manifest.version,
+          action = verified.action,
+      )
+    } catch (exception: Exception) {
+      Log.w(TAG, "OTA update check failed", exception)
+      result("error", exception.message ?: "The update could not be verified or downloaded.")
+    }
+  }
+
+  fun closeAppForUpdate(currentActivity: android.app.Activity) {
+    android.os.Handler(android.os.Looper.getMainLooper()).post {
+      currentActivity.finishAndRemoveTask()
+      android.os.Handler(android.os.Looper.getMainLooper()).postDelayed(
+          { android.os.Process.killProcess(android.os.Process.myPid()) },
+          150,
+      )
+    }
+  }
+
+  private fun requestUpdateCheck(currentVersion: Int): JSONObject {
+    val installationId =
+        preferences.getString(KEY_INSTALLATION_ID, null) ?: UUID.randomUUID().toString().also {
+          check(preferences.edit().putString(KEY_INSTALLATION_ID, it).commit()) {
+            "Could not persist installation ID"
+          }
+        }
+    val requestBody =
+        JSONObject()
+            .put("platform", "android")
+            .put("app_id", config.appId)
+            .put("runtime_version", config.runtimeVersion)
+            .put("channel", config.channel)
+            .put("current_version", currentVersion)
+            .put("installation_id", installationId)
+            .put("failed_release_id", readActivationState().failedReleaseId ?: JSONObject.NULL)
+
+    val url = URL("${config.serverUrl.trimEnd('/')}/api/v1/updates/check")
+    val connection = openConnection(url).apply {
+      requestMethod = "POST"
+      doOutput = true
+      setRequestProperty("Content-Type", "application/json; charset=utf-8")
+      setRequestProperty("Accept", "application/json")
+    }
+    try {
+      connection.outputStream.use { it.write(requestBody.toString().toByteArray(Charsets.UTF_8)) }
+      val code = connection.responseCode
+      val stream = if (code in 200..299) connection.inputStream else connection.errorStream
+      val body = stream?.bufferedReader(Charsets.UTF_8)?.use { it.readText() }.orEmpty()
+      if (code !in 200..299) throw OtaVerificationException("Update server returned HTTP $code")
+      return JSONObject(body)
+    } finally {
+      connection.disconnect()
+    }
+  }
+
+  private fun downloadArchive(release: VerifiedOtaRelease): File {
+    validateDownloadUrl(release.downloadUrl)
+    stagingDirectory.mkdirs()
+    val archive = File(stagingDirectory, "${release.manifest.releaseId}.zip.part")
+    archive.delete()
+    val connection = openConnection(URL(release.downloadUrl)).apply {
+      requestMethod = "GET"
+      setRequestProperty("Accept", "application/zip")
+    }
+    try {
+      val code = connection.responseCode
+      if (code != HttpURLConnection.HTTP_OK) {
+        throw OtaVerificationException("Bundle server returned HTTP $code")
+      }
+      val contentLength = connection.contentLengthLong
+      if (contentLength > MAX_ARTIFACT_BYTES ||
+          (contentLength >= 0L && contentLength != release.manifest.artifactSizeBytes)) {
+        throw OtaVerificationException("Bundle download size does not match the signed manifest")
+      }
+
+      val digest = MessageDigest.getInstance("SHA-256")
+      var total = 0L
+      connection.inputStream.use { input ->
+        FileOutputStream(archive).use { output ->
+          val buffer = ByteArray(DEFAULT_BUFFER_SIZE)
+          while (true) {
+            val count = input.read(buffer)
+            if (count < 0) break
+            total += count
+            if (total > MAX_ARTIFACT_BYTES || total > release.manifest.artifactSizeBytes) {
+              throw OtaVerificationException("Bundle exceeds the permitted download size")
+            }
+            digest.update(buffer, 0, count)
+            output.write(buffer, 0, count)
+          }
+          output.fd.sync()
+        }
+      }
+      if (total != release.manifest.artifactSizeBytes ||
+          digest.digest().toHex() != release.manifest.artifactSha256) {
+        throw OtaVerificationException("Downloaded bundle hash or size does not match the signed manifest")
+      }
+      return archive
+    } catch (exception: Exception) {
+      archive.delete()
+      throw exception
+    } finally {
+      connection.disconnect()
+    }
+  }
+
+  private fun openConnection(url: URL): HttpURLConnection {
+    return (url.openConnection() as HttpURLConnection).apply {
+      connectTimeout = CONNECT_TIMEOUT_MILLIS
+      readTimeout = READ_TIMEOUT_MILLIS
+      instanceFollowRedirects = false
+      useCaches = false
+    }
+  }
+
+  private fun validateDownloadUrl(downloadUrl: String) {
+    val base = Uri.parse(config.serverUrl)
+    val download = Uri.parse(downloadUrl)
+    val basePort = effectivePort(base)
+    if (download.userInfo != null || download.host != base.host || effectivePort(download) != basePort) {
+      throw OtaVerificationException("Bundle URL must use the configured OTA server origin")
+    }
+    if (download.scheme != base.scheme) {
+      throw OtaVerificationException("Bundle URL scheme does not match the configured OTA server")
+    }
+    if (download.scheme != "https" && !isLocalDevelopmentHttpAllowed(download)) {
+      throw OtaVerificationException("Release APKs require HTTPS for OTA downloads")
+    }
+  }
+
+  private fun supportsConfiguredTransport(): Boolean =
+      Uri.parse(config.serverUrl).scheme == "https" ||
+          isLocalDevelopmentHttpAllowed(Uri.parse(config.serverUrl))
+
+  private fun isLocalDevelopmentHttpAllowed(uri: Uri): Boolean =
+      config.allowInsecureHttp &&
+          uri.scheme == "http" &&
+          uri.host?.lowercase() in setOf("localhost", "127.0.0.1", "::1", "10.0.2.2")
+
+  private fun effectivePort(uri: Uri): Int =
+      if (uri.port != -1) uri.port else if (uri.scheme == "https") 443 else 80
+
+  private fun readActivationState(): OtaActivationState =
+      OtaActivationState(
+          activeReleaseId = preferences.getString(KEY_ACTIVE_RELEASE_ID, null),
+          activeVersion = preferences.getInt(KEY_ACTIVE_VERSION, config.baseVersion),
+          pendingReleaseId = preferences.getString(KEY_PENDING_RELEASE_ID, null),
+          pendingVersion = preferences.getInt(KEY_PENDING_VERSION, -1).takeIf { it >= 0 },
+          previousReleaseId = preferences.getString(KEY_PREVIOUS_RELEASE_ID, null),
+          previousVersion = preferences.getInt(KEY_PREVIOUS_VERSION, -1).takeIf { it >= 0 },
+          pendingLaunchAttempted = preferences.getBoolean(KEY_PENDING_LAUNCH_ATTEMPTED, false),
+          failedReleaseId = preferences.getString(KEY_FAILED_RELEASE_ID, null),
+      )
+
+  private fun persistActivationState(state: OtaActivationState) {
+    val editor =
+        preferences.edit()
+            .putString(KEY_RUNTIME_VERSION, config.runtimeVersion)
+            .putInt(KEY_ACTIVE_VERSION, state.activeVersion)
+            .putBoolean(KEY_PENDING_LAUNCH_ATTEMPTED, state.pendingLaunchAttempted)
+    editor.putNullableString(KEY_ACTIVE_RELEASE_ID, state.activeReleaseId)
+    editor.putNullableString(KEY_PENDING_RELEASE_ID, state.pendingReleaseId)
+    editor.putNullableInt(KEY_PENDING_VERSION, state.pendingVersion)
+    editor.putNullableString(KEY_PREVIOUS_RELEASE_ID, state.previousReleaseId)
+    editor.putNullableInt(KEY_PREVIOUS_VERSION, state.previousVersion)
+    editor.putNullableString(KEY_FAILED_RELEASE_ID, state.failedReleaseId)
+    check(editor.commit()) { "Could not save OTA activation state" }
+  }
+
+  private fun bundleFile(releaseId: String): File =
+      File(OtaBundleInstaller.releaseDirectory(updatesDirectory, releaseId), "index.android.bundle")
+
+  private fun result(
+      status: String,
+      message: String,
+      pendingVersion: Int? = null,
+      action: String? = null,
+  ): Map<String, Any?> =
+      status().toMutableMap().apply {
+        put("status", status)
+        put("message", message)
+        put("updateAvailable", status == "restart_required")
+        put("action", action)
+        if (pendingVersion != null) put("pendingVersion", pendingVersion)
+      }
+
+  private fun SharedPreferences.Editor.putNullableString(key: String, value: String?) =
+      if (value == null) remove(key) else putString(key, value)
+
+  private fun SharedPreferences.Editor.putNullableInt(key: String, value: Int?) =
+      if (value == null) remove(key) else putInt(key, value)
+
+  private fun ByteArray.toHex(): String = joinToString("") { byte -> "%02x".format(byte) }
+
+  companion object {
+    private const val TAG = "OTAUpdates"
+    private const val PREFERENCES_NAME = "ota_update_state"
+    private const val KEY_RUNTIME_VERSION = "runtime_version"
+    private const val KEY_INSTALLATION_ID = "installation_id"
+    private const val KEY_ACTIVE_RELEASE_ID = "active_release_id"
+    private const val KEY_ACTIVE_VERSION = "active_version"
+    private const val KEY_PENDING_RELEASE_ID = "pending_release_id"
+    private const val KEY_PENDING_VERSION = "pending_version"
+    private const val KEY_PREVIOUS_RELEASE_ID = "previous_release_id"
+    private const val KEY_PREVIOUS_VERSION = "previous_version"
+    private const val KEY_PENDING_LAUNCH_ATTEMPTED = "pending_launch_attempted"
+    private const val KEY_FAILED_RELEASE_ID = "failed_release_id"
+    private const val CONNECT_TIMEOUT_MILLIS = 10_000
+    private const val READ_TIMEOUT_MILLIS = 30_000
+    private const val MAX_ARTIFACT_BYTES = 100L * 1024L * 1024L
+  }
+}

package/android/src/main/java/com/otasdk/OtaUpdatesModule.kt

@@ -0,0 +1,70 @@
+package com.otasdk
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import java.util.concurrent.Executors
+
+@ReactModule(name = OtaUpdatesModule.NAME)
+class OtaUpdatesModule(context: ReactApplicationContext) : NativeOTAUpdatesSpec(context) {
+  private val executor = Executors.newSingleThreadExecutor()
+
+  override fun getStatus(promise: Promise) {
+    promise.resolve(toWritableMap(OtaSdkUpdates.status()))
+  }
+
+  override fun checkForUpdate(promise: Promise) {
+    executor.execute {
+      try {
+        promise.resolve(toWritableMap(OtaSdkUpdates.checkForUpdate()))
+      } catch (exception: Exception) {
+        promise.reject("OTA_CHECK_FAILED", exception.message, exception)
+      }
+    }
+  }
+
+  override fun markUpdateSuccessful(promise: Promise) {
+    try {
+      promise.resolve(toWritableMap(OtaSdkUpdates.markHealthy()))
+    } catch (exception: Exception) {
+      promise.reject("OTA_CONFIRM_FAILED", exception.message, exception)
+    }
+  }
+
+  override fun closeAppToApplyUpdate(promise: Promise) {
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      promise.reject("OTA_NO_ACTIVITY", "There is no foreground Activity to close")
+      return
+    }
+    if (OtaSdkUpdates.status()["pendingRestart"] != true) {
+      promise.reject("OTA_NO_PENDING_UPDATE", "There is no verified update waiting for restart")
+      return
+    }
+
+    promise.resolve(true)
+    OtaSdkUpdates.closeAppForUpdate(activity)
+  }
+
+  private fun toWritableMap(values: Map<String, Any?>): WritableMap {
+    val result = Arguments.createMap()
+    values.forEach { (key, value) ->
+      when (value) {
+        null -> result.putNull(key)
+        is String -> result.putString(key, value)
+        is Boolean -> result.putBoolean(key, value)
+        is Int -> result.putInt(key, value)
+        is Long -> result.putDouble(key, value.toDouble())
+        is Double -> result.putDouble(key, value)
+        else -> result.putString(key, value.toString())
+      }
+    }
+    return result
+  }
+
+  companion object {
+    const val NAME = "OTAUpdates"
+  }
+}

package/android/src/test/java/com/otasdk/OtaActivationPolicyTest.kt

@@ -0,0 +1,47 @@
+package com.otasdk
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class OtaActivationPolicyTest {
+  @Test
+  fun firstLaunchSelectsPendingBundleAndMarksAttempt() {
+    val pending = OtaActivationPolicy.stage(OtaActivationState(activeVersion = 0), "release-1", 1)
+
+    val transition = OtaActivationPolicy.beginStartup(pending)
+
+    assertEquals("release-1", transition.selectedReleaseId)
+    assertEquals(true, transition.state.pendingLaunchAttempted)
+    assertEquals(0, transition.state.activeVersion)
+  }
+
+  @Test
+  fun healthyStartupCommitsPendingRelease() {
+    val pending =
+        OtaActivationPolicy.beginStartup(
+            OtaActivationPolicy.stage(OtaActivationState(activeVersion = 0), "release-1", 1)
+        )
+
+    val healthy = OtaActivationPolicy.markHealthy(pending.state)
+
+    assertEquals("release-1", healthy.activeReleaseId)
+    assertEquals(1, healthy.activeVersion)
+    assertNull(healthy.pendingReleaseId)
+  }
+
+  @Test
+  fun unconfirmedStartupRollsBackToPreviouslyActiveRelease() {
+    val previous = OtaActivationState(activeReleaseId = "release-1", activeVersion = 1)
+    val pending = OtaActivationPolicy.stage(previous, "release-2", 2)
+    val firstStart = OtaActivationPolicy.beginStartup(pending)
+
+    val nextStart = OtaActivationPolicy.beginStartup(firstStart.state)
+
+    assertEquals("release-1", nextStart.selectedReleaseId)
+    assertEquals("release-2", nextStart.failedReleaseId)
+    assertEquals("release-2", nextStart.state.failedReleaseId)
+    assertEquals(1, nextStart.state.activeVersion)
+    assertNull(nextStart.state.pendingReleaseId)
+  }
+}

package/android/src/test/java/com/otasdk/OtaReleaseManifestTest.kt

@@ -0,0 +1,48 @@
+package com.otasdk
+
+import java.nio.charset.StandardCharsets
+import java.security.KeyPairGenerator
+import java.security.Signature
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+class OtaReleaseManifestTest {
+  private val manifest =
+      OtaReleaseManifest(
+          releaseId = "519b9918-f1e8-4bcf-9319-19c54389e575",
+          platform = "android",
+          appId = "com.ota",
+          runtimeVersion = "rn-0.88.0-android-v1",
+          version = 3,
+          artifactSha256 = "a".repeat(64),
+          artifactSizeBytes = 1234,
+          createdAt = "2026-10-22T10:25:36.458384Z",
+      )
+
+  @Test
+  fun canonicalManifestUsesPublisherKeyOrderingAndCompactEncoding() {
+    val expected =
+        "{\"app_id\":\"com.ota\",\"artifact_sha256\":\"${"a".repeat(64)}\"," +
+            "\"artifact_size_bytes\":1234,\"created_at\":\"2026-10-22T10:25:36.458384Z\"," +
+            "\"manifest_version\":1,\"platform\":\"android\"," +
+            "\"release_id\":\"519b9918-f1e8-4bcf-9319-19c54389e575\"," +
+            "\"runtime_version\":\"rn-0.88.0-android-v1\",\"version\":3}"
+
+    assertArrayEquals(expected.toByteArray(StandardCharsets.UTF_8), manifest.canonicalBytes())
+  }
+
+  @Test
+  fun p256SignatureVerifiesAndDetectsManifestTampering() {
+    val keyPair = KeyPairGenerator.getInstance("EC").apply { initialize(256) }.generateKeyPair()
+    val signer = Signature.getInstance("SHA256withECDSA")
+    signer.initSign(keyPair.private)
+    signer.update(manifest.canonicalBytes())
+    val signature = signer.sign()
+
+    manifest.verifySignature(signature, keyPair.public)
+    assertThrows(OtaVerificationException::class.java) {
+      manifest.copy(version = 4).verifySignature(signature, keyPair.public)
+    }
+  }
+}

package/ios/OtaSdk.h

@@ -0,0 +1,5 @@
+#import <OtaSdkSpec/OtaSdkSpec.h>
+
+@interface OtaSdk : NSObject <NativeOtaSdkSpec>
+
+@end

package/ios/OtaSdk.mm

@@ -0,0 +1,21 @@
+#import "OtaSdk.h"
+
+@implementation OtaSdk
+- (NSNumber *)multiply:(double)a b:(double)b {
+  NSNumber *result = @(a * b);
+
+  return result;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeOtaSdkSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"OtaSdk";
+}
+
+@end

package/lib/module/NativeOTAUpdates.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('OTAUpdates');
+//# sourceMappingURL=NativeOTAUpdates.js.map

package/lib/module/NativeOTAUpdates.js.map

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

package/lib/module/NativeOtaSdk.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('OtaSdk');
+//# sourceMappingURL=NativeOtaSdk.js.map

package/lib/module/NativeOtaSdk.js.map

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

package/lib/module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export { multiply } from './multiply';
+export { default as OTAUpdates } from "./NativeOTAUpdates.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["multiply","default","OTAUpdates"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,QAAQ,QAAQ,YAAY;AACrC,SAASC,OAAO,IAAIC,UAAU,QAAQ,uBAAoB","ignoreList":[]}

package/lib/module/multiply.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export function multiply(a, b) {
+  return a * b;
+}
+//# sourceMappingURL=multiply.js.map

package/lib/module/multiply.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["multiply","a","b"],"sourceRoot":"../../src","sources":["multiply.tsx"],"mappings":";;AAAA,OAAO,SAASA,QAAQA,CAACC,CAAS,EAAEC,CAAS,EAAU;EACrD,OAAOD,CAAC,GAAGC,CAAC;AACd","ignoreList":[]}

package/lib/module/multiply.native.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import OtaSdk from "./NativeOtaSdk.js";
+export function multiply(a, b) {
+  return OtaSdk.multiply(a, b);
+}
+//# sourceMappingURL=multiply.native.js.map

package/lib/module/multiply.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["OtaSdk","multiply","a","b"],"sourceRoot":"../../src","sources":["multiply.native.tsx"],"mappings":";;AAAA,OAAOA,MAAM,MAAM,mBAAgB;AAEnC,OAAO,SAASC,QAAQA,CAACC,CAAS,EAAEC,CAAS,EAAU;EACrD,OAAOH,MAAM,CAACC,QAAQ,CAACC,CAAC,EAAEC,CAAC,CAAC;AAC9B","ignoreList":[]}

package/lib/module/package.json

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

package/lib/typescript/package.json

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

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

@@ -0,0 +1,22 @@
+import type { TurboModule } from 'react-native';
+export type OtaUpdateStatus = {
+    enabled: boolean;
+    status: string;
+    message: string;
+    runtimeVersion: string;
+    channel: string;
+    currentVersion: number;
+    pendingVersion: number | null;
+    pendingRestart: boolean;
+    updateAvailable: boolean;
+    action: string | null;
+};
+export interface Spec extends TurboModule {
+    getStatus(): Promise<OtaUpdateStatus>;
+    checkForUpdate(): Promise<OtaUpdateStatus>;
+    markUpdateSuccessful(): Promise<OtaUpdateStatus>;
+    closeAppToApplyUpdate(): Promise<boolean>;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeOTAUpdates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NativeOTAUpdates.d.ts","sourceRoot":"","sources":["../../../src/NativeOTAUpdates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAEF,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,SAAS,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;IACtC,cAAc,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;IAC3C,oBAAoB,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;IACjD,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3C;;AAED,wBAAoE"}

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

@@ -0,0 +1,7 @@
+import { type TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    multiply(a: number, b: number): number;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativeOtaSdk.d.ts.map