@callstack/react-native-brownfield 5.1.0 → 5.2.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @callstack/react-native-brownfield
 
+## 5.2.0
+
+### Minor Changes
+
+- [#467](https://github.com/callstack/react-native-brownfield/pull/467) [`31c3939`](https://github.com/callstack/react-native-brownfield/commit/31c39399aad0efb098876d35a4fbbe80835d5dba) Thanks [@hurali97](https://github.com/hurali97)! - agp v9 compliance
+
+- [#467](https://github.com/callstack/react-native-brownfield/pull/467) [`31c3939`](https://github.com/callstack/react-native-brownfield/commit/31c39399aad0efb098876d35a4fbbe80835d5dba) Thanks [@hurali97](https://github.com/hurali97)! - add expo sdk 58
+
+### Patch Changes
+
+- [#477](https://github.com/callstack/react-native-brownfield/pull/477) [`9e57d43`](https://github.com/callstack/react-native-brownfield/commit/9e57d4384f93459526a41084ee82355dd43f4ed9) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - fix: publish dependencies of community libraries (e.g. react-native-screens, lottie-react-native) embedded in Expo brownfield AARs; the published POM now lists them, previously host apps could crash with NoClassDefFoundError
+- Updated dependencies [[`31c3939`](https://github.com/callstack/react-native-brownfield/commit/31c39399aad0efb098876d35a4fbbe80835d5dba)]:
+  - @callstack/brownfield-cli@5.2.0
+
+## 5.1.1
+
+### Patch Changes
+
+- [#458](https://github.com/callstack/react-native-brownfield/pull/458) [`bf976fd`](https://github.com/callstack/react-native-brownfield/commit/bf976fdebc1abb228c03213c9a1b41d9967d0909) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - Bump the Brownfield Gradle Plugin version injected by the Expo config plugin to `2.0.0-alpha09`.
+
+- [#462](https://github.com/callstack/react-native-brownfield/pull/462) [`2f7d5da`](https://github.com/callstack/react-native-brownfield/commit/2f7d5daf661808fdfdd1caae89236dbdfec3f62e) Thanks [@likevy](https://github.com/likevy)! - fixes [#457](https://github.com/callstack/react-native-brownfield/issues/457), android back callbacks survived RN fragment view destruction, retaining delegates and intercepting back presses after re-entry
+
+- [#470](https://github.com/callstack/react-native-brownfield/pull/470) [`09162c2`](https://github.com/callstack/react-native-brownfield/commit/09162c27bd8455b67bc0e2890a4ffe8dae5b9eae) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - Fix `popToNative()` on iOS closing every React Native screen instead of only the topmost one.
+
+  `popToNative()` is delivered as an app-wide notification, so every live React Native surface acted on it — including surfaces buried under other screens, and each surface acted twice when hosted by SwiftUI. In a stack such as RN → native → RN, a single call tore down the whole navigation stack, taking native screens with it.
+
+  A React Native surface now acts only when it is the topmost one on screen, and only once per host.
+
+  Two consequences worth knowing about:
+  - When no React Native surface is on screen — for example one hidden behind a full-screen native modal — `popToNative()` is now a no-op instead of popping the hidden screen. It logs when this happens.
+  - `popToNative()` no longer dismisses a modally presented native screen that merely _contains_ a React Native surface. Only a surface that owns a navigation stack entry pops.
+
+- Updated dependencies []:
+  - @callstack/brownfield-cli@5.1.1
+
 ## 5.1.0
 
 ### Minor Changes

package/android/src/main/java/com/callstack/reactnativebrownfield/ReactNativeBrownfield.kt

@@ -202,6 +202,19 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
         moduleName: String,
         reactDelegate: ReactDelegateWrapper? = null,
         launchOptions: Bundle? = null,
+    ): FrameLayout = createView(activity, moduleName, reactDelegate, launchOptions, activity)
+
+    /**
+     * Use the owner of the view when embedding React Native inside a fragment or
+     * another container whose lifetime is shorter than the activity.
+     * The four-argument overload retains its original JVM signature.
+     */
+    fun createView(
+        activity: FragmentActivity?,
+        moduleName: String,
+        reactDelegate: ReactDelegateWrapper?,
+        launchOptions: Bundle?,
+        lifecycleOwner: LifecycleOwner?,
     ): FrameLayout {
         val reactHost = shared.reactHost
         val resolvedDelegate =
@@ -215,12 +228,17 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
         }
 
         // Register back press callback
-        activity?.onBackPressedDispatcher?.addCallback(backPressedCallback)
+        if (lifecycleOwner != null) {
+            activity?.onBackPressedDispatcher?.addCallback(lifecycleOwner, backPressedCallback)
+        }
         // invoked on the last RN screen exit
         resolvedDelegate.setHardwareBackHandler {
             backPressedCallback.isEnabled = false
-            activity?.onBackPressedDispatcher?.onBackPressed()
-            backPressedCallback.isEnabled = true
+            try {
+                activity?.onBackPressedDispatcher?.onBackPressed()
+            } finally {
+                backPressedCallback.isEnabled = true
+            }
         }
 
         /**
@@ -230,7 +248,7 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
          * In such a case, we set the lifeCycle observer.
          */
         if (reactDelegate == null) {
-            activity?.lifecycle?.addObserver(getLifeCycleObserver(resolvedDelegate))
+            lifecycleOwner?.lifecycle?.addObserver(getLifeCycleObserver(resolvedDelegate))
         }
 
         resolvedDelegate.loadApp()

package/android/src/main/java/com/callstack/reactnativebrownfield/ReactNativeFragment.kt

@@ -54,7 +54,9 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
         return ReactNativeBrownfield.shared.createView(
             activity,
             moduleName,
-            this.reactDelegate as ReactDelegateWrapper
+            this.reactDelegate as ReactDelegateWrapper,
+            launchOptions = null,
+            lifecycleOwner = viewLifecycleOwner
         )
     }
 

package/gradle-plugin/brownfield/build.gradle.kts

@@ -103,11 +103,83 @@ repositories {
     google()
 }
 
+// AGP for GradleRunner.withPluginClasspath(), which only sees runtime dependencies, so TestKit
+// projects can still apply com.android.library
+val testKitPluginClasspath: Configuration by configurations.creating
+
 dependencies {
-    implementation(libs.agp)
-    implementation(libs.common)
+    // AGP is provided by the consuming build's buildscript classpath. Keeping it
+    // compileOnly stops the published module from pinning AGP (and therefore the
+    // minimum Gradle version) for every app that applies this plugin.
+    compileOnly(libs.agp)
+    compileOnly(libs.common)
     implementation(libs.asm.commons)
     implementation(libs.versioncompare)
+    testImplementation(libs.agp)
+    testImplementation(libs.common)
+    testImplementation(libs.junit.jupiter)
+    testImplementation(gradleTestKit())
+    testImplementation(kotlin("test"))
+    testKitPluginClasspath(libs.agp)
+}
+
+tasks.pluginUnderTestMetadata {
+    pluginClasspath.from(testKitPluginClasspath)
+}
+
+/**
+ * AGP versions the plugin is tested against, oldest first.
+ *
+ * The first entry is the floor, and it is the same number as `agp` in `gradle/libs.versions.toml`
+ * (what the plugin compiles against) and `RNBrownfieldPlugin.MIN_AGP` (what the apply-time gate
+ * enforces). The compiler covers "we accidentally used an API newer than the floor"; this matrix
+ * covers the other direction — "we used something a newer AGP has since removed or changed".
+ */
+val agpMatrix = listOf(libs.versions.agp.get(), "9.2.1")
+
+/**
+ * An AGP below the matrix floor. Not supported, and not built against — it exists only so a test can
+ * prove `RNBrownfieldPlugin.MIN_AGP` actually rejects it instead of letting the consumer fail later
+ * with an unattributable `NoSuchMethodError`.
+ */
+val belowFloorAgp = "8.9.0"
+
+// A TestKit-ready AGP classpath per version above, keyed by version.
+val agpClasspaths =
+    (agpMatrix + belowFloorAgp).associateWith { agpVersion ->
+        val suffix = agpVersion.replace('.', '_')
+        val scope = configurations.dependencyScope("testkitAgp$suffix")
+        dependencies.add(scope.name, "com.android.tools.build:gradle:$agpVersion")
+        configurations.resolvable("testkitAgp${suffix}Classpath") {
+            extendsFrom(scope.get())
+        }
+    }
+
+// `withPluginClasspath()` builds the TestKit fixture classpath from the plugin's runtime
+// classpath, which no longer carries AGP now that it is compileOnly. The fixtures apply
+// `com.android.library`, so hand the floor AGP back to them here — test-only, so nothing
+// reaches the published module.
+tasks.named<PluginUnderTestMetadata>("pluginUnderTestMetadata") {
+    pluginClasspath.from(agpClasspaths.getValue(agpMatrix.first()))
+}
+
+tasks.test {
+    useJUnitPlatform()
+
+    // Tests that want a specific AGP build their own TestKit classpath from these, via
+    // `withPluginClasspath(files)` instead of the no-arg `withPluginClasspath()`.
+    val mainSourceSet = sourceSets.main.get()
+    systemProperty("agp.matrix.versions", agpMatrix.joinToString(","))
+    systemProperty("agp.belowFloor.version", belowFloorAgp)
+    agpClasspaths.forEach { (agpVersion, agpClasspath) ->
+        val pluginClasspath = files(mainSourceSet.output, mainSourceSet.runtimeClasspath, agpClasspath)
+        inputs.files(pluginClasspath).withPropertyName("agpMatrix-$agpVersion").withNormalizer(ClasspathNormalizer::class)
+        jvmArgumentProviders.add(
+            CommandLineArgumentProvider {
+                listOf("-Dagp.classpath.$agpVersion=${pluginClasspath.joinToString(File.pathSeparator)}")
+            },
+        )
+    }
 }
 
 tasks.named("detekt").configure {

package/gradle-plugin/brownfield/gradle/libs.versions.toml

@@ -2,10 +2,14 @@
 kotlinJvm = "2.2.21"
 ktlint = "12.1.1"
 detekt = "1.23.7"
-agp = "8.5.2"
-common = "31.2.2" # do not bump it for now, as it throws an error for incompatible AGP used
+# The AGP the plugin compiles against: deliberately the OLDEST supported version, so the
+# compiler rejects any accidental use of a newer AGP API. Newer AGP is covered by the
+# TestKit matrix in build.gradle.kts. Keep in sync with MIN_AGP in RNBrownfieldPlugin.kt.
+agp = "8.12.0"
+common = "31.12.0"
 asm-commons = "9.7"
 versioncompare = "1.5.0"
+junit = "5.11.4"
 
 [plugins]
 kotlinJvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlinJvm" }
@@ -17,3 +21,4 @@ agp = { module = "com.android.tools.build:gradle", name = "agp", version.ref = "
 common = { module = "com.android.tools:common", version.ref = "common" }
 asm-commons = { module = "org.ow2.asm:asm-commons", version.ref = "asm-commons" }
 versioncompare = { module = "io.github.g00fy2:versioncompare", version.ref = "versioncompare" }
+junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit" }

package/gradle-plugin/brownfield/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

package/gradle-plugin/brownfield/gradle.properties

@@ -1,6 +1,6 @@
 PROJECT_ID=com.callstack.react.brownfield
 ARTIFACT_ID=brownfield-gradle-plugin
-VERSION=2.0.0-alpha08
+VERSION=2.0.0-alpha10
 GROUP=com.callstack.react
 IMPLEMENTATION_CLASS=com.callstack.react.brownfield.plugin.RNBrownfieldPlugin
 

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/artifacts/RncTransitiveDependencyDiscoverer.kt

@@ -0,0 +1,96 @@
+package com.callstack.react.brownfield.artifacts
+
+import com.callstack.react.brownfield.shared.Logging
+import com.callstack.react.brownfield.shared.TRANSITIVE_DEPENDENCY_CONFIG_NAMES
+import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
+import com.callstack.react.brownfield.shared.VersionMediatingDependencySet
+import com.callstack.react.brownfield.shared.collectPublishableGradleDependencies
+import com.callstack.react.brownfield.shared.isPublishableCoordinate
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Dependency
+
+/**
+ * Result of [RncTransitiveDependencyDiscoverer.discover].
+ *
+ * @param dependencies The mediated set of third-party dependencies to inject.
+ * @param supersededCoordinates Coordinates the consumer declares itself that an embedded module
+ * also needs. The caller must drop their pre-existing POM/module.json entries: [dependencies]
+ * already carries the mediated (never-lower) version, so keeping both duplicates or shadows it.
+ */
+data class RncTransitiveDependencyDiscoveryResult(
+    val dependencies: VersionMediatingDependencySet,
+    val supersededCoordinates: Set<Pair<String, String>>,
+)
+
+/**
+ * Discovers third-party dependencies of the native modules embedded into the fat AAR, for
+ * publication into its POM/module metadata. The RNC-CLI counterpart to
+ * `ExpoPublishingHelper.appendExpoTransitiveDependenciesFromGradle`.
+ */
+class RncTransitiveDependencyDiscoverer(private val project: Project) {
+    fun discover(artifacts: List<UnresolvedArtifactInfo>): RncTransitiveDependencyDiscoveryResult {
+        val discovered = VersionMediatingDependencySet()
+        val supersededCoordinates = mutableSetOf<Pair<String, String>>()
+
+        artifacts
+            .filter { it.isExpoPublishDependency != true }
+            .forEach { artifact -> discoverFromArtifact(artifact, discovered, supersededCoordinates) }
+
+        return RncTransitiveDependencyDiscoveryResult(discovered, supersededCoordinates)
+    }
+
+    private fun discoverFromArtifact(
+        artifact: UnresolvedArtifactInfo,
+        discovered: VersionMediatingDependencySet,
+        supersededCoordinates: MutableSet<Pair<String, String>>,
+    ) {
+        val moduleProject = project.rootProject.findProject(":${artifact.moduleName}")
+        if (moduleProject == null) {
+            Logging.log(
+                "WARNING: Could not discover transitive dependencies for embedded module " +
+                    "'${artifact.moduleName}' - no Gradle project found at " +
+                    "':${artifact.moduleName}' in the root project",
+            )
+            return
+        }
+
+        collectPublishableGradleDependencies(moduleProject).forEach { moduleDependency ->
+            val consumerDeclaration = consumerDeclaredDependency(moduleDependency.groupId, moduleDependency.artifactId)
+
+            if (consumerDeclaration != null) {
+                // Supersede on the declaration existing, not on it having a version: a versionless
+                // one (BOM/platform) still leaves a stale entry that must be replaced, not doubled.
+                supersededCoordinates.add(moduleDependency.groupId to moduleDependency.artifactId)
+
+                // Module-side versions are already validated upstream; this is the consumer-side
+                // equivalent, keeping a dynamic version from winning mediation and being published.
+                val consumerVersioned = moduleDependency.copy(version = consumerDeclaration.version)
+                if (isPublishableCoordinate(consumerVersioned)) {
+                    discovered.add(consumerVersioned)
+                }
+            }
+
+            discovered.add(moduleDependency)
+        }
+    }
+
+    /**
+     * The consumer's own declaration of this coordinate, or null if it doesn't declare it. Returns
+     * the [Dependency], not its version, so "declared without a version" stays distinguishable from
+     * "not declared" — collapsing the two leaks duplicate POM entries.
+     *
+     * Note this narrows a dynamic declaration: consumer `appcompat:1.+` against module `1.0.0`
+     * publishes `1.0.0`, possibly lower than `1.+` would have resolved to. Intended — a published
+     * `1.+` is broken for downstream consumers.
+     */
+    private fun consumerDeclaredDependency(
+        groupId: String,
+        artifactId: String,
+    ): Dependency? {
+        return TRANSITIVE_DEPENDENCY_CONFIG_NAMES.firstNotNullOfOrNull { configName ->
+            project.configurations.findByName(configName)?.dependencies?.firstOrNull {
+                it.group == groupId && it.name == artifactId
+            }
+        }
+    }
+}

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/expo/ExpoPublishingHelper.kt

@@ -1,20 +1,15 @@
 package com.callstack.react.brownfield.expo
 
 import com.android.utils.forEach
-import com.callstack.react.brownfield.expo.utils.DependencyInfo
 import com.callstack.react.brownfield.expo.utils.ExpoGradleProjectProjection
 import com.callstack.react.brownfield.expo.utils.LocalMavenUtils
-import com.callstack.react.brownfield.expo.utils.VersionMediatingDependencySet
 import com.callstack.react.brownfield.expo.utils.asExpoGradleProjectProjection
 import com.callstack.react.brownfield.shared.Constants
+import com.callstack.react.brownfield.shared.DependencyInfo
 import com.callstack.react.brownfield.shared.Logging
-import groovy.json.JsonOutput
-import groovy.json.JsonSlurper
-import groovy.util.NodeList
+import com.callstack.react.brownfield.shared.VersionMediatingDependencySet
+import com.callstack.react.brownfield.shared.collectPublishableGradleDependencies
 import org.gradle.api.Project
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.publish.tasks.GenerateModuleMetadata
 import org.w3c.dom.Node
 import java.io.File
 import javax.xml.parsers.DocumentBuilderFactory
@@ -29,6 +24,11 @@ fun Node.getChildNodeByName(nodeName: String): Node? {
 }
 
 open class ExpoPublishingHelper(val brownfieldAppProject: Project) {
+    /**
+     * Discovers *which* Expo projects are publishable, not their transitive dependencies: this runs
+     * during `apply()`, when those projects may not have configured their own dependencies yet.
+     * [discoverAllExpoTransitiveDependencies] handles that later.
+     */
     fun configure(): List<ExpoGradleProjectProjection> {
         val discoverableExpoProjects = getDiscoverableExpoProjects()
 
@@ -39,29 +39,10 @@ open class ExpoPublishingHelper(val brownfieldAppProject: Project) {
                 ) { it.name },
         )
 
-        val expoTransitiveDependencies =
-            discoverAllExpoTransitiveDependencies(
-                expoProjects = discoverableExpoProjects,
-            )
-
-        Logging.log(
-            "Collected a total of ${expoTransitiveDependencies.size} unique Expo transitive " +
-                "dependencies for brownfield app project publishing",
-        )
-        expoTransitiveDependencies.forEach {
-            Logging.log(
-                "(*) dependency ${it.groupId}:${it.artifactId}:${it.version} (scope: ${it.scope}, " +
-                    "${if (it.optional) "optional" else "required"})",
-            )
-        }
-
-        reconfigurePOM(expoTransitiveDependencies)
-        reconfigureGradleModuleJSON(expoTransitiveDependencies)
-
         return discoverableExpoProjects
     }
 
-    protected fun shouldExcludeDependency(
+    internal fun shouldExcludeDependency(
         groupId: String,
         artifactId: String,
     ): Boolean {
@@ -78,174 +59,6 @@ open class ExpoPublishingHelper(val brownfieldAppProject: Project) {
         return (isRootProjectArtifact || isExpoArtifact)
     }
 
-    /**
-     * Modifies the generated Gradle Module Metadata file to inject Expo transitive dependencies.
-     * @param discoveredExpoTransitiveDependencies Set of DependencyInfo
-     * representing Expo transitive dependencies to add.
-     */
-    @Suppress("LongMethod")
-    protected fun reconfigureGradleModuleJSON(discoveredExpoTransitiveDependencies: VersionMediatingDependencySet) {
-        val removeDependenciesFromModuleFileTask =
-            brownfieldAppProject.tasks.register("removeDependenciesFromModuleFile")
-        removeDependenciesFromModuleFileTask.configure { task ->
-            task.doLast {
-                val moduleBuildDir = brownfieldAppProject.layout.buildDirectory.get()
-
-                File("$moduleBuildDir/publications/mavenAar/module.json").run {
-                    val json = inputStream().use { JsonSlurper().parse(it) as Map<*, *> }
-
-                    discoveredExpoTransitiveDependencies.forEach { dependencyToAdd ->
-                        @Suppress("UNCHECKED_CAST")
-                        (json["variants"] as? List<MutableMap<String, Any>>)?.forEach { variant ->
-                            Logging.log(
-                                "Injecting dependency to Gradle module JSON for variant " +
-                                    "'${variant["name"]}': ${dependencyToAdd.groupId}:" +
-                                    "${dependencyToAdd.artifactId}:${dependencyToAdd.version}",
-                            )
-
-                            (variant["dependencies"] as? MutableList<MutableMap<String, Any>>)?.add(
-                                mutableMapOf<String, Any>(
-                                    "group" to dependencyToAdd.groupId,
-                                    "module" to dependencyToAdd.artifactId,
-                                ).apply {
-                                    dependencyToAdd.version?.let { version ->
-                                        put(
-                                            "version",
-                                            mapOf(
-                                                "requires" to version,
-                                            ),
-                                        )
-                                    }
-                                },
-                            )
-                        }
-                    }
-
-                    @Suppress("UNCHECKED_CAST")
-                    (json["variants"] as? List<MutableMap<String, Any>>)?.forEach { variant ->
-                        (variant["dependencies"] as? MutableList<Map<String, Any>>)?.removeAll {
-                            val group = it["group"] as String
-                            val module = it["module"] as String
-
-                            val shouldBeExcluded =
-                                shouldExcludeDependency(
-                                    groupId = group,
-                                    artifactId = module,
-                                )
-
-                            if (shouldBeExcluded) {
-                                Logging.log(
-                                    "Removing excluded dependency from Gradle module JSON: $group:$module",
-                                )
-                            }
-
-                            shouldBeExcluded
-                        }
-
-                        writer().use {
-                            it.write(
-                                JsonOutput.prettyPrint(
-                                    JsonOutput.toJson(
-                                        json,
-                                    ),
-                                ),
-                            )
-                        }
-                    }
-                }
-            }
-        }
-
-        brownfieldAppProject.tasks.withType(GenerateModuleMetadata::class.java)
-            .configureEach {
-                it.finalizedBy(removeDependenciesFromModuleFileTask.get())
-            }
-    }
-
-    /**
-     * Modifies the generated Maven POM file to inject Expo transitive dependencies.
-     * @param discoveredExpoTransitiveDependencies Set of DependencyInfo
-     * representing Expo transitive dependencies to add.
-     */
-    @Suppress("LongMethod")
-    protected fun reconfigurePOM(discoveredExpoTransitiveDependencies: VersionMediatingDependencySet) {
-        brownfieldAppProject.pluginManager.withPlugin("maven-publish") {
-            brownfieldAppProject.extensions.configure(PublishingExtension::class.java) { publishing ->
-                publishing.publications.withType(MavenPublication::class.java)
-                    .configureEach { pub ->
-                        Logging.log(
-                            "Configuring POM for publication '${pub.name}' to include Expo transitive dependencies",
-                        )
-
-                        pub.pom.withXml {
-                            val root = it.asNode()
-
-                            // below: obtains a view of the <dependencies> node(s)
-                            // inside the POM XML; in practice, there should be only one such node
-                            val dependenciesNodeList =
-                                root.get("dependencies") as NodeList
-                            val dependenciesNode =
-                                dependenciesNodeList.first() as groovy.util.Node
-
-                            // below: inject the discovered Expo transitive dependencies
-                            // into the POM's <dependencies> node
-                            discoveredExpoTransitiveDependencies.forEach { dependencyToAdd ->
-                                Logging.log(
-                                    "Injecting dependency to POM: ${dependencyToAdd.groupId}:" +
-                                        "${dependencyToAdd.artifactId}:${dependencyToAdd.version}",
-                                )
-
-                                val childTags =
-                                    mutableMapOf(
-                                        "groupId" to dependencyToAdd.groupId,
-                                        "artifactId" to dependencyToAdd.artifactId,
-                                        "scope" to dependencyToAdd.scope,
-                                        "optional" to dependencyToAdd.optional.toString(),
-                                    )
-
-                                if (dependencyToAdd.version?.isNotBlank() == true) {
-                                    childTags["version"] = dependencyToAdd.version
-                                }
-
-                                dependenciesNode.appendNode("dependency").let { newDepNode ->
-                                    childTags.forEach { (tagName, tagValue) ->
-                                        newDepNode.appendNode(tagName, tagValue)
-                                    }
-                                }
-                            }
-
-                            // below: filter out dependencies that should be excluded
-                            dependenciesNode.children()
-                                .filterIsInstance<groovy.util.Node>()
-                                .filter { dependency ->
-                                    val groupId =
-                                        (dependency["groupId"] as NodeList).text()
-                                    val artifactId =
-                                        (dependency["artifactId"] as NodeList).text()
-
-                                    val shouldBeExcluded =
-                                        shouldExcludeDependency(
-                                            groupId = groupId,
-                                            artifactId = artifactId,
-                                        )
-
-                                    if (shouldBeExcluded) {
-                                        Logging.log(
-                                            "Removing excluded dependency from POM: $groupId:$artifactId",
-                                        )
-                                    }
-
-                                    shouldBeExcluded
-                                }
-                                .forEach { dependency ->
-                                    dependenciesNode.remove(dependency)
-                                }
-                        }
-                    }
-            }
-        }
-    }
-
     fun discoverAllExpoTransitiveDependencies(expoProjects: Iterable<ExpoGradleProjectProjection>): VersionMediatingDependencySet {
         var discoveredExpoTransitiveDependencies = VersionMediatingDependencySet()
         expoProjects.forEach { expoProj ->
@@ -368,24 +181,7 @@ open class ExpoPublishingHelper(val brownfieldAppProject: Project) {
         pkgProject: Project,
         dependencies: VersionMediatingDependencySet,
     ) {
-        /**
-         * Not accounting for variant specific configurations as Expo packages are not
-         * using it. Should we face any issues/needs to account for it, we can do it here.
-         */
-        listOf("implementation", "api", "runtime").forEach {
-            val configuration = pkgProject.configurations.findByName(it)
-            configuration?.dependencies?.forEach { dep ->
-                if (dep.group != null) {
-                    dependencies.add(
-                        DependencyInfo.fromGradleDep(
-                            groupId = dep.group!!,
-                            artifactId = dep.name,
-                            version = dep.version,
-                        ),
-                    )
-                }
-            }
-        }
+        dependencies.addAll(collectPublishableGradleDependencies(pkgProject))
     }
 
     /**

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/expo/utils/BrownfieldPublishingInfo.kt

@@ -0,0 +1,7 @@
+package com.callstack.react.brownfield.expo.utils
+
+data class BrownfieldPublishingInfo(
+    val groupId: String,
+    val artifactId: String,
+    val version: String,
+)