@momo-kits/native-kits 0.162.21 → 0.162.22

package/ios/Application/ApplicationEnvironment.swift

@@ -41,11 +41,13 @@ public class ApplicationEnvironment: ObservableObject {
     let applicationContext: MiniAppContext?
     let composeApi: KitComposeApi?
     let config: KitConfig?
-    
-    public init(applicationContext: MiniAppContext? = nil, composeApi: KitComposeApi? = nil, config: KitConfig? = nil) {
+    let maxApi: MaxApi?
+
+    public init(applicationContext: MiniAppContext? = nil, composeApi: KitComposeApi? = nil, config: KitConfig? = nil, maxApi: MaxApi? = nil) {
         self.applicationContext = applicationContext
         self.composeApi = composeApi
         self.config = config
+        self.maxApi = maxApi
     }
 }
 

package/ios/Application/MaxApi.swift

@@ -0,0 +1,18 @@
+//
+//  MaxApi.swift
+//  MoMoUIKits
+//
+//  Swift mirror of the host-app bridge exposed on Kotlin as `vn.momo.maxapi.IMaxApi`
+//  (`LocalMaxApi`). `IMaxApi` itself is an external compiled dependency with no
+//  source in this repo, so this protocol intentionally exposes only the methods
+//  this kit's Kotlin source actually calls (`track`, `dismiss`, `getLanguage`) —
+//  not a full guess at IMaxApi's real surface.
+//
+
+import Foundation
+
+public protocol MaxApi {
+    func track(eventName: String, params: [String: Any?])
+    func dismiss(completion: (() -> Void)?)
+    func getLanguage(callback: @escaping ([String: Any?]?) -> Void)
+}

package/ios/Application/Navigation/NavigationContainer.swift

@@ -18,6 +18,7 @@ public struct NavigationContainer<Initial: View>: View {
 
     private let setNavigator: ((Navigator) -> Void)?
     private let composeApi: KitComposeApi?
+    private let maxApi: MaxApi?
 
     public init(
         initialScreenName: String = "",
@@ -26,6 +27,7 @@ public struct NavigationContainer<Initial: View>: View {
         applicationContext: MiniAppContext? = nil,
         composeApi: KitComposeApi? = nil,
         config: KitConfig? = nil,
+        maxApi: MaxApi? = nil,
         localize: Localize? = nil,
         setNavigator: ((Navigator) -> Void)? = nil
     ) {
@@ -40,11 +42,13 @@ public struct NavigationContainer<Initial: View>: View {
             wrappedValue: ApplicationEnvironment(
                 applicationContext: applicationContext,
                 composeApi: composeApi,
-                config: config
+                config: config,
+                maxApi: maxApi
             )
         )
         _localize = StateObject(wrappedValue: localize ?? Localize())
         self.composeApi = composeApi
+        self.maxApi = maxApi
         self.setNavigator = setNavigator
     }
 
@@ -80,12 +84,19 @@ public struct NavigationContainer<Initial: View>: View {
                 navigator.composeApi = composeApi
             }
             setNavigator?(navigator)
+            // Mirrors Compose's LaunchedEffect(maxApi, resolvedLocalize): host-reported
+            // language wins over the default "vi" only when it resolves to English.
+            maxApi?.getLanguage { data in
+                if parseLanguage(data) == Localize.EN {
+                    localize.changeLanguage(Localize.EN)
+                }
+            }
         }
     }
 
     @ViewBuilder
     private func screenView(for route: DynamicScreenRoute) -> some View {
-        if let screen = DynamicScreenRegistry.shared.getScreen(id: route.id) {
+        if let screen = navigator.registry.getScreen(id: route.id) {
             ScreenHost(screen: screen, navigator: navigator)
                 .navigationBarBackButtonHidden(true)
         } else {
@@ -95,7 +106,7 @@ public struct NavigationContainer<Initial: View>: View {
 
     @ViewBuilder
     private func screenView(forDialog route: DynamicDialogRoute) -> some View {
-        if let screen = DynamicScreenRegistry.shared.getScreen(id: route.id) {
+        if let screen = navigator.registry.getScreen(id: route.id) {
             ScreenHost(screen: screen, navigator: navigator)
         } else {
             EmptyView()
@@ -134,6 +145,7 @@ private struct ScreenHost: View {
             layoutOffset: options.layoutOffset,
             inputSearchProps: options.inputSearchProps,
             fabProps: options.fabProps,
+            screenName: screen.name,
             content: { screen.content() }
         )
     }
@@ -180,3 +192,9 @@ private func safeAreaBottomInset() -> CGFloat {
         .compactMap { ($0 as? UIWindowScene)?.keyWindow?.safeAreaInsets.bottom }
         .first ?? 0
 }
+
+private func parseLanguage(_ raw: [String: Any?]?) -> String? {
+    guard let response = (raw?["response"] as? String)?.trimmingCharacters(in: .whitespaces).lowercased(),
+          !response.isEmpty else { return nil }
+    return response.hasPrefix(Localize.EN) ? Localize.EN : Localize.VI
+}

package/ios/Application/Navigation/Navigator.swift

@@ -30,12 +30,10 @@ public struct DynamicScreen {
 }
 
 public final class DynamicScreenRegistry {
-    public static let shared = DynamicScreenRegistry()
-
     private var screens: [Int: DynamicScreen] = [:]
     private var idCounter: Int = 1
 
-    private init() {}
+    public init() {}
 
     @discardableResult
     public func register(
@@ -95,6 +93,11 @@ public final class Navigator: ObservableObject {
     @Published public var presented: DynamicDialogRoute?
     @Published public var overplay: OverplayItem?
 
+    /// Owned per-Navigator (mirrors Compose's `remember { DynamicScreenRegistry() }` +
+    /// disposal): screens registered by this navigator are released via ARC when the
+    /// navigator itself deallocates, instead of accumulating in a process-wide singleton.
+    public let registry = DynamicScreenRegistry()
+
     /// 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
@@ -111,7 +114,7 @@ public final class Navigator: ObservableObject {
         composeApi: KitComposeApi? = nil
     ) {
         self.composeApi = composeApi
-        self.rootRoute = DynamicScreenRegistry.shared.register(
+        self.rootRoute = registry.register(
             screenName: initialScreenName,
             content: initialContent,
             options: options
@@ -121,7 +124,7 @@ public final class Navigator: ObservableObject {
     // MARK: Stack
 
     public func push<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        let route = DynamicScreenRegistry.shared.register(
+        let route = registry.register(
             screenName: options?.screenName ?? "",
             content: { AnyView(content()) },
             options: options
@@ -134,7 +137,7 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        let route = DynamicScreenRegistry.shared.register(
+        let route = registry.register(
             screenName: screenName,
             content: { AnyView(content()) },
             options: options
@@ -145,7 +148,7 @@ public final class Navigator: ObservableObject {
     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)
+        registry.unregister(id: removed.id)
         push(content, options: options)
     }
 
@@ -156,15 +159,15 @@ public final class Navigator: ObservableObject {
     ) {
         guard !path.isEmpty else { return }
         let removed = path.removeLast()
-        DynamicScreenRegistry.shared.unregister(id: removed.id)
+        registry.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)
+        for route in path { registry.unregister(id: route.id) }
+        registry.unregister(id: rootRoute.id)
         path.removeAll()
-        let route = DynamicScreenRegistry.shared.register(
+        let route = registry.register(
             screenName: options?.screenName ?? "",
             content: { AnyView(content()) },
             options: options
@@ -177,10 +180,10 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        for route in path { DynamicScreenRegistry.shared.unregister(id: route.id) }
-        DynamicScreenRegistry.shared.unregister(id: rootRoute.id)
+        for route in path { registry.unregister(id: route.id) }
+        registry.unregister(id: rootRoute.id)
         path.removeAll()
-        let route = DynamicScreenRegistry.shared.register(
+        let route = registry.register(
             screenName: screenName,
             content: { AnyView(content()) },
             options: options
@@ -191,17 +194,16 @@ public final class Navigator: ObservableObject {
     public func pop(_ count: Int = 1, callback: (() -> Void)? = nil) {
         var remaining = count
         while remaining > 0 {
-            if overplay != nil {
+            if overplay?.type == .snackBar {
+                // 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
+                if !popScreen() { break }
+            } else 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)
+            } else if !popScreen() {
                 break
             }
             remaining -= 1
@@ -209,13 +211,32 @@ public final class Navigator: ObservableObject {
         callback?()
     }
 
+    /// Pops the topmost presented screen or stack entry. Returns `false` (and requests
+    /// a host dismiss) when there is nothing left to pop.
+    @discardableResult
+    private func popScreen() -> Bool {
+        if presented != nil {
+            let dismissedId = presented?.id
+            presented = nil
+            if let id = dismissedId { registry.unregister(id: id) }
+            return true
+        } else if !path.isEmpty {
+            let removed = path.removeLast()
+            registry.unregister(id: removed.id)
+            return true
+        } else {
+            composeApi?.requestCallback(funcName: "dismiss", params: nil, onResponse: nil)
+            return false
+        }
+    }
+
     public func popToRoot() {
-        for route in path { DynamicScreenRegistry.shared.unregister(id: route.id) }
+        for route in path { registry.unregister(id: route.id) }
         path.removeAll()
     }
 
     public func onBackSafe(callback: (() -> Void)? = nil) {
-        let latest = DynamicScreenRegistry.shared.latest()
+        let latest = registry.latest()
         if let onBack = latest?.options?.onBackHandler {
             onBack()
             return
@@ -256,7 +277,7 @@ public final class Navigator: ObservableObject {
     // MARK: Modal-style screen (vertical slide)
 
     public func present<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        let route = DynamicScreenRegistry.shared.register(
+        let route = registry.register(
             screenName: options?.screenName ?? "",
             content: { AnyView(content()) },
             options: options
@@ -269,7 +290,7 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        let route = DynamicScreenRegistry.shared.register(
+        let route = registry.register(
             screenName: screenName,
             content: { AnyView(content()) },
             options: options
@@ -279,7 +300,7 @@ public final class Navigator: ObservableObject {
 
     public func dismiss() {
         if let id = presented?.id {
-            DynamicScreenRegistry.shared.unregister(id: id)
+            registry.unregister(id: id)
         }
         presented = nil
     }

package/ios/Application/Navigation/Overplay/ModalScreen.swift

@@ -15,6 +15,7 @@ struct ModalScreen<Content: View>: View {
     let content: () -> Content
 
     @EnvironmentObject private var navigator: Navigator
+    @Environment(\.applicationEnvironment) private var appEnv
 
     @State private var scrimOpacity: CGFloat = 0
     @State private var contentScale: CGFloat = 0.8
@@ -38,6 +39,11 @@ struct ModalScreen<Content: View>: View {
         .onAppear {
             guard !didAppear else { return }
             didAppear = true
+            ScreenTracker.trackPopupDisplayed(
+                maxApi: appEnv.maxApi,
+                context: appEnv.applicationContext,
+                parentScreenName: ScreenTracker.getLastScreenName()
+            )
             navigator.registerOverplayDismiss { close() }
             open()
         }

package/ios/Application/Navigation/Tracking/ScreenTracker.swift

@@ -0,0 +1,117 @@
+//
+//  ScreenTracker.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `navigation/tracking/ScreenTracker.kt`. Pure
+//  logic, no platform dependency beyond the `MaxApi` bridge.
+//
+
+import Foundation
+
+public final class ScreenTrackingState {
+    public var time: Double = Date().timeIntervalSince1970 * 1000
+    public var releaseNavigated: Bool = false
+    public var releaseLoad: Bool = false
+    public var releaseInteraction: Bool = false
+    public var previousScreenName: String?
+    public var action: String = "push"
+
+    public init() {}
+}
+
+public enum ScreenTracker {
+    private static var lastScreenName: String?
+
+    public static func trackScreenNavigated(
+        maxApi: MaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        action: String,
+        state: ScreenTrackingState
+    ) {
+        guard !state.releaseNavigated else { return }
+
+        let previousScreen = lastScreenName
+        lastScreenName = screenName
+
+        var params = buildBaseParams(context: context, screenName: screenName)
+        params["pre_screen_name"] = previousScreen
+        params["state"] = "navigated"
+        params["action"] = action
+        maxApi?.track(eventName: "auto_screen_navigated", params: params)
+
+        state.releaseNavigated = true
+        state.previousScreenName = previousScreen
+    }
+
+    public static func trackScreenDisplayed(
+        maxApi: MaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        duration: Double,
+        state: ScreenTrackingState
+    ) {
+        guard !state.releaseLoad else { return }
+
+        var params = buildBaseParams(context: context, screenName: screenName)
+        params["state"] = "load"
+        params["duration"] = duration
+        maxApi?.track(eventName: "auto_screen_displayed", params: params)
+
+        state.releaseLoad = true
+    }
+
+    public static func trackScreenInteracted(
+        maxApi: MaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        duration: Double,
+        totalDuration: Double,
+        state: ScreenTrackingState
+    ) {
+        guard !state.releaseInteraction else { return }
+
+        var params = buildBaseParams(context: context, screenName: screenName)
+        params["state"] = "interaction"
+        params["duration"] = duration
+        params["total_duration"] = totalDuration
+        maxApi?.track(eventName: "auto_screen_interacted", params: params)
+
+        state.releaseInteraction = true
+    }
+
+    public static func trackPopupDisplayed(
+        maxApi: MaxApi?,
+        context: MiniAppContext?,
+        parentScreenName: String?
+    ) {
+        maxApi?.track(eventName: "auto_popup_displayed", params: [
+            "screen_name": parentScreenName,
+            "tracking_source": 1,
+            "app_id": context?.appId,
+            "feature_code": context?.appCode,
+            "kits_version": nil,
+            "component_name": "Modal"
+        ])
+    }
+
+    private static func buildBaseParams(
+        context: MiniAppContext?,
+        screenName: String,
+        componentName: String = "Screen"
+    ) -> [String: Any?] {
+        [
+            "app_id": context?.appId,
+            "feature_code": context?.appCode,
+            "screen_name": screenName,
+            "component_name": componentName,
+            "tracking_source": 1
+        ]
+    }
+
+    public static func getLastScreenName() -> String? { lastScreenName }
+
+    public static func reset() {
+        lastScreenName = nil
+    }
+}

package/ios/Application/StackScreen.swift

@@ -39,6 +39,7 @@ public struct StackScreen<Content: View>: View {
     var layoutOffset: CGFloat
     var inputSearchProps: InputSearchProps?
     var fabProps: FabProps?
+    var screenName: String = ""
     var content: () -> Content
 
     public init(
@@ -66,6 +67,7 @@ public struct StackScreen<Content: View>: View {
         layoutOffset: CGFloat = 56,
         inputSearchProps: InputSearchProps? = nil,
         fabProps: FabProps? = nil,
+        screenName: String = "",
         @ViewBuilder content: @escaping () -> Content
     ) {
         self.backgroundColor = backgroundColor
@@ -92,6 +94,7 @@ public struct StackScreen<Content: View>: View {
         self.layoutOffset = layoutOffset
         self.inputSearchProps = inputSearchProps
         self.fabProps = fabProps
+        self.screenName = screenName
         self.content = content
     }
 
@@ -100,6 +103,13 @@ public struct StackScreen<Content: View>: View {
     @State private var headerRightWidth: CGFloat = 0
     @State private var isBottomTabRoot: Bool = false
 
+    @Environment(\.applicationEnvironment) private var appEnv
+
+    // Auto-tracking state (mirrors Compose's `remember { ScreenTrackingState() }` +
+    // the once-computed push/back `action`).
+    @State private var trackingState = ScreenTrackingState()
+    @State private var trackingAction: String = ScreenTracker.getLastScreenName() != nil ? "push" : "back"
+
     /// Header background fade tied to scroll: 0 → transparent (over a hero image
     /// or transparent header), 1 → opaque surface with the drop shadow.
     private var scrollOpacity: CGFloat { min(scrollOffset / 114, 1) }
@@ -193,6 +203,37 @@ public struct StackScreen<Content: View>: View {
             // taps still reach buttons/fields while also dismissing the keyboard.
             .modifier(HideKeyboardOnTap(enabled: keyboardShouldPersistTaps))
         }
+        .task(id: screenName) {
+            ScreenTracker.trackScreenNavigated(
+                maxApi: appEnv.maxApi,
+                context: appEnv.applicationContext,
+                screenName: screenName,
+                action: trackingAction,
+                state: trackingState
+            )
+            do {
+                try await Task.sleep(nanoseconds: 2_000_000_000)
+            } catch {
+                return
+            }
+            let loadTime = Date().timeIntervalSince1970 * 1000 - trackingState.time
+            ScreenTracker.trackScreenDisplayed(
+                maxApi: appEnv.maxApi,
+                context: appEnv.applicationContext,
+                screenName: screenName,
+                duration: loadTime,
+                state: trackingState
+            )
+            let interactionTime = Date().timeIntervalSince1970 * 1000 - trackingState.time
+            ScreenTracker.trackScreenInteracted(
+                maxApi: appEnv.maxApi,
+                context: appEnv.applicationContext,
+                screenName: screenName,
+                duration: interactionTime - loadTime,
+                totalDuration: interactionTime,
+                state: trackingState
+            )
+        }
     }
 
     // MARK: - Header + content layer

package/ios/Badge/BadgeRibbon.swift

@@ -196,6 +196,86 @@ public struct BadgeRibbon: View {
     }
 }
 
+/// Ported from Compose's `RoundedBadgeRibbon` (BadgeRibbon.kt:164-326): a canvas-drawn
+/// ribbon shape sized to its text, mirrored per corner via scaleX/scaleY (never an actual
+/// rotation) — the label gets the same scale applied a second time so it stays right-reading
+/// while only the ribbon shape flips.
+public struct RoundedBadgeRibbon: View {
+    let text: String
+    let position: RibbonPosition
+
+    public init(text: String = "Label", position: RibbonPosition = .topLeft) {
+        self.text = text
+        self.position = position
+    }
+
+    private var scale: (x: CGFloat, y: CGFloat) {
+        switch position {
+        case .topLeft: return (-1, 1)
+        case .topRight: return (1, 1)
+        case .bottomRight: return (1, -1)
+        case .bottomLeft: return (-1, -1)
+        }
+    }
+
+    private var measuredTextSize: CGSize {
+        let fontSize = scaleSize(TypographyStyle.labelXsMedium.fontSize)
+        let font = UIFont.systemFont(ofSize: fontSize, weight: .medium)
+        return text.size(withAttributes: [.font: font])
+    }
+
+    public var body: some View {
+        let textSize = measuredTextSize
+        let minRibbonHeight = max(textSize.height * 1.2, 16)
+        let padding = minRibbonHeight / 4
+        let badgeHeight = minRibbonHeight + padding
+        let badgeWidth = max(textSize.width + padding * 2, 28)
+
+        ZStack {
+            Canvas { context, size in
+                let ribbonHeight = size.height - padding
+                let cornerRadius = (badgeHeight - padding) / 2
+                let mainColor = Colors.orange03
+                let tailColor = Colors.red01
+
+                let headWidth: CGFloat = 4
+                // Kotlin computes `leftSectionWidth` + `middleSectionWidth` here, but those
+                // cancel algebraically to `width - headWidth` — kept as the direct result.
+                let rightX = size.width - headWidth
+
+                let leftMiddlePath = RoundedCorners(topLeft: cornerRadius, topRight: 0, bottomLeft: cornerRadius, bottomRight: 0)
+                    .path(in: CGRect(x: 0, y: 0, width: rightX + 1, height: ribbonHeight))
+                context.fill(leftMiddlePath, with: .color(mainColor))
+
+                let headPath = RoundedCorners(topLeft: 0, topRight: cornerRadius, bottomLeft: 0, bottomRight: 0)
+                    .path(in: CGRect(x: rightX, y: 0, width: headWidth, height: ribbonHeight))
+                context.fill(headPath, with: .color(mainColor))
+
+                let halfHeadWidth = headWidth / 2
+                let tailStartX = rightX + headWidth - halfHeadWidth
+                let tailY = ribbonHeight
+                let tailHeight = padding
+
+                context.fill(
+                    Path(CGRect(x: tailStartX, y: tailY, width: halfHeadWidth, height: halfHeadWidth)),
+                    with: .color(mainColor)
+                )
+
+                let tailRightPath = RoundedCorners(topLeft: 0, topRight: tailHeight, bottomLeft: 0, bottomRight: tailHeight)
+                    .path(in: CGRect(x: tailStartX, y: tailY, width: halfHeadWidth, height: tailHeight))
+                context.fill(tailRightPath, with: .color(tailColor))
+            }
+
+            MomoText(text, typography: .labelXsMedium, color: Colors.black01, maxLines: 1)
+                .padding(.bottom, padding)
+                .padding(.horizontal, padding / 2)
+                .scaleEffect(x: scale.x, y: scale.y)
+        }
+        .frame(width: badgeWidth, height: badgeHeight)
+        .scaleEffect(x: scale.x, y: scale.y)
+    }
+}
+
 // MARK: - Constants
 private struct RibbonConstants {
     static let ribbonHeight: CGFloat = 20