@momo-kits/native-kits 0.163.1-sp.1-debug → 0.163.1-sp.11-debug

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] = [] {
+        // 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) }
+    }
     @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,26 +190,50 @@ public final class Navigator: ObservableObject {
             options: options
         )
         rootRoute = route
+        disposeScreens([previousRoot])
     }
 
     public func pop(_ count: Int = 1, callback: (() -> Void)? = nil) {
-        var remaining = count
-        while remaining > 0 {
-            if overplay?.type == .snackBar {
-                // Mirrors Kotlin: a snackbar doesn't block back-navigation, so popping
-                // while one is showing pops the screen underneath and clears the
-                // snackbar immediately, without playing its dismiss animation.
-                overplayDismissHandler = nil
-                overplay = nil
-                if !popScreen() { break }
-            } else if overplay != nil {
-                hideOverplay()
-            } else if !popScreen() {
-                break
+        popStep(remaining: count, callback: callback)
+    }
+
+    /// One `pop` iteration. Compose runs the loop in a coroutine and suspends over the
+    /// overplay's exit animation before the next step; the same wait is needed here, or
+    /// a `pop(2)` (prevent-back: close the popup, then leave) would spend both steps on
+    /// the overplay that is still animating out and never pop the screen.
+    private func popStep(remaining: Int, callback: (() -> Void)?) {
+        guard remaining > 0 else {
+            callback?()
+            return
+        }
+
+        if overplay?.type == .snackBar {
+            // Mirrors Kotlin: a snackbar doesn't block back-navigation, so popping
+            // while one is showing pops the screen underneath and clears the
+            // snackbar immediately, without playing its dismiss animation.
+            overplayDismissHandler = nil
+            overplay = nil
+            guard popScreen() else {
+                callback?()
+                return
+            }
+            popStep(remaining: remaining - 1, callback: callback)
+        } else if overplay != nil {
+            hideOverplay()
+            DispatchQueue.main.asyncAfter(deadline: .now() + Self.overplayDismissDelay) { [weak self] in
+                guard let self else { return }
+                // The component reports back through `finishOverplayDismiss` once its exit
+                // animation ends; clear it here if it never did, so the step is not wasted.
+                if self.overplay != nil { self.finishOverplayDismiss() }
+                self.popStep(remaining: remaining - 1, callback: callback)
             }
-            remaining -= 1
+        } else {
+            guard popScreen() else {
+                callback?()
+                return
+            }
+            popStep(remaining: remaining - 1, callback: callback)
         }
-        callback?()
     }
 
     /// Pops the topmost presented screen or stack entry. Returns `false` (and requests
@@ -218,11 +243,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,42 +255,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)
+    }
+
     public func onBackSafe(callback: (() -> Void)? = nil) {
-        let latest = registry.latest()
+        let latest = currentScreen()
         if let onBack = latest?.options?.onBackHandler {
             onBack()
             return
         }
         if let preventBack = latest?.options?.headerBackProps?.preventBack {
             showModal {
-                PopupDisplay(
-                    isPresented: .constant(true),
-                    title: preventBack.title,
-                    description: preventBack.description,
-                    url: preventBack.image,
-                    buttonDirection: preventBack.buttonDirection,
-                    buttonType: .button,
-                    actionButtonTitle: preventBack.primary?.title ?? "",
-                    closeButtonTitle: preventBack.secondary?.title ?? "",
-                    onPressAction: { [weak self] in
-                        preventBack.primary?.onPress?()
-                        // Close the popup, then leave the screen (matches Compose's pop(2)).
-                        self?.pop(2, callback: callback)
-                    },
-                    onPressCloseButton: { [weak self] in
-                        preventBack.secondary?.onPress?()
-                        self?.hideOverplay()
-                    },
-                    onClose: { [weak self] in
-                        preventBack.onIconClose?()
-                        self?.hideOverplay()
-                    },
-                    errorCode: preventBack.error,
-                    isShowCloseIcon: preventBack.isShowCloseIcon
+                PopupNotify(
+                    props: PopupNotifyProps(
+                        image: preventBack.image,
+                        title: preventBack.title,
+                        description: preventBack.description,
+                        error: preventBack.error,
+                        primary: PopupAction(
+                            title: preventBack.primary?.title ?? "",
+                            onPress: { [weak self] in
+                                preventBack.primary?.onPress?()
+                                // Close the popup, then leave the screen (matches Compose's pop(2)).
+                                self?.pop(2, callback: callback)
+                            }
+                        ),
+                        secondary: preventBack.secondary.map { secondary in
+                            PopupAction(
+                                title: secondary.title,
+                                onPress: { [weak self] in
+                                    secondary.onPress?()
+                                    self?.hideOverplay()
+                                }
+                            )
+                        },
+                        buttonDirection: preventBack.buttonDirection,
+                        onIconClose: { [weak self] in
+                            preventBack.onIconClose?()
+                            self?.hideOverplay()
+                        },
+                        isShowCloseIcon: preventBack.isShowCloseIcon
+                    )
                 )
             }
             return
@@ -382,4 +418,36 @@ 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 a little headroom for the pop transition.
+    private static let screenDisposeDelay: TimeInterval = 0.35
+
+    /// Longest overplay exit animation (the bottom sheet's), so a queued pop step runs
+    /// 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) })
+    }
+
+    /// 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]) {
+        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/NavigatorManager.swift

@@ -0,0 +1,49 @@
+//
+//  NavigatorManager.swift
+//  MoMoUIKits
+//
+//  Host bridge for the native iOS edge-swipe back — the SwiftUI mirror of Compose's
+//  `ComposeNavigatorManager` (momo-app `vn.momo.compose.uikits.ComposeNavigatorManager`).
+//
+//  The kit does NOT own the swipe gesture. In the host app a kit screen lives inside a
+//  `UIHostingController` hosted by the mini-app container VC, and that VC owns the
+//  `UIScreenEdgePanGestureRecognizer`. When the swipe fires the host asks this manager
+//  whether a kit stack is mounted (`checkCanPop`) and, if so, routes the back into it
+//  (`pop` → `Navigator.onBackSafe`) instead of dismissing the whole mini-app. Standalone
+//  (no such host, e.g. the demo app) there is no edge swipe — same as Compose on iOS,
+//  whose `BackHandler` is a no-op and which relies entirely on the host.
+//
+
+import Foundation
+
+@available(iOS 16.0, *)
+public final class NavigatorManager {
+    public static let shared = NavigatorManager()
+    private init() {}
+
+    /// Stack of mounted navigators; the last one is the visible top (nested mini-apps
+    /// push more than one). Held strongly, mirroring `ComposeNavigatorManager` — entries
+    /// are released by `NavigationContainer` on disappear, not by ARC.
+    private var navigators: [Navigator] = []
+
+    /// Idempotent: SwiftUI can re-run a view's `onAppear`, and a double push would need a
+    /// matching double remove to unwind.
+    public func push(_ navigator: Navigator) {
+        guard !navigators.contains(where: { $0 === navigator }) else { return }
+        navigators.append(navigator)
+    }
+
+    /// Removes by identity rather than `removeLast` so a spurious disappear of a covered
+    /// (non-top) container can't drop the wrong navigator.
+    public func remove(_ navigator: Navigator) {
+        navigators.removeAll { $0 === navigator }
+    }
+
+    /// True while any kit stack is mounted — tells the host to route the back into the kit
+    /// instead of dismissing the mini-app. Matches `ComposeNavigatorManager.checkCanPop`:
+    /// it does not inspect stack depth; `onBackSafe` handles the at-root case itself by
+    /// asking the host to dismiss (via `composeApi`).
+    public func checkCanPop() -> Bool { !navigators.isEmpty }
+
+    public func pop() { navigators.last?.onBackSafe() }
+}

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

@@ -22,7 +22,7 @@ public struct NavigationHeader: View {
     /// Optional rich title (mirrors Compose's `HeaderTitle`); `.user` renders an
     /// avatar group, `.default`/nil renders plain `title`.
     var headerTitle: HeaderTitle?
-    var headerRight: (() -> any View)? = { HeaderRight() }
+    var headerRight: (() -> any View)? = { NavigationHeaderRight() }
     var goBack: (() -> Void)?
     var opacity: CGFloat = 1
     var animatedHeader: AnimatedHeader?

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

@@ -0,0 +1,11 @@
+import SwiftUI
+
+/// Reports the measured width of the header-right area so the animated search
+/// header can compute its trailing inset (mirrors Compose's headerRightWidthPx).
+/// Written by the header views (`NavigationHeader`) and read by `StackScreen`.
+public struct HeaderRightWidthKey: PreferenceKey {
+    public static var defaultValue: CGFloat = 0
+    public static func reduce(value: inout CGFloat, nextValue: () -> CGFloat) {
+        value = max(value, nextValue())
+    }
+}

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

@@ -0,0 +1,90 @@
+//
+//  NavigationFooter.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `Footer` (navigation/StackScreen.kt): the band
+//  pinned under the screen content — surface background, S/M padding, the
+//  navigation-bar reserve, and the 6pt gradient shadow cast up onto the content.
+//
+//  Named `NavigationFooter` to coexist with the legacy `Footer` in `Screen.swift`
+//  (kept as-is for the old `Screen` path). Used by `StackScreen`.
+//
+
+import SwiftUI
+
+public struct NavigationFooter: View {
+    /// Compose's `footerComponent`: nothing renders when nil.
+    var footerComponent: (() -> AnyView)?
+    /// Current keyboard height, measured from the bottom of the screen.
+    var keyboardSize: CGFloat
+
+    public init(
+        footerComponent: (() -> AnyView)?,
+        keyboardSize: CGFloat = 0
+    ) {
+        self.footerComponent = footerComponent
+        self.keyboardSize = keyboardSize
+    }
+
+    @Environment(\.appTheme) private var theme
+
+    /// Read from the window, not from an enclosing `GeometryProxy`: the proxy's bottom
+    /// inset grows to the keyboard height while the keyboard is up.
+    static var safeAreaBottom: CGFloat {
+        UIApplication.shared.connectedScenes
+            .compactMap { ($0 as? UIWindowScene)?.keyWindow?.safeAreaInsets.bottom }
+            .first ?? 0
+    }
+
+    /// Compose's `AppNavigationBar.current` (`getNavigationBarHeight` clamps iOS to 21pt).
+    static var navigationBarInset: CGFloat { min(safeAreaBottom, 21) }
+
+    /// Compose's `bottomPadding + Spacing.S` with the keyboard down. The footer is laid
+    /// out inside the safe area, which already covers part of that gap.
+    static var bottomPadding: CGFloat {
+        max(navigationBarInset + Spacing.S - safeAreaBottom, 0)
+    }
+
+    /// Deliberately an offset and not padding: growing the footer feeds back into SwiftUI's
+    /// keyboard avoidance, so a padding-based lift never settles at the right place.
+    /// Negative lifts the band over the keyboard; positive shaves the few points by which
+    /// the safe area over-reserves compared to Compose. `FloatingContent` rides the same
+    /// amount so the FAB keeps its distance above the band.
+    ///
+    /// Natural position is `safeAreaBottom + bottomPadding` above the bottom of the screen;
+    /// Compose puts it at `(AppNavigationBar - keyboard).coerceAtLeast(0) + Spacing.S` on
+    /// top of the `imePadding()` lift — i.e. `max(navigationBar, keyboard) + Spacing.S`.
+    static func verticalOffset(keyboardSize: CGFloat) -> CGFloat {
+        (safeAreaBottom + bottomPadding) - (max(navigationBarInset, keyboardSize) + Spacing.S)
+    }
+
+    public var body: some View {
+        if let footerComponent = footerComponent {
+            VStack(alignment: .leading, spacing: 0) {
+                footerComponent()
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(.top, Spacing.S)
+            .padding(.horizontal, Spacing.M)
+            .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))
+            .overlay(alignment: .top) { shadow }
+            .offset(y: Self.verticalOffset(keyboardSize: keyboardSize))
+        }
+    }
+
+    /// Compose offsets the shadow box by -6dp, so it lands on the content above the
+    /// footer rather than on the footer surface itself.
+    private var shadow: some View {
+        LinearGradient(
+            colors: [Color.clear, Color.black.opacity(0.05)],
+            startPoint: .top,
+            endPoint: .bottom
+        )
+        .frame(height: 6)
+        .offset(y: -6)
+        .allowsHitTesting(false)
+    }
+}

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

@@ -0,0 +1,196 @@
+import SwiftUI
+import Foundation
+
+/// Keyed (`@Environment(\.applicationEnvironment)`) variant of `HeaderRight`, for hosts
+/// wired through `NavigationContainer`/`KitContainer` (the injection style introduced by
+/// MR 227 / DS-637). Reuses the shared data types (`HeaderRightData`, `Tool`, `ToolGroup`)
+/// and `NavigationButton` from `HeaderRight.swift`. The legacy `HeaderRight` there stays on
+/// `@EnvironmentObject` for hosts that render `Screen` directly with
+/// `.environmentObject(ApplicationEnvironment(...))`. Opt in per screen with
+/// `headerRight: { NavigationHeaderRight() }`.
+public struct NavigationHeaderRight: View {
+    public init(headerRight: HeaderRightData? = nil, tintColor: Color? = nil) {
+        self.headerRight = headerRight
+        self.tintColor = tintColor
+    }
+    var headerRight: HeaderRightData?
+    var tintColor: Color? = nil
+
+    public var body: some View {
+        HStack(alignment: .center) {
+            ToolkitNavigationHeaderRight(headerRight: headerRight, tintColor: tintColor)
+        }
+    }
+}
+
+struct ToolkitNavigationHeaderRight: View {
+    var headerRight: HeaderRightData?
+    var tintColor: Color?
+    @State private var isFavorite: Bool = false
+    @State private var isLoading: Bool = false
+    @Environment(\.applicationEnvironment) private var environment
+
+    private func apiValue(_ value: Any?) -> Any {
+        value ?? NSNull()
+    }
+
+    private var contextMap: [String: Any] {
+        let context = environment.applicationContext
+        return [
+            "appId": apiValue(context?.appId),
+            "code": apiValue(context?.appCode),
+            "name": apiValue(context?.appName),
+            "icon": apiValue(context?.appIcon),
+            "description": apiValue(context?.description),
+            "support": apiValue(context?.support),
+            "toolkitConfig": apiValue(context?.toolkitConfig),
+            "providerId": apiValue(context?.providerId),
+            "permissions": apiValue(context?.permissions)
+        ]
+    }
+
+    private var shouldShowShortcut: Bool {
+        headerRight?.useShortcut == true && !(headerRight?.useMore == true && environment.applicationContext == nil)
+    }
+
+    private func parseResponse(_ response: String) -> Any? {
+        guard let jsonData = response.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: jsonData) as? [String: Any] else {
+            return nil
+        }
+        return json["response"]
+    }
+
+    // MARK: - Actions
+    private func loadFavoriteState() {
+        environment.composeApi?.request(
+            funcName: "isFavoriteApp",
+            params: ["code": apiValue(environment.applicationContext?.appCode)]
+        ) { response in
+            if let isFavorite = parseResponse(response) as? Bool {
+                self.isFavorite = isFavorite
+            }
+        }
+    }
+
+    private func onPressShortcut() {
+        environment.composeApi?.request(
+            funcName: "onToolAction",
+            params: [
+                "item": ["key": "onFavorite"],
+                "context": contextMap
+            ]
+        ) { response in
+            if let result = parseResponse(response) as? [String: Any],
+               result["success"] as? Bool == true {
+                isFavorite.toggle()
+            }
+        }
+    }
+
+    private func onPressHelpCenter() {
+        environment.composeApi?.request(
+            funcName: "showHelpCenter",
+            params: [
+                "appId": apiValue(environment.applicationContext?.appId),
+                "code": apiValue(environment.applicationContext?.appCode),
+                "name": apiValue(environment.applicationContext?.appName),
+                "icon": apiValue(environment.applicationContext?.appIcon),
+                "description": apiValue(environment.applicationContext?.description)
+            ]
+        ) { _ in }
+    }
+
+    private func onPressClose() {
+        environment.composeApi?.request(
+            funcName: "dismissAll",
+            params: nil
+        ) { _ in }
+    }
+
+    private func onPressMore() {
+        let params: [String: Any] = [
+            "useSystemTools": headerRight?.useSystemTools ?? true,
+            "tools": headerRight?.tools.map { $0.toMap() } ?? [],
+            "context": contextMap
+        ]
+        environment.composeApi?.request(
+            funcName: "showTools",
+            params: params
+        ) { response in
+            if let toolResponse = parseResponse(response) as? String {
+                headerRight?.toolCallback?(toolResponse)
+            }
+        }
+    }
+
+    private func getNavigationButtonConfig() -> NavigationButtonConfig {
+        let totalTools = headerRight?.tools.reduce(0) { $0 + $1.items.count } ?? 0
+        var icon = isFavorite ? "pin_star_checked" : "pin_star"
+        var onClickHandler: () -> Void = onPressShortcut
+
+        if totalTools > 1 || headerRight?.useMore == true {
+            icon = "navigation_more_icon"
+            onClickHandler = onPressMore
+        } else if totalTools == 1, let singleTool = headerRight?.tools.first?.items.first {
+            icon = singleTool.icon
+            onClickHandler = {
+                headerRight?.toolCallback?(singleTool.key)
+            }
+        }
+
+        return NavigationButtonConfig(icon: icon, onPress: onClickHandler)
+    }
+
+    var body: some View {
+        let backgroundButtonColor: Color = tintColor == Colors.black01 ? Colors.black20.opacity(0.6) : Colors.black01.opacity(0.6)
+        let borderColor: Color = tintColor == Colors.black01 ? Colors.black01.opacity(0.2) : Colors.black20.opacity(0.2)
+        let navButtonConfig = getNavigationButtonConfig()
+        let showBadge = headerRight?.tools.contains { group in
+            group.items.contains { $0.showBadge }
+        } ?? false
+
+        HStack(alignment: .center, spacing: 0) {
+            if shouldShowShortcut {
+                NavigationButton(
+                    disabled: isLoading,
+                    icon: navButtonConfig.icon,
+                    showBadge: showBadge,
+                    onClick: navButtonConfig.onPress,
+                    tintColor: tintColor
+                )
+            }
+
+            HStack(alignment: .center, spacing: 0) {
+                if environment.applicationContext != nil {
+                    Icon(source: "help_center", size: 20, color: tintColor ?? Colors.black17)
+                        .padding(4)
+                        .onTapGesture {
+                            onPressHelpCenter()
+                        }
+
+                    Rectangle()
+                        .fill(tintColor ?? Colors.black20)
+                        .frame(width: 0.5, height: 12)
+                }
+
+                Icon(source: "16_basic_home", size: 20, color: tintColor ?? Colors.black17)
+                    .padding(4)
+                    .onTapGesture {
+                        onPressClose()
+                    }
+            }
+            .frame(width: 65, height: 28)
+            .background(backgroundButtonColor)
+            .cornerRadius(14)
+            .overlay(
+                RoundedRectangle(cornerRadius: 14)
+                    .stroke(borderColor, lineWidth: 0.2)
+            )
+            .padding(.leading, Spacing.S)
+        }
+        .onAppear {
+            loadFavoriteState()
+        }
+    }
+}