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

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

@@ -0,0 +1,212 @@
+/*
+ * 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
+
+import com.android.build.api.variant.AndroidComponentsExtension
+import com.android.build.gradle.AppExtension
+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
+import com.facebook.react.utils.AgpConfiguratorUtils.configureBuildConfigFields
+import com.facebook.react.utils.AgpConfiguratorUtils.configureDevPorts
+import com.facebook.react.utils.BackwardCompatUtils.configureBackwardCompatibilityReactMap
+import com.facebook.react.utils.DependencyUtils.configureDependencies
+import com.facebook.react.utils.DependencyUtils.configureRepositories
+import com.facebook.react.utils.DependencyUtils.readVersionAndGroupStrings
+import com.facebook.react.utils.JsonUtils
+import com.facebook.react.utils.NdkConfiguratorUtils.configureReactNativeNdk
+import com.facebook.react.utils.ProjectUtils.needsCodegenFromPackageJson
+import com.facebook.react.utils.findPackageJsonFile
+import java.io.File
+import kotlin.system.exitProcess
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.internal.jvm.Jvm
+
+class ReactPlugin : Plugin<Project> {
+  override fun apply(project: 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")
+        val versionAndGroupStrings = readVersionAndGroupStrings(propertiesFile)
+        val versionString = versionAndGroupStrings.first
+        val groupString = versionAndGroupStrings.second
+        configureDependencies(project, versionString, groupString)
+        configureRepositories(project, reactNativeDir)
+      }
+
+      configureReactNativeNdk(project, extension)
+      configureBuildConfigFields(project)
+      configureDevPorts(project)
+      configureBackwardCompatibilityReactMap(project)
+
+      project.extensions.getByType(AndroidComponentsExtension::class.java).apply {
+        onVariants(selector().all()) { variant ->
+          project.configureReactTasks(variant = variant, config = extension)
+        }
+      }
+
+      // This is a legacy AGP api. Needed as AGP 7.3 is not consuming generated resources correctly.
+      // Can be removed as we bump to AGP 7.4 stable.
+      // This registers the $buildDir/generated/res/react/<variant> folder as a
+      // res folder to be consumed with the old AGP Apis which are not broken.
+      project.extensions.getByType(AppExtension::class.java).apply {
+        this.applicationVariants.all { variant ->
+          val isDebuggableVariant =
+              extension.debuggableVariants.get().any { it.equals(variant.name, ignoreCase = true) }
+          val targetName = variant.name.replaceFirstChar { it.uppercase() }
+          val bundleTaskName = "createBundle${targetName}JsAndAssets"
+          if (!isDebuggableVariant) {
+            variant.registerGeneratedResFolders(
+                project.layout.buildDirectory.files("generated/res/react/${variant.name}"))
+            variant.mergeResourcesProvider.get().dependsOn(bundleTaskName)
+          }
+        }
+      }
+      configureCodegen(project, extension, rootExtension, isLibrary = false)
+    }
+
+    // Library Only Configuration
+    project.pluginManager.withPlugin("com.android.library") {
+      configureCodegen(project, extension, rootExtension, isLibrary = true)
+    }
+  }
+
+  private fun checkJvmVersion(project: Project) {
+    val jvmVersion = Jvm.current()?.javaVersion?.majorVersion
+    if ((jvmVersion?.toIntOrNull() ?: 0) <= 8) {
+      project.logger.error(
+          """
+
+      ********************************************************************************
+
+      ERROR: requires JDK11 or higher.
+      Incompatible major version detected: '$jvmVersion'
+
+      ********************************************************************************
+
+      """
+              .trimIndent())
+      exitProcess(1)
+    }
+  }
+
+  /** This function sets up `react-native-codegen` in our Gradle plugin. */
+  @Suppress("UnstableApiUsage")
+  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(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(rootExtension.root)
+          it.onlyIf { isLibrary || needsCodegenFromPackageJson }
+        }
+
+    // We create the task to produce schema from JS files.
+    val generateCodegenSchemaTask =
+        project.tasks.register(
+            "generateCodegenSchemaFromJavaScript", GenerateCodegenSchemaTask::class.java) { it ->
+              it.dependsOn(buildCodegenTask)
+              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, 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(localExtension.jsRootDir)
+              }
+              val needsCodegenFromPackageJson =
+                  project.needsCodegenFromPackageJson(rootExtension.root)
+              it.onlyIf { isLibrary || needsCodegenFromPackageJson }
+            }
+
+    // We create the task to generate Java code from schema.
+    val generateCodegenArtifactsTask =
+        project.tasks.register(
+            "generateCodegenArtifactsFromSchema", GenerateCodegenArtifactsTask::class.java) {
+              it.dependsOn(generateCodegenSchemaTask)
+              it.reactNativeDir.set(rootExtension.reactNativeDir)
+              it.nodeExecutableAndArgs.set(rootExtension.nodeExecutableAndArgs)
+              it.generatedSrcDir.set(generatedSrcDir)
+              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(rootExtension.root)
+              it.onlyIf { isLibrary || needsCodegenFromPackageJson }
+            }
+
+    // We update the android configuration to include the generated sources.
+    // This equivalent to this DSL:
+    //
+    // android { sourceSets { main { java { srcDirs += "$generatedSrcDir/java" } } } }
+    project.extensions.getByType(AndroidComponentsExtension::class.java).finalizeDsl { ext ->
+      ext.sourceSets.getByName("main").java.srcDir(File(generatedSrcDir, "java"))
+    }
+
+    // `preBuild` is one of the base tasks automatically registered by AGP.
+    // This will invoke the codegen before compiling the entire project.
+    project.tasks.named("preBuild", Task::class.java).dependsOn(generateCodegenArtifactsTask)
+  }
+}

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

@@ -0,0 +1,81 @@
+/*
+ * 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
+
+import com.android.build.api.variant.Variant
+import com.facebook.react.tasks.BundleHermesCTask
+import com.facebook.react.utils.NdkConfiguratorUtils.configureJsEnginePackagingOptions
+import com.facebook.react.utils.NdkConfiguratorUtils.configureNewArchPackagingOptions
+import com.facebook.react.utils.ProjectUtils.isHermesEnabled
+import com.facebook.react.utils.detectedCliFile
+import com.facebook.react.utils.detectedEntryFile
+import java.io.File
+import org.gradle.api.Project
+
+@Suppress("SpreadOperator", "UnstableApiUsage")
+internal fun Project.configureReactTasks(variant: Variant, config: ReactExtension) {
+  val targetName = variant.name.replaceFirstChar { it.uppercase() }
+  val targetPath = variant.name
+
+  // Resources: generated/assets/react/<variant>/index.android.bundle
+  val resourcesDir = File(buildDir, "generated/res/react/$targetPath")
+  // Bundle: generated/assets/react/<variant>/index.android.bundle
+  val jsBundleDir = File(buildDir, "generated/assets/react/$targetPath")
+  // Sourcemap: generated/sourcemaps/react/<variant>/index.android.bundle.map
+  val jsSourceMapsDir = File(buildDir, "generated/sourcemaps/react/$targetPath")
+  // 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
+  val cliFile = detectedCliFile(config)
+
+  val isHermesEnabledInProject = project.isHermesEnabled
+  val isHermesEnabledInThisVariant =
+      if (config.enableHermesOnlyInVariants.get().isNotEmpty()) {
+        config.enableHermesOnlyInVariants.get().contains(variant.name) && isHermesEnabledInProject
+      } else {
+        isHermesEnabledInProject
+      }
+  val isDebuggableVariant =
+      config.debuggableVariants.get().any { it.equals(variant.name, ignoreCase = true) }
+
+  configureNewArchPackagingOptions(project, variant)
+  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, entryFileEnvVariable))
+          it.extraPackagerArgs.set(config.extraPackagerArgs)
+          it.bundleConfig.set(config.bundleConfig)
+          it.bundleAssetName.set(config.bundleAssetName)
+          it.jsBundleDir.set(jsBundleDir)
+          it.resourcesDir.set(resourcesDir)
+          it.hermesEnabled.set(isHermesEnabledInThisVariant)
+          it.minifyEnabled.set(!isHermesEnabledInThisVariant)
+          it.devEnabled.set(false)
+          it.jsIntermediateSourceMapsDir.set(jsIntermediateSourceMapsDir)
+          it.jsSourceMapsDir.set(jsSourceMapsDir)
+          it.hermesCommand.set(config.hermesCommand)
+          it.hermesFlags.set(config.hermesFlags)
+          it.reactNativeDir.set(config.reactNativeDir)
+        }
+    // Currently broken inside AGP 7.3 We need to wait for a release of AGP 7.4 in order to use
+    // the addGeneratedSourceDirectory API.
+    // variant.sources.res?.addGeneratedSourceDirectory(bundleTask, BundleHermesCTask::resourcesDir)
+    variant.sources.assets?.addGeneratedSourceDirectory(bundleTask, BundleHermesCTask::jsBundleDir)
+  }
+}

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/model/ModelCodegenConfig.kt

@@ -0,0 +1,15 @@
+/*
+ * 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.model
+
+data class ModelCodegenConfig(
+    val name: String?,
+    val type: String?,
+    val jsSrcsDir: String?,
+    val android: ModelCodegenConfigAndroid?
+)

package/src/main/kotlin/com/facebook/react/model/ModelCodegenConfigAndroid.kt

@@ -0,0 +1,10 @@
+/*
+ * 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.model
+
+data class ModelCodegenConfigAndroid(val javaPackageName: String?)

package/src/main/kotlin/com/facebook/react/model/ModelPackageJson.kt

@@ -0,0 +1,10 @@
+/*
+ * 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.model
+
+data class ModelPackageJson(val codegenConfig: ModelCodegenConfig?)

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

@@ -0,0 +1,58 @@
+/*
+ * 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.tasks
+
+import com.facebook.react.utils.Os.unixifyPath
+import com.facebook.react.utils.windowsAwareBashCommandLine
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.FileCollection
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.*
+
+/**
+ * A Task that will call the `scripts/oss/build.sh` script to trigger the creation of the codegen
+ * lib artifacts.
+ *
+ * NOTE: This task is required when using react-native-codegen from source, instead of npm.
+ */
+abstract class BuildCodegenCLITask : Exec() {
+
+  @get:Internal abstract val codegenDir: DirectoryProperty
+
+  @get:Internal abstract val bashWindowsHome: Property<String>
+
+  @get:InputFiles
+  val input: FileCollection by lazy {
+    codegenDir.get().files("scripts", "src", "package.json", ".babelrc", ".prettierrc")
+  }
+
+  @get:OutputDirectories
+  val output: FileCollection by lazy { codegenDir.get().files("lib", "node_modules") }
+
+  init {
+    // We need this condition as we want a single instance of BuildCodegenCLITask to execute
+    // per project. Therefore we can safely skip the task if the lib/cli/ folder is available.
+    onlyIf {
+      val cliDir = codegenDir.file("lib/cli/").get().asFile
+      !cliDir.exists() || cliDir.listFiles()?.size == 0
+    }
+  }
+
+  override fun exec() {
+    commandLine(
+        windowsAwareBashCommandLine(
+            codegenDir.asFile.get().canonicalPath.unixifyPath().plus(BUILD_SCRIPT_PATH),
+            bashWindowsHome = bashWindowsHome.orNull,
+        ))
+    super.exec()
+  }
+
+  companion object {
+    private const val BUILD_SCRIPT_PATH = "/scripts/oss/build.sh"
+  }
+}

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

@@ -0,0 +1,200 @@
+/*
+ * 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.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
+import java.io.File
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileTree
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.*
+
+abstract class BundleHermesCTask : DefaultTask() {
+
+  init {
+    group = "react"
+  }
+
+  @get:Internal abstract val root: DirectoryProperty
+
+  @get:InputFiles
+  val sources: ConfigurableFileTree =
+      project.fileTree(root) {
+        it.include("**/*.js")
+        it.include("**/*.jsx")
+        it.include("**/*.ts")
+        it.include("**/*.tsx")
+        it.exclude("**/android/**/*")
+        it.exclude("**/ios/**/*")
+        it.exclude("**/build/**/*")
+        it.exclude("**/node_modules/**/*")
+      }
+
+  @get:Input abstract val nodeExecutableAndArgs: ListProperty<String>
+
+  @get:InputFile abstract val cliFile: RegularFileProperty
+
+  @get:Internal abstract val reactNativeDir: DirectoryProperty
+
+  @get:Input abstract val bundleCommand: Property<String>
+
+  @get:InputFile abstract val entryFile: RegularFileProperty
+
+  @get:InputFile @get:Optional abstract val bundleConfig: RegularFileProperty
+
+  @get:Input abstract val bundleAssetName: Property<String>
+
+  @get:Input abstract val minifyEnabled: Property<Boolean>
+
+  @get:Input abstract val hermesEnabled: Property<Boolean>
+
+  @get:Input abstract val devEnabled: Property<Boolean>
+
+  @get:Input abstract val extraPackagerArgs: ListProperty<String>
+
+  @get:Input abstract val hermesCommand: Property<String>
+
+  @get:Input abstract val hermesFlags: ListProperty<String>
+
+  @get:OutputDirectory abstract val jsBundleDir: DirectoryProperty
+
+  @get:OutputDirectory abstract val resourcesDir: DirectoryProperty
+
+  @get:OutputDirectory abstract val jsIntermediateSourceMapsDir: RegularFileProperty
+
+  @get:OutputDirectory abstract val jsSourceMapsDir: DirectoryProperty
+
+  @TaskAction
+  fun run() {
+    jsBundleDir.get().asFile.mkdirs()
+    resourcesDir.get().asFile.mkdirs()
+    jsIntermediateSourceMapsDir.get().asFile.mkdirs()
+    jsSourceMapsDir.get().asFile.mkdirs()
+    val bundleAssetFilename = bundleAssetName.get()
+
+    val bundleFile = File(jsBundleDir.get().asFile, bundleAssetFilename)
+    val packagerSourceMap = resolvePackagerSourceMapFile(bundleAssetFilename)
+
+    val bundleCommand = getBundleCommand(bundleFile, packagerSourceMap)
+    runCommand(bundleCommand)
+
+    if (hermesEnabled.get()) {
+      val detectedHermesCommand = detectOSAwareHermesCommand(root.get().asFile, hermesCommand.get())
+      val bytecodeFile = File("${bundleFile}.hbc")
+      val outputSourceMap = resolveOutputSourceMap(bundleAssetFilename)
+      val compilerSourceMap = resolveCompilerSourceMap(bundleAssetFilename)
+
+      val hermesCommand = getHermescCommand(detectedHermesCommand, bytecodeFile, bundleFile)
+      runCommand(hermesCommand)
+      bytecodeFile.moveTo(bundleFile)
+
+      if (hermesFlags.get().contains("-output-source-map")) {
+        val hermesTempSourceMapFile = File("$bytecodeFile.map")
+        hermesTempSourceMapFile.moveTo(compilerSourceMap)
+
+        val reactNativeDir = reactNativeDir.get().asFile
+        val composeScriptFile = File(reactNativeDir, "scripts/compose-source-maps.js")
+        val composeSourceMapsCommand =
+            getComposeSourceMapsCommand(
+                composeScriptFile, packagerSourceMap, compilerSourceMap, outputSourceMap)
+        runCommand(composeSourceMapsCommand)
+      }
+    }
+  }
+
+  internal fun resolvePackagerSourceMapFile(bundleAssetName: String) =
+      if (hermesEnabled.get()) {
+        File(jsIntermediateSourceMapsDir.get().asFile, "$bundleAssetName.packager.map")
+      } else {
+        resolveOutputSourceMap(bundleAssetName)
+      }
+
+  internal fun resolveOutputSourceMap(bundleAssetName: String) =
+      File(jsSourceMapsDir.get().asFile, "$bundleAssetName.map")
+
+  internal fun resolveCompilerSourceMap(bundleAssetName: String) =
+      File(jsIntermediateSourceMapsDir.get().asFile, "$bundleAssetName.compiler.map")
+
+  private fun runCommand(command: List<Any>) {
+    val process = ProcessBuilder(command.map { it.toString() })
+        .directory(root.get().asFile)
+        .redirectErrorStream(true)
+        .start()
+    val exitCode = process.waitFor()
+    if (exitCode != 0) {
+        throw org.gradle.api.GradleException("Command failed with exit code $exitCode: $command")
+    }
+  }
+
+  internal fun getBundleCommand(bundleFile: File, sourceMapFile: File): List<Any> =
+      windowsAwareCommandLine(
+          buildList {
+            val rootFile = root.get().asFile
+            addAll(nodeExecutableAndArgs.get())
+            add(cliFile.get().asFile.cliPath(rootFile))
+            add(bundleCommand.get())
+            add("--platform")
+            add("android")
+            add("--dev")
+            add(devEnabled.get().toString())
+            add("--reset-cache")
+            add("--entry-file")
+            add(entryFile.get().asFile.cliPath(rootFile))
+            add("--bundle-output")
+            add(bundleFile.cliPath(rootFile))
+            add("--assets-dest")
+            add(resourcesDir.get().asFile.cliPath(rootFile))
+            add("--sourcemap-output")
+            add(sourceMapFile.cliPath(rootFile))
+            if (bundleConfig.isPresent) {
+              add("--config")
+              add(bundleConfig.get().asFile.cliPath(rootFile))
+            }
+            add("--minify")
+            add(minifyEnabled.get().toString())
+            addAll(extraPackagerArgs.get())
+            add("--verbose")
+          })
+
+  internal fun getHermescCommand(
+      hermesCommand: String,
+      bytecodeFile: File,
+      bundleFile: File
+  ): 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> {
+    val rootFile = root.get().asFile
+    return windowsAwareCommandLine(
+        *nodeExecutableAndArgs.get().toTypedArray(),
+        composeScript.cliPath(rootFile),
+        packagerSourceMap.cliPath(rootFile),
+        compilerSourceMap.cliPath(rootFile),
+        "-o",
+        outputSourceMap.cliPath(rootFile))
+  }
+}