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

package/{src → react-native-gradle-plugin/src}/main/kotlin/com/facebook/react/utils/NdkConfiguratorUtils.kt

@@ -7,11 +7,10 @@
 
 package com.facebook.react.utils
 
-import com.android.build.api.variant.AndroidComponentsExtension
+import com.android.build.api.variant.ApplicationAndroidComponentsExtension
 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
 
@@ -19,11 +18,8 @@ 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
-        }
+      project.extensions.getByType(ApplicationAndroidComponentsExtension::class.java).finalizeDsl {
+          ext ->
         // We enable prefab so users can consume .so/headers from ReactAndroid and hermes-engine
         // .aar
         ext.buildFeatures.prefab = true
@@ -34,22 +30,30 @@ internal object NdkConfiguratorUtils {
           ext.externalNativeBuild.cmake.path =
               File(
                   extension.reactNativeDir.get().asFile,
-                  "ReactAndroid/cmake-utils/default-app-setup/CMakeLists.txt")
+                  "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 (cmakeArgs.none { it.startsWith("-DPROJECT_BUILD_DIR") }) {
+          cmakeArgs.add("-DPROJECT_BUILD_DIR=${project.layout.buildDirectory.get().asFile}")
+        }
+        if (cmakeArgs.none { it.startsWith("-DPROJECT_ROOT_DIR") }) {
+          cmakeArgs.add("-DPROJECT_ROOT_DIR=${project.rootProject.layout.projectDirectory.asFile}")
         }
-        if ("-DREACT_ANDROID_DIR" !in cmakeArgs) {
+        if (cmakeArgs.none { it.startsWith("-DREACT_ANDROID_DIR") }) {
           cmakeArgs.add(
-              "-DREACT_ANDROID_DIR=${extension.reactNativeDir.file("ReactAndroid").get().asFile}")
+              "-DREACT_ANDROID_DIR=${extension.reactNativeDir.file("ReactAndroid").get().asFile}"
+          )
         }
-        if ("-DANDROID_STL" !in cmakeArgs) {
+        if (cmakeArgs.none { it.startsWith("-DANDROID_STL") }) {
           cmakeArgs.add("-DANDROID_STL=c++_shared")
         }
+        if (cmakeArgs.none { it.startsWith("-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES") }) {
+          cmakeArgs.add("-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON")
+        }
 
         val architectures = project.getReactNativeArchitectures()
         // abiFilters are split ABI are not compatible each other, so we set the abiFilters
@@ -68,48 +72,23 @@ internal object NdkConfiguratorUtils {
    */
   fun configureNewArchPackagingOptions(
       project: Project,
+      extension: ReactExtension,
       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",
-          ))
-    }
+    // 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.
+            "**/libreactnative.so",
+            "**/libjsi.so",
+            // AGP will give priority of libc++_shared coming from App modules.
+            "**/libc++_shared.so",
+        )
+    )
   }
 
   /**
@@ -120,27 +99,42 @@ internal object NdkConfiguratorUtils {
       config: ReactExtension,
       variant: Variant,
       hermesEnabled: Boolean,
+      useThirdPartyJSC: Boolean,
   ) {
     if (config.enableSoCleanup.get()) {
-      val (excludes, includes) = getPackagingOptionsForVariant(hermesEnabled)
+      val (excludes, includes) = getPackagingOptionsForVariant(hermesEnabled, useThirdPartyJSC)
       variant.packaging.jniLibs.excludes.addAll(excludes)
       variant.packaging.jniLibs.pickFirsts.addAll(includes)
     }
   }
 
-  fun getPackagingOptionsForVariant(hermesEnabled: Boolean): Pair<List<String>, List<String>> {
+  fun getPackagingOptionsForVariant(
+      hermesEnabled: Boolean,
+      useThirdPartyJSC: 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")
+
+    // note: libjsctooling.so is kept here for backward compatibility.
+    when {
+      hermesEnabled -> {
+        excludes.add("**/libjsc.so")
+        excludes.add("**/libjsctooling.so")
+        includes.add("**/libhermesvm.so")
+        includes.add("**/libhermestooling.so")
+      }
+      useThirdPartyJSC -> {
+        excludes.add("**/libhermesvm.so")
+        excludes.add("**/libhermestooling.so")
+        excludes.add("**/libjsctooling.so")
+        includes.add("**/libjsc.so")
+      }
+      else -> {
+        excludes.add("**/libhermesvm.so")
+        excludes.add("**/libhermestooling.so")
+        includes.add("**/libjsc.so")
+        includes.add("**/libjsctooling.so")
+      }
     }
     return excludes to includes
   }

package/{src → react-native-gradle-plugin/src}/main/kotlin/com/facebook/react/utils/PathUtils.kt

@@ -11,6 +11,7 @@ package com.facebook.react.utils
 
 import com.facebook.react.ReactExtension
 import com.facebook.react.model.ModelPackageJson
+import com.facebook.react.utils.KotlinStdlibCompatUtils.capitalizeCompat
 import com.facebook.react.utils.Os.cliPath
 import java.io.File
 import org.gradle.api.Project
@@ -29,7 +30,8 @@ internal fun detectedEntryFile(config: ReactExtension, envVariableOverride: Stri
     detectEntryFile(
         entryFile = config.entryFile.orNull?.asFile,
         reactRoot = config.root.get().asFile,
-        envVariableOverride = envVariableOverride)
+        envVariableOverride = envVariableOverride,
+    )
 
 /**
  * Computes the CLI file for React Native. The Algo follows this order:
@@ -40,17 +42,19 @@ internal fun detectedEntryFile(config: ReactExtension, envVariableOverride: Stri
  */
 internal fun detectedCliFile(config: ReactExtension): File =
     detectCliFile(
+        project = config.project,
         reactNativeRoot = config.root.get().asFile,
-        preconfiguredCliFile = config.cliFile.asFile.orNull)
+        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.
+ *    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 =
@@ -59,7 +63,7 @@ internal fun detectedHermesCommand(config: ReactExtension): String =
 private fun detectEntryFile(
     entryFile: File?,
     reactRoot: File,
-    envVariableOverride: String? = null
+    envVariableOverride: String? = null,
 ): File =
     when {
       envVariableOverride != null -> File(reactRoot, envVariableOverride)
@@ -68,7 +72,11 @@ private fun detectEntryFile(
       else -> File(reactRoot, "index.js")
     }
 
-private fun detectCliFile(reactNativeRoot: File, preconfiguredCliFile: File?): File {
+private fun detectCliFile(
+    project: Project,
+    reactNativeRoot: File,
+    preconfiguredCliFile: File?,
+): File {
   // 1. preconfigured path
   if (preconfiguredCliFile != null) {
     if (preconfiguredCliFile.exists()) {
@@ -78,13 +86,12 @@ private fun detectCliFile(reactNativeRoot: File, preconfiguredCliFile: File?): F
 
   // 2. node module path
   val nodeProcess =
-      Runtime.getRuntime()
-          .exec(
-              arrayOf("node", "--print", "require.resolve('react-native/cli');"),
-              emptyArray(),
-              reactNativeRoot)
+      project.providers.exec { exec ->
+        exec.commandLine("node", "--print", "require.resolve('react-native/cli');")
+        exec.workingDir(reactNativeRoot)
+      }
 
-  val nodeProcessOutput = nodeProcess.inputStream.use { it.bufferedReader().readText().trim() }
+  val nodeProcessOutput = nodeProcess.standardOutput.asText.get().trim()
 
   if (nodeProcessOutput.isNotEmpty()) {
     val nodeModuleCliJs = File(nodeProcessOutput)
@@ -102,26 +109,31 @@ private fun detectCliFile(reactNativeRoot: File, preconfiguredCliFile: File?): F
   error(
       """
       Couldn't determine CLI location!
-      
-      Please set `react { cliFile = file(...) }` inside your 
+
+      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())
+      """
+          .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.
+ *    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. Or, if the user has opted in to use Hermes V1, the used file will be
+ *    located in `node_modules/hermes-compiler/%OS-BIN%/hermesc` where `%OS-BIN%` is substituted
+ *    with the correct OS arch.
  * 4. Fails otherwise
  */
-internal fun detectOSAwareHermesCommand(projectRoot: File, hermesCommand: String): String {
-  // 1. If the project specifies a Hermes command, don't second guess it.
+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) {
@@ -141,9 +153,9 @@ internal fun detectOSAwareHermesCommand(projectRoot: File, hermesCommand: String
     return builtHermesc.cliPath(projectRoot)
   }
 
-  // 3. If the react-native contains a pre-built hermesc, use it.
+  // 3. Use hermes-compiler from npm
   val prebuiltHermesPath =
-      HERMESC_IN_REACT_NATIVE_DIR.plus(getHermesCBin())
+      HERMES_COMPILER_NPM_DIR.plus(getHermesCBin())
           .replace("%OS-BIN%", getHermesOSBin())
           // Execution on Windows fails with / as separator
           .replace('/', File.separatorChar)
@@ -156,7 +168,8 @@ internal fun detectOSAwareHermesCommand(projectRoot: File, hermesCommand: String
   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")
+          "node_modules/react-native/sdks/hermesc/%OS-BIN%/hermesc"
+  )
 }
 
 /**
@@ -182,13 +195,14 @@ internal fun getHermesOSBin(): String {
   if (Os.isLinuxAmd64()) return "linux64-bin"
   error(
       "OS not recognized. Please set project.react.hermesCommand " +
-          "to the path of a working Hermes compiler.")
+          "to the path of a working Hermes compiler."
+  )
 }
 
 internal fun projectPathToLibraryName(projectPath: String): String =
     projectPath
         .split(':', '-', '_', '.')
-        .joinToString("") { token -> token.replaceFirstChar { it.uppercase() } }
+        .joinToString("") { token -> token.capitalizeCompat() }
         .plus("Spec")
 
 /**
@@ -220,12 +234,12 @@ internal fun findPackageJsonFile(project: Project, rootProperty: DirectoryProper
  */
 internal fun readPackageJsonFile(
     project: Project,
-    rootProperty: DirectoryProperty
+    rootProperty: DirectoryProperty,
 ): ModelPackageJson? {
   val packageJson = findPackageJsonFile(project, rootProperty)
-  return packageJson?.let { JsonUtils.fromCodegenJson(it) }
+  return packageJson?.let { JsonUtils.fromPackageJson(it) }
 }
 
-private const val HERMESC_IN_REACT_NATIVE_DIR = "node_modules/react-native/sdks/hermesc/%OS-BIN%/"
+private const val HERMES_COMPILER_NPM_DIR = "node_modules/hermes-compiler/hermesc/%OS-BIN%/"
 private const val HERMESC_BUILT_FROM_SOURCE_DIR =
     "node_modules/react-native/ReactAndroid/hermes-engine/build/hermes/bin/"

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/utils/ProjectUtils.kt

@@ -0,0 +1,119 @@
+/*
+ * 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.ReactExtension
+import com.facebook.react.model.ModelPackageJson
+import com.facebook.react.utils.KotlinStdlibCompatUtils.lowercaseCompat
+import com.facebook.react.utils.KotlinStdlibCompatUtils.toBooleanStrictOrNullCompat
+import com.facebook.react.utils.PropertyUtils.EDGE_TO_EDGE_ENABLED
+import com.facebook.react.utils.PropertyUtils.HERMES_ENABLED
+import com.facebook.react.utils.PropertyUtils.HERMES_V1_ENABLED
+import com.facebook.react.utils.PropertyUtils.REACT_NATIVE_ARCHITECTURES
+import com.facebook.react.utils.PropertyUtils.SCOPED_EDGE_TO_EDGE_ENABLED
+import com.facebook.react.utils.PropertyUtils.SCOPED_HERMES_ENABLED
+import com.facebook.react.utils.PropertyUtils.SCOPED_HERMES_V1_ENABLED
+import com.facebook.react.utils.PropertyUtils.SCOPED_REACT_NATIVE_ARCHITECTURES
+import com.facebook.react.utils.PropertyUtils.SCOPED_USE_THIRD_PARTY_JSC
+import com.facebook.react.utils.PropertyUtils.USE_THIRD_PARTY_JSC
+import org.gradle.api.Project
+import org.gradle.api.file.DirectoryProperty
+import org.jetbrains.kotlin.gradle.plugin.extraProperties
+
+internal object ProjectUtils {
+
+  const val HERMES_FALLBACK = true
+
+  const val HERMES_V1_ENABLED_FALLBACK = true
+
+  internal fun Project.isNewArchEnabled(): Boolean = true
+
+  internal val Project.isHermesEnabled: Boolean
+    get() =
+        if (project.hasProperty(HERMES_ENABLED) || project.hasProperty(SCOPED_HERMES_ENABLED)) {
+          val propertyString =
+              if (project.hasProperty(HERMES_ENABLED)) {
+                HERMES_ENABLED
+              } else {
+                SCOPED_HERMES_ENABLED
+              }
+          project
+              .property(propertyString)
+              .toString()
+              .lowercaseCompat()
+              .toBooleanStrictOrNullCompat() ?: 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.lowercaseCompat().toBooleanStrictOrNullCompat() ?: true
+            else -> HERMES_FALLBACK
+          }
+        } else {
+          HERMES_FALLBACK
+        }
+
+  internal val Project.isEdgeToEdgeEnabled: Boolean
+    get() =
+        (project.hasProperty(EDGE_TO_EDGE_ENABLED) &&
+            project.property(EDGE_TO_EDGE_ENABLED).toString().toBoolean()) ||
+            (project.hasProperty(SCOPED_EDGE_TO_EDGE_ENABLED) &&
+                project.property(SCOPED_EDGE_TO_EDGE_ENABLED).toString().toBoolean())
+
+  internal val Project.useThirdPartyJSC: Boolean
+    get() =
+        (project.hasProperty(USE_THIRD_PARTY_JSC) &&
+            project.property(USE_THIRD_PARTY_JSC).toString().toBoolean()) ||
+            (project.hasProperty(SCOPED_USE_THIRD_PARTY_JSC) &&
+                project.property(SCOPED_USE_THIRD_PARTY_JSC).toString().toBoolean())
+
+  internal val Project.isHermesV1Enabled: Boolean
+    get() =
+        if (
+            project.hasProperty(HERMES_V1_ENABLED) || project.hasProperty(SCOPED_HERMES_V1_ENABLED)
+        ) {
+          (project.hasProperty(HERMES_V1_ENABLED) &&
+              project.property(HERMES_V1_ENABLED).toString().toBoolean()) ||
+              (project.hasProperty(SCOPED_HERMES_V1_ENABLED) &&
+                  project.property(SCOPED_HERMES_V1_ENABLED).toString().toBoolean()) ||
+              (project.extraProperties.has(HERMES_V1_ENABLED) &&
+                  project.extraProperties.get(HERMES_V1_ENABLED).toString().toBoolean()) ||
+              (project.extraProperties.has(SCOPED_HERMES_V1_ENABLED) &&
+                  project.extraProperties.get(SCOPED_HERMES_V1_ENABLED).toString().toBoolean())
+        } else {
+          HERMES_V1_ENABLED_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(REACT_NATIVE_ARCHITECTURES)) {
+      val architecturesString = project.property(REACT_NATIVE_ARCHITECTURES).toString()
+      architectures.addAll(architecturesString.split(",").filter { it.isNotBlank() })
+    } else if (project.hasProperty(SCOPED_REACT_NATIVE_ARCHITECTURES)) {
+      val architecturesString = project.property(SCOPED_REACT_NATIVE_ARCHITECTURES).toString()
+      architectures.addAll(architecturesString.split(",").filter { it.isNotBlank() })
+    }
+    return architectures
+  }
+
+  internal fun Project.reactNativeDir(extension: ReactExtension): String =
+      extension.reactNativeDir.get().asFile.absolutePath
+
+  internal fun Project.hasPropertySetToFalse(property: String): Boolean =
+      this.hasProperty(property) && this.property(property).toString().toBoolean() == false
+}

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/utils/PropertyUtils.kt

@@ -0,0 +1,96 @@
+/*
+ * 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
+
+/** Collection of all the Gradle Properties that are accepted by React Native Gradle Plugin. */
+object PropertyUtils {
+
+  /** Public property that toggles the New Architecture */
+  const val NEW_ARCH_ENABLED = "newArchEnabled"
+  const val SCOPED_NEW_ARCH_ENABLED = "react.newArchEnabled"
+
+  /** Public property that toggles Hermes */
+  const val HERMES_ENABLED = "hermesEnabled"
+  const val SCOPED_HERMES_ENABLED = "react.hermesEnabled"
+
+  /** Public property that toggles Hermes V1 */
+  const val HERMES_V1_ENABLED = "hermesV1Enabled"
+  const val SCOPED_HERMES_V1_ENABLED = "react.hermesV1Enabled"
+
+  /** Public property that toggles edge-to-edge */
+  const val EDGE_TO_EDGE_ENABLED = "edgeToEdgeEnabled"
+  const val SCOPED_EDGE_TO_EDGE_ENABLED = "react.edgeToEdgeEnabled"
+
+  /** Public property that excludes jsctooling from core */
+  const val USE_THIRD_PARTY_JSC = "useThirdPartyJSC"
+  const val SCOPED_USE_THIRD_PARTY_JSC = "react.useThirdPartyJSC"
+
+  /** Public property that allows to control which architectures to build for React Native. */
+  const val REACT_NATIVE_ARCHITECTURES = "reactNativeArchitectures"
+  const val SCOPED_REACT_NATIVE_ARCHITECTURES = "react.nativeArchitectures"
+
+  /** Public property that allows to control whether the JitPack repository is included or not */
+  const val INCLUDE_JITPACK_REPOSITORY = "includeJitpackRepository"
+  const val SCOPED_INCLUDE_JITPACK_REPOSITORY = "react.includeJitpackRepository"
+
+  /**
+   * Public property that allows to configure an enterprise repository proxy as exclusive repository
+   */
+  const val EXCLUSIVE_ENTEPRISE_REPOSITORY = "exclusiveEnterpriseRepository"
+  const val SCOPED_EXCLUSIVE_ENTEPRISE_REPOSITORY = "react.exclusiveEnterpriseRepository"
+
+  /** By default we include JitPack to avoid breaking user builds */
+  internal const val INCLUDE_JITPACK_REPOSITORY_DEFAULT = true
+
+  /**
+   * Internal Property that acts as a killswitch to configure the JDK version and align it for app
+   * and all the libraries.
+   */
+  const val INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT = "react.internal.disableJavaVersionAlignment"
+
+  /**
+   * Internal Property that allows to specify a local Maven repository to use for React Native
+   * artifacts It's used on CI to test templates against a version of React Native built on the fly.
+   */
+  const val INTERNAL_REACT_NATIVE_MAVEN_LOCAL_REPO = "react.internal.mavenLocalRepo"
+
+  /**
+   * Internal property used to specify where the Windows Bash executable is located. This is useful
+   * for contributors who are running Windows on their machine.
+   */
+  const val INTERNAL_REACT_WINDOWS_BASH = "react.internal.windowsBashPath"
+
+  /**
+   * Controls whether to use Hermes from stable builds. This will force hermes version set in the
+   * sdks/hermes-engine/version.properties file to be used. This has a higher priority than
+   * react.internal.useHermesNightly.
+   */
+  const val INTERNAL_USE_HERMES_STABLE = "react.internal.useHermesStable"
+
+  /**
+   * Internal property to force the build to use Hermes from the latest nightly. This speeds up the
+   * build at the cost of not testing the latest integration against Hermes.
+   */
+  const val INTERNAL_USE_HERMES_NIGHTLY = "react.internal.useHermesNightly"
+
+  /** Internal property used to override the publishing group for the React Native artifacts. */
+  const val INTERNAL_REACT_PUBLISHING_GROUP = "react.internal.publishingGroup"
+  const val INTERNAL_HERMES_PUBLISHING_GROUP = "react.internal.hermesPublishingGroup"
+  const val DEFAULT_INTERNAL_REACT_PUBLISHING_GROUP = "com.facebook.react"
+  const val DEFAULT_INTERNAL_HERMES_PUBLISHING_GROUP = "com.facebook.hermes"
+
+  /** Internal property used to control the version name of React Native */
+  const val INTERNAL_VERSION_NAME = "VERSION_NAME"
+
+  /**
+   * Internal properties, shared with iOS, used to control the version name of Hermes Engine. They
+   * are stored in sdks/hermes-engine/version.properties
+   */
+  const val INTERNAL_HERMES_VERSION_NAME = "HERMES_VERSION_NAME"
+  const val INTERNAL_HERMES_V1_VERSION_NAME = "HERMES_V1_VERSION_NAME"
+}

package/settings-plugin/build.gradle.kts

@@ -0,0 +1,73 @@
+/*
+ * 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)
+  id("java-gradle-plugin")
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+gradlePlugin {
+  plugins {
+    create("react.settings") {
+      id = "com.facebook.react.settings"
+      implementationClass = "com.facebook.react.ReactSettingsPlugin"
+    }
+  }
+}
+
+group = "com.facebook.react"
+
+dependencies {
+  implementation(project(":shared"))
+
+  implementation(gradleApi())
+  implementation(libs.gson)
+  implementation(libs.guava)
+  implementation(libs.javapoet)
+
+  testImplementation(libs.junit)
+  testImplementation(libs.assertj)
+  testImplementation(project(":shared-testutil"))
+}
+
+// We intentionally don't build for Java 17 as users will see a cryptic bytecode version
+// error first. Instead we produce a Java 11-compatible Gradle Plugin, so that AGP can print their
+// nice message showing that JDK 11 (or 17) is required first
+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
+  }
+}