@hot-updater/react-native 0.12.7 → 0.13.1

package/src/index.ts

@@ -3,6 +3,8 @@ import {
   addListener,
   getAppVersion,
   getBundleId,
+  getChannel,
+  getMinBundleId,
   reload,
   updateBundle,
 } from "./native";
@@ -16,17 +18,112 @@ export type { HotUpdaterEvent } from "./native";
 export * from "./store";
 
 addListener("onProgress", ({ progress }) => {
-  hotUpdaterStore.setProgress(progress);
+  hotUpdaterStore.setState({
+    progress,
+  });
 });
 
 export 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,
-
+  /**
+   * Reloads the app.
+   */
   reload,
+  /**
+   * Fetches the current app version.
+   */
   getAppVersion,
+  /**
+   * Fetches the current bundle ID of the app.
+   */
   getBundleId,
+  /**
+   * Retrieves the initial bundle ID based on the build time of the native app.
+   */
+  getMinBundleId,
+  /**
+   * 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,
+  /**
+   * 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,
-
+  /**
+   * 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,
   /**
    * Manually checks and applies updates for the application.
@@ -61,5 +158,34 @@ export const HotUpdater = {
    * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
    */
   runUpdateProcess,
+  /**
+   * 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,
 };

package/src/native.ts

@@ -4,6 +4,7 @@ const NIL_UUID = "00000000-0000-0000-0000-000000000000";
 
 const HotUpdater = {
   HOT_UPDATER_BUNDLE_ID: NIL_UUID,
+  CHANNEL: "production",
 };
 
 const LINKING_ERROR =
@@ -79,6 +80,17 @@ export const reload = () => {
   });
 };
 
+/**
+ * Fetches the minimum bundle id, which represents the initial bundle of the app
+ * since it is created at build time.
+ *
+ * @returns {string} Resolves with the minimum bundle id or null if not available.
+ */
+export const getMinBundleId = (): string => {
+  const constants = HotUpdaterNative.getConstants();
+  return constants.MIN_BUNDLE_ID;
+};
+
 /**
  * Fetches the current bundle version id.
  *
@@ -86,5 +98,13 @@ export const reload = () => {
  * @returns {Promise<string>} Resolves with the current version id or null if not available.
  */
 export const getBundleId = (): string => {
-  return HotUpdater.HOT_UPDATER_BUNDLE_ID;
+  const minBundleId = getMinBundleId();
+
+  return minBundleId.localeCompare(HotUpdater.HOT_UPDATER_BUNDLE_ID) >= 0
+    ? minBundleId
+    : HotUpdater.HOT_UPDATER_BUNDLE_ID;
+};
+
+export const getChannel = (): string => {
+  return HotUpdater.CHANNEL;
 };

package/src/runUpdateProcess.ts

@@ -1,15 +1,12 @@
 import { type CheckForUpdateConfig, checkForUpdate } from "./checkForUpdate";
-import { reload, updateBundle } from "./native";
+import { getBundleId, reload, updateBundle } from "./native";
 
-export type RunUpdateProcessResponse =
-  | {
-      status: "ROLLBACK" | "UPDATE";
-      shouldForceUpdate: boolean;
-      id: string;
-    }
-  | {
-      status: "UP_TO_DATE";
-    };
+export interface RunUpdateProcessResponse {
+  status: "ROLLBACK" | "UPDATE" | "UP_TO_DATE";
+  shouldForceUpdate: boolean;
+  message: string | null;
+  id: string;
+}
 
 export interface RunUpdateProcessConfig extends CheckForUpdateConfig {
   /**
@@ -60,6 +57,9 @@ export const runUpdateProcess = async ({
   if (!updateInfo) {
     return {
       status: "UP_TO_DATE",
+      shouldForceUpdate: false,
+      message: null,
+      id: getBundleId(),
     };
   }
 
@@ -75,5 +75,6 @@ export const runUpdateProcess = async ({
     status: updateInfo.status,
     shouldForceUpdate: updateInfo.shouldForceUpdate,
     id: updateInfo.id,
+    message: updateInfo.message,
   };
 };

package/src/specs/NativeHotUpdater.ts

@@ -10,6 +10,9 @@ interface Spec extends TurboModule {
   // EventEmitter
   addListener(eventName: string): void;
   removeListeners(count: number): void;
+  readonly getConstants: () => {
+    MIN_BUNDLE_ID: string;
+  };
 }
 
 export default TurboModuleRegistry.get<Spec>("HotUpdater");

package/src/store.ts

@@ -24,10 +24,10 @@ const createHotUpdaterStore = () => {
     }
   };
 
-  const setProgress = (progress: number) => {
+  const setState = (newState: Partial<HotUpdaterState>) => {
     state = {
-      isBundleUpdated: progress === 1,
-      progress,
+      ...state,
+      ...newState,
     };
     emitChange();
   };
@@ -37,7 +37,7 @@ const createHotUpdaterStore = () => {
     return () => listeners.delete(listener);
   };
 
-  return { getSnapshot, setProgress, subscribe };
+  return { getSnapshot, setState, subscribe };
 };
 
 export const hotUpdaterStore = createHotUpdaterStore();

package/src/wrap.tsx

@@ -1,9 +1,9 @@
-import type React from "react";
+import React from "react";
 import { useEffect, useLayoutEffect, useState } from "react";
 import { type CheckForUpdateConfig, checkForUpdate } from "./checkForUpdate";
 import { HotUpdaterError } from "./error";
 import { useEventCallback } from "./hooks/useEventCallback";
-import { reload, updateBundle } from "./native";
+import { getBundleId, reload, updateBundle } from "./native";
 import type { RunUpdateProcessResponse } from "./runUpdateProcess";
 import { useHotUpdaterStore } from "./store";
 
@@ -37,6 +37,7 @@ export interface HotUpdaterConfig extends CheckForUpdateConfig {
   fallbackComponent?: React.FC<{
     status: Exclude<UpdateStatus, "UPDATE_PROCESS_COMPLETED">;
     progress: number;
+    message: string | null;
   }>;
   onError?: (error: HotUpdaterError) => void;
   onProgress?: (progress: number) => void;
@@ -62,9 +63,10 @@ export function wrap<P>(
   return (WrappedComponent) => {
     const HotUpdaterHOC: React.FC<P> = () => {
       const progress = useHotUpdaterStore((state) => state.progress);
+
+      const [message, setMessage] = useState<string | null>(null);
       const [updateStatus, setUpdateStatus] =
         useState<UpdateStatus>("CHECK_FOR_UPDATE");
-
       const initHotUpdater = useEventCallback(async () => {
         try {
           setUpdateStatus("CHECK_FOR_UPDATE");
@@ -72,9 +74,14 @@ export function wrap<P>(
             source: restConfig.source,
             requestHeaders: restConfig.requestHeaders,
           });
+          setMessage(updateInfo?.message ?? null);
+
           if (!updateInfo) {
             restConfig.onUpdateProcessCompleted?.({
               status: "UP_TO_DATE",
+              shouldForceUpdate: false,
+              message: null,
+              id: getBundleId(),
             });
             setUpdateStatus("UPDATE_PROCESS_COMPLETED");
             return;
@@ -86,6 +93,7 @@ export function wrap<P>(
               id: updateInfo.id,
               status: updateInfo.status,
               shouldForceUpdate: updateInfo.shouldForceUpdate,
+              message: updateInfo.message,
             });
             setUpdateStatus("UPDATE_PROCESS_COMPLETED");
             return;
@@ -111,6 +119,7 @@ export function wrap<P>(
             id: updateInfo.id,
             status: updateInfo.status,
             shouldForceUpdate: updateInfo.shouldForceUpdate,
+            message: updateInfo.message,
           });
           setUpdateStatus("UPDATE_PROCESS_COMPLETED");
         } catch (error) {
@@ -135,7 +144,13 @@ export function wrap<P>(
         updateStatus !== "UPDATE_PROCESS_COMPLETED"
       ) {
         const Fallback = restConfig.fallbackComponent;
-        return <Fallback progress={progress} status={updateStatus} />;
+        return (
+          <Fallback
+            progress={progress}
+            status={updateStatus}
+            message={message}
+          />
+        );
       }
 
       return <WrappedComponent />;

package/dist/ensureUpdateInfo.d.ts

@@ -1,2 +0,0 @@
-import type { Bundle, BundleArg, GetBundlesArgs, UpdateInfo } from "@hot-updater/core";
-export declare const ensureUpdateInfo: (source: BundleArg, { appVersion, bundleId, platform }: GetBundlesArgs, requestHeaders?: Record<string, string>) => Promise<Bundle[] | UpdateInfo>;

package/src/ensureUpdateInfo.ts

@@ -1,36 +0,0 @@
-import type {
-  Bundle,
-  BundleArg,
-  GetBundlesArgs,
-  UpdateInfo,
-} from "@hot-updater/core";
-
-export const ensureUpdateInfo = async (
-  source: BundleArg,
-  { appVersion, bundleId, platform }: GetBundlesArgs,
-  requestHeaders?: Record<string, string>,
-): Promise<Bundle[] | UpdateInfo> => {
-  try {
-    let bundles: Bundle[] | null = null;
-    if (typeof source === "string") {
-      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 if (typeof source === "function") {
-      bundles = await source();
-    } else {
-      bundles = source;
-    }
-
-    return bundles ?? [];
-  } catch {
-    return [];
-  }
-};