@callstack/react-native-brownfield 5.1.0 → 5.1.1

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/shared/DependencyPublishabilityTest.kt

@@ -0,0 +1,67 @@
+package com.callstack.react.brownfield.shared
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class DependencyPublishabilityTest {
+    @Test
+    fun `rejects a fully dynamic version`() {
+        val dep = DependencyInfo("com.facebook.react", "react-native", "+", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a partially dynamic version`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "1.+", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a null version`() {
+        val dep = DependencyInfo("com.facebook.react", "react-android", null, "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a blank version`() {
+        val dep = DependencyInfo("com.facebook.react", "react-android", "  ", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `accepts a normal pinned version`() {
+        val dep = DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false)
+        assertTrue(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects latest_release`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "latest.release", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects latest_integration`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "latest.integration", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a closed Maven version range`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "[1.0,2.0]", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects a half-open Maven version range`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "[1.0,2.0)", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+
+    @Test
+    fun `rejects an unbounded Maven version range`() {
+        val dep = DependencyInfo("androidx.core", "core-ktx", "[1.0,)", "compile", false)
+        assertFalse(isPublishableCoordinate(dep))
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/shared/PublishingMetadataInjectorTest.kt

@@ -0,0 +1,222 @@
+package com.callstack.react.brownfield.shared
+
+import groovy.util.NodeList
+import groovy.xml.XmlParser
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class PublishingMetadataInjectorTaskRegistrationTest {
+    @Test
+    fun `does not claim the task name the setup docs tell consumers to register`() {
+        val project = ProjectBuilder.builder().build()
+
+        PublishingMetadataInjector(project)
+
+        assertNull(
+            project.tasks.findByName(Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME),
+            "the plugin must leave this name free: the published setup docs tell every bare-RN " +
+                "consumer to register it themselves, and the plugin applies before their script body",
+        )
+        assertNotNull(
+            project.tasks.findByName(Constants.MODULE_METADATA_POST_PROCESS_TASK_NAME),
+        )
+    }
+
+    @Test
+    fun `a not-yet-migrated consumer can still register the legacy task after the plugin has run`() {
+        // The upgrade path at the task-container level: plugin registers during apply(), then the
+        // consumer's script body registers the task the docs told them to. Must not throw.
+        val project = ProjectBuilder.builder().build()
+
+        PublishingMetadataInjector(project)
+        project.tasks.register(Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME)
+
+        assertNotNull(project.tasks.findByName(Constants.LEGACY_CONSUMER_MODULE_METADATA_TASK_NAME))
+        assertNotNull(project.tasks.findByName(Constants.MODULE_METADATA_POST_PROCESS_TASK_NAME))
+    }
+}
+
+class MutatePomDependenciesNodeTest {
+    private fun dependenciesNodeFrom(xml: String): groovy.util.Node {
+        val root = XmlParser().parseText(xml)
+        return (root.get("dependencies") as NodeList).first() as groovy.util.Node
+    }
+
+    private fun versionsFor(
+        dependenciesNode: groovy.util.Node,
+        groupId: String,
+        artifactId: String,
+    ): List<String> {
+        return dependenciesNode.children()
+            .filterIsInstance<groovy.util.Node>()
+            .filter {
+                (it["groupId"] as NodeList).text() == groupId && (it["artifactId"] as NodeList).text() == artifactId
+            }
+            .map { (it["version"] as NodeList).text() }
+    }
+
+    @Test
+    fun `appends new dependencies with no pre-existing entries`() {
+        val dependenciesNode = dependenciesNodeFrom("<project><dependencies/></project>")
+        val toInject = VersionMediatingDependencySet()
+        toInject.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        mutatePomDependenciesNode(dependenciesNode, toInject) { _, _ -> false }
+
+        assertEquals(listOf("1.17.0"), versionsFor(dependenciesNode, "androidx.core", "core-ktx"))
+    }
+
+    @Test
+    fun `injects into a POM that has no dependencies element at all`() {
+        // Must call resolveOrCreateDependenciesNode — inlining the fallback here would make this
+        // pass even with the production path reverted to first().
+        val root = XmlParser().parseText("<project/>")
+        val toInject = VersionMediatingDependencySet()
+        toInject.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        val dependenciesNode = resolveOrCreateDependenciesNode(root)
+        mutatePomDependenciesNode(dependenciesNode, toInject) { _, _ -> false }
+
+        assertEquals(listOf("1.17.0"), versionsFor(dependenciesNode, "androidx.core", "core-ktx"))
+    }
+
+    @Test
+    fun `reuses the existing dependencies element instead of appending a second one`() {
+        val root =
+            XmlParser().parseText(
+                """
+                <project>
+                  <dependencies>
+                    <dependency>
+                      <groupId>androidx.core</groupId>
+                      <artifactId>core-ktx</artifactId>
+                      <version>1.17.0</version>
+                    </dependency>
+                  </dependencies>
+                </project>
+                """.trimIndent(),
+            )
+
+        val dependenciesNode = resolveOrCreateDependenciesNode(root)
+
+        assertEquals(
+            1,
+            (root.get("dependencies") as NodeList).size,
+            "a POM that already has <dependencies> must not gain a second one",
+        )
+        assertEquals(listOf("1.17.0"), versionsFor(dependenciesNode, "androidx.core", "core-ktx"))
+    }
+
+    @Test
+    fun `removes an unrelated excluded entry that is not being re-injected`() {
+        val dependenciesNode =
+            dependenciesNodeFrom(
+                """
+                <project>
+                  <dependencies>
+                    <dependency>
+                      <groupId>com.rnapp</groupId>
+                      <artifactId>brownfieldlib</artifactId>
+                      <version>unspecified</version>
+                    </dependency>
+                  </dependencies>
+                </project>
+                """.trimIndent(),
+            )
+
+        mutatePomDependenciesNode(dependenciesNode, VersionMediatingDependencySet()) { groupId, _ ->
+            groupId == "com.rnapp"
+        }
+
+        assertTrue(versionsFor(dependenciesNode, "com.rnapp", "brownfieldlib").isEmpty())
+    }
+
+    @Test
+    fun `a superseded stale entry is replaced by the mediated version, not left duplicated or missing`() {
+        // Consumer hand-declares 1.6.0, embedded module needs 1.7.1, so the coordinate is
+        // superseded and shouldExclude matches it. The mediated 1.7.1 must survive exactly once.
+        val dependenciesNode =
+            dependenciesNodeFrom(
+                """
+                <project>
+                  <dependencies>
+                    <dependency>
+                      <groupId>androidx.appcompat</groupId>
+                      <artifactId>appcompat</artifactId>
+                      <version>1.6.0</version>
+                      <scope>runtime</scope>
+                    </dependency>
+                  </dependencies>
+                </project>
+                """.trimIndent(),
+            )
+        val mediated = VersionMediatingDependencySet()
+        mediated.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        mutatePomDependenciesNode(dependenciesNode, mediated) { groupId, artifactId ->
+            groupId == "androidx.appcompat" && artifactId == "appcompat"
+        }
+
+        assertEquals(listOf("1.7.1"), versionsFor(dependenciesNode, "androidx.appcompat", "appcompat"))
+    }
+}
+
+class MutateModuleJsonVariantsTest {
+    private fun jsonWithVariant(dependencies: MutableList<MutableMap<String, Any>>): MutableMap<String, Any> {
+        return mutableMapOf(
+            "variants" to
+                mutableListOf(
+                    mutableMapOf<String, Any>(
+                        "name" to "runtimeElements",
+                        "dependencies" to dependencies,
+                    ),
+                ),
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun dependenciesOf(json: Map<*, *>): List<Map<String, Any>> {
+        val variants = json["variants"] as List<Map<String, Any>>
+        return variants.first()["dependencies"] as List<Map<String, Any>>
+    }
+
+    @Test
+    fun `appends new dependencies with no pre-existing entries`() {
+        val json = jsonWithVariant(mutableListOf())
+        val toInject = VersionMediatingDependencySet()
+        toInject.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        mutateModuleJsonVariants(json, toInject) { _, _ -> false }
+
+        val deps = dependenciesOf(json)
+        assertEquals(1, deps.size)
+        assertEquals("androidx.core", deps.first()["group"])
+        assertEquals("core-ktx", deps.first()["module"])
+    }
+
+    @Test
+    fun `a superseded stale entry is replaced by the mediated version, not left duplicated or missing`() {
+        val json =
+            jsonWithVariant(
+                mutableListOf(
+                    mutableMapOf("group" to "androidx.appcompat", "module" to "appcompat"),
+                ),
+            )
+        val mediated = VersionMediatingDependencySet()
+        mediated.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        mutateModuleJsonVariants(json, mediated) { group, module ->
+            group == "androidx.appcompat" && module == "appcompat"
+        }
+
+        val deps = dependenciesOf(json)
+        assertEquals(1, deps.size, "expected exactly one entry, not zero (deleted) or two (duplicated)")
+        @Suppress("UNCHECKED_CAST")
+        val version = (deps.first()["version"] as? Map<String, Any>)?.get("requires")
+        assertEquals("1.7.1", version)
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/shared/TransitiveDependencyFilteringTest.kt

@@ -0,0 +1,37 @@
+package com.callstack.react.brownfield.shared
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class TransitiveDependencyFilteringTest {
+    @Test
+    fun `drops a hard-excluded coordinate the RNC discoverer found, even though it has no Expo awareness`() {
+        // The RNC discoverer has no Expo blacklist, so an embedded module depending on an Expo
+        // coordinate would otherwise be published as a Maven dependency that resolves nowhere.
+        val transitiveDeps = VersionMediatingDependencySet()
+        transitiveDeps.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+        transitiveDeps.add(DependencyInfo("host.exp.exponent", "expo.modules.device", "56.0.4", "compile", false))
+
+        val hardExcludePredicate: (String, String) -> Boolean = { groupId, _ -> groupId == "host.exp.exponent" }
+        dropHardExcludedDependencies(transitiveDeps, hardExcludePredicate)
+
+        assertTrue(transitiveDeps.contains(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false)))
+        assertFalse(transitiveDeps.any { it.groupId == "host.exp.exponent" })
+        assertEquals(1, transitiveDeps.size)
+    }
+
+    @Test
+    fun `does not drop a superseded coordinate that is meant to still be injected`() {
+        // hardExcludePredicate must never include the supersede check, or a mediated
+        // replacement for a consumer's stale hand-declared dependency would be dropped too.
+        val transitiveDeps = VersionMediatingDependencySet()
+        transitiveDeps.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        dropHardExcludedDependencies(transitiveDeps) { _, _ -> false }
+
+        assertTrue(transitiveDeps.contains(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false)))
+        assertEquals(1, transitiveDeps.size)
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/shared/VersionMediatingDependencySetTest.kt

@@ -0,0 +1,42 @@
+package com.callstack.react.brownfield.shared
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class VersionMediatingDependencySetTest {
+    @Test
+    fun `keeps the higher version when the same coordinate is added twice`() {
+        val set = VersionMediatingDependencySet()
+
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.6.0", "compile", false))
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+
+        assertEquals(1, set.size)
+        assertTrue(set.contains(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false)))
+    }
+
+    @Test
+    fun `does not downgrade when a lower version is added second`() {
+        val set = VersionMediatingDependencySet()
+
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.7.1", "compile", false))
+        set.add(DependencyInfo("androidx.appcompat", "appcompat", "1.6.0", "compile", false))
+
+        val kept = set.first { it.groupId == "androidx.appcompat" }
+        assertEquals("1.7.1", kept.version)
+    }
+
+    @Test
+    fun `removeAll removes matching entries and returns them`() {
+        val set = VersionMediatingDependencySet()
+        set.add(DependencyInfo("host.exp.exponent", "expo", "1.0.0", "compile", false))
+        set.add(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false))
+
+        val removed = set.removeAll { it.groupId == "host.exp.exponent" }
+
+        assertEquals(1, removed.size)
+        assertEquals(1, set.size)
+        assertTrue(set.contains(DependencyInfo("androidx.core", "core-ktx", "1.17.0", "compile", false)))
+    }
+}

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/utils/ExtensionTest.kt

@@ -0,0 +1,11 @@
+package com.callstack.react.brownfield.utils
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertTrue
+
+class ExtensionTest {
+    @Test
+    fun `experimentalIncludeTransitiveDependencies defaults to true`() {
+        assertTrue(Extension().experimentalIncludeTransitiveDependencies)
+    }
+}

package/ios/BrownfieldSurfaceRegistry.swift

@@ -0,0 +1,93 @@
+import Foundation
+
+/// Identifies one live React Native surface. Vended by `BrownfieldSurfaceRegistry`.
+struct BrownfieldSurfaceID: Hashable, CustomStringConvertible {
+  fileprivate let rawValue: UInt64
+
+  var description: String { "surface#\(rawValue)" }
+}
+
+/// Decides which React Native surface may act on a `popToNative()` request.
+///
+/// `popToNative()` is delivered as an app-wide notification, so every live React
+/// Native surface receives it — including ones buried under other screens. Acting
+/// on all of them tears down the whole navigation stack
+/// (https://github.com/callstack/react-native-brownfield/issues/354).
+///
+/// The registry resolves that to a single surface: whichever on-screen surface
+/// was shown most recently.
+///
+/// Visibility is asked for at query time instead of being cached from lifecycle
+/// callbacks. Hosts recreate view controllers — SwiftUI does it freely — and a
+/// cached flag is stale exactly when the notification arrives.
+///
+/// Deliberately free of UIKit so it can be unit tested on macOS via `swift test`.
+/// Internal, like the sibling `BrownfieldBundleSupport` target: it is an
+/// implementation detail of the pod, not API for host apps.
+final class BrownfieldSurfaceRegistry {
+  static let shared = BrownfieldSurfaceRegistry()
+
+  private struct Surface {
+    let isOnScreen: () -> Bool
+    var shownAt: UInt64
+  }
+
+  private let lock = NSLock()
+  private var nextSurfaceValue: UInt64 = 0
+  private var nextShownValue: UInt64 = 0
+  private var surfaces: [BrownfieldSurfaceID: Surface] = [:]
+
+  init() {}
+
+  /// - Parameter isOnScreen: queried on every `popTarget()`. Capture the host
+  ///   weakly so a released surface stops winning the election.
+  func register(isOnScreen: @escaping () -> Bool) -> BrownfieldSurfaceID {
+    lock.lock()
+    defer { lock.unlock() }
+
+    nextSurfaceValue += 1
+    let id = BrownfieldSurfaceID(rawValue: nextSurfaceValue)
+    surfaces[id] = Surface(isOnScreen: isOnScreen, shownAt: 0)
+    return id
+  }
+
+  func unregister(_ surface: BrownfieldSurfaceID) {
+    lock.lock()
+    defer { lock.unlock() }
+
+    surfaces.removeValue(forKey: surface)
+  }
+
+  /// Records that a surface was just shown, ordering it ahead of other on-screen
+  /// surfaces. Only a tiebreaker — a surface never marked shown can still win
+  /// when it is the one on screen.
+  func markShown(_ surface: BrownfieldSurfaceID) {
+    lock.lock()
+    defer { lock.unlock() }
+
+    guard var entry = surfaces[surface] else { return }
+
+    nextShownValue += 1
+    entry.shownAt = nextShownValue
+    surfaces[surface] = entry
+  }
+
+  /// The single surface allowed to handle `popToNative()`, or `nil` when no
+  /// React Native surface is on screen.
+  func popTarget() -> BrownfieldSurfaceID? {
+    lock.lock()
+    let candidates = surfaces
+    lock.unlock()
+
+    return candidates
+      .filter { $0.value.isOnScreen() }
+      .max { lhs, rhs in
+        (lhs.value.shownAt, lhs.key.rawValue) < (rhs.value.shownAt, rhs.key.rawValue)
+      }?
+      .key
+  }
+
+  func isPopTarget(_ surface: BrownfieldSurfaceID) -> Bool {
+    popTarget() == surface
+  }
+}

package/ios/Views/ReactNativeView.swift

@@ -1,20 +1,38 @@
 import SwiftUI
 
+/**
+ Links a SwiftUI `ReactNativeView` to the view controller it hosts, so the
+ SwiftUI layer can ask whether this surface may act on `popToNative()`.
+ */
+final class BrownfieldSurfaceHost {
+  weak var controller: ReactNativeViewController?
+
+  var isPopTarget: Bool { controller?.isPopTarget ?? false }
+}
+
 /**
  A UIViewControllerRepresentable that bridges ReactNativeViewController to SwiftUI.
  */
 struct ReactNativeViewRepresentable: UIViewControllerRepresentable {
   var moduleName: String
   var initialProperties: [String: Any] = [:]
+  var host: BrownfieldSurfaceHost
 
   func makeUIViewController(context: Context) -> UIViewController {
-    return ReactNativeViewController(
+    let controller = ReactNativeViewController(
       moduleName: moduleName,
       initialProperties: initialProperties
     )
+    controller.isHostedBySwiftUI = true
+    host.controller = controller
+    return controller
   }
 
-  func updateUIViewController(_ uiViewController: UIViewController, context: Context) {}
+  func updateUIViewController(_ uiViewController: UIViewController, context: Context) {
+    if let controller = uiViewController as? ReactNativeViewController {
+      host.controller = controller
+    }
+  }
 }
 
 /**
@@ -24,6 +42,7 @@ struct ReactNativeViewRepresentable: UIViewControllerRepresentable {
 @available(iOS 15.0, *)
 public struct ReactNativeView: View {
   @Environment(\.dismiss) var dismiss
+  @State private var host = BrownfieldSurfaceHost()
   var moduleName: String
   var initialProperties: [String: Any] = [:]
 
@@ -35,11 +54,21 @@ public struct ReactNativeView: View {
   public var body: some View {
     ReactNativeViewRepresentable(
       moduleName: moduleName,
-      initialProperties: initialProperties
+      initialProperties: initialProperties,
+      host: host
     )
     .ignoresSafeArea(.all)
-    .onReceive(NotificationCenter.default.publisher(for: NSNotification.Name.popToNative))
-    { notification in
+    // `.popToNative` is public API and may be posted from any thread, while
+    // `host.isPopTarget` reads UIKit state — so deliver on main.
+    .onReceive(
+      NotificationCenter.default
+        .publisher(for: NSNotification.Name.popToNative)
+        .receive(on: DispatchQueue.main)
+    ) { _ in
+      // Every live surface receives this app-wide notification; only the
+      // topmost on-screen one may dismiss.
+      // https://github.com/callstack/react-native-brownfield/issues/354
+      guard host.isPopTarget else { return }
       dismiss()
     }
   }