@hot-updater/react-native 0.12.7 → 0.13.1

package/android/generated/java/com/hotupdater/NativeHotUpdaterSpec.java

@@ -17,8 +17,14 @@ 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.common.build.ReactBuildConfig;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 
 public abstract class NativeHotUpdaterSpec extends ReactContextBaseJavaModule implements TurboModule {
   public static final String NAME = "HotUpdater";
@@ -51,4 +57,30 @@ public abstract class NativeHotUpdaterSpec extends ReactContextBaseJavaModule im
   @ReactMethod
   @DoNotStrip
   public abstract void removeListeners(double count);
+
+  protected abstract Map<String, Object> getTypedExportedConstants();
+
+  @Override
+  @DoNotStrip
+  public final @Nullable Map<String, Object> getConstants() {
+    Map<String, Object> constants = getTypedExportedConstants();
+    if (ReactBuildConfig.DEBUG || ReactBuildConfig.IS_INTERNAL_BUILD) {
+      Set<String> obligatoryFlowConstants = new HashSet<>(Arrays.asList(
+          "MIN_BUNDLE_ID"
+      ));
+      Set<String> optionalFlowConstants = new HashSet<>();
+      Set<String> undeclaredConstants = new HashSet<>(constants.keySet());
+      undeclaredConstants.removeAll(obligatoryFlowConstants);
+      undeclaredConstants.removeAll(optionalFlowConstants);
+      if (!undeclaredConstants.isEmpty()) {
+        throw new IllegalStateException(String.format("Native Module Flow doesn't declare constants: %s", undeclaredConstants));
+      }
+      undeclaredConstants = obligatoryFlowConstants;
+      undeclaredConstants.removeAll(constants.keySet());
+      if (!undeclaredConstants.isEmpty()) {
+        throw new IllegalStateException(String.format("Native Module doesn't fill in constants: %s", undeclaredConstants));
+      }
+    }
+    return constants;
+  }
 }

package/android/generated/jni/HotUpdaterSpec-generated.cpp

@@ -37,6 +37,11 @@ static facebook::jsi::Value __hostFunction_NativeHotUpdaterSpecJSI_removeListene
   return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "removeListeners", "(D)V", args, count, cachedMethodId);
 }
 
+static facebook::jsi::Value __hostFunction_NativeHotUpdaterSpecJSI_getConstants(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, ObjectKind, "getConstants", "()Ljava/util/Map;", args, count, cachedMethodId);
+}
+
 NativeHotUpdaterSpecJSI::NativeHotUpdaterSpecJSI(const JavaTurboModule::InitParams &params)
   : JavaTurboModule(params) {
   methodMap_["reload"] = MethodMetadata {0, __hostFunction_NativeHotUpdaterSpecJSI_reload};
@@ -44,6 +49,7 @@ NativeHotUpdaterSpecJSI::NativeHotUpdaterSpecJSI(const JavaTurboModule::InitPara
   methodMap_["getAppVersion"] = MethodMetadata {0, __hostFunction_NativeHotUpdaterSpecJSI_getAppVersion};
   methodMap_["addListener"] = MethodMetadata {1, __hostFunction_NativeHotUpdaterSpecJSI_addListener};
   methodMap_["removeListeners"] = MethodMetadata {1, __hostFunction_NativeHotUpdaterSpecJSI_removeListeners};
+  methodMap_["getConstants"] = MethodMetadata {0, __hostFunction_NativeHotUpdaterSpecJSI_getConstants};
 }
 
 std::shared_ptr<TurboModule> HotUpdaterSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {

package/android/generated/jni/react/renderer/components/HotUpdaterSpec/HotUpdaterSpecJSI-generated.cpp

@@ -43,6 +43,11 @@ static jsi::Value __hostFunction_NativeHotUpdaterCxxSpecJSI_removeListeners(jsi:
   );
   return jsi::Value::undefined();
 }
+static jsi::Value __hostFunction_NativeHotUpdaterCxxSpecJSI_getConstants(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeHotUpdaterCxxSpecJSI *>(&turboModule)->getConstants(
+    rt
+  );
+}
 
 NativeHotUpdaterCxxSpecJSI::NativeHotUpdaterCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
   : TurboModule("HotUpdater", jsInvoker) {
@@ -51,6 +56,7 @@ NativeHotUpdaterCxxSpecJSI::NativeHotUpdaterCxxSpecJSI(std::shared_ptr<CallInvok
   methodMap_["getAppVersion"] = MethodMetadata {0, __hostFunction_NativeHotUpdaterCxxSpecJSI_getAppVersion};
   methodMap_["addListener"] = MethodMetadata {1, __hostFunction_NativeHotUpdaterCxxSpecJSI_addListener};
   methodMap_["removeListeners"] = MethodMetadata {1, __hostFunction_NativeHotUpdaterCxxSpecJSI_removeListeners};
+  methodMap_["getConstants"] = MethodMetadata {0, __hostFunction_NativeHotUpdaterCxxSpecJSI_getConstants};
 }
 
 

package/android/generated/jni/react/renderer/components/HotUpdaterSpec/HotUpdaterSpecJSI.h

@@ -25,6 +25,7 @@ public:
   virtual jsi::Value getAppVersion(jsi::Runtime &rt) = 0;
   virtual void addListener(jsi::Runtime &rt, jsi::String eventName) = 0;
   virtual void removeListeners(jsi::Runtime &rt, double count) = 0;
+  virtual jsi::Object getConstants(jsi::Runtime &rt) = 0;
 
 };
 
@@ -91,6 +92,14 @@ private:
       return bridging::callFromJs<void>(
           rt, &T::removeListeners, jsInvoker_, instance_, std::move(count));
     }
+    jsi::Object getConstants(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::getConstants) == 1,
+          "Expected getConstants(...) to have 1 parameters");
+
+      return bridging::callFromJs<jsi::Object>(
+          rt, &T::getConstants, jsInvoker_, instance_);
+    }
 
   private:
     friend class NativeHotUpdaterCxxSpec;

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

@@ -153,7 +153,7 @@ class HotUpdater : ReactPackage {
             }
             tempDir.mkdirs()
 
-            val tempZipFile = File(tempDir, "build.zip")
+            val tempZipFile = File(tempDir, "bundle.zip")
             val extractedDir = File(tempDir, "extracted")
             extractedDir.mkdirs()
 
@@ -274,5 +274,51 @@ class HotUpdater : ReactPackage {
                 }
             }
         }
+
+        fun getMinBundleId(context: Context): String =
+            try {
+                val apkFile = File(context.applicationInfo.sourceDir)
+                val buildTimestampMs = apkFile.lastModified()
+                val bytes =
+                    ByteArray(16).apply {
+                        this[0] = ((buildTimestampMs shr 40) and 0xFF).toByte()
+                        this[1] = ((buildTimestampMs shr 32) and 0xFF).toByte()
+                        this[2] = ((buildTimestampMs shr 24) and 0xFF).toByte()
+                        this[3] = ((buildTimestampMs shr 16) and 0xFF).toByte()
+                        this[4] = ((buildTimestampMs shr 8) and 0xFF).toByte()
+                        this[5] = (buildTimestampMs and 0xFF).toByte()
+                        this[6] = 0x70.toByte()
+                        this[7] = 0x00.toByte()
+                        this[8] = 0x80.toByte()
+                        this[9] = 0x00.toByte()
+                        this[10] = 0x00.toByte()
+                        this[11] = 0x00.toByte()
+                        this[12] = 0x00.toByte()
+                        this[13] = 0x00.toByte()
+                        this[14] = 0x00.toByte()
+                        this[15] = 0x00.toByte()
+                    }
+                String.format(
+                    "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+                    bytes[0].toInt() and 0xFF,
+                    bytes[1].toInt() and 0xFF,
+                    bytes[2].toInt() and 0xFF,
+                    bytes[3].toInt() and 0xFF,
+                    bytes[4].toInt() and 0xFF,
+                    bytes[5].toInt() and 0xFF,
+                    bytes[6].toInt() and 0xFF,
+                    bytes[7].toInt() and 0xFF,
+                    bytes[8].toInt() and 0xFF,
+                    bytes[9].toInt() and 0xFF,
+                    bytes[10].toInt() and 0xFF,
+                    bytes[11].toInt() and 0xFF,
+                    bytes[12].toInt() and 0xFF,
+                    bytes[13].toInt() and 0xFF,
+                    bytes[14].toInt() and 0xFF,
+                    bytes[15].toInt() and 0xFF,
+                )
+            } catch (e: Exception) {
+                "00000000-0000-0000-0000-000000000000"
+            }
     }
 }

package/android/src/newarch/HotUpdaterModule.kt

@@ -54,6 +54,12 @@ class HotUpdaterModule internal constructor(
         }
     }
 
+    override fun getTypedExportedConstants(): Map<String, Any?> {
+        val constants: MutableMap<String, Any?> = HashMap()
+        constants["MIN_BUNDLE_ID"] = HotUpdater.getMinBundleId(mReactApplicationContext)
+        return constants
+    }
+
     override fun addListener(eventName: String?) {
         // No-op
     }

package/android/src/newarch/ReactIntegrationManager.kt

@@ -34,13 +34,35 @@ class ReactIntegrationManager(
      * Reload the React Native application.
      */
     public fun reload(application: ReactApplication) {
-        val reactHost = application.reactHost
-        check(reactHost != null)
+        try {
+            val reactHost = application.reactHost
+            if (reactHost != null) {
+                val activity = reactHost.currentReactContext?.currentActivity
+                if (reactHost.lifecycleState != LifecycleState.RESUMED && activity != null) {
+                    reactHost.onHostResume(activity)
+                }
+                reactHost.reload("Requested by HotUpdater")
+            } else {
+                val reactNativeHost = application.reactNativeHost
+                try {
+                    reactNativeHost.reactInstanceManager.recreateReactContextInBackground()
+                } catch (e: Exception) {
+                    val currentActivity = reactNativeHost.reactInstanceManager.currentReactContext?.currentActivity
+                    if (currentActivity == null) {
+                        return
+                    }
 
-        val activity = reactHost.currentReactContext?.currentActivity
-        if (reactHost.lifecycleState != LifecycleState.RESUMED && activity != null) {
-            reactHost.onHostResume(activity)
+                    currentActivity.runOnUiThread {
+                        currentActivity.recreate()
+                    }
+                } catch (e: Exception) {
+                    Log.d("HotUpdater", "Failed to reload: ${e.message}")
+                    throw e
+                }
+            }
+        } catch (e: Exception) {
+            Log.d("HotUpdater", "Failed to reload: ${e.message}")
+            throw e
         }
-        reactHost.reload("Requested by HotUpdater")
     }
 }

package/android/src/oldarch/HotUpdaterModule.kt

@@ -54,6 +54,22 @@ class HotUpdaterModule internal constructor(
         }
     }
 
+    @ReactMethod
+    fun addListener(eventName: String?) {
+        // No-op
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Double) {
+        // No-op
+    }
+
+    override fun getConstants(): Map<String, Any?> {
+        val constants: MutableMap<String, Any?> = HashMap()
+        constants["MIN_BUNDLE_ID"] = HotUpdater.getMinBundleId(mReactApplicationContext)
+        return constants
+    }
+
     companion object {
         const val NAME = "HotUpdater"
     }

package/android/src/oldarch/ReactIntegrationManager.kt

@@ -36,6 +36,20 @@ class ReactIntegrationManager(
      */
     public fun reload(application: ReactApplication) {
         val reactNativeHost = application.reactNativeHost
-        reactNativeHost.reactInstanceManager.recreateReactContextInBackground()
+        try {
+            reactNativeHost.reactInstanceManager.recreateReactContextInBackground()
+        } catch (e: Exception) {
+            val currentActivity = reactNativeHost.reactInstanceManager.currentReactContext?.currentActivity
+            if (currentActivity == null) {
+                return
+            }
+
+            currentActivity.runOnUiThread {
+                currentActivity.recreate()
+            }
+        } catch (e: Exception) {
+            Log.d("HotUpdater", "Failed to reload: ${e.message}")
+            throw e
+        }
     }
 }

package/dist/checkForUpdate.d.ts

@@ -1,6 +1,5 @@
-import type { BundleArg, UpdateInfo } from "@hot-updater/core";
 export interface CheckForUpdateConfig {
-    source: BundleArg;
+    source: string;
     requestHeaders?: Record<string, string>;
 }
-export declare function checkForUpdate(config: CheckForUpdateConfig): Promise<UpdateInfo | null>;
+export declare function checkForUpdate(config: CheckForUpdateConfig): Promise<import("@hot-updater/core").AppUpdateInfo | null>;

package/dist/fetchUpdateInfo.d.ts

@@ -0,0 +1,2 @@
+import type { AppUpdateInfo, GetBundlesArgs } from "@hot-updater/core";
+export declare const fetchUpdateInfo: (source: string, { appVersion, bundleId, platform, minBundleId, channel }: GetBundlesArgs, requestHeaders?: Record<string, string>) => Promise<AppUpdateInfo | null>;

package/dist/index.d.ts

@@ -4,11 +4,106 @@ export type { HotUpdaterConfig } from "./wrap";
 export type { HotUpdaterEvent } from "./native";
 export * from "./store";
 export declare const HotUpdater: {
+    /**
+     * `HotUpdater.wrap` checks for updates at the entry point, and if there is a bundle to update, it downloads the bundle and applies the update strategy.
+     *
+     * @param {object} options - Configuration options
+     * @param {string} options.source - Update server URL
+     * @param {object} [options.requestHeaders] - Request headers
+     * @param {React.ComponentType} [options.fallbackComponent] - Component to display during updates
+     * @param {boolean} [options.reloadOnForceUpdate=true] - Whether to automatically reload the app on force updates
+     * @param {Function} [options.onUpdateProcessCompleted] - Callback after update process completes
+     * @param {Function} [options.onProgress] - Callback to track bundle download progress
+     * @returns {Function} Higher-order component that wraps the app component
+     *
+     * @example
+     * ```tsx
+     * export default HotUpdater.wrap({
+     *   source: "<your-update-server-url>",
+     *   requestHeaders: {
+     *     "Authorization": "Bearer <your-access-token>",
+     *   },
+     * })(App);
+     * ```
+     */
     wrap: typeof wrap;
+    /**
+     * Reloads the app.
+     */
     reload: () => void;
+    /**
+     * Fetches the current app version.
+     */
     getAppVersion: () => Promise<string | null>;
+    /**
+     * Fetches the current bundle ID of the app.
+     */
     getBundleId: () => string;
+    /**
+     * Retrieves the initial bundle ID based on the build time of the native app.
+     */
+    getMinBundleId: () => string;
+    /**
+     * Fetches the current release channel of the app.
+     *
+     * By default, if no channel is specified, the app is assigned to the 'production' channel.
+     *
+     * @returns {string} The current release channel of the app
+     *
+     * @example
+     * ```ts
+     * const channel = HotUpdater.getChannel();
+     * console.log(`Current channel: ${channel}`);
+     * ```
+     */
+    getChannel: () => string;
+    /**
+     * Adds a listener to HotUpdater events.
+     *
+     * @param {keyof HotUpdaterEvent} eventName - The name of the event to listen for
+     * @param {(event: HotUpdaterEvent[T]) => void} listener - The callback function to handle the event
+     * @returns {() => void} A cleanup function that removes the event listener
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = HotUpdater.addListener("onProgress", ({ progress }) => {
+     *   console.log(`Update progress: ${progress * 100}%`);
+     * });
+     *
+     * // Unsubscribe when no longer needed
+     * unsubscribe();
+     * ```
+     */
     addListener: <T extends keyof import("./native").HotUpdaterEvent>(eventName: T, listener: (event: import("./native").HotUpdaterEvent[T]) => void) => () => void;
+    /**
+     * Manually checks for updates.
+     *
+     * @param {Object} config - Update check configuration
+     * @param {string} config.source - Update server URL
+     * @param {Record<string, string>} [config.requestHeaders] - Request headers
+     *
+     * @returns {Promise<UpdateInfo | null>} Update information or null if up to date
+     *
+     * @example
+     * ```ts
+     * const updateInfo = await HotUpdater.checkForUpdate({
+     *   source: "<your-update-server-url>",
+     *   requestHeaders: {
+     *     Authorization: "Bearer <your-access-token>",
+     *   },
+     * });
+     *
+     * if (!updateInfo) {
+     *   console.log("App is up to date");
+     *   return;
+     * }
+     *
+     * await HotUpdater.updateBundle(updateInfo.id, updateInfo.fileUrl);
+     * if (updateInfo.shouldForceUpdate) {
+     *   HotUpdater.reload();
+     * }
+     * ```
+     */
     checkForUpdate: typeof checkForUpdate;
     /**
      * Manually checks and applies updates for the application.
@@ -43,5 +138,34 @@ export declare const HotUpdater: {
      * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
      */
     runUpdateProcess: ({ reloadOnForceUpdate, ...checkForUpdateConfig }: import("./runUpdateProcess").RunUpdateProcessConfig) => Promise<import("./runUpdateProcess").RunUpdateProcessResponse>;
+    /**
+     * Updates the bundle of the app.
+     *
+     * @param {string} bundleId - The bundle ID of the app
+     * @param {string} zipUrl - The URL of the zip file
+     *
+     * @returns {Promise<boolean>} Whether the update was successful
+     *
+     * @example
+     * ```ts
+     * const updateInfo = await HotUpdater.checkForUpdate({
+     *   source: "<your-update-server-url>",
+     *   requestHeaders: {
+     *     Authorization: "Bearer <your-access-token>",
+     *   },
+     * });
+     *
+     * if (!updateInfo) {
+     *   return {
+     *     status: "UP_TO_DATE",
+     *   };
+     * }
+     *
+     * await HotUpdater.updateBundle(updateInfo.id, updateInfo.fileUrl);
+     * if (updateInfo.shouldForceUpdate) {
+     *   HotUpdater.reload();
+     * }
+     * ```
+     */
     updateBundle: (bundleId: string, zipUrl: string | null) => Promise<boolean>;
 };

package/dist/index.js

@@ -59,35 +59,37 @@ var __webpack_exports__ = {};
         useHotUpdaterStore: ()=>useHotUpdaterStore,
         hotUpdaterStore: ()=>hotUpdaterStore
     });
-    const js_namespaceObject = require("@hot-updater/js");
     var external_react_native_ = __webpack_require__("react-native");
-    const ensureUpdateInfo = async (source, { appVersion, bundleId, platform }, requestHeaders)=>{
-        try {
-            let bundles = null;
-            if ("string" == typeof source) {
-                if (source.startsWith("http")) return await fetch(source, {
-                    headers: {
-                        "x-app-platform": platform,
-                        "x-app-version": appVersion,
-                        "x-bundle-id": bundleId,
-                        ...requestHeaders
-                    }
-                }).then((res)=>res.json());
-            } else bundles = "function" == typeof source ? await source() : source;
-            return bundles ?? [];
-        } catch  {
-            return [];
-        }
-    };
     class HotUpdaterError extends Error {
         constructor(message){
             super(message);
             this.name = "HotUpdaterError";
         }
     }
+    const fetchUpdateInfo = async (source, { appVersion, bundleId, platform, minBundleId, channel }, requestHeaders)=>{
+        try {
+            return fetch(source, {
+                headers: {
+                    "x-app-platform": platform,
+                    "x-app-version": appVersion,
+                    "x-bundle-id": bundleId,
+                    ...minBundleId ? {
+                        "x-min-bundle-id": minBundleId
+                    } : {},
+                    ...channel ? {
+                        "x-channel": channel
+                    } : {},
+                    ...requestHeaders
+                }
+            }).then((res)=>200 === res.status ? res.json() : null);
+        } catch  {
+            return null;
+        }
+    };
     const NIL_UUID = "00000000-0000-0000-0000-000000000000";
     const HotUpdater = {
-        HOT_UPDATER_BUNDLE_ID: NIL_UUID
+        HOT_UPDATER_BUNDLE_ID: NIL_UUID,
+        CHANNEL: "production"
     };
     const LINKING_ERROR = `The package '@hot-updater/react-native' doesn't seem to be linked. Make sure: \n\n` + external_react_native_.Platform.select({
         ios: "- You have run 'pod install'\n",
@@ -114,7 +116,15 @@ var __webpack_exports__ = {};
             HotUpdaterNative.reload();
         });
     };
-    const getBundleId = ()=>HotUpdater.HOT_UPDATER_BUNDLE_ID;
+    const getMinBundleId = ()=>{
+        const constants = HotUpdaterNative.getConstants();
+        return constants.MIN_BUNDLE_ID;
+    };
+    const getBundleId = ()=>{
+        const minBundleId = getMinBundleId();
+        return minBundleId.localeCompare(HotUpdater.HOT_UPDATER_BUNDLE_ID) >= 0 ? minBundleId : HotUpdater.HOT_UPDATER_BUNDLE_ID;
+    };
+    const getChannel = ()=>HotUpdater.CHANNEL;
     async function checkForUpdate(config) {
         if (__DEV__) return null;
         if (![
@@ -123,28 +133,25 @@ var __webpack_exports__ = {};
         ].includes(external_react_native_.Platform.OS)) throw new HotUpdaterError("HotUpdater is only supported on iOS and Android");
         const currentAppVersion = await getAppVersion();
         const platform = external_react_native_.Platform.OS;
-        const currentBundleId = await getBundleId();
+        const currentBundleId = getBundleId();
+        const minBundleId = getMinBundleId();
+        const channel = getChannel();
         if (!currentAppVersion) throw new HotUpdaterError("Failed to get app version");
-        const ensuredUpdateInfo = await ensureUpdateInfo(config.source, {
+        return fetchUpdateInfo(config.source, {
             appVersion: currentAppVersion,
             bundleId: currentBundleId,
-            platform
+            platform,
+            minBundleId,
+            channel
         }, config.requestHeaders);
-        let updateInfo = null;
-        if (Array.isArray(ensuredUpdateInfo)) {
-            const bundles = ensuredUpdateInfo;
-            updateInfo = await (0, js_namespaceObject.getUpdateInfo)(bundles, {
-                appVersion: currentAppVersion,
-                bundleId: currentBundleId,
-                platform
-            });
-        } else updateInfo = ensuredUpdateInfo;
-        return updateInfo;
     }
     const runUpdateProcess = async ({ reloadOnForceUpdate = true, ...checkForUpdateConfig })=>{
         const updateInfo = await checkForUpdate(checkForUpdateConfig);
         if (!updateInfo) return {
-            status: "UP_TO_DATE"
+            status: "UP_TO_DATE",
+            shouldForceUpdate: false,
+            message: null,
+            id: getBundleId()
         };
         const isUpdated = await updateBundle(updateInfo.id, updateInfo.fileUrl);
         if (isUpdated && updateInfo.shouldForceUpdate && reloadOnForceUpdate) reload();
@@ -152,7 +159,8 @@ var __webpack_exports__ = {};
         return {
             status: updateInfo.status,
             shouldForceUpdate: updateInfo.shouldForceUpdate,
-            id: updateInfo.id
+            id: updateInfo.id,
+            message: updateInfo.message
         };
     };
     const with_selector_namespaceObject = require("use-sync-external-store/shim/with-selector");
@@ -168,10 +176,10 @@ var __webpack_exports__ = {};
         const emitChange = ()=>{
             for (const listener of listeners)listener();
         };
-        const setProgress = (progress)=>{
+        const setState = (newState)=>{
             state = {
-                isBundleUpdated: 1 === progress,
-                progress
+                ...state,
+                ...newState
             };
             emitChange();
         };
@@ -181,13 +189,14 @@ var __webpack_exports__ = {};
         };
         return {
             getSnapshot,
-            setProgress,
+            setState,
             subscribe
         };
     };
     const hotUpdaterStore = createHotUpdaterStore();
     const useHotUpdaterStore = (selector = (snapshot)=>snapshot)=>useSyncExternalStoreWithSelector(hotUpdaterStore.subscribe, hotUpdaterStore.getSnapshot, hotUpdaterStore.getSnapshot, selector);
     const external_react_namespaceObject = require("react");
+    var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
     function useEventCallback(fn) {
         const callbackRef = (0, external_react_namespaceObject.useRef)(()=>{
             throw new Error("Cannot call an event handler while rendering.");
@@ -206,6 +215,7 @@ var __webpack_exports__ = {};
         return (WrappedComponent)=>{
             const HotUpdaterHOC = ()=>{
                 const progress = useHotUpdaterStore((state)=>state.progress);
+                const [message, setMessage] = (0, external_react_namespaceObject.useState)(null);
                 const [updateStatus, setUpdateStatus] = (0, external_react_namespaceObject.useState)("CHECK_FOR_UPDATE");
                 const initHotUpdater = useEventCallback(async ()=>{
                     try {
@@ -214,9 +224,13 @@ var __webpack_exports__ = {};
                             source: restConfig.source,
                             requestHeaders: restConfig.requestHeaders
                         });
+                        setMessage(updateInfo?.message ?? null);
                         if (!updateInfo) {
                             restConfig.onUpdateProcessCompleted?.({
-                                status: "UP_TO_DATE"
+                                status: "UP_TO_DATE",
+                                shouldForceUpdate: false,
+                                message: null,
+                                id: getBundleId()
                             });
                             setUpdateStatus("UPDATE_PROCESS_COMPLETED");
                             return;
@@ -226,7 +240,8 @@ var __webpack_exports__ = {};
                             restConfig.onUpdateProcessCompleted?.({
                                 id: updateInfo.id,
                                 status: updateInfo.status,
-                                shouldForceUpdate: updateInfo.shouldForceUpdate
+                                shouldForceUpdate: updateInfo.shouldForceUpdate,
+                                message: updateInfo.message
                             });
                             setUpdateStatus("UPDATE_PROCESS_COMPLETED");
                             return;
@@ -238,7 +253,8 @@ var __webpack_exports__ = {};
                         restConfig.onUpdateProcessCompleted?.({
                             id: updateInfo.id,
                             status: updateInfo.status,
-                            shouldForceUpdate: updateInfo.shouldForceUpdate
+                            shouldForceUpdate: updateInfo.shouldForceUpdate,
+                            message: updateInfo.message
                         });
                         setUpdateStatus("UPDATE_PROCESS_COMPLETED");
                     } catch (error) {
@@ -257,24 +273,29 @@ var __webpack_exports__ = {};
                 }, []);
                 if (restConfig.fallbackComponent && "UPDATE_PROCESS_COMPLETED" !== updateStatus) {
                     const Fallback = restConfig.fallbackComponent;
-                    return /*#__PURE__*/ React.createElement(Fallback, {
+                    return /*#__PURE__*/ external_react_default().createElement(Fallback, {
                         progress: progress,
-                        status: updateStatus
+                        status: updateStatus,
+                        message: message
                     });
                 }
-                return /*#__PURE__*/ React.createElement(WrappedComponent, null);
+                return /*#__PURE__*/ external_react_default().createElement(WrappedComponent, null);
             };
             return HotUpdaterHOC;
         };
     }
     addListener("onProgress", ({ progress })=>{
-        hotUpdaterStore.setProgress(progress);
+        hotUpdaterStore.setState({
+            progress
+        });
     });
     const src_HotUpdater = {
         wrap: wrap,
         reload: reload,
         getAppVersion: getAppVersion,
         getBundleId: getBundleId,
+        getMinBundleId: getMinBundleId,
+        getChannel: getChannel,
         addListener: addListener,
         checkForUpdate: checkForUpdate,
         runUpdateProcess: runUpdateProcess,