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

package/ios/Application/FloatingButton.swift

@@ -0,0 +1,174 @@
+import SwiftUI
+import Combine
+
+public enum FABSize {
+    case small
+    case `default`
+    /// Backward-compatible alias for older iOS call sites. Compose names this
+    /// size `DEFAULT`.
+    case large
+}
+
+public enum FABPosition {
+    case end
+    /// Backward-compatible alias for older iOS call sites. Compose names this
+    /// position `END`.
+    case right
+    case center
+}
+
+public struct FabProps {
+    public let icon: String?
+    public let iconColor: Color?
+    public let label: String?
+    public let onClick: (() -> Void)?
+    public let containerColor: Color?
+    public let size: FABSize?
+    public let iconSize: CGFloat?
+    public let scrollOffset: CGFloat?
+    public let position: FABPosition?
+    public let bottomPadding: CGFloat?
+    public let renderComponent: (() -> AnyView)?
+    
+    public init(
+        icon: String? = nil,
+        iconColor: Color? = .white,
+        label: String? = nil,
+        onClick: (() -> Void)? = nil,
+        containerColor: Color? = Colors.primary,
+        size: FABSize? = .default,
+        iconSize: CGFloat? = nil,
+        scrollOffset: CGFloat? = nil,
+        position: FABPosition? = .end,
+        bottomPadding: CGFloat? = nil,
+        renderComponent: (() -> AnyView)? = nil
+    ) {
+        self.icon = icon
+        self.iconColor = iconColor
+        self.label = label
+        self.onClick = onClick
+        self.containerColor = containerColor
+        self.size = size
+        self.iconSize = iconSize
+        self.scrollOffset = scrollOffset
+        self.position = position
+        self.bottomPadding = bottomPadding
+        self.renderComponent = renderComponent
+    }
+}
+
+public struct FloatingButton: View {
+    @State private var lastScrollOffset: CGFloat = 0
+    @State private var isExpanded: Bool = false
+    @State private var internalScrollOffset: CGFloat = 0
+    @State private var showText: Bool = true
+    @State private var fullWidth: CGFloat? = nil
+    @State private var currentWidth: CGFloat = 0
+    @State private var lastDirection: String? = nil
+    
+    private let props: FabProps
+    private var keyboardOffset: CGFloat
+    private var scrollOffset: CGFloat
+    private var bottomPadding: CGFloat { props.bottomPadding ?? 12 + keyboardOffset}
+    private var position: FABPosition? { props.position ?? .end }
+    private var containerColor: Color? { props.containerColor ?? Colors.primary }
+    private var iconColor: Color? { props.iconColor ?? .white }
+    private var label: String? { props.label }
+    private var icon: String? { props.icon }
+    private var size: FABSize? { props.size }
+    private var iconSize: CGFloat? { props.iconSize ?? defaultIconSize}
+    private var onClick: (() -> Void)? { props.onClick }
+    private var renderComponent: (() -> AnyView)? { props.renderComponent }
+    
+    public init(props: FabProps, keyboardOffset: CGFloat = 0, scrollOffset: CGFloat = 0) {
+        self.props = props
+        self.keyboardOffset = keyboardOffset
+        self.scrollOffset = scrollOffset
+    }
+    
+    private var height: CGFloat {
+        if(iconSize == nil) {
+            size == .small ? 36 : 48
+        }
+        else {
+            iconSize!
+        }
+    }
+    
+    private var minWidth: CGFloat {
+        size == .small ? 36 : 48
+    }
+    
+    private var defaultIconSize: CGFloat {
+        size == .small ? 12 : 24
+    }
+    
+    public var body: some View {
+        Group {
+            if ((icon?.isEmpty) == nil), let render = renderComponent {
+                render()
+            } else {
+                content
+            }
+        }
+        .onTapGesture {
+            onClick?()
+        }
+        .padding(Spacing.M)
+        .frame(height: height + (Spacing.M * 2))
+        .background(containerColor)
+        .cornerRadius(100)
+        .padding(.bottom, bottomPadding)
+        .frame(alignment: position == .center ? .center : .trailing)
+        .onAppear {
+            internalScrollOffset = scrollOffset
+            isExpanded = label != nil
+        }
+        .onReceive(Just(scrollOffset)) { newValue in
+            let direction = newValue > internalScrollOffset ? "down" : "up"
+
+            if direction != lastDirection {
+                lastDirection = direction
+                if direction == "down" {
+                    withAnimation(.easeOut(duration: 0.1)) {
+                        isExpanded = false
+                    }
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+                        showText = false
+                    }
+                } else {
+                    showText = true
+                    withAnimation(.easeIn(duration: 0.1)) {
+                        isExpanded = true
+                    }
+                    
+                }
+            }
+        }
+    }
+    
+    private var content: some View {
+        HStack(spacing: 0) {
+            ImageView(icon ?? "")
+                .scaledToFit()
+                .frame(width: iconSize, height: iconSize)
+                .foregroundColor(iconColor)
+            
+            if let label = label {
+                if showText {
+                    Spacer().frame(width: 8)
+                    MomoText(label, typography: .actionDefaultBold, color: .white, maxLines: 1)
+                        .background(
+                            GeometryReader { geo in
+                                Color.clear.onAppear {
+                                    fullWidth = geo.size.width
+                                }
+                            }
+                        )
+                        .opacity(isExpanded ? 1 : 0)
+                }
+            }
+
+        }
+    }
+}

package/ios/Application/HeaderRight.swift

@@ -0,0 +1,306 @@
+import SwiftUI
+import Foundation
+
+public struct HeaderRightData {
+    var useShortcut: Bool
+    var useMore: Bool
+    var tools: [ToolGroup]
+    var toolCallback: ((String) -> Void)?
+    var useSystemTools: Bool
+    
+    public init(
+        useShortcut: Bool = false,
+        useMore: Bool = false,
+        tools: [ToolGroup] = [],
+        toolCallback: ((String) -> Void)? = nil,
+        useSystemTools: Bool = true
+    ) {
+        self.useShortcut = useShortcut
+        self.useMore = useMore
+        self.tools = tools
+        self.toolCallback = toolCallback
+        self.useSystemTools = useSystemTools
+    }
+}
+
+public struct Tool {
+    var key: String
+    var icon: String
+    var showBadge: Bool
+    var name: [String: String]
+    var showRightIcon: Bool
+    
+    public init(
+        key: String,
+        icon: String,
+        name: [String: String] = [:],
+        showBadge: Bool = false,
+        showRightIcon: Bool = true
+    ) {
+        self.key = key
+        self.icon = icon
+        self.showBadge = showBadge
+        self.name = name
+        self.showRightIcon = showRightIcon
+    }
+    
+    func toMap() -> [String: Any] {
+        return [
+            "key": key,
+            "icon": icon,
+            "showBadge": showBadge,
+            "name": name,
+            "showRightIcon": showRightIcon
+        ]
+    }
+}
+
+public struct ToolGroup {
+    var title: [String: String]
+    var items: [Tool]
+    
+    public init(
+        title: [String: String] = [:],
+        items: [Tool]
+    ) {
+        self.title = title
+        self.items = items
+    }
+    
+    func toMap() -> [String: Any] {
+        return [
+            "title": title,
+            "items": items.map { $0.toMap() }
+        ]
+    }
+}
+
+struct NavigationButtonConfig {
+    let icon: String
+    let onPress: () -> Void
+}
+
+// MARK: - Components
+public struct HeaderRight: View {
+    public init(headerRight: HeaderRightData? = nil, tintColor: Color? = nil) {
+        self.headerRight = headerRight
+        self.tintColor = tintColor
+    }
+    var headerRight: HeaderRightData?
+    var tintColor: Color? = nil
+    
+    public var body: some View {
+        HStack(alignment: .center) {
+            ToolkitHeaderRight(headerRight: headerRight, tintColor: tintColor)
+        }
+    }
+}
+
+struct ToolkitHeaderRight: View {
+    var headerRight: HeaderRightData?
+    var tintColor: Color?
+    @State private var isFavorite: Bool = false
+    @State private var isLoading: Bool = false
+    @EnvironmentObject private var environment: ApplicationEnvironment
+    
+    // MARK: - Actions
+    private func onPressShortcut() {
+        // onToolAction needs the app context (appId/code) so the host knows which app to (un)favorite;
+        // without it the favorite is a no-op. Mirrors onPressMore below and the Compose HeaderRight.
+        let context = environment.applicationContext
+        environment.composeApi?.request(
+            funcName: "onToolAction",
+            params: [
+                "item": ["key": "onFavorite"],
+                "context": [
+                    "appId": context?.appId,
+                    "code": context?.appCode,
+                    "name": context?.appName,
+                    "icon": context?.appIcon,
+                    "description": context?.description,
+                    "support": context?.support,
+                    "toolkitConfig": context?.toolkitConfig,
+                    "providerId": context?.providerId,
+                    "permissions": context?.permissions
+                ]
+            ]
+        ) { _ in
+            isFavorite.toggle()
+        }
+    }
+    
+    private func onPressHelpCenter() {
+        let context = environment.applicationContext
+        let paramMap: [String: Any] = [
+            "appId": context?.appId,
+            "code": context?.appCode,
+            "name": context?.appName,
+            "icon": context?.appIcon,
+            "description": context?.description
+        ]
+        environment.composeApi?.request(
+            funcName: "showHelpCenter",
+            params: paramMap
+        ) { _ in }
+    }
+    
+    private func onPressClose() {
+        environment.composeApi?.request(
+            funcName: "dismissAll",
+            params: ""
+        ) { _ in }
+    }
+    
+    private func onPressMore() {
+        let context = environment.applicationContext
+        let params: [String: Any] = [
+            "useSystemTools": headerRight?.useSystemTools,
+            "tools": headerRight?.tools.map { $0.toMap() } ?? [],
+            "context": [
+                "appId": context?.appId,
+                "code": context?.appCode,
+                "name": context?.appName,
+                "icon": context?.appIcon,
+                "description": context?.description,
+                "support": context?.support,
+                "toolkitConfig": context?.toolkitConfig,
+                "providerId": context?.providerId,
+                "permissions": context?.permissions
+            ]
+        ]
+        environment.composeApi?.request(
+            funcName: "showTools",
+            params: params
+        ) { response in
+            do {
+                if let jsonData = response.data(using: .utf8),
+                   let json = try JSONSerialization.jsonObject(with: jsonData) as? [String: Any],
+                   let toolResponse = json["response"] as? String {
+                    headerRight?.toolCallback?(toolResponse)
+                }
+            } catch {
+                print("Error parsing response:", error)
+            }
+        }
+    }
+    
+    // Load the current favorite state on appear so the star reflects reality; without this the button
+    // always renders "not favorited" until the user taps it. Mirrors the Compose LaunchedEffect.
+    private func loadFavoriteState() {
+        let context = environment.applicationContext
+        environment.composeApi?.request(
+            funcName: "isFavoriteApp",
+            params: ["code": context?.appCode]
+        ) { response in
+            guard let data = response.data(using: .utf8),
+                  let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+                return
+            }
+            isFavorite = (json["response"] as? Bool) ?? false
+        }
+    }
+
+    private func getNavigationButtonConfig() -> NavigationButtonConfig {
+        let totalTools = headerRight?.tools.reduce(0) { $0 + $1.items.count } ?? 0
+        var icon = isFavorite ? "pin_star_checked" : "pin_star"
+        var onClickHandler: () -> Void = onPressShortcut
+        
+        if totalTools > 1 || headerRight?.useMore == true {
+            icon = "navigation_more_icon"
+            onClickHandler = onPressMore
+        } else if totalTools == 1, let singleTool = headerRight?.tools.first?.items.first {
+            icon = singleTool.icon
+            onClickHandler = {
+                headerRight?.toolCallback?(singleTool.key)
+            }
+        }
+        
+        return NavigationButtonConfig(icon: icon, onPress: onClickHandler)
+    }
+    
+    var body: some View {
+        let backgroundButtonColor: Color = tintColor == Colors.black01 ? Colors.black20.opacity(0.6) : Colors.black01.opacity(0.6)
+        let borderColor: Color = tintColor == Colors.black01 ? Colors.black01.opacity(0.2) : Colors.black20.opacity(0.2)
+        let navButtonConfig = getNavigationButtonConfig()
+        let showBadge = headerRight?.tools.contains { group in
+            group.items.contains { $0.showBadge }
+        } ?? false
+        
+        HStack(alignment: .center, spacing: 0) {
+            if headerRight?.useShortcut == true {
+                NavigationButton(
+                    disabled: isLoading,
+                    icon: navButtonConfig.icon,
+                    showBadge: showBadge,
+                    onClick: navButtonConfig.onPress,
+                    tintColor: tintColor
+                )
+            }
+            
+            HStack(alignment: .center, spacing: 0) {
+                Icon(source: "help_center", size: 20, color: tintColor ?? Colors.black17)
+                    .padding(4)
+                    .onTapGesture {
+                        onPressHelpCenter()
+                    }
+                
+                Rectangle()
+                    .fill(tintColor ?? Colors.black20)
+                    .frame(width: 0.5, height: 12)
+                
+                Icon(source: "16_basic_home", size: 20, color: tintColor ?? Colors.black17)
+                    .padding(4)
+                    .onTapGesture {
+                        onPressClose()
+                    }
+            }
+            .frame(width: 65, height: 28)
+            .background(backgroundButtonColor)
+            .cornerRadius(14)
+            .overlay(
+                RoundedRectangle(cornerRadius: 14)
+                    .stroke(borderColor, lineWidth: 0.2)
+            )
+            .padding(.leading, Spacing.S)
+        }
+        .onAppear {
+            loadFavoriteState()
+        }
+    }
+}
+
+struct NavigationButton: View {
+    var disabled: Bool
+    var icon: String
+    var showBadge: Bool
+    var onClick: () -> Void
+    var tintColor: Color?
+    
+    var body: some View {
+        let backgroundButtonColor: Color = tintColor == Colors.black01 ? Colors.black20.opacity(0.6) : Colors.black01.opacity(0.6)
+        let borderColor: Color = tintColor == Colors.black01 ? Colors.black01.opacity(0.2) : Colors.black20.opacity(0.2)
+        
+        ZStack {
+            Circle()
+                .fill(backgroundButtonColor)
+                .overlay(
+                    Circle()
+                        .stroke(borderColor, lineWidth: 0.2)
+                )
+            
+            Icon(source: icon, size: 16, color: tintColor)
+            
+            if showBadge {
+                BadgeDot(size: .small)
+                    .offset(x: -2, y: -2)
+                    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topTrailing)
+            }
+        }
+        .frame(width: 28, height: 28)
+        .onTapGesture {
+            if !disabled {
+                onClick()
+            }
+        }
+    }
+}

package/ios/Application/LanguageSource.swift

@@ -0,0 +1,93 @@
+// File: ios/Application/LanguageSource.swift
+// Created At: 2026-07-29 10:00:00 +07:00
+// Created By: AI
+// AI Agent: Claude Code
+// Model: claude-opus-5[1m]
+
+// AI-GENERATED START: observe the host app's active language so Localize can follow it
+import Foundation
+
+/// Read-only view of the host app's active language, plus change delivery.
+/// Values handed to `onChange` are already normalized to `Localize.VI` / `Localize.EN`.
+public protocol LanguageSource: AnyObject {
+    var currentLanguage: String { get }
+    /// `onChange` may be invoked on any thread; `Localize` dedupes and hops to main.
+    func startObserving(_ onChange: @escaping (String) -> Void)
+    func stopObserving()
+}
+
+/// Reads the language the MoMo host app persists in `UserDefaults`. All three host writers
+/// (the `RNResource` RN bridge, `JSONLocalization`, and the KMP `LocalizationProvider`) write the
+/// same key on `UserDefaults.standard` in-process, so KVO on it sees every one of them.
+public final class UserDefaultsLanguageSource: NSObject, LanguageSource {
+    public static let defaultKey = "language"
+
+    private let defaults: UserDefaults
+    private let key: String
+    private var onChange: ((String) -> Void)?
+    private var isObserving = false
+    private var kvoContext = 0
+
+    /// - Note: `key` must not contain `.` — `forKeyPath:` would read it as a key path.
+    public init(
+        defaults: UserDefaults = .standard,
+        key: String = UserDefaultsLanguageSource.defaultKey
+    ) {
+        self.defaults = defaults
+        self.key = key
+        super.init()
+    }
+
+    public var currentLanguage: String {
+        Localize.normalize(defaults.string(forKey: key))
+    }
+
+    public func startObserving(_ onChange: @escaping (String) -> Void) {
+        guard !isObserving else { return }
+        isObserving = true
+        self.onChange = onChange
+        defaults.addObserver(self, forKeyPath: key, options: [.new], context: &kvoContext)
+        // Safety net for writes KVO can miss (e.g. `removeObject`). Double delivery is free:
+        // `Localize` dedupes before touching `@Published`.
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(emit),
+            name: UserDefaults.didChangeNotification,
+            object: defaults
+        )
+    }
+
+    public func stopObserving() {
+        guard isObserving else { return }
+        isObserving = false
+        defaults.removeObserver(self, forKeyPath: key, context: &kvoContext)
+        NotificationCenter.default.removeObserver(
+            self,
+            name: UserDefaults.didChangeNotification,
+            object: defaults
+        )
+        onChange = nil
+    }
+
+    deinit {
+        stopObserving()
+    }
+
+    public override func observeValue(
+        forKeyPath keyPath: String?,
+        of object: Any?,
+        change: [NSKeyValueChangeKey: Any]?,
+        context: UnsafeMutableRawPointer?
+    ) {
+        guard context == &kvoContext else {
+            super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
+            return
+        }
+        emit()
+    }
+
+    @objc private func emit() {
+        onChange?(currentLanguage)
+    }
+}
+// AI-GENERATED END: observe the host app's active language so Localize can follow it