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

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/tasks/GeneratePackageListTask.kt

@@ -0,0 +1,214 @@
+/*
+ * 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.model.ModelAutolinkingConfigJson
+import com.facebook.react.model.ModelAutolinkingDependenciesPlatformAndroidJson
+import com.facebook.react.utils.JsonUtils
+import java.io.File
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+
+abstract class GeneratePackageListTask : DefaultTask() {
+
+  init {
+    group = "react"
+  }
+
+  @get:InputFile abstract val autolinkInputFile: RegularFileProperty
+
+  @get:OutputDirectory abstract val generatedOutputDirectory: DirectoryProperty
+
+  @TaskAction
+  fun taskAction() {
+    val model =
+        JsonUtils.fromAutolinkingConfigJson(autolinkInputFile.get().asFile)
+            ?: error(
+                """
+                   RNGP - Autolinking: Could not parse autolinking config file:
+                   ${autolinkInputFile.get().asFile.absolutePath}
+                   
+                   The file is either missing or not containing valid JSON so the build won't succeed. 
+                 """
+                    .trimIndent()
+            )
+
+    val packageName =
+        model.project?.android?.packageName
+            ?: error(
+                "RNGP - Autolinking: Could not find project.android.packageName in react-native config output! Could not autolink packages without this field."
+            )
+
+    val androidPackages = filterAndroidPackages(model)
+    val packageClassInstance = composePackageInstance(packageName, androidPackages)
+    val generatedFileContents = composeFileContent(packageClassInstance)
+
+    val outputDir = generatedOutputDirectory.get().asFile
+    outputDir.mkdirs()
+    File(outputDir, GENERATED_FILENAME).apply {
+      parentFile.mkdirs()
+      writeText(generatedFileContents)
+    }
+  }
+
+  /**
+   * Extracts the fully qualified class name from an import statement. E.g., "import
+   * com.foo.bar.MyClass;" -> "com.foo.bar.MyClass"
+   */
+  internal fun extractFqcnFromImport(importStatement: String): String? {
+    val match = Regex("import\\s+([\\w.]+)\\s*;").find(importStatement)
+    return match?.groupValues?.get(1)
+  }
+
+  internal fun composePackageInstance(
+      packageName: String,
+      packages: Map<String, ModelAutolinkingDependenciesPlatformAndroidJson>,
+  ): String {
+    if (packages.isEmpty()) {
+      return ""
+    }
+
+    val instances =
+        packages.entries.map { (name, dep) ->
+          val packageInstance =
+              requireNotNull(dep.packageInstance) {
+                "RNGP - Autolinking: Missing `packageInstance` in `config` for dependency $name. This is required to generate the autolinking package list."
+              }
+          val packageImportPath = dep.packageImportPath
+          val interpolated = interpolateDynamicValues(packageInstance, packageName)
+
+          // Use FQCN to avoid class name collisions between different packages
+          val fqcn = extractFqcnFromImport(interpolateDynamicValues(packageImportPath, packageName))
+          val fqcnInstance =
+              if (fqcn != null) {
+                val className = fqcn.substringAfterLast('.')
+                // Replace the short class name with FQCN in the instance
+                interpolated.replace(Regex("\\b${Regex.escape(className)}\\b")) { fqcn }
+              } else {
+                interpolated
+              }
+
+          // Add comment with package name before each instance
+          "// $name\n      $fqcnInstance"
+        }
+
+    return ",\n      " + instances.joinToString(",\n      ")
+  }
+
+  internal fun filterAndroidPackages(
+      model: ModelAutolinkingConfigJson?
+  ): Map<String, ModelAutolinkingDependenciesPlatformAndroidJson> {
+    val packages = model?.dependencies?.values ?: emptyList()
+    return packages
+        .filter { it.platforms?.android != null }
+        // The pure C++ dependencies won't have a .java/.kt file to import
+        .filterNot { it.platforms?.android?.isPureCxxDependency == true }
+        .associate { it.name to checkNotNull(it.platforms?.android) }
+  }
+
+  internal fun composeFileContent(packageClassInstance: String): String =
+      generatedFileContentsTemplate.replace("{{ packageClassInstances }}", packageClassInstance)
+
+  companion object {
+    const val GENERATED_FILENAME = "com/facebook/react/PackageList.java"
+
+    /**
+     * Before adding the package replacement mechanism, BuildConfig and R classes were imported
+     * automatically into the scope of the file. We want to replace all non-FQDN references to those
+     * classes with the package name of the MainApplication.
+     *
+     *     We want to match "R" or "BuildConfig":
+     *     - new Package(R.string…),
+     *     - Module.configure(BuildConfig);
+     *     ^ hence including (BuildConfig|R)
+     *     but we don't want to match "R":
+     *     - new Package(getResources…),
+     *     - new PackageR…,
+     *     - new Royal…,
+     *     ^ hence excluding \w before and after matches
+     *     and "BuildConfig" that has FQDN reference:
+     *     - Module.configure(com.acme.BuildConfig);
+     *     ^ hence excluding . before the match.
+     */
+    internal fun interpolateDynamicValues(input: String, packageName: String): String =
+        input.replace(Regex("([^.\\w])(BuildConfig|R)(\\W)")) { match ->
+          val (prefix, className, suffix) = match.destructured
+          "${prefix}${packageName}.${className}${suffix}"
+        }
+
+    // language=java
+    val generatedFileContentsTemplate =
+        """
+        package com.facebook.react;
+
+        import android.app.Application;
+        import android.content.Context;
+        import android.content.res.Resources;
+
+        import com.facebook.react.ReactPackage;
+        import com.facebook.react.shell.MainPackageConfig;
+        import com.facebook.react.shell.MainReactPackage;
+        import java.util.Arrays;
+        import java.util.ArrayList;
+
+        @SuppressWarnings("deprecation")
+        public class PackageList {
+          private Application application;
+          private ReactNativeHost reactNativeHost;
+          private MainPackageConfig mConfig;
+
+          public PackageList(ReactNativeHost reactNativeHost) {
+            this(reactNativeHost, null);
+          }
+
+          public PackageList(Application application) {
+            this(application, null);
+          }
+
+          public PackageList(ReactNativeHost reactNativeHost, MainPackageConfig config) {
+            this.reactNativeHost = reactNativeHost;
+            mConfig = config;
+          }
+
+          public PackageList(Application application, MainPackageConfig config) {
+            this.reactNativeHost = null;
+            this.application = application;
+            mConfig = config;
+          }
+
+          private ReactNativeHost getReactNativeHost() {
+            return this.reactNativeHost;
+          }
+
+          private Resources getResources() {
+            return this.getApplication().getResources();
+          }
+
+          private Application getApplication() {
+            if (this.reactNativeHost == null) return this.application;
+            return this.reactNativeHost.getApplication();
+          }
+
+          private Context getApplicationContext() {
+            return this.getApplication().getApplicationContext();
+          }
+
+          public ArrayList<ReactPackage> getPackages() {
+            return new ArrayList<>(Arrays.<ReactPackage>asList(
+              new MainReactPackage(mConfig){{ packageClassInstances }}
+            ));
+          }
+        }
+        """
+            .trimIndent()
+  }
+}

package/{src/main/kotlin/com/facebook/react/tasks → react-native-gradle-plugin/src/main/kotlin/com/facebook/react/tasks/internal}/BuildCodegenCLITask.kt

@@ -5,12 +5,14 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.tasks
+package com.facebook.react.tasks.internal
 
 import com.facebook.react.utils.Os.unixifyPath
 import com.facebook.react.utils.windowsAwareBashCommandLine
+import java.io.FileOutputStream
 import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.file.FileCollection
+import org.gradle.api.file.FileTree
+import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 
@@ -26,29 +28,34 @@ abstract class BuildCodegenCLITask : Exec() {
 
   @get:Internal abstract val bashWindowsHome: Property<String>
 
-  @get:InputFiles
-  val input: FileCollection by lazy {
-    codegenDir.get().files("scripts", "src", "package.json", ".babelrc", ".prettierrc")
-  }
+  @get:Internal abstract val rootProjectName: Property<String>
 
-  @get:OutputDirectories
-  val output: FileCollection by lazy { codegenDir.get().files("lib", "node_modules") }
+  @get:InputFiles abstract val inputFiles: Property<FileTree>
 
-  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
-    }
-  }
+  @get:OutputFiles abstract val outputFiles: Property<FileTree>
+
+  @get:OutputFile abstract val logFile: RegularFileProperty
 
   override fun exec() {
+    // For build from source scenario, we don't need to build the codegen at all.
+    if (rootProjectName.get() == "react-native-build-from-source") {
+      return
+    }
+    val logFileConcrete =
+        logFile.get().asFile.apply {
+          parentFile.mkdirs()
+          if (exists()) {
+            delete()
+          }
+          createNewFile()
+        }
+    standardOutput = FileOutputStream(logFileConcrete)
     commandLine(
         windowsAwareBashCommandLine(
             codegenDir.asFile.get().canonicalPath.unixifyPath().plus(BUILD_SCRIPT_PATH),
             bashWindowsHome = bashWindowsHome.orNull,
-        ))
+        )
+    )
     super.exec()
   }
 

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/tasks/internal/CustomExecTask.kt

@@ -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.
+ */
+
+package com.facebook.react.tasks.internal
+
+import java.io.File
+import java.io.FileOutputStream
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Exec
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.OutputFile
+
+/**
+ * A Task that will just expose an Exec-like task and that offers properties to configure the
+ * standard output and error.
+ */
+abstract class CustomExecTask : Exec() {
+
+  @get:OutputFile @get:Optional abstract val standardOutputFile: RegularFileProperty
+
+  @get:OutputFile @get:Optional abstract val errorOutputFile: RegularFileProperty
+
+  @get:Input @get:Optional abstract val onlyIfProvidedPathDoesNotExists: Property<String>
+
+  override fun exec() {
+    if (
+        onlyIfProvidedPathDoesNotExists.isPresent &&
+            File(onlyIfProvidedPathDoesNotExists.get()).exists()
+    ) {
+      return
+    }
+    if (standardOutputFile.isPresent) {
+      standardOutput = FileOutputStream(standardOutputFile.get().asFile)
+    }
+    if (errorOutputFile.isPresent) {
+      errorOutput = FileOutputStream(errorOutputFile.get().asFile)
+    }
+    super.exec()
+  }
+}

package/{src → react-native-gradle-plugin/src}/main/kotlin/com/facebook/react/tasks/internal/PrepareBoostTask.kt

@@ -8,9 +8,11 @@
 package com.facebook.react.tasks.internal
 
 import java.io.File
+import javax.inject.Inject
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 
@@ -21,26 +23,30 @@ import org.gradle.api.tasks.*
 abstract class PrepareBoostTask : DefaultTask() {
 
   @get:InputFiles abstract val boostPath: ConfigurableFileCollection
+  @get:InputDirectory abstract val boostThirdPartyJniPath: DirectoryProperty
 
   @get:Input abstract val boostVersion: Property<String>
 
   @get:OutputDirectory abstract val outputDir: DirectoryProperty
 
+  @get:Inject abstract val fs: FileSystemOperations
+
   @TaskAction
   fun taskAction() {
-    project.copy { it ->
+    fs.copy { it ->
       it.from(boostPath)
-      it.from(project.file("src/main/jni/third-party/boost"))
+      it.from(boostThirdPartyJniPath)
       it.include(
           "CMakeLists.txt",
           "boost_${boostVersion.get()}/boost/**/*.hpp",
           "boost/boost/**/*.hpp",
-          "asm/**/*.S")
+          "asm/**/*.S",
+      )
       it.includeEmptyDirs = false
       it.into(outputDir)
     }
     File(outputDir.asFile.get(), "boost").apply {
-      renameTo(File(this.parentFile, "boost_${boostVersion.get()}"))
+      renameTo(File(parentFile, "boost_${boostVersion.get()}"))
     }
   }
 }

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/tasks/internal/PrepareGflagsTask.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.tasks.internal
+
+import javax.inject.Inject
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.CopySpec
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.file.FileSystemOperations
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.*
+
+/**
+ * A task that takes care of extracting gflags from a source folder/zip and preparing it to be
+ * consumed by the NDK. This task will also take care of applying the mapping for gflags parameters.
+ */
+abstract class PrepareGflagsTask : DefaultTask() {
+
+  @get:InputFiles abstract val gflagsPath: ConfigurableFileCollection
+  @get:InputDirectory abstract val gflagsThirdPartyPath: DirectoryProperty
+  @get:Input abstract val gflagsVersion: Property<String>
+
+  @get:OutputDirectory abstract val outputDir: DirectoryProperty
+
+  @get:Inject abstract val fs: FileSystemOperations
+
+  @TaskAction
+  fun taskAction() {
+    val commonCopyConfig: (action: CopySpec) -> Unit = { action ->
+      action.from(gflagsPath)
+      action.from(gflagsThirdPartyPath)
+      action.duplicatesStrategy = DuplicatesStrategy.INCLUDE
+      action.includeEmptyDirs = false
+      action.into(outputDir)
+    }
+
+    fs.copy { action ->
+      commonCopyConfig(action)
+      action.include(
+          "gflags-${gflagsVersion.get()}/src/*.h",
+          "gflags-${gflagsVersion.get()}/src/*.cc",
+          "CMakeLists.txt",
+      )
+      action.filesMatching("*/src/*") { matchedFile ->
+        matchedFile.path = "gflags/${matchedFile.name}"
+      }
+    }
+
+    fs.copy { action ->
+      commonCopyConfig(action)
+      action.include("gflags-${gflagsVersion.get()}/src/gflags_declare.h.in")
+      action.filesMatching("*/src/*") { matchedFile ->
+        matchedFile.filter { line ->
+          // Replace all placeholders with appropriate values
+          // see https://github.com/gflags/gflags/blob/v2.2.0/src/gflags_declare.h.in
+          line
+              .replace(Regex("@GFLAGS_NAMESPACE@"), "gflags")
+              .replace(
+                  Regex(
+                      "@(HAVE_STDINT_H|HAVE_SYS_TYPES_H|HAVE_INTTYPES_H|GFLAGS_INTTYPES_FORMAT_C99)@"
+                  ),
+                  "1",
+              )
+              .replace(Regex("@([A-Z0-9_]+)@"), "1")
+        }
+        matchedFile.path = "gflags/${matchedFile.name.removeSuffix(".in")}"
+      }
+    }
+
+    fs.copy { action ->
+      commonCopyConfig(action)
+      action.include("gflags-${gflagsVersion.get()}/src/config.h.in")
+      action.filesMatching("*/src/*") { matchedFile ->
+        matchedFile.filter { line -> line.replace(Regex("^#cmakedefine"), "//cmakedefine") }
+        matchedFile.path = "gflags/${matchedFile.name.removeSuffix(".in")}"
+      }
+    }
+
+    fs.copy { action ->
+      commonCopyConfig(action)
+      action.include("gflags-${gflagsVersion.get()}/src/gflags_ns.h.in")
+      action.filesMatching("*/src/*") { matchedFile ->
+        matchedFile.filter { line ->
+          line.replace(Regex("@ns@"), "google").replace(Regex("@NS@"), "google".uppercase())
+        }
+        matchedFile.path = "gflags/gflags_google.h"
+      }
+    }
+
+    fs.copy { action ->
+      commonCopyConfig(action)
+      action.include("gflags-${gflagsVersion.get()}/src/gflags.h.in")
+      action.filesMatching("*/src/*") { matchedFile ->
+        matchedFile.filter { line ->
+          line
+              .replace(Regex("@GFLAGS_ATTRIBUTE_UNUSED@"), "")
+              .replace(Regex("@INCLUDE_GFLAGS_NS_H@"), "#include \"gflags/gflags_google.h\"")
+        }
+        matchedFile.path = "gflags/${matchedFile.name.removeSuffix(".in")}"
+      }
+    }
+
+    fs.copy { action ->
+      commonCopyConfig(action)
+      action.include("gflags-${gflagsVersion.get()}/src/gflags_completions.h.in")
+      action.filesMatching("*/src/*") { matchedFile ->
+        matchedFile.filter { line -> line.replace(Regex("@GFLAGS_NAMESPACE@"), "gflags") }
+        matchedFile.path = "gflags/${matchedFile.name.removeSuffix(".in")}"
+      }
+    }
+  }
+}

package/{src → react-native-gradle-plugin/src}/main/kotlin/com/facebook/react/tasks/internal/PrepareGlogTask.kt

@@ -8,11 +8,13 @@
 package com.facebook.react.tasks.internal
 
 import java.io.File
+import javax.inject.Inject
 import org.apache.tools.ant.filters.ReplaceTokens
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.file.FileSystemOperations
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 
@@ -23,20 +25,22 @@ import org.gradle.api.tasks.*
 abstract class PrepareGlogTask : DefaultTask() {
 
   @get:InputFiles abstract val glogPath: ConfigurableFileCollection
-
+  @get:InputDirectory abstract val glogThirdPartyJniPath: DirectoryProperty
   @get:Input abstract val glogVersion: Property<String>
 
   @get:OutputDirectory abstract val outputDir: DirectoryProperty
 
+  @get:Inject abstract val fs: FileSystemOperations
+
   @TaskAction
   fun taskAction() {
-    project.copy {
-      it.from(glogPath)
-      it.from(project.file("src/main/jni/third-party/glog/"))
-      it.include("glog-${glogVersion.get()}/src/**/*", "CMakeLists.txt", "config.h")
-      it.duplicatesStrategy = DuplicatesStrategy.WARN
-      it.includeEmptyDirs = false
-      it.filesMatching("**/*.h.in") { matchedFile ->
+    fs.copy { action ->
+      action.from(glogPath)
+      action.from(glogThirdPartyJniPath)
+      action.include("glog-${glogVersion.get()}/src/**/*", "CMakeLists.txt", "config.h")
+      action.duplicatesStrategy = DuplicatesStrategy.INCLUDE
+      action.includeEmptyDirs = false
+      action.filesMatching("**/*.h.in") { matchedFile ->
         matchedFile.filter(
             mapOf(
                 "tokens" to
@@ -56,24 +60,28 @@ abstract class PrepareGlogTask : DefaultTask() {
                         "ac_cv___attribute___noinline" to "__attribute__ ((noinline))",
                         "ac_cv___attribute___noreturn" to "__attribute__ ((noreturn))",
                         "ac_cv___attribute___printf_4_5" to
-                            "__attribute__((__format__ (__printf__, 4, 5)))")),
-            ReplaceTokens::class.java)
+                            "__attribute__((__format__ (__printf__, 4, 5)))",
+                    )
+            ),
+            ReplaceTokens::class.java,
+        )
         matchedFile.path = (matchedFile.name.removeSuffix(".in"))
       }
-      it.into(outputDir)
+      action.into(outputDir)
     }
     val exportedDir = File(outputDir.asFile.get(), "exported/glog/").apply { mkdirs() }
-    project.copy {
-      it.from(outputDir)
-      it.include(
+    fs.copy { action ->
+      action.from(outputDir)
+      action.include(
           "stl_logging.h",
           "logging.h",
           "raw_logging.h",
           "vlog_is_on.h",
-          "**/src/glog/log_severity.h")
-      it.eachFile { file -> file.path = file.name }
-      it.includeEmptyDirs = false
-      it.into(exportedDir)
+          "**/src/glog/log_severity.h",
+      )
+      action.eachFile { file -> file.path = file.name }
+      action.includeEmptyDirs = false
+      action.into(exportedDir)
     }
   }
 }

package/{src → react-native-gradle-plugin/src}/main/kotlin/com/facebook/react/tasks/internal/PreparePrefabHeadersTask.kt

@@ -42,19 +42,35 @@ abstract class PreparePrefabHeadersTask : DefaultTask() {
     input.get().forEach { (libraryName, pathToPrefixCouples) ->
       val outputFolder: RegularFile = outputDir.file(libraryName).get()
       pathToPrefixCouples.forEach { (headerPath, headerPrefix) ->
-        fs.copy {
-          it.from(headerPath)
-          it.include("**/*.h")
-          it.exclude("**/*.cpp")
-          it.exclude("**/*.txt")
+        fs.copy { copySpec ->
+          copySpec.from(headerPath)
+          copySpec.include("**/*.h")
+          copySpec.exclude("**/*.cpp")
+          copySpec.exclude("**/*.txt")
           // We don't want to copy all the boost headers as they are 250Mb+
-          it.include("boost/config.hpp")
-          it.include("boost/config/**/*.hpp")
-          it.include("boost/core/*.hpp")
-          it.include("boost/detail/workaround.hpp")
-          it.include("boost/operators.hpp")
-          it.include("boost/preprocessor/**/*.hpp")
-          it.into(File(outputFolder.asFile, headerPrefix))
+          copySpec.include("boost/config.hpp")
+          copySpec.include("boost/config/**/*.hpp")
+          copySpec.include("boost/core/*.hpp")
+          copySpec.include("boost/detail/workaround.hpp")
+          copySpec.include("boost/operators.hpp")
+          copySpec.include("boost/preprocessor/**/*.hpp")
+          // Headers needed for exposing rrc_text and rrc_textinput
+          copySpec.include("boost/container_hash/**/*.hpp")
+          copySpec.include("boost/detail/**/*.hpp")
+          copySpec.include("boost/intrusive/**/*.hpp")
+          copySpec.include("boost/iterator/**/*.hpp")
+          copySpec.include("boost/move/**/*.hpp")
+          copySpec.include("boost/mpl/**/*.hpp")
+          copySpec.include("boost/mp11/**/*.hpp")
+          copySpec.include("boost/describe/**/*.hpp")
+          copySpec.include("boost/type_traits/**/*.hpp")
+          copySpec.include("boost/utility/**/*.hpp")
+          copySpec.include("boost/assert.hpp")
+          copySpec.include("boost/static_assert.hpp")
+          copySpec.include("boost/cstdint.hpp")
+          copySpec.include("boost/utility.hpp")
+          copySpec.include("boost/version.hpp")
+          copySpec.into(File(outputFolder.asFile, headerPrefix))
         }
       }
     }

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

@@ -11,10 +11,11 @@ import java.io.Serializable
 
 /**
  * This data class represents an entry that can be consumed by the [PreparePrefabHeadersTask].
+ *
  * @param libraryName The name of the library that you're preparing for Prefab
  * @param pathToPrefixCouples A list of pairs Path to Header prefix. You can use this list to supply
- * a list of paths that you want to be considered for prefab. Each path can specify an header prefix
- * that will be used by prefab to re-created the header layout.
+ *   a list of paths that you want to be considered for prefab. Each path can specify an header
+ *   prefix that will be used by prefab to re-created the header layout.
  */
 data class PrefabPreprocessingEntry(
     val libraryName: String,
@@ -22,6 +23,6 @@ data class PrefabPreprocessingEntry(
 ) : Serializable {
   constructor(
       libraryName: String,
-      pathToPrefixCouple: Pair<String, String>
+      pathToPrefixCouple: Pair<String, String>,
   ) : this(libraryName, listOf(pathToPrefixCouple))
 }