@hot-updater/react-native 0.30.11 → 0.31.0

package/src/checkForUpdate.ts

@@ -1,4 +1,4 @@
-import type { AppUpdateInfo } from "@hot-updater/core";
+import type { AppUpdateAvailableInfo, AppUpdateInfo } from "@hot-updater/core";
 import { Platform } from "react-native";
 
 import { HotUpdaterError } from "./error";
@@ -42,7 +42,7 @@ export interface CheckForUpdateOptions {
   requestTimeout?: number;
 }
 
-export type CheckForUpdateResult = AppUpdateInfo & {
+export type CheckForUpdateResult = AppUpdateAvailableInfo & {
   /**
    * Updates the bundle.
    * This method is equivalent to `HotUpdater.updateBundle()` but with all required arguments pre-filled.
@@ -142,6 +142,10 @@ export async function checkForUpdate(
     return null;
   }
 
+  if (updateInfo.status === "UP_TO_DATE") {
+    return null;
+  }
+
   if (
     explicitChannel &&
     explicitChannel !== defaultChannel &&
@@ -168,8 +172,11 @@ export async function checkForUpdate(
       return updateBundle({
         bundleId: updateInfo.id,
         channel: runtimeChannel,
+        changedAssets: updateInfo.changedAssets ?? null,
         fileUrl: updateInfo.fileUrl,
         fileHash: updateInfo.fileHash,
+        manifestFileHash: updateInfo.manifestFileHash ?? null,
+        manifestUrl: updateInfo.manifestUrl ?? null,
         status: updateInfo.status,
         shouldSkipCurrentBundleIdCheck: isFirstRuntimeChannelSwitchAttempt,
       });

package/src/index.spec.ts

@@ -1,5 +1,8 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
+import type { HotUpdater as HotUpdaterValue } from "./index";
+import type { HotUpdaterInitOptions, HotUpdaterOptions } from "./wrap";
+
 const mocks = vi.hoisted(() => ({
   addListener: vi.fn(() => () => {}),
   checkForUpdate: vi.fn(),
@@ -74,7 +77,7 @@ describe("HotUpdater client initialization", () => {
 
     mocks.addListener.mockReturnValue(() => {});
     mocks.checkForUpdate.mockResolvedValue(null);
-    mocks.createDefaultResolver.mockImplementation((baseURL: string) => ({
+    mocks.createDefaultResolver.mockImplementation((baseURL: unknown) => ({
       baseURL,
       checkUpdate: vi.fn(),
       notifyAppReady: vi.fn(),
@@ -114,6 +117,171 @@ describe("HotUpdater client initialization", () => {
     });
   });
 
+  it("accepts dynamic baseURL resolvers for manual update flows", async () => {
+    const resolver = {
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn(),
+    };
+    const resolveBaseURL = vi.fn(() => "https://updates.example.com");
+    mocks.createDefaultResolver.mockReturnValue(resolver);
+
+    const HotUpdater = await importHotUpdater();
+
+    HotUpdater.init({
+      baseURL: resolveBaseURL,
+    });
+
+    expect(mocks.createDefaultResolver).toHaveBeenCalledWith(resolveBaseURL);
+    expect(mocks.init).toHaveBeenCalledWith({
+      resolver,
+    });
+  });
+
+  it("accepts custom resolvers for manual update flows", async () => {
+    const resolver = {
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn(),
+    };
+
+    const HotUpdater = await importHotUpdater();
+
+    HotUpdater.init({
+      resolver,
+      requestHeaders: {
+        Authorization: "Bearer token",
+      },
+    });
+
+    expect(mocks.createDefaultResolver).not.toHaveBeenCalled();
+    expect(mocks.init).toHaveBeenCalledWith({
+      resolver,
+      requestHeaders: {
+        Authorization: "Bearer token",
+      },
+    });
+  });
+
+  it("accepts onError during init and uses it for later manual update checks", async () => {
+    const resolver = {
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn(),
+    };
+    const onError = vi.fn();
+    mocks.createDefaultResolver.mockReturnValue(resolver);
+
+    const HotUpdater = await importHotUpdater();
+
+    HotUpdater.init({
+      baseURL: "https://updates.example.com",
+      onError,
+    });
+
+    await HotUpdater.checkForUpdate({
+      updateStrategy: "appVersion",
+    });
+
+    expect(mocks.init).toHaveBeenCalledWith({
+      onError,
+      resolver,
+    });
+    expect(mocks.checkForUpdate).toHaveBeenCalledWith({
+      onError,
+      requestHeaders: {},
+      requestTimeout: undefined,
+      resolver,
+      updateStrategy: "appVersion",
+    });
+  });
+
+  it("lets checkForUpdate override the init onError handler", async () => {
+    const resolver = {
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn(),
+    };
+    const initOnError = vi.fn();
+    const checkOnError = vi.fn();
+    mocks.createDefaultResolver.mockReturnValue(resolver);
+
+    const HotUpdater = await importHotUpdater();
+
+    HotUpdater.init({
+      baseURL: "https://updates.example.com",
+      onError: initOnError,
+    });
+
+    await HotUpdater.checkForUpdate({
+      onError: checkOnError,
+      updateStrategy: "appVersion",
+    });
+
+    expect(mocks.checkForUpdate).toHaveBeenCalledWith({
+      onError: checkOnError,
+      requestHeaders: {},
+      requestTimeout: undefined,
+      resolver,
+      updateStrategy: "appVersion",
+    });
+  });
+
+  it("defaults wrap to automatic update mode", async () => {
+    const resolver = {
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn(),
+    };
+    mocks.createDefaultResolver.mockReturnValue(resolver);
+
+    const HotUpdater = await importHotUpdater();
+
+    HotUpdater.wrap({
+      baseURL: "https://updates.example.com",
+      updateStrategy: "appVersion",
+    });
+
+    expect(mocks.wrap).toHaveBeenCalledWith({
+      resolver,
+      updateMode: "auto",
+      updateStrategy: "appVersion",
+    });
+  });
+
+  it("keeps deprecated manual wrap calls working", async () => {
+    const resolver = {
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn(),
+    };
+    mocks.createDefaultResolver.mockReturnValue(resolver);
+
+    const HotUpdater = await importHotUpdater();
+
+    HotUpdater.wrap({
+      baseURL: "https://updates.example.com",
+      updateMode: "manual",
+    });
+
+    expect(mocks.wrap).toHaveBeenCalledWith({
+      resolver,
+      updateMode: "manual",
+    });
+  });
+
+  it("types public wrap to accept pre-typed option unions", () => {
+    const compileOnly = (
+      wrap: typeof HotUpdaterValue.wrap,
+      options: HotUpdaterOptions,
+    ) => wrap(options);
+
+    expect(compileOnly).toBeTypeOf("function");
+  });
+
+  it("types public init options with onError", () => {
+    const options = {
+      baseURL: "https://updates.example.com",
+      onError: vi.fn(),
+    } satisfies HotUpdaterInitOptions;
+
+    expect(options.baseURL).toBe("https://updates.example.com");
+  });
+
   it("uses init configuration for later manual update checks", async () => {
     const resolver = {
       checkUpdate: vi.fn(),
@@ -163,7 +331,7 @@ describe("HotUpdater client initialization", () => {
     const HotUpdater = await importHotUpdater();
 
     expect(() => HotUpdater.init({} as never)).toThrow(
-      "baseURL must be provided",
+      "Either baseURL or resolver must be provided",
     );
     expect(mocks.init).not.toHaveBeenCalled();
   });

package/src/index.ts

@@ -28,17 +28,21 @@ import {
 import { hotUpdaterStore } from "./store";
 import type { HotUpdaterResolver } from "./types";
 import {
+  type AutoUpdateOptions,
   type HotUpdaterInitOptions,
   type HotUpdaterOptions,
   init,
   type InternalInitOptions,
   type InternalWrapOptions,
+  type ManualUpdateOptions,
   wrap,
 } from "./wrap";
 
 export type {
   CustomReloadHandler,
   HotUpdaterEvent,
+  HotUpdaterProgressArtifactType,
+  HotUpdaterProgressEvent,
   Manifest,
   ManifestAsset,
   NotifyAppReadyResult,
@@ -48,6 +52,7 @@ export type {
 export * from "./store";
 export {
   extractSignatureFailure,
+  type HotUpdaterBaseURL,
   type HotUpdaterResolver,
   isSignatureVerificationError,
   type ResolverCheckUpdateParams,
@@ -55,8 +60,10 @@ export {
   type SignatureVerificationFailure,
 } from "./types";
 export type {
+  HotUpdaterFallbackComponentProps,
   HotUpdaterInitOptions,
   HotUpdaterOptions,
+  ManualUpdateOptions,
   RunUpdateProcessResponse,
 } from "./wrap";
 
@@ -78,6 +85,33 @@ const registerGlobalGetBaseURL = () => {
 // Call registration immediately on module load
 registerGlobalGetBaseURL();
 
+type HotUpdaterWrap = {
+  (options: AutoUpdateOptions): ReturnType<typeof wrap>;
+  /**
+   * @deprecated Replace manual `HotUpdater.wrap` with `HotUpdater.init`.
+   *
+   * ```tsx
+   * import { HotUpdater } from "@hot-updater/react-native";
+   *
+   * HotUpdater.init({
+   *   baseURL: "<your-update-server-url>",
+   * });
+   *
+   * export default App;
+   * ```
+   *
+   * Then call `HotUpdater.checkForUpdate(...)` from your manual update flow.
+   * See https://hot-updater.dev/docs/guides/custom-update
+   */
+  (options: ManualUpdateOptions): ReturnType<typeof wrap>;
+  (options: HotUpdaterOptions): ReturnType<typeof wrap>;
+};
+
+const isManualWrapOptions = (
+  options: HotUpdaterOptions,
+): options is ManualUpdateOptions =>
+  "updateMode" in options && options.updateMode === "manual";
+
 /**
  * Creates a HotUpdater client instance with all update management methods.
  * This function is called once on module initialization to create a singleton instance.
@@ -88,6 +122,7 @@ function createHotUpdaterClient() {
     resolver: HotUpdaterResolver | null;
     requestHeaders?: Record<string, string>;
     requestTimeout?: number;
+    onError?: (error: unknown) => void;
   } = {
     resolver: null,
   };
@@ -95,54 +130,67 @@ function createHotUpdaterClient() {
   const createMissingNetworkConfigError = (apiName: "init" | "wrap") => {
     if (apiName === "init") {
       return new Error(
-        `[HotUpdater] baseURL must be provided.\n\n` +
-          `Configure HotUpdater before calling update APIs:\n\n` +
+        `[HotUpdater] Either baseURL or resolver must be provided.\n\n` +
+          `Configure HotUpdater before calling update APIs with the standard baseURL setup:\n\n` +
           `  HotUpdater.init({\n` +
           `    baseURL: "<your-update-server-url>",\n` +
           `  });\n\n` +
-          `For more information, visit: https://hot-updater.dev/docs/react-native-api/init`,
+          `For manual update flows, visit: https://hot-updater.dev/docs/guides/custom-update`,
       );
     }
 
     const baseURLExample =
       `  export default HotUpdater.wrap({\n` +
       `    baseURL: "<your-update-server-url>",\n` +
-      `    updateStrategy: "appVersion",\n` +
-      `    updateMode: "auto"\n` +
-      `  })(App);\n\n`;
-
-    const resolverExample =
-      `  export default HotUpdater.wrap({\n` +
-      `    resolver: {\n` +
-      `      checkUpdate: async (params) => { /* custom logic */ },\n` +
-      `      notifyAppReady: async (params) => { /* custom logic */ }\n` +
-      `    },\n` +
-      `    updateMode: "manual"\n` +
+      `    updateStrategy: "appVersion"\n` +
       `  })(App);\n\n`;
 
     return new Error(
       `[HotUpdater] Either baseURL or resolver must be provided.\n\n` +
-        `Option 1: Using baseURL (recommended for most cases)\n` +
+        `Configure HotUpdater.wrap with the standard baseURL setup:\n\n` +
         baseURLExample +
-        `Option 2: Using custom resolver (advanced)\n` +
-        resolverExample +
-        `For more information, visit: https://hot-updater.dev/docs/react-native-api/${apiName}`,
+        `For manual update flows, use HotUpdater.init() and visit: ` +
+        `https://hot-updater.dev/docs/guides/custom-update`,
     );
   };
 
   const normalizeOptions = (
     options: HotUpdaterOptions,
   ): InternalWrapOptions => {
-    if ("baseURL" in options && options.baseURL) {
-      const { baseURL, ...rest } = options;
+    if (isManualWrapOptions(options)) {
+      if ("baseURL" in options && options.baseURL) {
+        const { baseURL, ...rest } = options;
+        return {
+          ...rest,
+          resolver: createDefaultResolver(baseURL),
+          updateMode: "manual",
+        };
+      }
+
+      if ("resolver" in options && options.resolver) {
+        return {
+          ...options,
+          updateMode: "manual",
+        };
+      }
+    }
+
+    const autoOptions = options as AutoUpdateOptions;
+
+    if ("baseURL" in autoOptions && autoOptions.baseURL) {
+      const { baseURL, ...rest } = autoOptions;
       return {
         ...rest,
         resolver: createDefaultResolver(baseURL),
+        updateMode: "auto",
       };
     }
 
-    if ("resolver" in options && options.resolver) {
-      return options;
+    if ("resolver" in autoOptions && autoOptions.resolver) {
+      return {
+        ...autoOptions,
+        updateMode: "auto",
+      };
     }
 
     throw createMissingNetworkConfigError("wrap");
@@ -151,21 +199,23 @@ function createHotUpdaterClient() {
   const normalizeInitOptions = (
     options: HotUpdaterInitOptions,
   ): InternalInitOptions => {
-    const {
-      baseURL,
-      updateMode: _updateMode,
-      ...rest
-    } = options as HotUpdaterInitOptions & {
-      updateMode?: unknown;
-    };
-
-    if (baseURL) {
+    const { updateMode: _updateMode, ...rest } =
+      options as HotUpdaterInitOptions & {
+        updateMode?: unknown;
+      };
+
+    if ("baseURL" in rest && rest.baseURL) {
+      const { baseURL, ...baseURLRest } = rest;
       return {
-        ...rest,
+        ...baseURLRest,
         resolver: createDefaultResolver(baseURL),
       };
     }
 
+    if ("resolver" in rest && rest.resolver) {
+      return rest;
+    }
+
     throw createMissingNetworkConfigError("init");
   };
 
@@ -176,6 +226,7 @@ function createHotUpdaterClient() {
     globalConfig.resolver = normalizedOptions.resolver;
     globalConfig.requestHeaders = options.requestHeaders;
     globalConfig.requestTimeout = options.requestTimeout;
+    globalConfig.onError = options.onError;
   };
 
   const ensureGlobalResolver = (methodName: string) => {
@@ -186,15 +237,13 @@ function createHotUpdaterClient() {
           `Option 1: With HotUpdater.wrap()\n` +
           `  export default HotUpdater.wrap({\n` +
           `    baseURL: "<your-update-server-url>",\n` +
-          `    updateStrategy: "appVersion",\n` +
-          `    updateMode: "auto"\n` +
+          `    updateStrategy: "appVersion"\n` +
           `  })(App);\n\n` +
           `Option 2: With HotUpdater.init() for custom runtimes\n` +
           `  HotUpdater.init({\n` +
           `    baseURL: "<your-update-server-url>",\n` +
           `  });\n\n` +
-          `For more information, visit: https://hot-updater.dev/docs/react-native-api/wrap ` +
-          `or https://hot-updater.dev/docs/react-native-api/init`,
+          `For manual update flows, visit: https://hot-updater.dev/docs/guides/custom-update`,
       );
     }
     return globalConfig.resolver;
@@ -218,7 +267,6 @@ function createHotUpdaterClient() {
      * export default HotUpdater.wrap({
      *   baseURL: "<your-update-server-url>",
      *   updateStrategy: "appVersion",
-     *   updateMode: "auto",
      *   requestHeaders: {
      *     "Authorization": "Bearer <your-access-token>",
      *   },
@@ -236,8 +284,8 @@ function createHotUpdaterClient() {
      * Initializes HotUpdater without wrapping a React component.
      *
      * Use this for manual update flows in runtimes where a root component HOC
-     * is not convenient. It has the same initialization effect as
-     * `HotUpdater.wrap({ updateMode: "manual" })(App)`.
+     * is not convenient. Replace deprecated manual
+     * `HotUpdater.wrap({ updateMode: "manual" })(App)` usage with this API.
      *
      * @example
      * ```tsx
@@ -419,6 +467,7 @@ function createHotUpdaterClient() {
           ...config.requestHeaders,
         },
         requestTimeout: config.requestTimeout ?? globalConfig.requestTimeout,
+        onError: config.onError ?? globalConfig.onError,
       };
 
       return checkForUpdate(mergedConfig);
@@ -471,8 +520,12 @@ function createHotUpdaterClient() {
       const ok = await resetChannel();
       if (ok) {
         hotUpdaterStore.setState({
+          artifactType: null,
+          details: null,
+          downloadedBytes: undefined,
           isUpdateDownloaded: false,
           progress: 0,
+          totalBytes: undefined,
         });
       }
       return ok;
@@ -521,4 +574,11 @@ function createHotUpdaterClient() {
   };
 }
 
-export const HotUpdater = createHotUpdaterClient();
+type HotUpdaterClient = Omit<
+  ReturnType<typeof createHotUpdaterClient>,
+  "wrap"
+> & {
+  wrap: HotUpdaterWrap;
+};
+
+export const HotUpdater: HotUpdaterClient = createHotUpdaterClient();

package/src/native.spec.ts

@@ -167,6 +167,7 @@ describe("notifyAppReady", () => {
       assets: {
         "assets/logo.png": {
           fileHash: "hash-logo",
+          signature: "sig-logo",
         },
         "index.android.bundle": {
           fileHash: "hash-bundle",
@@ -181,6 +182,7 @@ describe("notifyAppReady", () => {
       assets: {
         "assets/logo.png": {
           fileHash: "hash-logo",
+          signature: "sig-logo",
         },
         "index.android.bundle": {
           fileHash: "hash-bundle",
@@ -337,11 +339,147 @@ describe("notifyAppReady", () => {
       bundleId: "bundle-123",
     });
     expect(getBaseURL()).toBe("file:///bundle-123");
-    expect(nativeModuleMock.getBundleId).toHaveBeenCalledTimes(2);
+    expect(nativeModuleMock.getBundleId).toHaveBeenCalledTimes(3);
     expect(nativeModuleMock.getManifest).toHaveBeenCalledTimes(2);
     expect(nativeModuleMock.getBaseURL).toHaveBeenCalledTimes(2);
   });
 
+  it("reinstalls a session-installed bundle after native resets to built-in", async () => {
+    nativeModuleMock.getConstants.mockReturnValue({
+      APP_VERSION: null,
+      CHANNEL: "production",
+      DEFAULT_CHANNEL: "production",
+      FINGERPRINT_HASH: null,
+      MIN_BUNDLE_ID: "00000000-0000-0000-0000-000000000001",
+    });
+    nativeModuleMock.getBundleId.mockReturnValue(
+      "00000000-0000-0000-0000-000000000002",
+    );
+    nativeModuleMock.updateBundle.mockResolvedValue(true);
+
+    const { getBundleId, updateBundle } = await import("./native");
+
+    await updateBundle({
+      bundleId: "00000000-0000-0000-0000-000000000003",
+      fileHash: null,
+      fileUrl: "https://example.com/bundle.zip",
+      status: "UPDATE",
+    });
+
+    nativeModuleMock.getBundleId.mockReturnValue(
+      "00000000-0000-0000-0000-000000000003",
+    );
+    expect(getBundleId()).toBe("00000000-0000-0000-0000-000000000003");
+
+    nativeModuleMock.getBundleId.mockReturnValue(null);
+
+    await expect(
+      updateBundle({
+        bundleId: "00000000-0000-0000-0000-000000000003",
+        fileHash: null,
+        fileUrl: "https://example.com/bundle.zip",
+        status: "UPDATE",
+      }),
+    ).resolves.toBe(true);
+
+    expect(nativeModuleMock.updateBundle).toHaveBeenCalledTimes(2);
+  });
+
+  it("skips a session-installed bundle when native still reports it active", async () => {
+    nativeModuleMock.getConstants.mockReturnValue({
+      APP_VERSION: null,
+      CHANNEL: "production",
+      DEFAULT_CHANNEL: "production",
+      FINGERPRINT_HASH: null,
+      MIN_BUNDLE_ID: "00000000-0000-0000-0000-000000000001",
+    });
+    nativeModuleMock.getBundleId.mockReturnValue(
+      "00000000-0000-0000-0000-000000000002",
+    );
+    nativeModuleMock.updateBundle.mockResolvedValue(true);
+
+    const { updateBundle } = await import("./native");
+
+    await updateBundle({
+      bundleId: "00000000-0000-0000-0000-000000000003",
+      fileHash: null,
+      fileUrl: "https://example.com/bundle.zip",
+      status: "UPDATE",
+    });
+
+    nativeModuleMock.getBundleId.mockReturnValue(
+      "00000000-0000-0000-0000-000000000003",
+    );
+
+    await expect(
+      updateBundle({
+        bundleId: "00000000-0000-0000-0000-000000000003",
+        fileHash: null,
+        fileUrl: "https://example.com/bundle.zip",
+        status: "UPDATE",
+      }),
+    ).resolves.toBe(true);
+
+    expect(nativeModuleMock.updateBundle).toHaveBeenCalledTimes(1);
+  });
+
+  it("forwards manifest artifact parameters to native updateBundle", async () => {
+    nativeModuleMock.getBundleId.mockReturnValue("bundle-123");
+    nativeModuleMock.updateBundle.mockResolvedValue(true);
+
+    const { updateBundle } = await import("./native");
+
+    await updateBundle({
+      bundleId: "bundle-789",
+      changedAssets: {
+        "index.ios.bundle": {
+          file: {
+            compression: "br",
+            url: "https://example.com/files/index.ios.bundle.br",
+          },
+          fileHash: "hash-next",
+          patch: {
+            algorithm: "bsdiff",
+            baseBundleId: "bundle-123",
+            baseFileHash: "hash-prev",
+            patchFileHash: "hash-patch",
+            patchUrl: "https://example.com/files/index.ios.bundle.bsdiff",
+          },
+        },
+      },
+      fileHash: "sig:archive",
+      fileUrl: "https://example.com/bundle.zip",
+      manifestFileHash: "sig:manifest",
+      manifestUrl: "https://example.com/manifest.json",
+      status: "UPDATE",
+    });
+
+    expect(nativeModuleMock.updateBundle).toHaveBeenCalledWith({
+      bundleId: "bundle-789",
+      changedAssets: {
+        "index.ios.bundle": {
+          file: {
+            compression: "br",
+            url: "https://example.com/files/index.ios.bundle.br",
+          },
+          fileHash: "hash-next",
+          patch: {
+            algorithm: "bsdiff",
+            baseBundleId: "bundle-123",
+            baseFileHash: "hash-prev",
+            patchFileHash: "hash-patch",
+            patchUrl: "https://example.com/files/index.ios.bundle.bsdiff",
+          },
+        },
+      },
+      channel: undefined,
+      fileHash: "sig:archive",
+      fileUrl: "https://example.com/bundle.zip",
+      manifestFileHash: "sig:manifest",
+      manifestUrl: "https://example.com/manifest.json",
+    });
+  });
+
   it("invalidates cached bundle getters after resetChannel succeeds", async () => {
     nativeModuleMock.getConstants.mockReturnValue({
       APP_VERSION: null,