@momo-kits/native-kits 0.167.1-duo.1-debug → 0.167.1-duo.10-debug

package/ios/{Application/Navigation → Navigation}/NavigationContainer.swift

@@ -2,10 +2,9 @@
 //  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.
+//  SwiftUI mirror of Compose's `navigation/NavigationContainer.kt`: wraps NavigationStack
+//  (iOS 16+), injects Navigator, theme, localize and font scale, and renders every registered
+//  screen inside `StackScreen` chrome built from its options.
 //
 
 import SwiftUI
@@ -16,14 +15,19 @@ public struct NavigationContainer<Initial: View>: View {
     @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,
@@ -37,6 +41,7 @@ public struct NavigationContainer<Initial: View>: View {
             options: options,
             composeApi: composeApi
         )
+        nav.maxApi = maxApi
         _navigator = StateObject(wrappedValue: nav)
         _applicationEnvironment = StateObject(
             wrappedValue: ApplicationEnvironment(
@@ -51,53 +56,49 @@ public struct NavigationContainer<Initial: View>: View {
         // AI-GENERATED END: default to the app-language-observing shared Localize
         self.composeApi = composeApi
         self.maxApi = maxApi
+        self.initialTheme = initialTheme
         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
+    /// 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
         }
-        .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
-            }
+        return theme.copy(assets: ThemeAssets(headerBackground: headerBar))
+    }
+
+    public var body: some View {
+        withKitEnvironment(
+            stack(path: $navigator.path, root: navigator.rootRoute)
+                .overlay { overplayLayer(presentedId: nil) }
+        )
+        .fullScreenCover(item: Binding(
+            get: { navigator.coverRoute },
+            // A close that bypasses the navigator (e.g. `dismiss()`) still tears the flow down.
+            // SwiftUI also writes nil after a navigator-driven close; by then a new screen may
+            // already be queued, so only a cover that is still showing counts.
+            set: { if $0 == nil, navigator.coverRoute != nil { navigator.dismiss() } }
+        )) { route in
+            withKitEnvironment(
+                stack(path: $navigator.presentedPath, root: DynamicScreenRoute(id: route.id))
+                    .overlay { overplayLayer(presentedId: route.id) }
+            )
+            .onAppear { navigator.coverDidAppear() }
+            .onDisappear { navigator.coverDidDisappear() }
         }
         .onAppear {
             if navigator.composeApi == nil {
                 navigator.composeApi = composeApi
             }
+            if navigator.maxApi == nil {
+                navigator.maxApi = maxApi
+            }
             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)
+            // 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
@@ -109,7 +110,20 @@ public struct NavigationContainer<Initial: View>: View {
             // AI-GENERATED END: demote the MaxApi language pull to a seed of last resort
         }
         .onDisappear {
-            NavigatorManager.shared.remove(navigator)
+            // Our own cover hides the stack without leaving it; host back must still reach it.
+            guard navigator.presented == nil else { return }
+            HostBackGestureBridge.shared.detach(navigator)
+        }
+    }
+
+    private func stack(path: Binding<[DynamicScreenRoute]>, root: DynamicScreenRoute) -> some View {
+        NavigationStack(path: path) {
+            screenView(for: root)
+                // A reset swaps the root in place; without the id it would inherit the old root's state.
+                .id(root.id)
+                .navigationDestination(for: DynamicScreenRoute.self) { route in
+                    screenView(for: route)
+                }
         }
     }
 
@@ -123,14 +137,24 @@ public struct NavigationContainer<Initial: View>: View {
         }
     }
 
+    /// Each context draws only the overplays shown over it, so one never re-mounts elsewhere.
     @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()
+    private func overplayLayer(presentedId: Int?) -> some View {
+        if let item = navigator.overplay, item.presentedId == presentedId {
+            OverplayHost(item: item)
+                .momoScreenLayout()
         }
     }
+
+    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
@@ -139,34 +163,26 @@ public struct NavigationContainer<Initial: View>: View {
 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 {
-        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,
+        OptionsStackScreen(
+            options: navigation.options,
             screenName: screen.name,
-            content: { screen.content() }
+            goBack: { navigator.onBackSafe() },
+            content: screen.content
         )
+        .environmentObject(navigation)
+        // Per screen, not around the NavigationStack: a state-driven reader there stops path pushes rendering.
+        .momoScreenLayout()
     }
 }
 
@@ -190,24 +206,19 @@ private struct OverplayHost: View {
             BottomSheetView(
                 header: item.header ?? .title(),
                 isSurface: item.isSurface,
-                barrierDismissible: item.barrierDismissible
+                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(snackBar: snackBar, bottomInset: safeAreaBottomInset() + Spacing.S)
+                SnackBarView(snackBar: snackBar, bottomInset: navigator.snackBarBottomInset())
                     .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
-}