@hot-updater/react-native 0.6.5 → 0.6.7

package/dist/index.d.ts

@@ -10,6 +10,38 @@ export declare const HotUpdater: {
     getBundleId: () => string;
     addListener: <T extends keyof import("./native").HotUpdaterEvent>(eventName: T, listener: (event: import("./native").HotUpdaterEvent[T]) => void) => () => void;
     checkForUpdate: typeof checkForUpdate;
+    /**
+     * Manually checks and applies updates for the application.
+     *
+     * @param {RunUpdateProcessConfig} config - Update process configuration
+     * @param {string} config.source - Update server URL
+     * @param {Record<string, string>} [config.requestHeaders] - Request headers
+     * @param {boolean} [config.reloadOnForceUpdate=false] - Whether to automatically reload on force update
+     *
+     * @example
+     * ```ts
+     * // Auto reload on force update
+     * const result = await HotUpdater.runUpdateProcess({
+     *   source: "<your-update-server-url>",
+     *   requestHeaders: {
+     *     // Add necessary headers
+     *   },
+     *   reloadOnForceUpdate: true
+     * });
+     *
+     * // Manually handle reload on force update
+     * const result = await HotUpdater.runUpdateProcess({
+     *   source: "<your-update-server-url>",
+     *   reloadOnForceUpdate: false
+     * });
+     *
+     * if(result.status !== "UP_TO_DATE" && result.shouldForceUpdate) {
+     *   HotUpdater.reload();
+     * }
+     * ```
+     *
+     * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
+     */
     runUpdateProcess: ({ reloadOnForceUpdate, ...checkForUpdateConfig }: import("./runUpdateProcess").RunUpdateProcessConfig) => Promise<import("./runUpdateProcess").RunUpdateProcessResponse>;
     updateBundle: (bundleId: string, zipUrl: string | null) => Promise<boolean>;
 };

package/dist/index.js

@@ -1721,7 +1721,7 @@ var __webpack_exports__ = {};
         } else updateInfo = ensuredUpdateInfo;
         return updateInfo;
     }
-    const runUpdateProcess = async ({ reloadOnForceUpdate = false, ...checkForUpdateConfig })=>{
+    const runUpdateProcess = async ({ reloadOnForceUpdate = true, ...checkForUpdateConfig })=>{
         const updateInfo = await checkForUpdate(checkForUpdateConfig);
         if (!updateInfo) return {
             status: "UP_TO_DATE"
@@ -1783,10 +1783,10 @@ var __webpack_exports__ = {};
         return (WrappedComponent)=>{
             const HotUpdaterHOC = ()=>{
                 const { progress } = useHotUpdaterStore();
-                const [status, setStatus] = (0, react.useState)("IDLE");
+                const [updateStatus, setUpdateStatus] = (0, react.useState)("CHECK_FOR_UPDATE");
                 const initHotUpdater = useEventCallback(async ()=>{
                     try {
-                        setStatus("CHECK_FOR_UPDATE");
+                        setUpdateStatus("CHECK_FOR_UPDATE");
                         const updateInfo = await checkForUpdate({
                             source: restConfig.source,
                             requestHeaders: restConfig.requestHeaders
@@ -1795,22 +1795,32 @@ var __webpack_exports__ = {};
                             restConfig.onUpdateProcessCompleted?.({
                                 status: "UP_TO_DATE"
                             });
-                            setStatus("UPDATE_PROCESS_COMPLETED");
+                            setUpdateStatus("UPDATE_PROCESS_COMPLETED");
                             return;
                         }
-                        setStatus("UPDATING");
+                        if (false === updateInfo.shouldForceUpdate) {
+                            updateBundle(updateInfo.id, updateInfo.fileUrl);
+                            restConfig.onUpdateProcessCompleted?.({
+                                id: updateInfo.id,
+                                status: updateInfo.status,
+                                shouldForceUpdate: updateInfo.shouldForceUpdate
+                            });
+                            setUpdateStatus("UPDATE_PROCESS_COMPLETED");
+                            return;
+                        }
+                        setUpdateStatus("UPDATING");
                         const isSuccess = await updateBundle(updateInfo.id, updateInfo.fileUrl);
                         if (!isSuccess) throw new Error("New update was found but failed to download the bundle.");
-                        if (updateInfo.shouldForceUpdate && reloadOnForceUpdate) reload();
+                        if (reloadOnForceUpdate) reload();
                         restConfig.onUpdateProcessCompleted?.({
                             id: updateInfo.id,
                             status: updateInfo.status,
                             shouldForceUpdate: updateInfo.shouldForceUpdate
                         });
-                        setStatus("UPDATE_PROCESS_COMPLETED");
+                        setUpdateStatus("UPDATE_PROCESS_COMPLETED");
                     } catch (error) {
                         if (error instanceof HotUpdaterError) restConfig.onError?.(error);
-                        setStatus("UPDATE_PROCESS_COMPLETED");
+                        setUpdateStatus("UPDATE_PROCESS_COMPLETED");
                         throw error;
                     }
                 });
@@ -1822,10 +1832,11 @@ var __webpack_exports__ = {};
                 (0, react.useLayoutEffect)(()=>{
                     initHotUpdater();
                 }, []);
-                if (restConfig.fallbackComponent && "UPDATE_PROCESS_COMPLETED" !== status) {
+                if (restConfig.fallbackComponent && "UPDATE_PROCESS_COMPLETED" !== updateStatus) {
                     const Fallback = restConfig.fallbackComponent;
                     return /*#__PURE__*/ React.createElement(Fallback, {
-                        progress: progress
+                        progress: progress,
+                        status: updateStatus
                     });
                 }
                 return /*#__PURE__*/ React.createElement(WrappedComponent, null);

package/dist/index.mjs

@@ -1690,7 +1690,7 @@ async function checkForUpdate(config) {
     } else updateInfo = ensuredUpdateInfo;
     return updateInfo;
 }
-const runUpdateProcess = async ({ reloadOnForceUpdate = false, ...checkForUpdateConfig })=>{
+const runUpdateProcess = async ({ reloadOnForceUpdate = true, ...checkForUpdateConfig })=>{
     const updateInfo = await checkForUpdate(checkForUpdateConfig);
     if (!updateInfo) return {
         status: "UP_TO_DATE"
@@ -1752,10 +1752,10 @@ function wrap(config) {
     return (WrappedComponent)=>{
         const HotUpdaterHOC = ()=>{
             const { progress } = useHotUpdaterStore();
-            const [status, setStatus] = (0, react.useState)("IDLE");
+            const [updateStatus, setUpdateStatus] = (0, react.useState)("CHECK_FOR_UPDATE");
             const initHotUpdater = useEventCallback(async ()=>{
                 try {
-                    setStatus("CHECK_FOR_UPDATE");
+                    setUpdateStatus("CHECK_FOR_UPDATE");
                     const updateInfo = await checkForUpdate({
                         source: restConfig.source,
                         requestHeaders: restConfig.requestHeaders
@@ -1764,22 +1764,32 @@ function wrap(config) {
                         restConfig.onUpdateProcessCompleted?.({
                             status: "UP_TO_DATE"
                         });
-                        setStatus("UPDATE_PROCESS_COMPLETED");
+                        setUpdateStatus("UPDATE_PROCESS_COMPLETED");
                         return;
                     }
-                    setStatus("UPDATING");
+                    if (false === updateInfo.shouldForceUpdate) {
+                        updateBundle(updateInfo.id, updateInfo.fileUrl);
+                        restConfig.onUpdateProcessCompleted?.({
+                            id: updateInfo.id,
+                            status: updateInfo.status,
+                            shouldForceUpdate: updateInfo.shouldForceUpdate
+                        });
+                        setUpdateStatus("UPDATE_PROCESS_COMPLETED");
+                        return;
+                    }
+                    setUpdateStatus("UPDATING");
                     const isSuccess = await updateBundle(updateInfo.id, updateInfo.fileUrl);
                     if (!isSuccess) throw new Error("New update was found but failed to download the bundle.");
-                    if (updateInfo.shouldForceUpdate && reloadOnForceUpdate) reload();
+                    if (reloadOnForceUpdate) reload();
                     restConfig.onUpdateProcessCompleted?.({
                         id: updateInfo.id,
                         status: updateInfo.status,
                         shouldForceUpdate: updateInfo.shouldForceUpdate
                     });
-                    setStatus("UPDATE_PROCESS_COMPLETED");
+                    setUpdateStatus("UPDATE_PROCESS_COMPLETED");
                 } catch (error) {
                     if (error instanceof HotUpdaterError) restConfig.onError?.(error);
-                    setStatus("UPDATE_PROCESS_COMPLETED");
+                    setUpdateStatus("UPDATE_PROCESS_COMPLETED");
                     throw error;
                 }
             });
@@ -1791,10 +1801,11 @@ function wrap(config) {
             (0, react.useLayoutEffect)(()=>{
                 initHotUpdater();
             }, []);
-            if (restConfig.fallbackComponent && "UPDATE_PROCESS_COMPLETED" !== status) {
+            if (restConfig.fallbackComponent && "UPDATE_PROCESS_COMPLETED" !== updateStatus) {
                 const Fallback = restConfig.fallbackComponent;
                 return /*#__PURE__*/ React.createElement(Fallback, {
-                    progress: progress
+                    progress: progress,
+                    status: updateStatus
                 });
             }
             return /*#__PURE__*/ React.createElement(WrappedComponent, null);

package/dist/runUpdateProcess.d.ts

@@ -10,8 +10,40 @@ export interface RunUpdateProcessConfig extends CheckForUpdateConfig {
     /**
      * If `true`, the app will be reloaded when the downloaded bundle is a force update.
      * If `false`, shouldForceUpdate will be returned as true but the app won't reload.
-     * @default false
+     * @default true
      */
     reloadOnForceUpdate?: boolean;
 }
+/**
+ * Manually checks and applies updates for the application.
+ *
+ * @param {RunUpdateProcessConfig} config - Update process configuration
+ * @param {string} config.source - Update server URL
+ * @param {Record<string, string>} [config.requestHeaders] - Request headers
+ * @param {boolean} [config.reloadOnForceUpdate=true] - Whether to automatically reload on force update
+ *
+ * @example
+ * ```ts
+ * // Auto reload on force update
+ * const result = await HotUpdater.runUpdateProcess({
+ *   source: "<your-update-server-url>",
+ *   requestHeaders: {
+ *     // Add necessary headers
+ *   },
+ *   reloadOnForceUpdate: true
+ * });
+ *
+ * // Manually handle reload on force update
+ * const result = await HotUpdater.runUpdateProcess({
+ *   source: "<your-update-server-url>",
+ *   reloadOnForceUpdate: false
+ * });
+ *
+ * if(result.status !== "UP_TO_DATE" && result.shouldForceUpdate) {
+ *   HotUpdater.reload();
+ * }
+ * ```
+ *
+ * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
+ */
 export declare const runUpdateProcess: ({ reloadOnForceUpdate, ...checkForUpdateConfig }: RunUpdateProcessConfig) => Promise<RunUpdateProcessResponse>;

package/dist/wrap.d.ts

@@ -2,7 +2,7 @@ import type React from "react";
 import { type CheckForUpdateConfig } from "./checkUpdate";
 import { HotUpdaterError } from "./error";
 import type { RunUpdateProcessResponse } from "./runUpdateProcess";
-import { type HotUpdaterState } from "./store";
+type UpdateStatus = "CHECK_FOR_UPDATE" | "UPDATING" | "UPDATE_PROCESS_COMPLETED";
 export interface HotUpdaterConfig extends CheckForUpdateConfig {
     /**
      * Component to show while downloading a new bundle update.
@@ -25,7 +25,10 @@ export interface HotUpdaterConfig extends CheckForUpdateConfig {
      *
      * If not defined, the bundle will download in the background without blocking the screen.
      */
-    fallbackComponent?: React.FC<Pick<HotUpdaterState, "progress">>;
+    fallbackComponent?: React.FC<{
+        status: Exclude<UpdateStatus, "UPDATE_PROCESS_COMPLETED">;
+        progress: number;
+    }>;
     onError?: (error: HotUpdaterError) => void;
     onProgress?: (progress: number) => void;
     /**
@@ -43,3 +46,4 @@ export interface HotUpdaterConfig extends CheckForUpdateConfig {
     onUpdateProcessCompleted?: (response: RunUpdateProcessResponse) => void;
 }
 export declare function wrap<P>(config: HotUpdaterConfig): (WrappedComponent: React.ComponentType) => React.ComponentType<P>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "React Native OTA solution for self-hosted",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -78,8 +78,8 @@
     "react-native-builder-bob": "^0.33.1"
   },
   "dependencies": {
-    "@hot-updater/js": "0.6.5",
-    "@hot-updater/core": "0.6.5"
+    "@hot-updater/js": "0.6.7",
+    "@hot-updater/core": "0.6.7"
   },
   "scripts": {
     "build": "rslib build",

package/src/index.ts

@@ -28,6 +28,38 @@ export const HotUpdater = {
   addListener,
 
   checkForUpdate,
+  /**
+   * Manually checks and applies updates for the application.
+   *
+   * @param {RunUpdateProcessConfig} config - Update process configuration
+   * @param {string} config.source - Update server URL
+   * @param {Record<string, string>} [config.requestHeaders] - Request headers
+   * @param {boolean} [config.reloadOnForceUpdate=false] - Whether to automatically reload on force update
+   *
+   * @example
+   * ```ts
+   * // Auto reload on force update
+   * const result = await HotUpdater.runUpdateProcess({
+   *   source: "<your-update-server-url>",
+   *   requestHeaders: {
+   *     // Add necessary headers
+   *   },
+   *   reloadOnForceUpdate: true
+   * });
+   *
+   * // Manually handle reload on force update
+   * const result = await HotUpdater.runUpdateProcess({
+   *   source: "<your-update-server-url>",
+   *   reloadOnForceUpdate: false
+   * });
+   *
+   * if(result.status !== "UP_TO_DATE" && result.shouldForceUpdate) {
+   *   HotUpdater.reload();
+   * }
+   * ```
+   *
+   * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
+   */
   runUpdateProcess,
   updateBundle,
 };

package/src/runUpdateProcess.ts

@@ -15,13 +15,45 @@ export interface RunUpdateProcessConfig extends CheckForUpdateConfig {
   /**
    * If `true`, the app will be reloaded when the downloaded bundle is a force update.
    * If `false`, shouldForceUpdate will be returned as true but the app won't reload.
-   * @default false
+   * @default true
    */
   reloadOnForceUpdate?: boolean;
 }
 
+/**
+ * Manually checks and applies updates for the application.
+ *
+ * @param {RunUpdateProcessConfig} config - Update process configuration
+ * @param {string} config.source - Update server URL
+ * @param {Record<string, string>} [config.requestHeaders] - Request headers
+ * @param {boolean} [config.reloadOnForceUpdate=true] - Whether to automatically reload on force update
+ *
+ * @example
+ * ```ts
+ * // Auto reload on force update
+ * const result = await HotUpdater.runUpdateProcess({
+ *   source: "<your-update-server-url>",
+ *   requestHeaders: {
+ *     // Add necessary headers
+ *   },
+ *   reloadOnForceUpdate: true
+ * });
+ *
+ * // Manually handle reload on force update
+ * const result = await HotUpdater.runUpdateProcess({
+ *   source: "<your-update-server-url>",
+ *   reloadOnForceUpdate: false
+ * });
+ *
+ * if(result.status !== "UP_TO_DATE" && result.shouldForceUpdate) {
+ *   HotUpdater.reload();
+ * }
+ * ```
+ *
+ * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
+ */
 export const runUpdateProcess = async ({
-  reloadOnForceUpdate = false,
+  reloadOnForceUpdate = true,
   ...checkForUpdateConfig
 }: RunUpdateProcessConfig): Promise<RunUpdateProcessResponse> => {
   const updateInfo = await checkForUpdate(checkForUpdateConfig);

package/src/wrap.tsx

@@ -5,7 +5,12 @@ import { HotUpdaterError } from "./error";
 import { useEventCallback } from "./hooks/useEventCallback";
 import { reload, updateBundle } from "./native";
 import type { RunUpdateProcessResponse } from "./runUpdateProcess";
-import { type HotUpdaterState, useHotUpdaterStore } from "./store";
+import { useHotUpdaterStore } from "./store";
+
+type UpdateStatus =
+  | "CHECK_FOR_UPDATE"
+  | "UPDATING"
+  | "UPDATE_PROCESS_COMPLETED";
 
 export interface HotUpdaterConfig extends CheckForUpdateConfig {
   /**
@@ -29,7 +34,10 @@ export interface HotUpdaterConfig extends CheckForUpdateConfig {
    *
    * If not defined, the bundle will download in the background without blocking the screen.
    */
-  fallbackComponent?: React.FC<Pick<HotUpdaterState, "progress">>;
+  fallbackComponent?: React.FC<{
+    status: Exclude<UpdateStatus, "UPDATE_PROCESS_COMPLETED">;
+    progress: number;
+  }>;
   onError?: (error: HotUpdaterError) => void;
   onProgress?: (progress: number) => void;
   /**
@@ -54,13 +62,12 @@ export function wrap<P>(
   return (WrappedComponent) => {
     const HotUpdaterHOC: React.FC<P> = () => {
       const { progress } = useHotUpdaterStore();
-      const [status, setStatus] = useState<
-        "IDLE" | "CHECK_FOR_UPDATE" | "UPDATING" | "UPDATE_PROCESS_COMPLETED"
-      >("IDLE");
+      const [updateStatus, setUpdateStatus] =
+        useState<UpdateStatus>("CHECK_FOR_UPDATE");
 
       const initHotUpdater = useEventCallback(async () => {
         try {
-          setStatus("CHECK_FOR_UPDATE");
+          setUpdateStatus("CHECK_FOR_UPDATE");
           const updateInfo = await checkForUpdate({
             source: restConfig.source,
             requestHeaders: restConfig.requestHeaders,
@@ -69,12 +76,23 @@ export function wrap<P>(
             restConfig.onUpdateProcessCompleted?.({
               status: "UP_TO_DATE",
             });
-            setStatus("UPDATE_PROCESS_COMPLETED");
+            setUpdateStatus("UPDATE_PROCESS_COMPLETED");
             return;
           }
 
-          setStatus("UPDATING");
+          if (updateInfo.shouldForceUpdate === false) {
+            void updateBundle(updateInfo.id, updateInfo.fileUrl);
+            restConfig.onUpdateProcessCompleted?.({
+              id: updateInfo.id,
+              status: updateInfo.status,
+              shouldForceUpdate: updateInfo.shouldForceUpdate,
+            });
+            setUpdateStatus("UPDATE_PROCESS_COMPLETED");
+            return;
+          }
 
+          // Force Update Scenario
+          setUpdateStatus("UPDATING");
           const isSuccess = await updateBundle(
             updateInfo.id,
             updateInfo.fileUrl,
@@ -85,7 +103,7 @@ export function wrap<P>(
             );
           }
 
-          if (updateInfo.shouldForceUpdate && reloadOnForceUpdate) {
+          if (reloadOnForceUpdate) {
             reload();
           }
 
@@ -94,12 +112,12 @@ export function wrap<P>(
             status: updateInfo.status,
             shouldForceUpdate: updateInfo.shouldForceUpdate,
           });
-          setStatus("UPDATE_PROCESS_COMPLETED");
+          setUpdateStatus("UPDATE_PROCESS_COMPLETED");
         } catch (error) {
           if (error instanceof HotUpdaterError) {
             restConfig.onError?.(error);
           }
-          setStatus("UPDATE_PROCESS_COMPLETED");
+          setUpdateStatus("UPDATE_PROCESS_COMPLETED");
           throw error;
         }
       });
@@ -114,10 +132,10 @@ export function wrap<P>(
 
       if (
         restConfig.fallbackComponent &&
-        status !== "UPDATE_PROCESS_COMPLETED"
+        updateStatus !== "UPDATE_PROCESS_COMPLETED"
       ) {
         const Fallback = restConfig.fallbackComponent;
-        return <Fallback progress={progress} />;
+        return <Fallback progress={progress} status={updateStatus} />;
       }
 
       return <WrappedComponent />;