react-native-tvos 0.76.5-0 → 0.77.0-0

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactNoCrashSoftException.kt

@@ -0,0 +1,22 @@
+/*
+ * 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.bridge
+
+/**
+ * Extends RuntimeException so that it may be caught by a [ReactSoftExceptionListener]. Any
+ * [ReactSoftExceptionListener] that catches a ReactNoCrashSoftException should log it only and not
+ * crash, no matter what.
+ */
+public open class ReactNoCrashSoftException : RuntimeException {
+
+  public constructor(m: String) : super(m)
+
+  public constructor(e: Throwable) : super(e)
+
+  public constructor(m: String, e: Throwable?) : super(m, e)
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactSoftExceptionLogger.kt

@@ -0,0 +1,65 @@
+/*
+ * 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.bridge
+
+import com.facebook.common.logging.FLog
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.concurrent.CopyOnWriteArrayList
+import kotlin.jvm.JvmStatic
+
+@DoNotStrip
+public object ReactSoftExceptionLogger {
+
+  // Use a list instead of a set here because we expect the number of listeners
+  // to be very small, and we want listeners to be called in a deterministic
+  // order.
+  private val listeners: MutableList<ReactSoftExceptionListener> = CopyOnWriteArrayList()
+
+  @JvmStatic
+  public fun addListener(listener: ReactSoftExceptionListener): Unit {
+    if (!listeners.contains(listener)) {
+      listeners.add(listener)
+    }
+  }
+
+  @JvmStatic
+  public fun removeListener(listener: ReactSoftExceptionListener): Unit {
+    listeners.remove(listener)
+  }
+
+  @JvmStatic
+  public fun clearListeners(): Unit {
+    listeners.clear()
+  }
+
+  @JvmStatic
+  public fun logSoftExceptionVerbose(category: String, cause: Throwable): Unit {
+    logSoftException("${category}|${cause.javaClass.simpleName}:${cause.message}", cause)
+  }
+
+  @JvmStatic
+  public fun logSoftException(category: String, cause: Throwable): Unit {
+    if (!listeners.isEmpty()) {
+      for (listener in listeners) {
+        listener.logSoftException(category, cause)
+      }
+    } else {
+      FLog.e(category, "Unhandled SoftException", cause)
+    }
+  }
+
+  @JvmStatic
+  @DoNotStrip
+  private fun logNoThrowSoftExceptionWithMessage(category: String, message: String) {
+    logSoftException(category, ReactNoCrashSoftException(message))
+  }
+
+  public fun interface ReactSoftExceptionListener {
+    public fun logSoftException(category: String, cause: Throwable)
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableArray.kt

@@ -14,7 +14,7 @@ import java.util.ArrayList
  * to Kotlin.
  */
 public interface ReadableArray {
-  public fun getArray(index: Int): ReadableArray
+  public fun getArray(index: Int): ReadableArray?
 
   public fun getBoolean(index: Int): Boolean
 
@@ -26,9 +26,9 @@ public interface ReadableArray {
 
   public fun getLong(index: Int): Long
 
-  public fun getMap(index: Int): ReadableMap
+  public fun getMap(index: Int): ReadableMap?
 
-  public fun getString(index: Int): String
+  public fun getString(index: Int): String?
 
   public fun getType(index: Int): ReadableType
 
@@ -36,5 +36,5 @@ public interface ReadableArray {
 
   public fun size(): Int
 
-  public fun toArrayList(): ArrayList<Any>
+  public fun toArrayList(): ArrayList<Any?>
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableMap.kt

@@ -16,7 +16,7 @@ import kotlin.collections.Map
  * Kotlin.
  */
 public interface ReadableMap {
-  public val entryIterator: Iterator<Map.Entry<String, Any>>
+  public val entryIterator: Iterator<Map.Entry<String, Any?>>
 
   public fun getArray(name: String): ReadableArray?
 
@@ -42,5 +42,5 @@ public interface ReadableMap {
 
   public fun keySetIterator(): ReadableMapKeySetIterator
 
-  public fun toHashMap(): HashMap<String, Any>
+  public fun toHashMap(): HashMap<String, Any?>
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableNativeArray.kt

@@ -0,0 +1,92 @@
+/*
+ * 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.bridge
+
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.ArrayList
+import java.util.Arrays
+import kotlin.jvm.JvmStatic
+
+/**
+ * Implementation of a NativeArray that allows read-only access to its members. This will generally
+ * be constructed and filled in native code so you shouldn't construct one yourself.
+ */
+@DoNotStrip
+public open class ReadableNativeArray protected constructor() : NativeArray(), ReadableArray {
+
+  private val localArray: Array<Any?> by
+      lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
+        jniPassCounter++
+        importArray()
+      }
+
+  private external fun importArray(): Array<Any?>
+
+  private val localTypeArray: Array<ReadableType> by
+      lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
+        jniPassCounter++
+        val tempArray = importTypeArray()
+        Arrays.copyOf(tempArray, tempArray.size, Array<ReadableType>::class.java)
+      }
+
+  private external fun importTypeArray(): Array<Any>
+
+  override fun size(): Int = localArray.size
+
+  override fun isNull(index: Int): Boolean = localArray[index] == null
+
+  override fun getBoolean(index: Int): Boolean = localArray[index] as Boolean
+
+  override fun getDouble(index: Int): Double = localArray[index] as Double
+
+  override fun getInt(index: Int): Int = (localArray[index] as Double).toInt()
+
+  override fun getLong(index: Int): Long = localArray[index] as Long
+
+  override fun getString(index: Int): String? = localArray[index] as String?
+
+  override fun getArray(index: Int): ReadableNativeArray? =
+      localArray[index] as ReadableNativeArray?
+
+  override fun getMap(index: Int): ReadableNativeMap? = localArray[index] as ReadableNativeMap?
+
+  override fun getType(index: Int): ReadableType = localTypeArray[index]
+
+  override fun getDynamic(index: Int): Dynamic = DynamicFromArray.create(this, index)
+
+  override fun hashCode(): Int = localArray.hashCode()
+
+  override fun equals(other: Any?): Boolean {
+    if (other !is ReadableNativeArray) {
+      return false
+    }
+    return localArray.contentDeepEquals(other.localArray)
+  }
+
+  override fun toArrayList(): ArrayList<Any?> {
+    val arrayList = ArrayList<Any?>()
+    repeat(size()) { i ->
+      when (getType(i)) {
+        ReadableType.Null -> arrayList.add(null)
+        ReadableType.Boolean -> arrayList.add(getBoolean(i))
+        ReadableType.Number -> arrayList.add(getDouble(i))
+        ReadableType.String -> arrayList.add(getString(i))
+        ReadableType.Map -> arrayList.add(getMap(i)?.toHashMap())
+        ReadableType.Array -> arrayList.add(getArray(i)?.toArrayList())
+      }
+    }
+    return arrayList
+  }
+
+  private companion object {
+    @get:JvmStatic
+    @get:JvmName("getJNIPassCounter")
+    public var jniPassCounter: Int = 0
+      private set
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReadableNativeMap.kt

@@ -9,7 +9,6 @@ package com.facebook.react.bridge
 
 import android.annotation.SuppressLint
 import com.facebook.infer.annotation.Assertions
-import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStripAny
 
 /**
@@ -17,15 +16,14 @@ import com.facebook.proguard.annotations.DoNotStripAny
  * in native code so you shouldn't construct one yourself.
  */
 @DoNotStripAny
-public open class ReadableNativeMap protected constructor(hybridData: HybridData?) :
-    NativeMap(hybridData), ReadableMap {
+public open class ReadableNativeMap protected constructor() : NativeMap(), ReadableMap {
   private val keys: Array<String> by
       lazy(LazyThreadSafetyMode.SYNCHRONIZED) { importKeys().also { jniPassCounter++ } }
 
-  private val localMap: HashMap<String, Any> by
+  private val localMap: HashMap<String, Any?> by
       lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
         val length = keys.size
-        val res = HashMap<String, Any>(length)
+        val res = HashMap<String, Any?>(length)
         val values = importValues()
         jniPassCounter++
         for (i in 0 until length) {
@@ -159,7 +157,7 @@ public open class ReadableNativeMap protected constructor(hybridData: HybridData
         false
       } else localMap == other.localMap
 
-  override fun toHashMap(): HashMap<String, Any> {
+  override fun toHashMap(): HashMap<String, Any?> {
     // we can almost just return getLocalMap(), but we need to convert nested arrays and maps to the
     // correct types first
     val hashMap = HashMap(localMap)
@@ -179,12 +177,9 @@ public open class ReadableNativeMap protected constructor(hybridData: HybridData
   }
 
   private companion object {
-    init {
-      ReactBridge.staticInit()
-    }
-
-    private var jniPassCounter: Int = 0
-
-    @JvmStatic public fun getJNIPassCounter(): Int = jniPassCounter
+    @get:JvmStatic
+    @get:JvmName("getJNIPassCounter")
+    public var jniPassCounter: Int = 0
+      private set
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/{RetryableMountingLayerException.java → RetryableMountingLayerException.kt}

@@ -5,22 +5,17 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.bridge;
+package com.facebook.react.bridge
 
 /**
  * ViewCommands can throw this Exception. If this is caught during the execution of a ViewCommand
  * mounting instruction, it indicates that the mount item can be safely retried.
  */
-public class RetryableMountingLayerException extends RuntimeException {
-  public RetryableMountingLayerException(String msg, Throwable e) {
-    super(msg, e);
-  }
+public class RetryableMountingLayerException : RuntimeException {
 
-  public RetryableMountingLayerException(Throwable e) {
-    super(e);
-  }
+  public constructor(msg: String) : super(msg)
 
-  public RetryableMountingLayerException(String msg) {
-    super(msg);
-  }
+  public constructor(e: Throwable) : super(e)
+
+  public constructor(msg: String, e: Throwable?) : super(msg, e)
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/UIManagerProvider.kt

@@ -7,14 +7,10 @@
 
 package com.facebook.react.bridge
 
-import com.facebook.react.common.annotations.DeprecatedInNewArchitecture
-
 /**
  * {@link UIManagerProvider} is used to create UIManager objects during the initialization of React
- * Native. This was introduced as a temporary interface to enable the new renderer of React Native
- * in isolation of others part of the new architecture of React Native.
+ * Native.
  */
-@DeprecatedInNewArchitecture
 public fun interface UIManagerProvider {
 
   /* Provides a {@link com.facebook.react.bridge.UIManager} for the context received as a parameter. */

package/ReactAndroid/src/main/java/com/facebook/react/bridge/WritableNativeArray.kt

@@ -0,0 +1,52 @@
+/*
+ * 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.bridge
+
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Implementation of a write-only array stored in native memory. Use [Arguments#createArray()] if
+ * you need to stub out creating this class in a test.
+ */
+@DoNotStrip
+public class WritableNativeArray : ReadableNativeArray(), WritableArray {
+
+  init {
+    initHybrid()
+  }
+
+  external override fun pushNull()
+
+  external override fun pushBoolean(value: Boolean)
+
+  external override fun pushDouble(value: Double)
+
+  external override fun pushInt(value: Int)
+
+  external override fun pushLong(value: Long)
+
+  external override fun pushString(value: String?)
+
+  // Note: this consumes the map so do not reuse it.
+  override fun pushArray(array: ReadableArray?) {
+    check(array == null || array is ReadableNativeArray) { "Illegal type provided" }
+    pushNativeArray(array as ReadableNativeArray?)
+  }
+
+  // Note: this consumes the map so do not reuse it.
+  override fun pushMap(map: ReadableMap?) {
+    check(map == null || map is ReadableNativeMap) { "Illegal type provided" }
+    pushNativeMap(map as ReadableNativeMap?)
+  }
+
+  private external fun initHybrid()
+
+  private external fun pushNativeArray(array: ReadableNativeArray?)
+
+  private external fun pushNativeMap(map: ReadableNativeMap?)
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/WritableNativeMap.kt

@@ -8,7 +8,6 @@
 package com.facebook.react.bridge
 
 import com.facebook.infer.annotation.Assertions
-import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 
 /**
@@ -16,7 +15,11 @@ import com.facebook.proguard.annotations.DoNotStrip
  * to stub out creating this class in a test. TODO(5815532): Check if consumed on read
  */
 @DoNotStrip
-public class WritableNativeMap : ReadableNativeMap(initHybrid()), WritableMap {
+public class WritableNativeMap : ReadableNativeMap(), WritableMap {
+  init {
+    initHybrid()
+  }
+
   external override fun putBoolean(key: String, value: Boolean)
 
   external override fun putDouble(key: String, value: Double)
@@ -59,11 +62,5 @@ public class WritableNativeMap : ReadableNativeMap(initHybrid()), WritableMap {
 
   private external fun mergeNativeMap(source: ReadableNativeMap)
 
-  private companion object {
-    init {
-      ReactBridge.staticInit()
-    }
-
-    @JvmStatic private external fun initHybrid(): HybridData?
-  }
+  private external fun initHybrid()
 }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/interop/InteropModuleRegistry.kt

@@ -0,0 +1,49 @@
+/*
+ * 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.bridge.interop
+
+import com.facebook.react.bridge.JavaScriptModule
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags.enableFabricRenderer
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags.useFabricInterop
+
+/**
+ * A utility class that takes care of returning [JavaScriptModule] which are used for the Fabric
+ * Interop Layer. This allows us to override the returned classes once the user is invoking
+ * `ReactContext.getJsModule()`.
+ *
+ * Currently we only support a `RCTEventEmitter` re-implementation, being `InteropEventEmitter` but
+ * this class can support other re-implementation in the future.
+ */
+internal class InteropModuleRegistry {
+  private val supportedModules = mutableMapOf<Class<*>, Any?>()
+
+  fun <T : JavaScriptModule?> shouldReturnInteropModule(requestedModule: Class<T>): Boolean {
+    return checkReactFeatureFlagsConditions() && supportedModules.containsKey(requestedModule)
+  }
+
+  fun <T : JavaScriptModule?> getInteropModule(requestedModule: Class<T>): T? {
+    return if (checkReactFeatureFlagsConditions()) {
+      @Suppress("UNCHECKED_CAST")
+      supportedModules[requestedModule] as? T?
+    } else {
+      null
+    }
+  }
+
+  fun <T : JavaScriptModule?> registerInteropModule(
+      interopModuleInterface: Class<T>,
+      interopModule: Any
+  ) {
+    if (checkReactFeatureFlagsConditions()) {
+      supportedModules[interopModuleInterface] = interopModule
+    }
+  }
+
+  private fun checkReactFeatureFlagsConditions(): Boolean =
+      enableFabricRenderer() && useFabricInterop()
+}

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

@@ -5,14 +5,14 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.common;
+package com.facebook.react.common
 
 /**
  * Interface for handling a surface in React Native. In mobile platform a surface can be any
- * container that holds some {@link View}. For example, a Dialog can be a surface to wrap content
- * view object as needed. In VR platform, a surface is provided by Shell panel app sdk, which
- * requires custom logic to show/hide. NativeModules requires a surface will delegate interactions
- * with the surface to a SurfaceDelegate.
+ * container that holds some [View]. For example, a Dialog can be a surface to wrap content view
+ * object as needed. In VR platform, a surface is provided by Shell panel app sdk, which requires
+ * custom logic to show/hide. NativeModules requires a surface will delegate interactions with the
+ * surface to a SurfaceDelegate.
  */
 public interface SurfaceDelegate {
   /**
@@ -20,24 +20,24 @@ public interface SurfaceDelegate {
    *
    * @param appKey
    */
-  void createContentView(String appKey);
+  public fun createContentView(appKey: String): Unit
 
   /**
    * Check if the content view is created and ready to be shown
    *
    * @return true if the content view is ready to be shown
    */
-  boolean isContentViewReady();
+  public fun isContentViewReady(): Boolean
 
   /** Destroy the React content view to avoid memory leak */
-  void destroyContentView();
+  public fun destroyContentView(): Unit
 
   /** Show the surface containing the React content view */
-  void show();
+  public fun show(): Unit
 
   /** Hide the surface containing the React content view */
-  void hide();
+  public fun hide(): Unit
 
   /** Check if the surface is currently showing */
-  boolean isShowing();
+  public fun isShowing(): Boolean
 }

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

@@ -0,0 +1,22 @@
+/*
+ * 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
+
+/**
+ * Factory to create a [SurfaceDelegate]. The moduleName is needed to help the factory decide which
+ * surface to return [SurfaceDelegate] that the given module should use to interact with.
+ */
+public fun interface SurfaceDelegateFactory {
+  /**
+   * Create a [SurfaceDelegate] instance which is used to interact with a surface of platform the
+   * app is running in.
+   *
+   * @param moduleName the module name that will be using the surface
+   * @return [SurfaceDelegate] instance
+   */
+  public fun createSurfaceDelegate(moduleName: String): SurfaceDelegate?
+}

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

@@ -23,4 +23,8 @@ public object ReactBuildConfig {
   @JvmField public val IS_INTERNAL_BUILD: Boolean = BuildConfig.IS_INTERNAL_BUILD
 
   @JvmField public val EXOPACKAGE_FLAGS: Int = BuildConfig.EXOPACKAGE_FLAGS
+
+  /** [Experimental] Enable React Native DevTools in release builds. */
+  @JvmField
+  public val UNSTABLE_ENABLE_FUSEBOX_RELEASE: Boolean = BuildConfig.UNSTABLE_ENABLE_FUSEBOX_RELEASE
 }

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

@@ -17,7 +17,7 @@ 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?> {
+internal class SimpleSettableFuture<T> : Future<T?> {
 
   private val readyLatch = CountDownLatch(1)
   private var result: T? = null

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

@@ -13,7 +13,7 @@ import okhttp3.OkHttpClient
 /**
  * Helper class that provides the necessary methods for canceling queued and running OkHttp calls
  */
-public object OkHttpCallUtil {
+internal object OkHttpCallUtil {
   @JvmStatic
   public fun cancelTag(client: OkHttpClient, tag: Any) {
     // client.dispatcher is private, so we need to use reflection to access

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

@@ -0,0 +1,35 @@
+/*
+ * 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.config
+
+import com.facebook.proguard.annotations.DoNotStripAny
+import kotlin.jvm.JvmField
+
+/**
+ * Hi there, traveller! This configuration class is not meant to be used by end-users of RN. It
+ * contains mainly flags for features that are either under active development and not ready for
+ * public consumption, or for use in experiments.
+ *
+ * These values are safe defaults and should not require manual changes.
+ */
+@Deprecated("Use com.facebook.react.internal.featureflags.ReactNativeFeatureFlags instead.")
+@DoNotStripAny
+public object ReactFeatureFlags {
+  @JvmField public var dispatchPointerEvents: Boolean = false
+  /**
+   * Android TV: Send key down events as well as key up events.
+   * Enabling this flag will result in two 'select' TVRemoteEventHandler events
+   * (one with key action 0 and one with key action 1) for each press of the center
+   * DPad button. (Similarly for arrow keys.)
+   * Note: If you enable this flag, long presses of the select or center button will
+   * result in an initial 'select' with eventKeyAction = 0 (ACTION_DOWN), before
+   * the expected 'longSelect' events are fired. (Similarly for arrow keys.)
+   * TODO: Move this flag to ReactNativeFeatureFlags
+   */
+  @JvmField public var enableKeyDownEvents: Boolean = false
+}

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

@@ -10,7 +10,6 @@
 package com.facebook.react.defaults
 
 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.ReactNativeNewArchitectureFeatureFlagsDefaults
 
@@ -39,20 +38,20 @@ public object DefaultNewArchitectureEntryPoint {
     if (!isValid) {
       error(errorMessage)
     }
-    ReactFeatureFlags.useTurboModules = turboModulesEnabled
-    ReactFeatureFlags.enableFabricRenderer = fabricEnabled
-
-    if (bridgelessEnabled) {
-      ReactNativeFeatureFlags.override(
-          object : ReactNativeNewArchitectureFeatureFlagsDefaults(newArchitectureEnabled = true) {
-            override fun useFabricInterop(): Boolean = fabricEnabled
-
-            // 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
-          })
-    }
+
+    ReactNativeFeatureFlags.override(
+        object : ReactNativeNewArchitectureFeatureFlagsDefaults(bridgelessEnabled) {
+          override fun useFabricInterop(): Boolean = bridgelessEnabled || fabricEnabled
+
+          override fun enableFabricRenderer(): Boolean = bridgelessEnabled || fabricEnabled
+
+          // 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 =
+              bridgelessEnabled || fabricEnabled
+
+          override fun useTurboModules(): Boolean = bridgelessEnabled || turboModulesEnabled
+        })
 
     privateFabricEnabled = fabricEnabled
     privateTurboModulesEnabled = turboModulesEnabled