@hot-updater/react-native 0.23.1 → 0.24.0

package/src/specs/NativeHotUpdater.ts

@@ -19,8 +19,71 @@ export interface UpdateBundleParams {
 export interface Spec extends TurboModule {
   // Methods
   reload(): Promise<void>;
+  /**
+   * Downloads and applies a bundle update.
+   *
+   * @param params - Update bundle parameters
+   * @returns Promise that resolves to true if successful
+   * @throws {HotUpdaterErrorCode} Rejects with one of the following error codes:
+   *
+   *   Parameter validation:
+   *   - MISSING_BUNDLE_ID: Missing or empty bundleId
+   *   - INVALID_FILE_URL: Invalid fileUrl provided
+   *
+   *   Bundle storage:
+   *   - DIRECTORY_CREATION_FAILED: Failed to create bundle directory
+   *   - DOWNLOAD_FAILED: Failed to download bundle
+   *   - INCOMPLETE_DOWNLOAD: Download incomplete (size mismatch)
+   *   - EXTRACTION_FORMAT_ERROR: Invalid or corrupted archive format
+   *   - INVALID_BUNDLE: Bundle missing required platform files
+   *   - INSUFFICIENT_DISK_SPACE: Insufficient disk space
+   *   - MOVE_OPERATION_FAILED: Failed to move bundle files
+   *   - BUNDLE_IN_CRASHED_HISTORY: Bundle was previously marked as crashed
+   *
+   *   Signature:
+   *   - SIGNATURE_VERIFICATION_FAILED: Any signature/hash verification failure
+   *
+   *   Internal:
+   *   - SELF_DEALLOCATED: Native object was deallocated (iOS)
+   *   - UNKNOWN_ERROR: Fallback for rare or platform-specific errors
+   *
+   *   Note: iOS normalizes rare signature/storage errors to SIGNATURE_VERIFICATION_FAILED
+   *   or UNKNOWN_ERROR to keep the JS error surface small.
+   */
   updateBundle(params: UpdateBundleParams): Promise<boolean>;
 
+  /**
+   * Notifies the native side that the app has successfully started with the given bundle.
+   * If the bundle matches the staging bundle, it promotes to stable.
+   *
+   * @param params - Parameters containing the bundle ID
+   * @returns Object with status and optional crashedBundleId
+   * - `status: "PROMOTED"` - Staging bundle was promoted to stable (ACTIVE event)
+   * - `status: "RECOVERED"` - App recovered from crash, rollback occurred (ROLLBACK event)
+   * - `status: "STABLE"` - No changes, already stable
+   * - `crashedBundleId` - Present only when status is "RECOVERED"
+   */
+  notifyAppReady(params: { bundleId: string }): {
+    status: "PROMOTED" | "RECOVERED" | "STABLE";
+    crashedBundleId?: string;
+  };
+
+  /**
+   * Gets the list of bundle IDs that have been marked as crashed.
+   * These bundles will be rejected if attempted to install again.
+   *
+   * @returns Array of crashed bundle IDs
+   */
+  getCrashHistory(): string[];
+
+  /**
+   * Clears the crashed bundle history, allowing previously crashed bundles
+   * to be installed again.
+   *
+   * @returns true if clearing was successful
+   */
+  clearCrashHistory(): boolean;
+
   // EventEmitter
   addListener(eventName: string): void;
   removeListeners(count: number): void;

package/src/wrap.tsx

@@ -1,17 +1,93 @@
 import React, { useEffect, useLayoutEffect, useState } from "react";
-import { type CheckForUpdateOptions, checkForUpdate } from "./checkForUpdate";
+import { checkForUpdate } from "./checkForUpdate";
 import type { HotUpdaterError } from "./error";
 import { useEventCallback } from "./hooks/useEventCallback";
-import { getBundleId, reload } from "./native";
-import type { RunUpdateProcessResponse } from "./runUpdateProcess";
+import {
+  getBundleId,
+  type NotifyAppReadyResult,
+  notifyAppReady as nativeNotifyAppReady,
+  reload,
+} from "./native";
 import { useHotUpdaterStore } from "./store";
 
+export interface RunUpdateProcessResponse {
+  status: "ROLLBACK" | "UPDATE" | "UP_TO_DATE";
+  shouldForceUpdate: boolean;
+  message: string | null;
+  id: string;
+}
+
 type UpdateStatus =
   | "CHECK_FOR_UPDATE"
   | "UPDATING"
   | "UPDATE_PROCESS_COMPLETED";
 
-export interface HotUpdaterOptions extends CheckForUpdateOptions {
+/**
+ * Common options shared between auto and manual update modes
+ */
+interface CommonHotUpdaterOptions {
+  /**
+   * Base URL for update server
+   * @example "https://update.example.com"
+   */
+  baseURL: string;
+
+  /**
+   * Custom request headers for update checks
+   */
+  requestHeaders?: Record<string, string>;
+
+  /**
+   * Request timeout in milliseconds
+   * @default 5000
+   */
+  requestTimeout?: number;
+
+  /**
+   * Callback invoked when the app is ready and bundle verification completes.
+   * Provides information about bundle promotion, recovery from crashes, or stable state.
+   *
+   * @param result - Bundle state information
+   * @param result.status - Current bundle state:
+   *   - "PROMOTED": Staging bundle was promoted to stable (new update applied)
+   *   - "RECOVERED": App recovered from a crash, rollback occurred
+   *   - "STABLE": No changes, bundle is stable
+   * @param result.crashedBundleId - Present only when status is "RECOVERED"
+   *
+   * @example
+   * ```tsx
+   * HotUpdater.wrap({
+   *   baseURL: "https://api.example.com",
+   *   updateMode: "manual",
+   *   onNotifyAppReady: ({ status, crashedBundleId }) => {
+   *     if (status === "RECOVERED") {
+   *       analytics.track('bundle_rollback', { crashedBundleId });
+   *     } else if (status === "PROMOTED") {
+   *       analytics.track('bundle_promoted');
+   *     }
+   *   }
+   * })(App);
+   * ```
+   */
+  onNotifyAppReady?: (result: NotifyAppReadyResult) => void;
+}
+
+export interface AutoUpdateOptions extends CommonHotUpdaterOptions {
+  /**
+   * Update strategy
+   * - "fingerprint": Use fingerprint hash to check for updates
+   * - "appVersion": Use app version to check for updates
+   */
+  updateStrategy: "fingerprint" | "appVersion";
+
+  /**
+   * Update mode
+   * - "auto": Automatically check and download updates
+   */
+  updateMode: "auto";
+
+  onError?: (error: HotUpdaterError | Error | unknown) => void;
+
   /**
    * Component to show while downloading a new bundle update.
    *
@@ -22,7 +98,8 @@ export interface HotUpdaterOptions extends CheckForUpdateOptions {
    *
    * ```tsx
    * HotUpdater.wrap({
-   *   source: "<update-server-url>",
+   *   baseURL: "<update-server-url>",
+   *   updateStrategy: "appVersion",
    *   fallbackComponent: ({ progress = 0 }) => (
    *     <View style={styles.container}>
    *       <Text style={styles.text}>Updating... {progress}%</Text>
@@ -38,8 +115,9 @@ export interface HotUpdaterOptions extends CheckForUpdateOptions {
     progress: number;
     message: string | null;
   }>;
-  onError?: (error: HotUpdaterError | Error | unknown) => void;
+
   onProgress?: (progress: number) => void;
+
   /**
    * When a force update exists, the app will automatically reload.
    * If `false`, When a force update exists, the app will not reload. `shouldForceUpdate` will be returned as `true` in `onUpdateProcessCompleted`.
@@ -47,6 +125,7 @@ export interface HotUpdaterOptions extends CheckForUpdateOptions {
    * @default true
    */
   reloadOnForceUpdate?: boolean;
+
   /**
    * Callback function that is called when the update process is completed.
    *
@@ -55,9 +134,39 @@ export interface HotUpdaterOptions extends CheckForUpdateOptions {
   onUpdateProcessCompleted?: (response: RunUpdateProcessResponse) => void;
 }
 
+export interface ManualUpdateOptions extends CommonHotUpdaterOptions {
+  /**
+   * Update mode
+   * - "manual": Only notify app ready, user manually calls checkForUpdate()
+   */
+  updateMode: "manual";
+}
+
+export type HotUpdaterOptions = AutoUpdateOptions | ManualUpdateOptions;
+
 export function wrap<P extends React.JSX.IntrinsicAttributes = object>(
   options: HotUpdaterOptions,
 ): (WrappedComponent: React.ComponentType<P>) => React.ComponentType<P> {
+  if (options.updateMode === "manual") {
+    return (WrappedComponent: React.ComponentType<P>) => {
+      const ManualHOC: React.FC<P> = (props: P) => {
+        useLayoutEffect(() => {
+          try {
+            const result = nativeNotifyAppReady();
+            options.onNotifyAppReady?.(result);
+          } catch (e) {
+            console.warn("[HotUpdater] Failed to notify app ready:", e);
+          }
+        }, []);
+
+        return <WrappedComponent {...props} />;
+      };
+
+      return ManualHOC as React.ComponentType<P>;
+    };
+  }
+
+  // updateMode: "auto"
   const { reloadOnForceUpdate = true, ...restOptions } = options;
 
   return (WrappedComponent: React.ComponentType<P>) => {
@@ -73,10 +182,12 @@ export function wrap<P extends React.JSX.IntrinsicAttributes = object>(
           setUpdateStatus("CHECK_FOR_UPDATE");
 
           const updateInfo = await checkForUpdate({
-            source: restOptions.source,
+            baseURL: restOptions.baseURL,
+            updateStrategy: restOptions.updateStrategy,
             requestHeaders: restOptions.requestHeaders,
+            requestTimeout: restOptions.requestTimeout,
             onError: restOptions.onError,
-          });
+          } as Parameters<typeof checkForUpdate>[0]);
 
           setMessage(updateInfo?.message ?? null);
 
@@ -92,7 +203,7 @@ export function wrap<P extends React.JSX.IntrinsicAttributes = object>(
           }
 
           if (updateInfo.shouldForceUpdate === false) {
-            void updateInfo.updateBundle().catch((error) => {
+            void updateInfo.updateBundle().catch((error: unknown) => {
               restOptions.onError?.(error);
             });
 
@@ -137,6 +248,17 @@ export function wrap<P extends React.JSX.IntrinsicAttributes = object>(
         restOptions.onProgress?.(progress);
       }, [progress]);
 
+      // Notify native side that app is ready (JS bundle fully loaded)
+      useLayoutEffect(() => {
+        try {
+          const result = nativeNotifyAppReady();
+          restOptions.onNotifyAppReady?.(result);
+        } catch (e) {
+          console.warn("[HotUpdater] Failed to notify app ready:", e);
+        }
+      }, []);
+
+      // Start update check
       useLayoutEffect(() => {
         initHotUpdater();
       }, []);

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

@@ -1,52 +0,0 @@
-package com.hotupdater
-
-import android.content.Context
-
-/**
- * Factory for creating HotUpdaterImpl instances with proper dependency injection
- */
-object HotUpdaterFactory {
-    @Volatile
-    private var instance: HotUpdaterImpl? = null
-
-    /**
-     * Gets the singleton instance of HotUpdaterImpl
-     * @param context Application context
-     * @return HotUpdaterImpl instance
-     */
-    fun getInstance(context: Context): HotUpdaterImpl =
-        instance ?: synchronized(this) {
-            instance ?: createHotUpdaterImpl(context).also { instance = it }
-        }
-
-    /**
-     * Creates a new HotUpdaterImpl instance with all dependencies
-     * @param context Application context
-     * @return New HotUpdaterImpl instance
-     */
-    private fun createHotUpdaterImpl(context: Context): HotUpdaterImpl {
-        val appContext = context.applicationContext
-
-        // Get isolation key using the utility method
-        val isolationKey = HotUpdaterImpl.getIsolationKey(appContext)
-
-        // Create services
-        val fileSystem = FileManagerService(appContext)
-        val preferences = VersionedPreferencesService(appContext, isolationKey)
-        val downloadService = OkHttpDownloadService()
-        val decompressService = DecompressService()
-
-        // Create bundle storage with dependencies
-        val bundleStorage =
-            BundleFileStorageService(
-                appContext,
-                fileSystem,
-                downloadService,
-                decompressService,
-                preferences,
-            )
-
-        // Create and return the implementation
-        return HotUpdaterImpl(appContext, bundleStorage, preferences)
-    }
-}

package/ios/HotUpdater/Internal/HotUpdaterFactory.swift

@@ -1,24 +0,0 @@
-import Foundation
-
-@objcMembers
-public class HotUpdaterFactory: NSObject {
-    public static let shared = HotUpdaterFactory()
-    
-    private override init() {}
-    
-    public func create() -> HotUpdaterImpl {
-        let fileSystem = FileManagerService()
-        let preferences = VersionedPreferencesService()
-        let downloadService = URLSessionDownloadService()
-        let decompressService = DecompressService()
-
-        let bundleStorage = BundleFileStorageService(
-            fileSystem: fileSystem,
-            downloadService: downloadService,
-            decompressService: decompressService,
-            preferences: preferences
-        )
-
-        return HotUpdaterImpl(bundleStorage: bundleStorage, preferences: preferences)
-    }
-}

package/lib/commonjs/runUpdateProcess.js

@@ -1,69 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.runUpdateProcess = void 0;
-var _checkForUpdate = require("./checkForUpdate.js");
-var _native = require("./native.js");
-/**
- * Manually checks and applies updates for the application.
- *
- * @param {RunUpdateProcessConfig} config - Update process configuration
- * @param {string} config.source - Update server URL
- * @param {Record<string, string>} [config.requestHeaders] - Request headers
- * @param {boolean} [config.reloadOnForceUpdate=true] - Whether to automatically reload on force update
- *
- * @example
- * ```ts
- * // Auto reload on force update
- * const result = await HotUpdater.runUpdateProcess({
- *   source: "<your-update-server-url>",
- *   requestHeaders: {
- *     // Add necessary headers
- *   },
- *   reloadOnForceUpdate: true
- * });
- *
- * // Manually handle reload on force update
- * const result = await HotUpdater.runUpdateProcess({
- *   source: "<your-update-server-url>",
- *   reloadOnForceUpdate: false
- * });
- *
- * if(result.status !== "UP_TO_DATE" && result.shouldForceUpdate) {
- *   await HotUpdater.reload();
- * }
- * ```
- *
- * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
- */
-const runUpdateProcess = async ({
-  reloadOnForceUpdate = true,
-  ...checkForUpdateOptions
-}) => {
-  const updateInfo = await (0, _checkForUpdate.checkForUpdate)(checkForUpdateOptions);
-  if (!updateInfo) {
-    return {
-      status: "UP_TO_DATE",
-      shouldForceUpdate: false,
-      message: null,
-      id: (0, _native.getBundleId)()
-    };
-  }
-  const isUpdated = await updateInfo.updateBundle();
-  if (isUpdated && updateInfo.shouldForceUpdate && reloadOnForceUpdate) {
-    await (0, _native.reload)();
-  }
-  if (!isUpdated) {
-    throw new Error("New update was found but failed to download the bundle.");
-  }
-  return {
-    status: updateInfo.status,
-    shouldForceUpdate: updateInfo.shouldForceUpdate,
-    id: updateInfo.id,
-    message: updateInfo.message
-  };
-};
-exports.runUpdateProcess = runUpdateProcess;
-//# sourceMappingURL=runUpdateProcess.js.map

package/lib/commonjs/runUpdateProcess.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_checkForUpdate","require","_native","runUpdateProcess","reloadOnForceUpdate","checkForUpdateOptions","updateInfo","checkForUpdate","status","shouldForceUpdate","message","id","getBundleId","isUpdated","updateBundle","reload","Error","exports"],"sourceRoot":"../../src","sources":["runUpdateProcess.ts"],"mappings":";;;;;;AAAA,IAAAA,eAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAkBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAME,gBAAgB,GAAG,MAAAA,CAAO;EACrCC,mBAAmB,GAAG,IAAI;EAC1B,GAAGC;AACoB,CAAC,KAAwC;EAChE,MAAMC,UAAU,GAAG,MAAM,IAAAC,8BAAc,EAACF,qBAAqB,CAAC;EAC9D,IAAI,CAACC,UAAU,EAAE;IACf,OAAO;MACLE,MAAM,EAAE,YAAY;MACpBC,iBAAiB,EAAE,KAAK;MACxBC,OAAO,EAAE,IAAI;MACbC,EAAE,EAAE,IAAAC,mBAAW,EAAC;IAClB,CAAC;EACH;EAEA,MAAMC,SAAS,GAAG,MAAMP,UAAU,CAACQ,YAAY,CAAC,CAAC;EACjD,IAAID,SAAS,IAAIP,UAAU,CAACG,iBAAiB,IAAIL,mBAAmB,EAAE;IACpE,MAAM,IAAAW,cAAM,EAAC,CAAC;EAChB;EAEA,IAAI,CAACF,SAAS,EAAE;IACd,MAAM,IAAIG,KAAK,CAAC,yDAAyD,CAAC;EAC5E;EACA,OAAO;IACLR,MAAM,EAAEF,UAAU,CAACE,MAAM;IACzBC,iBAAiB,EAAEH,UAAU,CAACG,iBAAiB;IAC/CE,EAAE,EAAEL,UAAU,CAACK,EAAE;IACjBD,OAAO,EAAEJ,UAAU,CAACI;EACtB,CAAC;AACH,CAAC;AAACO,OAAA,CAAAd,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/lib/module/runUpdateProcess.js

@@ -1,64 +0,0 @@
-"use strict";
-
-import { checkForUpdate } from "./checkForUpdate.js";
-import { getBundleId, reload } from "./native.js";
-/**
- * Manually checks and applies updates for the application.
- *
- * @param {RunUpdateProcessConfig} config - Update process configuration
- * @param {string} config.source - Update server URL
- * @param {Record<string, string>} [config.requestHeaders] - Request headers
- * @param {boolean} [config.reloadOnForceUpdate=true] - Whether to automatically reload on force update
- *
- * @example
- * ```ts
- * // Auto reload on force update
- * const result = await HotUpdater.runUpdateProcess({
- *   source: "<your-update-server-url>",
- *   requestHeaders: {
- *     // Add necessary headers
- *   },
- *   reloadOnForceUpdate: true
- * });
- *
- * // Manually handle reload on force update
- * const result = await HotUpdater.runUpdateProcess({
- *   source: "<your-update-server-url>",
- *   reloadOnForceUpdate: false
- * });
- *
- * if(result.status !== "UP_TO_DATE" && result.shouldForceUpdate) {
- *   await HotUpdater.reload();
- * }
- * ```
- *
- * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
- */
-export const runUpdateProcess = async ({
-  reloadOnForceUpdate = true,
-  ...checkForUpdateOptions
-}) => {
-  const updateInfo = await checkForUpdate(checkForUpdateOptions);
-  if (!updateInfo) {
-    return {
-      status: "UP_TO_DATE",
-      shouldForceUpdate: false,
-      message: null,
-      id: getBundleId()
-    };
-  }
-  const isUpdated = await updateInfo.updateBundle();
-  if (isUpdated && updateInfo.shouldForceUpdate && reloadOnForceUpdate) {
-    await reload();
-  }
-  if (!isUpdated) {
-    throw new Error("New update was found but failed to download the bundle.");
-  }
-  return {
-    status: updateInfo.status,
-    shouldForceUpdate: updateInfo.shouldForceUpdate,
-    id: updateInfo.id,
-    message: updateInfo.message
-  };
-};
-//# sourceMappingURL=runUpdateProcess.js.map

package/lib/module/runUpdateProcess.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["checkForUpdate","getBundleId","reload","runUpdateProcess","reloadOnForceUpdate","checkForUpdateOptions","updateInfo","status","shouldForceUpdate","message","id","isUpdated","updateBundle","Error"],"sourceRoot":"../../src","sources":["runUpdateProcess.ts"],"mappings":";;AAAA,SAAqCA,cAAc,QAAQ,qBAAkB;AAC7E,SAASC,WAAW,EAAEC,MAAM,QAAQ,aAAU;AAkB9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,gBAAgB,GAAG,MAAAA,CAAO;EACrCC,mBAAmB,GAAG,IAAI;EAC1B,GAAGC;AACoB,CAAC,KAAwC;EAChE,MAAMC,UAAU,GAAG,MAAMN,cAAc,CAACK,qBAAqB,CAAC;EAC9D,IAAI,CAACC,UAAU,EAAE;IACf,OAAO;MACLC,MAAM,EAAE,YAAY;MACpBC,iBAAiB,EAAE,KAAK;MACxBC,OAAO,EAAE,IAAI;MACbC,EAAE,EAAET,WAAW,CAAC;IAClB,CAAC;EACH;EAEA,MAAMU,SAAS,GAAG,MAAML,UAAU,CAACM,YAAY,CAAC,CAAC;EACjD,IAAID,SAAS,IAAIL,UAAU,CAACE,iBAAiB,IAAIJ,mBAAmB,EAAE;IACpE,MAAMF,MAAM,CAAC,CAAC;EAChB;EAEA,IAAI,CAACS,SAAS,EAAE;IACd,MAAM,IAAIE,KAAK,CAAC,yDAAyD,CAAC;EAC5E;EACA,OAAO;IACLN,MAAM,EAAED,UAAU,CAACC,MAAM;IACzBC,iBAAiB,EAAEF,UAAU,CAACE,iBAAiB;IAC/CE,EAAE,EAAEJ,UAAU,CAACI,EAAE;IACjBD,OAAO,EAAEH,UAAU,CAACG;EACtB,CAAC;AACH,CAAC","ignoreList":[]}

package/lib/typescript/commonjs/runUpdateProcess.d.ts

@@ -1,49 +0,0 @@
-import { type CheckForUpdateOptions } from "./checkForUpdate";
-export interface RunUpdateProcessResponse {
-    status: "ROLLBACK" | "UPDATE" | "UP_TO_DATE";
-    shouldForceUpdate: boolean;
-    message: string | null;
-    id: string;
-}
-export interface RunUpdateProcessOptions extends CheckForUpdateOptions {
-    /**
-     * If `true`, the app will be reloaded when the downloaded bundle is a force update.
-     * If `false`, shouldForceUpdate will be returned as true but the app won't reload.
-     * @default true
-     */
-    reloadOnForceUpdate?: boolean;
-}
-/**
- * Manually checks and applies updates for the application.
- *
- * @param {RunUpdateProcessConfig} config - Update process configuration
- * @param {string} config.source - Update server URL
- * @param {Record<string, string>} [config.requestHeaders] - Request headers
- * @param {boolean} [config.reloadOnForceUpdate=true] - Whether to automatically reload on force update
- *
- * @example
- * ```ts
- * // Auto reload on force update
- * const result = await HotUpdater.runUpdateProcess({
- *   source: "<your-update-server-url>",
- *   requestHeaders: {
- *     // Add necessary headers
- *   },
- *   reloadOnForceUpdate: true
- * });
- *
- * // Manually handle reload on force update
- * const result = await HotUpdater.runUpdateProcess({
- *   source: "<your-update-server-url>",
- *   reloadOnForceUpdate: false
- * });
- *
- * if(result.status !== "UP_TO_DATE" && result.shouldForceUpdate) {
- *   await HotUpdater.reload();
- * }
- * ```
- *
- * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
- */
-export declare const runUpdateProcess: ({ reloadOnForceUpdate, ...checkForUpdateOptions }: RunUpdateProcessOptions) => Promise<RunUpdateProcessResponse>;
-//# sourceMappingURL=runUpdateProcess.d.ts.map

package/lib/typescript/commonjs/runUpdateProcess.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runUpdateProcess.d.ts","sourceRoot":"","sources":["../../../src/runUpdateProcess.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,qBAAqB,EAAkB,MAAM,kBAAkB,CAAC;AAG9E,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,UAAU,GAAG,QAAQ,GAAG,YAAY,CAAC;IAC7C,iBAAiB,EAAE,OAAO,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,uBAAwB,SAAQ,qBAAqB;IACpE;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,gBAAgB,GAAU,mDAGpC,uBAAuB,KAAG,OAAO,CAAC,wBAAwB,CAyB5D,CAAC"}

package/lib/typescript/module/runUpdateProcess.d.ts

@@ -1,49 +0,0 @@
-import { type CheckForUpdateOptions } from "./checkForUpdate";
-export interface RunUpdateProcessResponse {
-    status: "ROLLBACK" | "UPDATE" | "UP_TO_DATE";
-    shouldForceUpdate: boolean;
-    message: string | null;
-    id: string;
-}
-export interface RunUpdateProcessOptions extends CheckForUpdateOptions {
-    /**
-     * If `true`, the app will be reloaded when the downloaded bundle is a force update.
-     * If `false`, shouldForceUpdate will be returned as true but the app won't reload.
-     * @default true
-     */
-    reloadOnForceUpdate?: boolean;
-}
-/**
- * Manually checks and applies updates for the application.
- *
- * @param {RunUpdateProcessConfig} config - Update process configuration
- * @param {string} config.source - Update server URL
- * @param {Record<string, string>} [config.requestHeaders] - Request headers
- * @param {boolean} [config.reloadOnForceUpdate=true] - Whether to automatically reload on force update
- *
- * @example
- * ```ts
- * // Auto reload on force update
- * const result = await HotUpdater.runUpdateProcess({
- *   source: "<your-update-server-url>",
- *   requestHeaders: {
- *     // Add necessary headers
- *   },
- *   reloadOnForceUpdate: true
- * });
- *
- * // Manually handle reload on force update
- * const result = await HotUpdater.runUpdateProcess({
- *   source: "<your-update-server-url>",
- *   reloadOnForceUpdate: false
- * });
- *
- * if(result.status !== "UP_TO_DATE" && result.shouldForceUpdate) {
- *   await HotUpdater.reload();
- * }
- * ```
- *
- * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
- */
-export declare const runUpdateProcess: ({ reloadOnForceUpdate, ...checkForUpdateOptions }: RunUpdateProcessOptions) => Promise<RunUpdateProcessResponse>;
-//# sourceMappingURL=runUpdateProcess.d.ts.map

package/lib/typescript/module/runUpdateProcess.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runUpdateProcess.d.ts","sourceRoot":"","sources":["../../../src/runUpdateProcess.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,qBAAqB,EAAkB,MAAM,kBAAkB,CAAC;AAG9E,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,UAAU,GAAG,QAAQ,GAAG,YAAY,CAAC;IAC7C,iBAAiB,EAAE,OAAO,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,uBAAwB,SAAQ,qBAAqB;IACpE;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,gBAAgB,GAAU,mDAGpC,uBAAuB,KAAG,OAAO,CAAC,wBAAwB,CAyB5D,CAAC"}

package/src/runUpdateProcess.ts

@@ -1,80 +0,0 @@
-import { type CheckForUpdateOptions, checkForUpdate } from "./checkForUpdate";
-import { getBundleId, reload } from "./native";
-
-export interface RunUpdateProcessResponse {
-  status: "ROLLBACK" | "UPDATE" | "UP_TO_DATE";
-  shouldForceUpdate: boolean;
-  message: string | null;
-  id: string;
-}
-
-export interface RunUpdateProcessOptions extends CheckForUpdateOptions {
-  /**
-   * If `true`, the app will be reloaded when the downloaded bundle is a force update.
-   * If `false`, shouldForceUpdate will be returned as true but the app won't reload.
-   * @default true
-   */
-  reloadOnForceUpdate?: boolean;
-}
-
-/**
- * Manually checks and applies updates for the application.
- *
- * @param {RunUpdateProcessConfig} config - Update process configuration
- * @param {string} config.source - Update server URL
- * @param {Record<string, string>} [config.requestHeaders] - Request headers
- * @param {boolean} [config.reloadOnForceUpdate=true] - Whether to automatically reload on force update
- *
- * @example
- * ```ts
- * // Auto reload on force update
- * const result = await HotUpdater.runUpdateProcess({
- *   source: "<your-update-server-url>",
- *   requestHeaders: {
- *     // Add necessary headers
- *   },
- *   reloadOnForceUpdate: true
- * });
- *
- * // Manually handle reload on force update
- * const result = await HotUpdater.runUpdateProcess({
- *   source: "<your-update-server-url>",
- *   reloadOnForceUpdate: false
- * });
- *
- * if(result.status !== "UP_TO_DATE" && result.shouldForceUpdate) {
- *   await HotUpdater.reload();
- * }
- * ```
- *
- * @returns {Promise<RunUpdateProcessResponse>} The result of the update process
- */
-export const runUpdateProcess = async ({
-  reloadOnForceUpdate = true,
-  ...checkForUpdateOptions
-}: RunUpdateProcessOptions): Promise<RunUpdateProcessResponse> => {
-  const updateInfo = await checkForUpdate(checkForUpdateOptions);
-  if (!updateInfo) {
-    return {
-      status: "UP_TO_DATE",
-      shouldForceUpdate: false,
-      message: null,
-      id: getBundleId(),
-    };
-  }
-
-  const isUpdated = await updateInfo.updateBundle();
-  if (isUpdated && updateInfo.shouldForceUpdate && reloadOnForceUpdate) {
-    await reload();
-  }
-
-  if (!isUpdated) {
-    throw new Error("New update was found but failed to download the bundle.");
-  }
-  return {
-    status: updateInfo.status,
-    shouldForceUpdate: updateInfo.shouldForceUpdate,
-    id: updateInfo.id,
-    message: updateInfo.message,
-  };
-};