@hot-updater/react-native 0.30.7 → 0.30.8

package/src/index.ts

@@ -27,7 +27,13 @@ import {
 } from "./native";
 import { hotUpdaterStore } from "./store";
 import type { HotUpdaterResolver } from "./types";
-import { type HotUpdaterOptions, type InternalWrapOptions, wrap } from "./wrap";
+import {
+  type HotUpdaterOptions,
+  init,
+  type InternalWrapOptions,
+  type ManualUpdateOptions,
+  wrap,
+} from "./wrap";
 
 export type {
   CustomReloadHandler,
@@ -48,6 +54,7 @@ export {
   type SignatureVerificationFailure,
 } from "./types";
 export type { HotUpdaterOptions, RunUpdateProcessResponse } from "./wrap";
+export type { ManualUpdateOptions as HotUpdaterInitOptions } from "./wrap";
 
 /**
  * Register getBaseURL to global objects for use without imports.
@@ -81,23 +88,88 @@ function createHotUpdaterClient() {
     resolver: null,
   };
 
+  const normalizeOptions = (
+    options: HotUpdaterOptions,
+    apiName: "init" | "wrap",
+  ): InternalWrapOptions => {
+    if ("baseURL" in options && options.baseURL) {
+      const { baseURL, ...rest } = options;
+      return {
+        ...rest,
+        resolver: createDefaultResolver(baseURL),
+      };
+    }
+
+    if ("resolver" in options && options.resolver) {
+      return options;
+    }
+
+    const baseURLExample =
+      apiName === "wrap"
+        ? `  export default HotUpdater.wrap({\n` +
+          `    baseURL: "<your-update-server-url>",\n` +
+          `    updateStrategy: "appVersion",\n` +
+          `    updateMode: "auto"\n` +
+          `  })(App);\n\n`
+        : `  HotUpdater.init({\n` +
+          `    baseURL: "<your-update-server-url>",\n` +
+          `    updateMode: "manual"\n` +
+          `  });\n\n`;
+
+    const resolverExample =
+      apiName === "wrap"
+        ? `  export default HotUpdater.wrap({\n` +
+          `    resolver: {\n` +
+          `      checkUpdate: async (params) => { /* custom logic */ },\n` +
+          `      notifyAppReady: async (params) => { /* custom logic */ }\n` +
+          `    },\n` +
+          `    updateMode: "manual"\n` +
+          `  })(App);\n\n`
+        : `  HotUpdater.init({\n` +
+          `    resolver: {\n` +
+          `      checkUpdate: async (params) => { /* custom logic */ },\n` +
+          `      notifyAppReady: async (params) => { /* custom logic */ }\n` +
+          `    },\n` +
+          `    updateMode: "manual"\n` +
+          `  });\n\n`;
+
+    throw new Error(
+      `[HotUpdater] Either baseURL or resolver must be provided.\n\n` +
+        `Option 1: Using baseURL (recommended for most cases)\n` +
+        baseURLExample +
+        `Option 2: Using custom resolver (advanced)\n` +
+        resolverExample +
+        `For more information, visit: https://hot-updater.dev/docs/react-native-api/${apiName}`,
+    );
+  };
+
+  const configureGlobal = (
+    normalizedOptions: InternalWrapOptions,
+    options: HotUpdaterOptions,
+  ) => {
+    globalConfig.resolver = normalizedOptions.resolver;
+    globalConfig.requestHeaders = options.requestHeaders;
+    globalConfig.requestTimeout = options.requestTimeout;
+  };
+
   const ensureGlobalResolver = (methodName: string) => {
     if (!globalConfig.resolver) {
       throw new Error(
-        `[HotUpdater] ${methodName} requires HotUpdater.wrap() to be used.\n\n` +
-          `To fix this issue, wrap your root component with HotUpdater.wrap():\n\n` +
-          `Option 1: With automatic updates\n` +
+        `[HotUpdater] ${methodName} requires HotUpdater.wrap() or HotUpdater.init() to be used.\n\n` +
+          `To fix this issue, configure HotUpdater before calling ${methodName}:\n\n` +
+          `Option 1: With HotUpdater.wrap()\n` +
           `  export default HotUpdater.wrap({\n` +
           `    baseURL: "<your-update-server-url>",\n` +
           `    updateStrategy: "appVersion",\n` +
           `    updateMode: "auto"\n` +
           `  })(App);\n\n` +
-          `Option 2: Manual updates only (custom flow)\n` +
-          `  export default HotUpdater.wrap({\n` +
+          `Option 2: With HotUpdater.init() for custom runtimes\n` +
+          `  HotUpdater.init({\n` +
           `    baseURL: "<your-update-server-url>",\n` +
           `    updateMode: "manual"\n` +
-          `  })(App);\n\n` +
-          `For more information, visit: https://hot-updater.dev/docs/react-native-api/wrap`,
+          `  });\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`,
       );
     }
     return globalConfig.resolver;
@@ -129,42 +201,31 @@ function createHotUpdaterClient() {
      * ```
      */
     wrap: (options: HotUpdaterOptions) => {
-      let normalizedOptions: InternalWrapOptions;
-
-      if ("baseURL" in options && options.baseURL) {
-        const { baseURL, ...rest } = options;
-        normalizedOptions = {
-          ...rest,
-          resolver: createDefaultResolver(baseURL),
-        };
-      } else if ("resolver" in options && options.resolver) {
-        normalizedOptions = options;
-      } else {
+      const normalizedOptions = normalizeOptions(options, "wrap");
+      configureGlobal(normalizedOptions, options);
+
+      return wrap(normalizedOptions);
+    },
+
+    /**
+     * 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)`.
+     */
+    init: (options: ManualUpdateOptions): void => {
+      const normalizedOptions = normalizeOptions(options, "init");
+      if (normalizedOptions.updateMode !== "manual") {
         throw new Error(
-          `[HotUpdater] Either baseURL or resolver must be provided.\n\n` +
-            `Option 1: Using baseURL (recommended for most cases)\n` +
-            `  export default HotUpdater.wrap({\n` +
-            `    baseURL: "<your-update-server-url>",\n` +
-            `    updateStrategy: "appVersion",\n` +
-            `    updateMode: "auto"\n` +
-            `  })(App);\n\n` +
-            `Option 2: Using custom resolver (advanced)\n` +
-            `  export default HotUpdater.wrap({\n` +
-            `    resolver: {\n` +
-            `      checkUpdate: async (params) => { /* custom logic */ },\n` +
-            `      notifyAppReady: async (params) => { /* custom logic */ }\n` +
-            `    },\n` +
-            `    updateMode: "manual"\n` +
-            `  })(App);\n\n` +
-            `For more information, visit: https://hot-updater.dev/docs/react-native-api/wrap`,
+          `[HotUpdater] HotUpdater.init() only supports updateMode: "manual". ` +
+            `Use HotUpdater.wrap() for automatic updates.`,
         );
       }
 
-      globalConfig.resolver = normalizedOptions.resolver;
-      globalConfig.requestHeaders = options.requestHeaders;
-      globalConfig.requestTimeout = options.requestTimeout;
+      configureGlobal(normalizedOptions, options);
 
-      return wrap(normalizedOptions);
+      init(normalizedOptions);
     },
 
     /**

package/src/wrap.spec.ts

@@ -0,0 +1,82 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  addListener: vi.fn(() => () => {}),
+  checkForUpdate: vi.fn(),
+  getBundleId: vi.fn(() => "bundle-id"),
+  notifyAppReady: vi.fn(() => ({ status: "STABLE" })),
+  reload: vi.fn(),
+}));
+
+vi.mock("./checkForUpdate", () => ({
+  checkForUpdate: mocks.checkForUpdate,
+}));
+
+vi.mock("./native", () => ({
+  addListener: mocks.addListener,
+  getBundleId: mocks.getBundleId,
+  notifyAppReady: mocks.notifyAppReady,
+  reload: mocks.reload,
+}));
+
+describe("HotUpdater wrap initialization", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+
+    for (const mock of Object.values(mocks)) {
+      mock.mockReset();
+    }
+
+    mocks.checkForUpdate.mockResolvedValue(null);
+    mocks.addListener.mockReturnValue(() => {});
+    mocks.getBundleId.mockReturnValue("bundle-id");
+    mocks.notifyAppReady.mockReturnValue({ status: "STABLE" });
+  });
+
+  it("returns void from init and defers notifyAppReady to the next frame", async () => {
+    vi.useFakeTimers();
+
+    const requestAnimationFrame = vi.fn(
+      (callback: (timestamp: number) => void) => {
+        setTimeout(() => callback(0), 0);
+        return 1;
+      },
+    );
+    vi.stubGlobal("requestAnimationFrame", requestAnimationFrame);
+
+    const resolver = {
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn().mockResolvedValue(undefined),
+    };
+    const { init } = await import("./wrap");
+
+    const result = init({
+      resolver,
+      requestHeaders: {
+        Authorization: "Bearer token",
+      },
+      requestTimeout: 1000,
+      updateMode: "manual",
+    });
+
+    expect(result).toBeUndefined();
+    expect(mocks.notifyAppReady).not.toHaveBeenCalled();
+    expect(resolver.notifyAppReady).not.toHaveBeenCalled();
+
+    expect(requestAnimationFrame).toHaveBeenCalled();
+
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(mocks.notifyAppReady).toHaveBeenCalledWith();
+    expect(resolver.notifyAppReady).toHaveBeenCalledWith({
+      status: "STABLE",
+      crashedBundleId: undefined,
+      requestHeaders: {
+        Authorization: "Bearer token",
+      },
+      requestTimeout: 1000,
+    });
+  });
+});

package/src/wrap.tsx

@@ -204,10 +204,30 @@ type InternalManualUpdateOptions = InternalCommonOptions & {
   updateMode: "manual";
 };
 
+export type InternalInitOptions = InternalManualUpdateOptions;
+
 export type InternalWrapOptions =
   | InternalAutoUpdateOptions
   | InternalManualUpdateOptions;
 
+type RequestAnimationFrame = (callback: (timestamp: number) => void) => number;
+
+const waitForNextFrame = () =>
+  new Promise<void>((resolve) => {
+    const requestAnimationFrame = (
+      globalThis as typeof globalThis & {
+        requestAnimationFrame?: RequestAnimationFrame;
+      }
+    )?.requestAnimationFrame;
+
+    if (requestAnimationFrame) {
+      requestAnimationFrame(() => resolve());
+      return;
+    }
+
+    void Promise.resolve().then(resolve);
+  });
+
 /**
  * Helper function to handle notifyAppReady flow
  */
@@ -217,6 +237,8 @@ const handleNotifyAppReady = async (options: {
   requestTimeout?: number;
   onNotifyAppReady?: (result: NotifyAppReadyResult) => void;
 }): Promise<void> => {
+  await waitForNextFrame();
+
   try {
     const nativeResult = nativeNotifyAppReady();
 
@@ -240,6 +262,10 @@ const handleNotifyAppReady = async (options: {
   }
 };
 
+export function init(options: InternalInitOptions): void {
+  void handleNotifyAppReady(options);
+}
+
 export function wrap<P extends React.JSX.IntrinsicAttributes = object>(
   options: InternalWrapOptions,
 ): (WrappedComponent: React.ComponentType<P>) => React.ComponentType<P> {