@react-native/gradle-plugin 0.72.2 → 0.72.4

package/build.gradle.kts

@@ -33,7 +33,7 @@ group = "com.facebook.react"
 
 dependencies {
   implementation(gradleApi())
-  implementation("com.android.tools.build:gradle:7.4.0-beta05")
+  implementation("com.android.tools.build:gradle:7.4.1")
   implementation("com.google.code.gson:gson:2.8.9")
   implementation("com.google.guava:guava:31.0.1-jre")
   implementation("com.squareup:javapoet:1.13.0")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native/gradle-plugin",
-  "version": "0.72.2",
+  "version": "0.72.4",
   "description": "⚛️ Gradle Plugin for React Native",
   "homepage": "https://github.com/facebook/react-native/tree/HEAD/packages/react-native-gradle-plugin",
   "repository": {

package/src/main/kotlin/com/facebook/react/ReactExtension.kt

@@ -89,7 +89,7 @@ abstract class ReactExtension @Inject constructor(project: Project) {
    * will:
    * - Not be bundled (the bundle file will not be created and won't be copied over).
    * - Have the Hermes Debug flags set. That's useful if you have another variant (say `canary`)
-   * where you want dev mode to be enabled. Default: ['debug']
+   *   where you want dev mode to be enabled. Default: ['debug']
    */
   val debuggableVariants: ListProperty<String> =
       objects.listProperty(String::class.java).convention(listOf("debug"))
@@ -129,9 +129,9 @@ abstract class ReactExtension @Inject constructor(project: Project) {
   /**
    * The root directory for all JS files for the app.
    *
-   * Default: [root] (i.e. ${rootProject.dir}/../)
+   * Default: the parent folder of the `/android` folder.
    */
-  val jsRootDir: DirectoryProperty = objects.directoryProperty().convention(root.get())
+  val jsRootDir: DirectoryProperty = objects.directoryProperty()
 
   /**
    * The library name that will be used for the codegen artifacts.

package/src/main/kotlin/com/facebook/react/ReactPlugin.kt

@@ -9,6 +9,7 @@ package com.facebook.react
 
 import com.android.build.api.variant.AndroidComponentsExtension
 import com.android.build.gradle.internal.tasks.factory.dependsOn
+import com.facebook.react.internal.PrivateReactExtension
 import com.facebook.react.tasks.BuildCodegenCLITask
 import com.facebook.react.tasks.GenerateCodegenArtifactsTask
 import com.facebook.react.tasks.GenerateCodegenSchemaTask
@@ -34,8 +35,22 @@ class ReactPlugin : Plugin<Project> {
     checkJvmVersion(project)
     val extension = project.extensions.create("react", ReactExtension::class.java, project)
 
+    // We register a private extension on the rootProject so that project wide configs
+    // like codegen config can be propagated from app project to libraries.
+    val rootExtension =
+        project.rootProject.extensions.findByType(PrivateReactExtension::class.java)
+            ?: project.rootProject.extensions.create(
+                "privateReact", PrivateReactExtension::class.java, project)
+
     // App Only Configuration
     project.pluginManager.withPlugin("com.android.application") {
+      // We wire the root extension with the values coming from the app (either user populated or
+      // defaults).
+      rootExtension.root.set(extension.root)
+      rootExtension.reactNativeDir.set(extension.reactNativeDir)
+      rootExtension.codegenDir.set(extension.codegenDir)
+      rootExtension.nodeExecutableAndArgs.set(extension.nodeExecutableAndArgs)
+
       project.afterEvaluate {
         val reactNativeDir = extension.reactNativeDir.get().asFile
         val propertiesFile = File(reactNativeDir, "ReactAndroid/gradle.properties")
@@ -54,12 +69,12 @@ class ReactPlugin : Plugin<Project> {
           project.configureReactTasks(variant = variant, config = extension)
         }
       }
-      configureCodegen(project, extension, isLibrary = false)
+      configureCodegen(project, extension, rootExtension, isLibrary = false)
     }
 
     // Library Only Configuration
     project.pluginManager.withPlugin("com.android.library") {
-      configureCodegen(project, extension, isLibrary = true)
+      configureCodegen(project, extension, rootExtension, isLibrary = true)
     }
   }
 
@@ -82,25 +97,36 @@ class ReactPlugin : Plugin<Project> {
     }
   }
 
-  /**
-   * A plugin to enable react-native-codegen in Gradle environment. See the Gradle API docs for more
-   * information: https://docs.gradle.org/current/javadoc/org/gradle/api/Project.html
-   */
+  /** This function sets up `react-native-codegen` in our Gradle plugin. */
   @Suppress("UnstableApiUsage")
-  private fun configureCodegen(project: Project, extension: ReactExtension, isLibrary: Boolean) {
+  private fun configureCodegen(
+      project: Project,
+      localExtension: ReactExtension,
+      rootExtension: PrivateReactExtension,
+      isLibrary: Boolean
+  ) {
     // First, we set up the output dir for the codegen.
     val generatedSrcDir = File(project.buildDir, "generated/source/codegen")
 
+    // We specify the default value (convention) for jsRootDir.
+    // It's the root folder for apps (so ../../ from the Gradle project)
+    // and the package folder for library (so ../ from the Gradle project)
+    if (isLibrary) {
+      localExtension.jsRootDir.convention(project.layout.projectDirectory.dir("../"))
+    } else {
+      localExtension.jsRootDir.convention(localExtension.root)
+    }
+
     val buildCodegenTask =
         project.tasks.register("buildCodegenCLI", BuildCodegenCLITask::class.java) {
-          it.codegenDir.set(extension.codegenDir)
+          it.codegenDir.set(rootExtension.codegenDir)
           val bashWindowsHome = project.findProperty("REACT_WINDOWS_BASH") as String?
           it.bashWindowsHome.set(bashWindowsHome)
 
           // Please note that appNeedsCodegen is triggering a read of the package.json at
           // configuration time as we need to feed the onlyIf condition of this task.
           // Therefore, the appNeedsCodegen needs to be invoked inside this lambda.
-          val needsCodegenFromPackageJson = project.needsCodegenFromPackageJson(extension)
+          val needsCodegenFromPackageJson = project.needsCodegenFromPackageJson(rootExtension.root)
           it.onlyIf { isLibrary || needsCodegenFromPackageJson }
         }
 
@@ -109,23 +135,24 @@ class ReactPlugin : Plugin<Project> {
         project.tasks.register(
             "generateCodegenSchemaFromJavaScript", GenerateCodegenSchemaTask::class.java) { it ->
               it.dependsOn(buildCodegenTask)
-              it.nodeExecutableAndArgs.set(extension.nodeExecutableAndArgs)
-              it.codegenDir.set(extension.codegenDir)
+              it.nodeExecutableAndArgs.set(rootExtension.nodeExecutableAndArgs)
+              it.codegenDir.set(rootExtension.codegenDir)
               it.generatedSrcDir.set(generatedSrcDir)
 
               // We're reading the package.json at configuration time to properly feed
               // the `jsRootDir` @Input property of this task & the onlyIf. Therefore, the
               // parsePackageJson should be invoked inside this lambda.
-              val packageJson = findPackageJsonFile(project, extension)
+              val packageJson = findPackageJsonFile(project, rootExtension.root)
               val parsedPackageJson = packageJson?.let { JsonUtils.fromCodegenJson(it) }
 
               val jsSrcsDirInPackageJson = parsedPackageJson?.codegenConfig?.jsSrcsDir
               if (jsSrcsDirInPackageJson != null) {
                 it.jsRootDir.set(File(packageJson.parentFile, jsSrcsDirInPackageJson))
               } else {
-                it.jsRootDir.set(extension.jsRootDir)
+                it.jsRootDir.set(localExtension.jsRootDir)
               }
-              val needsCodegenFromPackageJson = project.needsCodegenFromPackageJson(extension)
+              val needsCodegenFromPackageJson =
+                  project.needsCodegenFromPackageJson(rootExtension.root)
               it.onlyIf { isLibrary || needsCodegenFromPackageJson }
             }
 
@@ -134,17 +161,18 @@ class ReactPlugin : Plugin<Project> {
         project.tasks.register(
             "generateCodegenArtifactsFromSchema", GenerateCodegenArtifactsTask::class.java) {
               it.dependsOn(generateCodegenSchemaTask)
-              it.reactNativeDir.set(extension.reactNativeDir)
-              it.nodeExecutableAndArgs.set(extension.nodeExecutableAndArgs)
+              it.reactNativeDir.set(rootExtension.reactNativeDir)
+              it.nodeExecutableAndArgs.set(rootExtension.nodeExecutableAndArgs)
               it.generatedSrcDir.set(generatedSrcDir)
-              it.packageJsonFile.set(findPackageJsonFile(project, extension))
-              it.codegenJavaPackageName.set(extension.codegenJavaPackageName)
-              it.libraryName.set(extension.libraryName)
+              it.packageJsonFile.set(findPackageJsonFile(project, rootExtension.root))
+              it.codegenJavaPackageName.set(localExtension.codegenJavaPackageName)
+              it.libraryName.set(localExtension.libraryName)
 
               // Please note that appNeedsCodegen is triggering a read of the package.json at
               // configuration time as we need to feed the onlyIf condition of this task.
               // Therefore, the appNeedsCodegen needs to be invoked inside this lambda.
-              val needsCodegenFromPackageJson = project.needsCodegenFromPackageJson(extension)
+              val needsCodegenFromPackageJson =
+                  project.needsCodegenFromPackageJson(rootExtension.root)
               it.onlyIf { isLibrary || needsCodegenFromPackageJson }
             }
 

package/src/main/kotlin/com/facebook/react/TaskConfiguration.kt

@@ -22,14 +22,16 @@ internal fun Project.configureReactTasks(variant: Variant, config: ReactExtensio
   val targetName = variant.name.replaceFirstChar { it.uppercase() }
   val targetPath = variant.name
 
-  // React js bundle directories
+  // Resources: generated/assets/react/<variant>/index.android.bundle
   val resourcesDir = File(buildDir, "generated/res/react/$targetPath")
-  // Bundle: generated/assets/react/path/index.android.bundle
+  // Bundle: generated/assets/react/<variant>/index.android.bundle
   val jsBundleDir = File(buildDir, "generated/assets/react/$targetPath")
-  // Sourcemap: generated/sourcemaps/react/path/index.android.bundle.map
+  // Sourcemap: generated/sourcemaps/react/<variant>/index.android.bundle.map
   val jsSourceMapsDir = File(buildDir, "generated/sourcemaps/react/$targetPath")
-  // Intermediate packager: intermediates/sourcemaps/react/path/index.android.bundle.packager.map
-  // Intermediate compiler: intermediates/sourcemaps/react/path/index.android.bundle.compiler.map
+  // Intermediate packager:
+  // intermediates/sourcemaps/react/<variant>/index.android.bundle.packager.map
+  // Intermediate compiler:
+  // intermediates/sourcemaps/react/<variant>/index.android.bundle.compiler.map
   val jsIntermediateSourceMapsDir = File(buildDir, "intermediates/sourcemaps/react/$targetPath")
 
   // The location of the cli.js file for React Native
@@ -49,13 +51,14 @@ internal fun Project.configureReactTasks(variant: Variant, config: ReactExtensio
   configureJsEnginePackagingOptions(config, variant, isHermesEnabledInThisVariant)
 
   if (!isDebuggableVariant) {
+    val entryFileEnvVariable = System.getenv("ENTRY_FILE")
     val bundleTask =
         tasks.register("createBundle${targetName}JsAndAssets", BundleHermesCTask::class.java) {
           it.root.set(config.root)
           it.nodeExecutableAndArgs.set(config.nodeExecutableAndArgs)
           it.cliFile.set(cliFile)
           it.bundleCommand.set(config.bundleCommand)
-          it.entryFile.set(detectedEntryFile(config))
+          it.entryFile.set(detectedEntryFile(config, entryFileEnvVariable))
           it.extraPackagerArgs.set(config.extraPackagerArgs)
           it.bundleConfig.set(config.bundleConfig)
           it.bundleAssetName.set(config.bundleAssetName)

package/src/main/kotlin/com/facebook/react/internal/PrivateReactExtension.kt

@@ -0,0 +1,56 @@
+/*
+ * 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.internal
+
+import javax.inject.Inject
+import org.gradle.api.Project
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.ListProperty
+
+/**
+ * A private extension we set on the rootProject to make easier to share values at execution time
+ * between app project and library project.
+ *
+ * Specifically, the [codegenDir], [reactNativeDir] and other properties should be provided by apps
+ * (for setups like a monorepo which are app specific) and libraries should honor those values.
+ *
+ * Users are not supposed to access directly this extension from their build.gradle file.
+ */
+abstract class PrivateReactExtension @Inject constructor(project: Project) {
+
+  private val objects = project.objects
+
+  val root: DirectoryProperty =
+      objects
+          .directoryProperty()
+          .convention(
+              // This is the default for the project root if the users hasn't specified anything.
+              // If the project is called "react-native-github"
+              //   - We're inside the Github Repo -> root is defined by RN Tester (so no default
+              // needed)
+              //   - We're inside an includedBuild as we're performing a build from source
+              //     (then we're inside `node_modules/react-native`, so default should be ../../)
+              // If the project is called in any other name
+              //   - We're inside a user project, so inside the ./android folder. Default should be
+              // ../
+              // User can always override this default by setting a `root =` inside the template.
+              if (project.rootProject.name == "react-native-github") {
+                project.rootProject.layout.projectDirectory.dir("../../")
+              } else {
+                project.rootProject.layout.projectDirectory.dir("../")
+              })
+
+  val reactNativeDir: DirectoryProperty =
+      objects.directoryProperty().convention(root.dir("node_modules/react-native"))
+
+  val nodeExecutableAndArgs: ListProperty<String> =
+      objects.listProperty(String::class.java).convention(listOf("node"))
+
+  val codegenDir: DirectoryProperty =
+      objects.directoryProperty().convention(root.dir("node_modules/@react-native/codegen"))
+}

package/src/main/kotlin/com/facebook/react/tasks/BundleHermesCTask.kt

@@ -7,6 +7,7 @@
 
 package com.facebook.react.tasks
 
+import com.facebook.react.utils.Os.cliPath
 import com.facebook.react.utils.detectOSAwareHermesCommand
 import com.facebook.react.utils.moveTo
 import com.facebook.react.utils.windowsAwareCommandLine
@@ -135,8 +136,9 @@ abstract class BundleHermesCTask : DefaultTask() {
   internal fun getBundleCommand(bundleFile: File, sourceMapFile: File): List<Any> =
       windowsAwareCommandLine(
           buildList {
+            val rootFile = root.get().asFile
             addAll(nodeExecutableAndArgs.get())
-            add(cliFile.get().asFile.absolutePath)
+            add(cliFile.get().asFile.cliPath(rootFile))
             add(bundleCommand.get())
             add("--platform")
             add("android")
@@ -144,16 +146,16 @@ abstract class BundleHermesCTask : DefaultTask() {
             add(devEnabled.get().toString())
             add("--reset-cache")
             add("--entry-file")
-            add(entryFile.get().asFile.toString())
+            add(entryFile.get().asFile.cliPath(rootFile))
             add("--bundle-output")
-            add(bundleFile.toString())
+            add(bundleFile.cliPath(rootFile))
             add("--assets-dest")
-            add(resourcesDir.get().asFile.toString())
+            add(resourcesDir.get().asFile.cliPath(rootFile))
             add("--sourcemap-output")
-            add(sourceMapFile.toString())
+            add(sourceMapFile.cliPath(rootFile))
             if (bundleConfig.isPresent) {
               add("--config")
-              add(bundleConfig.get().asFile.absolutePath)
+              add(bundleConfig.get().asFile.cliPath(rootFile))
             }
             add("--minify")
             add(minifyEnabled.get().toString())
@@ -165,26 +167,30 @@ abstract class BundleHermesCTask : DefaultTask() {
       hermesCommand: String,
       bytecodeFile: File,
       bundleFile: File
-  ): List<Any> =
-      windowsAwareCommandLine(
-          hermesCommand,
-          "-emit-binary",
-          "-out",
-          bytecodeFile.absolutePath,
-          bundleFile.absolutePath,
-          *hermesFlags.get().toTypedArray())
+  ): List<Any> {
+    val rootFile = root.get().asFile
+    return windowsAwareCommandLine(
+        hermesCommand,
+        "-emit-binary",
+        "-out",
+        bytecodeFile.cliPath(rootFile),
+        bundleFile.cliPath(rootFile),
+        *hermesFlags.get().toTypedArray())
+  }
 
   internal fun getComposeSourceMapsCommand(
       composeScript: File,
       packagerSourceMap: File,
       compilerSourceMap: File,
       outputSourceMap: File
-  ): List<Any> =
-      windowsAwareCommandLine(
-          *nodeExecutableAndArgs.get().toTypedArray(),
-          composeScript.absolutePath,
-          packagerSourceMap.toString(),
-          compilerSourceMap.toString(),
-          "-o",
-          outputSourceMap.toString())
+  ): List<Any> {
+    val rootFile = root.get().asFile
+    return windowsAwareCommandLine(
+        *nodeExecutableAndArgs.get().toTypedArray(),
+        composeScript.cliPath(rootFile),
+        packagerSourceMap.cliPath(rootFile),
+        compilerSourceMap.cliPath(rootFile),
+        "-o",
+        outputSourceMap.cliPath(rootFile))
+  }
 }

package/src/main/kotlin/com/facebook/react/tasks/GenerateCodegenArtifactsTask.kt

@@ -8,6 +8,7 @@
 package com.facebook.react.tasks
 
 import com.facebook.react.utils.JsonUtils
+import com.facebook.react.utils.Os.cliPath
 import com.facebook.react.utils.windowsAwareCommandLine
 import org.gradle.api.file.Directory
 import org.gradle.api.file.DirectoryProperty
@@ -63,16 +64,17 @@ abstract class GenerateCodegenArtifactsTask : Exec() {
   }
 
   internal fun setupCommandLine(libraryName: String, codegenJavaPackageName: String) {
+    val workingDir = project.projectDir
     commandLine(
         windowsAwareCommandLine(
             *nodeExecutableAndArgs.get().toTypedArray(),
-            reactNativeDir.file("scripts/generate-specs-cli.js").get().asFile.absolutePath,
+            reactNativeDir.file("scripts/generate-specs-cli.js").get().asFile.cliPath(workingDir),
             "--platform",
             "android",
             "--schemaPath",
-            generatedSchemaFile.get().asFile.absolutePath,
+            generatedSchemaFile.get().asFile.cliPath(workingDir),
             "--outputDir",
-            generatedSrcDir.get().asFile.absolutePath,
+            generatedSrcDir.get().asFile.cliPath(workingDir),
             "--libraryName",
             libraryName,
             "--javaPackageName",

package/src/main/kotlin/com/facebook/react/tasks/GenerateCodegenSchemaTask.kt

@@ -7,6 +7,7 @@
 
 package com.facebook.react.tasks
 
+import com.facebook.react.utils.Os.cliPath
 import com.facebook.react.utils.windowsAwareCommandLine
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.RegularFile
@@ -63,6 +64,7 @@ abstract class GenerateCodegenSchemaTask : Exec() {
   }
 
   internal fun setupCommandLine() {
+    val workingDir = project.projectDir
     commandLine(
         windowsAwareCommandLine(
             *nodeExecutableAndArgs.get().toTypedArray(),
@@ -70,11 +72,11 @@ abstract class GenerateCodegenSchemaTask : Exec() {
                 .file("lib/cli/combine/combine-js-to-schema-cli.js")
                 .get()
                 .asFile
-                .absolutePath,
+                .cliPath(workingDir),
             "--platform",
             "android",
-            generatedSchemaFile.get().asFile.absolutePath,
-            jsRootDir.asFile.get().absolutePath,
+            generatedSchemaFile.get().asFile.cliPath(workingDir),
+            jsRootDir.asFile.get().cliPath(workingDir),
         ))
   }
 }

package/src/main/kotlin/com/facebook/react/tasks/internal/utils/PrefabPreprocessingEntry.kt

@@ -11,10 +11,11 @@ import java.io.Serializable
 
 /**
  * This data class represents an entry that can be consumed by the [PreparePrefabHeadersTask].
+ *
  * @param libraryName The name of the library that you're preparing for Prefab
  * @param pathToPrefixCouples A list of pairs Path to Header prefix. You can use this list to supply
- * a list of paths that you want to be considered for prefab. Each path can specify an header prefix
- * that will be used by prefab to re-created the header layout.
+ *   a list of paths that you want to be considered for prefab. Each path can specify an header
+ *   prefix that will be used by prefab to re-created the header layout.
  */
 data class PrefabPreprocessingEntry(
     val libraryName: String,

package/src/main/kotlin/com/facebook/react/utils/NdkConfiguratorUtils.kt

@@ -10,6 +10,7 @@ package com.facebook.react.utils
 import com.android.build.api.variant.AndroidComponentsExtension
 import com.android.build.api.variant.Variant
 import com.facebook.react.ReactExtension
+import com.facebook.react.utils.ProjectUtils.getReactNativeArchitectures
 import com.facebook.react.utils.ProjectUtils.isNewArchEnabled
 import java.io.File
 import org.gradle.api.Project
@@ -49,6 +50,13 @@ internal object NdkConfiguratorUtils {
         if ("-DANDROID_STL" !in cmakeArgs) {
           cmakeArgs.add("-DANDROID_STL=c++_shared")
         }
+
+        val architectures = project.getReactNativeArchitectures()
+        // abiFilters are split ABI are not compatible each other, so we set the abiFilters
+        // only if the user hasn't enabled the split abi feature.
+        if (architectures.isNotEmpty() && !ext.splits.abi.isEnable) {
+          ext.defaultConfig.ndk.abiFilters.addAll(architectures)
+        }
       }
     }
   }

package/src/main/kotlin/com/facebook/react/utils/Os.kt

@@ -7,7 +7,9 @@
 
 package com.facebook.react.utils
 
-object Os {
+import java.io.File
+
+internal object Os {
 
   fun isWindows(): Boolean =
       System.getProperty("os.name")?.lowercase()?.contains("windows") ?: false
@@ -28,4 +30,15 @@ object Os {
           it
         }
       }
+
+  /**
+   * As Gradle doesn't support well path with spaces on Windows, we need to return relative path on
+   * Win. On Linux & Mac we'll default to return absolute path.
+   */
+  fun File.cliPath(base: File): String =
+      if (isWindows()) {
+        this.relativeTo(base).path
+      } else {
+        this.absolutePath
+      }
 }

package/src/main/kotlin/com/facebook/react/utils/PathUtils.kt

@@ -11,8 +11,10 @@ package com.facebook.react.utils
 
 import com.facebook.react.ReactExtension
 import com.facebook.react.model.ModelPackageJson
+import com.facebook.react.utils.Os.cliPath
 import java.io.File
 import org.gradle.api.Project
+import org.gradle.api.file.DirectoryProperty
 
 /**
  * Computes the entry file for React Native. The Algo follows this order:
@@ -23,9 +25,11 @@ import org.gradle.api.Project
  *
  * @param config The [ReactExtension] configured for this project
  */
-internal fun detectedEntryFile(config: ReactExtension): File =
+internal fun detectedEntryFile(config: ReactExtension, envVariableOverride: String? = null): File =
     detectEntryFile(
-        entryFile = config.entryFile.orNull?.asFile, reactRoot = config.root.get().asFile)
+        entryFile = config.entryFile.orNull?.asFile,
+        reactRoot = config.root.get().asFile,
+        envVariableOverride = envVariableOverride)
 
 /**
  * Computes the CLI file for React Native. The Algo follows this order:
@@ -43,18 +47,22 @@ internal fun detectedCliFile(config: ReactExtension): File =
  * Computes the `hermesc` command location. The Algo follows this order:
  * 1. The path provided by the `hermesCommand` config in the `react` Gradle extension
  * 2. The file located in `node_modules/react-native/sdks/hermes/build/bin/hermesc`. This will be
- * used if the user is building Hermes from source.
+ *    used if the user is building Hermes from source.
  * 3. The file located in `node_modules/react-native/sdks/hermesc/%OS-BIN%/hermesc` where `%OS-BIN%`
- * is substituted with the correct OS arch. This will be used if the user is using a precompiled
- * hermes-engine package.
+ *    is substituted with the correct OS arch. This will be used if the user is using a precompiled
+ *    hermes-engine package.
  * 4. Fails otherwise
  */
 internal fun detectedHermesCommand(config: ReactExtension): String =
     detectOSAwareHermesCommand(config.root.get().asFile, config.hermesCommand.get())
 
-private fun detectEntryFile(entryFile: File?, reactRoot: File): File =
+private fun detectEntryFile(
+    entryFile: File?,
+    reactRoot: File,
+    envVariableOverride: String? = null
+): File =
     when {
-      System.getenv("ENTRY_FILE") != null -> File(System.getenv("ENTRY_FILE"))
+      envVariableOverride != null -> File(reactRoot, envVariableOverride)
       entryFile != null -> entryFile
       File(reactRoot, "index.android.js").exists() -> File(reactRoot, "index.android.js")
       else -> File(reactRoot, "index.js")
@@ -106,10 +114,10 @@ private fun detectCliFile(reactNativeRoot: File, preconfiguredCliFile: File?): F
  * Computes the `hermesc` command location. The Algo follows this order:
  * 1. The path provided by the `hermesCommand` config in the `react` Gradle extension
  * 2. The file located in `node_modules/react-native/sdks/hermes/build/bin/hermesc`. This will be
- * used if the user is building Hermes from source.
+ *    used if the user is building Hermes from source.
  * 3. The file located in `node_modules/react-native/sdks/hermesc/%OS-BIN%/hermesc` where `%OS-BIN%`
- * is substituted with the correct OS arch. This will be used if the user is using a precompiled
- * hermes-engine package.
+ *    is substituted with the correct OS arch. This will be used if the user is using a precompiled
+ *    hermes-engine package.
  * 4. Fails otherwise
  */
 internal fun detectOSAwareHermesCommand(projectRoot: File, hermesCommand: String): String {
@@ -130,7 +138,7 @@ internal fun detectOSAwareHermesCommand(projectRoot: File, hermesCommand: String
   val builtHermesc =
       getBuiltHermescFile(projectRoot, System.getenv("REACT_NATIVE_OVERRIDE_HERMES_DIR"))
   if (builtHermesc.exists()) {
-    return builtHermesc.absolutePath
+    return builtHermesc.cliPath(projectRoot)
   }
 
   // 3. If the react-native contains a pre-built hermesc, use it.
@@ -142,7 +150,7 @@ internal fun detectOSAwareHermesCommand(projectRoot: File, hermesCommand: String
 
   val prebuiltHermes = File(projectRoot, prebuiltHermesPath)
   if (prebuiltHermes.exists()) {
-    return prebuiltHermes.absolutePath
+    return prebuiltHermes.cliPath(projectRoot)
   }
 
   error(
@@ -188,13 +196,13 @@ internal fun projectPathToLibraryName(projectPath: String): String =
  * Gradle module (generally the case for library projects) or we fallback to looking into the `root`
  * folder of a React Native project (generally the case for app projects).
  */
-internal fun findPackageJsonFile(project: Project, extension: ReactExtension): File? {
+internal fun findPackageJsonFile(project: Project, rootProperty: DirectoryProperty): File? {
   val inParent = project.file("../package.json")
   if (inParent.exists()) {
     return inParent
   }
 
-  val fromExtension = extension.root.file("package.json").orNull?.asFile
+  val fromExtension = rootProperty.file("package.json").orNull?.asFile
   if (fromExtension?.exists() == true) {
     return fromExtension
   }
@@ -206,12 +214,15 @@ internal fun findPackageJsonFile(project: Project, extension: ReactExtension): F
  * Function to look for the `package.json` and parse it. It returns a [ModelPackageJson] if found or
  * null others.
  *
- * Please note that this function access the [ReactExtension] field properties and calls .get() on
- * them, so calling this during apply() of the ReactPlugin is not recommended. It should be invoked
- * inside lazy lambdas or at execution time.
+ * Please note that this function access the [DirectoryProperty] parameter and calls .get() on them,
+ * so calling this during apply() of the ReactPlugin is not recommended. It should be invoked inside
+ * lazy lambdas or at execution time.
  */
-internal fun readPackageJsonFile(project: Project, extension: ReactExtension): ModelPackageJson? {
-  val packageJson = findPackageJsonFile(project, extension)
+internal fun readPackageJsonFile(
+    project: Project,
+    rootProperty: DirectoryProperty
+): ModelPackageJson? {
+  val packageJson = findPackageJsonFile(project, rootProperty)
   return packageJson?.let { JsonUtils.fromCodegenJson(it) }
 }
 

package/src/main/kotlin/com/facebook/react/utils/ProjectUtils.kt

@@ -7,9 +7,9 @@
 
 package com.facebook.react.utils
 
-import com.facebook.react.ReactExtension
 import com.facebook.react.model.ModelPackageJson
 import org.gradle.api.Project
+import org.gradle.api.file.DirectoryProperty
 
 internal object ProjectUtils {
   internal val Project.isNewArchEnabled: Boolean
@@ -35,12 +35,21 @@ internal object ProjectUtils {
           HERMES_FALLBACK
         }
 
-  internal fun Project.needsCodegenFromPackageJson(extension: ReactExtension): Boolean {
-    val parsedPackageJson = readPackageJsonFile(this, extension)
+  internal fun Project.needsCodegenFromPackageJson(rootProperty: DirectoryProperty): Boolean {
+    val parsedPackageJson = readPackageJsonFile(this, rootProperty)
     return needsCodegenFromPackageJson(parsedPackageJson)
   }
 
   internal fun Project.needsCodegenFromPackageJson(model: ModelPackageJson?): Boolean {
     return model?.codegenConfig != null
   }
+
+  internal fun Project.getReactNativeArchitectures(): List<String> {
+    val architectures = mutableListOf<String>()
+    if (project.hasProperty("reactNativeArchitectures")) {
+      val architecturesString = project.property("reactNativeArchitectures").toString()
+      architectures.addAll(architecturesString.split(",").filter { it.isNotBlank() })
+    }
+    return architectures
+  }
 }