@momo-kits/native-kits 0.164.1-beta.6-debug → 0.164.1-beta.7-debug

package/compose/build.gradle.kts

@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.164.1-beta.6-debug"
+        version = "0.164.1-beta.7-debug"
         summary = "IOS Shared module"
         homepage = "https://momo.vn"
         ios.deploymentTarget = "15.0"

package/compose/compose.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |spec|
     spec.name                     = 'compose'
-    spec.version                  = '0.164.1-beta.6-debug'
+    spec.version                  = '0.164.1-beta.7-debug'
     spec.homepage                 = 'https://momo.vn'
     spec.source                   = { :http=> ''}
     spec.authors                  = ''

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/NavigationContainer.kt

@@ -161,7 +161,8 @@ fun NavigationContainer(
                                     id = route.id,
                                     name = screen.name,
                                     content = screen.content,
-                                    navigationOptions = screen.options
+                                    navigationOptions = screen.options,
+                                    isDialogRoute = true
                                 )
                             }
                         }

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/Navigator.kt

@@ -10,6 +10,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.navigation.NavBackStackEntry
 import androidx.navigation.NavController
 import androidx.navigation.NavGraph
 import androidx.navigation.toRoute
@@ -88,9 +89,16 @@ class Navigator(
     @Composable
     internal fun rememberCanPop(): Boolean {
         val backStack by navController.currentBackStack.collectAsState()
-        return backStack.count { it.destination !is NavGraph } > 1
+        return backStack.hasPoppableEntry()
     }
 
+    /**
+     * Non-composable twin of [rememberCanPop] for the iOS host: its own back check is mount-based
+     * and so answers `true` even on the mini-app root, where a swipe must dismiss rather than pop.
+     * Reads the StateFlow value directly — correct here precisely because nothing recomposes on it.
+     */
+    fun canPop(): Boolean = navController.currentBackStack.value.hasPoppableEntry()
+
     fun pop(count: Int = 1, callBack: (() -> Unit)? = null) {
         scope.launch {
             repeat(count) {
@@ -188,6 +196,10 @@ class Navigator(
     }
 }
 
+// The NavGraph itself sits in the back stack as an entry; only real destinations can be popped.
+private fun List<NavBackStackEntry>.hasPoppableEntry(): Boolean =
+    count { it.destination !is NavGraph } > 1
+
 val LocalNavigator = staticCompositionLocalOf<Navigator> {
     error("No NavigationStack provided")
 }

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/StackScreen.kt

@@ -93,6 +93,7 @@ internal fun StackScreen(
     id: Int = -1,
     name: String = "",
     bottomTabIndex: Int = -1,
+    isDialogRoute: Boolean = false,
     onBackHandler: (() -> Unit)? = null,
 ) {
     val navigator = LocalNavigator.current
@@ -176,8 +177,12 @@ internal fun StackScreen(
     // Port of RN's `hasCustomBackHandling`: this handler is registered inside the NavHost
     // destination, so while it is enabled it beats NavHost's own predictive-back handler and
     // swallows the swipe. Enable it only when a plain pop is the wrong answer.
+    //
+    // A presented route is one of those cases: NavHost arms predictive back on back-stack size
+    // alone, so a horizontal edge drag over a dialog would seek its *vertical* slide.
     val hasCustomBackHandling = !SwipeBackConfig.enabled ||
             isBottomTabChild ||
+            isDialogRoute ||
             options.onBackHandler != null ||
             options.headerBackProps.preventBack != null ||
             OverplayComponentRegistry.isOverplayShowing() ||

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/StackTransition.kt

@@ -46,8 +46,9 @@ private val EDGE_SHADOW_WIDTH = 8.dp
 
 /**
  * Kill switch for the swipe-back gesture. Set to `false` to make kit back handling always win,
- * which disables Android's predictive back drag, without a kit release. It has no effect on iOS —
- * the host owns the edge gesture there. Screen transitions stay on the parallax curve either way.
+ * which disables the predictive-back drag on both platforms — on iOS that means the host-driven
+ * seek stops following the finger, though the host's own gesture still fires a plain back. Screen
+ * transitions stay on the parallax curve either way.
  */
 object SwipeBackConfig {
     // Snapshot-backed so a host toggle takes effect on the next frame instead of waiting for an

package/compose/src/iosMain/kotlin/vn/momo/kits/navigation/HostBackGesture.ios.kt

@@ -0,0 +1,118 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.remember
+import androidx.navigationevent.NavigationEvent
+import androidx.navigationevent.NavigationEventDispatcher
+import androidx.navigationevent.NavigationEventInput
+import kotlinx.cinterop.ExperimentalForeignApi
+import platform.Foundation.NSThread
+import platform.darwin.dispatch_async
+import platform.darwin.dispatch_get_main_queue
+
+/**
+ * Kit end of the host's edge-pan recogniser.
+ *
+ * iOS keeps exactly one back-gesture recogniser and it belongs to the host app — the kit never
+ * installs its own, so the `.failed -> completed` conflict between two competing recognisers is
+ * unreachable by construction. The host replays its drag here; the events are fed into the
+ * `NavigationEventDispatcher` that [NavigationContainer] provides, which drives NavHost's
+ * `PredictiveBackHandler` and therefore `SeekableTransitionState.seekTo`. Parallax, scrim and edge
+ * shadow are children of that same transition, so they follow the finger for free.
+ *
+ * Only primitives cross the Swift boundary: `androidx.navigationevent` is a private transitive
+ * dependency and is absent from the generated framework header.
+ *
+ * Call every method from the main thread; anything else is re-posted to the main queue.
+ */
+object HostBackGestureBridge {
+    private val attachedInputs = mutableListOf<HostNavigationEventInput>()
+    private var gestureInput: HostNavigationEventInput? = null
+
+    /**
+     * Whether the top-most mounted container has an enabled back handler, i.e. the authoritative
+     * answer to "will Compose consume this back?". `false` means no container is mounted, or the
+     * mounted one deliberately opts out (kill switch, overlay showing, custom back handler), and
+     * the host should fall back to its own navigation.
+     */
+    val hasEnabledHandlers: Boolean
+        get() = attachedInputs.lastOrNull()?.hasEnabledHandlers == true
+
+    /** Begins a drag. Pairs with exactly one [completed] or [cancelled]. */
+    fun started() = onMain {
+        val input = attachedInputs.lastOrNull() ?: return@onMain
+        gestureInput = input
+        input.backStarted()
+    }
+
+    /** Drag progress in `0f..1f` — the fraction of the screen width travelled. */
+    fun progressed(progress: Float) = onMain {
+        gestureInput?.backProgressed(progress.coerceIn(0f, 1f))
+    }
+
+    /** Released past the commit threshold: the screen pops. */
+    fun completed() = onMain {
+        gestureInput?.backCompleted()
+        gestureInput = null
+    }
+
+    /** Released below the commit threshold: the screen springs back. */
+    fun cancelled() = onMain {
+        gestureInput?.backCancelled()
+        gestureInput = null
+    }
+
+    internal fun attach(input: HostNavigationEventInput) {
+        attachedInputs += input
+    }
+
+    internal fun detach(input: HostNavigationEventInput) {
+        attachedInputs -= input
+        // A container unmounted mid-drag must not hand its pending terminal event to whichever
+        // container is on top now: NavigationEventInput fabricates a non-predictive start for a
+        // completed/cancelled it never saw begin, which would pop a screen out of nowhere.
+        if (gestureInput === input) gestureInput = null
+    }
+}
+
+/** Wires one [NavigationContainer]'s dispatcher to [HostBackGestureBridge] while it is composed. */
+@Composable
+internal fun AttachHostBackGesture(dispatcher: NavigationEventDispatcher) {
+    val input = remember(dispatcher) { HostNavigationEventInput() }
+
+    DisposableEffect(dispatcher, input) {
+        dispatcher.addInput(input)
+        HostBackGestureBridge.attach(input)
+        onDispose {
+            HostBackGestureBridge.detach(input)
+            dispatcher.removeInput(input)
+        }
+    }
+}
+
+internal class HostNavigationEventInput : NavigationEventInput() {
+    var hasEnabledHandlers: Boolean = false
+        private set
+
+    override fun onHasEnabledHandlersChanged(hasEnabledHandlers: Boolean) {
+        this.hasEnabledHandlers = hasEnabledHandlers
+    }
+
+    // Touch coordinates are not forwarded — the stack transition is seeked by progress alone, and
+    // leaving them out keeps the bridge's Swift-facing signatures primitive.
+    fun backStarted() = dispatchOnBackStarted(NavigationEvent(swipeEdge = NavigationEvent.EDGE_LEFT))
+
+    fun backProgressed(progress: Float) = dispatchOnBackProgressed(
+        NavigationEvent(swipeEdge = NavigationEvent.EDGE_LEFT, progress = progress)
+    )
+
+    fun backCancelled() = dispatchOnBackCancelled()
+
+    fun backCompleted() = dispatchOnBackCompleted()
+}
+
+@OptIn(ExperimentalForeignApi::class)
+private fun onMain(block: () -> Unit) {
+    if (NSThread.isMainThread()) block() else dispatch_async(dispatch_get_main_queue()) { block() }
+}

package/compose/src/iosMain/kotlin/vn/momo/kits/platform/Platform.ios.kt

@@ -17,6 +17,7 @@ import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.InternalComposeUiApi
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.backhandler.LocalCompatNavigationEventDispatcherOwner
+import androidx.compose.ui.backhandler.BackHandler as ComposeBackHandler
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.NativePaint
 import androidx.compose.ui.graphics.toArgb
@@ -38,6 +39,7 @@ import platform.Foundation.NSBundle
 import platform.UIKit.UIColor
 import platform.UIKit.UIDevice
 import platform.UIKit.UIScreen
+import vn.momo.kits.navigation.AttachHostBackGesture
 
 actual fun getPlatformName(): String = "iOS"
 
@@ -60,21 +62,32 @@ actual fun getStatusBarHeight(): Dp {
     return WindowInsets.systemBars.asPaddingValues().calculateTopPadding()
 }
 
+// An enabled kit BackHandler is registered inside the NavHost destination, so it out-ranks
+// NavHost's own predictive-back handler and swallows the gesture — that is how a screen opts out
+// of swipe-back (the port of RN's `hasCustomBackHandling`).
+@Suppress("DEPRECATION")
+@OptIn(ExperimentalComposeUiApi::class)
 @Composable
 actual fun BackHandler(enabled: Boolean, onBack: () -> Unit) {
+    ComposeBackHandler(enabled = enabled, onBack = onBack)
 }
 
 @OptIn(InternalComposeUiApi::class)
 @Composable
 actual fun ProvideNavigationEventDispatcherOwner(content: @Composable () -> Unit) {
+    // Detached on purpose: passing the scene's owner through would arm Compose's own
+    // UIKitBackGestureRecognizer alongside the host's, and UIKit settles that conflict by driving
+    // one to .failed, which UIKitNavigationEventInput turns into a fabricated completed back.
+    // Enabled on purpose: every NavigationEventDispatcher.dispatchOn* early-returns while
+    // isEnabled is false, which would mute the host-driven seek as well.
     val navigationEventDispatcherOwner = remember {
         object : NavigationEventDispatcherOwner {
-            override val navigationEventDispatcher = NavigationEventDispatcher().apply {
-                isEnabled = false
-            }
+            override val navigationEventDispatcher = NavigationEventDispatcher()
         }
     }
 
+    AttachHostBackGesture(navigationEventDispatcherOwner.navigationEventDispatcher)
+
     CompositionLocalProvider(
         LocalCompatNavigationEventDispatcherOwner provides navigationEventDispatcherOwner,
         content = content

package/gradle.properties

@@ -18,7 +18,7 @@ kotlin.apple.xcodeCompatibility.nowarn=true
 name="ComposeKits"
 group=vn.momo.kits
 artifact.id=kits
-version=0.164.1-beta.6
+version=0.164.1-beta.7
 
 repo=GitLab
 url=https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven

package/ios/native-kits.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'MoMoUIKits'
-  s.version          = '0.164.1-beta.6'
+  s.version          = '0.164.1-beta.7'
   s.summary          = 'MoMoUIKits for iOS'
   s.homepage         = 'https://momo.vn'
   s.license          = { :type => 'MIT' }

package/ios-demo/MoMoUIKitsDemo.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'MoMoUIKitsDemo'
-  s.version          = '0.164.1-beta.6'
+  s.version          = '0.164.1-beta.7'
   s.summary          = 'Demo browser for MoMoUIKits SwiftUI components'
   s.homepage         = 'https://momo.vn'
   s.license          = { :type => 'MIT' }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.164.1-beta.6-debug",
+  "version": "0.164.1-beta.7-debug",
   "private": false,
   "dependeNavigationncies": {},
   "devDependencies": {},