@momo-kits/native-kits 0.162.2-debug → 0.162.2-sp.1

package/ios/DateTimePicker/DateTimePicker.swift

@@ -0,0 +1,210 @@
+import SwiftUI
+
+// MARK: - Constants
+
+private let datePickerHeight: CGFloat = 210
+private let datePickerWithLabelsHeight: CGFloat = 238
+
+// MARK: - DateTimePicker
+
+/// A wheel-style date/time picker matching Compose `DateTimePicker`.
+///
+/// The `format` string drives which columns are shown:
+/// - `DD` day, `MM` month, `YYYY` year, `HH` hour, `mm` minute.
+/// - `"HH:mm"` shows hour + minute; a lone `"HH"` switches the hour wheel to a
+///   12-hour clock with an AM/PM column.
+public struct DateTimePicker: View {
+    // MARK: Lifecycle
+
+    public init(
+        format: String = "DD-MM-YYYY",
+        minuteInterval: Int = 1,
+        selectedValue: Date? = nil,
+        minDate: Date? = nil,
+        maxDate: Date? = nil,
+        arrayLabelTime: [String] = [],
+        onChange: @escaping (Date) -> Void
+    ) {
+        self.format = format
+        self.minuteInterval = minuteInterval
+        self.selectedValue = selectedValue
+        self.minDate = minDate
+        self.maxDate = maxDate
+        self.arrayLabelTime = arrayLabelTime
+        self.onChange = onChange
+
+        let calendar = Calendar.current
+        let effectiveSelected = selectedValue ?? DateTimePickerUtils.getCurrentDateTime()
+        let effectiveMin = minDate ?? DateTimePickerUtils.createRelativeDate(years: -10)
+        let effectiveMax = maxDate ?? DateTimePickerUtils.createRelativeDate(years: 10)
+
+        // needCheckRange is true only when the caller supplied no bounds.
+        let needCheckRange = (minDate == nil && maxDate == nil)
+
+        let initialValue: Date
+        if !needCheckRange {
+            initialValue = effectiveSelected
+        } else if effectiveSelected < effectiveMin {
+            initialValue = effectiveMin
+        } else if effectiveSelected > effectiveMax {
+            initialValue = effectiveMax
+        } else {
+            initialValue = effectiveSelected
+        }
+
+        let comps = calendar.dateComponents([.year, .month, .day, .hour, .minute], from: initialValue)
+        self._currentData = State(initialValue: DateTimePickerData(
+            day: comps.day ?? 1,
+            month: comps.month ?? 1,
+            year: comps.year ?? 2000,
+            hour: comps.hour ?? 0,
+            minute: comps.minute ?? 0
+        ))
+
+        self.effectiveMinComponents = calendar.dateComponents([.year, .month, .day, .hour, .minute], from: effectiveMin)
+        self.effectiveMaxComponents = calendar.dateComponents([.year, .month, .day, .hour, .minute], from: effectiveMax)
+        self.needCheckRange = needCheckRange
+    }
+
+    // MARK: Public
+
+    public var body: some View {
+        let components = DateTimePickerUtils.getDateComponents(
+            format: format,
+            currentData: currentData,
+            minDate: effectiveMinComponents,
+            maxDate: effectiveMaxComponents,
+            minuteInterval: minuteInterval
+        )
+        let pickerHeight = arrayLabelTime.isEmpty ? datePickerHeight : datePickerWithLabelsHeight
+
+        return HStack(spacing: Spacing.M) {
+            ForEach(Array(components.enumerated()), id: \.offset) { index, component in
+                let hasLabel = index < arrayLabelTime.count && !arrayLabelTime[index].isEmpty
+
+                VStack(spacing: 0) {
+                    if hasLabel {
+                        MomoText(arrayLabelTime[index], typography: .actionSBold, color: Colors.text)
+                            .padding(.bottom, Spacing.S)
+                    }
+
+                    WheelPicker(
+                        name: component.name,
+                        data: component.data,
+                        selectedData: selectedDataFor(component.name),
+                        onChange: onWheelChange
+                    )
+                }
+                .frame(maxWidth: .infinity)
+            }
+        }
+        .frame(maxWidth: .infinity)
+        .frame(height: pickerHeight)
+        .background(Colors.background)
+        .padding(.horizontal, Spacing.M)
+        .onAppear { emitIfValid() }
+    }
+
+    // MARK: Internal
+
+    let format: String
+    let minuteInterval: Int
+    let selectedValue: Date?
+    let minDate: Date?
+    let maxDate: Date?
+    let arrayLabelTime: [String]
+    let onChange: (Date) -> Void
+
+    @State private var currentData: DateTimePickerData
+
+    private let effectiveMinComponents: DateComponents
+    private let effectiveMaxComponents: DateComponents
+    private let needCheckRange: Bool
+
+    private func selectedDataFor(_ name: String) -> String {
+        switch name {
+        case "day": return DateTimePickerUtils.paddingNum(currentData.day)
+        case "month": return DateTimePickerUtils.paddingNum(currentData.month)
+        case "year": return String(currentData.year)
+        case "hour": return DateTimePickerUtils.paddingNum(currentData.hour)
+        case "minute": return DateTimePickerUtils.paddingNum(currentData.minute)
+        case "timeMode": return currentData.timeMode
+        default: return ""
+        }
+    }
+
+    /// Mirrors Compose `onWheelChangeValue`: applies value and coerces day/month
+    /// to stay within the effective min/max bounds.
+    private func onWheelChange(_ name: String, _ value: String) {
+        var day = name == "day" ? (Int(value) ?? currentData.day) : currentData.day
+        var month = name == "month" ? (Int(value) ?? currentData.month) : currentData.month
+        let year = name == "year" ? (Int(value) ?? currentData.year) : currentData.year
+        let hour = name == "hour" ? (Int(value) ?? currentData.hour) : currentData.hour
+        let minute = name == "minute" ? (Int(value) ?? currentData.minute) : currentData.minute
+        let timeMode = name == "timeMode" ? value : currentData.timeMode
+
+        let maxYear = effectiveMaxComponents.year ?? year
+        let minYear = effectiveMinComponents.year ?? year
+        let maxMonth = effectiveMaxComponents.month ?? 12
+        let minMonth = effectiveMinComponents.month ?? 1
+        let maxDayBound = effectiveMaxComponents.day ?? 31
+        let minDayBound = effectiveMinComponents.day ?? 1
+
+        if name == "year" {
+            if year == maxYear {
+                month = min(max(month, 1), maxMonth)
+            } else if year == minYear {
+                month = min(max(month, minMonth), 12)
+            }
+        }
+
+        if name == "month" || name == "year" {
+            let maxDayOfMonth: Int
+            switch month {
+            case 4, 6, 9, 11: maxDayOfMonth = 30
+            case 2: maxDayOfMonth = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? 29 : 28
+            default: maxDayOfMonth = 31
+            }
+
+            if year == maxYear && month == maxMonth {
+                day = min(max(day, 1), maxDayBound)
+            } else if year == minYear && month == minMonth {
+                day = min(max(day, minDayBound), maxDayOfMonth)
+            } else if day > maxDayOfMonth {
+                day = maxDayOfMonth
+            }
+        }
+
+        currentData = DateTimePickerData(
+            day: day,
+            month: month,
+            year: year,
+            hour: hour,
+            minute: minute,
+            timeMode: timeMode
+        )
+        emitIfValid()
+    }
+
+    /// Emit `onChange` only when the assembled date is valid and (when bounds were
+    /// not supplied) within the effective min/max range. Mirrors the Compose
+    /// `snapshotFlow.mapNotNull` filter.
+    private func emitIfValid() {
+        guard let date = currentData.toDate() else { return }
+        if !needCheckRange {
+            onChange(date)
+            return
+        }
+        let calendar = Calendar.current
+        guard
+            let minDate = calendar.date(from: effectiveMinComponents),
+            let maxDate = calendar.date(from: effectiveMaxComponents)
+        else {
+            onChange(date)
+            return
+        }
+        if date >= minDate && date <= maxDate {
+            onChange(date)
+        }
+    }
+}

package/ios/DateTimePicker/DateTimePickerTypes.swift

@@ -0,0 +1,55 @@
+import Foundation
+
+// MARK: - PickerData
+
+/// Internal mutable representation of the picker's current selection.
+/// Mirrors Compose `PickerData`.
+public struct DateTimePickerData: Equatable {
+    public var day: Int
+    public var month: Int
+    public var year: Int
+    public var hour: Int
+    public var minute: Int
+    public var timeMode: String
+
+    public init(
+        day: Int,
+        month: Int,
+        year: Int,
+        hour: Int = 0,
+        minute: Int = 0,
+        timeMode: String = ""
+    ) {
+        self.day = day
+        self.month = month
+        self.year = year
+        self.hour = hour
+        self.minute = minute
+        self.timeMode = timeMode
+    }
+
+    /// Convert to a `DateComponents` based value. Returns `nil` if the date is invalid.
+    public func toDate(calendar: Calendar = Calendar.current) -> Date? {
+        var components = DateComponents()
+        components.year = year
+        components.month = month
+        components.day = day
+        components.hour = hour
+        components.minute = minute
+        components.second = 0
+        return calendar.date(from: components)
+    }
+}
+
+// MARK: - DateComponent
+
+/// A single wheel column descriptor. Mirrors Compose `DateComponent`.
+public struct DateTimePickerComponent: Equatable {
+    public let name: String
+    public let data: [String]
+
+    public init(name: String, data: [String]) {
+        self.name = name
+        self.data = data
+    }
+}

package/ios/DateTimePicker/DateTimePickerUtils.swift

@@ -0,0 +1,167 @@
+import Foundation
+
+// MARK: - DateTimePickerUtils
+
+/// Pure helper functions mirroring Compose `DateTimePickerUtils.kt`.
+public enum DateTimePickerUtils {
+
+    /// Time mode list for 12-hour clock (only-hour format).
+    public static let timeMode: [String] = ["AM", "PM"]
+
+    /// Pad a number with a leading zero if it's less than 10.
+    public static func paddingNum(_ num: Int) -> String {
+        return num > 9 ? String(num) : "0\(num)"
+    }
+
+    /// Format a `Date` into a string, matching Compose `formatLocalDateTime`.
+    public static func formatDate(
+        _ date: Date,
+        format: String = "yyyy-MM-dd HH:mm",
+        calendar: Calendar = Calendar.current
+    ) -> String {
+        let c = calendar.dateComponents([.year, .month, .day, .hour, .minute], from: date)
+        let year = c.year ?? 0
+        let month = c.month ?? 1
+        let day = c.day ?? 1
+        let hour = c.hour ?? 0
+        let minute = c.minute ?? 0
+
+        switch format {
+        case "yyyy-MM-dd HH:mm":
+            return "\(year)-\(paddingNum(month))-\(paddingNum(day)) \(paddingNum(hour)):\(paddingNum(minute))"
+        case "dd-MM-yyyy":
+            return "\(paddingNum(day))-\(paddingNum(month))-\(year)"
+        case "HH:mm":
+            return "\(paddingNum(hour)):\(paddingNum(minute))"
+        default:
+            return "\(year)-\(paddingNum(month))-\(paddingNum(day)) \(paddingNum(hour)):\(paddingNum(minute))"
+        }
+    }
+
+    /// Number of days in a given month/year.
+    private static func daysInMonth(year: Int, month: Int) -> Int {
+        switch month {
+        case 1, 3, 5, 7, 8, 10, 12: return 31
+        case 4, 6, 9, 11: return 30
+        case 2: return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? 29 : 28
+        default: return 31
+        }
+    }
+
+    /// Get a list of day strings constrained by min/max date.
+    public static func getDaysInMonth(
+        year: Int,
+        month: Int,
+        minDate: DateComponents,
+        maxDate: DateComponents
+    ) -> [String] {
+        let maxDay = daysInMonth(year: year, month: month)
+        var startDay = 1
+        var endDay = maxDay
+
+        if year == minDate.year && month == minDate.month {
+            startDay = minDate.day ?? 1
+        }
+        if year == maxDate.year && month == maxDate.month {
+            endDay = maxDate.day ?? maxDay
+        }
+
+        guard startDay <= endDay else { return [paddingNum(startDay)] }
+        return (startDay...endDay).map { paddingNum($0) }
+    }
+
+    /// Get a list of month strings constrained by min/max date for a year.
+    public static func getMonths(
+        minDate: DateComponents,
+        maxDate: DateComponents,
+        currentYear: Int
+    ) -> [String] {
+        var startMonth = 1
+        var endMonth = 12
+
+        if currentYear == minDate.year {
+            startMonth = minDate.month ?? 1
+        }
+        if currentYear == maxDate.year {
+            endMonth = maxDate.month ?? 12
+        }
+
+        guard startMonth <= endMonth else { return [paddingNum(startMonth)] }
+        return (startMonth...endMonth).map { paddingNum($0) }
+    }
+
+    /// Get a list of year strings between min and max date.
+    public static func getYears(minDate: DateComponents, maxDate: DateComponents) -> [String] {
+        let startYear = minDate.year ?? 0
+        let endYear = maxDate.year ?? 0
+        guard startYear <= endYear else { return [String(startYear)] }
+        return (startYear...endYear).map { String($0) }
+    }
+
+    /// Get a list of hours for either a 12-hour or 24-hour clock.
+    public static func getHours(hourMode: Int) -> [String] {
+        var hours: [String] = []
+        for i in 0..<hourMode {
+            let hour = hourMode == 12 ? i + 1 : i
+            hours.append(paddingNum(hour))
+        }
+        return hours
+    }
+
+    /// Get a list of minutes stepped by `interval`.
+    public static func getMinutes(interval: Int) -> [String] {
+        let step = max(1, interval)
+        var minutes: [String] = []
+        var min = 0
+        while min < 60 {
+            minutes.append(paddingNum(min))
+            min += step
+        }
+        return minutes
+    }
+
+    /// Today's date.
+    public static func getCurrentDateTime() -> Date {
+        return Date()
+    }
+
+    /// Create a date a certain number of years before/after now.
+    public static func createRelativeDate(years: Int, calendar: Calendar = Calendar.current) -> Date {
+        let now = Date()
+        return calendar.date(byAdding: .year, value: years, to: now) ?? now
+    }
+
+    /// Resolve the wheel columns from a format string. Mirrors Compose `getDateComponents`.
+    public static func getDateComponents(
+        format: String,
+        currentData: DateTimePickerData,
+        minDate: DateComponents,
+        maxDate: DateComponents,
+        minuteInterval: Int
+    ) -> [DateTimePickerComponent] {
+        let formatParts = format.split(whereSeparator: { !$0.isLetter }).map { String($0) }
+        let isOnlyHour = formatParts.count == 1 && formatParts[0] == "HH"
+
+        let dayData = getDaysInMonth(year: currentData.year, month: currentData.month, minDate: minDate, maxDate: maxDate)
+        let monthData = getMonths(minDate: minDate, maxDate: maxDate, currentYear: currentData.year)
+        let yearData = getYears(minDate: minDate, maxDate: maxDate)
+        let hourData = getHours(hourMode: isOnlyHour ? 12 : 24)
+        let minData = getMinutes(interval: minuteInterval)
+
+        var components: [DateTimePickerComponent] = []
+        for part in formatParts {
+            switch part {
+            case "DD": components.append(DateTimePickerComponent(name: "day", data: dayData))
+            case "MM": components.append(DateTimePickerComponent(name: "month", data: monthData))
+            case "YYYY": components.append(DateTimePickerComponent(name: "year", data: yearData))
+            case "HH": components.append(DateTimePickerComponent(name: "hour", data: hourData))
+            case "mm": components.append(DateTimePickerComponent(name: "minute", data: minData))
+            default: break
+            }
+        }
+        if isOnlyHour {
+            components.append(DateTimePickerComponent(name: "timeMode", data: timeMode))
+        }
+        return components
+    }
+}

package/ios/DateTimePicker/WheelPicker.swift

@@ -0,0 +1,161 @@
+import SwiftUI
+
+// MARK: - Constants
+
+private let wheelItemHeight: CGFloat = 42
+private let wheelVisibleCount: Int = 5
+private let wheelPickerBorderWidth: CGFloat = 1
+
+// MARK: - WheelPicker
+
+/// A reusable single-column wheel picker, mirroring Compose `WheelPicker.kt`.
+///
+/// The data is padded with two empty rows at the top and bottom so the first/last
+/// real value can be centered. The currently centered row is reported back via
+/// `onChange(name, value)`.
+public struct WheelPicker: View {
+    // MARK: Lifecycle
+
+    public init(
+        name: String,
+        data: [String],
+        selectedData: String,
+        onChange: @escaping (String, String) -> Void
+    ) {
+        self.name = name
+        self.data = data
+        self.selectedData = selectedData
+        self.onChange = onChange
+    }
+
+    // MARK: Public
+
+    public var body: some View {
+        let paddedData = ["", ""] + data + ["", ""]
+
+        return GeometryReader { geo in
+            let height = geo.size.height
+            ScrollViewReader { proxy in
+                ScrollView(.vertical, showsIndicators: false) {
+                    LazyVStack(spacing: 0) {
+                        ForEach(Array(paddedData.enumerated()), id: \.offset) { index, text in
+                            WheelPickerItem(
+                                text: text,
+                                isSelected: index == selectedIndex,
+                                index: index,
+                                scrollOffset: scrollOffset,
+                                viewportHeight: height
+                            )
+                            .frame(height: wheelItemHeight)
+                            .id(index)
+                        }
+                    }
+                    .background(
+                        GeometryReader { inner in
+                            Color.clear.preference(
+                                key: WheelOffsetKey.self,
+                                value: inner.frame(in: .named(scrollSpace)).minY
+                            )
+                        }
+                    )
+                }
+                .coordinateSpace(name: scrollSpace)
+                .onPreferenceChange(WheelOffsetKey.self) { value in
+                    scrollOffset = value
+                    updateSelection(paddedData: paddedData, viewportHeight: height)
+                }
+                .onAppear {
+                    let initial = max(paddedData.firstIndex(of: selectedData) ?? 2, 2)
+                    selectedIndex = initial
+                    DispatchQueue.main.async {
+                        proxy.scrollTo(initial, anchor: .center)
+                    }
+                }
+            }
+        }
+        .frame(height: wheelItemHeight * CGFloat(wheelVisibleCount))
+        .overlay(
+            RoundedRectangle(cornerRadius: Radius.S)
+                .stroke(Colors.border, lineWidth: wheelPickerBorderWidth)
+        )
+        .background(Colors.background.clipShape(RoundedRectangle(cornerRadius: Radius.S)))
+        .overlay(
+            // Centered translucent selection band.
+            Rectangle()
+                .fill(Colors.blue10)
+                .opacity(0.2)
+                .frame(height: wheelItemHeight)
+                .allowsHitTesting(false)
+        )
+        .clipShape(RoundedRectangle(cornerRadius: Radius.S))
+    }
+
+    // MARK: Internal
+
+    let name: String
+    let data: [String]
+    let selectedData: String
+    let onChange: (String, String) -> Void
+
+    @State private var selectedIndex: Int = 0
+    @State private var scrollOffset: CGFloat = 0
+
+    private let scrollSpace = "wheelScroll"
+
+    /// Map the current scroll offset to the centered index and report changes.
+    private func updateSelection(paddedData: [String], viewportHeight: CGFloat) {
+        // `scrollOffset` is the top of the content relative to the viewport (<= 0 when scrolled).
+        let centerY = viewportHeight / 2
+        let contentCenter = -scrollOffset + centerY
+        let rawIndex = Int((contentCenter / wheelItemHeight).rounded()) - 1
+        let clamped = max(2, min(rawIndex, paddedData.count - 3))
+        guard clamped != selectedIndex else { return }
+        selectedIndex = clamped
+        let value = paddedData[clamped]
+        if !value.isEmpty {
+            onChange(name, value)
+        }
+    }
+}
+
+// MARK: - WheelPickerItem
+
+private struct WheelPickerItem: View {
+    let text: String
+    let isSelected: Bool
+    let index: Int
+    let scrollOffset: CGFloat
+    let viewportHeight: CGFloat
+
+    var body: some View {
+        let itemCenterInContent = CGFloat(index) * wheelItemHeight + wheelItemHeight / 2
+        let itemCenterInViewport = itemCenterInContent + scrollOffset
+        let distanceFromCenter = abs(itemCenterInViewport - viewportHeight / 2) / wheelItemHeight
+
+        let alpha: Double
+        switch distanceFromCenter {
+        case ..<1: alpha = 1.0
+        case ..<2: alpha = 0.8
+        default: alpha = 0.4
+        }
+
+        let scale: CGFloat = isSelected ? 1.0 : 0.87
+
+        return ZStack {
+            MomoText(text, typography: .actionSBold, color: Colors.text)
+                .scaleEffect(scale)
+        }
+        .frame(maxWidth: .infinity)
+        .frame(height: wheelItemHeight)
+        .opacity(alpha)
+    }
+}
+
+// MARK: - WheelOffsetKey
+
+private struct WheelOffsetKey: PreferenceKey {
+    static var defaultValue: CGFloat = 0
+    static func reduce(value: inout CGFloat, nextValue: () -> CGFloat) {
+        value = nextValue()
+    }
+}

package/ios/Divider/Divider.swift

@@ -0,0 +1,16 @@
+import Foundation
+import SwiftUI
+
+public struct MomoDivider: View {
+    @Environment(\.appTheme) private var theme
+
+    public init() {}
+
+    public var body: some View {
+        Rectangle()
+            .fill(theme.colors.border.default)
+            .frame(maxWidth: .infinity)
+            .frame(height: 1)
+            .padding(.vertical, Spacing.XS)
+    }
+}

package/ios/Icon/Icon.swift

@@ -23,6 +23,9 @@ func loadIconSources() -> [String: IconSource] {
 // Load the JSON data into a global variable
 let iconSources: [String: IconSource] = loadIconSources()
 
+// Icons that must never be tinted (mirror Compose `noThemeIcons`)
+let noThemeIcons: [String] = ["ic_round_momo_tiny"]
+
 // Icon ViewModel
 public struct Icon: View {
     var source: String
@@ -44,7 +47,9 @@ public struct Icon: View {
 
     public var body: some View {
         if let uri = iconSources[source]?.uri {
-            ImageView(uri, color: color).frame(width: size, height: size)
+            // Mirror Compose: certain icons (e.g. branded glyphs) are never tinted
+            let resolvedColor = noThemeIcons.contains(source) ? nil : color
+            ImageView(uri, color: resolvedColor).frame(width: size, height: size)
         }
     }
 }