@hot-updater/react-native 0.1.2 → 0.1.4

package/android/src/main/java/com/hotupdater/HotUpdater.kt

@@ -271,14 +271,14 @@ class HotUpdater internal constructor(context: Context, reactNativeHost: ReactNa
         }
 
         val extractedDirectory = File(extractedPath)
-        val indexFile = extractedDirectory.walk().find { it.name == "index.android.bundle.js" }
+        val indexFile = extractedDirectory.walk().find { it.name == "index.android.bundle" }
 
         if (indexFile != null) {
             val bundlePath = indexFile.path
             Log.d("HotUpdater", "Setting bundle URL: $bundlePath")
             setBundleURL(bundlePath)
         } else {
-            Log.d("HotUpdater", "index.android.bundle.js not found.")
+            Log.d("HotUpdater", "index.android.bundle not found.")
             return false
         }
 

package/ios/HotUpdater/HotUpdater.mm

@@ -146,7 +146,7 @@ RCT_EXPORT_MODULE();
     NSDirectoryEnumerator *enumerator = [fileManager enumeratorAtPath:extractedPath];
     NSString *filename = nil;
     for (NSString *file in enumerator) {
-        if ([file isEqualToString:@"index.ios.bundle.js"]) {
+        if ([file isEqualToString:@"index.ios.bundle"]) {
             filename = file;
             break;
         }
@@ -157,7 +157,7 @@ RCT_EXPORT_MODULE();
         NSLog(@"Setting bundle URL: %@", bundlePath);
         [self setBundleURL:bundlePath];
     } else {
-        NSLog(@"index.ios.bundle.js not found.");
+        NSLog(@"index.ios.bundle not found.");
         return NO;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "description": "React Native OTA solution for self-hosted",
   "main": "dist/index.cjs",
@@ -9,6 +9,7 @@
   "types": "dist/index.d.ts",
   "files": [
     "dist",
+    "src",
     "android",
     "ios",
     "cpp",
@@ -58,7 +59,7 @@
     "react-native": "^0.72.6"
   },
   "dependencies": {
-    "@hot-updater/utils": "0.1.2"
+    "@hot-updater/utils": "0.1.4"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/checkForUpdate.test.ts

@@ -0,0 +1,517 @@
+import type { UpdateSource } from "@hot-updater/utils";
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import { checkForUpdate } from "./checkForUpdate";
+import * as natives from "./native";
+
+vi.mock("./native", () => ({
+  getAppVersion: async () => "1.0",
+  getBundleVersion: async () => 1,
+}));
+
+vi.mock("react-native", () => ({
+  Platform: {
+    OS: "ios",
+  },
+}));
+
+describe("appVersion 1.0, bundleVersion null", async () => {
+  beforeAll(() => {
+    vi.spyOn(natives, "getAppVersion").mockImplementation(async () => "1.0");
+    vi.spyOn(natives, "getBundleVersion").mockImplementation(async () => -1);
+  });
+
+  it("should return null if no update information is available", async () => {
+    const updateSources: UpdateSource[] = [];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toBeNull();
+  });
+
+  it("should return null if no update is available when the app version is higher", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.1",
+        enabled: true,
+        bundleVersion: 1,
+        forceUpdate: false,
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toBeNull();
+  });
+
+  it("should update if a higher bundle with semver version exists", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.x.x",
+        enabled: true,
+        bundleVersion: 1,
+        forceUpdate: false,
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        enabled: true,
+        bundleVersion: 2,
+        forceUpdate: false,
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual({
+      bundleVersion: 2,
+      forceUpdate: false,
+      status: "UPDATE",
+      file: "http://example.com/bundle.zip",
+      hash: "hash",
+    });
+  });
+
+  it("should update if a higher bundle version exists and forceUpdate is set to true", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        enabled: true,
+        bundleVersion: 1,
+        forceUpdate: true,
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+      },
+    ];
+    const update = await checkForUpdate(updateSources);
+
+    expect(update).toStrictEqual({
+      bundleVersion: 1,
+      forceUpdate: true,
+      status: "UPDATE",
+      file: "http://example.com/bundle.zip",
+      hash: "hash",
+    });
+  });
+
+  it("should update if a higher bundle version exists and forceUpdate is set to false", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        enabled: true,
+        bundleVersion: 1,
+        forceUpdate: false,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual({
+      file: "http://example.com/bundle.zip",
+      hash: "hash",
+      bundleVersion: 1,
+      forceUpdate: false,
+      status: "UPDATE",
+    });
+  });
+
+  it("should update even if the app version is the same and the bundle version is significantly higher", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 5,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual({
+      bundleVersion: 5,
+      forceUpdate: false,
+      status: "UPDATE",
+      file: "http://example.com/bundle.zip",
+      hash: "hash",
+    });
+  });
+
+  it("should update if the latest version is not available but a previous version is available", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: true,
+        enabled: false, // Disabled
+        bundleVersion: 2,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 1,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual({
+      file: "http://example.com/bundle.zip",
+      hash: "hash",
+      bundleVersion: 1,
+      forceUpdate: false,
+      status: "UPDATE",
+    });
+  });
+
+  it("should not update if all updates are disabled", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: true,
+        enabled: false, // Disabled
+        bundleVersion: 2,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: false, // Disabled
+        bundleVersion: 1,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toBeNull();
+  });
+
+  it("should rollback to the original bundle when receiving the latest bundle but all updates are disabled", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: true,
+        enabled: false, // Disabled
+        bundleVersion: 2,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: false, // Disabled
+        bundleVersion: 1,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual(null);
+  });
+
+  it("should update if the latest version is available and the app version is the same", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        forceUpdate: false,
+        platform: "ios",
+        file: "20240722210327/ios/build.zip",
+        hash: "a5cbf59a627759a88d472c502423ff55a4f6cd1aafeed3536f6a5f6e870c2290",
+        description: "",
+        targetVersion: "1.0",
+        bundleVersion: 20240722210327,
+        enabled: true,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual({
+      bundleVersion: 20240722210327,
+      forceUpdate: false,
+      status: "UPDATE",
+      file: "20240722210327/ios/build.zip",
+      hash: "a5cbf59a627759a88d472c502423ff55a4f6cd1aafeed3536f6a5f6e870c2290",
+    });
+  });
+});
+
+describe("appVersion 1.0, bundleVersion v2", async () => {
+  beforeAll(() => {
+    vi.spyOn(natives, "getAppVersion").mockImplementation(async () => "1.0");
+    vi.spyOn(natives, "getBundleVersion").mockImplementation(async () => 2);
+  });
+
+  it("should return null if no update information is available", async () => {
+    const updateSources: UpdateSource[] = [];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toBeNull();
+  });
+
+  it("should return null if no update is available when the app version is higher", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 2,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 1,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toBeNull();
+  });
+
+  it("should rollback if the latest bundle is deleted", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 1,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual({
+      file: "http://example.com/bundle.zip",
+      hash: "hash",
+      bundleVersion: 1,
+      forceUpdate: true,
+      status: "ROLLBACK",
+    });
+  });
+
+  it("should update if a higher bundle version exists and forceUpdate is set to false", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 3,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 2,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 1,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual({
+      file: "http://example.com/bundle.zip",
+      hash: "hash",
+      bundleVersion: 3,
+      forceUpdate: false,
+      status: "UPDATE",
+    });
+  });
+
+  it("should update even if the app version is the same and the bundle version is significantly higher", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 5, // Higher than the current version
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 4,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 3,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 2,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 1,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual({
+      file: "http://example.com/bundle.zip",
+      hash: "hash",
+      bundleVersion: 5,
+      forceUpdate: false,
+      status: "UPDATE",
+    });
+  });
+
+  it("should not update if the latest version is disabled and matches the current version", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: true,
+        enabled: false, // Disabled
+        bundleVersion: 3,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: true,
+        enabled: true,
+        bundleVersion: 2,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 1,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toBeNull();
+  });
+
+  it("should rollback to a previous version if the current version is disabled", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: true,
+        enabled: false, // Disabled
+        bundleVersion: 2,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: true,
+        bundleVersion: 1,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual({
+      file: "http://example.com/bundle.zip",
+      hash: "hash",
+      bundleVersion: 1,
+      forceUpdate: true, // Cause the app to reload
+      status: "ROLLBACK",
+    });
+  });
+
+  it("should rollback to the original bundle when receiving the latest bundle but all updates are disabled", async () => {
+    const updateSources: UpdateSource[] = [
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: true,
+        enabled: false, // Disabled
+        bundleVersion: 2,
+      },
+      {
+        platform: "ios",
+        targetVersion: "1.0",
+        file: "http://example.com/bundle.zip",
+        hash: "hash",
+        forceUpdate: false,
+        enabled: false, // Disabled
+        bundleVersion: 1,
+      },
+    ];
+
+    const update = await checkForUpdate(updateSources);
+    expect(update).toStrictEqual({
+      file: null,
+      hash: null,
+      bundleVersion: 0,
+      forceUpdate: true, // Cause the app to reload
+      status: "ROLLBACK",
+    });
+  });
+});

package/src/checkForUpdate.ts

@@ -0,0 +1,111 @@
+import type { UpdateSource, UpdateSourceArg } from "@hot-updater/utils";
+import { filterTargetVersion } from "@hot-updater/utils";
+import { Platform } from "react-native";
+import { getAppVersion, getBundleVersion } from "./native";
+import { isNullable } from "./utils";
+export type UpdateStatus = "ROLLBACK" | "UPDATE";
+
+const findLatestSources = (sources: UpdateSource[]) => {
+  return (
+    sources
+      ?.filter((item) => item.enabled)
+      ?.sort((a, b) => b.bundleVersion - a.bundleVersion)?.[0] ?? null
+  );
+};
+
+const checkForRollback = (
+  sources: UpdateSource[],
+  currentBundleVersion: number,
+) => {
+  const enabled = sources?.find(
+    (item) => item.bundleVersion === currentBundleVersion,
+  )?.enabled;
+  const availableOldVersion = sources?.find(
+    (item) => item.bundleVersion < currentBundleVersion && item.enabled,
+  )?.enabled;
+
+  if (isNullable(enabled)) {
+    return availableOldVersion;
+  }
+  return !enabled;
+};
+
+const ensureUpdateSource = async (updateSource: UpdateSourceArg) => {
+  let source: UpdateSource[] | null = null;
+  if (typeof updateSource === "string") {
+    if (updateSource.startsWith("http")) {
+      const response = await fetch(updateSource);
+      source = (await response.json()) as UpdateSource[];
+    }
+  } else if (typeof updateSource === "function") {
+    source = await updateSource();
+  } else {
+    source = updateSource;
+  }
+  if (!source) {
+    throw new Error("Invalid source");
+  }
+  return source;
+};
+
+export const checkForUpdate = async (updateSources: UpdateSourceArg) => {
+  const sources = await ensureUpdateSource(updateSources);
+
+  const currentAppVersion = await getAppVersion();
+  const platform = Platform.OS as "ios" | "android";
+
+  const appVersionSources = currentAppVersion
+    ? filterTargetVersion(sources, currentAppVersion, platform)
+    : [];
+  const currentBundleVersion = await getBundleVersion();
+
+  const isRollback = checkForRollback(appVersionSources, currentBundleVersion);
+  const latestSource = await findLatestSources(appVersionSources);
+
+  if (!latestSource) {
+    if (isRollback) {
+      return {
+        bundleVersion: 0,
+        forceUpdate: true,
+        file: null,
+        hash: null,
+        status: "ROLLBACK" as UpdateStatus,
+      };
+    }
+    return null;
+  }
+
+  if (latestSource.file)
+    if (isRollback) {
+      if (latestSource.bundleVersion === currentBundleVersion) {
+        return null;
+      }
+      if (latestSource.bundleVersion > currentBundleVersion) {
+        return {
+          bundleVersion: latestSource.bundleVersion,
+          forceUpdate: latestSource.forceUpdate,
+          file: latestSource.file,
+          hash: latestSource.hash,
+          status: "UPDATE" as UpdateStatus,
+        };
+      }
+      return {
+        bundleVersion: latestSource.bundleVersion,
+        forceUpdate: true,
+        file: latestSource.file,
+        hash: latestSource.hash,
+        status: "ROLLBACK" as UpdateStatus,
+      };
+    }
+
+  if (latestSource.bundleVersion > currentBundleVersion) {
+    return {
+      bundleVersion: latestSource.bundleVersion,
+      forceUpdate: latestSource.forceUpdate,
+      file: latestSource.file,
+      hash: latestSource.hash,
+      status: "UPDATE" as UpdateStatus,
+    };
+  }
+  return null;
+};

package/src/error.ts

@@ -0,0 +1,6 @@
+export class HotUpdaterError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "HotUpdaterError";
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+import { checkForUpdate } from "./checkForUpdate";
+import { init } from "./init";
+import { getAppVersion, getBundleVersion, reload } from "./native";
+
+export type * from "./init";
+export type * from "./checkForUpdate";
+export type * from "./native";
+
+export const HotUpdater = {
+  init,
+  reload,
+  checkForUpdate,
+  getAppVersion,
+  getBundleVersion,
+};

package/src/init.tsx

@@ -0,0 +1,51 @@
+import type { UpdateSourceArg } from "@hot-updater/utils";
+import { Platform } from "react-native";
+import { checkForUpdate } from "./checkForUpdate";
+import { HotUpdaterError } from "./error";
+import { initializeOnAppUpdate, reload, updateBundle } from "./native";
+
+export type HotUpdaterStatus = "INSTALLING_UPDATE" | "UP_TO_DATE";
+
+export interface HotUpdaterInitConfig {
+  source: UpdateSourceArg;
+  onSuccess?: (status: HotUpdaterStatus) => void;
+  onError?: (error: HotUpdaterError) => void;
+}
+
+export const init = async (config: HotUpdaterInitConfig) => {
+  if (__DEV__) {
+    console.warn(
+      "[HotUpdater] __DEV__ is true, HotUpdater is only supported in production",
+    );
+    return;
+  }
+
+  if (!["ios", "android"].includes(Platform.OS)) {
+    const error = new HotUpdaterError(
+      "HotUpdater is only supported on iOS and Android",
+    );
+
+    config?.onError?.(error);
+    throw error;
+  }
+  await initializeOnAppUpdate();
+
+  const update = await checkForUpdate(config.source);
+  if (!update) {
+    config?.onSuccess?.("UP_TO_DATE");
+    return;
+  }
+
+  try {
+    const isSuccess = await updateBundle(update.bundleVersion, update.file);
+    if (isSuccess && update.forceUpdate) {
+      reload();
+      config?.onSuccess?.("INSTALLING_UPDATE");
+    }
+  } catch (error) {
+    if (error instanceof HotUpdaterError) {
+      config?.onError?.(error);
+    }
+    throw error;
+  }
+};

package/src/native.ts

@@ -0,0 +1,72 @@
+import { NativeModules } from "react-native";
+import { HotUpdaterError } from "./error";
+
+const { HotUpdater } = NativeModules;
+
+/**
+ * Fetches the current bundle version id.
+ *
+ * @async
+ * @returns {Promise<number>} Resolves with the current version id or null if not available.
+ */
+export const getBundleVersion = async (): Promise<number> => {
+  return new Promise((resolve) => {
+    HotUpdater.getBundleVersion((version: number | null) => {
+      resolve(version ?? -1);
+    });
+  });
+};
+
+/**
+ * Downloads files from given URLs.
+ *
+ * @async
+ * @param {string} bundleVersion - identifier for the bundle version.
+ * @param {string | null} zipUrl - zip file URL.
+ * @returns {Promise<boolean>} Resolves with true if download was successful, otherwise rejects with an error.
+ */
+export const updateBundle = (
+  bundleVersion: number,
+  zipUrl: string | null,
+): Promise<boolean> => {
+  return new Promise((resolve, reject) => {
+    HotUpdater.updateBundle(
+      String(bundleVersion),
+      zipUrl,
+      (success: boolean) => {
+        if (success) {
+          resolve(success);
+        } else {
+          reject(
+            new HotUpdaterError("Failed to download and install the update"),
+          );
+        }
+      },
+    );
+  });
+};
+
+/**
+ * Fetches the current app version.
+ */
+export const getAppVersion = async (): Promise<string | null> => {
+  return new Promise((resolve) => {
+    HotUpdater.getAppVersion((version: string | null) => {
+      resolve(version);
+    });
+  });
+};
+
+/**
+ * Reloads the app.
+ */
+export const reload = () => {
+  HotUpdater.reload();
+};
+
+/**
+ * Initializes the HotUpdater.
+ */
+export const initializeOnAppUpdate = () => {
+  HotUpdater.initializeOnAppUpdate();
+};

package/src/specs/NativeHotUpdaterModule.ts

@@ -0,0 +1,16 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+
+interface Spec extends TurboModule {
+  reload(): void;
+  updateBundle(
+    prefix: string,
+    zipUrl: string | null,
+    callback: (success: boolean) => void,
+  ): Promise<boolean>;
+  initializeOnAppUpdate(): void;
+  getAppVersion(): Promise<string | null>;
+  getBundleVersion(): Promise<number | null>;
+}
+
+export default TurboModuleRegistry.get<Spec>("HotUpdater");

package/src/utils.ts

@@ -0,0 +1,2 @@
+export const isNullable = (value: unknown): value is null | undefined =>
+  value === null || value === undefined;