@hot-updater/react-native 0.30.6 → 0.30.8

package/plugin/build/withHotUpdater.js

@@ -5,18 +5,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const promises_1 = require("node:fs/promises");
 const path_1 = __importDefault(require("path"));
-const cli_tools_1 = require("@hot-updater/cli-tools");
 const config_plugins_1 = require("expo/config-plugins");
-const hot_updater_1 = require("hot-updater");
 const package_json_1 = __importDefault(require("../../package.json"));
 const transformers_1 = require("./transformers");
+const loadCliTools = () => import("@hot-updater/cli-tools");
+const loadHotUpdater = () => import("hot-updater");
 let fingerprintCache = null;
 const getFingerprint = async () => {
     if (fingerprintCache) {
         return fingerprintCache;
     }
-    fingerprintCache = await (0, hot_updater_1.generateFingerprints)();
-    await (0, hot_updater_1.createFingerprintJSON)(fingerprintCache);
+    const { createFingerprintJSON, generateFingerprints } = await loadHotUpdater();
+    fingerprintCache = await generateFingerprints();
+    await createFingerprintJSON(fingerprintCache);
     return fingerprintCache;
 };
 /**
@@ -36,7 +37,8 @@ const getPublicKeyFromConfig = async (signingConfig) => {
     const envPrivateKey = process.env.HOT_UPDATER_PRIVATE_KEY;
     if (envPrivateKey) {
         try {
-            const publicKeyPEM = (0, hot_updater_1.getPublicKeyFromPrivate)(envPrivateKey);
+            const { getPublicKeyFromPrivate } = await loadHotUpdater();
+            const publicKeyPEM = getPublicKeyFromPrivate(envPrivateKey);
             console.log("[hot-updater] Using public key extracted from HOT_UPDATER_PRIVATE_KEY environment variable");
             return publicKeyPEM.trim();
         }
@@ -59,8 +61,9 @@ const getPublicKeyFromConfig = async (signingConfig) => {
     const publicKeyPath = privateKeyPath.replace(/private-key\.pem$/, "public-key.pem");
     try {
         // Priority 2: Private key file (existing method)
-        const privateKeyPEM = await (0, hot_updater_1.loadPrivateKey)(privateKeyPath);
-        const publicKeyPEM = (0, hot_updater_1.getPublicKeyFromPrivate)(privateKeyPEM);
+        const { getPublicKeyFromPrivate, loadPrivateKey } = await loadHotUpdater();
+        const privateKeyPEM = await loadPrivateKey(privateKeyPath);
+        const publicKeyPEM = getPublicKeyFromPrivate(privateKeyPEM);
         console.log(`[hot-updater] Extracted public key from ${privateKeyPath}`);
         return publicKeyPEM.trim();
     }
@@ -118,7 +121,8 @@ const withHotUpdaterConfigAsync = (props) => (config) => {
     // === iOS: Add channel and fingerprint to Info.plist ===
     modifiedConfig = (0, config_plugins_1.withInfoPlist)(modifiedConfig, async (cfg) => {
         let fingerprintHash = null;
-        const config = await (0, cli_tools_1.loadConfig)(null);
+        const { loadConfig } = await loadCliTools();
+        const config = await loadConfig(null);
         if (config.updateStrategy !== "appVersion") {
             const fingerprint = await getFingerprint();
             fingerprintHash = fingerprint.ios.hash;
@@ -137,7 +141,8 @@ const withHotUpdaterConfigAsync = (props) => (config) => {
     // === Android: Add channel and fingerprint to strings.xml ===
     modifiedConfig = (0, config_plugins_1.withStringsXml)(modifiedConfig, async (cfg) => {
         let fingerprintHash = null;
-        const config = await (0, cli_tools_1.loadConfig)(null);
+        const { loadConfig } = await loadCliTools();
+        const config = await loadConfig(null);
         if (config.updateStrategy !== "appVersion") {
             const fingerprint = await getFingerprint();
             fingerprintHash = fingerprint.android.hash;

package/src/index.spec.ts

@@ -0,0 +1,177 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  addListener: vi.fn(() => () => {}),
+  checkForUpdate: vi.fn(),
+  clearCrashHistory: vi.fn(() => true),
+  createDefaultResolver: vi.fn(),
+  getAppVersion: vi.fn(() => "1.0.0"),
+  getBaseURL: vi.fn(() => null),
+  getBundleId: vi.fn(() => "bundle-id"),
+  getChannel: vi.fn(() => "production"),
+  getCohort: vi.fn(() => "123"),
+  getCrashHistory: vi.fn(() => []),
+  getDefaultChannel: vi.fn(() => "production"),
+  getFingerprintHash: vi.fn(() => null),
+  getManifest: vi.fn(() => null),
+  getMinBundleId: vi.fn(() => "min-bundle-id"),
+  init: vi.fn(),
+  isChannelSwitched: vi.fn(() => false),
+  reload: vi.fn(),
+  resetChannel: vi.fn(),
+  setCohort: vi.fn(),
+  setReloadBehavior: vi.fn(),
+  updateBundle: vi.fn(),
+  wrap: vi.fn(),
+}));
+
+vi.mock("./DefaultResolver", () => ({
+  createDefaultResolver: mocks.createDefaultResolver,
+}));
+
+vi.mock("./checkForUpdate", () => ({
+  checkForUpdate: mocks.checkForUpdate,
+}));
+
+vi.mock("./native", () => ({
+  addListener: mocks.addListener,
+  clearCrashHistory: mocks.clearCrashHistory,
+  getAppVersion: mocks.getAppVersion,
+  getBaseURL: mocks.getBaseURL,
+  getBundleId: mocks.getBundleId,
+  getChannel: mocks.getChannel,
+  getCohort: mocks.getCohort,
+  getCrashHistory: mocks.getCrashHistory,
+  getDefaultChannel: mocks.getDefaultChannel,
+  getFingerprintHash: mocks.getFingerprintHash,
+  getManifest: mocks.getManifest,
+  getMinBundleId: mocks.getMinBundleId,
+  isChannelSwitched: mocks.isChannelSwitched,
+  reload: mocks.reload,
+  resetChannel: mocks.resetChannel,
+  setCohort: mocks.setCohort,
+  setReloadBehavior: mocks.setReloadBehavior,
+  updateBundle: mocks.updateBundle,
+}));
+
+vi.mock("./wrap", () => ({
+  init: mocks.init,
+  wrap: mocks.wrap,
+}));
+
+const importHotUpdater = async () => {
+  const { HotUpdater } = await import("./index");
+  return HotUpdater;
+};
+
+describe("HotUpdater client initialization", () => {
+  beforeEach(() => {
+    vi.resetModules();
+
+    for (const mock of Object.values(mocks)) {
+      mock.mockReset();
+    }
+
+    mocks.addListener.mockReturnValue(() => {});
+    mocks.checkForUpdate.mockResolvedValue(null);
+    mocks.createDefaultResolver.mockImplementation((baseURL: string) => ({
+      baseURL,
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn(),
+    }));
+    mocks.getBaseURL.mockReturnValue(null);
+    mocks.init.mockReturnValue(undefined);
+    mocks.wrap.mockReturnValue((Component: unknown) => Component);
+  });
+
+  it("initializes manual update flows without wrapping a component", async () => {
+    const resolver = {
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn(),
+    };
+    mocks.createDefaultResolver.mockReturnValue(resolver);
+
+    const HotUpdater = await importHotUpdater();
+
+    const result = HotUpdater.init({
+      baseURL: "https://updates.example.com",
+      requestHeaders: {
+        Authorization: "Bearer token",
+      },
+      requestTimeout: 1000,
+      updateMode: "manual",
+    });
+
+    expect(result).toBeUndefined();
+    expect(mocks.createDefaultResolver).toHaveBeenCalledWith(
+      "https://updates.example.com",
+    );
+    expect(mocks.init).toHaveBeenCalledWith({
+      requestHeaders: {
+        Authorization: "Bearer token",
+      },
+      requestTimeout: 1000,
+      resolver,
+      updateMode: "manual",
+    });
+  });
+
+  it("uses init configuration for later manual update checks", async () => {
+    const resolver = {
+      checkUpdate: vi.fn(),
+      notifyAppReady: vi.fn(),
+    };
+    mocks.createDefaultResolver.mockReturnValue(resolver);
+
+    const HotUpdater = await importHotUpdater();
+
+    HotUpdater.init({
+      baseURL: "https://updates.example.com",
+      requestHeaders: {
+        Authorization: "Bearer token",
+      },
+      requestTimeout: 1000,
+      updateMode: "manual",
+    });
+
+    await HotUpdater.checkForUpdate({
+      requestHeaders: {
+        "X-Runtime": "secondary",
+      },
+      updateStrategy: "appVersion",
+    });
+
+    expect(mocks.checkForUpdate).toHaveBeenCalledWith({
+      requestHeaders: {
+        Authorization: "Bearer token",
+        "X-Runtime": "secondary",
+      },
+      requestTimeout: 1000,
+      resolver,
+      updateStrategy: "appVersion",
+    });
+  });
+
+  it("points users to wrap or init when methods are called too early", async () => {
+    const HotUpdater = await importHotUpdater();
+
+    expect(() =>
+      HotUpdater.checkForUpdate({
+        updateStrategy: "appVersion",
+      }),
+    ).toThrow("requires HotUpdater.wrap() or HotUpdater.init() to be used");
+  });
+
+  it("rejects automatic update mode for init at runtime", async () => {
+    const HotUpdater = await importHotUpdater();
+
+    expect(() =>
+      HotUpdater.init({
+        baseURL: "https://updates.example.com",
+        updateMode: "auto",
+        updateStrategy: "appVersion",
+      } as never),
+    ).toThrow('HotUpdater.init() only supports updateMode: "manual"');
+    expect(mocks.init).not.toHaveBeenCalled();
+  });
+});

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/store.spec.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const addListenerMock = vi.hoisted(() => vi.fn());
+
+vi.mock("./native", () => ({
+  addListener: addListenerMock,
+}));
+
+const importStore = async () => {
+  const { hotUpdaterStore } = await import("./store");
+  return hotUpdaterStore;
+};
+
+describe("hotUpdaterStore", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    addListenerMock.mockReset();
+  });
+
+  it("does not notify subscribers when state values are unchanged", async () => {
+    const store = await importStore();
+    const listener = vi.fn();
+
+    const unsubscribe = store.subscribe(listener);
+
+    store.setState({});
+    store.setState({ progress: 0 });
+    store.setState({ isUpdateDownloaded: false });
+
+    expect(listener).not.toHaveBeenCalled();
+
+    unsubscribe();
+  });
+
+  it("notifies subscribers only when progress events change the snapshot", async () => {
+    const store = await importStore();
+    const listener = vi.fn();
+    const progressListener = addListenerMock.mock.calls[0][1] as (state: {
+      progress: number;
+    }) => void;
+
+    const unsubscribe = store.subscribe(listener);
+
+    progressListener({ progress: 0.5 });
+    progressListener({ progress: 0.5 });
+    progressListener({ progress: 1 });
+    store.setState({ isUpdateDownloaded: true });
+
+    expect(listener).toHaveBeenCalledTimes(2);
+    expect(store.getSnapshot()).toEqual({
+      isUpdateDownloaded: true,
+      progress: 1,
+    });
+
+    unsubscribe();
+  });
+});

package/src/store.ts

@@ -46,6 +46,13 @@ const createHotUpdaterStore = () => {
       nextState.isUpdateDownloaded = newState.isUpdateDownloaded;
     }
 
+    if (
+      state.progress === nextState.progress &&
+      state.isUpdateDownloaded === nextState.isUpdateDownloaded
+    ) {
+      return;
+    }
+
     state = nextState;
     emitChange();
   };

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> {