@momo-kits/native-kits 0.167.1-duo.1-debug → 0.167.1-duo.10-debug

package/ios/{Application/Navigation → Navigation}/Navigator.swift

@@ -2,9 +2,9 @@
 //  Navigator.swift
 //  MoMoUIKits
 //
-//  SwiftUI mirror of Compose's Navigator + DynamicScreenRegistry.
-//  Screens are registered by Int id; the NavigationStack path stores routes
-//  by id and looks up content from the registry on render.
+//  SwiftUI mirror of Compose's `navigation/Navigator.kt`: Navigator, DynamicScreenRegistry and
+//  the overplay model. Screens are registered by Int id; the stack paths store routes by id and
+//  content is looked up from the registry on render.
 //
 
 import SwiftUI
@@ -31,6 +31,7 @@ public struct DynamicScreen {
 
 public final class DynamicScreenRegistry {
     private var screens: [Int: DynamicScreen] = [:]
+    private var navigations: [Int: WeakNavigation] = [:]
     private var idCounter: Int = 1
 
     public init() {}
@@ -49,12 +50,20 @@ public final class DynamicScreenRegistry {
 
     public func unregister(id: Int) {
         screens.removeValue(forKey: id)
+        navigations.removeValue(forKey: id)
     }
 
     public func unregisterAll() {
         screens.removeAll()
+        navigations.removeAll()
     }
 
+    func bind(_ navigation: Navigation) {
+        navigations[navigation.id] = WeakNavigation(value: navigation)
+    }
+
+    func navigation(id: Int) -> Navigation? { navigations[id]?.value }
+
     public func getScreen(id: Int) -> DynamicScreen? { screens[id] }
 
     public func latest() -> DynamicScreen? {
@@ -66,6 +75,10 @@ public final class DynamicScreenRegistry {
     }
 }
 
+private struct WeakNavigation {
+    weak var value: Navigation?
+}
+
 // MARK: - Overplay
 
 public enum OverplayType {
@@ -81,8 +94,14 @@ public struct OverplayItem: Identifiable {
     // Bottom-sheet params (mirrors Compose's OverplayComponentParams.BottomSheet).
     public var isSurface: Bool = false
     public var header: BottomSheetHeader? = nil
+    public var draggable: Bool = true
+    public var useBottomInset: Bool = true
+    public var footer: (() -> AnyView)? = nil
     // Snack-bar payload (mirrors Compose's SnackBar value).
     public var snackBar: SnackBar? = nil
+    /// The presented screen it was shown over, nil for the main stack. Like Compose's overplay
+    /// root id, it pins the item to that context instead of following later presents/dismisses.
+    public internal(set) var presentedId: Int? = nil
 }
 
 // MARK: - Navigator
@@ -92,11 +111,24 @@ public final class Navigator: ObservableObject {
     @Published public var path: [DynamicScreenRoute] = [] {
         // Disposal hangs off the path so every route that leaves the stack — pop,
         // replace, reset — is released the same way, after its exit transition.
-        didSet { disposeScreens(droppedFrom: oldValue) }
+        didSet { disposeScreens(droppedFrom: oldValue, keeping: path) }
+    }
+    @Published public var presented: DynamicDialogRoute? {
+        didSet { syncCover() }
+    }
+    /// Screens pushed while a screen is presented. Compose's dialog route is a plain back-stack
+    /// entry, so later pushes stack on top of it; the cover hosts its own stack for the same result.
+    @Published public var presentedPath: [DynamicScreenRoute] = [] {
+        didSet { disposeScreens(droppedFrom: oldValue, keeping: presentedPath) }
     }
-    @Published public var presented: DynamicDialogRoute?
     @Published public var overplay: OverplayItem?
 
+    /// What the cover shows. It trails `presented` while the previous cover is still sliding out:
+    /// SwiftUI can drop a presentation issued during another one's dismissal.
+    @Published private(set) var coverRoute: DynamicDialogRoute?
+    private var coverOnScreen = false
+    private var presentationGeneration = 0
+
     /// Owned per-Navigator (mirrors Compose's `remember { DynamicScreenRegistry() }` +
     /// disposal): screens registered by this navigator are released via ARC when the
     /// navigator itself deallocates, instead of accumulating in a process-wide singleton.
@@ -108,8 +140,15 @@ public final class Navigator: ObservableObject {
     /// actually removed via `finishOverplayDismiss`.
     private var overplayDismissHandler: (() -> Void)?
 
-    public private(set) var rootRoute: DynamicScreenRoute
+    @Published public private(set) var rootRoute: DynamicScreenRoute
     public var composeApi: KitComposeApi?
+    /// Host dismiss fallback when there is no `composeApi` (Compose's `maxApi.dismiss`).
+    public var maxApi: MaxApi?
+
+    /// Set by a bottom tab off its first tab: back on the screen hosting the tabs returns to the
+    /// first tab (Compose `tabBackHandler`). Keyed by that screen, so a screen pushed or presented
+    /// over the tabs still pops normally.
+    var tabBackHandler: (screenId: Int, handler: () -> Void)?
 
     public init(
         initialScreenName: String = "",
@@ -133,7 +172,7 @@ public final class Navigator: ObservableObject {
             content: { AnyView(content()) },
             options: options
         )
-        path.append(route)
+        appendToActiveStack(route)
     }
 
     public func push<V: View>(
@@ -146,12 +185,11 @@ public final class Navigator: ObservableObject {
             content: { AnyView(content()) },
             options: options
         )
-        path.append(route)
+        appendToActiveStack(route)
     }
 
     public func replace<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        guard !path.isEmpty else { return }
-        path.removeLast()
+        guard removeLastFromActiveStack() else { return }
         push(content, options: options)
     }
 
@@ -160,13 +198,37 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        guard !path.isEmpty else { return }
-        path.removeLast()
+        guard removeLastFromActiveStack() else { return }
         push(screenName: screenName, content, options: options)
     }
 
+    /// The presented flow while one is up, the main stack otherwise.
+    private func appendToActiveStack(_ route: DynamicScreenRoute) {
+        if presented != nil {
+            presentedPath.append(route)
+        } else {
+            path.append(route)
+        }
+    }
+
+    private func removeLastFromActiveStack() -> Bool {
+        if presented != nil {
+            // Compose pops the dialog route itself, so the replacement lands on the main stack.
+            if presentedPath.isEmpty {
+                clearPresented()
+            } else {
+                presentedPath.removeLast()
+            }
+        } else {
+            guard !path.isEmpty else { return false }
+            path.removeLast()
+        }
+        return true
+    }
+
     public func reset<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
         let previousRoot = rootRoute.id
+        clearPresented()
         path.removeAll()
         let route = registry.register(
             screenName: options?.screenName ?? "",
@@ -183,6 +245,7 @@ public final class Navigator: ObservableObject {
         options: NavigationOptions? = nil
     ) {
         let previousRoot = rootRoute.id
+        clearPresented()
         path.removeAll()
         let route = registry.register(
             screenName: screenName,
@@ -241,38 +304,64 @@ public final class Navigator: ObservableObject {
     @discardableResult
     private func popScreen() -> Bool {
         if presented != nil {
-            let dismissedId = presented?.id
-            presented = nil
-            if let id = dismissedId { disposeScreens([id]) }
+            if presentedPath.isEmpty {
+                clearPresented()
+            } else {
+                presentedPath.removeLast()
+            }
             return true
         } else if !path.isEmpty {
             path.removeLast()
             return true
         } else {
-            composeApi?.requestCallback(funcName: "dismiss", params: nil, onResponse: nil)
+            requestHostDismiss()
             return false
         }
     }
 
+    private func requestHostDismiss() {
+        if let composeApi {
+            composeApi.requestCallback(funcName: "dismiss", params: nil, onResponse: nil)
+        } else {
+            maxApi?.dismiss(completion: nil)
+        }
+    }
+
+    /// Whether the active stack has a screen to go back to (Compose's `canPop`); at the root a
+    /// back dismisses the mini app instead.
+    public func canPop() -> Bool {
+        presented != nil || !path.isEmpty
+    }
+
+    /// Empties both stacks; a presented screen stays up on its own root.
     public func popToRoot() {
+        presentedPath.removeAll()
         path.removeAll()
     }
 
     /// The entry a back action applies to — mirrors Compose's `currentScreen()`
-    /// (`navController.currentBackStackEntry`): a presented screen sits on top of
+    /// (`navController.currentBackStackEntry`): the presented flow 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)
+        if let presented {
+            return registry.getScreen(id: presentedPath.last?.id ?? presented.id)
+        }
+        return registry.getScreen(id: path.last?.id ?? rootRoute.id)
     }
 
     public func onBackSafe(callback: (() -> Void)? = nil) {
         let latest = currentScreen()
+        if let tabBackHandler, tabBackHandler.screenId == -1 || tabBackHandler.screenId == latest?.id {
+            tabBackHandler.handler()
+            return
+        }
         if let onBack = latest?.options?.onBackHandler {
             onBack()
             return
         }
         if let preventBack = latest?.options?.headerBackProps?.preventBack {
-            showModal {
+            // stored in `overplay`, so a strong self would cycle until the popup closes
+            showModal { [weak self] in
                 PopupNotify(
                     props: PopupNotifyProps(
                         image: preventBack.image,
@@ -281,7 +370,7 @@ public final class Navigator: ObservableObject {
                         error: preventBack.error,
                         primary: PopupAction(
                             title: preventBack.primary?.title ?? "",
-                            onPress: { [weak self] in
+                            onPress: {
                                 preventBack.primary?.onPress?()
                                 // Close the popup, then leave the screen (matches Compose's pop(2)).
                                 self?.pop(2, callback: callback)
@@ -290,14 +379,14 @@ public final class Navigator: ObservableObject {
                         secondary: preventBack.secondary.map { secondary in
                             PopupAction(
                                 title: secondary.title,
-                                onPress: { [weak self] in
+                                onPress: {
                                     secondary.onPress?()
                                     self?.hideOverplay()
                                 }
                             )
                         },
                         buttonDirection: preventBack.buttonDirection,
-                        onIconClose: { [weak self] in
+                        onIconClose: {
                             preventBack.onIconClose?()
                             self?.hideOverplay()
                         },
@@ -318,7 +407,7 @@ public final class Navigator: ObservableObject {
             content: { AnyView(content()) },
             options: options
         )
-        presented = DynamicDialogRoute(id: route.id)
+        presentScreen(route)
     }
 
     public func present<V: View>(
@@ -331,14 +420,54 @@ public final class Navigator: ObservableObject {
             content: { AnyView(content()) },
             options: options
         )
-        presented = DynamicDialogRoute(id: route.id)
+        presentScreen(route)
     }
 
     public func dismiss() {
-        if let id = presented?.id {
-            registry.unregister(id: id)
+        clearPresented()
+    }
+
+    /// One cover per container: presenting from a presented flow stacks onto that flow, the way
+    /// Compose stacks a second dialog route.
+    private func presentScreen(_ route: DynamicScreenRoute) {
+        if presented != nil {
+            presentedPath.append(route)
+        } else {
+            presentationGeneration += 1
+            presentedPath = []
+            presented = DynamicDialogRoute(id: route.id)
         }
+    }
+
+    /// The cover keeps rendering its stack while it slides out, so the flow is torn down only
+    /// once the exit animation is over.
+    private func clearPresented() {
+        guard let id = presented?.id else { return }
         presented = nil
+        let generation = presentationGeneration
+        DispatchQueue.main.asyncAfter(deadline: .now() + Self.presentedDisposeDelay) { [weak self] in
+            guard let self, self.presentationGeneration == generation else { return }
+            self.presentedPath.removeAll()
+        }
+        disposeScreens([id], after: Self.presentedDisposeDelay)
+    }
+
+    private func syncCover() {
+        if presented == nil {
+            coverRoute = nil
+        } else if !coverOnScreen || coverRoute != nil {
+            coverRoute = presented
+        }
+    }
+
+    /// Reported by the container from the cover's appear / disappear.
+    func coverDidAppear() {
+        coverOnScreen = true
+    }
+
+    func coverDidDisappear() {
+        coverOnScreen = false
+        syncCover()
     }
 
     // MARK: Overplay
@@ -353,7 +482,8 @@ public final class Navigator: ObservableObject {
             type: .modal,
             content: { AnyView(content()) },
             barrierDismissible: barrierDismissible,
-            onDismiss: onDismiss
+            onDismiss: onDismiss,
+            presentedId: presented?.id
         )
     }
 
@@ -362,7 +492,10 @@ public final class Navigator: ObservableObject {
         isSurface: Bool = false,
         barrierDismissible: Bool = true,
         header: BottomSheetHeader? = nil,
-        onDismiss: (() -> Void)? = nil
+        onDismiss: (() -> Void)? = nil,
+        draggable: Bool = true,
+        useBottomInset: Bool = true,
+        footer: (() -> AnyView)? = nil
     ) {
         overplayDismissHandler = nil
         overplay = OverplayItem(
@@ -371,7 +504,11 @@ public final class Navigator: ObservableObject {
             barrierDismissible: barrierDismissible,
             onDismiss: onDismiss,
             isSurface: isSurface,
-            header: header
+            header: header,
+            draggable: draggable,
+            useBottomInset: useBottomInset,
+            footer: footer,
+            presentedId: presented?.id
         )
     }
 
@@ -383,7 +520,8 @@ public final class Navigator: ObservableObject {
             content: { AnyView(EmptyView()) },
             barrierDismissible: false,
             onDismiss: onDismiss,
-            snackBar: snackBar
+            snackBar: snackBar,
+            presentedId: presented?.id
         )
     }
 
@@ -419,6 +557,14 @@ public final class Navigator: ObservableObject {
         if overplay?.type == .snackBar { hideOverplay() }
     }
 
+    /// Room the current screen's footer (or navigation bar) takes from the window bottom.
+    func snackBarBottomInset() -> CGFloat {
+        guard let id = currentScreen()?.id, let navigation = registry.navigation(id: id) else {
+            return NavigationFooter.navigationBarInset
+        }
+        return navigation.bottomObstruction
+    }
+
     // MARK: Screen disposal
 
     /// Matches the `delay(300)` Compose waits in `dismissScreen` before unregistering,
@@ -429,20 +575,23 @@ public final class Navigator: ObservableObject {
     /// after the component has taken itself down.
     private static let overplayDismissDelay: TimeInterval = 0.3
 
-    private func disposeScreens(droppedFrom previous: [DynamicScreenRoute]) {
-        let live = Set(path.map(\.id))
-        disposeScreens(previous.map(\.id).filter { !live.contains($0) })
+    /// A full-screen cover slides out slower than a stack pop.
+    private static let presentedDisposeDelay: TimeInterval = 0.6
+
+    private func disposeScreens(droppedFrom previous: [DynamicScreenRoute], keeping current: [DynamicScreenRoute]) {
+        let kept = Set(current.map(\.id))
+        disposeScreens(previous.map(\.id).filter { !kept.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-transition. Liveness is re-checked
     /// when the timer fires, so a route pushed back before then keeps its screen.
-    private func disposeScreens(_ ids: [Int]) {
+    private func disposeScreens(_ ids: [Int], after delay: TimeInterval = Navigator.screenDisposeDelay) {
         guard !ids.isEmpty else { return }
-        DispatchQueue.main.asyncAfter(deadline: .now() + Self.screenDisposeDelay) { [weak self] in
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
             guard let self else { return }
-            var live = Set(self.path.map(\.id))
+            var live = Set(self.path.map(\.id)).union(self.presentedPath.map(\.id))
             live.insert(self.rootRoute.id)
             if let presented = self.presented { live.insert(presented.id) }
             for id in ids where !live.contains(id) {