@hot-updater/react-native 0.30.11 → 0.31.0

package/src/native.ts

@@ -1,4 +1,5 @@
 import {
+  type ChangedAsset,
   INVALID_COHORT_ERROR_MESSAGE,
   isValidCohort,
   normalizeCohortValue,
@@ -24,6 +25,7 @@ const normalizeAndValidateCohort = (cohort: string): string => {
 
 export interface ManifestAsset {
   fileHash: string;
+  signature?: string;
 }
 
 export interface Manifest {
@@ -186,11 +188,38 @@ const cloneManifest = (manifest: Manifest): Manifest => ({
   assets: Object.fromEntries(
     Object.entries(manifest.assets).map(([key, asset]) => [
       key,
-      { fileHash: asset.fileHash },
+      {
+        fileHash: asset.fileHash,
+        ...(asset.signature ? { signature: asset.signature } : {}),
+      },
     ]),
   ),
 });
 
+const getNativeBundleId = (): string | null => {
+  const nativeModule = HotUpdaterNative as typeof HotUpdaterNative & {
+    getBundleId?: () => string | null;
+  };
+
+  if (typeof nativeModule.getBundleId !== "function") {
+    throw new Error(
+      "[HotUpdater] Native module is missing 'getBundleId()'. This JS bundle requires a newer native @hot-updater/react-native SDK. Rebuild and release a new app version before delivering this OTA update.",
+    );
+  }
+
+  return nativeModule.getBundleId();
+};
+
+const resolveBundleId = (bundleId: string | null): string => {
+  return !bundleId || bundleId === NIL_UUID ? getMinBundleId() : bundleId;
+};
+
+const getFreshBundleId = (): string => {
+  const resolvedBundleId = resolveBundleId(getNativeBundleId());
+  sessionState.cacheBundleId(resolvedBundleId);
+  return resolvedBundleId;
+};
+
 const getReloadProcess = (): (() => Promise<void>) | null => {
   const nativeModule = HotUpdaterNative as typeof HotUpdaterNative & {
     reloadProcess?: () => Promise<void>;
@@ -201,10 +230,73 @@ const getReloadProcess = (): (() => Promise<void>) | null => {
     : null;
 };
 
+export type HotUpdaterProgressArtifactType = "archive" | "diff";
+
+export type HotUpdaterDiffFileStatus =
+  | "pending"
+  | "downloading"
+  | "downloaded"
+  | "failed";
+
+export interface HotUpdaterDiffFileSnapshot {
+  /**
+   * Manifest asset path for this progress entry.
+   *
+   * This is the stable identity of the asset in the installed bundle. Use this
+   * when matching progress back to the manifest or to the final file location.
+   */
+  path: string;
+  /**
+   * Artifact path currently being transferred for this progress entry.
+   *
+   * Usually this is the same as `path`. It can differ when the updater
+   * downloads an intermediate artifact that will be applied to produce the
+   * final asset.
+   */
+  downloadPath: string;
+  /**
+   * Current download state for this asset within the manifest diff update.
+   */
+  status: HotUpdaterDiffFileStatus;
+  /**
+   * Download progress for this file, normalized from 0 to 1.
+   */
+  progress: number;
+  /**
+   * Stable display order among diff files.
+   */
+  order: number;
+  /**
+   * Bytes downloaded for `downloadPath`, when the native downloader reports it.
+   */
+  downloadedBytes?: number;
+  /**
+   * Total expected bytes for `downloadPath`, when known.
+   */
+  totalBytes?: number;
+}
+
+export interface HotUpdaterDiffProgressDetails {
+  totalFilesCount: number;
+  completedFilesCount: number;
+  files: HotUpdaterDiffFileSnapshot[];
+}
+
+export type HotUpdaterProgressEvent =
+  | {
+      progress: number;
+      artifactType: "archive";
+      downloadedBytes?: number;
+      totalBytes?: number;
+    }
+  | {
+      progress: number;
+      artifactType: "diff";
+      details: HotUpdaterDiffProgressDetails;
+    };
+
 export type HotUpdaterEvent = {
-  onProgress: {
-    progress: number;
-  };
+  onProgress: HotUpdaterProgressEvent;
 };
 
 const eventEmitter = new NativeEventEmitter(HotUpdaterNative);
@@ -252,8 +344,21 @@ export async function updateBundle(
   const status =
     typeof paramsOrBundleId === "string" ? "UPDATE" : paramsOrBundleId.status;
 
-  // If we have already installed this bundle in this session, skip re-download.
-  if (status === "UPDATE" && sessionState.hasInstalledBundle(updateBundleId)) {
+  const targetFileUrl =
+    typeof paramsOrBundleId === "string"
+      ? (fileUrl ?? null)
+      : paramsOrBundleId.fileUrl;
+
+  const currentBundleId = status === "UPDATE" ? getFreshBundleId() : undefined;
+
+  // If native is still on the same bundle we installed in this session,
+  // skip re-download. Native state can move back to the built-in bundle after
+  // rollback/reset, so check a fresh native bundle id before using this guard.
+  if (
+    status === "UPDATE" &&
+    sessionState.hasInstalledBundle(updateBundleId) &&
+    currentBundleId === updateBundleId
+  ) {
     return true;
   }
 
@@ -265,7 +370,8 @@ export async function updateBundle(
   if (
     !shouldSkipCurrentBundleIdCheck &&
     status === "UPDATE" &&
-    updateBundleId.localeCompare(getBundleId()) <= 0
+    currentBundleId !== undefined &&
+    updateBundleId.localeCompare(currentBundleId) <= 0
   ) {
     throw new Error(
       "Update bundle id is not newer than the current bundle id. Preventing infinite update loop.",
@@ -276,11 +382,6 @@ export async function updateBundle(
   const existing = sessionState.getInflightUpdate(updateBundleId);
   if (existing) return existing;
 
-  const targetFileUrl =
-    typeof paramsOrBundleId === "string"
-      ? (fileUrl ?? null)
-      : paramsOrBundleId.fileUrl;
-
   const targetFileHash =
     typeof paramsOrBundleId === "string"
       ? undefined
@@ -288,14 +389,30 @@ export async function updateBundle(
 
   const targetChannel =
     typeof paramsOrBundleId === "string" ? undefined : paramsOrBundleId.channel;
+  const targetManifestUrl =
+    typeof paramsOrBundleId === "string"
+      ? undefined
+      : paramsOrBundleId.manifestUrl;
+  const targetManifestFileHash =
+    typeof paramsOrBundleId === "string"
+      ? undefined
+      : paramsOrBundleId.manifestFileHash;
+  const targetChangedAssets =
+    typeof paramsOrBundleId === "string"
+      ? undefined
+      : paramsOrBundleId.changedAssets;
 
   const promise = (async () => {
     try {
       const ok = await HotUpdaterNative.updateBundle({
         bundleId: updateBundleId,
         channel: targetChannel,
+        changedAssets:
+          (targetChangedAssets as Record<string, ChangedAsset> | null) ?? null,
         fileUrl: targetFileUrl,
         fileHash: targetFileHash ?? null,
+        manifestFileHash: targetManifestFileHash ?? null,
+        manifestUrl: targetManifestUrl ?? null,
       });
       if (ok) {
         sessionState.markBundleInstalled(updateBundleId, targetChannel);
@@ -424,23 +541,7 @@ export const getBundleId = (): string => {
     return cachedBundleId;
   }
 
-  const nativeModule = HotUpdaterNative as typeof HotUpdaterNative & {
-    getBundleId?: () => string | null;
-  };
-
-  if (typeof nativeModule.getBundleId !== "function") {
-    throw new Error(
-      "[HotUpdater] Native module is missing 'getBundleId()'. This JS bundle requires a newer native @hot-updater/react-native SDK. Rebuild and release a new app version before delivering this OTA update.",
-    );
-  }
-
-  const bundleId = nativeModule.getBundleId();
-
-  const resolvedBundleId =
-    !bundleId || bundleId === NIL_UUID ? getMinBundleId() : bundleId;
-
-  sessionState.cacheBundleId(resolvedBundleId);
-  return resolvedBundleId;
+  return getFreshBundleId();
 };
 
 /**
@@ -617,12 +718,25 @@ const normalizeManifestAssets = (value: unknown): Manifest["assets"] => {
         return [];
       }
 
-      const { fileHash } = entry as { fileHash?: unknown };
+      const { fileHash, signature } = entry as {
+        fileHash?: unknown;
+        signature?: unknown;
+      };
       if (typeof fileHash !== "string" || !fileHash.trim()) {
         return [];
       }
 
-      return [[trimmedKey, { fileHash: fileHash.trim() }] as const];
+      return [
+        [
+          trimmedKey,
+          {
+            fileHash: fileHash.trim(),
+            ...(typeof signature === "string" && signature.trim()
+              ? { signature: signature.trim() }
+              : {}),
+          },
+        ] as const,
+      ];
     }),
   );
 };

package/src/sdkVersion.ts

@@ -0,0 +1 @@
+export const HOT_UPDATER_SDK_VERSION = "0.30.12";

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,
+    });
+  });
 });