feat: introduce com.facebook.react.library as separate library plugin

packages/gradle-plugin/build.gradle.kts

@@ -12,6 +12,7 @@ plugins {
 
 tasks.register("build") {
   dependsOn(
+      ":react-native-library-plugin:build",
       ":react-native-gradle-plugin:build",
       ":settings-plugin:build",
       ":shared-testutil:build",
@@ -21,6 +22,7 @@ tasks.register("build") {
 
 tasks.register("clean") {
   dependsOn(
+      ":react-native-library-plugin:clean",
       ":react-native-gradle-plugin:clean",
       ":settings-plugin:clean",
       ":shared-testutil:clean",
@@ -30,6 +32,7 @@ tasks.register("clean") {
 
 tasks.named("ktfmtCheck") {
   dependsOn(
+      ":react-native-library-plugin:ktfmtCheck",
       ":react-native-gradle-plugin:ktfmtCheck",
       ":settings-plugin:ktfmtCheck",
       ":shared-testutil:ktfmtCheck",
@@ -39,6 +42,7 @@ tasks.named("ktfmtCheck") {
 
 tasks.named("ktfmtFormat") {
   dependsOn(
+      ":react-native-library-plugin:ktfmtFormat",
       ":react-native-gradle-plugin:ktfmtFormat",
       ":settings-plugin:ktfmtFormat",
       ":shared-testutil:ktfmtFormat",

packages/gradle-plugin/package.json

@@ -30,6 +30,8 @@
     "gradlew",
     "gradlew.bat",
     "README.md",
+    "react-native-library-plugin",
+    "!react-native-library-plugin/src/test",
     "react-native-gradle-plugin",
     "!react-native-gradle-plugin/src/test",
     "settings-plugin",

packages/gradle-plugin/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/ReactAppCodegenConfigurator.kt

@@ -0,0 +1,141 @@
+/*
+ * 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.ApplicationAndroidComponentsExtension
+import com.android.build.gradle.internal.tasks.factory.dependsOn
+import com.facebook.react.internal.PrivateReactExtension
+import com.facebook.react.tasks.GenerateCodegenArtifactsTask
+import com.facebook.react.tasks.GenerateCodegenSchemaTask
+import com.facebook.react.utils.JsonUtils
+import com.facebook.react.utils.findPackageJsonFile
+import java.io.File
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.file.Directory
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.TaskProvider
+
+@Suppress("UnstableApiUsage")
+object ReactAppCodegenConfigurator {
+  fun configureCodegen(
+      project: Project,
+      localExtension: ReactExtension,
+      rootExtension: PrivateReactExtension,
+      needsCodegenFromPackageJson: (Project, PrivateReactExtension) -> Boolean,
+  ) {
+    val generatedSrcDir: Provider<Directory> =
+        project.layout.buildDirectory.dir("generated/source/codegen")
+
+    localExtension.jsRootDir.convention(localExtension.root)
+
+    val generateCodegenArtifactsTask =
+        registerCodegenTasks(
+            project = project,
+            rootExtension = rootExtension,
+            generatedSrcDir = generatedSrcDir,
+            packageJsonFile = { findPackageJsonFile(project, rootExtension.root) },
+            schemaTaskName = "generateCodegenSchemaFromJavaScript",
+            artifactsTaskName = "generateCodegenArtifactsFromSchema",
+            configureJsRoot = { task, packageJson ->
+              val parsedPackageJson = packageJson?.let { JsonUtils.fromPackageJson(it) }
+              val jsSrcsDirInPackageJson = parsedPackageJson?.codegenConfig?.jsSrcsDir
+
+              if (packageJson != null && jsSrcsDirInPackageJson != null) {
+                task.jsRootDir.set(File(packageJson.parentFile, jsSrcsDirInPackageJson))
+              } else {
+                task.jsRootDir.set(localExtension.jsRootDir)
+              }
+            },
+            configureCodegenArtifacts = { task, _ ->
+              task.codegenJavaPackageName.set(localExtension.codegenJavaPackageName)
+              task.libraryName.set(localExtension.libraryName)
+            },
+            onlyIf = { packageJson ->
+              val needsCodegen =
+                  needsCodegenFromPackageJson(project, rootExtension)
+              val parsedPackageJson = packageJson?.let { JsonUtils.fromPackageJson(it) }
+              val includesGeneratedCode =
+                  parsedPackageJson?.codegenConfig?.includesGeneratedCode ?: false
+              needsCodegen && !includesGeneratedCode
+            },
+        )
+
+    project.extensions.getByType(ApplicationAndroidComponentsExtension::class.java).finalizeDsl { ext
+      ->
+      ext.sourceSets
+          .getByName("main")
+          .java
+          .directories
+          .add(generatedSrcDir.get().dir("java").asFile.path)
+    }
+
+    project.tasks.named("preBuild", Task::class.java).dependsOn(generateCodegenArtifactsTask)
+  }
+
+  fun registerCodegenTasks(
+      project: Project,
+      rootExtension: PrivateReactExtension,
+      generatedSrcDir: Provider<Directory>,
+      packageJsonFile: () -> File?,
+      schemaTaskName: String,
+      artifactsTaskName: String,
+      configureJsRoot: (GenerateCodegenSchemaTask, File?) -> Unit,
+      configureCodegenArtifacts: (GenerateCodegenArtifactsTask, File?) -> Unit,
+      onlyIf: (File?) -> Boolean = { true },
+  ): TaskProvider<GenerateCodegenArtifactsTask> {
+    val generateCodegenSchemaTask =
+        project.tasks.register(
+            schemaTaskName,
+            GenerateCodegenSchemaTask::class.java,
+        ) { task ->
+          val packageJson = packageJsonFile()
+
+          task.nodeExecutableAndArgs.set(rootExtension.nodeExecutableAndArgs)
+          task.codegenDir.set(rootExtension.codegenDir)
+          task.generatedSrcDir.set(generatedSrcDir)
+          task.nodeWorkingDir.set(project.layout.projectDirectory.asFile.absolutePath)
+
+          configureJsRoot(task, packageJson)
+
+          task.jsInputFiles.set(
+              project.fileTree(task.jsRootDir) { tree ->
+                tree.include("**/*.js")
+                tree.include("**/*.jsx")
+                tree.include("**/*.ts")
+                tree.include("**/*.tsx")
+
+                tree.exclude("node_modules/**/*")
+                tree.exclude("**/*.d.ts")
+                tree.exclude("**/build/**/*")
+              }
+          )
+          val shouldRunTask = onlyIf(packageJson)
+          task.onlyIf { shouldRunTask }
+        }
+
+    return project.tasks.register(
+        artifactsTaskName,
+        GenerateCodegenArtifactsTask::class.java,
+    ) { task ->
+      val packageJson = packageJsonFile()
+
+      task.dependsOn(generateCodegenSchemaTask)
+      task.reactNativeDir.set(rootExtension.reactNativeDir)
+      task.nodeExecutableAndArgs.set(rootExtension.nodeExecutableAndArgs)
+      task.generatedSrcDir.set(generatedSrcDir)
+      task.packageJsonFile.set(packageJson)
+      task.nodeWorkingDir.set(project.layout.projectDirectory.asFile.absolutePath)
+
+      configureCodegenArtifacts(task, packageJson)
+
+      val shouldRunTask = onlyIf(packageJson)
+      task.onlyIf { shouldRunTask }
+    }
+  }
+}