@momo-kits/native-kits 0.162.2-beta.26-debug → 0.162.2-beta.27-debug

package/ios/SuggestAction/SuggestAction.swift

@@ -1,97 +0,0 @@
-import SwiftUI
-import Foundation
-
-public struct SuggestAction: View {
-    @Environment(\.appTheme) private var theme
-
-    private let message: String
-    private let buttonTitle: String
-    private let boldMessage: String
-    private let image: String
-    private let visible: Bool
-    private let onClose: () -> Void
-    private let onPressButton: () -> Void
-
-    public init(
-        message: String,
-        buttonTitle: String,
-        boldMessage: String = "",
-        image: String = "",
-        visible: Bool = false,
-        onClose: @escaping () -> Void = {},
-        onPressButton: @escaping () -> Void = {}
-    ) {
-        self.message = message
-        self.buttonTitle = buttonTitle
-        self.boldMessage = boldMessage
-        self.image = image
-        self.visible = visible
-        self.onClose = onClose
-        self.onPressButton = onPressButton
-    }
-
-    // Builds an attributed string with `boldMessage` (case-insensitive) emphasized.
-    private var annotatedMessage: AttributedString {
-        let baseFont = Font.system(size: scaleSize(TypographyStyle.bodyDefaultRegular.fontSize), weight: .regular)
-        var attributed = AttributedString(message)
-        attributed.font = baseFont
-
-        guard !boldMessage.isEmpty,
-              let range = message.range(of: boldMessage, options: .caseInsensitive)
-        else {
-            return attributed
-        }
-
-        if let boldRange = Range(range, in: attributed) {
-            attributed[boldRange].font = Font.system(
-                size: scaleSize(TypographyStyle.bodyDefaultRegular.fontSize),
-                weight: .bold
-            )
-        }
-        return attributed
-    }
-
-    public var body: some View {
-        Group {
-            if visible {
-                HStack(spacing: 0) {
-                    if !image.isEmpty {
-                        ImageView(image)
-                            .frame(width: 32, height: 32)
-                            .clipShape(RoundedRectangle(cornerRadius: Radius.XS, style: .continuous))
-                        Spacer().frame(width: Spacing.S)
-                    }
-
-                    Text(annotatedMessage)
-                        .foregroundColor(theme.colors.text.default)
-                        .frame(maxWidth: .infinity, alignment: .leading)
-                        .padding(.trailing, Spacing.M)
-
-                    Button(
-                        title: buttonTitle,
-                        action: { onPressButton() },
-                        type: .tonal,
-                        size: .small,
-                        isFull: false
-                    )
-
-                    Spacer().frame(width: Spacing.S)
-
-                    Icon(source: "navigation_close", size: 24, color: theme.colors.text.default)
-                        .contentShape(Rectangle())
-                        .onTapGesture { onClose() }
-                }
-                .padding(Spacing.M)
-                .frame(maxWidth: .infinity)
-                .background(
-                    RoundedRectangle(cornerRadius: Radius.S, style: .continuous)
-                        .fill(theme.colors.background.surface)
-                )
-                .clipShape(RoundedRectangle(cornerRadius: Radius.S, style: .continuous))
-                .shadow(color: theme.colors.text.default.opacity(0.12), radius: 8, x: 0, y: 4)
-                .transition(.opacity)
-            }
-        }
-        .animation(.easeInOut, value: visible)
-    }
-}

package/ios/TabView/TabView.swift

@@ -1,530 +0,0 @@
-import SwiftUI
-
-// ---------------------------------------------------------------------------
-// Style enums (prefixed with `Tab` to avoid collisions with existing public
-// types like ButtonSize / InputSize / TagColor)
-// ---------------------------------------------------------------------------
-
-public enum TabViewType {
-    case `default`
-    case card
-}
-
-public enum TabViewDirection {
-    case row
-    case column
-}
-
-// ---------------------------------------------------------------------------
-// Data model — mirrors Compose `TabViewItem`
-// ---------------------------------------------------------------------------
-
-public struct TabViewItem {
-    public let title: String
-    public let icon: String?
-    public let renderIcon: ((Bool) -> AnyView)?
-    public let showDot: Bool
-    public let dotSize: DotSize
-    public let badgeValue: String?
-    public let accessibilityLabel: String?
-    public let content: AnyView
-
-    public init(
-        title: String,
-        icon: String? = nil,
-        renderIcon: ((Bool) -> AnyView)? = nil,
-        showDot: Bool = false,
-        dotSize: DotSize = .small,
-        badgeValue: String? = nil,
-        accessibilityLabel: String? = nil,
-        @ViewBuilder content: () -> some View
-    ) {
-        self.title = title
-        self.icon = icon
-        self.renderIcon = renderIcon
-        self.showDot = showDot
-        self.dotSize = dotSize
-        self.badgeValue = badgeValue
-        self.accessibilityLabel = accessibilityLabel
-        self.content = AnyView(content())
-    }
-
-    /// Convenience init for tabs without slot content (Compose default `content = {}`).
-    public init(
-        title: String,
-        icon: String? = nil,
-        renderIcon: ((Bool) -> AnyView)? = nil,
-        showDot: Bool = false,
-        dotSize: DotSize = .small,
-        badgeValue: String? = nil,
-        accessibilityLabel: String? = nil
-    ) {
-        self.init(
-            title: title,
-            icon: icon,
-            renderIcon: renderIcon,
-            showDot: showDot,
-            dotSize: dotSize,
-            badgeValue: badgeValue,
-            accessibilityLabel: accessibilityLabel,
-            content: { EmptyView() }
-        )
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Public component — named `MomoTabView` to avoid shadowing SwiftUI.TabView
-// ---------------------------------------------------------------------------
-
-public struct MomoTabView: View {
-    @Environment(\.appTheme) private var theme
-
-    private let tabs: [TabViewItem]
-    private let type: TabViewType
-    private let scrollable: Bool
-    private let fitContent: Bool
-    private let selectedColor: Color?
-    private let unselectedColor: Color?
-    private let direction: TabViewDirection
-    private let userScrollEnabled: Bool
-    private let onPressTabItem: (Int) -> Void
-    private let onPageSelected: (Int) -> Void
-
-    @State private var selectedIndex: Int
-
-    public init(
-        tabs: [TabViewItem],
-        initialPage: Int = 0,
-        type: TabViewType = .default,
-        scrollable: Bool = false,
-        fitContent: Bool = false,
-        selectedColor: Color? = nil,
-        unselectedColor: Color? = nil,
-        direction: TabViewDirection = .row,
-        userScrollEnabled: Bool = true,
-        onPressTabItem: @escaping (Int) -> Void = { _ in },
-        onPageSelected: @escaping (Int) -> Void = { _ in }
-    ) {
-        self.tabs = tabs
-        self.type = type
-        self.scrollable = scrollable
-        self.fitContent = fitContent
-        self.selectedColor = selectedColor
-        self.unselectedColor = unselectedColor
-        self.direction = direction
-        self.userScrollEnabled = userScrollEnabled
-        self.onPressTabItem = onPressTabItem
-        self.onPageSelected = onPageSelected
-        let start = tabs.isEmpty ? 0 : min(max(initialPage, 0), tabs.count - 1)
-        _selectedIndex = State(initialValue: start)
-    }
-
-    private var resolvedSelectedColor: Color { selectedColor ?? theme.colors.primary }
-    private var resolvedUnselectedColor: Color { unselectedColor ?? theme.colors.text.default }
-
-    public var body: some View {
-        if tabs.isEmpty {
-            EmptyView()
-        } else {
-            VStack(spacing: 0) {
-                tabBar
-
-                if fitContent {
-                    tabs[safe: selectedIndex]?.content
-                        .frame(maxWidth: .infinity)
-                } else {
-                    pager
-                }
-            }
-            .frame(maxWidth: .infinity)
-        }
-    }
-
-    // MARK: - Tab bar dispatch
-
-    @ViewBuilder
-    private var tabBar: some View {
-        switch type {
-        case .card:
-            CardTabBar(
-                tabs: tabs,
-                selectedIndex: selectedIndex,
-                selectedColor: resolvedSelectedColor,
-                unselectedColor: resolvedUnselectedColor,
-                direction: direction,
-                onPress: onTabPressed
-            )
-        case .default:
-            if scrollable {
-                ScrollableTabBar(
-                    tabs: tabs,
-                    selectedIndex: selectedIndex,
-                    selectedColor: resolvedSelectedColor,
-                    unselectedColor: resolvedUnselectedColor,
-                    direction: direction,
-                    onPress: onTabPressed
-                )
-            } else {
-                DefaultTabBar(
-                    tabs: tabs,
-                    selectedIndex: selectedIndex,
-                    selectedColor: resolvedSelectedColor,
-                    unselectedColor: resolvedUnselectedColor,
-                    direction: direction,
-                    onPress: onTabPressed
-                )
-            }
-        }
-    }
-
-    // MARK: - Pager content
-
-    @ViewBuilder
-    private var pager: some View {
-        if userScrollEnabled {
-            SwiftUI.TabView(selection: $selectedIndex) {
-                ForEach(tabs.indices, id: \.self) { index in
-                    tabs[index].content
-                        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
-                        .tag(index)
-                }
-            }
-            .tabViewStyle(.page(indexDisplayMode: .never))
-            .frame(maxWidth: .infinity, maxHeight: .infinity)
-            .onChange(of: selectedIndex) { newValue in
-                onPageSelected(newValue)
-            }
-        } else {
-            tabs[safe: selectedIndex]?.content
-                .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
-        }
-    }
-
-    // MARK: - Selection
-
-    private func onTabPressed(_ index: Int) {
-        onPressTabItem(index)
-        withAnimation(.easeInOut(duration: 0.2)) {
-            selectedIndex = index
-        }
-        if fitContent || !userScrollEnabled {
-            onPageSelected(index)
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Default fixed-width tab bar (equal-width items + animated underline)
-// ---------------------------------------------------------------------------
-
-private struct DefaultTabBar: View {
-    @Environment(\.appTheme) private var theme
-
-    let tabs: [TabViewItem]
-    let selectedIndex: Int
-    let selectedColor: Color
-    let unselectedColor: Color
-    let direction: TabViewDirection
-    let onPress: (Int) -> Void
-
-    var body: some View {
-        GeometryReader { geo in
-            let itemWidth = tabs.isEmpty ? 0 : geo.size.width / CGFloat(tabs.count)
-            let indicatorWidth = max(itemWidth - Spacing.XS * 2, 0)
-            let indicatorX = itemWidth * CGFloat(selectedIndex) + Spacing.XS
-
-            ZStack(alignment: .bottomLeading) {
-                HStack(spacing: 0) {
-                    ForEach(tabs.indices, id: \.self) { index in
-                        TabItemView(
-                            tab: tabs[index],
-                            active: selectedIndex == index,
-                            selectedColor: selectedColor,
-                            unselectedColor: unselectedColor,
-                            direction: direction,
-                            scrollable: false,
-                            onPress: { onPress(index) }
-                        )
-                        .frame(maxWidth: .infinity)
-                    }
-                }
-
-                UnstyledRoundedRectangle(topLeft: Radius.XXS, topRight: Radius.XXS)
-                    .fill(selectedColor)
-                    .frame(width: indicatorWidth, height: 2)
-                    .offset(x: indicatorX)
-                    .animation(.easeInOut(duration: 0.2), value: selectedIndex)
-            }
-            .frame(maxWidth: .infinity)
-            .background(theme.colors.background.surface)
-            .overlay(
-                Rectangle()
-                    .stroke(theme.colors.border.default, lineWidth: 0.5)
-            )
-        }
-        .frame(height: barHeight(direction))
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Scrollable tab bar (wrap-width items, horizontal scroll, animated underline)
-// ---------------------------------------------------------------------------
-
-private struct ScrollableTabBar: View {
-    @Environment(\.appTheme) private var theme
-
-    let tabs: [TabViewItem]
-    let selectedIndex: Int
-    let selectedColor: Color
-    let unselectedColor: Color
-    let direction: TabViewDirection
-    let onPress: (Int) -> Void
-
-    @State private var frames: [Int: CGRect] = [:]
-
-    var body: some View {
-        ScrollViewReader { proxy in
-            ScrollView(.horizontal, showsIndicators: false) {
-                ZStack(alignment: .bottomLeading) {
-                    HStack(spacing: 0) {
-                        ForEach(tabs.indices, id: \.self) { index in
-                            TabItemView(
-                                tab: tabs[index],
-                                active: selectedIndex == index,
-                                selectedColor: selectedColor,
-                                unselectedColor: unselectedColor,
-                                direction: direction,
-                                scrollable: true,
-                                onPress: { onPress(index) }
-                            )
-                            .background(
-                                GeometryReader { g in
-                                    Color.clear.preference(
-                                        key: TabFramePreferenceKey.self,
-                                        value: [index: g.frame(in: .named("scrollableTabBar"))]
-                                    )
-                                }
-                            )
-                            .id(index)
-                        }
-                    }
-
-                    if let frame = frames[selectedIndex] {
-                        UnstyledRoundedRectangle(topLeft: Radius.XXS, topRight: Radius.XXS)
-                            .fill(selectedColor)
-                            .frame(width: max(frame.width - Spacing.XS * 2, 0), height: 2)
-                            .offset(x: frame.minX + Spacing.XS)
-                            .animation(.easeInOut(duration: 0.25), value: selectedIndex)
-                    }
-                }
-                .coordinateSpace(name: "scrollableTabBar")
-                .onPreferenceChange(TabFramePreferenceKey.self) { value in
-                    frames.merge(value) { _, new in new }
-                }
-            }
-            .frame(height: barHeight(direction))
-            .background(theme.colors.background.surface)
-            .overlay(
-                Rectangle()
-                    .stroke(theme.colors.border.default, lineWidth: 0.5)
-            )
-            .onChange(of: selectedIndex) { index in
-                withAnimation { proxy.scrollTo(index, anchor: .center) }
-            }
-        }
-    }
-}
-
-private struct TabFramePreferenceKey: PreferenceKey {
-    static var defaultValue: [Int: CGRect] = [:]
-    static func reduce(value: inout [Int: CGRect], nextValue: () -> [Int: CGRect]) {
-        value.merge(nextValue()) { _, new in new }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Card tab bar
-// ---------------------------------------------------------------------------
-
-private struct CardTabBar: View {
-    @Environment(\.appTheme) private var theme
-
-    let tabs: [TabViewItem]
-    let selectedIndex: Int
-    let selectedColor: Color
-    let unselectedColor: Color
-    let direction: TabViewDirection
-    let onPress: (Int) -> Void
-
-    var body: some View {
-        HStack(alignment: .bottom, spacing: 0) {
-            ForEach(tabs.indices, id: \.self) { index in
-                let tab = tabs[index]
-                let isActive = selectedIndex == index
-                let iconColor = isActive ? selectedColor : unselectedColor
-
-                cardItem(tab: tab, isActive: isActive, iconColor: iconColor)
-                    .frame(maxWidth: .infinity)
-                    .frame(height: isActive ? 44 : 40)
-                    .background(isActive ? theme.colors.background.surface : theme.colors.background.tonal)
-                    .clipShape(UnstyledRoundedRectangle(topLeft: Radius.M, topRight: Radius.M))
-                    .contentShape(Rectangle())
-                    .onTapGesture { onPress(index) }
-            }
-        }
-        .frame(maxWidth: .infinity)
-        .padding(.top, Spacing.XS)
-    }
-
-    @ViewBuilder
-    private func cardItem(tab: TabViewItem, isActive: Bool, iconColor: Color) -> some View {
-        HStack(spacing: 0) {
-            if let renderIcon = tab.renderIcon {
-                renderIcon(isActive)
-                Spacer().frame(width: Spacing.XS)
-            } else if let icon = tab.icon {
-                Icon(source: icon, size: 18, color: iconColor)
-                Spacer().frame(width: Spacing.XS)
-            }
-            MomoText(
-                tab.title,
-                typography: isActive ? .headerSSemibold : .bodyDefaultRegular,
-                color: isActive ? selectedColor : unselectedColor
-            )
-            .lineLimit(1)
-
-            tabBadge(tab)
-        }
-        .padding(.horizontal, Spacing.S)
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Shared tab item (Default + Scrollable bars)
-// ---------------------------------------------------------------------------
-
-private struct TabItemView: View {
-    let tab: TabViewItem
-    let active: Bool
-    let selectedColor: Color
-    let unselectedColor: Color
-    let direction: TabViewDirection
-    let scrollable: Bool
-    let onPress: () -> Void
-
-    private var textColor: Color { active ? selectedColor : unselectedColor }
-    private var textStyle: TypographyStyle { active ? .headerSSemibold : .bodyDefaultRegular }
-
-    var body: some View {
-        Group {
-            if direction == .column {
-                columnBody
-            } else {
-                rowBody
-            }
-        }
-        .contentShape(Rectangle())
-        .onTapGesture { onPress() }
-    }
-
-    @ViewBuilder
-    private var columnBody: some View {
-        VStack(spacing: 0) {
-            ZStack(alignment: .topTrailing) {
-                if let renderIcon = tab.renderIcon {
-                    renderIcon(active)
-                } else if let icon = tab.icon {
-                    Icon(source: icon, size: 24, color: textColor)
-                }
-                badgeOverlay
-            }
-            if tab.icon != nil || tab.renderIcon != nil {
-                Spacer().frame(height: Spacing.XXS)
-            }
-            MomoText(tab.title, typography: textStyle, color: textColor)
-                .lineLimit(1)
-        }
-        .frame(height: 68)
-        .padding(.horizontal, Spacing.S)
-    }
-
-    @ViewBuilder
-    private var rowBody: some View {
-        HStack(spacing: 0) {
-            if let renderIcon = tab.renderIcon {
-                renderIcon(active)
-                Spacer().frame(width: Spacing.XS)
-            } else if let icon = tab.icon {
-                Icon(source: icon, size: 18, color: textColor)
-                Spacer().frame(width: Spacing.XS)
-            }
-            MomoText(tab.title, typography: textStyle, color: textColor)
-                .lineLimit(1)
-            tabBadge(tab)
-        }
-        .frame(height: 48)
-        .padding(.horizontal, Spacing.M)
-    }
-
-    @ViewBuilder
-    private var badgeOverlay: some View {
-        if tab.showDot {
-            BadgeDot(size: tab.dotSize)
-                .offset(x: 4, y: -4)
-        } else if let badge = tab.badgeValue, !badge.isEmpty {
-            Badge(label: badge)
-                .offset(x: 4, y: -4)
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-
-private func barHeight(_ direction: TabViewDirection) -> CGFloat {
-    direction == .column ? 68 : 48
-}
-
-@ViewBuilder
-private func tabBadge(_ tab: TabViewItem) -> some View {
-    if tab.showDot {
-        Spacer().frame(width: Spacing.XS)
-        BadgeDot(size: tab.dotSize)
-    } else if let badge = tab.badgeValue, !badge.isEmpty {
-        Spacer().frame(width: Spacing.XS)
-        Badge(label: badge)
-    }
-}
-
-/// A rectangle rounded only on the top corners (mirrors Compose top-only radius).
-private struct UnstyledRoundedRectangle: Shape {
-    let topLeft: CGFloat
-    let topRight: CGFloat
-
-    func path(in rect: CGRect) -> Path {
-        var path = Path()
-        let tl = min(topLeft, min(rect.width, rect.height) / 2)
-        let tr = min(topRight, min(rect.width, rect.height) / 2)
-        path.move(to: CGPoint(x: rect.minX, y: rect.maxY))
-        path.addLine(to: CGPoint(x: rect.minX, y: rect.minY + tl))
-        path.addArc(
-            center: CGPoint(x: rect.minX + tl, y: rect.minY + tl),
-            radius: tl, startAngle: .degrees(180), endAngle: .degrees(270), clockwise: false
-        )
-        path.addLine(to: CGPoint(x: rect.maxX - tr, y: rect.minY))
-        path.addArc(
-            center: CGPoint(x: rect.maxX - tr, y: rect.minY + tr),
-            radius: tr, startAngle: .degrees(270), endAngle: .degrees(0), clockwise: false
-        )
-        path.addLine(to: CGPoint(x: rect.maxX, y: rect.maxY))
-        path.closeSubpath()
-        return path
-    }
-}
-
-private extension Array {
-    subscript(safe index: Int) -> Element? {
-        indices.contains(index) ? self[index] : nil
-    }
-}