@appsonair.ir/react-native 1.0.0

package/android/src/main/java/com/otaupdater/OTAUpdaterModule.kt

@@ -0,0 +1,159 @@
+package com.otaupdater
+
+import android.content.Context
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.common.build.ReactBuildConfig
+import java.io.File
+
+class OTAUpdaterModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  init {
+    reactContext.addLifecycleEventListener(
+      object : LifecycleEventListener {
+        override fun onHostResume() {
+          UiThreadUtil.runOnUiThread {
+            OTAApkInstallHelper.retryPendingInstall(reactContext)
+          }
+        }
+
+        override fun onHostPause() {}
+
+        override fun onHostDestroy() {}
+      },
+    )
+  }
+
+  companion object {
+    @JvmStatic
+    fun getBundlePath(context: Context): String? =
+      OTAUpdaterStorage.getBundlePath(context)
+
+    /**
+     * RN 0.76+ exposes ReactHost with setBundleSource(). Use reflection so RN 0.74/0.75 still compile.
+     */
+    @JvmStatic
+    private fun tryHotReloadBundle(app: ReactApplication, bundlePath: String): Boolean {
+      return try {
+        val reactHost =
+          try {
+            app.javaClass.getMethod("getReactHost").invoke(app)
+          } catch (_: Exception) {
+            null
+          } ?: return false
+
+        val method = reactHost.javaClass.getMethod("setBundleSource", String::class.java)
+        method.invoke(reactHost, bundlePath)
+        true
+      } catch (_: Exception) {
+        false
+      }
+    }
+  }
+
+  override fun getName(): String = "OTAUpdaterNative"
+
+  @ReactMethod
+  fun setBundlePath(path: String, promise: Promise) {
+    val normalizedPath = path.removePrefix("file://")
+    val file = File(normalizedPath)
+    if (!OTAUpdaterStorage.isValidBundle(file)) {
+      promise.reject("EINVAL", "Bundle file is missing or invalid: $normalizedPath")
+      return
+    }
+
+    val saved = OTAUpdaterStorage.setBundlePath(reactContext, normalizedPath)
+    if (!saved) {
+      promise.reject("ESTORAGE", "Failed to persist bundle path")
+      return
+    }
+
+    promise.resolve(normalizedPath)
+  }
+
+  @ReactMethod
+  fun getBundlePath(promise: Promise) {
+    promise.resolve(OTAUpdaterStorage.getBundlePath(reactContext))
+  }
+
+  @ReactMethod
+  fun clearBundlePath(promise: Promise) {
+    OTAUpdaterStorage.clearBundlePath(reactContext)
+    promise.resolve(true)
+  }
+
+  @ReactMethod
+  fun getDeviceAbi(promise: Promise) {
+    try {
+      val abis = android.os.Build.SUPPORTED_ABIS
+      promise.resolve(abis.firstOrNull() ?: "unknown")
+    } catch (e: Exception) {
+      promise.reject("EABI", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun installApk(path: String, promise: Promise) {
+    UiThreadUtil.runOnUiThread {
+      try {
+        val result = OTAApkInstallHelper.install(reactContext, path)
+        promise.resolve(result)
+      } catch (e: Exception) {
+        promise.reject("EINSTALL", e.message, e)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun retryPendingApkInstall(promise: Promise) {
+    UiThreadUtil.runOnUiThread {
+      try {
+        OTAApkInstallHelper.retryPendingInstall(reactContext)
+        promise.resolve(true)
+      } catch (e: Exception) {
+        promise.reject("EINSTALL", e.message, e)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun extractZipArchive(zipPath: String, destDir: String, promise: Promise) {
+    Thread {
+      try {
+        OTAZipExtractHelper.extract(zipPath, destDir)
+        promise.resolve(destDir.removePrefix("file://"))
+      } catch (e: Exception) {
+        promise.reject("EUNZIP", e.message, e)
+      }
+    }.start()
+  }
+
+  @ReactMethod
+  fun restartApp(promise: Promise) {
+    UiThreadUtil.runOnUiThread {
+      try {
+        val normalizedPath = OTAUpdaterStorage.getBundlePath(reactContext)
+
+        // Debug hot-reload is RN 0.76+ only; RN 0.74 always process-restarts.
+        if (ReactBuildConfig.DEBUG && normalizedPath != null) {
+          val app = reactContext.applicationContext as? ReactApplication
+          if (app != null && tryHotReloadBundle(app, normalizedPath)) {
+            promise.resolve("reloaded")
+            return@runOnUiThread
+          }
+        }
+
+        OTARestartHelper.triggerRebirth(reactContext.applicationContext)
+        promise.resolve("restarted")
+      } catch (e: Exception) {
+        promise.reject("ERESTART", e.message, e)
+      }
+    }
+  }
+}

package/android/src/main/java/com/otaupdater/OTAUpdaterPackage.kt

@@ -0,0 +1,16 @@
+package com.otaupdater
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class OTAUpdaterPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(OTAUpdaterModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/otaupdater/OTAUpdaterStorage.kt

@@ -0,0 +1,196 @@
+package com.otaupdater
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.util.Log
+import java.io.File
+
+object OTAUpdaterStorage {
+  private const val PREFS_NAME = "ota_updater"
+  private const val KEY_BUNDLE_PATH = "bundle_path"
+  private const val KEY_NATIVE_VERSION = "native_version"
+  private const val KEY_NATIVE_BUILD = "native_build"
+  private const val KEY_PENDING_APK_PATH = "pending_apk_path"
+  private const val MIN_BUNDLE_BYTES = 1024L
+  private const val MIN_APK_BYTES = 1024L * 100
+  private const val TAG = "OTAUpdater"
+
+  /**
+   * Returns the OTA JS bundle path, or null after clearing a stale path when the
+   * installed APK versionName / versionCode changed. Must run before RN loads JS
+   * so a post-APK install does not keep serving the previous OTA bundle.
+   */
+  fun getBundlePath(context: Context): String? {
+    clearStaleBundleAfterNativeUpgrade(context)
+
+    val path =
+      context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        .getString(KEY_BUNDLE_PATH, null)
+        ?: return null
+
+    val file = File(normalizePath(path))
+    if (!isValidBundle(file)) {
+      clearBundlePath(context)
+      return null
+    }
+
+    return file.absolutePath
+  }
+
+  fun setBundlePath(context: Context, path: String): Boolean {
+    return context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      .edit()
+      .putString(KEY_BUNDLE_PATH, normalizePath(path))
+      .commit()
+  }
+
+  fun clearBundlePath(context: Context) {
+    context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      .edit()
+      .remove(KEY_BUNDLE_PATH)
+      .commit()
+  }
+
+  /**
+   * Drop a persisted OTA bundle when the native binary changed (new APK install).
+   * Safe to call from Application / getJSBundleFile before React Native starts.
+   */
+  fun clearStaleBundleAfterNativeUpgrade(context: Context) {
+    val current = readInstalledNativeInfo(context) ?: return
+    val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+    val storedVersion = prefs.getString(KEY_NATIVE_VERSION, null)
+    val storedBuild = if (prefs.contains(KEY_NATIVE_BUILD)) {
+      prefs.getLong(KEY_NATIVE_BUILD, -1L)
+    } else {
+      null
+    }
+    val hasBundlePath = prefs.contains(KEY_BUNDLE_PATH)
+
+    val versionChanged = storedVersion != null && storedVersion != current.versionName
+    val buildChanged = storedBuild != null && storedBuild != current.versionCode
+    val firstRunWithStaleBundle = storedVersion == null && hasBundlePath
+
+    if (versionChanged || buildChanged || firstRunWithStaleBundle) {
+      Log.i(
+        TAG,
+        "Native version changed (${storedVersion ?: "unknown"} → ${current.versionName}, " +
+          "build ${storedBuild ?: "unknown"} → ${current.versionCode}); clearing stale OTA bundle.",
+      )
+      clearBundlePath(context)
+    }
+
+    prefs
+      .edit()
+      .putString(KEY_NATIVE_VERSION, current.versionName)
+      .putLong(KEY_NATIVE_BUILD, current.versionCode)
+      .apply()
+  }
+
+  fun getPendingApkPath(context: Context): String? {
+    val path =
+      context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        .getString(KEY_PENDING_APK_PATH, null)
+        ?: return null
+
+    val file = File(normalizePath(path))
+    if (!file.exists() || file.length() < MIN_APK_BYTES) {
+      clearPendingApkPath(context)
+      return null
+    }
+
+    return file.absolutePath
+  }
+
+  fun setPendingApkPath(context: Context, path: String): Boolean {
+    return context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      .edit()
+      .putString(KEY_PENDING_APK_PATH, normalizePath(path))
+      .commit()
+  }
+
+  fun clearPendingApkPath(context: Context) {
+    context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      .edit()
+      .remove(KEY_PENDING_APK_PATH)
+      .commit()
+  }
+
+  fun isValidBundle(file: File): Boolean {
+    if (!file.exists() || !file.isFile || file.length() < MIN_BUNDLE_BYTES) {
+      return false
+    }
+
+    return try {
+      file.inputStream().use { input ->
+        val header = ByteArray(4)
+        if (input.read(header) != 4) {
+          return false
+        }
+
+        // Hermes bytecode (hermesc output)
+        if (isHermesBytecode(header)) {
+          return true
+        }
+
+        // Metro bundle: UTF-8 JavaScript text
+        isLikelyJavaScriptBundle(header, input)
+      }
+    } catch (_: Exception) {
+      false
+    }
+  }
+
+  private data class NativeInfo(val versionName: String, val versionCode: Long)
+
+  private fun readInstalledNativeInfo(context: Context): NativeInfo? {
+    return try {
+      val packageInfo =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+          context.packageManager.getPackageInfo(
+            context.packageName,
+            PackageManager.PackageInfoFlags.of(0),
+          )
+        } else {
+          @Suppress("DEPRECATION")
+          context.packageManager.getPackageInfo(context.packageName, 0)
+        }
+
+      val versionName = packageInfo.versionName ?: return null
+      val versionCode =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+          packageInfo.longVersionCode
+        } else {
+          @Suppress("DEPRECATION")
+          packageInfo.versionCode.toLong()
+        }
+
+      NativeInfo(versionName, versionCode)
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to read package version for OTA clear", e)
+      null
+    }
+  }
+
+  private fun normalizePath(path: String): String =
+    path.removePrefix("file://")
+
+  private fun isHermesBytecode(header: ByteArray): Boolean =
+    header[0] == 0xC6.toByte() &&
+      header[1] == 0x1F.toByte() &&
+      header[2] == 0xBC.toByte() &&
+      header[3] == 0x03.toByte()
+
+  private fun isLikelyJavaScriptBundle(header: ByteArray, input: java.io.InputStream): Boolean {
+    val preview = ByteArray(64)
+    System.arraycopy(header, 0, preview, 0, 4)
+    input.read(preview, 4, 60)
+
+    val text = String(preview, Charsets.UTF_8)
+    return text.contains("__d(") ||
+      text.contains("var ") ||
+      text.startsWith("(") ||
+      text.startsWith("!") ||
+      text.startsWith(";")
+  }
+}

package/android/src/main/java/com/otaupdater/OTAZipExtractHelper.kt

@@ -0,0 +1,62 @@
+package com.otaupdater
+
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.util.zip.ZipInputStream
+
+object OTAZipExtractHelper {
+  fun extract(zipPath: String, destDirPath: String) {
+    val zipFile = File(normalizePath(zipPath))
+    val destDir = File(normalizePath(destDirPath))
+
+    if (!zipFile.isFile) {
+      throw IllegalArgumentException("Zip file not found: ${zipFile.absolutePath}")
+    }
+
+    if (destDir.exists()) {
+      deleteRecursive(destDir)
+    }
+    destDir.mkdirs()
+
+    ZipInputStream(FileInputStream(zipFile)).use { zipInput ->
+      var entry = zipInput.nextEntry
+      while (entry != null) {
+        val outFile = safeOutputFile(destDir, entry.name)
+
+        if (entry.isDirectory) {
+          outFile.mkdirs()
+        } else {
+          outFile.parentFile?.mkdirs()
+          FileOutputStream(outFile).use { output ->
+            zipInput.copyTo(output)
+          }
+        }
+
+        zipInput.closeEntry()
+        entry = zipInput.nextEntry
+      }
+    }
+  }
+
+  private fun safeOutputFile(destDir: File, entryName: String): File {
+    val outFile = File(destDir, entryName)
+    val destPath = destDir.canonicalPath
+    val outPath = outFile.canonicalPath
+    if (outPath != destPath && !outPath.startsWith("$destPath${File.separator}")) {
+      throw SecurityException("Zip entry escapes target directory: $entryName")
+    }
+    return outFile
+  }
+
+  private fun deleteRecursive(path: File) {
+    if (path.isDirectory) {
+      path.listFiles()?.forEach { child ->
+        deleteRecursive(child)
+      }
+    }
+    path.delete()
+  }
+
+  private fun normalizePath(path: String): String = path.removePrefix("file://")
+}

package/android/src/main/res/xml/ota_file_paths.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+  <files-path name="ota_files" path="." />
+  <external-files-path name="ota_external_files" path="." />
+  <cache-path name="ota_cache" path="." />
+</paths>

package/android/src/reacthost76/java/com/otaupdater/OTAReactHostFactory.kt

@@ -0,0 +1,84 @@
+package com.otaupdater
+
+import android.content.Context
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.JSBundleLoader
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.defaults.DefaultComponentsRegistry
+import com.facebook.react.defaults.DefaultReactHostDelegate
+import com.facebook.react.defaults.DefaultTurboModuleManagerDelegate
+import com.facebook.react.fabric.ComponentFactory
+import com.facebook.react.runtime.ReactHostImpl
+import com.facebook.react.runtime.hermes.HermesInstance
+import java.io.File
+
+/**
+ * Creates a fresh [ReactHost] on every cold start. Unlike [DefaultReactHost.getDefaultReactHost],
+ * this does not cache a process-wide singleton, so OTA restarts can load a new bundle path.
+ */
+object OTAReactHostFactory {
+  @OptIn(UnstableReactNativeAPI::class)
+  @JvmStatic
+  fun create(
+    context: Context,
+    packageList: List<ReactPackage>,
+    jsMainModulePath: String = "index",
+    jsBundleAssetPath: String = "index.android.bundle",
+    jsBundleFilePath: String? = null,
+    useDevSupport: Boolean = false,
+  ): ReactHost {
+    val bundleLoader =
+      if (jsBundleFilePath != null) {
+        if (jsBundleFilePath.startsWith("assets://")) {
+          JSBundleLoader.createAssetLoader(context, jsBundleFilePath, true)
+        } else {
+          createFileBundleLoader(jsBundleFilePath)
+        }
+      } else {
+        JSBundleLoader.createAssetLoader(context, "assets://$jsBundleAssetPath", true)
+      }
+
+    val turboModuleDelegateBuilder = DefaultTurboModuleManagerDelegate.Builder()
+    val reactHostDelegate =
+      DefaultReactHostDelegate(
+        jsMainModulePath = jsMainModulePath,
+        jsBundleLoader = bundleLoader,
+        reactPackages = packageList,
+        jsRuntimeFactory = HermesInstance(),
+        bindingsInstaller = null,
+        turboModuleManagerDelegateBuilder = turboModuleDelegateBuilder,
+        exceptionHandler = { throw it },
+      )
+
+    val componentFactory = ComponentFactory()
+    DefaultComponentsRegistry.register(componentFactory)
+
+    return ReactHostImpl(
+      context,
+      reactHostDelegate,
+      componentFactory,
+      true,
+      useDevSupport,
+    )
+  }
+
+  /** Load JS from disk with sibling drawable assets (OTA zip extract folder). */
+  private fun createFileBundleLoader(jsBundleFilePath: String): JSBundleLoader {
+    return try {
+      val bundleFile = File(jsBundleFilePath)
+      val assetUrl =
+        "file://${bundleFile.parentFile?.absolutePath?.trimEnd('/')}/"
+      val method =
+        JSBundleLoader::class.java.getMethod(
+          "createFileLoader",
+          String::class.java,
+          String::class.java,
+          Boolean::class.javaPrimitiveType,
+        )
+      method.invoke(null, jsBundleFilePath, assetUrl, true) as JSBundleLoader
+    } catch (_: Exception) {
+      JSBundleLoader.createFileLoader(jsBundleFilePath)
+    }
+  }
+}

package/ios/OTAUpdaterNative.h

@@ -0,0 +1,4 @@
+#import <React/RCTBridgeModule.h>
+
+@interface OTAUpdaterNative : NSObject <RCTBridgeModule>
+@end

package/ios/OTAUpdaterNative.m

@@ -0,0 +1,110 @@
+#import "OTAUpdaterNative.h"
+#import <React/RCTLog.h>
+#import <React/RCTReloadCommand.h>
+#import <UIKit/UIKit.h>
+
+static NSString *const kBundlePathKey = @"ota_updater_bundle_path";
+static NSString *const kNativeVersionKey = @"ota_updater_native_version";
+static NSString *const kNativeBuildKey = @"ota_updater_native_build";
+
+@implementation OTAUpdaterNative
+
+RCT_EXPORT_MODULE();
+
++ (void)clearStaleBundleAfterNativeUpgrade {
+  NSDictionary *info = [[NSBundle mainBundle] infoDictionary];
+  NSString *currentVersion = info[@"CFBundleShortVersionString"];
+  NSString *currentBuild = info[@"CFBundleVersion"];
+  if (currentVersion == nil) {
+    return;
+  }
+
+  NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+  NSString *storedVersion = [defaults stringForKey:kNativeVersionKey];
+  NSString *storedBuild = [defaults stringForKey:kNativeBuildKey];
+  BOOL hasBundlePath = [defaults objectForKey:kBundlePathKey] != nil;
+
+  BOOL versionChanged = storedVersion != nil && ![storedVersion isEqualToString:currentVersion];
+  BOOL buildChanged =
+    currentBuild != nil && storedBuild != nil && ![storedBuild isEqualToString:currentBuild];
+  BOOL firstRunWithStaleBundle = storedVersion == nil && hasBundlePath;
+
+  if (versionChanged || buildChanged || firstRunWithStaleBundle) {
+    RCTLogInfo(@"[OTA] Native version changed; clearing stale OTA bundle.");
+    [defaults removeObjectForKey:kBundlePathKey];
+  }
+
+  [defaults setObject:currentVersion forKey:kNativeVersionKey];
+  if (currentBuild != nil) {
+    [defaults setObject:currentBuild forKey:kNativeBuildKey];
+  }
+  [defaults synchronize];
+}
+
++ (NSString *)otaBundlePath {
+  [OTAUpdaterNative clearStaleBundleAfterNativeUpgrade];
+
+  NSString *path = [[NSUserDefaults standardUserDefaults] stringForKey:kBundlePathKey];
+  if (path != nil && [[NSFileManager defaultManager] fileExistsAtPath:path]) {
+    return path;
+  }
+  return nil;
+}
+
+RCT_EXPORT_METHOD(setBundlePath:(NSString *)path
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  if (![[NSFileManager defaultManager] fileExistsAtPath:path]) {
+    reject(@"ENOENT", @"Bundle file not found", nil);
+    return;
+  }
+
+  [[NSUserDefaults standardUserDefaults] setObject:path forKey:kBundlePathKey];
+  [[NSUserDefaults standardUserDefaults] synchronize];
+  resolve(path);
+}
+
+RCT_EXPORT_METHOD(clearBundlePath:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  [[NSUserDefaults standardUserDefaults] removeObjectForKey:kBundlePathKey];
+  [[NSUserDefaults standardUserDefaults] synchronize];
+  resolve(@YES);
+}
+
+RCT_EXPORT_METHOD(restartApp:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+#if DEBUG
+    NSString *otaPath = [OTAUpdaterNative otaBundlePath];
+    if (otaPath != nil) {
+      RCTTriggerReloadCommandListeners(@"OTA update applied");
+      resolve(@"reloaded");
+      return;
+    }
+#endif
+
+    UIApplication *application = [UIApplication sharedApplication];
+    __block UIBackgroundTaskIdentifier taskId = UIBackgroundTaskInvalid;
+
+    taskId = [application beginBackgroundTaskWithExpirationHandler:^{
+      [application endBackgroundTask:taskId];
+      taskId = UIBackgroundTaskInvalid;
+    }];
+
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+      exit(0);
+      resolve(@"restarted");
+    });
+  });
+}
+
+RCT_EXPORT_METHOD(getBundlePath:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  resolve([OTAUpdaterNative otaBundlePath] ?: [NSNull null]);
+}
+
+@end

package/lib/api.d.ts

@@ -0,0 +1 @@
+export { checkForUpdate, downloadBundle, getBundleFilePath, verifyBundleHash, } from './sync';

package/lib/api.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyBundleHash = exports.getBundleFilePath = exports.downloadBundle = exports.checkForUpdate = void 0;
+var sync_1 = require("./sync");
+Object.defineProperty(exports, "checkForUpdate", { enumerable: true, get: function () { return sync_1.checkForUpdate; } });
+Object.defineProperty(exports, "downloadBundle", { enumerable: true, get: function () { return sync_1.downloadBundle; } });
+Object.defineProperty(exports, "getBundleFilePath", { enumerable: true, get: function () { return sync_1.getBundleFilePath; } });
+Object.defineProperty(exports, "verifyBundleHash", { enumerable: true, get: function () { return sync_1.verifyBundleHash; } });

package/lib/config.d.ts

@@ -0,0 +1,3 @@
+import { OTAUpdaterConfig } from './types';
+export declare function configure(options: OTAUpdaterConfig): void;
+export declare function getConfig(): OTAUpdaterConfig | null;

package/lib/config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configure = configure;
+exports.getConfig = getConfig;
+let config = null;
+function configure(options) {
+    config = options;
+}
+function getConfig() {
+    return config;
+}

package/lib/debug.d.ts

@@ -0,0 +1,4 @@
+export declare function setOtaDebug(enabled: boolean): void;
+export declare function isOtaDebugEnabled(): boolean;
+export declare function otaLog(...args: unknown[]): void;
+export declare function otaWarn(...args: unknown[]): void;