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

package/shared/src/test/kotlin/com/facebook/react/utils/TaskUtilsTest.kt

@@ -0,0 +1,76 @@
+/*
+ * 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.tests.OS
+import com.facebook.react.tests.OsRule
+import com.facebook.react.tests.WithOs
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Rule
+import org.junit.Test
+
+class TaskUtilsTest {
+
+  @get:Rule val osRule = OsRule()
+
+  @Test
+  fun windowsAwareCommandLine_withEmptyInput_isEmpty() {
+    assertThat(windowsAwareCommandLine().isEmpty()).isTrue()
+  }
+
+  @Test
+  fun windowsAwareCommandLine_withList_isEqualAsVararg() {
+    assertThat(windowsAwareCommandLine(listOf("a", "b", "c")))
+        .isEqualTo(windowsAwareCommandLine("a", "b", "c"))
+  }
+
+  @Test
+  @WithOs(OS.MAC)
+  fun windowsAwareCommandLine_onMac_returnsTheList() {
+    assertThat(listOf("a", "b", "c")).isEqualTo(windowsAwareCommandLine("a", "b", "c"))
+  }
+
+  @Test
+  @WithOs(OS.LINUX)
+  fun windowsAwareCommandLine_onLinux_returnsTheList() {
+    assertThat(listOf("a", "b", "c")).isEqualTo(windowsAwareCommandLine("a", "b", "c"))
+  }
+
+  @Test
+  @WithOs(OS.WIN)
+  fun windowsAwareCommandLine_onWindows_prependsCmd() {
+    assertThat(listOf("cmd", "/c", "a", "b", "c")).isEqualTo(windowsAwareCommandLine("a", "b", "c"))
+  }
+
+  @Test
+  @WithOs(OS.MAC)
+  fun windowsAwareBashCommandLine_onMac_returnsTheList() {
+    assertThat(listOf("a", "b", "c"))
+        .isEqualTo(windowsAwareBashCommandLine("a", "b", "c", bashWindowsHome = "abc"))
+  }
+
+  @Test
+  @WithOs(OS.LINUX)
+  fun windowsAwareBashCommandLine_onLinux_returnsTheList() {
+    assertThat(listOf("a", "b", "c")).isEqualTo(windowsAwareBashCommandLine("a", "b", "c"))
+  }
+
+  @Test
+  @WithOs(OS.WIN)
+  fun windowsAwareBashCommandLine_onWindows_prependsBash() {
+    assertThat(listOf("bash", "-c", "a", "b", "c"))
+        .isEqualTo(windowsAwareBashCommandLine("a", "b", "c"))
+  }
+
+  @Test
+  @WithOs(OS.WIN)
+  fun windowsAwareBashCommandLine_onWindows_prependsCustomBashPath() {
+    assertThat(listOf("/custom/bash", "-c", "a", "b", "c"))
+        .isEqualTo(windowsAwareBashCommandLine("a", "b", "c", bashWindowsHome = "/custom/bash"))
+  }
+}

package/shared-testutil/build.gradle.kts

@@ -0,0 +1,46 @@
+/*
+ * 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.
+ */
+
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+  alias(libs.plugins.kotlin.jvm)
+  alias(libs.plugins.ktfmt)
+}
+
+repositories { mavenCentral() }
+
+group = "com.facebook.react"
+
+dependencies { implementation(libs.junit) }
+
+java { targetCompatibility = JavaVersion.VERSION_11 }
+
+kotlin { jvmToolchain(26) }
+
+tasks.withType<KotlinCompile>().configureEach {
+  compilerOptions {
+    apiVersion.set(KotlinVersion.KOTLIN_1_8)
+    // See comment above on JDK 11 support
+    jvmTarget.set(JvmTarget.JVM_11)
+    allWarningsAsErrors.set(
+        project.properties["enableWarningsAsErrors"]?.toString()?.toBoolean() ?: false
+    )
+  }
+}
+
+tasks.withType<Test>().configureEach {
+  testLogging {
+    exceptionFormat = TestExceptionFormat.FULL
+    showExceptions = true
+    showCauses = true
+    showStackTraces = true
+  }
+}

package/shared-testutil/src/main/kotlin/com/facebook/react/tests/OsRule.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.tests
+
+import org.junit.rules.TestRule
+import org.junit.runner.Description
+import org.junit.runners.model.Statement
+
+/**
+ * A JUnit [TestRule] to override values of [System.getProperties] with the support of the [WithOs]
+ * annotation.
+ */
+class OsRule : TestRule {
+
+  private var retainOs: String? = null
+  private var retainArch: String? = null
+
+  override fun apply(statement: Statement, description: Description): Statement {
+    return object : Statement() {
+      override fun evaluate() {
+        val annotation = description.annotations.filterIsInstance<WithOs>().firstOrNull()
+
+        annotation?.os?.propertyName?.let { osName ->
+          retainOs = System.getProperty(OS_NAME_KEY)
+          System.setProperty(OS_NAME_KEY, osName)
+        }
+        annotation?.arch?.let { arch ->
+          if (arch.isNotBlank()) {
+            retainArch = System.getProperty(OS_ARCH_KEY)
+            System.setProperty(OS_ARCH_KEY, arch)
+          }
+        }
+        try {
+          statement.evaluate()
+        } finally {
+          retainOs?.let { System.setProperty(OS_NAME_KEY, it) }
+          retainArch?.let { System.setProperty(OS_ARCH_KEY, it) }
+        }
+      }
+    }
+  }
+
+  companion object {
+    const val OS_NAME_KEY = "os.name"
+    const val OS_ARCH_KEY = "os.arch"
+  }
+}

package/shared-testutil/src/main/kotlin/com/facebook/react/tests/WithOs.kt

@@ -0,0 +1,17 @@
+/*
+ * 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.tests
+
+/** Annotation to specify an Operating System to override the "os.name" System Property. */
+@Retention(AnnotationRetention.RUNTIME) annotation class WithOs(val os: OS, val arch: String = "")
+
+enum class OS(val propertyName: String) {
+  WIN("Windows"),
+  MAC("MacOs"),
+  LINUX("Linux"),
+}

package/index.js

@@ -1,73 +0,0 @@
-/**
- * react-native-gradle-plugin Node.js entry point
- *
- * This package is a Gradle/Kotlin build plugin for React Native.
- * It is compiled to a JAR file and loaded via the JVM/Gradle runtime.
- * This JS entry point provides a bridge to invoke the Gradle plugin
- * from Node.js using the available JVM and Gradle toolchain.
- */
-
-const { execSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-
-// Locate the compiled JAR
-const jarPath = path.join(__dirname, 'build', 'libs', 'react-native-gradle-plugin.jar');
-
-// Package metadata
-const pkg = require('./package.json');
-
-/**
- * Get the path to the compiled Gradle plugin JAR.
- * @returns {string} Absolute path to the JAR file
- */
-function getJarPath() {
-  return jarPath;
-}
-
-/**
- * Check if the JAR has been compiled and is available.
- * @returns {boolean} True if the JAR exists
- */
-function isCompiled() {
-  return fs.existsSync(jarPath);
-}
-
-/**
- * Run the Gradle plugin via the Gradle build tool.
- * This invokes the Gradle build system with the React Native plugin applied.
- *
- * @param {Object} options - Options for the Gradle invocation
- * @param {string} options.projectDir - Directory of the project to build
- * @param {string[]} options.tasks - Gradle tasks to execute
- * @param {Object} options.gradleProps - Additional Gradle properties
- * @returns {string} Output of the Gradle command
- */
-function runGradle(options = {}) {
-  const projectDir = options.projectDir || process.cwd();
-  const tasks = options.tasks || ['assembleRelease'];
-  const gradleCmd = process.env.GRADLE_CMD || 'gradle';
-  const args = [gradleCmd, ...tasks, '-p', projectDir];
-
-  if (options.gradleProps) {
-    for (const [key, value] of Object.entries(options.gradleProps)) {
-      args.push(`-P${key}=${value}`);
-    }
-  }
-
-  const cmd = args.join(' ');
-  return execSync(cmd, {
-    cwd: projectDir,
-    encoding: 'utf-8',
-    stdio: 'pipe',
-  });
-}
-
-module.exports = {
-  name: pkg.name,
-  version: pkg.version,
-  description: pkg.description,
-  getJarPath,
-  isCompiled,
-  runGradle,
-};

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

@@ -1,212 +0,0 @@
-/*
- * 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/tasks/internal/PrepareJSCTask.kt

@@ -1,50 +0,0 @@
-/*
- * 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.internal
-
-import java.io.File
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.*
-
-/**
- * A task that takes care of unbundling JSC and preparing it for be consumed by the Android NDK.
- * Specifically it will unbundle shared libs, headers and will copy over the Makefile from
- * `src/main/jni/third-party/jsc/`
- */
-abstract class PrepareJSCTask : DefaultTask() {
-
-  @get:Input abstract val jscPackagePath: Property<String>
-
-  @get:OutputDirectory abstract val outputDir: DirectoryProperty
-
-  @TaskAction
-  fun taskAction() {
-    if (!jscPackagePath.isPresent || jscPackagePath.orNull == null) {
-      error("Could not find the jsc-android npm package")
-    }
-    val jscDist = File(jscPackagePath.get(), "dist")
-    if (!jscDist.exists()) {
-      error("The jsc-android npm package is missing its \"dist\" directory")
-    }
-    val jscAAR =
-        project.fileTree(jscDist).matching { it.include("**/android-jsc/**/*.aar") }.singleFile
-    val soFiles = project.zipTree(jscAAR).matching { it.include("**/*.so") }
-    val headerFiles = project.fileTree(jscDist).matching { it.include("**/include/*.h") }
-
-    project.copy { it ->
-      it.from(soFiles)
-      it.from(headerFiles)
-      it.from(project.file("src/main/jni/third-party/jsc/CMakeLists.txt"))
-      it.filesMatching("**/*.h") { it.path = "JavaScriptCore/${it.name}" }
-      it.includeEmptyDirs = false
-      it.into(outputDir)
-    }
-  }
-}

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

@@ -1,51 +0,0 @@
-/*
- * 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.internal
-
-import java.io.File
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.provider.Property
-import org.gradle.api.tasks.*
-
-/**
- * A task that takes care of extracting Libevent from a source folder/zip and preparing it to be
- * consumed by the NDK.
- */
-abstract class PrepareLibeventTask : DefaultTask() {
-
-  @get:InputFiles abstract val libeventPath: ConfigurableFileCollection
-
-  @get:Input abstract val libeventVersion: Property<String>
-
-  @get:OutputDirectory abstract val outputDir: DirectoryProperty
-
-  @TaskAction
-  fun taskAction() {
-    project.copy { it ->
-      it.from(libeventPath)
-      it.from(project.file("src/main/jni/third-party/libevent/"))
-      it.include(
-          "libevent-${libeventVersion.get()}-stable/*.c",
-          "libevent-${libeventVersion.get()}-stable/*.h",
-          "libevent-${libeventVersion.get()}-stable/include/**/*",
-          "evconfig-private.h",
-          "event-config.h",
-          "CMakeLists.txt")
-      it.eachFile { it.path = it.path.removePrefix("libevent-${libeventVersion.get()}-stable/") }
-      it.includeEmptyDirs = false
-      it.into(outputDir)
-    }
-    File(outputDir.asFile.get(), "event-config.h").apply {
-      val destination =
-          File(this.parentFile, "include/event2/event-config.h").apply { parentFile.mkdirs() }
-      renameTo(destination)
-    }
-  }
-}

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

@@ -1,54 +0,0 @@
-/*
- * 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.facebook.react.utils.ProjectUtils.isHermesEnabled
-import com.facebook.react.utils.ProjectUtils.isNewArchEnabled
-import org.gradle.api.Action
-import org.gradle.api.Project
-import org.gradle.api.plugins.AppliedPlugin
-
-@Suppress("UnstableApiUsage")
-internal object AgpConfiguratorUtils {
-
-  fun configureBuildConfigFields(project: Project) {
-    val action =
-        Action<AppliedPlugin> {
-          project.extensions.getByType(AndroidComponentsExtension::class.java).finalizeDsl { ext ->
-            ext.defaultConfig.buildConfigField(
-                "boolean", "IS_NEW_ARCHITECTURE_ENABLED", project.isNewArchEnabled.toString())
-            ext.defaultConfig.buildConfigField(
-                "boolean", "IS_HERMES_ENABLED", project.isHermesEnabled.toString())
-          }
-        }
-    project.pluginManager.withPlugin("com.android.application", action)
-    project.pluginManager.withPlugin("com.android.library", action)
-  }
-
-  fun configureDevPorts(project: Project) {
-    val devServerPort =
-        project.properties["reactNativeDevServerPort"]?.toString() ?: DEFAULT_DEV_SERVER_PORT
-    val inspectorProxyPort =
-        project.properties["reactNativeInspectorProxyPort"]?.toString() ?: devServerPort
-
-    val action =
-        Action<AppliedPlugin> {
-          project.extensions.getByType(AndroidComponentsExtension::class.java).finalizeDsl { ext ->
-            ext.defaultConfig.resValue("integer", "react_native_dev_server_port", devServerPort)
-            ext.defaultConfig.resValue(
-                "integer", "react_native_inspector_proxy_port", inspectorProxyPort)
-          }
-        }
-
-    project.pluginManager.withPlugin("com.android.application", action)
-    project.pluginManager.withPlugin("com.android.library", action)
-  }
-}
-
-const val DEFAULT_DEV_SERVER_PORT = "8081"

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

@@ -1,48 +0,0 @@
-/*
- * 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.util.*
-import org.gradle.api.Project
-
-internal object BackwardCompatUtils {
-
-  fun configureBackwardCompatibilityReactMap(project: Project) {
-    if (project.extensions.extraProperties.has("react")) {
-      @Suppress("UNCHECKED_CAST")
-      val reactMap =
-          project.extensions.extraProperties.get("react") as? Map<String, Any?> ?: mapOf()
-      if (reactMap.isNotEmpty()) {
-        project.logger.error(
-            """
-          ********************************************************************************
- 
-          ERROR: Using old project.ext.react configuration.
-          We identified that your project is using a old configuration block as:
-          
-          project.ext.react = [
-              // ...
-          ]
-          
-          You should migrate to the new configuration:
-          
-          react {
-              // ...
-          }
-          You can find documentation inside `android/app/build.gradle` on how to use it.
-        
-          ********************************************************************************
-          """
-                .trimIndent())
-      }
-    }
-
-    // We set an empty react[] map so if a library is reading it, they will find empty values.
-    project.extensions.extraProperties.set("react", mapOf<String, String>())
-  }
-}