@callstack/react-native-brownfield 5.0.2 → 5.1.1

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @callstack/react-native-brownfield
 
+## 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
+
+- [#450](https://github.com/callstack/react-native-brownfield/pull/450) [`4846a05`](https://github.com/callstack/react-native-brownfield/commit/4846a055eb06f8c8dea08b33d0bb0d1b2a2f2f86) Thanks [@borisyankov](https://github.com/borisyankov)! - Add `preloadBundle` to `startReactNative` on iOS. Without a preload, `startReactNative` only makes the factory, and React Native loads the JavaScript bundle when it creates the first React Native view. `startReactNative(launchOptions:preloadBundle:onBundleLoaded:)` moves that work to the app launch: the call starts the React Host, and React Native evaluates the bundle on the JavaScript thread, in parallel with the remainder of the app launch. On Android, `ReactNativeBrownfield.initialize` does the same operation. This shape of `startReactNative` also takes the launch options for the React Host.
+
+  `onBundleLoaded` now runs on the main thread, and not on the JavaScript thread. A callback that you add after React Native loaded the bundle runs in the next turn of the main run loop.
+
+### Patch Changes
+
+- [#381](https://github.com/callstack/react-native-brownfield/pull/381) [`b8e8da5`](https://github.com/callstack/react-native-brownfield/commit/b8e8da50fbf20058c5c2745981c7deb5cb33061a) Thanks [@alpharius-ck](https://github.com/alpharius-ck)! - e2e tests for android
+- Updated dependencies []:
+  - @callstack/brownfield-cli@5.1.0
+
 ## 5.0.2
 
 ### Patch Changes

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

@@ -65,6 +65,8 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             if (!initialized.getAndSet(true)) {
                 loadNativeLibs(application)
                 installAndPreload(reactHost, onJSBundleLoaded)
+            } else {
+                invokeWhenJSBundleLoaded(onJSBundleLoaded)
             }
         }
 
@@ -77,6 +79,8 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             if (!initialized.getAndSet(true)) {
                 loadNativeLibs(application)
                 installAndPreload(reactHostFactory(), onJSBundleLoaded)
+            } else {
+                invokeWhenJSBundleLoaded(onJSBundleLoaded)
             }
         }
         
@@ -102,6 +106,8 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
                     jsRuntimeFactory = null
                 )
                 installAndPreload(reactHost, onJSBundleLoaded)
+            } else {
+                invokeWhenJSBundleLoaded(onJSBundleLoaded)
             }
         }
 
@@ -134,6 +140,25 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
                 onJSBundleLoaded?.invoke(true)
             }
         }
+
+        private fun invokeWhenJSBundleLoaded(onJSBundleLoaded: OnJSBundleLoaded?) {
+            if (onJSBundleLoaded == null || !::instance.isInitialized) {
+                return
+            }
+
+            val reactHost = instance.reactHost
+            reactHost.currentReactContext?.let {
+                onJSBundleLoaded.invoke(true)
+                return
+            }
+
+            reactHost.addReactInstanceEventListener(object : ReactInstanceEventListener {
+                override fun onReactContextInitialized(context: ReactContext) {
+                    onJSBundleLoaded.invoke(true)
+                    reactHost.removeReactInstanceEventListener(this)
+                }
+            })
+        }
     }
 
     /**
@@ -177,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 =
@@ -190,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
+            }
         }
 
         /**
@@ -205,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
         )
     }
 
@@ -69,6 +71,26 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
         }
     }
 
+    override fun onPause() {
+        try {
+            super.onPause()
+        } catch (error: AssertionError) {
+            if (
+                error.message?.contains(
+                    "Pausing an activity that is not the current activity"
+                ) == true
+            ) {
+                Log.w(
+                    "ReactNativeFragment",
+                    "Ignoring stale onHostPause for ${activity?.javaClass?.simpleName}",
+                    error
+                )
+                return
+            }
+            throw error
+        }
+    }
+
     override fun onRequestPermissionsResult(
         requestCode: Int,
         permissions: Array<String>,

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

@@ -108,6 +108,13 @@ dependencies {
     implementation(libs.common)
     implementation(libs.asm.commons)
     implementation(libs.versioncompare)
+    testImplementation(libs.junit.jupiter)
+    testImplementation(gradleTestKit())
+    testImplementation(kotlin("test"))
+}
+
+tasks.test {
+    useJUnitPlatform()
 }
 
 tasks.named("detekt").configure {

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

@@ -6,6 +6,7 @@ agp = "8.5.2"
 common = "31.2.2" # do not bump it for now, as it throws an error for incompatible AGP used
 asm-commons = "9.7"
 versioncompare = "1.5.0"
+junit = "5.11.4"
 
 [plugins]
 kotlinJvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlinJvm" }
@@ -17,3 +18,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.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-alpha09
 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,
+)