@hot-updater/react-native 0.24.0 → 0.24.2

package/android/src/main/java/com/hotupdater/BundleFileStorageService.kt

@@ -382,9 +382,31 @@ class BundleFileStorageService(
             "updateBundle bundleId $bundleId fileUrl $fileUrl fileHash $fileHash",
         )
 
-        // If no URL is provided, reset to fallback
+        // If no URL is provided, reset to fallback and clean up all bundles
         if (fileUrl.isNullOrEmpty()) {
-            setBundleURL(null)
+            Log.d(TAG, "fileUrl is null or empty, resetting to fallback bundle")
+
+            withContext(Dispatchers.IO) {
+                // 1. Set bundle URL to null (reset preference)
+                val setResult = setBundleURL(null)
+                if (!setResult) {
+                    Log.w(TAG, "Failed to reset bundle URL")
+                }
+
+                // 2. Reset metadata to initial state (clear all bundle references)
+                val metadata = createInitialMetadata()
+                val saveResult = saveMetadata(metadata)
+                if (!saveResult) {
+                    Log.w(TAG, "Failed to reset metadata")
+                }
+
+                // 3. Clean up all downloaded bundles
+                // Pass null for currentBundleId to remove all bundles except the new bundleId
+                val bundleStoreDir = getBundleStoreDir()
+                cleanupOldBundles(bundleStoreDir, null, bundleId)
+
+                Log.d(TAG, "Successfully reset to fallback bundle and cleaned up downloads")
+            }
             return
         }
 

package/android/src/main/java/com/hotupdater/BundleMetadata.kt

@@ -25,8 +25,18 @@ data class BundleMetadata(
         fun fromJson(json: JSONObject): BundleMetadata =
             BundleMetadata(
                 schema = json.optString("schema", SCHEMA_VERSION),
-                stableBundleId = json.optString("stableBundleId", null)?.takeIf { it.isNotEmpty() },
-                stagingBundleId = json.optString("stagingBundleId", null)?.takeIf { it.isNotEmpty() },
+                stableBundleId =
+                    if (json.has("stableBundleId") && !json.isNull("stableBundleId")) {
+                        json.getString("stableBundleId").takeIf { it.isNotEmpty() }
+                    } else {
+                        null
+                    },
+                stagingBundleId =
+                    if (json.has("stagingBundleId") && !json.isNull("stagingBundleId")) {
+                        json.getString("stagingBundleId").takeIf { it.isNotEmpty() }
+                    } else {
+                        null
+                    },
                 verificationPending = json.optBoolean("verificationPending", false),
                 verificationAttemptedAt =
                     if (json.has("verificationAttemptedAt") && !json.isNull("verificationAttemptedAt")) {

package/android/src/main/java/com/hotupdater/ZipDecompressionStrategy.kt

@@ -5,6 +5,7 @@ import java.io.BufferedInputStream
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
+import java.io.IOException
 import java.util.zip.CRC32
 import java.util.zip.ZipEntry
 import java.util.zip.ZipException
@@ -85,25 +86,31 @@ class ZipDecompressionStrategy : DecompressionStrategy {
                 destinationDir.mkdirs()
             }
 
-            val totalEntries =
+            // Calculate total bytes to extract for accurate progress reporting
+            val totalBytes =
                 try {
                     ZipFile(File(filePath)).use { zipFile ->
-                        zipFile.entries().asSequence().count()
+                        zipFile
+                            .entries()
+                            .asSequence()
+                            .filter { !it.isDirectory }
+                            .sumOf { it.size }
                     }
                 } catch (e: Exception) {
-                    Log.d(TAG, "Failed to count entries: ${e.message}")
-                    0
+                    Log.d(TAG, "Failed to calculate total bytes: ${e.message}")
+                    0L
                 }
 
-            if (totalEntries == 0) {
-                Log.d(TAG, "No entries found in ZIP")
+            if (totalBytes == 0L) {
+                Log.d(TAG, "No content found in ZIP")
                 return false
             }
 
-            Log.d(TAG, "Extracting $totalEntries entries from ZIP")
+            Log.d(TAG, "Extracting $totalBytes bytes from ZIP")
 
             var extractedFileCount = 0
-            var processedEntries = 0
+            var extractedBytes = 0L
+            var lastReportedProgress = 0.0
 
             FileInputStream(filePath).use { fileInputStream ->
                 BufferedInputStream(fileInputStream).use { bufferedInputStream ->
@@ -112,10 +119,20 @@ class ZipDecompressionStrategy : DecompressionStrategy {
                         while (entry != null) {
                             val file = File(destinationPath, entry.name)
 
-                            if (!file.canonicalPath.startsWith(destinationDir.canonicalPath)) {
-                                Log.w(TAG, "Skipping potentially malicious zip entry: ${entry.name}")
+                            // Zip Slip vulnerability check - verify entry path is within destination
+                            try {
+                                val canonicalDestPath = destinationDir.canonicalPath
+                                val canonicalFilePath = file.canonicalPath
+
+                                if (!canonicalFilePath.startsWith(canonicalDestPath)) {
+                                    Log.w(TAG, "Skipping potentially malicious zip entry: ${entry.name}")
+                                    entry = zipInputStream.nextEntry
+                                    continue
+                                }
+                            } catch (e: IOException) {
+                                // If we can't resolve canonical paths, treat as potentially malicious
+                                Log.w(TAG, "Failed to resolve canonical path for zip entry: ${entry.name}", e)
                                 entry = zipInputStream.nextEntry
-                                processedEntries++
                                 continue
                             }
 
@@ -132,6 +149,16 @@ class ZipDecompressionStrategy : DecompressionStrategy {
                                     while (zipInputStream.read(buffer).also { bytesRead = it } != -1) {
                                         output.write(buffer, 0, bytesRead)
                                         crc.update(buffer, 0, bytesRead)
+
+                                        // Track bytes written for byte-based progress
+                                        extractedBytes += bytesRead
+
+                                        // Report progress more frequently (every 1%)
+                                        val currentProgress = extractedBytes.toDouble() / totalBytes
+                                        if (currentProgress - lastReportedProgress >= 0.01) {
+                                            progressCallback.invoke(currentProgress)
+                                            lastReportedProgress = currentProgress
+                                        }
                                     }
                                 }
 
@@ -145,11 +172,6 @@ class ZipDecompressionStrategy : DecompressionStrategy {
                             }
 
                             zipInputStream.closeEntry()
-                            processedEntries++
-
-                            val progress = processedEntries.toDouble() / totalEntries
-                            progressCallback.invoke(progress)
-
                             entry = zipInputStream.nextEntry
                         }
                     }
@@ -161,7 +183,7 @@ class ZipDecompressionStrategy : DecompressionStrategy {
                 return false
             }
 
-            Log.d(TAG, "Successfully extracted $extractedFileCount files")
+            Log.d(TAG, "Successfully extracted $extractedFileCount files ($extractedBytes bytes)")
             progressCallback.invoke(1.0)
             true
         } catch (e: ZipException) {

package/android/src/newarch/HotUpdaterModule.kt

@@ -1,8 +1,8 @@
 package com.hotupdater
 
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
-import androidx.fragment.app.FragmentActivity
-import androidx.lifecycle.lifecycleScope
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
@@ -11,6 +11,8 @@ import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 
 class HotUpdaterModule internal constructor(
@@ -18,15 +20,24 @@ class HotUpdaterModule internal constructor(
 ) : HotUpdaterSpec(reactContext) {
     private val mReactApplicationContext: ReactApplicationContext = reactContext
 
+    // Managed coroutine scope for the module lifecycle
+    private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
     override fun getName(): String = NAME
 
+    override fun invalidate() {
+        super.invalidate()
+        // Cancel all ongoing coroutines when module is destroyed
+        moduleScope.cancel()
+    }
+
     /**
      * Gets the singleton HotUpdaterImpl instance
      */
     private fun getInstance(): HotUpdaterImpl = HotUpdater.getInstance(mReactApplicationContext)
 
     override fun reload(promise: Promise) {
-        CoroutineScope(Dispatchers.Main.immediate).launch {
+        moduleScope.launch {
             try {
                 val impl = getInstance()
                 val currentActivity = mReactApplicationContext.currentActivity
@@ -40,17 +51,11 @@ class HotUpdaterModule internal constructor(
     }
 
     override fun updateBundle(
-        params: ReadableMap?,
+        params: ReadableMap,
         promise: Promise,
     ) {
-        (mReactApplicationContext.currentActivity as FragmentActivity?)?.lifecycleScope?.launch {
+        moduleScope.launch {
             try {
-                // Parameter validation
-                if (params == null) {
-                    promise.reject("UNKNOWN_ERROR", "Missing or invalid parameters for updateBundle")
-                    return@launch
-                }
-
                 val bundleId = params.getString("bundleId")
                 if (bundleId == null || bundleId.isEmpty()) {
                     promise.reject("MISSING_BUNDLE_ID", "Missing or empty 'bundleId'")
@@ -78,15 +83,22 @@ class HotUpdaterModule internal constructor(
                     fileUrl,
                     fileHash,
                 ) { progress ->
-                    val progressParams =
-                        WritableNativeMap().apply {
-                            putDouble("progress", progress)
+                    // Post to Main thread for React Native event emission
+                    Handler(Looper.getMainLooper()).post {
+                        try {
+                            val progressParams =
+                                WritableNativeMap().apply {
+                                    putDouble("progress", progress)
+                                }
+
+                            this@HotUpdaterModule
+                                .mReactApplicationContext
+                                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                ?.emit("onProgress", progressParams)
+                        } catch (e: Exception) {
+                            Log.w("HotUpdater", "Failed to emit progress (bridge may be unavailable): ${e.message}")
                         }
-
-                    this@HotUpdaterModule
-                        .mReactApplicationContext
-                        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                        .emit("onProgress", progressParams)
+                    }
                 }
                 promise.resolve(true)
             } catch (e: HotUpdaterException) {
@@ -118,9 +130,9 @@ class HotUpdaterModule internal constructor(
         // No-op
     }
 
-    override fun notifyAppReady(params: ReadableMap?): WritableNativeMap {
+    override fun notifyAppReady(params: ReadableMap): WritableNativeMap {
         val result = WritableNativeMap()
-        val bundleId = params?.getString("bundleId")
+        val bundleId = params.getString("bundleId")
         if (bundleId == null) {
             result.putString("status", "STABLE")
             return result

package/android/src/oldarch/HotUpdaterModule.kt

@@ -1,8 +1,8 @@
 package com.hotupdater
 
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
-import androidx.fragment.app.FragmentActivity
-import androidx.lifecycle.lifecycleScope
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
@@ -11,6 +11,8 @@ import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import org.json.JSONArray
 import org.json.JSONObject
@@ -20,8 +22,17 @@ class HotUpdaterModule internal constructor(
 ) : HotUpdaterSpec(context) {
     private val mReactApplicationContext: ReactApplicationContext = context
 
+    // Managed coroutine scope for the module lifecycle
+    private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
     override fun getName(): String = NAME
 
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        // Cancel all ongoing coroutines when module is destroyed
+        moduleScope.cancel()
+    }
+
     /**
      * Gets the singleton HotUpdaterImpl instance
      */
@@ -29,7 +40,7 @@ class HotUpdaterModule internal constructor(
 
     @ReactMethod
     override fun reload(promise: Promise) {
-        CoroutineScope(Dispatchers.Main.immediate).launch {
+        moduleScope.launch {
             try {
                 val impl = getInstance()
                 val currentActivity = mReactApplicationContext.currentActivity
@@ -47,14 +58,8 @@ class HotUpdaterModule internal constructor(
         params: ReadableMap,
         promise: Promise,
     ) {
-        (mReactApplicationContext.currentActivity as FragmentActivity?)?.lifecycleScope?.launch {
+        moduleScope.launch {
             try {
-                // Parameter validation
-                if (params == null) {
-                    promise.reject("UNKNOWN_ERROR", "Missing or invalid parameters for updateBundle")
-                    return@launch
-                }
-
                 val bundleId = params.getString("bundleId")
                 if (bundleId == null || bundleId.isEmpty()) {
                     promise.reject("MISSING_BUNDLE_ID", "Missing or empty 'bundleId'")
@@ -82,15 +87,22 @@ class HotUpdaterModule internal constructor(
                     fileUrl,
                     fileHash,
                 ) { progress ->
-                    val progressParams =
-                        WritableNativeMap().apply {
-                            putDouble("progress", progress)
+                    // Post to Main thread for React Native event emission
+                    Handler(Looper.getMainLooper()).post {
+                        try {
+                            val progressParams =
+                                WritableNativeMap().apply {
+                                    putDouble("progress", progress)
+                                }
+
+                            this@HotUpdaterModule
+                                .mReactApplicationContext
+                                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                ?.emit("onProgress", progressParams)
+                        } catch (e: Exception) {
+                            Log.w("HotUpdater", "Failed to emit progress (bridge may be unavailable): ${e.message}")
                         }
-
-                    this@HotUpdaterModule
-                        .mReactApplicationContext
-                        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                        .emit("onProgress", progressParams)
+                    }
                 }
                 promise.resolve(true)
             } catch (e: HotUpdaterException) {
@@ -126,7 +138,7 @@ class HotUpdaterModule internal constructor(
 
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun notifyAppReady(params: ReadableMap): String {
-        val bundleId = params?.getString("bundleId")
+        val bundleId = params.getString("bundleId")
         val result = JSONObject()
 
         if (bundleId == null) {

package/ios/HotUpdater/Internal/URLSessionDownloadService.swift

@@ -1,4 +1,7 @@
 import Foundation
+#if !os(macOS)
+import UIKit
+#endif
 
 protocol DownloadService {
     /**
@@ -25,16 +28,70 @@ enum DownloadError: Error {
     case invalidContentLength
 }
 
+// Task state for persistence and recovery
+struct TaskState: Codable {
+    let taskIdentifier: Int
+    let destination: String
+    let bundleId: String
+    let startedAt: TimeInterval
+}
+
 class URLSessionDownloadService: NSObject, DownloadService {
     private var session: URLSession!
+    private var backgroundSession: URLSession!
     private var progressHandlers: [URLSessionTask: (Double) -> Void] = [:]
     private var completionHandlers: [URLSessionTask: (Result<URL, Error>) -> Void] = [:]
     private var destinations: [URLSessionTask: String] = [:]
+    private var taskStates: [Int: TaskState] = [:]
 
     override init() {
         super.init()
-        let configuration = URLSessionConfiguration.default
-        session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+
+        // Foreground session (existing behavior)
+        let defaultConfig = URLSessionConfiguration.default
+        session = URLSession(configuration: defaultConfig, delegate: self, delegateQueue: nil)
+
+        // Background session for persistent downloads
+        let backgroundConfig = URLSessionConfiguration.background(
+            withIdentifier: "com.hotupdater.background.download"
+        )
+        backgroundConfig.isDiscretionary = false
+        backgroundConfig.sessionSendsLaunchEvents = true
+        backgroundSession = URLSession(configuration: backgroundConfig, delegate: self, delegateQueue: nil)
+
+        // Load persisted task states
+        taskStates = loadTaskStates()
+    }
+
+    // MARK: - State Persistence
+
+    private var stateFileURL: URL {
+        let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+        return documentsPath.appendingPathComponent("download-state.json")
+    }
+
+    private func saveTaskState(_ state: TaskState) {
+        taskStates[state.taskIdentifier] = state
+
+        if let data = try? JSONEncoder().encode(taskStates) {
+            try? data.write(to: stateFileURL)
+        }
+    }
+
+    private func loadTaskStates() -> [Int: TaskState] {
+        guard let data = try? Data(contentsOf: stateFileURL),
+              let states = try? JSONDecoder().decode([Int: TaskState].self, from: data) else {
+            return [:]
+        }
+        return states
+    }
+
+    private func removeTaskState(_ taskIdentifier: Int) {
+        taskStates.removeValue(forKey: taskIdentifier)
+
+        if let data = try? JSONEncoder().encode(taskStates) {
+            try? data.write(to: stateFileURL)
+        }
     }
 
     func getFileSize(from url: URL, completion: @escaping (Result<Int64, Error>) -> Void) {
@@ -66,10 +123,39 @@ class URLSessionDownloadService: NSObject, DownloadService {
     }
 
     func downloadFile(from url: URL, to destination: String, progressHandler: @escaping (Double) -> Void, completion: @escaping (Result<URL, Error>) -> Void) -> URLSessionDownloadTask? {
-        let task = session.downloadTask(with: url)
+        // Determine if we should use background session
+        #if !os(macOS)
+        let appState = UIApplication.shared.applicationState
+        let useBackgroundSession = (appState == .background || appState == .inactive)
+        #else
+        let useBackgroundSession = false
+        #endif
+
+        let selectedSession = useBackgroundSession ? backgroundSession : session
+        let task = selectedSession?.downloadTask(with: url)
+
+        guard let task = task else {
+            return nil
+        }
+
         progressHandlers[task] = progressHandler
         completionHandlers[task] = completion
         destinations[task] = destination
+
+        // Extract bundleId from destination path (e.g., "bundle-store/{bundleId}/bundle.zip")
+        let bundleId = (destination as NSString).pathComponents
+            .dropFirst()
+            .first(where: { $0 != "bundle-store" }) ?? "unknown"
+
+        // Save task metadata for background recovery
+        let taskState = TaskState(
+            taskIdentifier: task.taskIdentifier,
+            destination: destination,
+            bundleId: bundleId,
+            startedAt: Date().timeIntervalSince1970
+        )
+        saveTaskState(taskState)
+
         task.resume()
         return task
     }
@@ -84,6 +170,7 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
             progressHandlers.removeValue(forKey: downloadTask)
             completionHandlers.removeValue(forKey: downloadTask)
             destinations.removeValue(forKey: downloadTask)
+            removeTaskState(downloadTask.taskIdentifier)
 
             // 다운로드 완료 알림
             NotificationCenter.default.post(name: .downloadDidFinish, object: downloadTask)
@@ -136,10 +223,11 @@ extension URLSessionDownloadService: URLSessionDownloadDelegate {
             progressHandlers.removeValue(forKey: task)
             completionHandlers.removeValue(forKey: task)
             destinations.removeValue(forKey: task)
-            
+            removeTaskState(task.taskIdentifier)
+
             NotificationCenter.default.post(name: .downloadDidFinish, object: task)
         }
-        
+
         if let error = error {
             completion?(.failure(error))
         }

package/lib/commonjs/DefaultResolver.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDefaultResolver = createDefaultResolver;
+var _fetchUpdateInfo = require("./fetchUpdateInfo.js");
+/**
+ * Creates a default resolver that uses baseURL for network operations.
+ * This encapsulates the existing baseURL logic into a resolver.
+ *
+ * @param baseURL - The base URL for the update server
+ * @returns A HotUpdaterResolver that uses the baseURL
+ */
+function createDefaultResolver(baseURL) {
+  return {
+    checkUpdate: async params => {
+      // Build URL based on strategy (existing buildUpdateUrl logic)
+      let url;
+      if (params.updateStrategy === "fingerprint") {
+        if (!params.fingerprintHash) {
+          throw new Error("Fingerprint hash is required");
+        }
+        url = `${baseURL}/fingerprint/${params.platform}/${params.fingerprintHash}/${params.channel}/${params.minBundleId}/${params.bundleId}`;
+      } else {
+        url = `${baseURL}/app-version/${params.platform}/${params.appVersion}/${params.channel}/${params.minBundleId}/${params.bundleId}`;
+      }
+
+      // Use existing fetchUpdateInfo
+      return (0, _fetchUpdateInfo.fetchUpdateInfo)({
+        url,
+        requestHeaders: params.requestHeaders,
+        requestTimeout: params.requestTimeout
+      });
+    }
+  };
+}
+//# sourceMappingURL=DefaultResolver.js.map

package/lib/commonjs/DefaultResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_fetchUpdateInfo","require","createDefaultResolver","baseURL","checkUpdate","params","url","updateStrategy","fingerprintHash","Error","platform","channel","minBundleId","bundleId","appVersion","fetchUpdateInfo","requestHeaders","requestTimeout"],"sourceRoot":"../../src","sources":["DefaultResolver.ts"],"mappings":";;;;;;AACA,IAAAA,gBAAA,GAAAC,OAAA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,qBAAqBA,CAACC,OAAe,EAAsB;EACzE,OAAO;IACLC,WAAW,EAAE,MACXC,MAAiC,IACC;MAClC;MACA,IAAIC,GAAW;MACf,IAAID,MAAM,CAACE,cAAc,KAAK,aAAa,EAAE;QAC3C,IAAI,CAACF,MAAM,CAACG,eAAe,EAAE;UAC3B,MAAM,IAAIC,KAAK,CAAC,8BAA8B,CAAC;QACjD;QACAH,GAAG,GAAG,GAAGH,OAAO,gBAAgBE,MAAM,CAACK,QAAQ,IAAIL,MAAM,CAACG,eAAe,IAAIH,MAAM,CAACM,OAAO,IAAIN,MAAM,CAACO,WAAW,IAAIP,MAAM,CAACQ,QAAQ,EAAE;MACxI,CAAC,MAAM;QACLP,GAAG,GAAG,GAAGH,OAAO,gBAAgBE,MAAM,CAACK,QAAQ,IAAIL,MAAM,CAACS,UAAU,IAAIT,MAAM,CAACM,OAAO,IAAIN,MAAM,CAACO,WAAW,IAAIP,MAAM,CAACQ,QAAQ,EAAE;MACnI;;MAEA;MACA,OAAO,IAAAE,gCAAe,EAAC;QACrBT,GAAG;QACHU,cAAc,EAAEX,MAAM,CAACW,cAAc;QACrCC,cAAc,EAAEZ,MAAM,CAACY;MACzB,CAAC,CAAC;IACJ;EACF,CAAC;AACH","ignoreList":[]}

package/lib/commonjs/checkForUpdate.js

@@ -6,26 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.checkForUpdate = checkForUpdate;
 var _reactNative = require("react-native");
 var _error = require("./error.js");
-var _fetchUpdateInfo = require("./fetchUpdateInfo.js");
 var _native = require("./native.js");
-// Internal type that includes baseURL for use within index.ts
+// Internal type that includes resolver for use within index.ts
 
-// Internal function to build update URL (not exported)
-function buildUpdateUrl(baseURL, updateStrategy, params) {
-  switch (updateStrategy) {
-    case "fingerprint":
-      {
-        if (!params.fingerprintHash) {
-          throw new _error.HotUpdaterError("Fingerprint hash is required");
-        }
-        return `${baseURL}/fingerprint/${params.platform}/${params.fingerprintHash}/${params.channel}/${params.minBundleId}/${params.bundleId}`;
-      }
-    case "appVersion":
-      {
-        return `${baseURL}/app-version/${params.platform}/${params.appVersion}/${params.channel}/${params.minBundleId}/${params.bundleId}`;
-      }
-  }
-}
 async function checkForUpdate(options) {
   if (__DEV__) {
     return null;
@@ -34,10 +17,6 @@ async function checkForUpdate(options) {
     options.onError?.(new _error.HotUpdaterError("HotUpdater is only supported on iOS and Android"));
     return null;
   }
-  if (!options.baseURL || !options.updateStrategy) {
-    options.onError?.(new _error.HotUpdaterError("'baseURL' and 'updateStrategy' are required"));
-    return null;
-  }
   const currentAppVersion = (0, _native.getAppVersion)();
   const platform = _reactNative.Platform.OS;
   const currentBundleId = (0, _native.getBundleId)();
@@ -48,34 +27,40 @@ async function checkForUpdate(options) {
     return null;
   }
   const fingerprintHash = (0, _native.getFingerprintHash)();
-  const url = buildUpdateUrl(options.baseURL, options.updateStrategy, {
-    platform,
-    appVersion: currentAppVersion,
-    fingerprintHash: fingerprintHash ?? null,
-    channel,
-    minBundleId,
-    bundleId: currentBundleId
-  });
-  return (0, _fetchUpdateInfo.fetchUpdateInfo)({
-    url,
-    requestHeaders: options.requestHeaders,
-    onError: options.onError,
-    requestTimeout: options.requestTimeout
-  }).then(updateInfo => {
-    if (!updateInfo) {
-      return null;
+  if (!options.resolver?.checkUpdate) {
+    options.onError?.(new _error.HotUpdaterError("Resolver is required but not configured"));
+    return null;
+  }
+  let updateInfo = null;
+  try {
+    updateInfo = await options.resolver.checkUpdate({
+      platform,
+      appVersion: currentAppVersion,
+      bundleId: currentBundleId,
+      minBundleId,
+      channel,
+      updateStrategy: options.updateStrategy,
+      fingerprintHash,
+      requestHeaders: options.requestHeaders,
+      requestTimeout: options.requestTimeout
+    });
+  } catch (error) {
+    options.onError?.(error);
+    return null;
+  }
+  if (!updateInfo) {
+    return null;
+  }
+  return {
+    ...updateInfo,
+    updateBundle: async () => {
+      return (0, _native.updateBundle)({
+        bundleId: updateInfo.id,
+        fileUrl: updateInfo.fileUrl,
+        fileHash: updateInfo.fileHash,
+        status: updateInfo.status
+      });
     }
-    return {
-      ...updateInfo,
-      updateBundle: async () => {
-        return (0, _native.updateBundle)({
-          bundleId: updateInfo.id,
-          fileUrl: updateInfo.fileUrl,
-          fileHash: updateInfo.fileHash,
-          status: updateInfo.status
-        });
-      }
-    };
-  });
+  };
 }
 //# sourceMappingURL=checkForUpdate.js.map