@ohos-ports/react-native-gradle-plugin 0.71.19-beta.0

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

@@ -0,0 +1,109 @@
+/*
+ * 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.utils
+
+import java.io.File
+import java.net.URI
+import java.util.*
+import org.gradle.api.Project
+import org.gradle.api.artifacts.repositories.MavenArtifactRepository
+
+internal const val DEFAULT_GROUP_STRING = "com.facebook.react"
+
+internal object DependencyUtils {
+
+  /**
+   * This method takes care of configuring the repositories{} block for both the app and all the 3rd
+   * party libraries which are auto-linked.
+   */
+  fun configureRepositories(project: Project, reactNativeDir: File) {
+    project.rootProject.allprojects { eachProject ->
+      with(eachProject) {
+        if (hasProperty("REACT_NATIVE_MAVEN_LOCAL_REPO")) {
+          val mavenLocalRepoPath = property("REACT_NATIVE_MAVEN_LOCAL_REPO") as String
+          mavenRepoFromURI(File(mavenLocalRepoPath).toURI())
+        }
+        // We add the snapshot for users on nightlies.
+        mavenRepoFromUrl("https://oss.sonatype.org/content/repositories/snapshots/")
+        repositories.mavenCentral()
+        // Android JSC is installed from npm
+        mavenRepoFromURI(File(reactNativeDir, "../jsc-android/dist").toURI())
+        repositories.google()
+        mavenRepoFromUrl("https://www.jitpack.io")
+      }
+    }
+  }
+
+  /**
+   * This method takes care of configuring the resolution strategy for both the app and all the 3rd
+   * party libraries which are auto-linked. Specifically it takes care of:
+   * - Forcing the react-android/hermes-android version to the one specified in the package.json
+   * - Substituting `react-native` with `react-android` and `hermes-engine` with `hermes-android`.
+   */
+  fun configureDependencies(
+      project: Project,
+      versionString: String,
+      groupString: String = DEFAULT_GROUP_STRING
+  ) {
+    if (versionString.isBlank()) return
+    project.rootProject.allprojects { eachProject ->
+      eachProject.configurations.all { configuration ->
+        // Here we set a dependencySubstitution for both react-native and hermes-engine as those
+        // coordinates are voided due to https://github.com/facebook/react-native/issues/35210
+        // This allows users to import libraries that are still using
+        // implementation("com.facebook.react:react-native:+") and resolve the right dependency.
+        configuration.resolutionStrategy.dependencySubstitution {
+          it.substitute(it.module("com.facebook.react:react-native"))
+              .using(it.module("${groupString}:react-android:${versionString}"))
+              .because(
+                  "The react-native artifact was deprecated in favor of react-android due to https://github.com/facebook/react-native/issues/35210.")
+          it.substitute(it.module("com.facebook.react:hermes-engine"))
+              .using(it.module("${groupString}:hermes-android:${versionString}"))
+              .because(
+                  "The hermes-engine artifact was deprecated in favor of hermes-android due to https://github.com/facebook/react-native/issues/35210.")
+          if (groupString != DEFAULT_GROUP_STRING) {
+            it.substitute(it.module("com.facebook.react:react-android"))
+                .using(it.module("${groupString}:react-android:${versionString}"))
+                .because(
+                    "The react-android dependency was modified to use the correct Maven group.")
+            it.substitute(it.module("com.facebook.react:hermes-android"))
+                .using(it.module("${groupString}:hermes-android:${versionString}"))
+                .because(
+                    "The hermes-android dependency was modified to use the correct Maven group.")
+          }
+        }
+        configuration.resolutionStrategy.force(
+            "${groupString}:react-android:${versionString}",
+            "${groupString}:hermes-android:${versionString}",
+        )
+      }
+    }
+  }
+
+  fun readVersionAndGroupStrings(propertiesFile: File): Pair<String, String> {
+    val reactAndroidProperties = Properties()
+    propertiesFile.inputStream().use { reactAndroidProperties.load(it) }
+    val versionStringFromFile = reactAndroidProperties["VERSION_NAME"] as? String ?: ""
+    // If on a nightly, we need to fetch the -SNAPSHOT artifact from Sonatype.
+    val versionString =
+        if (versionStringFromFile.startsWith("0.0.0")) {
+          "$versionStringFromFile-SNAPSHOT"
+        } else {
+          versionStringFromFile
+        }
+    // Returns Maven group for repos using different group for Maven artifacts
+    val groupString = reactAndroidProperties["GROUP"] as? String ?: DEFAULT_GROUP_STRING
+    return Pair(versionString, groupString)
+  }
+
+  fun Project.mavenRepoFromUrl(url: String): MavenArtifactRepository =
+      project.repositories.maven { it.url = URI.create(url) }
+
+  fun Project.mavenRepoFromURI(uri: URI): MavenArtifactRepository =
+      project.repositories.maven { it.url = uri }
+}

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

@@ -0,0 +1,20 @@
+/*
+ * 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.utils
+
+import java.io.File
+
+internal fun File.moveTo(destination: File) {
+  copyTo(destination, overwrite = true)
+  delete()
+}
+
+internal fun File.recreateDir() {
+  deleteRecursively()
+  mkdirs()
+}

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

@@ -0,0 +1,21 @@
+/*
+ * 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.utils
+
+import com.facebook.react.model.ModelPackageJson
+import com.google.gson.Gson
+import java.io.File
+
+object JsonUtils {
+  private val gsonConverter = Gson()
+
+  fun fromCodegenJson(input: File): ModelPackageJson? =
+      input.bufferedReader().use {
+        runCatching { gsonConverter.fromJson(it, ModelPackageJson::class.java) }.getOrNull()
+      }
+}

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

@@ -0,0 +1,147 @@
+/*
+ * 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.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
+
+internal object NdkConfiguratorUtils {
+  @Suppress("UnstableApiUsage")
+  fun configureReactNativeNdk(project: Project, extension: ReactExtension) {
+    project.pluginManager.withPlugin("com.android.application") {
+      project.extensions.getByType(AndroidComponentsExtension::class.java).finalizeDsl { ext ->
+        if (!project.isNewArchEnabled) {
+          // For Old Arch, we don't need to setup the NDK
+          return@finalizeDsl
+        }
+        // We enable prefab so users can consume .so/headers from ReactAndroid and hermes-engine
+        // .aar
+        ext.buildFeatures.prefab = true
+
+        // If the user has not provided a CmakeLists.txt path, let's provide
+        // the default one from the framework
+        if (ext.externalNativeBuild.cmake.path == null) {
+          ext.externalNativeBuild.cmake.path =
+              File(
+                  extension.reactNativeDir.get().asFile,
+                  "ReactAndroid/cmake-utils/default-app-setup/CMakeLists.txt")
+        }
+
+        // Parameters should be provided in an additive manner (do not override what
+        // the user provided, but allow for sensible defaults).
+        val cmakeArgs = ext.defaultConfig.externalNativeBuild.cmake.arguments
+        if ("-DPROJECT_BUILD_DIR" !in cmakeArgs) {
+          cmakeArgs.add("-DPROJECT_BUILD_DIR=${project.buildDir}")
+        }
+        if ("-DREACT_ANDROID_DIR" !in cmakeArgs) {
+          cmakeArgs.add(
+              "-DREACT_ANDROID_DIR=${extension.reactNativeDir.file("ReactAndroid").get().asFile}")
+        }
+        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)
+        }
+      }
+    }
+  }
+
+  /**
+   * This method is used to configure the .so Packaging Options for the given variant. It will make
+   * sure we specify the correct .pickFirsts for all the .so files we are producing or that we're
+   * aware of as some of our dependencies are pulling them in.
+   */
+  fun configureNewArchPackagingOptions(
+      project: Project,
+      variant: Variant,
+  ) {
+    if (!project.isNewArchEnabled) {
+      // For Old Arch, we set a pickFirst only on libraries that we know are
+      // clashing with our direct dependencies (FBJNI, Flipper and Hermes).
+      variant.packaging.jniLibs.pickFirsts.addAll(
+          listOf(
+              "**/libfbjni.so",
+              "**/libc++_shared.so",
+          ))
+    } else {
+      // We set some packagingOptions { pickFirst ... } for our users for libraries we own.
+      variant.packaging.jniLibs.pickFirsts.addAll(
+          listOf(
+              // This is the .so provided by FBJNI via prefab
+              "**/libfbjni.so",
+              // Those are prefab libraries we distribute via ReactAndroid
+              // Due to a bug in AGP, they fire a warning on console as both the JNI
+              // and the prefab .so files gets considered. See more on:
+              "**/libfabricjni.so",
+              "**/libfolly_runtime.so",
+              "**/libglog.so",
+              "**/libjsi.so",
+              "**/libreact_codegen_rncore.so",
+              "**/libreact_debug.so",
+              "**/libreact_nativemodule_core.so",
+              "**/libreact_newarchdefaults.so",
+              "**/libreact_render_componentregistry.so",
+              "**/libreact_render_core.so",
+              "**/libreact_render_debug.so",
+              "**/libreact_render_graphics.so",
+              "**/libreact_render_imagemanager.so",
+              "**/libreact_render_mapbuffer.so",
+              "**/librrc_image.so",
+              "**/librrc_view.so",
+              "**/libruntimeexecutor.so",
+              "**/libturbomodulejsijni.so",
+              "**/libyoga.so",
+              // AGP will give priority of libc++_shared coming from App modules.
+              "**/libc++_shared.so",
+          ))
+    }
+  }
+
+  /**
+   * This method is used to configure the .so Cleanup for the given variant. It takes care of
+   * cleaning up the .so files that are not needed for Hermes or JSC, given a specific variant.
+   */
+  fun configureJsEnginePackagingOptions(
+      config: ReactExtension,
+      variant: Variant,
+      hermesEnabled: Boolean,
+  ) {
+    if (config.enableSoCleanup.get()) {
+      val (excludes, includes) = getPackagingOptionsForVariant(hermesEnabled)
+      variant.packaging.jniLibs.excludes.addAll(excludes)
+      variant.packaging.jniLibs.pickFirsts.addAll(includes)
+    }
+  }
+
+  fun getPackagingOptionsForVariant(hermesEnabled: Boolean): Pair<List<String>, List<String>> {
+    val excludes = mutableListOf<String>()
+    val includes = mutableListOf<String>()
+    if (hermesEnabled) {
+      excludes.add("**/libjsc.so")
+      excludes.add("**/libjscexecutor.so")
+      includes.add("**/libhermes.so")
+      includes.add("**/libhermes_executor.so")
+    } else {
+      excludes.add("**/libhermes.so")
+      excludes.add("**/libhermes_executor.so")
+      includes.add("**/libjsc.so")
+      includes.add("**/libjscexecutor.so")
+    }
+    return excludes to includes
+  }
+}

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

@@ -0,0 +1,44 @@
+/*
+ * 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.utils
+
+import java.io.File
+
+internal object Os {
+
+  fun isWindows(): Boolean =
+      System.getProperty("os.name")?.lowercase()?.contains("windows") ?: false
+
+  fun isMac(): Boolean = System.getProperty("os.name")?.lowercase()?.contains("mac") ?: false
+
+  fun isLinuxAmd64(): Boolean {
+    val osNameMatch = System.getProperty("os.name")?.lowercase()?.contains("linux") ?: false
+    val archMatch = System.getProperty("os.arch")?.lowercase()?.contains("amd64") ?: false
+    return osNameMatch && archMatch
+  }
+
+  fun String.unixifyPath() =
+      this.replace('\\', '/').replace(":", "").let {
+        if (!it.startsWith("/")) {
+          "/$it"
+        } else {
+          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

@@ -0,0 +1,231 @@
+/*
+ * 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.
+ */
+
+@file:JvmName("PathUtils")
+
+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:
+ * 1. The file pointed by the ENTRY_FILE env variable, if set.
+ * 2. The file provided by the `entryFile` config in the `reactApp` Gradle extension
+ * 3. The `index.android.js` file, if available.
+ * 4. Fallback to the `index.js` file.
+ *
+ * @param config The [ReactExtension] configured for this project
+ */
+internal fun detectedEntryFile(config: ReactExtension, envVariableOverride: String? = null): File =
+    detectEntryFile(
+        entryFile = config.entryFile.orNull?.asFile,
+        reactRoot = config.root.get().asFile,
+        envVariableOverride = envVariableOverride)
+
+/**
+ * Computes the CLI file for React Native. The Algo follows this order:
+ * 1. The path provided by the `cliFile` config in the `react {}` Gradle extension
+ * 2. The output of `node --print "require.resolve('react-native/cli');"` if not failing.
+ * 3. The `node_modules/react-native/cli.js` file if exists
+ * 4. Fails otherwise
+ */
+internal fun detectedCliFile(config: ReactExtension): File =
+    detectCliFile(
+        reactNativeRoot = config.root.get().asFile,
+        preconfiguredCliFile = config.cliFile.asFile.orNull)
+
+/**
+ * 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.
+ * 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.
+ * 4. Fails otherwise
+ */
+internal fun detectedHermesCommand(config: ReactExtension): String =
+    detectOSAwareHermesCommand(config.root.get().asFile, config.hermesCommand.get())
+
+private fun detectEntryFile(
+    entryFile: File?,
+    reactRoot: File,
+    envVariableOverride: String? = null
+): File =
+    when {
+      envVariableOverride != null -> File(reactRoot, envVariableOverride)
+      entryFile != null -> entryFile
+      File(reactRoot, "index.android.js").exists() -> File(reactRoot, "index.android.js")
+      else -> File(reactRoot, "index.js")
+    }
+
+private fun detectCliFile(reactNativeRoot: File, preconfiguredCliFile: File?): File {
+  // 1. preconfigured path
+  if (preconfiguredCliFile != null) {
+    if (preconfiguredCliFile.exists()) {
+      return preconfiguredCliFile
+    }
+  }
+
+  // 2. node module path
+  val nodeProcess =
+      Runtime.getRuntime()
+          .exec(
+              arrayOf("node", "--print", "require.resolve('react-native/cli');"),
+              emptyArray(),
+              reactNativeRoot)
+
+  val nodeProcessOutput = nodeProcess.inputStream.use { it.bufferedReader().readText().trim() }
+
+  if (nodeProcessOutput.isNotEmpty()) {
+    val nodeModuleCliJs = File(nodeProcessOutput)
+    if (nodeModuleCliJs.exists()) {
+      return nodeModuleCliJs
+    }
+  }
+
+  // 3. cli.js in the root folder
+  val rootCliJs = File(reactNativeRoot, "node_modules/react-native/cli.js")
+  if (rootCliJs.exists()) {
+    return rootCliJs
+  }
+
+  error(
+      """
+      Couldn't determine CLI location!
+      
+      Please set `react { cliFile = file(...) }` inside your 
+      build.gradle to the path of the react-native cli.js file.
+      This file typically resides in `node_modules/react-native/cli.js`
+    """
+          .trimIndent())
+}
+
+/**
+ * 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.
+ * 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.
+ * 4. Fails otherwise
+ */
+internal fun detectOSAwareHermesCommand(projectRoot: File, hermesCommand: String): String {
+  // 1. If the project specifies a Hermes command, don't second guess it.
+  if (hermesCommand.isNotBlank()) {
+    val osSpecificHermesCommand =
+        if ("%OS-BIN%" in hermesCommand) {
+          hermesCommand.replace("%OS-BIN%", getHermesOSBin())
+        } else {
+          hermesCommand
+        }
+    return osSpecificHermesCommand
+        // Execution on Windows fails with / as separator
+        .replace('/', File.separatorChar)
+  }
+
+  // 2. If the project is building hermes-engine from source, use hermesc from there
+  val builtHermesc =
+      getBuiltHermescFile(projectRoot, System.getenv("REACT_NATIVE_OVERRIDE_HERMES_DIR"))
+  if (builtHermesc.exists()) {
+    return builtHermesc.cliPath(projectRoot)
+  }
+
+  // 3. If the react-native contains a pre-built hermesc, use it.
+  val prebuiltHermesPath =
+      HERMESC_IN_REACT_NATIVE_DIR.plus(getHermesCBin())
+          .replace("%OS-BIN%", getHermesOSBin())
+          // Execution on Windows fails with / as separator
+          .replace('/', File.separatorChar)
+
+  val prebuiltHermes = File(projectRoot, prebuiltHermesPath)
+  if (prebuiltHermes.exists()) {
+    return prebuiltHermes.cliPath(projectRoot)
+  }
+
+  error(
+      "Couldn't determine Hermesc location. " +
+          "Please set `react.hermesCommand` to the path of the hermesc binary file. " +
+          "node_modules/react-native/sdks/hermesc/%OS-BIN%/hermesc")
+}
+
+/**
+ * Gets the location where Hermesc should be. If nothing is specified, built hermesc is assumed to
+ * be inside [HERMESC_BUILT_FROM_SOURCE_DIR]. Otherwise user can specify an override with
+ * [pathOverride], which is assumed to be an absolute path where Hermes source code is
+ * provided/built.
+ *
+ * @param projectRoot The root of the Project.
+ */
+internal fun getBuiltHermescFile(projectRoot: File, pathOverride: String?) =
+    if (!pathOverride.isNullOrBlank()) {
+      File(pathOverride, "build/bin/${getHermesCBin()}")
+    } else {
+      File(projectRoot, HERMESC_BUILT_FROM_SOURCE_DIR.plus(getHermesCBin()))
+    }
+
+internal fun getHermesCBin() = if (Os.isWindows()) "hermesc.exe" else "hermesc"
+
+internal fun getHermesOSBin(): String {
+  if (Os.isWindows()) return "win64-bin"
+  if (Os.isMac()) return "osx-bin"
+  if (Os.isLinuxAmd64()) return "linux64-bin"
+  error(
+      "OS not recognized. Please set project.react.hermesCommand " +
+          "to the path of a working Hermes compiler.")
+}
+
+internal fun projectPathToLibraryName(projectPath: String): String =
+    projectPath
+        .split(':', '-', '_', '.')
+        .joinToString("") { token -> token.replaceFirstChar { it.uppercase() } }
+        .plus("Spec")
+
+/**
+ * Function to look for the relevant `package.json`. We first look in the parent folder of this
+ * 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, rootProperty: DirectoryProperty): File? {
+  val inParent = project.file("../package.json")
+  if (inParent.exists()) {
+    return inParent
+  }
+
+  val fromExtension = rootProperty.file("package.json").orNull?.asFile
+  if (fromExtension?.exists() == true) {
+    return fromExtension
+  }
+
+  return null
+}
+
+/**
+ * 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 [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,
+    rootProperty: DirectoryProperty
+): ModelPackageJson? {
+  val packageJson = findPackageJsonFile(project, rootProperty)
+  return packageJson?.let { JsonUtils.fromCodegenJson(it) }
+}
+
+private const val HERMESC_IN_REACT_NATIVE_DIR = "node_modules/react-native/sdks/hermesc/%OS-BIN%/"
+private const val HERMESC_BUILT_FROM_SOURCE_DIR =
+    "node_modules/react-native/ReactAndroid/hermes-engine/build/hermes/bin/"

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

@@ -0,0 +1,55 @@
+/*
+ * 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.utils
+
+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
+    get() =
+        project.hasProperty("newArchEnabled") &&
+            project.property("newArchEnabled").toString().toBoolean()
+
+  const val HERMES_FALLBACK = true
+
+  internal val Project.isHermesEnabled: Boolean
+    get() =
+        if (project.hasProperty("hermesEnabled")) {
+          project.property("hermesEnabled").toString().lowercase().toBooleanStrictOrNull() ?: true
+        } else if (project.extensions.extraProperties.has("react")) {
+          @Suppress("UNCHECKED_CAST")
+          val reactMap = project.extensions.extraProperties.get("react") as? Map<String, Any?>
+          when (val enableHermesKey = reactMap?.get("enableHermes")) {
+            is Boolean -> enableHermesKey
+            is String -> enableHermesKey.lowercase().toBooleanStrictOrNull() ?: true
+            else -> HERMES_FALLBACK
+          }
+        } else {
+          HERMES_FALLBACK
+        }
+
+  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
+  }
+}

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

@@ -0,0 +1,28 @@
+/*
+ * 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.utils
+
+internal fun windowsAwareCommandLine(vararg args: Any): List<Any> =
+    windowsAwareCommandLine(args.toList())
+
+internal fun windowsAwareCommandLine(args: List<Any>): List<Any> =
+    if (Os.isWindows()) {
+      listOf("cmd", "/c") + args
+    } else {
+      args
+    }
+
+internal fun windowsAwareBashCommandLine(
+    vararg args: String,
+    bashWindowsHome: String? = null
+): List<String> =
+    if (Os.isWindows()) {
+      listOf(bashWindowsHome ?: "bash", "-c") + args
+    } else {
+      args.toList()
+    }