@momo-kits/native-kits 0.300.3 → 0.300.4-debug

package/ios/Navigation/NavigationContainer.swift

@@ -0,0 +1,195 @@
+//
+//  NavigationContainer.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `navigation/NavigationContainer.kt`: hosts the kit stack
+//  (`StackHost`, the NavHost counterpart), injects Navigator, theme, localize and font scale, and
+//  renders every registered screen inside `StackScreen` chrome built from its options.
+//
+
+import SwiftUI
+
+public struct NavigationContainer<Initial: View>: View {
+    @StateObject private var navigator: Navigator
+    @StateObject private var applicationEnvironment: ApplicationEnvironment
+    @StateObject private var localize: Localize
+
+    @Environment(\.appTheme) private var parentTheme
+
+    private let setNavigator: ((Navigator) -> Void)?
+    private let composeApi: KitComposeApi?
+    private let maxApi: MaxApi?
+    private let initialTheme: Theme?
+
+    /// `initialTheme` nil keeps the theme the host already put in the environment.
+    public init(
+        initialScreenName: String = "",
+        @ViewBuilder initialScreen: @escaping () -> Initial,
+        options: NavigationOptions? = nil,
+        initialTheme: Theme? = 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
+        )
+        nav.maxApi = maxApi
+        _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.initialTheme = initialTheme
+        self.setNavigator = setNavigator
+    }
+
+    /// RN parity: the theme's own header image wins; config `headerBar` is only the fallback.
+    private var resolvedTheme: Theme {
+        let theme = initialTheme ?? parentTheme
+        guard !theme.assets.isHeaderImage,
+              let headerBar = applicationEnvironment.config?.headerBar, !headerBar.isEmpty else {
+            return theme
+        }
+        return theme.copy(assets: ThemeAssets(headerBackground: headerBar))
+    }
+
+    public var body: some View {
+        StackHost(
+            navigator: navigator,
+            entries: navigator.entries,
+            screen: { [navigator] entry in
+                guard let screen = navigator.registry.getScreen(id: entry.id) else { return AnyView(EmptyView()) }
+                return AnyView(ScreenHost(screen: screen, navigator: navigator))
+            },
+            decorate: { AnyView(withKitEnvironment($0)) }
+        )
+        // edge to edge: each screen's hosting controller takes the safe area and keyboard itself
+        .ignoresSafeArea()
+        .onAppear {
+            if navigator.composeApi == nil {
+                navigator.composeApi = composeApi
+            }
+            if navigator.maxApi == nil {
+                navigator.maxApi = maxApi
+            }
+            setNavigator?(navigator)
+            // Idempotent, so a re-appear won't double-count.
+            HostBackGestureBridge.shared.attach(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 {
+            HostBackGestureBridge.shared.detach(navigator)
+        }
+    }
+
+    private func withKitEnvironment<Content: View>(_ content: Content) -> some View {
+        content
+            .environmentObject(navigator)
+            .environmentObject(applicationEnvironment)
+            .environment(\.applicationEnvironment, applicationEnvironment)
+            .environment(\.appTheme, resolvedTheme)
+            .momoLocalize(localize)
+            .momoFontScale(context: applicationEnvironment.applicationContext)
+    }
+}
+
+// MARK: - ScreenHost
+
+private struct ScreenHost: View {
+    let screen: DynamicScreen
+    let navigator: Navigator
+    @StateObject private var navigation: Navigation
+
+    init(screen: DynamicScreen, navigator: Navigator) {
+        self.screen = screen
+        self.navigator = navigator
+        _navigation = StateObject(
+            wrappedValue: Navigation(id: screen.id, options: screen.options, registry: navigator.registry)
+        )
+    }
+
+    var body: some View {
+        OptionsStackScreen(
+            options: navigation.options,
+            screenName: screen.name,
+            goBack: { navigator.onBackSafe() },
+            content: screen.content
+        )
+        // Compose draws the overplay inside the screen it was shown over, under its LocalNavigation.
+        .overlay { OverplayLayer(screenId: screen.id) }
+        .environmentObject(navigation)
+        .momoScreenLayout()
+    }
+}
+
+private struct OverplayLayer: View {
+    let screenId: Int
+    @EnvironmentObject private var navigator: Navigator
+
+    var body: some View {
+        if let item = navigator.overplay, item.screenId == screenId {
+            OverplayHost(item: item)
+        }
+    }
+}
+
+// MARK: - Overplay host
+
+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(overplayId: item.id, barrierDismissible: item.barrierDismissible) {
+                item.content()
+            }
+            .id(item.id)
+        case .bottomSheet:
+            BottomSheetView(
+                overplayId: item.id,
+                header: item.header ?? .title(),
+                isSurface: item.isSurface,
+                barrierDismissible: item.barrierDismissible,
+                draggable: item.draggable,
+                useBottomInset: item.useBottomInset,
+                footer: item.footer
+            ) {
+                item.content()
+            }
+            .id(item.id)
+        case .snackBar:
+            if let snackBar = item.snackBar {
+                SnackBarView(overplayId: item.id, snackBar: snackBar, bottomInset: navigator.snackBarBottomInset())
+                    .id(item.id)
+            }
+        }
+    }
+}