@momo-kits/native-kits 0.0.1-beta.5 → 0.0.2-alpha.1-debug

package/ios/Application/Navigation/NavigationContainer.swift

@@ -0,0 +1,213 @@
+//
+//  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
+    @StateObject private var localize: Localize
+
+    private let setNavigator: ((Navigator) -> Void)?
+    private let composeApi: KitComposeApi?
+    private let maxApi: MaxApi?
+
+    public init(
+        initialScreenName: String = "",
+        @ViewBuilder initialScreen: @escaping () -> Initial,
+        options: NavigationOptions? = nil,
+        applicationContext: MiniAppContext? = nil,
+        composeApi: KitComposeApi? = nil,
+        config: KitConfig? = nil,
+        maxApi: MaxApi? = nil,
+        localize: Localize? = 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,
+                maxApi: maxApi
+            )
+        )
+        // AI-GENERATED START: default to the app-language-observing shared Localize
+        _localize = StateObject(wrappedValue: localize ?? Localize.shared)
+        // AI-GENERATED END: default to the app-language-observing shared Localize
+        self.composeApi = composeApi
+        self.maxApi = maxApi
+        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)
+        // AI-GENERATED START: route Localize + font-scale injection through the observing modifiers
+        .momoLocalize(localize)
+        .momoFontScale(context: applicationEnvironment.applicationContext)
+        // AI-GENERATED END: route Localize + font-scale injection through the observing modifiers
+        .fullScreenCover(item: $navigator.presented) { route in
+            screenView(forDialog: route)
+                .environmentObject(navigator)
+                .environmentObject(applicationEnvironment)
+                .environment(\.applicationEnvironment, applicationEnvironment)
+                // AI-GENERATED START: route Localize + font-scale injection through the observing modifiers
+                .momoLocalize(localize)
+                .momoFontScale(context: applicationEnvironment.applicationContext)
+                // AI-GENERATED END: route Localize + font-scale injection through the observing modifiers
+        }
+        .overlay {
+            if let item = navigator.overplay {
+                OverplayHost(item: item)
+                    .environmentObject(navigator)
+                    .environmentObject(applicationEnvironment)
+                    .environment(\.applicationEnvironment, applicationEnvironment)
+                    // AI-GENERATED START: route Localize + font-scale injection through the observing modifiers
+                    .momoLocalize(localize)
+                    .momoFontScale(context: applicationEnvironment.applicationContext)
+                    // AI-GENERATED END: route Localize + font-scale injection through the observing modifiers
+            }
+        }
+        .onAppear {
+            if navigator.composeApi == nil {
+                navigator.composeApi = composeApi
+            }
+            setNavigator?(navigator)
+            // Register with the host swipe-back bridge (mirrors ComposeAppContainer's
+            // ComposeNavigatorManager.push). Idempotent, so a re-appear won't double-count.
+            NavigatorManager.shared.push(navigator)
+            // AI-GENERATED START: demote the MaxApi language pull to a seed of last resort
+            // Only a seed: a Localize with a language source already tracks the host in both
+            // directions, so asking maxApi would just race it. `changeLanguage` normalizes the
+            // raw response and hops to main itself.
+            guard !localize.observesAppLanguage else { return }
+            maxApi?.getLanguage { data in
+                localize.changeLanguage(data?["response"] as? String)
+            }
+            // AI-GENERATED END: demote the MaxApi language pull to a seed of last resort
+        }
+        .onDisappear {
+            NavigatorManager.shared.remove(navigator)
+        }
+    }
+
+    @ViewBuilder
+    private func screenView(for route: DynamicScreenRoute) -> some View {
+        if let screen = navigator.registry.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 = navigator.registry.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,
+            screenName: screen.name,
+            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) }
+    }
+}