@momo-kits/native-kits 0.163.1-sp.5-debug → 0.163.1-sp.6-debug

package/.claude/settings.local.json

@@ -128,7 +128,18 @@
       "Bash(xcodebuild -workspace iosApp.xcworkspace -scheme iosApp -sdk iphonesimulator -destination 'generic/platform=iOS Simulator' -configuration Debug build)",
       "Bash(xcodebuild -workspace iosApp.xcworkspace -scheme iosApp -sdk iphonesimulator -destination 'platform=iOS Simulator,id=E6A899C0-098E-473A-95B8-A2BBD2D42A92' -configuration Debug build)",
       "Bash(./gradlew :sample:shared:compileCommonMainKotlinMetadata -q)",
-      "Bash(echo \"gradle=$?\")"
+      "Bash(echo \"gradle=$?\")",
+      "Bash(xcodebuild -workspace iosApp.xcworkspace -scheme iosApp -sdk iphonesimulator -destination 'id=0228A4B2-57E0-4E56-BFAD-DB9E95044AD9' -derivedDataPath build/dd build)",
+      "Bash(osascript *)",
+      "Bash(screencapture -x -R253,53,452,950 win.png)",
+      "Bash(sips -g pixelWidth -g pixelHeight win.png)",
+      "Bash(screencapture -x -R\"253,53,452,950\" win.png)",
+      "Bash(screencapture -x full.png)",
+      "Bash(sips -g pixelWidth -g pixelHeight full.png)",
+      "Bash(sips -c 1900 904 --cropOffset 106 506 full.png --out crop.png)",
+      "Bash(swiftc -O mouse.swift -o mouse)",
+      "Bash(./mouse click *)",
+      "Bash(./mouse drag *)"
     ]
   }
 }

package/compose/build.gradle.kts

@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.163.1-sp.5-debug"
+        version = "0.163.1-sp.6-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.163.1-sp.5-debug'
+    spec.version                  = '0.163.1-sp.6-debug'
     spec.homepage                 = 'https://momo.vn'
     spec.source                   = { :http=> ''}
     spec.authors                  = ''

package/gradle.properties

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

package/ios/Application/Navigation/NavigationContainer.swift

@@ -109,6 +109,9 @@ public struct NavigationContainer<Initial: View>: View {
         if let screen = navigator.registry.getScreen(id: route.id) {
             ScreenHost(screen: screen, navigator: navigator)
                 .navigationBarBackButtonHidden(true)
+                // Hiding the back button is what kills the edge swipe; this puts it back
+                // and sends it through `onBackSafe`, like Compose's BackHandler.
+                .momoSwipeBack(navigator)
         } else {
             EmptyView()
         }

package/ios/Application/Navigation/Navigator.swift

@@ -89,7 +89,11 @@ public struct OverplayItem: Identifiable {
 
 @available(iOS 16.0, *)
 public final class Navigator: ObservableObject {
-    @Published public var path: [DynamicScreenRoute] = []
+    @Published public var path: [DynamicScreenRoute] = [] {
+        // The edge-swipe pop is driven by UIKit and lands straight on the binding,
+        // never on `pop`, so screen disposal hangs off the path itself.
+        didSet { disposeScreens(droppedFrom: oldValue) }
+    }
     @Published public var presented: DynamicDialogRoute?
     @Published public var overplay: OverplayItem?
 
@@ -147,8 +151,7 @@ public final class Navigator: ObservableObject {
 
     public func replace<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
         guard !path.isEmpty else { return }
-        let removed = path.removeLast()
-        registry.unregister(id: removed.id)
+        path.removeLast()
         push(content, options: options)
     }
 
@@ -158,14 +161,12 @@ public final class Navigator: ObservableObject {
         options: NavigationOptions? = nil
     ) {
         guard !path.isEmpty else { return }
-        let removed = path.removeLast()
-        registry.unregister(id: removed.id)
+        path.removeLast()
         push(screenName: screenName, content, options: options)
     }
 
     public func reset<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        for route in path { registry.unregister(id: route.id) }
-        registry.unregister(id: rootRoute.id)
+        let previousRoot = rootRoute.id
         path.removeAll()
         let route = registry.register(
             screenName: options?.screenName ?? "",
@@ -173,6 +174,7 @@ public final class Navigator: ObservableObject {
             options: options
         )
         rootRoute = route
+        disposeScreens([previousRoot])
     }
 
     public func reset<V: View>(
@@ -180,8 +182,7 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        for route in path { registry.unregister(id: route.id) }
-        registry.unregister(id: rootRoute.id)
+        let previousRoot = rootRoute.id
         path.removeAll()
         let route = registry.register(
             screenName: screenName,
@@ -189,6 +190,7 @@ public final class Navigator: ObservableObject {
             options: options
         )
         rootRoute = route
+        disposeScreens([previousRoot])
     }
 
     public func pop(_ count: Int = 1, callback: (() -> Void)? = nil) {
@@ -218,11 +220,10 @@ public final class Navigator: ObservableObject {
         if presented != nil {
             let dismissedId = presented?.id
             presented = nil
-            if let id = dismissedId { registry.unregister(id: id) }
+            if let id = dismissedId { disposeScreens([id]) }
             return true
         } else if !path.isEmpty {
-            let removed = path.removeLast()
-            registry.unregister(id: removed.id)
+            path.removeLast()
             return true
         } else {
             composeApi?.requestCallback(funcName: "dismiss", params: nil, onResponse: nil)
@@ -231,12 +232,54 @@ public final class Navigator: ObservableObject {
     }
 
     public func popToRoot() {
-        for route in path { registry.unregister(id: route.id) }
         path.removeAll()
     }
 
+    /// The entry a back action applies to — mirrors Compose's `currentScreen()`
+    /// (`navController.currentBackStackEntry`): a presented screen sits on top of
+    /// the stack, otherwise it is the last pushed screen, otherwise the root.
+    private func currentScreen() -> DynamicScreen? {
+        registry.getScreen(id: presented?.id ?? path.last?.id ?? rootRoute.id)
+    }
+
+    /// Whether the current screen takes back navigation over itself, i.e. back must
+    /// not pop it (mirrors the two early returns in Compose's `onBackSafe`).
+    private var currentScreenHandlesBack: Bool {
+        let options = currentScreen()?.options
+        return options?.onBackHandler != nil || options?.headerBackProps?.preventBack != nil
+    }
+
+    /// Asked by the edge-swipe delegate before UIKit starts an interactive pop, so the
+    /// gesture ends up where Compose's `BackHandler(true) { onBackSafe() }` does. Returning
+    /// `false` means the gesture is swallowed — the side effect it stands for (closing an
+    /// overplay, running `onBackHandler`, raising the prevent-back popup) has been run here.
+    /// Returning `true` hands the pop to UIKit so the swipe stays interactive; `path.didSet`
+    /// then disposes the screen exactly as `pop` would.
+    func shouldBeginInteractivePop() -> Bool {
+        // A presented screen covers the stack; its own chrome owns the dismissal.
+        if presented != nil { return false }
+
+        if overplay?.type == .snackBar {
+            // Same as `pop`: a snackbar doesn't block back, it is cleared on the way out.
+            overplayDismissHandler = nil
+            overplay = nil
+        } else if overplay != nil {
+            // Compose: the modal/bottom-sheet BackHandler wins and plays its exit animation.
+            hideOverplay()
+            return false
+        }
+
+        if currentScreenHandlesBack {
+            onBackSafe()
+            return false
+        }
+
+        // Nothing of ours left to pop: leave the swipe to whatever stack hosts the kit.
+        return !path.isEmpty
+    }
+
     public func onBackSafe(callback: (() -> Void)? = nil) {
-        let latest = registry.latest()
+        let latest = currentScreen()
         if let onBack = latest?.options?.onBackHandler {
             onBack()
             return
@@ -382,4 +425,32 @@ public final class Navigator: ObservableObject {
     public func hideSnackBar() {
         if overplay?.type == .snackBar { hideOverplay() }
     }
+
+    // MARK: Screen disposal
+
+    /// Matches the `delay(300)` Compose waits in `dismissScreen` before unregistering,
+    /// with headroom for the slower interactive swipe.
+    private static let screenDisposeDelay: TimeInterval = 0.35
+
+    private func disposeScreens(droppedFrom previous: [DynamicScreenRoute]) {
+        let live = Set(path.map(\.id))
+        disposeScreens(previous.map(\.id).filter { !live.contains($0) })
+    }
+
+    /// Screens are released only once the pop transition has played out: the outgoing
+    /// view is still on screen while it animates and the registry is what renders it —
+    /// dropping it right away blanks the screen mid-swipe. Liveness is re-checked when
+    /// the timer fires, so a cancelled swipe (path restored) keeps its screen.
+    private func disposeScreens(_ ids: [Int]) {
+        guard !ids.isEmpty else { return }
+        DispatchQueue.main.asyncAfter(deadline: .now() + Self.screenDisposeDelay) { [weak self] in
+            guard let self else { return }
+            var live = Set(self.path.map(\.id))
+            live.insert(self.rootRoute.id)
+            if let presented = self.presented { live.insert(presented.id) }
+            for id in ids where !live.contains(id) {
+                self.registry.unregister(id: id)
+            }
+        }
+    }
 }

package/ios/Application/Navigation/SwipeBackGesture.swift

@@ -0,0 +1,116 @@
+//
+//  SwipeBackGesture.swift
+//  MoMoUIKits
+//
+//  Makes the iOS edge swipe behave like Compose's `BackHandler(true) { navigator.onBackSafe() }`.
+//  Every kit screen draws its own header and therefore hides the system back button, which is
+//  exactly what makes SwiftUI turn `interactivePopGestureRecognizer` off — so the gesture is
+//  re-enabled here and its start is arbitrated by the Navigator.
+//
+
+import SwiftUI
+import UIKit
+
+@available(iOS 16.0, *)
+extension View {
+    /// Re-enables the interactive pop gesture for a `NavigationStack` destination and
+    /// routes it through `navigator`. Apply it to every destination: SwiftUI reconfigures
+    /// the recognizer as screens come and go, so the install has to be repeated.
+    func momoSwipeBack(_ navigator: Navigator) -> some View {
+        background(SwipeBackInstaller(navigator: navigator).allowsHitTesting(false))
+    }
+}
+
+@available(iOS 16.0, *)
+private struct SwipeBackInstaller: UIViewRepresentable {
+    let navigator: Navigator
+
+    func makeUIView(context: Context) -> SwipeBackProbeView {
+        let view = SwipeBackProbeView()
+        view.navigator = navigator
+        return view
+    }
+
+    func updateUIView(_ uiView: SwipeBackProbeView, context: Context) {
+        uiView.navigator = navigator
+        uiView.install()
+    }
+}
+
+/// Zero-sized view whose only job is to reach the `UINavigationController` backing the
+/// enclosing `NavigationStack` — SwiftUI exposes no other handle on it.
+@available(iOS 16.0, *)
+private final class SwipeBackProbeView: UIView {
+    weak var navigator: Navigator?
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        install()
+        // SwiftUI applies the destination's bar configuration around the same runloop
+        // turn, and it is the thing that disables the recognizer — so claim it again
+        // once that has settled.
+        DispatchQueue.main.async { [weak self] in self?.install() }
+    }
+
+    func install() {
+        guard window != nil, let navigator, let controller = navigationController() else { return }
+        SwipeBackGestureDelegate.shared.install(on: controller, navigator: navigator)
+    }
+
+    private func navigationController() -> UINavigationController? {
+        var responder: UIResponder? = self
+        while let current = responder {
+            if let nav = current as? UINavigationController { return nav }
+            if let controller = current as? UIViewController, let nav = controller.navigationController { return nav }
+            responder = current.next
+        }
+        return nil
+    }
+}
+
+/// Shared `interactivePopGestureRecognizer` delegate. One instance serves every kit stack
+/// in the process (a bottom-tab surface or a host screen can have its own), keyed by the
+/// navigation controller the recognizer belongs to. Being long-lived matters: the delegate
+/// is held weakly by UIKit, and a nil delegate lets the gesture fire on a single-screen
+/// stack, which corrupts it.
+@available(iOS 16.0, *)
+private final class SwipeBackGestureDelegate: NSObject, UIGestureRecognizerDelegate {
+    static let shared = SwipeBackGestureDelegate()
+
+    private struct Entry {
+        weak var controller: UINavigationController?
+        weak var navigator: Navigator?
+    }
+
+    private var entries: [ObjectIdentifier: Entry] = [:]
+
+    func install(on controller: UINavigationController, navigator: Navigator) {
+        entries = entries.filter { $0.value.controller != nil && $0.value.navigator != nil }
+        entries[ObjectIdentifier(controller)] = Entry(controller: controller, navigator: navigator)
+
+        guard let gesture = controller.interactivePopGestureRecognizer else { return }
+        gesture.delegate = self
+        gesture.isEnabled = true
+    }
+
+    func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
+        guard let entry = entry(for: gestureRecognizer), let controller = entry.controller else { return false }
+        // Guards the classic UIKit hang: popping the only view controller on the stack.
+        guard controller.viewControllers.count > 1 else { return false }
+        guard let navigator = entry.navigator else { return true }
+        return navigator.shouldBeginInteractivePop()
+    }
+
+    /// The edge swipe stays exclusive — letting it run alongside a horizontal scroll or a
+    /// swipeable cell would pop the screen while the user is dragging inside it.
+    func gestureRecognizer(
+        _ gestureRecognizer: UIGestureRecognizer,
+        shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer
+    ) -> Bool {
+        false
+    }
+
+    private func entry(for gestureRecognizer: UIGestureRecognizer) -> Entry? {
+        entries.values.first { $0.controller?.interactivePopGestureRecognizer === gestureRecognizer }
+    }
+}

package/ios/native-kits.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'MoMoUIKits'
-  s.version          = '0.163.1-sp.5'
+  s.version          = '0.163.1-sp.6'
   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.163.1-sp.5'
+  s.version          = '0.163.1-sp.6'
   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.163.1-sp.5-debug",
+  "version": "0.163.1-sp.6-debug",
   "private": false,
   "dependencies": {},
   "devDependencies": {},