@hot-updater/react-native 0.30.12 → 0.31.0

package/src/specs/NativeHotUpdater.ts

@@ -2,6 +2,21 @@ import type { TurboModule } from "react-native";
 import { TurboModuleRegistry } from "react-native";
 import type { UnsafeObject } from "react-native/Libraries/Types/CodegenTypes";
 
+export interface ChangedAsset {
+  file?: {
+    compression?: "br" | null;
+    url: string;
+  } | null;
+  fileHash: string;
+  patch?: {
+    algorithm: "bsdiff";
+    baseBundleId: string;
+    baseFileHash: string;
+    patchFileHash: string;
+    patchUrl: string;
+  } | null;
+}
+
 export interface UpdateBundleParams {
   bundleId: string;
   channel?: string;
@@ -16,6 +31,19 @@ export interface UpdateBundleParams {
    * Native determines verification mode by checking for "sig:" prefix.
    */
   fileHash: string | null;
+  /**
+   * Optional signed manifest URL for manifest-driven installation.
+   */
+  manifestUrl?: string | null;
+  /**
+   * File hash/signature for the manifest file itself.
+   */
+  manifestFileHash?: string | null;
+  /**
+   * Per-file URLs for assets that must be downloaded instead of reused from
+   * the currently active bundle.
+   */
+  changedAssets?: UnsafeObject | null;
 }
 
 export interface Spec extends TurboModule {

package/src/store.spec.ts

@@ -1,9 +1,18 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
-const addListenerMock = vi.hoisted(() => vi.fn());
+const listeners = vi.hoisted(
+  () => new Map<string, (event: Record<string, unknown>) => void>(),
+);
 
 vi.mock("./native", () => ({
-  addListener: addListenerMock,
+  addListener: vi.fn(
+    (eventName: string, listener: (event: Record<string, unknown>) => void) => {
+      listeners.set(eventName, listener);
+      return () => {
+        listeners.delete(eventName);
+      };
+    },
+  ),
 }));
 
 const importStore = async () => {
@@ -13,8 +22,8 @@ const importStore = async () => {
 
 describe("hotUpdaterStore", () => {
   beforeEach(() => {
+    listeners.clear();
     vi.resetModules();
-    addListenerMock.mockReset();
   });
 
   it("does not notify subscribers when state values are unchanged", async () => {
@@ -35,23 +44,329 @@ describe("hotUpdaterStore", () => {
   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 emitProgress = listeners.get("onProgress");
+
+    expect(emitProgress).toBeTypeOf("function");
 
     const unsubscribe = store.subscribe(listener);
 
-    progressListener({ progress: 0.5 });
-    progressListener({ progress: 0.5 });
-    progressListener({ progress: 1 });
+    emitProgress?.({
+      artifactType: "archive",
+      progress: 0.5,
+    });
+    emitProgress?.({
+      artifactType: "archive",
+      progress: 0.5,
+    });
+    emitProgress?.({
+      artifactType: "archive",
+      progress: 1,
+    });
     store.setState({ isUpdateDownloaded: true });
 
     expect(listener).toHaveBeenCalledTimes(2);
     expect(store.getSnapshot()).toEqual({
+      artifactType: "archive",
+      details: null,
+      downloadedBytes: undefined,
       isUpdateDownloaded: true,
       progress: 1,
+      totalBytes: undefined,
     });
 
     unsubscribe();
   });
+
+  it("stores archive byte metadata and notifies when only bytes change", async () => {
+    const store = await importStore();
+    const listener = vi.fn();
+    const emitProgress = listeners.get("onProgress");
+
+    const unsubscribe = store.subscribe(listener);
+
+    emitProgress?.({
+      artifactType: "archive",
+      downloadedBytes: 100.4,
+      progress: 0.5,
+      totalBytes: 1_000,
+    });
+    emitProgress?.({
+      artifactType: "archive",
+      downloadedBytes: 250,
+      progress: 0.5,
+      totalBytes: 1_000,
+    });
+
+    expect(listener).toHaveBeenCalledTimes(2);
+    expect(store.getSnapshot()).toEqual({
+      artifactType: "archive",
+      details: null,
+      downloadedBytes: 250,
+      isUpdateDownloaded: false,
+      progress: 0.5,
+      totalBytes: 1_000,
+    });
+
+    unsubscribe();
+  });
+
+  it("stores manifest progress metadata while keeping overall progress", async () => {
+    const store = await importStore();
+    const emitProgress = listeners.get("onProgress");
+
+    expect(emitProgress).toBeTypeOf("function");
+
+    emitProgress?.({
+      artifactType: "diff",
+      details: {
+        completedFilesCount: 1,
+        files: [
+          {
+            downloadPath: "index.ios.bundle",
+            order: 0,
+            path: "index.ios.bundle",
+            progress: 1,
+            status: "downloaded",
+          },
+          {
+            downloadPath: "assets/logo.png",
+            order: 1,
+            path: "assets/logo.png",
+            progress: 0.5,
+            status: "downloading",
+          },
+        ],
+        totalFilesCount: 2,
+      },
+      progress: 0.42,
+    });
+
+    expect(store.getSnapshot()).toEqual({
+      artifactType: "diff",
+      details: {
+        completedFilesCount: 1,
+        files: [
+          {
+            downloadPath: "index.ios.bundle",
+            order: 0,
+            path: "index.ios.bundle",
+            progress: 1,
+            status: "downloaded",
+          },
+          {
+            downloadPath: "assets/logo.png",
+            order: 1,
+            path: "assets/logo.png",
+            progress: 0.5,
+            status: "downloading",
+          },
+        ],
+        totalFilesCount: 2,
+      },
+      downloadedBytes: undefined,
+      isUpdateDownloaded: false,
+      progress: 0.42,
+      totalBytes: undefined,
+    });
+  });
+
+  it("preserves patch download metadata for manifest diff files", async () => {
+    const store = await importStore();
+    const emitProgress = listeners.get("onProgress");
+
+    emitProgress?.({
+      artifactType: "diff",
+      details: {
+        completedFilesCount: 0,
+        files: [
+          {
+            downloadPath: "index.ios.bundle.bsdiff",
+            order: 0,
+            path: "index.ios.bundle",
+            progress: 0.4,
+            status: "downloading",
+          },
+        ],
+        totalFilesCount: 1,
+      },
+      progress: 0.32,
+    });
+
+    expect(store.getSnapshot().details?.files).toEqual([
+      {
+        downloadPath: "index.ios.bundle.bsdiff",
+        downloadedBytes: undefined,
+        order: 0,
+        path: "index.ios.bundle",
+        progress: 0.4,
+        status: "downloading",
+        totalBytes: undefined,
+      },
+    ]);
+  });
+
+  it("stores diff snapshot transitions from downloading to downloaded", async () => {
+    const store = await importStore();
+    const emitProgress = listeners.get("onProgress");
+
+    emitProgress?.({
+      artifactType: "diff",
+      details: {
+        completedFilesCount: 0,
+        files: [
+          {
+            order: 0,
+            path: "index.ios.bundle",
+            progress: 0.6,
+            status: "downloading",
+          },
+          {
+            order: 1,
+            path: "assets/logo.png",
+            progress: 0,
+            status: "pending",
+          },
+        ],
+        totalFilesCount: 2,
+      },
+      progress: 0.4,
+    });
+
+    emitProgress?.({
+      artifactType: "diff",
+      details: {
+        completedFilesCount: 1,
+        files: [
+          {
+            downloadPath: "index.ios.bundle",
+            order: 0,
+            path: "index.ios.bundle",
+            progress: 1,
+            status: "downloaded",
+          },
+          {
+            downloadPath: "assets/logo.png",
+            order: 1,
+            path: "assets/logo.png",
+            progress: 0,
+            status: "pending",
+          },
+        ],
+        totalFilesCount: 2,
+      },
+      progress: 0.6,
+    });
+
+    expect(store.getSnapshot()).toEqual({
+      artifactType: "diff",
+      details: {
+        completedFilesCount: 1,
+        files: [
+          {
+            downloadPath: "index.ios.bundle",
+            order: 0,
+            path: "index.ios.bundle",
+            progress: 1,
+            status: "downloaded",
+          },
+          {
+            downloadPath: "assets/logo.png",
+            order: 1,
+            path: "assets/logo.png",
+            progress: 0,
+            status: "pending",
+          },
+        ],
+        totalFilesCount: 2,
+      },
+      downloadedBytes: undefined,
+      isUpdateDownloaded: false,
+      progress: 0.6,
+      totalBytes: undefined,
+    });
+  });
+
+  it("clears manifest metadata when archive progress events arrive", async () => {
+    const store = await importStore();
+    const emitProgress = listeners.get("onProgress");
+
+    emitProgress?.({
+      artifactType: "diff",
+      details: {
+        completedFilesCount: 2,
+        files: [
+          {
+            order: 0,
+            path: "index.ios.bundle",
+            progress: 1,
+            status: "downloaded",
+          },
+          {
+            order: 1,
+            path: "assets/logo.png",
+            progress: 1,
+            status: "downloaded",
+          },
+          {
+            order: 2,
+            path: "assets/bg.png",
+            progress: 0,
+            status: "pending",
+          },
+        ],
+        totalFilesCount: 3,
+      },
+      progress: 0.9,
+    });
+
+    emitProgress?.({
+      artifactType: "archive",
+      progress: 0.25,
+    });
+
+    expect(store.getSnapshot()).toEqual({
+      artifactType: "archive",
+      details: null,
+      downloadedBytes: undefined,
+      isUpdateDownloaded: false,
+      progress: 0.25,
+      totalBytes: undefined,
+    });
+  });
+
+  it("clears stale manifest metadata even when archive events omit optional fields", async () => {
+    const store = await importStore();
+    const emitProgress = listeners.get("onProgress");
+
+    emitProgress?.({
+      artifactType: "diff",
+      details: {
+        completedFilesCount: 0,
+        files: [
+          {
+            order: 0,
+            path: "manifest.asset.png",
+            progress: 0,
+            status: "failed",
+          },
+        ],
+        totalFilesCount: 1,
+      },
+      progress: 0.2,
+    });
+
+    emitProgress?.({
+      artifactType: "archive",
+      progress: 0.4,
+    });
+
+    expect(store.getSnapshot()).toEqual({
+      artifactType: "archive",
+      details: null,
+      downloadedBytes: undefined,
+      isUpdateDownloaded: false,
+      progress: 0.4,
+      totalBytes: undefined,
+    });
+  });
 });

package/src/store.ts

@@ -1,18 +1,88 @@
 import useSyncExternalStoreExports from "use-sync-external-store/shim/with-selector";
 
+import type {
+  HotUpdaterDiffFileSnapshot,
+  HotUpdaterDiffProgressDetails,
+  HotUpdaterProgressEvent,
+} from "./native";
 import { addListener } from "./native";
 
 export type HotUpdaterState = {
   progress: number;
+  downloadedBytes: number | undefined;
+  totalBytes: number | undefined;
   isUpdateDownloaded: boolean;
+  artifactType: "archive" | "diff" | null;
+  details: HotUpdaterDiffProgressDetails | null;
 };
 
 const { useSyncExternalStoreWithSelector } = useSyncExternalStoreExports;
 
+const areDiffDetailsEqual = (
+  left: HotUpdaterDiffProgressDetails | null,
+  right: HotUpdaterDiffProgressDetails | null,
+) => {
+  if (left === right) {
+    return true;
+  }
+
+  if (left === null || right === null) {
+    return false;
+  }
+
+  if (
+    left.totalFilesCount !== right.totalFilesCount ||
+    left.completedFilesCount !== right.completedFilesCount ||
+    left.files.length !== right.files.length
+  ) {
+    return false;
+  }
+
+  return left.files.every((leftFile, index) => {
+    const rightFile = right.files[index];
+    return (
+      rightFile !== undefined &&
+      leftFile.order === rightFile.order &&
+      leftFile.path === rightFile.path &&
+      leftFile.downloadPath === rightFile.downloadPath &&
+      leftFile.downloadedBytes === rightFile.downloadedBytes &&
+      leftFile.progress === rightFile.progress &&
+      leftFile.status === rightFile.status &&
+      leftFile.totalBytes === rightFile.totalBytes
+    );
+  });
+};
+
+const areStatesEqual = (left: HotUpdaterState, right: HotUpdaterState) => {
+  return (
+    left.progress === right.progress &&
+    left.downloadedBytes === right.downloadedBytes &&
+    left.totalBytes === right.totalBytes &&
+    left.isUpdateDownloaded === right.isUpdateDownloaded &&
+    left.artifactType === right.artifactType &&
+    areDiffDetailsEqual(left.details, right.details)
+  );
+};
+
+const normalizeByteCount = (value: number | undefined) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return undefined;
+  }
+  return Math.round(value);
+};
+
+const normalizeDownloadPath = (value: string | undefined) => {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+};
+
 const createHotUpdaterStore = () => {
   let state: HotUpdaterState = {
     progress: 0,
+    downloadedBytes: undefined,
+    totalBytes: undefined,
     isUpdateDownloaded: false,
+    artifactType: null,
+    details: null,
   };
 
   const getSnapshot = () => {
@@ -27,8 +97,39 @@ const createHotUpdaterStore = () => {
     }
   };
 
+  const normalizeDiffDetails = (
+    details: HotUpdaterDiffProgressDetails,
+  ): HotUpdaterDiffProgressDetails => {
+    const totalFilesCount = Math.max(0, details.totalFilesCount);
+    const normalizedFiles: HotUpdaterDiffFileSnapshot[] = details.files
+      .map((file) => {
+        const downloadPath =
+          normalizeDownloadPath(file.downloadPath) ?? file.path;
+
+        return {
+          downloadPath,
+          downloadedBytes: normalizeByteCount(file.downloadedBytes),
+          order: Math.max(0, file.order),
+          path: file.path,
+          progress: Math.max(0, Math.min(file.progress, 1)),
+          status: file.status,
+          totalBytes: normalizeByteCount(file.totalBytes),
+        };
+      })
+      .sort((left, right) => left.order - right.order);
+
+    return {
+      completedFilesCount: Math.max(
+        0,
+        Math.min(details.completedFilesCount, totalFilesCount),
+      ),
+      files: normalizedFiles,
+      totalFilesCount,
+    };
+  };
+
   const setState = (newState: Partial<HotUpdaterState>) => {
-    // Merge first, then normalize derived fields
+    // Merge first, then normalize derived fields.
     const nextState: HotUpdaterState = {
       ...state,
       ...newState,
@@ -38,7 +139,8 @@ const createHotUpdaterStore = () => {
     // If `progress` is not provided but `isUpdateDownloaded` is,
     // honor the explicit value.
     if ("progress" in newState && typeof newState.progress === "number") {
-      nextState.isUpdateDownloaded = newState.progress >= 1;
+      nextState.progress = Math.max(0, Math.min(newState.progress, 1));
+      nextState.isUpdateDownloaded = nextState.progress >= 1;
     } else if (
       "isUpdateDownloaded" in newState &&
       typeof newState.isUpdateDownloaded === "boolean"
@@ -46,10 +148,15 @@ const createHotUpdaterStore = () => {
       nextState.isUpdateDownloaded = newState.isUpdateDownloaded;
     }
 
-    if (
-      state.progress === nextState.progress &&
-      state.isUpdateDownloaded === nextState.isUpdateDownloaded
-    ) {
+    if (newState.details === undefined) {
+      nextState.details = state.details;
+    }
+
+    if (nextState.artifactType !== "diff") {
+      nextState.details = null;
+    }
+
+    if (areStatesEqual(state, nextState)) {
       return;
     }
 
@@ -57,6 +164,25 @@ const createHotUpdaterStore = () => {
     emitChange();
   };
 
+  const applyProgressEvent = (event: HotUpdaterProgressEvent) => {
+    setState({
+      artifactType: event.artifactType,
+      details:
+        event.artifactType === "diff"
+          ? normalizeDiffDetails(event.details)
+          : null,
+      downloadedBytes:
+        event.artifactType === "archive"
+          ? normalizeByteCount(event.downloadedBytes)
+          : undefined,
+      progress: event.progress,
+      totalBytes:
+        event.artifactType === "archive"
+          ? normalizeByteCount(event.totalBytes)
+          : undefined,
+    });
+  };
+
   const subscribe = (listener: () => void) => {
     listeners.add(listener);
     return () => listeners.delete(listener);
@@ -64,7 +190,7 @@ const createHotUpdaterStore = () => {
 
   // Subscribe to native onProgress events
   // This listener is registered once when the store is created
-  addListener("onProgress", setState);
+  addListener("onProgress", applyProgressEvent);
 
   return { getSnapshot, setState, subscribe };
 };

package/src/wrap.spec.ts

@@ -1,5 +1,8 @@
+import type React from "react";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
+import type { HotUpdaterOptions } from "./wrap";
+
 const mocks = vi.hoisted(() => ({
   addListener: vi.fn(() => () => {}),
   checkForUpdate: vi.fn(),
@@ -78,4 +81,92 @@ describe("HotUpdater wrap initialization", () => {
       requestTimeout: 1000,
     });
   });
+
+  it("calls init onError when app-ready notification fails", async () => {
+    vi.useFakeTimers();
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const error = new Error("notify failed");
+    const onError = vi.fn();
+    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().mockRejectedValue(error),
+    };
+    const { init } = await import("./wrap");
+
+    init({
+      resolver,
+      onError,
+    });
+
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(onError).toHaveBeenCalledWith(error);
+    warn.mockRestore();
+  });
+
+  it("warns when the deprecated manual wrap HOC is used", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const { wrap } = await import("./wrap");
+
+    wrap({
+      resolver: {
+        checkUpdate: vi.fn(),
+        notifyAppReady: vi.fn(),
+      },
+      updateMode: "manual",
+    });
+
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'HotUpdater.wrap({ updateMode: "manual" }) is deprecated',
+      ),
+    );
+    warn.mockRestore();
+  });
+
+  it("preserves wrapped component prop inference", async () => {
+    const { wrap } = await import("./wrap");
+    const Component: React.ComponentType<{ title: string }> = () => null;
+
+    const WrappedComponent = wrap({
+      resolver: {
+        checkUpdate: vi.fn(),
+        notifyAppReady: vi.fn(),
+      },
+      updateMode: "auto",
+      updateStrategy: "appVersion",
+    })(Component);
+
+    const acceptsTitleProps: React.ComponentType<{ title: string }> =
+      WrappedComponent;
+    expect(acceptsTitleProps).toBe(WrappedComponent);
+  });
+
+  it("types public wrap options as automatic mode by default", () => {
+    const autoOptions = {
+      baseURL: "https://updates.example.com",
+      updateStrategy: "appVersion",
+    } satisfies HotUpdaterOptions;
+    const explicitAutoOptions = {
+      baseURL: "https://updates.example.com",
+      updateMode: "auto",
+      updateStrategy: "appVersion",
+    } satisfies HotUpdaterOptions;
+    const manualOptions = {
+      baseURL: "https://updates.example.com",
+      updateMode: "manual",
+    } satisfies HotUpdaterOptions;
+
+    expect(autoOptions.updateStrategy).toBe("appVersion");
+    expect(explicitAutoOptions.updateMode).toBe("auto");
+    expect(manualOptions.updateMode).toBe("manual");
+  });
 });