@momo-kits/native-kits 0.163.1-beta.3-debug → 0.163.1-beta.5-debug

package/ios/Application/Navigation/NavigationContainer.swift

@@ -0,0 +1,176 @@
+//
+//  NavigationContainer.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's NavigationContainer.
+//  Wraps NavigationStack, injects Navigator into the environment, and renders
+//  every registered screen inside `Screen(options)` chrome — same auto-wrap
+//  behavior as Compose's StackScreen.
+//
+
+import SwiftUI
+
+@available(iOS 16.0, *)
+public struct NavigationContainer<Initial: View>: View {
+    @StateObject private var navigator: Navigator
+    @StateObject private var applicationEnvironment: ApplicationEnvironment
+
+    private let setNavigator: ((Navigator) -> Void)?
+    private let composeApi: KitComposeApi?
+
+    public init(
+        initialScreenName: String = "",
+        @ViewBuilder initialScreen: @escaping () -> Initial,
+        options: NavigationOptions? = nil,
+        applicationContext: MiniAppContext? = nil,
+        composeApi: KitComposeApi? = nil,
+        config: KitConfig? = nil,
+        setNavigator: ((Navigator) -> Void)? = nil
+    ) {
+        let nav = Navigator(
+            initialScreenName: initialScreenName.isEmpty ? (options?.screenName ?? "") : initialScreenName,
+            initialContent: { AnyView(initialScreen()) },
+            options: options,
+            composeApi: composeApi
+        )
+        _navigator = StateObject(wrappedValue: nav)
+        _applicationEnvironment = StateObject(
+            wrappedValue: ApplicationEnvironment(
+                applicationContext: applicationContext,
+                composeApi: composeApi,
+                config: config
+            )
+        )
+        self.composeApi = composeApi
+        self.setNavigator = setNavigator
+    }
+
+    public var body: some View {
+        NavigationStack(path: $navigator.path) {
+            screenView(for: navigator.rootRoute)
+                .navigationDestination(for: DynamicScreenRoute.self) { route in
+                    screenView(for: route)
+                }
+        }
+        .environmentObject(navigator)
+        .environmentObject(applicationEnvironment)
+        .environment(\.applicationEnvironment, applicationEnvironment)
+        .fullScreenCover(item: $navigator.presented) { route in
+            screenView(forDialog: route)
+                .environmentObject(navigator)
+                .environmentObject(applicationEnvironment)
+                .environment(\.applicationEnvironment, applicationEnvironment)
+        }
+        .overlay {
+            if let item = navigator.overplay {
+                OverplayHost(item: item)
+                    .environmentObject(navigator)
+                    .environmentObject(applicationEnvironment)
+                    .environment(\.applicationEnvironment, applicationEnvironment)
+            }
+        }
+        .onAppear {
+            if navigator.composeApi == nil {
+                navigator.composeApi = composeApi
+            }
+            setNavigator?(navigator)
+        }
+    }
+
+    @ViewBuilder
+    private func screenView(for route: DynamicScreenRoute) -> some View {
+        if let screen = DynamicScreenRegistry.shared.getScreen(id: route.id) {
+            ScreenHost(screen: screen, navigator: navigator)
+                .navigationBarBackButtonHidden(true)
+        } else {
+            EmptyView()
+        }
+    }
+
+    @ViewBuilder
+    private func screenView(forDialog route: DynamicDialogRoute) -> some View {
+        if let screen = DynamicScreenRegistry.shared.getScreen(id: route.id) {
+            ScreenHost(screen: screen, navigator: navigator)
+        } else {
+            EmptyView()
+        }
+    }
+}
+
+// MARK: - ScreenHost
+
+@available(iOS 16.0, *)
+private struct ScreenHost: View {
+    let screen: DynamicScreen
+    let navigator: Navigator
+
+    var body: some View {
+        let options = screen.options ?? NavigationOptions()
+        StackScreen(
+            backgroundColor: options.backgroundColor,
+            headerTransparent: options.headerTransparent,
+            fullScreenContent: options.fullScreenContent,
+            tintColor: options.tintColor ?? Colors.black17,
+            isBack: !options.hiddenBack,
+            headerType: options.headerType,
+            useAnimated: options.useAnimated,
+            title: options.title,
+            headerTitle: options.headerTitle,
+            titlePosition: options.titlePosition,
+            goBack: options.hiddenBack ? nil : { navigator.onBackSafe() },
+            scrollable: options.scrollable,
+            scrollToTopCallback: options.scrollToTopCallback,
+            useAvoidKeyboard: options.useAvoidKeyboard,
+            keyboardShouldPersistTaps: options.keyboardShouldPersistTaps,
+            footer: options.footer,
+            headerRight: options.resolvedHeaderRight,
+            animatedHeader: options.animatedHeader,
+            layoutOffset: options.layoutOffset,
+            inputSearchProps: options.inputSearchProps,
+            fabProps: options.fabProps,
+            content: { screen.content() }
+        )
+    }
+}
+
+// MARK: - Overplay host
+
+@available(iOS 16.0, *)
+private struct OverplayHost: View {
+    let item: OverplayItem
+    @EnvironmentObject var navigator: Navigator
+
+    var body: some View {
+        // Each component self-animates on appear and drives its own exit through
+        // the Navigator before the item is removed (mirrors Compose's overplay).
+        switch item.type {
+        case .modal:
+            ModalScreen(barrierDismissible: item.barrierDismissible) {
+                item.content()
+            }
+            .id(item.id)
+        case .bottomSheet:
+            BottomSheetView(
+                header: item.header ?? .title(),
+                isSurface: item.isSurface,
+                barrierDismissible: item.barrierDismissible
+            ) {
+                item.content()
+            }
+            .id(item.id)
+        case .snackBar:
+            if let snackBar = item.snackBar {
+                SnackBarView(snackBar: snackBar, bottomInset: safeAreaBottomInset() + Spacing.S)
+                    .id(item.id)
+            }
+        }
+    }
+}
+
+/// Bottom safe-area inset (home indicator), used to lift the snack bar.
+@available(iOS 16.0, *)
+private func safeAreaBottomInset() -> CGFloat {
+    UIApplication.shared.connectedScenes
+        .compactMap { ($0 as? UIWindowScene)?.keyWindow?.safeAreaInsets.bottom }
+        .first ?? 0
+}

package/ios/Application/Navigation/NavigationOptions.swift

@@ -0,0 +1,109 @@
+//
+//  NavigationOptions.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's NavigationOptions.
+//  Each option lines up with a parameter on the existing `Screen` view,
+//  so NavigationContainer can auto-wrap a registered screen body in `Screen(options)`.
+//
+
+import SwiftUI
+
+public struct NavigationOptions {
+    public var screenName: String?
+    public var title: String
+    /// Rich header title (mirrors Compose's `headerTitle`). When set to `.user`
+    /// the header renders an avatar group instead of `title`; `.default` keeps
+    /// the plain `title` text.
+    public var headerTitle: HeaderTitle?
+    public var titlePosition: TitlePosition
+    public var headerType: HeaderType
+    /// Mirrors Compose's `HeaderType.Extended/Default(useAnimated = ...)`: when true
+    /// and `inputSearchProps` is set, the search bar animates into the header on scroll.
+    public var useAnimated: Bool
+    public var headerTransparent: Bool
+    public var fullScreenContent: Bool
+    public var hiddenBack: Bool
+    public var backgroundColor: Color?
+    public var tintColor: Color?
+    public var scrollable: Bool
+    /// Mirrors Compose's `ScrollData.scrollToTopCallback`: invoked when the
+    /// screen is asked to scroll to top (e.g. on a status-bar tap).
+    public var scrollToTopCallback: (() -> Void)?
+    public var useAvoidKeyboard: Bool
+    /// Mirrors Compose's `KeyboardOptions.keyboardShouldPersistTaps`: when true,
+    /// tapping anywhere on the screen dismisses the keyboard.
+    public var keyboardShouldPersistTaps: Bool
+    /// Mirrors Compose's `HeaderBackProps`: drives the prevent-back confirm popup.
+    public var headerBackProps: HeaderBackProps?
+    /// Typed toolkit data for the default header right control (mirrors
+    /// Compose's `HeaderRight.Toolkit`). Use `headerRight` for `.custom` and nil
+    /// for `.none`.
+    public var headerRightData: HeaderRightData?
+    public var headerRight: (() -> any View)?
+    public var footer: (() -> AnyView)?
+    public var animatedHeader: AnimatedHeader?
+    public var layoutOffset: CGFloat
+    public var inputSearchProps: InputSearchProps?
+    public var fabProps: FabProps?
+    public var onBackHandler: (() -> Void)?
+
+    public init(
+        screenName: String? = nil,
+        title: String = "Stack",
+        headerTitle: HeaderTitle? = nil,
+        titlePosition: TitlePosition = .left,
+        headerType: HeaderType = .default,
+        useAnimated: Bool = false,
+        headerTransparent: Bool = false,
+        fullScreenContent: Bool = false,
+        hiddenBack: Bool = false,
+        backgroundColor: Color? = nil,
+        tintColor: Color? = Colors.black17,
+        scrollable: Bool = true,
+        scrollToTopCallback: (() -> Void)? = nil,
+        useAvoidKeyboard: Bool = true,
+        keyboardShouldPersistTaps: Bool = false,
+        headerBackProps: HeaderBackProps? = nil,
+        headerRightData: HeaderRightData? = nil,
+        headerRight: (() -> any View)? = { HeaderRight() },
+        footer: (() -> AnyView)? = nil,
+        animatedHeader: AnimatedHeader? = nil,
+        layoutOffset: CGFloat = 56,
+        inputSearchProps: InputSearchProps? = nil,
+        fabProps: FabProps? = nil,
+        onBackHandler: (() -> Void)? = nil
+    ) {
+        self.screenName = screenName
+        self.title = title
+        self.headerTitle = headerTitle
+        self.titlePosition = titlePosition
+        self.headerType = headerType
+        self.useAnimated = useAnimated
+        self.headerTransparent = headerTransparent
+        self.fullScreenContent = fullScreenContent
+        self.hiddenBack = hiddenBack
+        self.backgroundColor = backgroundColor
+        self.tintColor = tintColor
+        self.scrollable = scrollable
+        self.scrollToTopCallback = scrollToTopCallback
+        self.useAvoidKeyboard = useAvoidKeyboard
+        self.keyboardShouldPersistTaps = keyboardShouldPersistTaps
+        self.headerBackProps = headerBackProps
+        self.headerRightData = headerRightData
+        self.headerRight = headerRight
+        self.footer = footer
+        self.animatedHeader = animatedHeader
+        self.layoutOffset = layoutOffset
+        self.inputSearchProps = inputSearchProps
+        self.fabProps = fabProps
+        self.onBackHandler = onBackHandler
+    }
+}
+
+extension NavigationOptions {
+    var resolvedHeaderRight: (() -> any View)? {
+        guard let headerRightData else { return headerRight }
+        return { HeaderRight(headerRight: headerRightData, tintColor: tintColor) }
+    }
+}

package/ios/Application/Navigation/Navigator.swift

@@ -0,0 +1,364 @@
+//
+//  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.
+//
+
+import SwiftUI
+import Combine
+
+// MARK: - Routes
+
+public struct DynamicScreenRoute: Hashable, Identifiable {
+    public let id: Int
+}
+
+public struct DynamicDialogRoute: Hashable, Identifiable {
+    public let id: Int
+}
+
+// MARK: - Registry
+
+public struct DynamicScreen {
+    public let id: Int
+    public let name: String
+    public let content: () -> AnyView
+    public var options: NavigationOptions?
+}
+
+public final class DynamicScreenRegistry {
+    public static let shared = DynamicScreenRegistry()
+
+    private var screens: [Int: DynamicScreen] = [:]
+    private var idCounter: Int = 1
+
+    private init() {}
+
+    @discardableResult
+    public func register(
+        screenName: String = "",
+        content: @escaping () -> AnyView,
+        options: NavigationOptions? = nil
+    ) -> DynamicScreenRoute {
+        let id = idCounter
+        idCounter += 1
+        screens[id] = DynamicScreen(id: id, name: screenName, content: content, options: options)
+        return DynamicScreenRoute(id: id)
+    }
+
+    public func unregister(id: Int) {
+        screens.removeValue(forKey: id)
+    }
+
+    public func unregisterAll() {
+        screens.removeAll()
+    }
+
+    public func getScreen(id: Int) -> DynamicScreen? { screens[id] }
+
+    public func latest() -> DynamicScreen? {
+        screens.max(by: { $0.key < $1.key })?.value
+    }
+
+    public func setOptions(id: Int, options: NavigationOptions) {
+        screens[id]?.options = options
+    }
+}
+
+// MARK: - Overplay
+
+public enum OverplayType {
+    case modal, bottomSheet, snackBar
+}
+
+public struct OverplayItem: Identifiable {
+    public let id = UUID()
+    public let type: OverplayType
+    public let content: () -> AnyView
+    public let barrierDismissible: Bool
+    public let onDismiss: (() -> Void)?
+    // Bottom-sheet params (mirrors Compose's OverplayComponentParams.BottomSheet).
+    public var isSurface: Bool = false
+    public var header: BottomSheetHeader? = nil
+    // Snack-bar payload (mirrors Compose's SnackBar value).
+    public var snackBar: SnackBar? = nil
+}
+
+// MARK: - Navigator
+
+@available(iOS 16.0, *)
+public final class Navigator: ObservableObject {
+    @Published public var path: [DynamicScreenRoute] = []
+    @Published public var presented: DynamicDialogRoute?
+    @Published public var overplay: OverplayItem?
+
+    /// Animated-close handler registered by the active overplay component
+    /// (mirrors Compose's `OverplayComponentRegistry.bindClose`). When set, a
+    /// dismiss request runs the component's exit animation before the item is
+    /// actually removed via `finishOverplayDismiss`.
+    private var overplayDismissHandler: (() -> Void)?
+
+    public private(set) var rootRoute: DynamicScreenRoute
+    public var composeApi: KitComposeApi?
+
+    public init(
+        initialScreenName: String = "",
+        initialContent: @escaping () -> AnyView,
+        options: NavigationOptions? = nil,
+        composeApi: KitComposeApi? = nil
+    ) {
+        self.composeApi = composeApi
+        self.rootRoute = DynamicScreenRegistry.shared.register(
+            screenName: initialScreenName,
+            content: initialContent,
+            options: options
+        )
+    }
+
+    // MARK: Stack
+
+    public func push<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: options?.screenName ?? "",
+            content: { AnyView(content()) },
+            options: options
+        )
+        path.append(route)
+    }
+
+    public func push<V: View>(
+        screenName: String,
+        @ViewBuilder _ content: @escaping () -> V,
+        options: NavigationOptions? = nil
+    ) {
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: screenName,
+            content: { AnyView(content()) },
+            options: options
+        )
+        path.append(route)
+    }
+
+    public func replace<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
+        guard !path.isEmpty else { return }
+        let removed = path.removeLast()
+        DynamicScreenRegistry.shared.unregister(id: removed.id)
+        push(content, options: options)
+    }
+
+    public func replace<V: View>(
+        screenName: String,
+        @ViewBuilder _ content: @escaping () -> V,
+        options: NavigationOptions? = nil
+    ) {
+        guard !path.isEmpty else { return }
+        let removed = path.removeLast()
+        DynamicScreenRegistry.shared.unregister(id: removed.id)
+        push(screenName: screenName, content, options: options)
+    }
+
+    public func reset<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
+        for route in path { DynamicScreenRegistry.shared.unregister(id: route.id) }
+        DynamicScreenRegistry.shared.unregister(id: rootRoute.id)
+        path.removeAll()
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: options?.screenName ?? "",
+            content: { AnyView(content()) },
+            options: options
+        )
+        rootRoute = route
+    }
+
+    public func reset<V: View>(
+        screenName: String,
+        @ViewBuilder _ content: @escaping () -> V,
+        options: NavigationOptions? = nil
+    ) {
+        for route in path { DynamicScreenRegistry.shared.unregister(id: route.id) }
+        DynamicScreenRegistry.shared.unregister(id: rootRoute.id)
+        path.removeAll()
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: screenName,
+            content: { AnyView(content()) },
+            options: options
+        )
+        rootRoute = route
+    }
+
+    public func pop(_ count: Int = 1, callback: (() -> Void)? = nil) {
+        var remaining = count
+        while remaining > 0 {
+            if overplay != nil {
+                hideOverplay()
+            } else if presented != nil {
+                let dismissedId = presented?.id
+                presented = nil
+                if let id = dismissedId { DynamicScreenRegistry.shared.unregister(id: id) }
+            } else if !path.isEmpty {
+                let removed = path.removeLast()
+                DynamicScreenRegistry.shared.unregister(id: removed.id)
+            } else {
+                composeApi?.requestCallback(funcName: "dismiss", params: nil, onResponse: nil)
+                break
+            }
+            remaining -= 1
+        }
+        callback?()
+    }
+
+    public func popToRoot() {
+        for route in path { DynamicScreenRegistry.shared.unregister(id: route.id) }
+        path.removeAll()
+    }
+
+    public func onBackSafe(callback: (() -> Void)? = nil) {
+        let latest = DynamicScreenRegistry.shared.latest()
+        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
+                )
+            }
+            return
+        }
+        pop(1, callback: callback)
+    }
+
+    // MARK: Modal-style screen (vertical slide)
+
+    public func present<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: options?.screenName ?? "",
+            content: { AnyView(content()) },
+            options: options
+        )
+        presented = DynamicDialogRoute(id: route.id)
+    }
+
+    public func present<V: View>(
+        screenName: String,
+        @ViewBuilder _ content: @escaping () -> V,
+        options: NavigationOptions? = nil
+    ) {
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: screenName,
+            content: { AnyView(content()) },
+            options: options
+        )
+        presented = DynamicDialogRoute(id: route.id)
+    }
+
+    public func dismiss() {
+        if let id = presented?.id {
+            DynamicScreenRegistry.shared.unregister(id: id)
+        }
+        presented = nil
+    }
+
+    // MARK: Overplay
+
+    public func showModal<V: View>(
+        @ViewBuilder _ content: @escaping () -> V,
+        barrierDismissible: Bool = true,
+        onDismiss: (() -> Void)? = nil
+    ) {
+        overplayDismissHandler = nil
+        overplay = OverplayItem(
+            type: .modal,
+            content: { AnyView(content()) },
+            barrierDismissible: barrierDismissible,
+            onDismiss: onDismiss
+        )
+    }
+
+    public func showBottomSheet<V: View>(
+        @ViewBuilder _ content: @escaping () -> V,
+        isSurface: Bool = false,
+        barrierDismissible: Bool = true,
+        header: BottomSheetHeader? = nil,
+        onDismiss: (() -> Void)? = nil
+    ) {
+        overplayDismissHandler = nil
+        overplay = OverplayItem(
+            type: .bottomSheet,
+            content: { AnyView(content()) },
+            barrierDismissible: barrierDismissible,
+            onDismiss: onDismiss,
+            isSurface: isSurface,
+            header: header
+        )
+    }
+
+    /// Mirrors Compose's `showSnackBar(snackBar:)`.
+    public func showSnackBar(_ snackBar: SnackBar, onDismiss: (() -> Void)? = nil) {
+        overplayDismissHandler = nil
+        overplay = OverplayItem(
+            type: .snackBar,
+            content: { AnyView(EmptyView()) },
+            barrierDismissible: false,
+            onDismiss: onDismiss,
+            snackBar: snackBar
+        )
+    }
+
+    // MARK: Overplay dismissal
+
+    /// Registered by the active overplay component so external dismiss requests
+    /// run its exit animation (mirrors Compose's `bindClose`).
+    public func registerOverplayDismiss(_ handler: @escaping () -> Void) {
+        overplayDismissHandler = handler
+    }
+
+    /// Removes the overplay and fires its `onDismiss` (mirrors Compose's
+    /// `hardClearAfterDismiss`). Called by a component once its exit animation
+    /// has completed.
+    public func finishOverplayDismiss() {
+        let dismissCallback = overplay?.onDismiss
+        overplayDismissHandler = nil
+        overplay = nil
+        dismissCallback?()
+    }
+
+    public func hideOverplay() {
+        if let close = overplayDismissHandler {
+            // Component runs its exit animation, then calls finishOverplayDismiss.
+            overplayDismissHandler = nil
+            close()
+        } else {
+            finishOverplayDismiss()
+        }
+    }
+
+    public func hideSnackBar() {
+        if overplay?.type == .snackBar { hideOverplay() }
+    }
+}