@callstack/react-native-brownfield 3.11.0 → 3.13.0

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/processors/VariantPackagesProperty.kt

@@ -0,0 +1,21 @@
+package com.callstack.react.brownfield.processors
+
+import org.gradle.api.Project
+import org.gradle.api.provider.MapProperty
+
+object VariantPackagesProperty {
+    private lateinit var properties: MapProperty<String, List<String>>
+
+    fun getVariantPackagesProperty(): MapProperty<String, List<String>> {
+        return properties
+    }
+
+    fun setVariantPackagesProperty(project: Project) {
+        @Suppress("UNCHECKED_CAST")
+        properties =
+            project.objects.mapProperty(
+                String::class.java,
+                List::class.java as Class<List<String>>,
+            )
+    }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/processors/VariantTaskProvider.kt

@@ -0,0 +1,103 @@
+package com.callstack.react.brownfield.processors
+
+import com.android.build.gradle.internal.tasks.factory.dependsOn
+import com.callstack.react.brownfield.exceptions.TaskNotFound
+import com.callstack.react.brownfield.shared.ExplodeAarTask
+import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
+import com.callstack.react.brownfield.utils.DirectoryManager
+import com.callstack.react.brownfield.utils.Extension
+import com.callstack.react.brownfield.utils.Utils
+import com.callstack.react.brownfield.utils.capitalized
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.UnknownTaskException
+import org.gradle.api.tasks.TaskProvider
+import java.io.File
+
+class VariantTaskProvider(val project: Project) {
+    fun bundleTaskProvider(
+        project: Project,
+        variantName: String,
+    ): TaskProvider<Task> {
+        var bundleTaskPath = "bundle${variantName.capitalized()}"
+        return try {
+            project.tasks.named(bundleTaskPath)
+        } catch (_: UnknownTaskException) {
+            bundleTaskPath += "Aar"
+            project.tasks.named(bundleTaskPath)
+        }
+    }
+
+    fun processDataBinding(
+        bundleTask: TaskProvider<Task>,
+        aarLibraries: Collection<AndroidArchiveLibrary>,
+        variantName: String,
+    ) {
+        bundleTask.configure { task ->
+            task.doLast {
+                aarLibraries.forEach {
+                    val dataBindingFolder = it.getDataBindingFolder()
+                    if (dataBindingFolder.exists()) {
+                        val filePath = getReBundleFilePath(dataBindingFolder.name, variantName)
+                        File(filePath).mkdirs()
+                        project.copy { copyTask ->
+                            copyTask.from(dataBindingFolder)
+                            copyTask.into(filePath)
+                        }
+                    }
+
+                    val dataBindingLogFolder = it.getDataBindingLogFolder()
+                    if (dataBindingLogFolder.exists()) {
+                        val filePath = getReBundleFilePath(dataBindingLogFolder.name, variantName)
+                        File(filePath).mkdirs()
+                        project.copy { copyTask ->
+                            copyTask.from(dataBindingLogFolder)
+                            copyTask.into(filePath)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun getReBundleFilePath(
+        folderName: String,
+        variantName: String,
+    ) = "${DirectoryManager.getReBundleDirectory(
+        variantName,
+    ).path}/$folderName"
+
+    fun preBuildTaskByVariant(
+        variantName: String,
+        buildTypeName: String,
+        isVariantDebuggable: Boolean,
+        explodeAarTask: TaskProvider<ExplodeAarTask>,
+    ) {
+        val preBuildTaskPath = "pre${variantName.capitalized()}Build"
+        val preBuildTask = project.tasks.named(preBuildTaskPath)
+
+        if (!preBuildTask.isPresent) {
+            throw TaskNotFound("Can not find $preBuildTaskPath task")
+        }
+
+        preBuildTask.dependsOn(explodeAarTask)
+
+        val bundledAssetsVariantName =
+            Utils.getBundledAssetsVariantName(
+                variantName = variantName,
+                buildTypeName = buildTypeName,
+                isDebuggable = isVariantDebuggable,
+            )
+        val capitalizedBundledAssetsVariantName = bundledAssetsVariantName.capitalized()
+
+        val projectExt = project.extensions.getByType(Extension::class.java)
+        val appProject = project.rootProject.project(projectExt.appProjectName)
+        preBuildTask.dependsOn("${appProject.path}:createBundle${capitalizedBundledAssetsVariantName}JsAndAssets")
+
+        if (Utils.isExpoProject(project)) {
+            preBuildTask.dependsOn(
+                "${appProject.path}:create${capitalizedBundledAssetsVariantName}UpdatesResources",
+            )
+        }
+    }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/BaseProject.kt

@@ -0,0 +1,17 @@
+package com.callstack.react.brownfield.shared
+
+import org.gradle.api.Project
+import org.gradle.api.file.Directory
+
+open class BaseProject {
+    private var _project: Project? = null
+
+    var project: Project
+        get() = checkNotNull(_project) { "Project has not been initialized" }
+        set(value) {
+            _project = value
+        }
+
+    val buildDir: Directory
+        get() = project.layout.buildDirectory.get()
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/BundleTaskProvider.kt

@@ -0,0 +1,46 @@
+@file:Suppress("DEPRECATION")
+
+package com.callstack.react.brownfield.shared
+
+import com.android.build.gradle.LibraryExtension
+import com.android.build.gradle.api.LibraryVariant
+import com.callstack.react.brownfield.processors.VariantTaskProvider
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.tasks.TaskProvider
+
+class BundleTaskProvider(private val variantTaskProvider: VariantTaskProvider) {
+    fun getBundleTask(
+        project: Project,
+        variant: LibraryVariant,
+    ): TaskProvider<Task>? {
+        val androidExtension = project.extensions.getByType(LibraryExtension::class.java)
+
+        // Find the first variant in the library that matches our criteria
+        val matchedVariant =
+            androidExtension.libraryVariants.find { libraryVariant ->
+                // 1. Try Simple Match
+                if (libraryVariant.name == variant.name || libraryVariant.name == variant.buildType.name) {
+                    return@find true
+                }
+
+                // 2. Try Dimension Strategy Match
+                val flavor = variant.productFlavors.firstOrNull() ?: variant.mergedFlavor
+                val strategies =
+                    runCatching {
+                        androidExtension.productFlavors.getByName(flavor.name).missingDimensionStrategies
+                    }.getOrNull() ?: return@find false
+
+                strategies.any { (dimension, strategy) ->
+                    val fallbacks = listOf(strategy.requested) + strategy.fallbacks
+                    val libFlavor = libraryVariant.productFlavors.firstOrNull() ?: libraryVariant.mergedFlavor
+
+                    dimension == libFlavor.dimension &&
+                        fallbacks.contains(libFlavor.name) &&
+                        variant.buildType.name == libraryVariant.buildType.name
+                }
+            }
+
+        return matchedVariant?.let { variantTaskProvider.bundleTaskProvider(project, it.name) }
+    }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/Constants.kt

@@ -0,0 +1,58 @@
+package com.callstack.react.brownfield.shared
+
+import com.callstack.react.brownfield.expo.utils.DependencyInfo
+import com.callstack.react.brownfield.utils.StringMatcher
+
+/**
+ * A condition that checks if a certain Expo version meets specific criteria
+ * and returns a set of DependencyInfo objects if applicable.
+ */
+fun interface ExpoVersionConditionalDepSet {
+    /**
+     * Gets the dependency set if it is applicable for the given Expo version.
+     * @param expoVersion The Expo version to check.
+     * @return A set of DependencyInfo objects if the condition is met; otherwise, null.
+     */
+    fun getIfApplicable(expoVersion: String): Set<DependencyInfo>?
+}
+
+data class ArtifactMatcher(
+    val groupId: StringMatcher? = null,
+    val artifactId: StringMatcher? = null,
+) {
+    fun matches(
+        groupId: String,
+        artifactId: String,
+    ): Boolean {
+        val groupMatches = groupIdMatcher()?.matches(groupId) ?: true
+        val artifactMatches = artifactIdMatcher()?.matches(artifactId) ?: true
+        return groupMatches && artifactMatches
+    }
+
+    private fun groupIdMatcher(): StringMatcher? = groupId
+
+    private fun artifactIdMatcher(): StringMatcher? = artifactId
+}
+
+object Constants {
+    const val PROJECT_ID = "com.callstack.react.brownfield"
+    const val PLUGIN_NAME = "react-brownfield"
+
+    const val RE_BUNDLE_FOLDER = "aar_rebundle"
+    const val INTERMEDIATES_TEMP_DIR = PLUGIN_NAME
+
+    val BROWNFIELD_EXPO_TRANSITIVE_DEPS_WHITELISTED_MODULES_FOR_DISCOVERY =
+        setOf("expo-modules-core", "expo-constants", "expo", "expo-updates")
+    val BROWNFIELD_EXPO_TRANSITIVE_DEPS_ARTIFACTS_BLACKLIST =
+        setOf(
+            // below: groupIds of Expo components in node_modules
+            ArtifactMatcher(groupId = StringMatcher.literal("host.exp.exponent")),
+            ArtifactMatcher(groupId = StringMatcher.literal("BareExpo")),
+            ArtifactMatcher(groupId = StringMatcher.regex("expo.*")),
+            // below: a broken transitive dependency that has no version specified and thus breaks the build
+            ArtifactMatcher(
+                groupId = StringMatcher.literal("org.jetbrains.kotlin"),
+                artifactId = StringMatcher.literal("kotlin-build-tools-impl"),
+            ),
+        )
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/ExplodeAarTask.kt

@@ -0,0 +1,72 @@
+package com.callstack.react.brownfield.shared
+
+import com.callstack.react.brownfield.processors.VariantHelper
+import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
+import com.callstack.react.brownfield.utils.DirectoryManager
+import org.gradle.api.DefaultTask
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.TaskAction
+
+abstract class ExplodeAarTask : DefaultTask() {
+    @get:Internal
+    abstract val inputArtifacts: ListProperty<UnresolvedArtifactInfo>
+
+    @get:Input
+    abstract val variantName: Property<String>
+
+    @get:Input
+    abstract val minifyEnabled: Property<Boolean>
+
+    @TaskAction
+    fun run() {
+        val artifacts = inputArtifacts.get()
+        val resolvedVariantName = variantName.get()
+
+        val variantHelper = VariantHelper()
+        variantHelper.project = project
+
+        // classes-merge
+        variantHelper.classesMergeTaskDoFirst(
+            DirectoryManager.getMergeClassDirectory(
+                resolvedVariantName,
+            ),
+            resolvedVariantName,
+        )
+
+        val aarLibraries = mutableListOf<AndroidArchiveLibrary>()
+        artifacts.forEach { art ->
+            val artifactFile =
+                requireNotNull(art.file) {
+                    "Missing AAR file for artifact ${art.moduleGroup}:${art.moduleName}:${art.moduleVersion} " +
+                        "while exploding variant $resolvedVariantName. Ensure the artifact is resolved " +
+                        "or the dependency is configured to produce an AAR before running this task."
+                }
+
+            val archiveLibrary =
+                AndroidArchiveLibrary(
+                    this.project,
+                    art,
+                    resolvedVariantName,
+                )
+
+            aarLibraries.add(archiveLibrary)
+
+            // explode-aar
+            val zipFolder = archiveLibrary.getExplodedAarRootDir()
+            zipFolder.mkdirs()
+
+            project.copy {
+                zipFolder.deleteRecursively()
+                it.from(project.zipTree(artifactFile))
+                it.into(zipFolder)
+            }
+        }
+
+        // classes-merge
+        val mergeClassesOutputDir = DirectoryManager.getMergeClassDirectory(resolvedVariantName)
+        variantHelper.classesMergeTaskDoLast(mergeClassesOutputDir, aarLibraries, mutableListOf(), resolvedVariantName, minifyEnabled.get())
+    }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/GradleILogger.kt

@@ -0,0 +1,59 @@
+package com.callstack.react.brownfield.shared
+
+import com.android.utils.ILogger
+import org.gradle.api.logging.Logger
+import java.util.IllegalFormatException
+
+class GradleILogger(
+    private val logger: Logger,
+) : ILogger {
+    override fun error(
+        throwable: Throwable?,
+        msgFormat: String?,
+        vararg args: Any?,
+    ) {
+        val message = formatMessage(msgFormat, args)
+        logger.error(message, throwable)
+    }
+
+    override fun warning(
+        msgFormat: String?,
+        vararg args: Any?,
+    ) {
+        logger.warn(formatMessage(msgFormat, args))
+    }
+
+    override fun info(
+        msgFormat: String?,
+        vararg args: Any?,
+    ) {
+        logger.info(formatMessage(msgFormat, args))
+    }
+
+    override fun verbose(
+        msgFormat: String?,
+        vararg args: Any?,
+    ) {
+        logger.debug(formatMessage(msgFormat, args))
+    }
+
+    @Suppress("SpreadOperator") // Required for Java vararg interop with String.format.
+    private fun formatMessage(
+        msgFormat: String?,
+        args: Array<out Any?>,
+    ): String {
+        if (msgFormat == null) {
+            return ""
+        }
+
+        return try {
+            if (args.isEmpty()) {
+                msgFormat
+            } else {
+                String.format(msgFormat, *args)
+            }
+        } catch (_: IllegalFormatException) {
+            msgFormat
+        }
+    }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/Logging.kt

@@ -0,0 +1,24 @@
+package com.callstack.react.brownfield.shared
+
+import com.callstack.react.brownfield.shared.Constants.PLUGIN_NAME
+
+object Logging : BaseProject() {
+    fun error(
+        message: Any,
+        error: Throwable,
+    ) {
+        project.logger.error(getFormattedMessage(message), error)
+    }
+
+    fun info(message: Any) {
+        project.logger.info(getFormattedMessage(message))
+    }
+
+    fun log(message: Any) {
+        println(getFormattedMessage(message))
+    }
+
+    private fun getFormattedMessage(message: Any): String {
+        return " $PLUGIN_NAME :: $message"
+    }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/shared/ModuleInfo.kt

@@ -0,0 +1,22 @@
+package com.callstack.react.brownfield.shared
+
+interface ModuleInfo {
+    val moduleGroup: String
+    val moduleName: String
+    val moduleVersion: String
+
+    val file: String?
+
+    val type: String
+        get() = "aar"
+
+    val isExpoPublishDependency: Boolean?
+}
+
+data class UnresolvedArtifactInfo(
+    override val moduleGroup: String,
+    override val moduleName: String,
+    override val moduleVersion: String,
+    override val file: String?,
+    override val isExpoPublishDependency: Boolean?,
+) : ModuleInfo

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/utils/AndroidArchiveLibrary.kt

@@ -0,0 +1,77 @@
+package com.callstack.react.brownfield.utils
+
+import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
+import org.gradle.api.Project
+import java.io.File
+
+class AndroidArchiveLibrary(
+    private val project: Project,
+    artifact: UnresolvedArtifactInfo,
+    private val variantName: String,
+) {
+    private var packageName: String? = null
+    private val artifact: UnresolvedArtifactInfo =
+        requireNotNull(artifact.takeIf { it.type == "aar" }) {
+            "Only Aar is accepted as an artifact"
+        }
+
+    fun getExplodedAarRootDir(): File {
+        val explodedRootDir = File("${project.layout.buildDirectory.get()}/intermediates/exploded-aar")
+        return File(explodedRootDir, "${artifact.moduleGroup}/${artifact.moduleName}/${artifact.moduleVersion}/$variantName")
+    }
+
+    @Synchronized
+    fun getPackageName(): String {
+        if (packageName != null) return packageName!!
+
+        packageName = getNameSpaceFromBuildGradle()
+        return packageName!!
+    }
+
+    private fun getNameSpaceFromBuildGradle(): String {
+        if (artifact.isExpoPublishDependency == true) {
+            return artifact.moduleGroup
+        }
+
+        val subProj = project.rootProject.project(":${artifact.moduleName}")
+        val buildFile = subProj.buildFile // points to build.gradle or build.gradle.kts
+
+        if (!buildFile.exists()) {
+            error("build.gradle file does not exist for ${artifact.moduleName}")
+        }
+
+        val text = buildFile.readText()
+
+        // Regex to match: namespace = "com.example.rnscreens"
+        val regex = Regex("""namespace\s*=?\s*["']([^"']+)["']""")
+        val match = regex.find(text)
+
+        val namespace =
+            match?.groupValues?.get(1)
+                ?: error("No namespace found in ${buildFile.path}")
+
+        return namespace
+    }
+
+    fun getManifestFile() = File(getExplodedAarRootDir(), "AndroidManifest.xml")
+
+    fun getAssetsDir(): File = File(getExplodedAarRootDir(), "assets")
+
+    fun getJniDir(): File = File(getExplodedAarRootDir(), "jni")
+
+    fun getLibsDir(): File = File(getExplodedAarRootDir(), "libs")
+
+    fun getClassesJarFile(): File = File(getExplodedAarRootDir(), "classes.jar")
+
+    fun getLocalJars(): Collection<File> {
+        return getLibsDir().listFiles()?.filter { it.isFile && it.name.endsWith(".jar") } ?: emptyList()
+    }
+
+    fun getResDir(): File = File(getExplodedAarRootDir(), "res")
+
+    fun getProguardRules(): File = File(getExplodedAarRootDir(), "proguard.txt")
+
+    fun getDataBindingFolder(): File = File(getExplodedAarRootDir(), "data-binding")
+
+    fun getDataBindingLogFolder(): File = File(getExplodedAarRootDir(), "data-binding-base-class-log")
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/utils/DirectoryManager.kt

@@ -0,0 +1,20 @@
+package com.callstack.react.brownfield.utils
+
+import com.callstack.react.brownfield.shared.BaseProject
+import com.callstack.react.brownfield.shared.Constants.INTERMEDIATES_TEMP_DIR
+import com.callstack.react.brownfield.shared.Constants.RE_BUNDLE_FOLDER
+import java.io.File
+
+object DirectoryManager : BaseProject() {
+    fun getMergeClassDirectory(variantName: String): File {
+        return project.file("$buildDir/intermediates/$INTERMEDIATES_TEMP_DIR/merge_classes/$variantName")
+    }
+
+    fun getKotlinMetaDirectory(variantName: String): File {
+        return project.file("$buildDir/tmp/kotlin-classes/$variantName/META-INF")
+    }
+
+    fun getReBundleDirectory(variantName: String): File {
+        return project.file("$buildDir/outputs/$RE_BUNDLE_FOLDER/$variantName")
+    }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/utils/Extension.kt

@@ -0,0 +1,44 @@
+package com.callstack.react.brownfield.utils
+
+open class Extension {
+    companion object {
+        const val NAME = "reactBrownfield"
+    }
+
+    /**
+     * Name of the module using `com.android.application`
+     * For eg, app
+     *
+     * Default value is `app`
+     */
+    var appProjectName = "app"
+
+    /**
+     * List of dynamic libs (.so) files that you wish to bundle with
+     * the aar.
+     *
+     * By default, only `libappmodules.so` and `libreact_codegen_*.so` are
+     * bundled.
+     */
+    var dynamicLibs = listOf<String>()
+
+    /**
+     * Whether to use stripped .so files.
+     *
+     * Default is `true`.
+     */
+    var useStrippedSoFiles = true
+
+    @Deprecated(
+        message =
+            "This property is deprecated and will be removed in a future release." +
+                "The successor is useStrippedSoFiles, which is by default true.",
+        replaceWith = ReplaceWith("useStrippedSoFiles"),
+        level = DeprecationLevel.WARNING,
+    )
+    var experimentalUseStrippedSoFiles
+        get() = useStrippedSoFiles
+        set(value) {
+            useStrippedSoFiles = value
+        }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/utils/StringExtensions.kt

@@ -0,0 +1,5 @@
+package com.callstack.react.brownfield.utils
+
+fun String.capitalized(): String {
+    return this.replaceFirstChar(Char::titlecase)
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/utils/StringMatcher.kt

@@ -0,0 +1,21 @@
+package com.callstack.react.brownfield.utils
+
+sealed class StringMatcher {
+    abstract fun matches(input: String): Boolean
+
+    data class Literal(private val value: String) : StringMatcher() {
+        override fun matches(input: String): Boolean = input == value
+    }
+
+    data class Pattern(private val regex: Regex) : StringMatcher() {
+        override fun matches(input: String): Boolean = regex.matches(input)
+    }
+
+    companion object {
+        fun literal(value: String): StringMatcher = Literal(value)
+
+        fun regex(pattern: String): StringMatcher = Pattern(Regex(pattern))
+
+        fun regex(regex: Regex): StringMatcher = Pattern(regex)
+    }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/utils/Utils.kt

@@ -0,0 +1,59 @@
+package com.callstack.react.brownfield.utils
+
+import com.callstack.react.brownfield.plugin.RNBrownfieldPlugin.Companion.EXPO_PROJECT_LOCATOR
+import org.gradle.api.Project
+import java.io.File
+
+object Utils {
+    fun mergeFiles(
+        inputFiles: Collection<File>?,
+        output: File,
+    ) {
+        if (inputFiles.isNullOrEmpty()) return
+
+        val existingFiles = inputFiles.filter { it.exists() }
+
+        if (existingFiles.isEmpty()) return
+
+        if (!output.exists()) {
+            output.createNewFile()
+        }
+
+        existingFiles.forEach { file ->
+            output.appendText("\n${file.readText(Charsets.UTF_8)}\n")
+        }
+    }
+
+    fun isExpoProject(project: Project): Boolean {
+        return project.findProject(EXPO_PROJECT_LOCATOR) != null
+    }
+
+    fun getBundledAssetsVariantName(
+        variantName: String?,
+        buildTypeName: String?,
+        isDebuggable: Boolean,
+    ): String {
+        require(!variantName.isNullOrEmpty()) {
+            "getBundledAssetsVariantName: Variant name cannot be empty"
+        }
+
+        require(!buildTypeName.isNullOrEmpty()) {
+            "getBundledAssetsVariantName: Build Type cannot be empty"
+        }
+
+        if (!isDebuggable) {
+            return variantName
+        }
+
+        if (variantName == buildTypeName) {
+            return "release"
+        }
+
+        val capitalizedBuildTypeName = buildTypeName.capitalized()
+        return if (variantName.endsWith(capitalizedBuildTypeName)) {
+            "${variantName.removeSuffix(capitalizedBuildTypeName)}Release"
+        } else {
+            "release"
+        }
+    }
+}

package/ios/Expo/ExpoHostRuntime.swift

@@ -102,7 +102,7 @@ final class ExpoHostRuntime {
   }
 
   /**
-   * Prefer the embedded JavaScript bundle instead of Metro when this framework is built in Debug.
+   * Use the embedded JavaScript bundle as a Debug fallback when Metro is unavailable.
    * Default value: false
    */
   public var preferEmbeddedBundleInDebug: Bool = false {
@@ -232,7 +232,8 @@ class ExpoHostRuntimeDelegate: ExpoReactNativeFactoryDelegate {
         bundleURLOverride: nil,
         metroURL: {
           RCTBundleURLProvider.sharedSettings().jsBundleURL(
-            forBundleRoot: entryFile
+            forBundleRoot: entryFile,
+            fallbackURLProvider: { nil }
           )
         }
       )