@momo-kits/native-kits 0.167.1-duo.21 → 0.167.1-duo.22-debug

package/ios/Navigation/Component/HeaderRight.swift

@@ -191,38 +191,64 @@ struct Toolkit: View {
         return json["response"]
     }
 
+    private typealias MaxApiRequest = (MaxApi, [String: Any?], @escaping ([String: Any?]?) -> Void) -> Void
+
+    /// Through `composeApi` while the host still passes one, else `maxApi` (Compose `IMaxApi`).
+    /// Hosts may answer off the main thread, so the response is handed back on it.
+    private func request(
+        _ funcName: String,
+        _ params: [String: Any],
+        maxApi maxApiRequest: MaxApiRequest,
+        onResponse: @escaping (Any?) -> Void = { _ in }
+    ) {
+        if let composeApi = environment.composeApi {
+            _ = composeApi.request(funcName: funcName, params: params) { response in
+                let value = parseResponse(response)
+                DispatchQueue.main.async { onResponse(value) }
+            }
+        } else if let maxApi = environment.maxApi {
+            maxApiRequest(maxApi, params.mapValues { $0 as Any? }) { data in
+                let value = data?["response"] ?? nil
+                DispatchQueue.main.async { onResponse(value) }
+            }
+        }
+    }
+
     // MARK: Actions
 
     private func loadFavoriteState() {
-        _ = environment.composeApi?.request(
-            funcName: "isFavoriteApp",
-            params: ["code": apiValue(context?.appCode)]
+        request(
+            "isFavoriteApp",
+            ["code": apiValue(context?.appCode)],
+            maxApi: { $0.isFavoriteApp($1, callback: $2) }
         ) { response in
-            isFavorite = parseResponse(response) as? Bool == true
+            isFavorite = response as? Bool == true
         }
     }
 
     private func onPressShortcut() {
-        _ = environment.composeApi?.request(
-            funcName: "onToolAction",
-            params: ["item": ["key": "onFavorite"], "context": contextMap]
+        request(
+            "onToolAction",
+            ["item": ["key": "onFavorite"], "context": contextMap],
+            maxApi: { $0.onToolAction($1, callback: $2) }
         ) { response in
-            if let result = parseResponse(response) as? [String: Any], result["success"] as? Bool == true {
+            if let result = response as? [String: Any], result["success"] as? Bool == true {
                 isFavorite.toggle()
             }
         }
     }
 
     private func onPressMore() {
-        _ = environment.composeApi?.request(
-            funcName: "showTools",
-            params: [
+        request(
+            "showTools",
+            [
                 "useSystemTools": headerRight.useSystemTools,
                 "tools": headerRight.tools.map { $0.toMap() },
                 "context": contextMap
-            ]
+            ],
+            maxApi: { $0.showTools($1, callback: $2) }
         ) { response in
-            if let tool = parseResponse(response) as? String {
+            if let tool = response as? String {
                 headerRight.toolCallback?(tool)
             }
         }
@@ -230,23 +256,26 @@ struct Toolkit: View {
 
     private func onPressHelpCenter() {
         guard context != nil else { return }
-        _ = environment.composeApi?.request(
-            funcName: "showHelpCenter",
-            params: [
+        request(
+            "showHelpCenter",
+            [
                 "appId": apiValue(context?.appId),
                 "code": apiValue(context?.appCode),
                 "name": apiValue(context?.appName),
                 "icon": apiValue(context?.appIcon),
                 "description": apiValue(context?.description)
-            ]
-        ) { _ in }
+            ],
+            maxApi: { $0.showHelpCenter($1, callback: $2) }
+        )
     }
 
     private func onPressClose() {
         if headerRight.useCloseIcon {
             environment.requestDismiss()
+        } else if let composeApi = environment.composeApi {
+            _ = composeApi.request(funcName: "dismissAll", params: nil) { _ in }
         } else {
-            _ = environment.composeApi?.request(funcName: "dismissAll", params: nil) { _ in }
+            environment.maxApi?.dismissAll(completion: nil)
         }
     }
 

package/ios/Navigation/Component/SnackBar.swift

@@ -50,6 +50,7 @@ public struct SnackBar {
 /// Self-animating container. Slides the content up on appear, schedules an
 /// auto-dismiss after `duration`, and animates out before removing the overplay.
 struct SnackBarView: View {
+    let overplayId: UUID
     let snackBar: SnackBar
     /// Distance from the window bottom to the top of the screen's footer, or the navigation bar
     /// inset without one (Compose's `footerHeight` offset).
@@ -121,7 +122,7 @@ struct SnackBarView: View {
             offsetY = max(contentHeight, 200) + bottomInset
         }
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
-            navigator.finishOverplayDismiss()
+            navigator.finishOverplayDismiss(id: overplayId)
         }
     }
 
@@ -133,7 +134,7 @@ struct SnackBarView: View {
         guard let duration = snackBar.duration else { return }
         let workItem = DispatchWorkItem {
             // Only auto-dismiss if this snack bar is still the active overplay.
-            if navigator.overplay?.type == .snackBar {
+            if navigator.overplay?.id == overplayId {
                 navigator.hideSnackBar()
             }
         }

package/ios/Navigation/ModalScreen.swift

@@ -10,6 +10,7 @@
 import SwiftUI
 
 struct ModalScreen<Content: View>: View {
+    let overplayId: UUID
     let barrierDismissible: Bool
     let content: () -> Content
 
@@ -74,7 +75,7 @@ struct ModalScreen<Content: View>: View {
             contentOpacity = 0
         }
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
-            navigator.finishOverplayDismiss()
+            navigator.finishOverplayDismiss(id: overplayId)
         }
     }
 }

package/ios/Navigation/NavigationContainer.swift

@@ -168,12 +168,13 @@ private struct OverplayHost: View {
         // the Navigator before the item is removed (mirrors Compose's overplay).
         switch item.type {
         case .modal:
-            ModalScreen(barrierDismissible: item.barrierDismissible) {
+            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,
@@ -186,7 +187,7 @@ private struct OverplayHost: View {
             .id(item.id)
         case .snackBar:
             if let snackBar = item.snackBar {
-                SnackBarView(snackBar: snackBar, bottomInset: navigator.snackBarBottomInset())
+                SnackBarView(overplayId: item.id, snackBar: snackBar, bottomInset: navigator.snackBarBottomInset())
                     .id(item.id)
             }
         }

package/ios/Navigation/Navigator.swift

@@ -238,20 +238,19 @@ public final class Navigator: ObservableObject {
             // 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
+            replaceOverplay(with: nil)
             guard popScreen() else {
                 callback?()
                 return
             }
             popStep(remaining: remaining - 1, callback: callback)
-        } else if overplay != nil {
+        } else if let closing = overplay?.id {
             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.finishOverplayDismiss(id: closing)
                 self.popStep(remaining: remaining - 1, callback: callback)
             }
         } else {
@@ -302,6 +301,11 @@ public final class Navigator: ObservableObject {
     }
 
     public func onBackSafe(callback: (() -> Void)? = nil) {
+        // An open modal or bottom sheet takes the back first (their BackHandler in Compose).
+        if let overplay, overplay.type != .snackBar {
+            pop(1, callback: callback)
+            return
+        }
         let latest = currentScreen()
         if let tabBackHandler, tabBackHandler.screenId == -1 || tabBackHandler.screenId == latest?.id {
             tabBackHandler.handler()
@@ -420,14 +424,13 @@ public final class Navigator: ObservableObject {
         barrierDismissible: Bool = true,
         onDismiss: (() -> Void)? = nil
     ) {
-        overplayDismissHandler = nil
-        overplay = OverplayItem(
+        replaceOverplay(with: OverplayItem(
             type: .modal,
             content: { AnyView(content()) },
             barrierDismissible: barrierDismissible,
             onDismiss: onDismiss,
             screenId: entries.last?.id
-        )
+        ))
     }
 
     public func showBottomSheet<V: View>(
@@ -440,8 +443,7 @@ public final class Navigator: ObservableObject {
         useBottomInset: Bool = true,
         footer: (() -> AnyView)? = nil
     ) {
-        overplayDismissHandler = nil
-        overplay = OverplayItem(
+        replaceOverplay(with: OverplayItem(
             type: .bottomSheet,
             content: { AnyView(content()) },
             barrierDismissible: barrierDismissible,
@@ -452,20 +454,19 @@ public final class Navigator: ObservableObject {
             useBottomInset: useBottomInset,
             footer: footer,
             screenId: entries.last?.id
-        )
+        ))
     }
 
     /// Mirrors Compose's `showSnackBar(snackBar:)`.
     public func showSnackBar(_ snackBar: SnackBar, onDismiss: (() -> Void)? = nil) {
-        overplayDismissHandler = nil
-        overplay = OverplayItem(
+        replaceOverplay(with: OverplayItem(
             type: .snackBar,
             content: { AnyView(EmptyView()) },
             barrierDismissible: false,
             onDismiss: onDismiss,
             snackBar: snackBar,
             screenId: entries.last?.id
-        )
+        ))
     }
 
     // MARK: Overplay dismissal
@@ -480,10 +481,23 @@ public final class Navigator: ObservableObject {
     /// `hardClearAfterDismiss`). Called by a component once its exit animation
     /// has completed.
     public func finishOverplayDismiss() {
-        let dismissCallback = overplay?.onDismiss
+        replaceOverplay(with: nil)
+    }
+
+    /// Same, but only while `id` is still the overplay: an exit that ends after a newer overplay
+    /// took its place must not take that one down.
+    public func finishOverplayDismiss(id: UUID) {
+        guard overplay?.id == id else { return }
+        replaceOverplay(with: nil)
+    }
+
+    /// A replaced overplay counts as dismissed (Compose disposes it), so its `onDismiss` fires once,
+    /// whether it was still closing or not.
+    private func replaceOverplay(with item: OverplayItem?) {
+        let replaced = overplay
         overplayDismissHandler = nil
-        overplay = nil
-        dismissCallback?()
+        overplay = item
+        replaced?.onDismiss?()
     }
 
     public func hideOverplay() {

package/ios/Navigation/StackScreen.swift

@@ -116,7 +116,6 @@ public struct StackScreen<Content: View>: View {
     @State private var isBottomTabRoot: Bool = false
     @State private var headerHide: CGFloat = 0
     @State private var lastScrollOffset: CGFloat = 0
-    @State private var headerSettle: Task<Void, Never>?
     @State private var footerHeight: CGFloat = 0
 
     @Environment(\.applicationEnvironment) private var appEnv
@@ -126,9 +125,7 @@ public struct StackScreen<Content: View>: View {
     @Environment(\.appTheme) private var theme
     @OptionalEnvironmentObject private var navigation: Navigation?
 
-    // Auto-tracking state (Compose's `remember { ScreenTrackingState() }` + the once-computed action).
-    @State private var trackingState = ScreenTrackingState()
-    @State private var trackingAction: String = ScreenTracker.getLastScreenName() != nil ? "push" : "back"
+    @State private var tracking: Task<Void, Never>?
 
     /// Compose's `headerOpacity()`: 0 over a banner or transparent header, 1 once the bar is opaque.
     private var opacity: CGFloat {
@@ -189,25 +186,21 @@ public struct StackScreen<Content: View>: View {
             return
         }
         headerHide = min(max(headerHide + delta, 0), layout.headerHeight)
-        settleHeaderWhenScrollStops()
-    }
-
-    /// A half-shown header settles fully in or out. SwiftUI before iOS 18 reports no scroll
-    /// phase, so the scroll counts as ended once the offset stops changing.
-    private func settleHeaderWhenScrollStops() {
-        headerSettle?.cancel()
-        headerSettle = Task { @MainActor in
-            try? await Task.sleep(nanoseconds: 150_000_000)
-            guard !Task.isCancelled else { return }
-            let height = layout.headerHeight
-            // within the first header height the header still sits on the content
-            guard scrollOffset >= height, headerHide > 0, headerHide < height else { return }
-            withAnimation(.easeOut(duration: 0.2)) {
-                headerHide = headerHide > height / 2 ? height : 0
-            }
+    }
+
+    /// A half-shown header settles fully in or out once the scroll comes to rest.
+    private func settleHeader() {
+        let height = layout.headerHeight
+        // within the first header height the header still sits on the content
+        guard useQuickReturn, scrollOffset >= height, headerHide > 0, headerHide < height else { return }
+        withAnimation(.easeOut(duration: 0.2)) {
+            headerHide = headerHide > height / 2 ? height : 0
         }
     }
 
+    /// Compose snaps the animated search fully in or out when the scroll stops.
+    private var searchSnapDistance: CGFloat? { inputSearchType == .animated ? HEADER_HEIGHT : nil }
+
     private var keyboardSize: CGFloat { useAvoidKeyboard ? max(keyboardHeight, 0) : 0 }
 
     /// What the footer, tab bar or home indicator takes from the bottom of the window, gap included.
@@ -338,35 +331,50 @@ public struct StackScreen<Content: View>: View {
         }
         .onAppear(perform: reportBottomObstruction)
         .onChange(of: bottomObstruction) { _ in reportBottomObstruction() }
-        .task(id: screenName) {
+        .onAppear(perform: startTracking)
+        .onChange(of: screenName) { _ in startTracking() }
+        .onDisappear { tracking?.cancel() }
+    }
+
+    /// Compose tracks from a `LaunchedEffect` with `remember`ed state, so every visit — first show, a
+    /// pop back, a tab switch — starts over with fresh state. A covered hosting controller keeps its
+    /// `@State` and doesn't re-run `.task`, so the run hangs off appear / disappear instead.
+    private func startTracking() {
+        tracking?.cancel()
+        let state = ScreenTrackingState()
+        let action = ScreenTracker.getLastScreenName() != nil ? "push" : "back"
+        let maxApi = appEnv.maxApi
+        let context = appEnv.applicationContext
+        let screenName = screenName
+        tracking = Task { @MainActor in
             ScreenTracker.trackScreenNavigated(
-                maxApi: appEnv.maxApi,
-                context: appEnv.applicationContext,
+                maxApi: maxApi,
+                context: context,
                 screenName: screenName,
-                action: trackingAction,
-                state: trackingState
+                action: action,
+                state: state
             )
             do {
                 try await Task.sleep(nanoseconds: 2_000_000_000)
             } catch {
                 return
             }
-            let loadTime = ScreenTracker.now() - trackingState.time
+            let loadTime = ScreenTracker.now() - state.time
             ScreenTracker.trackScreenDisplayed(
-                maxApi: appEnv.maxApi,
-                context: appEnv.applicationContext,
+                maxApi: maxApi,
+                context: context,
                 screenName: screenName,
                 duration: loadTime,
-                state: trackingState
+                state: state
             )
-            let interactionTime = ScreenTracker.now() - trackingState.time
+            let interactionTime = ScreenTracker.now() - state.time
             ScreenTracker.trackScreenInteracted(
-                maxApi: appEnv.maxApi,
-                context: appEnv.applicationContext,
+                maxApi: maxApi,
+                context: context,
                 screenName: screenName,
                 duration: interactionTime - loadTime,
                 totalDuration: interactionTime,
-                state: trackingState
+                state: state
             )
         }
     }
@@ -385,6 +393,8 @@ public struct StackScreen<Content: View>: View {
                     scrollToTopCallback: scrollToTopCallback,
                     animatedSearchInset: animatedSearchInset,
                     bottomInset: duoTabBarInsets.overlay,
+                    snapDistance: searchSnapDistance,
+                    onScrollIdle: settleHeader,
                     content: { animatedHeroBody(animatedHeader) }
                 )
                 .edgesIgnoringSafeArea(.all)
@@ -419,6 +429,8 @@ public struct StackScreen<Content: View>: View {
                     scrollToTopCallback: scrollToTopCallback,
                     animatedSearchInset: animatedSearchInset,
                     bottomInset: duoTabBarInsets.overlay,
+                    snapDistance: searchSnapDistance,
+                    onScrollIdle: settleHeader,
                     content: { duoInsetContent }
                 )
                 .edgesIgnoringSafeArea(.all)
@@ -438,6 +450,8 @@ public struct StackScreen<Content: View>: View {
                     scrollToTopCallback: scrollToTopCallback,
                     topInset: layout.headerHeight - layout.insets.top,
                     bottomInset: duoTabBarInsets.overlay,
+                    snapDistance: searchSnapDistance,
+                    onScrollIdle: settleHeader,
                     content: content
                 )
 
@@ -483,6 +497,8 @@ public struct StackScreen<Content: View>: View {
                 scrollToTopCallback: scrollToTopCallback,
                 animatedSearchInset: animatedSearchInset,
                 bottomInset: duoTabBarInsets.overlay,
+                snapDistance: searchSnapDistance,
+                onScrollIdle: settleHeader,
                 content: content
             )
         }
@@ -563,11 +579,30 @@ private struct StackScreenContent<Content: View>: View {
     var topInset: CGFloat = 0
     /// Room for a bar that overlays the content (iPhone Duo floating tab bar).
     var bottomInset: CGFloat = 0
+    /// Compose's animated-search snap: a scroll that comes to rest part way through this distance
+    /// finishes the move, up or back down.
+    var snapDistance: CGFloat? = nil
+    var onScrollIdle: (() -> Void)? = nil
     let content: () -> Content
 
     private let topAnchorID = "stack_screen_top_anchor"
     private let scrollSpace = "stack_screen_scroll_space"
 
+    @State private var scrollView = WeakScrollView()
+
+    private func scrollDidRest() {
+        onScrollIdle?()
+        guard let snapDistance, scrollOffset > 0, scrollOffset < snapDistance,
+              let scrollView = scrollView.value else { return }
+        // UIKit, not `ScrollViewProxy.scrollTo`: SwiftUI keeps re-applying a scrollTo target while the
+        // content above it resizes, which this content does as the search inset shrinks with the scroll
+        let target = scrollOffset < snapDistance / 2 ? 0 : snapDistance
+        scrollView.setContentOffset(
+            CGPoint(x: scrollView.contentOffset.x, y: target - scrollView.adjustedContentInset.top),
+            animated: true
+        )
+    }
+
     var body: some View {
         if scrollable {
             ScrollViewReader { proxy in
@@ -587,6 +622,7 @@ private struct StackScreenContent<Content: View>: View {
                                         scrollOffset = -minY
                                     }
                             })
+                            .background(ScrollViewProbe { scrollView.value = $0 })
 
                         if animatedSearchInset + topInset > 0 {
                             Spacer().frame(height: animatedSearchInset + topInset)
@@ -602,6 +638,7 @@ private struct StackScreenContent<Content: View>: View {
                     }
                 }
                 .coordinateSpace(name: scrollSpace)
+                .modifier(ScrollRest(offset: scrollOffset, onRest: scrollDidRest))
                 // Status-bar tap (MoMoStatusBarTap swizzle) scrolls to top and notifies the consumer.
                 .onReceive(NotificationCenter.default.publisher(for: MoMoStatusBarTap.notificationName)) { _ in
                     withAnimation {
@@ -618,6 +655,74 @@ private struct StackScreenContent<Content: View>: View {
     }
 }
 
+private final class WeakScrollView {
+    weak var value: UIScrollView?
+}
+
+/// Finds the UIScrollView behind the enclosing SwiftUI `ScrollView` once placed in its content.
+private struct ScrollViewProbe: UIViewRepresentable {
+    let found: (UIScrollView) -> Void
+
+    func makeUIView(context: Context) -> Probe { Probe(found: found) }
+
+    func updateUIView(_ uiView: Probe, context: Context) {}
+
+    final class Probe: UIView {
+        let found: (UIScrollView) -> Void
+
+        init(found: @escaping (UIScrollView) -> Void) {
+            self.found = found
+            super.init(frame: .zero)
+            isUserInteractionEnabled = false
+        }
+
+        required init?(coder: NSCoder) { nil }
+
+        override func didMoveToWindow() {
+            super.didMoveToWindow()
+            var view = superview
+            while let current = view, !(current is UIScrollView) { view = current.superview }
+            if let scrollView = view as? UIScrollView { found(scrollView) }
+        }
+    }
+}
+
+/// Calls `onRest` once the scroll comes to rest. Scroll phases need iOS 18; before that the scroll
+/// counts as ended once the offset stops changing, which a finger held still also looks like.
+private struct ScrollRest: ViewModifier {
+    let offset: CGFloat
+    let onRest: () -> Void
+
+    @State private var pending: Task<Void, Never>?
+
+    func body(content: Content) -> some View {
+        #if compiler(>=6.0)
+        if #available(iOS 18.0, *) {
+            content.onScrollPhaseChange { _, phase in
+                if phase == .idle { onRest() }
+            }
+        } else {
+            debounced(content)
+        }
+        #else
+        debounced(content)
+        #endif
+    }
+
+    private func debounced(_ content: Content) -> some View {
+        content
+            .onChange(of: offset) { _ in
+                pending?.cancel()
+                pending = Task { @MainActor in
+                    try? await Task.sleep(nanoseconds: 150_000_000)
+                    guard !Task.isCancelled else { return }
+                    onRest()
+                }
+            }
+            .onDisappear { pending?.cancel() }
+    }
+}
+
 // MARK: - Animated search header
 
 /// Compose's `SearchAnimated`: the search slides from below the header (scroll 0) up into the bar
@@ -633,6 +738,7 @@ private struct SearchAnimatedHeader: View {
 
     @Environment(\.screenLayout) private var layout
     @Environment(\.appTheme) private var theme
+    @OptionalEnvironmentObject private var navigator: Navigator?
 
     var body: some View {
         let scroll = max(scrollOffset, 0)
@@ -650,12 +756,20 @@ private struct SearchAnimatedHeader: View {
             ? Spacing.M
             : headerRightWidth + (hasHeaderRight ? Spacing.M * 2 : Spacing.M))
 
-        let top = min(max(maxTop - scroll, minTop), maxTop)
-        let start = min(max(minSide + scroll, minSide), maxStart)
-        let end = min(max(minSide + scroll, minSide), maxEnd)
+        // one progress for all three, so the field docks with its final insets and never covers the toolkit
+        let progress = min(scroll / HEADER_HEIGHT, 1)
+        let top = maxTop + (minTop - maxTop) * progress
+        let start = minSide + (maxStart - minSide) * progress
+        let end = minSide + (maxEnd - minSide) * progress
 
         // padding, not a Spacer: on the iPhone Duo status bar row the collapsed top is above the safe area
-        InputSearch(props: headerSearchProps(props, scroll: scroll, layout: layout, theme: theme))
+        InputSearch(props: headerSearchProps(
+            props,
+            scroll: scroll,
+            layout: layout,
+            theme: theme,
+            pop: navigator.map { navigator in { navigator.pop() } }
+        ))
             .frame(height: HEADER_HEIGHT)
             .padding(.leading, start)
             .padding(.trailing, end)