@hot-updater/react-native 1.0.0-rc.4 → 1.0.0-rc.41

package/src/wrap.tsx

@@ -1,30 +1,21 @@
 import React, { useEffect, useState } from "react";
 
-import { checkForUpdate } from "./checkForUpdate";
 import { useEventCallback } from "./hooks/useEventCallback";
 import { getUpdateId, reload } from "./native";
-import { handleNotifyAppReady } from "./notifyAppReadyInsights";
 import { useHotUpdaterStore } from "./store";
 import type {
-  InternalInitOptions,
+  HotUpdaterFallbackComponentProps,
   InternalWrapOptions,
   UpdateStatus,
 } from "./wrap.types";
 
 export type {
-  AutoUpdateOptions,
   HotUpdaterFallbackComponentProps,
-  HotUpdaterInitOptions,
-  HotUpdaterOptions,
-  InternalInitOptions,
+  HotUpdaterWrapOptions,
   InternalWrapOptions,
   RunUpdateProcessResponse,
 } from "./wrap.types";
 
-export function init(options: InternalInitOptions): void {
-  void handleNotifyAppReady(options);
-}
-
 export function wrap(
   options: InternalWrapOptions,
 ): <P extends object>(
@@ -32,11 +23,46 @@ export function wrap(
 ) => React.ComponentType<P> {
   const { reloadOnForceUpdate = true, ...restOptions } = options;
 
+  // Progress is subscribed only where it is rendered or reported, so progress
+  // events don't re-render the wrapped app.
+  const ProgressReporter = ({
+    onProgress,
+  }: {
+    onProgress: (progress: number) => void;
+  }) => {
+    const progress = useHotUpdaterStore((state) => state.progress);
+
+    useEffect(() => {
+      onProgress(progress);
+    }, [progress]);
+
+    return null;
+  };
+
+  const FallbackWithProgress = ({
+    Fallback,
+    status,
+    message,
+  }: {
+    Fallback: React.FC<HotUpdaterFallbackComponentProps>;
+    status: HotUpdaterFallbackComponentProps["status"];
+    message: string | null;
+  }) => {
+    const progressState = useHotUpdaterStore((state) => state);
+
+    return (
+      <Fallback
+        artifactType={progressState.artifactType}
+        details={progressState.details}
+        progress={progressState.progress}
+        status={status}
+        message={message}
+      />
+    );
+  };
+
   return <P extends object>(WrappedComponent: React.ComponentType<P>) => {
     const HotUpdaterHOC: React.FC<P> = (props: P) => {
-      const progressState = useHotUpdaterStore((state) => state);
-      const progress = progressState.progress;
-
       const [message, setMessage] = useState<string | null>(null);
       const [updateStatus, setUpdateStatus] =
         useState<UpdateStatus>("CHECK_FOR_UPDATE");
@@ -45,15 +71,12 @@ export function wrap(
         try {
           setUpdateStatus("CHECK_FOR_UPDATE");
 
-          const updateInfo = await checkForUpdate({
-            insights: restOptions.insights,
-            client: restOptions.client,
+          const updateInfo = await restOptions.checkForUpdate({
             updateStrategy: restOptions.updateStrategy,
-            requestHeaders: restOptions.requestHeaders,
-            requestTimeout: restOptions.requestTimeout,
-            onError: restOptions.onError,
           });
 
+          // A forced update reloads only after init has read this launch.
+          await restOptions.appReady();
           setMessage(updateInfo?.message ?? null);
 
           if (!updateInfo) {
@@ -69,7 +92,7 @@ export function wrap(
 
           if (updateInfo.shouldForceUpdate === false) {
             void updateInfo.updateBundle().catch((error: unknown) => {
-              restOptions.onError?.(error);
+              restOptions.onError(error);
             });
 
             restOptions.onUpdateProcessCompleted?.({
@@ -106,44 +129,38 @@ export function wrap(
         } catch (error) {
           const normalizedError =
             error instanceof Error ? error : new Error(String(error));
-          restOptions.onError?.(normalizedError);
+          restOptions.onError(normalizedError);
           setUpdateStatus("UPDATE_PROCESS_COMPLETED");
         }
       });
 
-      useEffect(() => {
-        restOptions.onProgress?.(progress);
-      }, [progress]);
-
-      // Read the native launch report after the first render commit.
-      useEffect(() => {
-        void handleNotifyAppReady(restOptions);
-      }, []);
-
       // Start update check
       useEffect(() => {
         initHotUpdater();
       }, []);
 
-      if (
+      const content =
         restOptions.fallbackComponent &&
-        updateStatus !== "UPDATE_PROCESS_COMPLETED"
-      ) {
-        const Fallback = restOptions.fallbackComponent;
-        return (
-          <Fallback
-            artifactType={progressState.artifactType}
-            details={progressState.details}
-            downloadedBytes={progressState.downloadedBytes}
-            progress={progress}
+        updateStatus !== "UPDATE_PROCESS_COMPLETED" ? (
+          <FallbackWithProgress
+            Fallback={restOptions.fallbackComponent}
             status={updateStatus}
             message={message}
-            totalBytes={progressState.totalBytes}
           />
+        ) : (
+          <WrappedComponent {...props} />
         );
+
+      if (!restOptions.onProgress) {
+        return content;
       }
 
-      return <WrappedComponent {...props} />;
+      return (
+        <>
+          {content}
+          <ProgressReporter onProgress={restOptions.onProgress} />
+        </>
+      );
     };
 
     return HotUpdaterHOC as React.ComponentType<P>;

package/src/wrap.types.ts

@@ -1,10 +1,10 @@
 import type React from "react";
 
-import type { HotUpdaterError } from "./error";
-import type { HotUpdaterHttpClient } from "./httpClient";
-import type { NotifyAppReadyResult } from "./native";
+import type {
+  CheckForUpdateOptions,
+  CheckForUpdateResult,
+} from "./checkForUpdate";
 import type { HotUpdaterState } from "./store";
-import type { HotUpdaterBaseURL } from "./types";
 
 export interface RunUpdateProcessResponse {
   status: "ROLLBACK" | "UPDATE" | "UP_TO_DATE";
@@ -21,57 +21,29 @@ export type UpdateStatus =
 export type HotUpdaterFallbackComponentProps = {
   status: Exclude<UpdateStatus, "UPDATE_PROCESS_COMPLETED">;
   progress: number;
-  downloadedBytes: HotUpdaterState["downloadedBytes"];
-  totalBytes: HotUpdaterState["totalBytes"];
   message: string | null;
   artifactType: HotUpdaterState["artifactType"];
   details: HotUpdaterState["details"];
 };
 
-interface CommonHotUpdaterOptions {
-  /**
-   * Sends app-ready transitions and same-Bundle Release adoptions to the
-   * configured server. Defaults to `true`; set to `false` to disable client
-   * reporting.
-   */
-  insights?: boolean;
-  /** Base URL of a server exposing the Hot Updater v1 client HTTP protocol. */
-  baseURL: HotUpdaterBaseURL;
-  requestHeaders?: Record<string, string>;
-  requestTimeout?: number;
-  onNotifyAppReady?: (result: NotifyAppReadyResult) => void;
-  onError?: (error: HotUpdaterError | Error | unknown) => void;
-}
-
-export type AutoUpdateOptions = CommonHotUpdaterOptions & {
+/**
+ * The update flow `hotUpdater.wrap` runs when the wrapped root mounts. The
+ * server, request settings, and plugins come from `HotUpdater.init`.
+ */
+export interface HotUpdaterWrapOptions {
   updateStrategy: "fingerprint" | "appVersion";
   fallbackComponent?: React.FC<HotUpdaterFallbackComponentProps>;
   onProgress?: (progress: number) => void;
   reloadOnForceUpdate?: boolean;
   onUpdateProcessCompleted?: (response: RunUpdateProcessResponse) => void;
-};
-
-export type HotUpdaterInitOptions = CommonHotUpdaterOptions;
-
-export type HotUpdaterOptions = AutoUpdateOptions;
+}
 
-type InternalCommonOptions = {
-  insights?: boolean;
-  client: HotUpdaterHttpClient;
-  requestHeaders?: Record<string, string>;
-  requestTimeout?: number;
-  onNotifyAppReady?: (result: NotifyAppReadyResult) => void;
-  onError?: (error: HotUpdaterError | Error | unknown) => void;
+export type InternalWrapOptions = HotUpdaterWrapOptions & {
+  /** The instance's check, over the configuration of `HotUpdater.init`. */
+  checkForUpdate: (
+    options: Pick<CheckForUpdateOptions, "updateStrategy">,
+  ) => Promise<CheckForUpdateResult | null>;
+  /** Settles once `HotUpdater.init` has read this launch. */
+  appReady: () => Promise<unknown>;
+  onError: (error: unknown) => void;
 };
-
-type InternalAutoUpdateOptions = InternalCommonOptions & {
-  updateStrategy: "fingerprint" | "appVersion";
-  fallbackComponent?: React.FC<HotUpdaterFallbackComponentProps>;
-  onProgress?: (progress: number) => void;
-  reloadOnForceUpdate?: boolean;
-  onUpdateProcessCompleted?: (response: RunUpdateProcessResponse) => void;
-};
-
-export type InternalInitOptions = InternalCommonOptions;
-
-export type InternalWrapOptions = InternalAutoUpdateOptions;

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

@@ -1,89 +0,0 @@
-package com.hotupdater
-
-import android.util.Log
-import java.io.File
-
-/**
- * Unified decompression service that uses Strategy pattern to handle multiple compression formats.
- * Automatically detects format by trying each strategy's validation and delegates to appropriate decompression strategy.
- */
-class DecompressService {
-    companion object {
-        private const val TAG = "DecompressService"
-    }
-
-    // Strategies with reliable file signatures that can be validated cheaply.
-    // TAR.BR is attempted only as the final fallback because Brotli has no reliable magic bytes.
-    private val signatureStrategies =
-        listOf(
-            ZipDecompressionStrategy(),
-            TarGzDecompressionStrategy(),
-        )
-    private val tarBrStrategy = TarBrDecompressionStrategy()
-
-    /**
-     * Extracts a compressed file to the destination directory.
-     * Automatically detects compression format by trying each strategy's validation.
-     * @param filePath Path to the compressed file
-     * @param destinationPath Path to the destination directory
-     * @param progressCallback Callback for progress updates (0.0 - 1.0)
-     * @return true if extraction was successful, false otherwise
-     */
-    fun extractZipFile(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean {
-        // Collect file information for better error messages
-        val file = File(filePath)
-        val fileName = file.name
-        val fileSize = if (file.exists()) file.length() else 0L
-
-        // Try each signature-based strategy first.
-        for (strategy in signatureStrategies) {
-            if (strategy.isValid(filePath)) {
-                Log.d(TAG, "Using strategy for $fileName")
-                return strategy.decompress(filePath, destinationPath, progressCallback)
-            }
-        }
-
-        Log.d(TAG, "No ZIP/TAR.GZ signature matched for $fileName, trying TAR.BR fallback")
-
-        if (tarBrStrategy.decompress(filePath, destinationPath, progressCallback)) {
-            Log.d(TAG, "Using TAR.BR fallback for $fileName")
-            return true
-        }
-
-        val errorMessage = createInvalidArchiveMessage(fileName, fileSize)
-        Log.e(TAG, errorMessage)
-        return false
-    }
-
-    /**
-     * Validates if a file matches one of the signature-based archive formats.
-     * @param filePath Path to the file to validate
-     * @return true if the file is a valid compressed archive
-     */
-    fun isValidZipFile(filePath: String): Boolean {
-        for (strategy in signatureStrategies) {
-            if (strategy.isValid(filePath)) {
-                return true
-            }
-        }
-        Log.d(TAG, "No ZIP/TAR.GZ signature matched for file: $filePath. TAR.BR is handled during extraction fallback.")
-        return false
-    }
-
-    private fun createInvalidArchiveMessage(
-        fileName: String,
-        fileSize: Long,
-    ): String =
-        """
-        The downloaded bundle file is not a valid compressed archive: $fileName ($fileSize bytes)
-
-        Supported formats:
-        - ZIP archives (.zip)
-        - GZIP compressed TAR archives (.tar.gz)
-        - Brotli compressed TAR archives (.tar.br)
-        """.trimIndent()
-}

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

@@ -1,26 +0,0 @@
-package com.hotupdater
-
-/**
- * Interface for decompression strategies
- */
-interface DecompressionStrategy {
-    /**
-     * Validates if a file can be decompressed by this strategy
-     * @param filePath Path to the file to validate
-     * @return true if the file is valid for this strategy
-     */
-    fun isValid(filePath: String): Boolean
-
-    /**
-     * Decompresses a file to the destination directory
-     * @param filePath Path to the compressed file
-     * @param destinationPath Path to the destination directory
-     * @param progressCallback Callback for progress updates (0.0 - 1.0)
-     * @return true if decompression was successful, false otherwise
-     */
-    fun decompress(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean
-}

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

@@ -1,117 +0,0 @@
-package com.hotupdater
-
-import android.util.Log
-import com.hotupdater.vendor.brotli.dec.BrotliInputStream
-import java.io.BufferedInputStream
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-
-/**
- * Strategy for handling TAR+Brotli compressed files
- * Uses native Brotli decoder and custom TAR parser
- */
-class TarBrDecompressionStrategy : DecompressionStrategy {
-    companion object {
-        private const val TAG = "TarBrStrategy"
-        private const val MIN_FILE_SIZE = 10L
-    }
-
-    override fun isValid(filePath: String): Boolean {
-        val file = File(filePath)
-
-        if (!file.exists() || file.length() < MIN_FILE_SIZE) {
-            Log.d(TAG, "Invalid file: doesn't exist or too small (${file.length()} bytes)")
-            return false
-        }
-
-        return try {
-            FileInputStream(file).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    BrotliInputStream(bufferedInputStream).use { brotliInputStream ->
-                        TarArchiveInputStream(brotliInputStream).use { tarInputStream ->
-                            val firstEntry = tarInputStream.getNextEntry()
-                            val isValid = firstEntry != null
-
-                            if (!isValid) {
-                                Log.d(TAG, "Invalid file: tar archive has no entries")
-                            }
-
-                            isValid
-                        }
-                    }
-                }
-            }
-        } catch (e: Exception) {
-            Log.d(TAG, "Invalid file: Brotli/TAR validation failed - ${e.message}")
-            false
-        }
-    }
-
-    override fun decompress(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean =
-        try {
-            val destinationDir = File(destinationPath)
-            if (!destinationDir.exists()) {
-                destinationDir.mkdirs()
-            }
-
-            val sourceFile = File(filePath)
-            val totalSize = sourceFile.length()
-            var processedBytes = 0L
-
-            Log.d(TAG, "Extracting tar.br file: $filePath")
-
-            FileInputStream(filePath).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    BrotliInputStream(bufferedInputStream).use { brotliInputStream ->
-                        TarArchiveInputStream(brotliInputStream).use { tarInputStream ->
-                            var entry = tarInputStream.getNextEntry()
-
-                            while (entry != null) {
-                                val file = RelativePathResolver.resolveInside(destinationDir, entry.name)
-
-                                if (file == null) {
-                                    Log.w(TAG, "Skipping potentially malicious tar entry: ${entry.name}")
-                                    entry = tarInputStream.getNextEntry()
-                                    continue
-                                }
-
-                                if (entry.isDirectory) {
-                                    file.mkdirs()
-                                } else {
-                                    file.parentFile?.mkdirs()
-
-                                    FileOutputStream(file).use { output ->
-                                        val buffer = ByteArray(8 * 1024)
-                                        var bytesRead: Int
-
-                                        while (tarInputStream.read(buffer).also { bytesRead = it } != -1) {
-                                            output.write(buffer, 0, bytesRead)
-                                            processedBytes += bytesRead
-                                        }
-                                    }
-                                }
-
-                                val progress = processedBytes.toDouble() / (totalSize * 2.0)
-                                progressCallback.invoke(progress.coerceIn(0.0, 1.0))
-
-                                entry = tarInputStream.getNextEntry()
-                            }
-                        }
-                    }
-                }
-            }
-
-            Log.d(TAG, "Successfully extracted tar.br file")
-            progressCallback.invoke(1.0)
-            true
-        } catch (e: Exception) {
-            Log.d(TAG, "Failed to extract tar.br file: ${e.message}")
-            e.printStackTrace()
-            false
-        }
-}

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

@@ -1,117 +0,0 @@
-package com.hotupdater
-
-import android.util.Log
-import java.io.BufferedInputStream
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-import java.util.zip.GZIPInputStream
-
-/**
- * Strategy for handling TAR+GZIP compressed files
- * Uses native GZIP decoder and custom TAR parser
- */
-class TarGzDecompressionStrategy : DecompressionStrategy {
-    companion object {
-        private const val TAG = "TarGzStrategy"
-        private const val MIN_FILE_SIZE = 10L
-    }
-
-    override fun isValid(filePath: String): Boolean {
-        val file = File(filePath)
-
-        if (!file.exists() || file.length() < MIN_FILE_SIZE) {
-            Log.d(TAG, "Invalid file: doesn't exist or too small (${file.length()} bytes)")
-            return false
-        }
-
-        try {
-            FileInputStream(file).use { fis ->
-                val header = ByteArray(2)
-                if (fis.read(header) != 2) {
-                    Log.d(TAG, "Invalid file: cannot read header")
-                    return false
-                }
-
-                // Check GZIP magic bytes (0x1F 0x8B)
-                val isGzip = header[0] == 0x1F.toByte() && header[1] == 0x8B.toByte()
-                if (!isGzip) {
-                    Log.d(
-                        TAG,
-                        "Invalid file: wrong magic bytes (expected 0x1F 0x8B, got 0x${header[0].toString(16)} 0x${header[1].toString(16)})",
-                    )
-                }
-                return isGzip
-            }
-        } catch (e: Exception) {
-            Log.d(TAG, "Invalid file: error reading header: ${e.message}")
-            return false
-        }
-    }
-
-    override fun decompress(
-        filePath: String,
-        destinationPath: String,
-        progressCallback: (Double) -> Unit,
-    ): Boolean =
-        try {
-            val destinationDir = File(destinationPath)
-            if (!destinationDir.exists()) {
-                destinationDir.mkdirs()
-            }
-
-            val sourceFile = File(filePath)
-            val totalSize = sourceFile.length()
-            var processedBytes = 0L
-
-            Log.d(TAG, "Extracting tar.gz file: $filePath")
-
-            FileInputStream(filePath).use { fileInputStream ->
-                BufferedInputStream(fileInputStream).use { bufferedInputStream ->
-                    GZIPInputStream(bufferedInputStream).use { gzipInputStream ->
-                        TarArchiveInputStream(gzipInputStream).use { tarInputStream ->
-                            var entry = tarInputStream.getNextEntry()
-
-                            while (entry != null) {
-                                val file = RelativePathResolver.resolveInside(destinationDir, entry.name)
-
-                                if (file == null) {
-                                    Log.w(TAG, "Skipping potentially malicious tar entry: ${entry.name}")
-                                    entry = tarInputStream.getNextEntry()
-                                    continue
-                                }
-
-                                if (entry.isDirectory) {
-                                    file.mkdirs()
-                                } else {
-                                    file.parentFile?.mkdirs()
-
-                                    FileOutputStream(file).use { output ->
-                                        val buffer = ByteArray(8 * 1024)
-                                        var bytesRead: Int
-
-                                        while (tarInputStream.read(buffer).also { bytesRead = it } != -1) {
-                                            output.write(buffer, 0, bytesRead)
-                                            processedBytes += bytesRead
-                                        }
-                                    }
-                                }
-
-                                val progress = processedBytes.toDouble() / (totalSize * 2.0)
-                                progressCallback.invoke(progress.coerceIn(0.0, 1.0))
-
-                                entry = tarInputStream.getNextEntry()
-                            }
-                        }
-                    }
-                }
-            }
-
-            Log.d(TAG, "Successfully extracted tar.gz file")
-            progressCallback.invoke(1.0)
-            true
-        } catch (e: Exception) {
-            Log.e(TAG, "Error extracting tar.gz file: ${e.message}", e)
-            false
-        }
-}