@granite-js/screen 1.0.0

package/gradle-plugin/src/main/kotlin/run/granite/gradle/models/NativeModule.kt

@@ -0,0 +1,177 @@
+package run.granite.gradle.models
+
+/**
+ * Enriched model representing a React Native native module with computed properties.
+ * This is the primary model used by code generators.
+ *
+ * Constructed from AndroidDependencyConfig with validation:
+ * - packageImportPath and packageInstance must both be present or both be null
+ */
+data class NativeModule(
+  val name: String,
+  val packageImportPath: String?,
+  val packageInstance: String?,
+  val dependencyConfiguration: String?,
+  val buildTypes: List<String>,
+  val libraryName: String?,
+  val componentDescriptors: List<String>,
+  val cmakeListsPath: String?,
+  val cxxModuleCMakeListsPath: String?,
+  val cxxModuleCMakeListsModuleName: String?,
+  val cxxModuleHeaderName: String?,
+  val isPureCxxDependency: Boolean,
+  /**
+   * True if the module's package.json has codegenConfig.includesGeneratedCode: true.
+   * Modules with this flag use their own codegen system (e.g., brick-codegen)
+   * and should be excluded from react-native-codegen based autolinking.
+   */
+  val includesGeneratedCode: Boolean = false,
+) {
+  init {
+    // Validate packageImportPath and packageInstance pairing
+    val hasImportPath = packageImportPath != null
+    val hasInstance = packageInstance != null
+    require(hasImportPath == hasInstance) {
+      "Module '$name': Failed to validate config - packageImportPath and packageInstance " +
+        "must both be present or both be null. Check module's react-native.config.js."
+    }
+  }
+
+  /**
+   * True if module has Java TurboModule implementation.
+   * Identified by non-null packageImportPath and packageInstance.
+   */
+  val hasJavaImplementation: Boolean
+    get() = packageImportPath != null && packageInstance != null
+
+  /**
+   * True if module has C++ TurboModule implementation.
+   * Identified by non-null cxxModuleHeaderName.
+   */
+  val hasCxxImplementation: Boolean
+    get() = cxxModuleHeaderName != null
+
+  /**
+   * True if module has any Fabric components.
+   * Identified by non-empty componentDescriptors array.
+   */
+  val hasFabricComponents: Boolean
+    get() = componentDescriptors.isNotEmpty()
+
+  /**
+   * True if module has CMake configuration.
+   * Identified by non-null cmakeListsPath or cxxModuleCMakeListsPath.
+   */
+  val hasCMakeConfiguration: Boolean
+    get() = cmakeListsPath != null || cxxModuleCMakeListsPath != null
+
+  /**
+   * True if module needs to be included in C++ autolinking.
+   * Required for C++ TurboModules or Fabric components.
+   */
+  val needsCppAutolinking: Boolean
+    get() = hasCxxImplementation || hasFabricComponents
+
+  /**
+   * Returns C++ identifier-safe name by sanitizing module name.
+   * Replaces invalid characters (spaces, hyphens, special chars) with underscores.
+   */
+  fun sanitizedName(): String = name.replace(Regex("[^a-zA-Z0-9_]"), "_")
+
+  /**
+   * Returns list of CMake entries for this module.
+   * Handles both standard CMakeLists.txt and separate cxxModule CMakeLists.txt.
+   */
+  fun cmakeEntries(): List<CMakeEntry> {
+    val entries = mutableListOf<CMakeEntry>()
+
+    // Add standard CMakeLists.txt entry
+    cmakeListsPath?.let { path ->
+      entries.add(
+        CMakeEntry(
+          sourcePath = path,
+          buildDirName = "${libraryName}_autolinked_build",
+          libraryTargets = listOfNotNull(
+            libraryName?.let { "react_codegen_$it" },
+          ),
+        ),
+      )
+    }
+
+    // Add C++ TurboModule CMakeLists.txt entry
+    cxxModuleCMakeListsPath?.let { path ->
+      entries.add(
+        CMakeEntry(
+          sourcePath = path,
+          buildDirName = "${libraryName}_cxx_autolinked_build",
+          libraryTargets = listOfNotNull(cxxModuleCMakeListsModuleName),
+        ),
+      )
+    }
+
+    return entries
+  }
+
+  companion object {
+    /**
+     * Constructs NativeModule from AndroidDependencyConfig with validation.
+     * Treats null and missing optional fields identically.
+     *
+     * @param name Module name
+     * @param config Android dependency configuration
+     * @param moduleRootPath Root path of the module (for reading package.json)
+     */
+    fun from(
+      name: String,
+      config: AndroidDependencyConfig,
+      moduleRootPath: String? = null,
+    ): NativeModule {
+      val includesGeneratedCode = moduleRootPath?.let {
+        readIncludesGeneratedCodeFlag(it)
+      } ?: false
+
+      return NativeModule(
+        name = name,
+        packageImportPath = config.packageImportPath,
+        packageInstance = config.packageInstance,
+        dependencyConfiguration = config.dependencyConfiguration,
+        buildTypes = config.buildTypes.orEmpty(),
+        libraryName = config.libraryName,
+        componentDescriptors = config.componentDescriptors.orEmpty(),
+        cmakeListsPath = config.cmakeListsPath,
+        cxxModuleCMakeListsPath = config.cxxModuleCMakeListsPath,
+        cxxModuleCMakeListsModuleName = config.cxxModuleCMakeListsModuleName,
+        cxxModuleHeaderName = config.cxxModuleHeaderName,
+        isPureCxxDependency = config.isPureCxxDependency ?: false,
+        includesGeneratedCode = includesGeneratedCode,
+      )
+    }
+
+    /**
+     * Reads codegenConfig.includesGeneratedCode from module's package.json.
+     * Returns false if the file doesn't exist or the flag is not set.
+     */
+    private fun readIncludesGeneratedCodeFlag(moduleRootPath: String): Boolean {
+      return try {
+        val packageJsonFile = java.io.File(moduleRootPath, "package.json")
+        if (!packageJsonFile.exists()) return false
+
+        val content = packageJsonFile.readText()
+        val gson = com.google.gson.Gson()
+
+        @Suppress("UNCHECKED_CAST")
+        val json = gson.fromJson(content, Map::class.java) as? Map<String, Any>
+          ?: return false
+
+        @Suppress("UNCHECKED_CAST")
+        val codegenConfig = json["codegenConfig"] as? Map<String, Any>
+          ?: return false
+
+        codegenConfig["includesGeneratedCode"] as? Boolean ?: false
+      } catch (e: Exception) {
+        // Fail gracefully - treat as false if we can't read the file
+        false
+      }
+    }
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/tasks/AssetPackagingTask.kt

@@ -0,0 +1,194 @@
+package run.granite.gradle.tasks
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.*
+import java.io.File
+import java.util.zip.GZIPOutputStream
+
+/**
+ * Gradle task for packaging React Native assets and bundles.
+ *
+ * This task:
+ * 1. Copies the JavaScript bundle to Android assets directory
+ * 2. Compresses the bundle with gzip (if enabled)
+ * 3. Copies React Native drawable assets
+ * 4. Organizes assets per build variant
+ *
+ * The packaged assets are included in the final AAR file.
+ *
+ * Inputs:
+ * - JavaScript bundle file
+ * - React Native assets directory
+ * - Compression settings
+ *
+ * Outputs:
+ * - Assets in src/{variant}/assets/
+ * - Drawable resources in src/{variant}/res/
+ */
+@CacheableTask
+abstract class AssetPackagingTask : DefaultTask() {
+
+  /**
+   * JavaScript bundle file to package.
+   */
+  @get:InputFile
+  @get:PathSensitive(PathSensitivity.RELATIVE)
+  abstract val bundleFile: RegularFileProperty
+
+  /**
+   * Directory containing React Native drawable assets.
+   */
+  @get:InputDirectory
+  @get:PathSensitive(PathSensitivity.RELATIVE)
+  @get:Optional
+  abstract val assetsDir: DirectoryProperty
+
+  /**
+   * Output assets directory (src/{variant}/assets/).
+   */
+  @get:OutputDirectory
+  abstract val outputAssetsDir: DirectoryProperty
+
+  /**
+   * Output resources directory (src/{variant}/res/).
+   */
+  @get:OutputDirectory
+  @get:Optional
+  abstract val outputResDir: DirectoryProperty
+
+  /**
+   * Bundle asset name (e.g., "index.android.bundle").
+   */
+  @get:Input
+  abstract val bundleAssetName: Property<String>
+
+  /**
+   * Whether to compress the bundle with gzip.
+   */
+  @get:Input
+  abstract val compressionEnabled: Property<Boolean>
+
+  /**
+   * Variant name for logging.
+   */
+  @get:Input
+  abstract val variantName: Property<String>
+
+  init {
+    group = "granite"
+    description = "Packages React Native assets and bundles"
+  }
+
+  @TaskAction
+  fun execute() {
+    val variant = variantName.get()
+    logger.lifecycle("Packaging assets for variant: $variant")
+
+    // Package JavaScript bundle
+    packageBundle()
+
+    // Package drawable assets
+    packageDrawableAssets()
+
+    logger.lifecycle("Asset packaging complete for variant: $variant")
+  }
+
+  /**
+   * Packages the JavaScript bundle into the assets directory.
+   *
+   * If compression is enabled, creates a gzipped bundle file.
+   */
+  private fun packageBundle() {
+    val bundleSource = bundleFile.get().asFile
+    val bundleName = bundleAssetName.get()
+
+    if (!bundleSource.exists()) {
+      error(
+        """
+                |Bundle file not found: ${bundleSource.absolutePath}
+                |
+                |Solution: Ensure the bundle task completed successfully before packaging.
+        """.trimMargin(),
+      )
+    }
+
+    val outputDir = outputAssetsDir.get().asFile
+    outputDir.mkdirs()
+
+    if (compressionEnabled.get()) {
+      // Create gzipped bundle
+      val compressedBundle = File(outputDir, "$bundleName.gz")
+      logger.lifecycle("Compressing bundle: ${compressedBundle.name}")
+
+      bundleSource.inputStream().use { input ->
+        GZIPOutputStream(compressedBundle.outputStream()).use { gzipOut ->
+          input.copyTo(gzipOut)
+        }
+      }
+
+      logger.lifecycle("Created compressed bundle: ${compressedBundle.absolutePath}")
+    } else {
+      // Copy bundle without compression
+      val outputBundle = File(outputDir, bundleName)
+      bundleSource.copyTo(outputBundle, overwrite = true)
+      logger.lifecycle("Copied bundle: ${outputBundle.absolutePath}")
+    }
+  }
+
+  /**
+   * Packages React Native drawable assets into the res directory.
+   *
+   * Copies drawable-* directories from the assets directory to the Android
+   * resources directory for inclusion in the AAR.
+   */
+  private fun packageDrawableAssets() {
+    if (!assetsDir.isPresent) {
+      logger.debug("No assets directory specified, skipping drawable packaging")
+      return
+    }
+
+    val assetsSource = assetsDir.get().asFile
+    if (!assetsSource.exists()) {
+      logger.debug("Assets directory does not exist: ${assetsSource.absolutePath}")
+      return
+    }
+
+    if (!outputResDir.isPresent) {
+      logger.debug("No output res directory specified, skipping drawable packaging")
+      return
+    }
+
+    val outputRes = outputResDir.get().asFile
+    outputRes.mkdirs()
+
+    // Find all drawable-* directories
+    val drawableDirs = assetsSource.listFiles { file ->
+      file.isDirectory && file.name.startsWith("drawable-")
+    } ?: emptyArray()
+
+    if (drawableDirs.isEmpty()) {
+      logger.debug("No drawable directories found in assets")
+      return
+    }
+
+    // Copy each drawable directory
+    for (drawableDir in drawableDirs) {
+      val targetDir = File(outputRes, drawableDir.name)
+      targetDir.mkdirs()
+
+      drawableDir.walk()
+        .filter { it.isFile }
+        .forEach { sourceFile ->
+          val relativePath = sourceFile.relativeTo(drawableDir).path
+          val targetFile = File(targetDir, relativePath)
+          targetFile.parentFile.mkdirs()
+          sourceFile.copyTo(targetFile, overwrite = true)
+        }
+
+      logger.lifecycle("Copied drawable assets: ${drawableDir.name}")
+    }
+  }
+}