@momo-kits/native-kits 0.167.1-duo.18-debug → 0.167.1-duo.19

package/ios/Navigation/Navigator.swift

@@ -99,36 +99,31 @@ public struct OverplayItem: Identifiable {
     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
+    /// The screen it was shown over (Compose's overplay root id): it renders inside that screen,
+    /// so a later push slides over it instead of re-mounting it on the new top.
+    public internal(set) var screenId: Int? = nil
+}
+
+// MARK: - Stack
+
+/// One back-stack entry, root first. A presented screen is an entry like any other (Compose's
+/// `DynamicDialogRoute` in the same NavHost): it rises instead of sliding in, and later pushes
+/// stack on top of it.
+struct StackEntry: Hashable, Identifiable {
+    let id: Int
+    let isDialog: Bool
 }
 
 // MARK: - Navigator
 
-@available(iOS 16.0, *)
 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, 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 private(set) var entries: [StackEntry] = [] {
+        // Disposal hangs off the stack so every entry that leaves it — pop, replace, reset,
+        // dismiss — is released the same way, after its exit transition.
+        didSet { disposeScreens(droppedFrom: oldValue, keeping: entries) }
     }
     @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.
@@ -140,7 +135,7 @@ public final class Navigator: ObservableObject {
     /// actually removed via `finishOverplayDismiss`.
     private var overplayDismissHandler: (() -> Void)?
 
-    @Published public private(set) var rootRoute: DynamicScreenRoute
+    public var rootRoute: DynamicScreenRoute { DynamicScreenRoute(id: entries[0].id) }
     public var composeApi: KitComposeApi?
     /// Host dismiss fallback when there is no `composeApi` (Compose's `maxApi.dismiss`).
     public var maxApi: MaxApi?
@@ -150,6 +145,11 @@ public final class Navigator: ObservableObject {
     /// over the tabs still pops normally.
     var tabBackHandler: (screenId: Int, handler: () -> Void)?
 
+    /// The container's stack view, which plays (and lets the host gesture scrub) the transitions.
+    weak var stackController: StackController?
+    private var isSeekingBack = false
+    private var swipeHaptic = SwipeBackHaptic()
+
     public init(
         initialScreenName: String = "",
         initialContent: @escaping () -> AnyView,
@@ -157,22 +157,18 @@ public final class Navigator: ObservableObject {
         composeApi: KitComposeApi? = nil
     ) {
         self.composeApi = composeApi
-        self.rootRoute = registry.register(
+        let root = registry.register(
             screenName: initialScreenName,
             content: initialContent,
             options: options
         )
+        entries = [StackEntry(id: root.id, isDialog: false)]
     }
 
     // MARK: Stack
 
     public func push<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        let route = registry.register(
-            screenName: options?.screenName ?? "",
-            content: { AnyView(content()) },
-            options: options
-        )
-        appendToActiveStack(route)
+        push(screenName: options?.screenName ?? "", content, options: options)
     }
 
     public func push<V: View>(
@@ -180,63 +176,26 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        let route = registry.register(
-            screenName: screenName,
-            content: { AnyView(content()) },
-            options: options
-        )
-        appendToActiveStack(route)
+        entries.append(register(screenName, content, options, isDialog: false))
     }
 
     public func replace<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        guard removeLastFromActiveStack() else { return }
-        push(content, options: options)
+        replace(screenName: options?.screenName ?? "", content, options: options)
     }
 
+    /// Compose pops the top entry (a presented one included) and navigates, so the replacement
+    /// always lands as a pushed screen; on the root it becomes the new root.
     public func replace<V: View>(
         screenName: String,
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        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
+        let entry = register(screenName, content, options, isDialog: false)
+        entries = Array(entries.dropLast()) + [entry]
     }
 
     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 ?? "",
-            content: { AnyView(content()) },
-            options: options
-        )
-        rootRoute = route
-        disposeScreens([previousRoot])
+        reset(screenName: options?.screenName ?? "", content, options: options)
     }
 
     public func reset<V: View>(
@@ -244,16 +203,21 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        let previousRoot = rootRoute.id
-        clearPresented()
-        path.removeAll()
+        entries = [register(screenName, content, options, isDialog: false)]
+    }
+
+    private func register<V: View>(
+        _ screenName: String,
+        _ content: @escaping () -> V,
+        _ options: NavigationOptions?,
+        isDialog: Bool
+    ) -> StackEntry {
         let route = registry.register(
             screenName: screenName,
             content: { AnyView(content()) },
             options: options
         )
-        rootRoute = route
-        disposeScreens([previousRoot])
+        return StackEntry(id: route.id, isDialog: isDialog)
     }
 
     public func pop(_ count: Int = 1, callback: (() -> Void)? = nil) {
@@ -299,24 +263,15 @@ public final class Navigator: ObservableObject {
         }
     }
 
-    /// Pops the topmost presented screen or stack entry. Returns `false` (and requests
-    /// a host dismiss) when there is nothing left to pop.
+    /// Pops the top entry. Returns `false` (and requests a host dismiss) on the root.
     @discardableResult
     private func popScreen() -> Bool {
-        if presented != nil {
-            if presentedPath.isEmpty {
-                clearPresented()
-            } else {
-                presentedPath.removeLast()
-            }
-            return true
-        } else if !path.isEmpty {
-            path.removeLast()
-            return true
-        } else {
+        guard canPop() else {
             requestHostDismiss()
             return false
         }
+        entries.removeLast()
+        return true
     }
 
     private func requestHostDismiss() {
@@ -327,26 +282,23 @@ public final class Navigator: ObservableObject {
         }
     }
 
-    /// Whether the active stack has a screen to go back to (Compose's `canPop`); at the root a
-    /// back dismisses the mini app instead.
+    /// Whether there is 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
+        entries.count > 1
     }
 
-    /// Empties both stacks; a presented screen stays up on its own root.
+    /// Back to the root of the active flow: the topmost presented screen while one is up,
+    /// the stack root otherwise.
     public func popToRoot() {
-        presentedPath.removeAll()
-        path.removeAll()
+        let root = entries.lastIndex(where: \.isDialog) ?? 0
+        entries = Array(entries[...root])
     }
 
-    /// The entry a back action applies to — mirrors Compose's `currentScreen()`
-    /// (`navController.currentBackStackEntry`): the presented flow sits on top of
-    /// the stack, otherwise it is the last pushed screen, otherwise the root.
+    /// The entry a back action applies to — Compose's `currentScreen()`
+    /// (`navController.currentBackStackEntry`).
     private func currentScreen() -> DynamicScreen? {
-        if let presented {
-            return registry.getScreen(id: presentedPath.last?.id ?? presented.id)
-        }
-        return registry.getScreen(id: path.last?.id ?? rootRoute.id)
+        entries.last.flatMap { registry.getScreen(id: $0.id) }
     }
 
     public func onBackSafe(callback: (() -> Void)? = nil) {
@@ -402,12 +354,7 @@ public final class Navigator: ObservableObject {
     // MARK: Modal-style screen (vertical slide)
 
     public func present<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        let route = registry.register(
-            screenName: options?.screenName ?? "",
-            content: { AnyView(content()) },
-            options: options
-        )
-        presentScreen(route)
+        present(screenName: options?.screenName ?? "", content, options: options)
     }
 
     public func present<V: View>(
@@ -415,59 +362,55 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        let route = registry.register(
-            screenName: screenName,
-            content: { AnyView(content()) },
-            options: options
-        )
-        presentScreen(route)
+        entries.append(register(screenName, content, options, isDialog: true))
     }
 
+    /// Closes the topmost presented screen together with everything pushed over it.
     public func dismiss() {
-        clearPresented()
+        guard let presented = entries.lastIndex(where: \.isDialog) else { return }
+        entries = Array(entries[..<presented])
     }
 
-    /// 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)
+    // MARK: Host back gesture (Compose's HostBackTarget)
+
+    /// Only a plain pop is scrubbed. A back the screen handles itself — tab back, custom
+    /// handler, prevent-back popup, an open overplay — or one closing a presented screen
+    /// waits for the release and goes through `onBackSafe`, as RN turns the gesture off there.
+    private var canSeekBack: Bool {
+        guard canPop(), overplay == nil, let top = entries.last, !top.isDialog else { return false }
+        if let tabBackHandler, tabBackHandler.screenId == -1 || tabBackHandler.screenId == top.id {
+            return false
         }
+        let options = registry.getScreen(id: top.id)?.options
+        return options?.onBackHandler == nil && options?.headerBackProps?.preventBack == nil
     }
 
-    /// 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)
+    func backStarted() {
+        swipeHaptic.reset()
+        isSeekingBack = canSeekBack && stackController?.beginBackSeek() == true
     }
 
-    private func syncCover() {
-        if presented == nil {
-            coverRoute = nil
-        } else if !coverOnScreen || coverRoute != nil {
-            coverRoute = presented
-        }
+    func backProgressed(_ progress: CGFloat) {
+        guard isSeekingBack, let stackController else { return }
+        stackController.seekBack(to: progress)
+        swipeHaptic.update(travelled: progress * stackController.view.bounds.width, maxApi: maxApi)
     }
 
-    /// Reported by the container from the cover's appear / disappear.
-    func coverDidAppear() {
-        coverOnScreen = true
+    func backCompleted() {
+        let wasSeeking = isSeekingBack
+        isSeekingBack = false
+        // A seek cut short by a programmatic change falls back to a regular back.
+        guard wasSeeking, stackController?.finishBackSeek() == true else {
+            onBackSafe()
+            return
+        }
+        entries.removeLast()
     }
 
-    func coverDidDisappear() {
-        coverOnScreen = false
-        syncCover()
+    func backCancelled() {
+        guard isSeekingBack else { return }
+        isSeekingBack = false
+        stackController?.cancelBackSeek()
     }
 
     // MARK: Overplay
@@ -483,7 +426,7 @@ public final class Navigator: ObservableObject {
             content: { AnyView(content()) },
             barrierDismissible: barrierDismissible,
             onDismiss: onDismiss,
-            presentedId: presented?.id
+            screenId: entries.last?.id
         )
     }
 
@@ -508,7 +451,7 @@ public final class Navigator: ObservableObject {
             draggable: draggable,
             useBottomInset: useBottomInset,
             footer: footer,
-            presentedId: presented?.id
+            screenId: entries.last?.id
         )
     }
 
@@ -521,7 +464,7 @@ public final class Navigator: ObservableObject {
             barrierDismissible: false,
             onDismiss: onDismiss,
             snackBar: snackBar,
-            presentedId: presented?.id
+            screenId: entries.last?.id
         )
     }
 
@@ -575,25 +518,19 @@ public final class Navigator: ObservableObject {
     /// after the component has taken itself down.
     private static let overplayDismissDelay: TimeInterval = 0.3
 
-    /// 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]) {
+    private func disposeScreens(droppedFrom previous: [StackEntry], keeping current: [StackEntry]) {
         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], after delay: TimeInterval = Navigator.screenDisposeDelay) {
+    /// view is still on screen while it animates. Liveness is re-checked when the timer
+    /// fires, so an entry back on the stack by then keeps its screen.
+    private func disposeScreens(_ ids: [Int]) {
         guard !ids.isEmpty else { return }
-        DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
+        DispatchQueue.main.asyncAfter(deadline: .now() + Self.screenDisposeDelay) { [weak self] in
             guard let self else { return }
-            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) }
+            let live = Set(self.entries.map(\.id))
             for id in ids where !live.contains(id) {
                 self.registry.unregister(id: id)
             }

package/ios/Navigation/StackScreen.swift

@@ -13,6 +13,9 @@ public struct StackScreen<Content: View>: View {
     // MARK: - Properties
 
     var backgroundColor: Color?
+    // AI-GENERATED START: custom screen background view (Compose backgroundComponent)
+    var background: (() -> AnyView)?
+    // AI-GENERATED END: custom screen background view (Compose backgroundComponent)
     var headerTransparent: Bool = false
     var fullScreenContent: Bool = false
     var tintColor: Color? = Colors.black17
@@ -43,6 +46,9 @@ public struct StackScreen<Content: View>: View {
 
     public init(
         backgroundColor: Color? = nil,
+        // AI-GENERATED START: custom screen background view (Compose backgroundComponent)
+        background: (() -> AnyView)? = nil,
+        // AI-GENERATED END: custom screen background view (Compose backgroundComponent)
         headerTransparent: Bool = false,
         fullScreenContent: Bool = false,
         tintColor: Color = Colors.black17,
@@ -72,6 +78,9 @@ public struct StackScreen<Content: View>: View {
         @ViewBuilder content: @escaping () -> Content
     ) {
         self.backgroundColor = backgroundColor
+        // AI-GENERATED START: custom screen background view (Compose backgroundComponent)
+        self.background = background
+        // AI-GENERATED END: custom screen background view (Compose backgroundComponent)
         self.headerTransparent = headerTransparent
         self.fullScreenContent = fullScreenContent
         self.tintColor = tintColor
@@ -238,8 +247,16 @@ public struct StackScreen<Content: View>: View {
     public var body: some View {
         GeometryReader { _ in
             ZStack(alignment: .top) {
-                (backgroundColor ?? theme.colors.background.default)
-                    .edgesIgnoringSafeArea(.all)
+                // AI-GENERATED START: custom screen background view (Compose backgroundComponent)
+                Group {
+                    if let background {
+                        background()
+                    } else {
+                        backgroundColor ?? theme.colors.background.default
+                    }
+                }
+                .edgesIgnoringSafeArea(.all)
+                // AI-GENERATED END: custom screen background view (Compose backgroundComponent)
 
                 VStack(spacing: 0) {
                     ZStack(alignment: fabProps?.position == .center ? .bottom : .bottomTrailing) {