react-native-tvos 0.75.3-0 → 0.76.0-0

package/ReactAndroid/src/main/java/com/facebook/react/common/assets/ReactFontManager.kt

@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.common.assets
+
+import android.content.Context
+import android.content.res.AssetManager
+import android.graphics.Typeface
+import android.os.Build
+import android.util.SparseArray
+import androidx.core.content.res.ResourcesCompat
+import com.facebook.react.common.ReactConstants
+
+/**
+ * Responsible for loading and caching Typeface objects.
+ *
+ * This will first try to load a typeface from the assets/fonts folder. If one is not found in that
+ * folder, this will fallback to the best matching system typeface.
+ *
+ * Custom fonts support the extensions `.ttf` and `.otf` and the variants `bold`, `italic`, and
+ * `bold_italic`. For example, given a font named "ExampleFontFamily", the following are supported:
+ * * ExampleFontFamily.ttf (or .otf)
+ * * ExampleFontFamily_bold.ttf (or .otf)
+ * * ExampleFontFamily_italic.ttf (or .otf)
+ * * ExampleFontFamily_bold_italic.ttf (or .otf)
+ */
+public class ReactFontManager {
+
+  private val fontCache: MutableMap<String, AssetFontFamily> = mutableMapOf()
+  private val customTypefaceCache: MutableMap<String, Typeface> = mutableMapOf()
+
+  public fun getTypeface(
+      fontFamilyName: String,
+      style: Int,
+      assetManager: AssetManager?,
+  ): Typeface = getTypeface(fontFamilyName, TypefaceStyle(style), assetManager)
+
+  public fun getTypeface(
+      fontFamilyName: String,
+      weight: Int,
+      italic: Boolean,
+      assetManager: AssetManager?,
+  ): Typeface = getTypeface(fontFamilyName, TypefaceStyle(weight, italic), assetManager)
+
+  public fun getTypeface(
+      fontFamilyName: String,
+      style: Int,
+      weight: Int,
+      assetManager: AssetManager?,
+  ): Typeface = getTypeface(fontFamilyName, TypefaceStyle(style, weight), assetManager)
+
+  public fun getTypeface(
+      fontFamilyName: String,
+      typefaceStyle: TypefaceStyle,
+      assetManager: AssetManager?,
+  ): Typeface {
+    if (customTypefaceCache.containsKey(fontFamilyName)) {
+      // Apply `typefaceStyle` because custom fonts configure variants using `app:fontStyle` and
+      // `app:fontWeight` in their resource XML configuration file.
+      return typefaceStyle.apply(customTypefaceCache[fontFamilyName])
+    }
+
+    val assetFontFamily = fontCache.getOrPut(fontFamilyName) { AssetFontFamily() }
+    val style = typefaceStyle.nearestStyle
+    return assetFontFamily.getTypefaceForStyle(style)
+        ?: createAssetTypeface(fontFamilyName, style, assetManager).also {
+          assetFontFamily.setTypefaceForStyle(style, it)
+        }
+  }
+
+  /*
+   * This method allows you to load custom fonts from res/font folder as provided font family name.
+   * Fonts may be one of .ttf, .otf or XML (https://developer.android.com/guide/topics/ui/look-and-feel/fonts-in-xml).
+   * To support multiple font styles or weights, you must provide a font in XML format.
+   *
+   * ReactFontManager.getInstance().addCustomFont(this, "Srisakdi", R.font.srisakdi);
+   */
+  public fun addCustomFont(context: Context, fontFamily: String, fontId: Int): Unit {
+    addCustomFont(fontFamily, ResourcesCompat.getFont(context, fontId))
+  }
+
+  /**
+   * Equivalent method to {@see addCustomFont(Context, String, int)} which accepts a Typeface
+   * object.
+   */
+  public fun addCustomFont(fontFamily: String, font: Typeface?): Unit {
+    if (font != null) {
+      customTypefaceCache[fontFamily] = font
+    }
+  }
+
+  /**
+   * Add additional font family, or replace the exist one in the font memory cache.
+   *
+   * @see [Typeface.DEFAULT]
+   * @see [Typeface.BOLD]
+   * @see [Typeface.ITALIC]
+   * @see [Typeface.BOLD_ITALIC]
+   */
+  public fun setTypeface(fontFamilyName: String, style: Int, typeface: Typeface?): Unit {
+    if (typeface != null) {
+      fontCache.getOrPut(fontFamilyName) { AssetFontFamily() }.setTypefaceForStyle(style, typeface)
+    }
+  }
+
+  /** Responsible for normalizing style and numeric weight for backward compatibility. */
+  public class TypefaceStyle {
+    private val italic: Boolean
+    private val weight: Int
+
+    public constructor(weight: Int, italic: Boolean) {
+      this.italic = italic
+      this.weight = if (weight == ReactConstants.UNSET) NORMAL else weight
+    }
+
+    /**
+     * If `weight` is supplied, it will be combined with the italic bit from `style`. Otherwise, any
+     * existing weight bit in `style` will be used.
+     */
+    @JvmOverloads
+    public constructor(style: Int, weight: Int = ReactConstants.UNSET) {
+      val fixedStyle = if (style == ReactConstants.UNSET) Typeface.NORMAL else style
+      italic = (fixedStyle and Typeface.ITALIC) != 0
+      this.weight =
+          if (weight == ReactConstants.UNSET)
+              (if ((fixedStyle and Typeface.BOLD) != 0) BOLD else NORMAL)
+          else weight
+    }
+
+    public val nearestStyle: Int
+      get() =
+          if (weight < BOLD) {
+            if (italic) Typeface.ITALIC else Typeface.NORMAL
+          } else {
+            if (italic) Typeface.BOLD_ITALIC else Typeface.BOLD
+          }
+
+    public fun apply(typeface: Typeface?): Typeface =
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
+          Typeface.create(typeface, nearestStyle)
+        } else {
+          Typeface.create(typeface, weight, italic)
+        }
+
+    public companion object {
+      public const val BOLD: Int = 700
+      public const val NORMAL: Int = 400
+    }
+  }
+
+  public companion object {
+
+    // NOTE: Indices in `EXTENSIONS` correspond to the `TypeFace` style constants.
+    private val EXTENSIONS = arrayOf("", "_bold", "_italic", "_bold_italic")
+    private val FILE_EXTENSIONS = arrayOf(".ttf", ".otf")
+    private const val FONTS_ASSET_PATH = "fonts/"
+
+    private val _instance = ReactFontManager()
+
+    @JvmStatic public fun getInstance(): ReactFontManager = _instance
+
+    private fun createAssetTypeface(
+        fontFamilyName: String,
+        style: Int,
+        assetManager: AssetManager?,
+    ): Typeface {
+      if (assetManager != null) {
+        val extension = EXTENSIONS[style]
+        for (fileExtension in FILE_EXTENSIONS) {
+          val fileName = "$FONTS_ASSET_PATH$fontFamilyName$extension$fileExtension"
+          try {
+            return Typeface.createFromAsset(assetManager, fileName)
+          } catch (e: RuntimeException) {
+            // If the typeface asset does not exist, try another extension.
+            continue
+          }
+        }
+      }
+      return Typeface.create(fontFamilyName, style)
+    }
+  }
+
+  /** Responsible for caching typefaces for each custom font family. */
+  private class AssetFontFamily {
+    private val typefaceSparseArray: SparseArray<Typeface?> = SparseArray(4)
+
+    fun getTypefaceForStyle(style: Int): Typeface? = typefaceSparseArray[style]
+
+    fun setTypefaceForStyle(style: Int, typeface: Typeface?) {
+      typefaceSparseArray.put(style, typeface)
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/common/build/{ReactBuildConfig.java → ReactBuildConfig.kt}

@@ -5,9 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.common.build;
+package com.facebook.react.common.build
 
-import com.facebook.react.BuildConfig;
+import com.facebook.react.BuildConfig
+import kotlin.jvm.JvmField
 
 /**
  * Convenience class for accessing auto-generated BuildConfig so that a) other modules can just
@@ -15,9 +16,11 @@ import com.facebook.react.BuildConfig;
  * and b) we don't have to deal with IntelliJ getting confused about the autogenerated BuildConfig
  * class all over the place.
  */
-public class ReactBuildConfig {
+public object ReactBuildConfig {
 
-  public static final boolean DEBUG = BuildConfig.DEBUG;
-  public static final boolean IS_INTERNAL_BUILD = BuildConfig.IS_INTERNAL_BUILD;
-  public static final int EXOPACKAGE_FLAGS = BuildConfig.EXOPACKAGE_FLAGS;
+  @JvmField public val DEBUG: Boolean = BuildConfig.DEBUG
+
+  @JvmField public val IS_INTERNAL_BUILD: Boolean = BuildConfig.IS_INTERNAL_BUILD
+
+  @JvmField public val EXOPACKAGE_FLAGS: Int = BuildConfig.EXOPACKAGE_FLAGS
 }

package/ReactAndroid/src/main/java/com/facebook/react/common/futures/SimpleSettableFuture.kt

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.common.futures
+
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.Future
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.TimeoutException
+
+/**
+ * A super simple Future-like class that can safely notify another Thread when a value is ready.
+ * Does not support canceling.
+ */
+public class SimpleSettableFuture<T> : Future<T?> {
+
+  private val readyLatch = CountDownLatch(1)
+  private var result: T? = null
+  private var exception: Exception? = null
+
+  /**
+   * Sets the result. If another thread has called [get], they will immediately receive the value.
+   * set or setException must only be called once.
+   */
+  public fun set(result: T?): Unit {
+    checkNotSet()
+    this.result = result
+    readyLatch.countDown()
+  }
+
+  /**
+   * Sets the exception. If another thread has called [get], they will immediately receive the
+   * exception. set or setException must only be called once.
+   */
+  public fun setException(exception: Exception): Unit {
+    checkNotSet()
+    this.exception = exception
+    readyLatch.countDown()
+  }
+
+  override fun cancel(mayInterruptIfRunning: Boolean): Boolean {
+    throw UnsupportedOperationException()
+  }
+
+  override fun isCancelled(): Boolean = false
+
+  override fun isDone(): Boolean = readyLatch.count == 0L
+
+  @Throws(InterruptedException::class, ExecutionException::class)
+  override fun get(): T? {
+    readyLatch.await()
+    if (exception != null) {
+      throw ExecutionException(exception)
+    }
+    return result
+  }
+
+  /**
+   * Wait up to the timeout time for another Thread to set a value on this future. If a value has
+   * already been set, this method will return immediately.
+   *
+   * NB: For simplicity, we catch and wrap InterruptedException. Do NOT use this class if you are in
+   * the 1% of cases where you actually want to handle that.
+   */
+  @Throws(InterruptedException::class, ExecutionException::class, TimeoutException::class)
+  override fun get(timeout: Long, unit: TimeUnit): T? {
+    if (!readyLatch.await(timeout, unit)) {
+      throw TimeoutException("Timed out waiting for result")
+    }
+    if (exception != null) {
+      throw ExecutionException(exception)
+    }
+    return result
+  }
+
+  /** Convenience wrapper for [get()] that re-throws get()'s Exceptions as RuntimeExceptions. */
+  public fun getOrThrow(): T? =
+      try {
+        get()
+      } catch (e: InterruptedException) {
+        throw RuntimeException(e)
+      } catch (e: ExecutionException) {
+        throw RuntimeException(e)
+      }
+
+  /**
+   * Convenience wrapper for [get(long, TimeUnit)] that re-throws get()'s Exceptions as
+   * RuntimeExceptions.
+   */
+  public fun getOrThrow(timeout: Long, unit: TimeUnit): T? =
+      try {
+        get(timeout, unit)
+      } catch (e: InterruptedException) {
+        throw RuntimeException(e)
+      } catch (e: ExecutionException) {
+        throw RuntimeException(e)
+      } catch (e: TimeoutException) {
+        throw RuntimeException(e)
+      }
+
+  private fun checkNotSet() {
+    if (readyLatch.count == 0L) {
+      throw RuntimeException("Result has already been set!")
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/common/network/OkHttpCallUtil.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.common.network
+
+import okhttp3.Dispatcher
+import okhttp3.OkHttpClient
+
+/**
+ * Helper class that provides the necessary methods for canceling queued and running OkHttp calls
+ */
+public object OkHttpCallUtil {
+  @JvmStatic
+  public fun cancelTag(client: OkHttpClient, tag: Any) {
+    // client.dispatcher is private, so we need to use reflection to access
+    // it via method dispatcher() otherwise we will get a compile error:
+    // Using 'dispatcher(): Dispatcher' is an error. moved to val
+    val dispatcherMethod = OkHttpClient::class.java.getMethod("dispatcher")
+    dispatcherMethod.setAccessible(true)
+    val dispatcher = dispatcherMethod.invoke(client) as Dispatcher
+    for (call in dispatcher.queuedCalls()) {
+      if (tag == call.request().tag()) {
+        call.cancel()
+        return
+      }
+    }
+    for (call in dispatcher.runningCalls()) {
+      if (tag == call.request().tag()) {
+        call.cancel()
+        return
+      }
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/config/ReactFeatureFlags.java

@@ -9,7 +9,6 @@ package com.facebook.react.config;
 
 import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.proguard.annotations.DoNotStripAny;
-import com.facebook.react.common.build.ReactBuildConfig;
 
 /**
  * Hi there, traveller! This configuration class is not meant to be used by end-users of RN. It
@@ -27,48 +26,36 @@ public class ReactFeatureFlags {
    * com.facebook.react.turbomodule.core.interfaces.TurboModule} will NOT be passed in to C++
    * CatalystInstanceImpl
    */
+  @Deprecated(
+      since =
+          "useTurboModules will be deleted in 0.77, please use"
+              + " DefaultNewArchitectureEntryPoint.load() to enable TurboModules instead.",
+      forRemoval = true)
   public static volatile boolean useTurboModules = false;
 
-  /** In Bridgeless mode, should legacy NativeModules use the TurboModule system? */
-  public static volatile boolean unstable_useTurboModuleInterop = false;
-
-  /**
-   * Temporary flag that will be used to validate the staibility of the TurboModule interop layer.
-   * Force all Java NativeModules that are TurboModule-compatible (that would have otherwise gone
-   * through the C++ codegen method dispatch path) instead through the TurboModule interop layer
-   * (i.e: the JavaInteropTurboModule method dispatch path).
-   */
-  public static volatile boolean unstable_useTurboModuleInteropForAllTurboModules = false;
-
-  /**
-   * By default, native module methods that return void run asynchronously. This flag will make
-   * execution of void methods in TurboModules stay on the JS thread.
-   */
-  public static volatile boolean unstable_enableTurboModuleSyncVoidMethods = false;
-
   /**
    * Should this application use the new (Fabric) Renderer? If yes, all rendering in this app will
    * use Fabric instead of the legacy renderer.
    */
+  @Deprecated(
+      since =
+          "enableFabricRenderer will be deleted in 0.77, please use"
+              + " DefaultNewArchitectureEntryPoint.load() to enable fabric instead.",
+      forRemoval = true)
   public static volatile boolean enableFabricRenderer = false;
 
-  /**
-   * Should this application enable the Fabric Interop Layer for Android? If yes, the application
-   * will behave so that it can accept non-Fabric components and render them on Fabric. This toggle
-   * is controlling extra logic such as custom event dispatching that are needed for the Fabric
-   * Interop Layer to work correctly.
-   */
-  public static volatile boolean unstable_useFabricInterop = false;
-
   /**
    * Feature flag to enable the new bridgeless architecture. Note: Enabling this will force enable
    * the following flags: `useTurboModules` & `enableFabricRenderer`.
    */
+  @Deprecated(
+      since =
+          "enableBridgelessArchitecture will be deleted in 0.77, please use"
+              + " DefaultNewArchitectureEntryPoint.load() to enable bridgeless architecture"
+              + " instead.",
+      forRemoval = true)
   public static boolean enableBridgelessArchitecture = false;
 
-  /** This feature flag enables logs for Fabric */
-  public static boolean enableFabricLogs = false;
-
   /** Feature flag to configure eager attachment of the root view/initialisation of the JS code */
   public static boolean enableEagerRootViewAttachment = false;
 
@@ -85,41 +72,8 @@ public class ReactFeatureFlags {
 
   public static boolean dispatchPointerEvents = false;
 
-  /**
-   * Feature Flag to enable View Recycling. When enabled, individual ViewManagers must still opt-in.
-   */
-  public static boolean enableViewRecycling = false;
-
   /**
    * Enable prop iterator setter-style construction of Props in C++ (this flag is not used in Java).
    */
   public static boolean enableCppPropsIteratorSetter = false;
-
-  /**
-   * Allow Differentiator.cpp and FabricMountingManager.cpp to generate a RemoveDeleteTree mega-op.
-   */
-  public static boolean enableRemoveDeleteTreeInstruction = false;
-
-  /** When enabled, rawProps in Props will not include Yoga specific props. */
-  public static boolean excludeYogaFromRawProps = false;
-
-  /**
-   * Enables storing js caller stack when creating promise in native module. This is useful in case
-   * of Promise rejection and tracing the cause.
-   */
-  public static boolean traceTurboModulePromiseRejections = ReactBuildConfig.DEBUG;
-
-  /**
-   * Enables auto rejecting promises from Turbo Modules method calls. If native error occurs Promise
-   * in JS will be rejected (The JS error will include native stack)
-   */
-  public static boolean rejectTurboModulePromiseOnNativeError = true;
-
-  /*
-   * When the app is completely migrated to Fabric, set this flag to true to
-   * disable parts of Paper infrastructure that are not needed anymore but consume
-   * memory and CPU. Specifically, UIViewOperationQueue and EventDispatcherImpl will no
-   * longer work as they won't subscribe to ReactChoreographer for updates.
-   */
-  public static boolean enableFabricRendererExclusively = false;
 }

package/ReactAndroid/src/main/java/com/facebook/react/defaults/DefaultComponentsRegistry.kt

@@ -7,7 +7,6 @@
 
 package com.facebook.react.defaults
 
-import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.fabric.ComponentFactory
 
@@ -21,24 +20,10 @@ import com.facebook.react.fabric.ComponentFactory
  * TODO(T186951312): Should this be @UnstableReactNativeAPI?
  */
 @DoNotStrip
-public class DefaultComponentsRegistry
-@DoNotStrip
-private constructor(componentFactory: ComponentFactory) {
-
-  @DoNotStrip
-  @Suppress("NoHungarianNotation")
-  private val mHybridData: HybridData = initHybrid(componentFactory)
-
-  @DoNotStrip private external fun initHybrid(componentFactory: ComponentFactory): HybridData
-
-  public companion object {
-    init {
-      DefaultSoLoader.maybeLoadSoLibrary()
-    }
-
-    @JvmStatic
-    @DoNotStrip
-    public fun register(componentFactory: ComponentFactory): DefaultComponentsRegistry =
-        DefaultComponentsRegistry(componentFactory)
+public object DefaultComponentsRegistry {
+  init {
+    DefaultSoLoader.maybeLoadSoLibrary()
   }
+
+  @JvmStatic @DoNotStrip public external fun register(componentFactory: ComponentFactory): Unit
 }

package/ReactAndroid/src/main/java/com/facebook/react/defaults/DefaultNewArchitectureEntryPoint.kt

@@ -9,11 +9,10 @@
 
 package com.facebook.react.defaults
 
-import com.facebook.infer.annotation.Assertions
 import com.facebook.react.common.annotations.VisibleForTesting
 import com.facebook.react.config.ReactFeatureFlags
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlagsDefaults
+import com.facebook.react.internal.featureflags.ReactNativeNewArchitectureFeatureFlagsDefaults
 
 /**
  * A utility class that serves as an entry point for users setup the New Architecture.
@@ -42,25 +41,16 @@ public object DefaultNewArchitectureEntryPoint {
     }
     ReactFeatureFlags.useTurboModules = turboModulesEnabled
     ReactFeatureFlags.enableFabricRenderer = fabricEnabled
-    ReactFeatureFlags.unstable_useFabricInterop = fabricEnabled
-    ReactFeatureFlags.enableBridgelessArchitecture = bridgelessEnabled
-    ReactFeatureFlags.unstable_useTurboModuleInterop = bridgelessEnabled
-    val fuseboxEnabledDebug = fuseboxEnabled
 
     if (bridgelessEnabled) {
       ReactNativeFeatureFlags.override(
-          object : ReactNativeFeatureFlagsDefaults() {
-            override fun useModernRuntimeScheduler(): Boolean = true
+          object : ReactNativeNewArchitectureFeatureFlagsDefaults(newArchitectureEnabled = true) {
+            override fun useFabricInterop(): Boolean = fabricEnabled
 
-            override fun enableMicrotasks(): Boolean = true
-
-            override fun batchRenderingUpdatesInEventLoop(): Boolean = true
-
-            override fun useNativeViewConfigsInBridgelessMode(): Boolean = true
-
-            // We need to assign this now as we can't call ReactNativeFeatureFlags.override()
-            // more than once.
-            override fun fuseboxEnabledDebug(): Boolean = fuseboxEnabledDebug
+            // We turn this feature flag to true for OSS to fix #44610 and #45126 and other
+            // similar bugs related to pressable.
+            override fun enableEventEmitterRetentionDuringGesturesOnAndroid(): Boolean =
+                fabricEnabled
           })
     }
 
@@ -70,7 +60,6 @@ public object DefaultNewArchitectureEntryPoint {
     privateBridgelessEnabled = bridgelessEnabled
 
     DefaultSoLoader.maybeLoadSoLibrary()
-    loaded = true
   }
 
   private var privateFabricEnabled: Boolean = false
@@ -112,41 +101,4 @@ public object DefaultNewArchitectureEntryPoint {
                 "bridgelessEnabled=true requires (turboModulesEnabled=true AND fabricEnabled=true) - Please update your DefaultNewArchitectureEntryPoint.load() parameters."
         else -> true to ""
       }
-
-  // region unstable_loadFusebox (short-lived API for testing Fusebox - EXPERIMENTAL)
-
-  /**
-   * Set to {@code true} when {@link #load()} is called. Used for assertion in
-   * {@link #unstable_loadFusebox()}.
-   */
-  private var loaded: Boolean = false
-
-  /** Set to {@code true} if {@link #unstable_loadFusebox()} was called. */
-  private var fuseboxEnabled: Boolean = false
-
-  /**
-   * If called, enables the new debugger stack (codename Fusebox). Must be called before
-   * {@link #load()}.
-   *
-   * @param isNewArchEnabled Please pass {@code BuildConfig.IS_NEW_ARCH_ENABLED} here.
-   */
-  @JvmStatic
-  public fun unstable_loadFusebox(
-      isNewArchEnabled: Boolean,
-  ) {
-    fuseboxEnabled = true
-
-    if (!isNewArchEnabled) {
-      ReactNativeFeatureFlags.override(
-          object : ReactNativeFeatureFlagsDefaults() {
-            override fun fuseboxEnabledDebug(): Boolean = true
-          })
-    } else {
-      Assertions.assertCondition(
-          loaded == false, "unstable_loadFusebox() must be called before load()")
-    }
-  }
-
-  // endregion
-
 }

package/ReactAndroid/src/main/java/com/facebook/react/defaults/DefaultReactHost.kt

@@ -8,7 +8,6 @@
 package com.facebook.react.defaults
 
 import android.content.Context
-import com.facebook.react.JSEngineResolutionAlgorithm
 import com.facebook.react.ReactHost
 import com.facebook.react.ReactNativeHost
 import com.facebook.react.ReactPackage
@@ -56,13 +55,22 @@ public object DefaultReactHost {
       packageList: List<ReactPackage>,
       jsMainModulePath: String = "index",
       jsBundleAssetPath: String = "index",
+      jsBundleFilePath: String? = null,
       isHermesEnabled: Boolean = true,
       useDevSupport: Boolean = ReactBuildConfig.DEBUG,
       cxxReactPackageProviders: List<(ReactContext) -> CxxReactPackage> = emptyList(),
   ): ReactHost {
     if (reactHost == null) {
       val jsBundleLoader =
-          JSBundleLoader.createAssetLoader(context, "assets://$jsBundleAssetPath", true)
+          if (jsBundleFilePath != null) {
+            if (jsBundleFilePath.startsWith("assets://")) {
+              JSBundleLoader.createAssetLoader(context, jsBundleFilePath, true)
+            } else {
+              JSBundleLoader.createFileLoader(jsBundleFilePath)
+            }
+          } else {
+            JSBundleLoader.createAssetLoader(context, "assets://$jsBundleAssetPath", true)
+          }
       val jsRuntimeFactory = if (isHermesEnabled) HermesInstance() else JSCInstance()
       val defaultTmmDelegateBuilder = DefaultTurboModuleManagerDelegate.Builder()
       cxxReactPackageProviders.forEach { defaultTmmDelegateBuilder.addCxxReactPackage(it) }
@@ -78,20 +86,12 @@ public object DefaultReactHost {
       // TODO: T164788699 find alternative of accessing ReactHostImpl for initialising reactHost
       reactHost =
           ReactHostImpl(
-                  context,
-                  defaultReactHostDelegate,
-                  componentFactory,
-                  true /* allowPackagerServerAccess */,
-                  useDevSupport,
-              )
-              .apply {
-                jsEngineResolutionAlgorithm =
-                    if (isHermesEnabled) {
-                      JSEngineResolutionAlgorithm.HERMES
-                    } else {
-                      JSEngineResolutionAlgorithm.JSC
-                    }
-              }
+              context,
+              defaultReactHostDelegate,
+              componentFactory,
+              true /* allowPackagerServerAccess */,
+              useDevSupport,
+          )
     }
     return reactHost as ReactHost
   }