@momo-kits/native-kits 0.167.1-beta.9-debug → 0.167.1-duo-search.1

package/ios/Application/Navigation/Navigator.swift

@@ -3,8 +3,8 @@
 //  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.
+//  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
@@ -83,6 +83,9 @@ public struct OverplayItem: Identifiable {
     public var header: BottomSheetHeader? = 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 +95,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,7 +124,7 @@ 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?
 
     public init(
@@ -133,7 +149,7 @@ public final class Navigator: ObservableObject {
             content: { AnyView(content()) },
             options: options
         )
-        path.append(route)
+        appendToActiveStack(route)
     }
 
     public func push<V: View>(
@@ -146,12 +162,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 +175,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 +222,7 @@ public final class Navigator: ObservableObject {
         options: NavigationOptions? = nil
     ) {
         let previousRoot = rootRoute.id
+        clearPresented()
         path.removeAll()
         let route = registry.register(
             screenName: screenName,
@@ -241,9 +281,11 @@ 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()
@@ -254,15 +296,20 @@ public final class Navigator: ObservableObject {
         }
     }
 
+    /// 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) {
@@ -318,7 +365,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 +378,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 +440,8 @@ public final class Navigator: ObservableObject {
             type: .modal,
             content: { AnyView(content()) },
             barrierDismissible: barrierDismissible,
-            onDismiss: onDismiss
+            onDismiss: onDismiss,
+            presentedId: presented?.id
         )
     }
 
@@ -371,7 +459,8 @@ public final class Navigator: ObservableObject {
             barrierDismissible: barrierDismissible,
             onDismiss: onDismiss,
             isSurface: isSurface,
-            header: header
+            header: header,
+            presentedId: presented?.id
         )
     }
 
@@ -383,7 +472,8 @@ public final class Navigator: ObservableObject {
             content: { AnyView(EmptyView()) },
             barrierDismissible: false,
             onDismiss: onDismiss,
-            snackBar: snackBar
+            snackBar: snackBar,
+            presentedId: presented?.id
         )
     }
 
@@ -429,20 +519,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) {

package/ios/Application/Navigation/NavigatorManager.swift

@@ -5,18 +5,25 @@ public final class NavigatorManager {
     public static let shared = NavigatorManager()
     private init() {}
 
-    private var navigators: [Navigator] = []
+    // Weak: a container torn down while its cover is up never reports its disappearance.
+    private var navigators: [WeakNavigator] = []
 
     public func push(_ navigator: Navigator) {
-        guard !navigators.contains(where: { $0 === navigator }) else { return }
-        navigators.append(navigator)
+        navigators.removeAll { $0.value == nil }
+        guard !navigators.contains(where: { $0.value === navigator }) else { return }
+        navigators.append(WeakNavigator(value: navigator))
     }
 
     public func remove(_ navigator: Navigator) {
-        navigators.removeAll { $0 === navigator }
+        navigators.removeAll { $0.value == nil || $0.value === navigator }
     }
 
-    public func checkCanPop() -> Bool { !navigators.isEmpty }
+    public func checkCanPop() -> Bool { navigators.contains { $0.value != nil } }
 
-    public func pop() { navigators.last?.onBackSafe() }
+    public func pop() { navigators.last { $0.value != nil }?.value?.onBackSafe() }
+}
+
+@available(iOS 16.0, *)
+private struct WeakNavigator {
+    weak var value: Navigator?
 }

package/ios/Application/Navigation/Overplay/BottomSheet.swift

@@ -45,6 +45,7 @@ struct BottomSheetView<Content: View>: View {
     @EnvironmentObject private var navigator: Navigator
     @Environment(\.appTheme) private var theme
     @Environment(\.applicationEnvironment) private var appEnv
+    @Environment(\.screenLayout) private var layout
 
     /// Vertical translation of the sheet; starts off-screen and animates to 0.
     @State private var sheetOffset: CGFloat = UIScreen.main.bounds.height
@@ -66,7 +67,36 @@ struct BottomSheetView<Content: View>: View {
     /// steady-state (fully open) scrim peaks at 0.6, matching ModalScreen's peak.
     private let maxDynamicAlpha: CGFloat = 0.3
 
-    private var screenHeight: CGFloat { UIScreen.main.bounds.height }
+    // UIScreen stays on the outer display on iPhone Duo, even when unfolded
+    private var screenHeight: CGFloat { isDuo ? layout.height : UIScreen.main.bounds.height }
+
+    private var isDuo: Bool { layout.isDuoDevice }
+    // iPhone Duo inner display: center the sheet instead of spanning the width
+    private var isDuoCentered: Bool { isDuo && layout.width >= 600 }
+
+    /// Keeps the portrait width in landscape, like system sheets.
+    private var duoCenteredWidth: CGFloat {
+        min(
+            min(layout.width, layout.height) - Spacing.L * 2,
+            layout.width - max(layout.insets.leading, layout.insets.trailing, Spacing.L) * 2
+        )
+    }
+
+    /// Landscape side buttons span the full height, so the content is inset; in portrait the
+    /// side status bar only covers the top corner.
+    private var sideInsetLeading: CGFloat {
+        isDuo && !isDuoCentered && layout.width > layout.height ? layout.insets.leading : 0
+    }
+
+    private var sideInsetTrailing: CGFloat {
+        isDuo && !isDuoCentered && layout.width > layout.height ? layout.insets.trailing : 0
+    }
+
+    /// The keyboard filler is part of the sheet, so capping the sheet shrinks the content by it.
+    private var duoMaxHeight: CGFloat? {
+        guard isDuo else { return nil }
+        return layout.height - max(layout.duoTopInset, Spacing.XL)
+    }
     private var bottomInset: CGFloat { safeAreaBottomInset() }
     /// While the keyboard is up, it already covers the home-indicator area, so it
     /// replaces (rather than adds to) the usual bottom-inset filler.
@@ -110,7 +140,7 @@ struct BottomSheetView<Content: View>: View {
         .onReceive(NotificationCenter.default.publisher(for: UIResponder.keyboardWillChangeFrameNotification)) { notification in
             guard let endFrame = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else { return }
             withAnimation(.easeOut(duration: 0.25)) {
-                keyboardHeight = UIScreen.main.bounds.height - endFrame.origin.y
+                keyboardHeight = screenHeight - endFrame.origin.y
             }
         }
         .onAppear {
@@ -138,6 +168,8 @@ struct BottomSheetView<Content: View>: View {
                 headerView
                     .frame(height: 56)
                     .padding(.horizontal, Spacing.M)
+                    .padding(.leading, sideInsetLeading)
+                    .padding(.trailing, sideInsetTrailing)
             }
             .frame(maxWidth: .infinity)
             .frame(height: 72)
@@ -149,12 +181,17 @@ struct BottomSheetView<Content: View>: View {
                 .frame(height: 1)
 
             content()
+                .padding(.leading, sideInsetLeading)
+                .padding(.trailing, sideInsetTrailing)
+                // a tall sheet on iPhone Duo keeps its header and gives the content what is left
+                .layoutPriority(-1)
 
             backgroundColor
                 .frame(height: effectiveBottomInset)
         }
-        .frame(maxWidth: .infinity)
-        .frame(alignment: .bottom)
+        .frame(maxWidth: isDuoCentered ? duoCenteredWidth : .infinity)
+        .frame(maxHeight: duoMaxHeight, alignment: .bottom)
+        .clipped()
         .background(
             GeometryReader { geo in
                 Color.clear.onAppear { sheetHeight = geo.size.height }

package/ios/Application/Navigation/Overplay/ModalScreen.swift

@@ -16,6 +16,7 @@ struct ModalScreen<Content: View>: View {
 
     @EnvironmentObject private var navigator: Navigator
     @Environment(\.applicationEnvironment) private var appEnv
+    @Environment(\.screenLayout) private var layout
 
     @State private var scrimOpacity: CGFloat = 0
     @State private var contentScale: CGFloat = 0.8
@@ -35,7 +36,13 @@ struct ModalScreen<Content: View>: View {
             content()
                 .scaleEffect(contentScale)
                 .opacity(contentOpacity)
+                // iPhone Duo: center below the side status bar and above the home indicator
+                .padding(.top, layout.isDuoDevice ? layout.duoTopInset : 0)
+                .padding(.bottom, layout.isDuoDevice ? layout.insets.bottom : 0)
         }
+        // Full screen like RN's Modal, so asymmetric landscape insets don't shift the content sideways.
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .ignoresSafeArea(.container)
         .onAppear {
             guard !didAppear else { return }
             didAppear = true

package/ios/Application/Navigation/component/DuoScrollGradient.swift

@@ -0,0 +1,54 @@
+//
+//  DuoScrollGradient.swift
+//  MoMoUIKits
+//
+//  Port of RN `DuoScrollGradient` (Components/DuoGlassBackground.tsx): with the iPhone Duo
+//  glass header the content scrolls under the bar, so the header gradient is drawn under it.
+//
+
+import SwiftUI
+
+// extended headers run their gradient this far below the header, as off Duo
+private let extendedGradientExtra: CGFloat = 52
+// scroll distance over which the extended gradient collapses to the header
+private let extendedCollapseDistance: CGFloat = 100
+
+struct DuoScrollGradient: View {
+    let scrollOffset: CGFloat
+    let headerHeight: CGFloat
+    let extended: Bool
+    /// Quick return header: the gradient leaves with the content instead of fading.
+    var followScroll = false
+
+    @Environment(\.appTheme) private var theme
+
+    private var scroll: CGFloat { max(scrollOffset, 0) }
+
+    var body: some View {
+        Group {
+            if followScroll {
+                gradient
+                    .frame(height: headerHeight + (extended ? extendedGradientExtra : 0))
+                    .offset(y: -scroll)
+            } else {
+                // fades out on scroll as the extended header does off Duo; extended also collapses
+                let progress = min(scroll / extendedCollapseDistance, 1)
+                gradient
+                    .frame(height: headerHeight + (extended ? extendedGradientExtra * (1 - progress) : 0))
+                    .opacity(1 - min(scroll / extendedGradientExtra, 1))
+            }
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
+        .ignoresSafeArea()
+        .allowsHitTesting(false)
+    }
+
+    /// The fade spans the gradient box.
+    private var gradient: LinearGradient {
+        LinearGradient(
+            colors: [theme.colors.gradient, theme.colors.gradient.opacity(0)],
+            startPoint: .top,
+            endPoint: .bottom
+        )
+    }
+}

package/ios/Application/Navigation/component/Header.swift

@@ -60,7 +60,11 @@ public struct NavigationHeader: View {
         self.titleOpacity = titleOpacity
     }
 
+    @Environment(\.screenLayout) private var layout
+
     private var isAnimated: Bool { animatedHeader != nil }
+    /// iPhone Duo side bar holds back and the toolkit; a custom header right stays in the bar.
+    private var useSideBar: Bool { layout.sideBar != nil }
     private var isSurface: Bool { animatedHeader?.isSurface ?? true }
 
     private var headerColor: HeaderColor {
@@ -79,7 +83,7 @@ public struct NavigationHeader: View {
         if headerType != .none {
             ZStack {
                 HStack(spacing: 0) {
-                    if let goBack {
+                    if let goBack, !useSideBar {
                         BackButton(color: headerColor, onBack: goBack)
                         Spacer().frame(width: Spacing.S)
                     }
@@ -91,7 +95,7 @@ public struct NavigationHeader: View {
                             .frame(maxWidth: .infinity, alignment: .leading)
                     }
 
-                    if let headerRight {
+                    if let headerRight, !(useSideBar && toolkitHeaderRight(headerRight) != nil) {
                         AnyView(headerRight())
                             .background(
                                 GeometryReader { geo in
@@ -107,8 +111,11 @@ public struct NavigationHeader: View {
                         .padding(.horizontal, Spacing.M)
                 }
             }
-            .frame(height: HEADER_HEIGHT)
+            .frame(height: layout.headerBarHeight)
             .overlay(alignment: .bottom) { VerticalShadow(opacity: opacity) }
+            // the row starts headerStatusBarHeight below the window top: 0 with the status bar off
+            // the top edge, lower on the iPhone Duo outer display to center on the camera
+            .padding(.top, layout.headerStatusBarHeight - layout.insets.top)
         }
     }
 
@@ -119,9 +126,7 @@ public struct NavigationHeader: View {
         if let inputSearchProps {
             InputSearch(props: inputSearchProps)
         } else if case let .user(userData)? = headerTitle {
-            if #available(iOS 16.0, *) {
-                HeaderUserView(userData)
-            }
+            HeaderUserView(userData)
         } else {
             MomoText(
                 headerTitle?.defaultTitle ?? title,

package/ios/Application/Navigation/component/HeaderBackground.swift

@@ -43,10 +43,11 @@ public struct NavigationHeaderBackground: View {
         )
     }
 
+    @Environment(\.screenLayout) private var layout
+
     public var body: some View {
-        let statusBarHeight = safeAreaTopInset()
         let opacity = max(0, 1 - scrollState / CGFloat(HEADER_HEIGHT))
-        let minHeight = fullScreenContent ? 0 : statusBarHeight + HEADER_HEIGHT
+        let minHeight = fullScreenContent ? 0 : layout.headerHeight
         let maxHeight: CGFloat = 154
         let backgroundColor = headerTransparent ? Color.clear : Colors.black01
         let topColor = opacity == 0 ? backgroundColor : Color(hex: 0xFDCADE)

package/ios/Application/Navigation/component/NavigationFooter.swift

@@ -69,7 +69,7 @@ public struct NavigationFooter: View {
             .padding(.bottom, Self.bottomPadding)
             // Compose paints the surface all the way to the bottom of the screen; the
             // footer's own frame stops at the safe area, so only the fill bleeds down.
-            .background(theme.colors.background.surface.ignoresSafeArea(.container, edges: .bottom))
+            .background(theme.colors.background.surface.ignoresSafeArea(.container, edges: [.bottom, .horizontal]))
             .overlay(alignment: .top) { shadow }
             .offset(y: Self.verticalOffset(keyboardSize: keyboardSize))
         }