@momo-kits/native-kits 0.152.4 → 0.152.5

package/compose/src/commonMain/kotlin/vn/momo/kits/components/datetimepicker/DateTimePicker.kt

@@ -1,199 +0,0 @@
-package vn.momo.kits.components.datetimepicker
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.runtime.snapshotFlow
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.max
-import kotlinx.coroutines.flow.collect
-import kotlinx.coroutines.flow.mapNotNull
-import kotlinx.coroutines.flow.onEach
-import kotlinx.datetime.LocalDateTime
-import kotlinx.datetime.number
-import vn.momo.kits.components.Text
-import vn.momo.kits.const.AppTheme
-import vn.momo.kits.const.Spacing
-import vn.momo.kits.const.Typography
-
-private val datePickerHeight = 210.dp
-private val datePickerWithLabelsHeight = 238.dp
-
-@Composable
-fun DateTimePicker(
-    modifier: Modifier = Modifier,
-    format: String = "DD-MM-YYYY",
-    minuteInterval: Int = 1,
-    onChange: (LocalDateTime) -> Unit,
-    selectedValue: LocalDateTime? = null,
-    minDate: LocalDateTime? = null,
-    maxDate: LocalDateTime? = null,
-    arrayLabelTime: List<String> = emptyList()
-) {
-    val effectiveSelectedValue = remember(selectedValue) {
-        selectedValue ?: getCurrentDateTime()
-    }
-
-    val effectiveMinDate = remember(minDate) {
-        minDate ?: createRelativeDate(-10)
-    }
-
-    val effectiveMaxDate = remember(maxDate) {
-        maxDate ?: createRelativeDate(10)
-    }
-
-    val needCheckRange = remember(minDate, maxDate) {
-        minDate == null && maxDate == null
-    }
-
-    val initialValue = remember(effectiveMinDate, effectiveMaxDate, effectiveSelectedValue) {
-        when {
-            !needCheckRange -> effectiveSelectedValue
-            effectiveSelectedValue < effectiveMinDate -> effectiveMinDate
-            effectiveSelectedValue > effectiveMaxDate -> effectiveMaxDate
-            else -> effectiveSelectedValue
-        }
-    }
-
-    var currentDate by remember(initialValue) {
-        mutableStateOf(
-            PickerData(
-                day = initialValue.dayOfMonth,
-                month = initialValue.month.number,
-                year = initialValue.year,
-                hour = initialValue.hour,
-                minute = initialValue.minute
-            )
-        )
-    }
-
-    val onWheelChangeValue = remember(currentDate, effectiveMinDate, effectiveMaxDate) {
-        { name: String, value: String ->
-            var day = if (name == "day") value.toInt() else currentDate.day
-            var month = if (name == "month") value.toInt() else currentDate.month
-            val year = if (name == "year") value.toInt() else currentDate.year
-            val hour = if (name == "hour") value.toInt() else currentDate.hour
-            val minute = if (name == "minute") value.toInt() else currentDate.minute
-            val timeMode = if (name == "timeMode") value else currentDate.timeMode
-            if (name == "year") {
-                month = when (year) {
-                    effectiveMaxDate.year -> month.coerceIn(
-                        1,
-                        effectiveMaxDate.monthNumber
-                    )
-                    effectiveMinDate.year -> month.coerceIn(
-                        effectiveMinDate.monthNumber,
-                        12,
-                    )
-                    else -> month
-                }
-            }
-            if (name == "month" || name == "year") {
-                val maxDayOfMonth = when (month) {
-                    4, 6, 9, 11 -> 30
-                    2 -> if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) 29 else 28
-                    else -> 31
-                }
-
-                day = when {
-                    year == effectiveMaxDate.year && month == effectiveMaxDate.monthNumber ->
-                        day.coerceIn(1, effectiveMaxDate.dayOfMonth)
-
-                    year == effectiveMinDate.year && month == effectiveMinDate.monthNumber ->
-                        day.coerceIn(effectiveMinDate.dayOfMonth, maxDayOfMonth)
-
-                    day > maxDayOfMonth -> maxDayOfMonth
-                    else -> day
-                }
-            }
-            currentDate = PickerData(
-                day = day,
-                month = month,
-                year = year,
-                hour = hour,
-                minute = minute,
-                timeMode = timeMode,
-            )
-        }
-    }
-
-    LaunchedEffect(effectiveMinDate, effectiveMaxDate) {
-        snapshotFlow { currentDate }
-            .mapNotNull {
-                val dateTime = it.toLocalDateTime()
-                if (!needCheckRange || dateTime in effectiveMinDate..effectiveMaxDate) dateTime
-                else null
-            }
-            .onEach(onChange)
-            .collect()
-    }
-
-    val pickerHeight = if (arrayLabelTime.isNotEmpty())
-        datePickerWithLabelsHeight else
-        datePickerHeight
-
-    Row(
-        modifier = modifier
-            .fillMaxWidth()
-            .height(pickerHeight)
-            .background(AppTheme.current.colors.background.surface)
-            .padding(horizontal = Spacing.M),
-        verticalAlignment = Alignment.CenterVertically
-    ) {
-        val dateComponents = getDateComponents(
-            format,
-            currentDate,
-            effectiveMinDate,
-            effectiveMaxDate,
-            minuteInterval,
-        )
-        dateComponents.forEachIndexed { index, component ->
-            val hasLabel = index < arrayLabelTime.size && arrayLabelTime[index].isNotEmpty()
-
-            Column(
-                horizontalAlignment = Alignment.CenterHorizontally,
-                modifier = Modifier.weight(1f)
-            ) {
-                if (hasLabel) {
-                    Text(
-                        text = arrayLabelTime[index],
-                        style = Typography.actionSBold,
-                        modifier = Modifier.padding(bottom = Spacing.S)
-                    )
-                }
-
-                WheelPicker(
-                    name = component.name,
-                    data = component.data,
-                    selectedData = when (component.name) {
-                        "day" -> paddingNum(currentDate.day)
-                        "month" -> paddingNum(currentDate.month)
-                        "year" -> currentDate.year.toString()
-                        "hour" -> paddingNum(currentDate.hour)
-                        "minute" -> paddingNum(currentDate.minute)
-                        "timeMode" -> currentDate.timeMode
-                        else -> ""
-                    },
-                    onChange = onWheelChangeValue,
-                )
-            }
-
-            if (index < dateComponents.size - 1) {
-                Spacer(modifier = Modifier.width(Spacing.M))
-            }
-        }
-    }
-} 

package/compose/src/commonMain/kotlin/vn/momo/kits/components/datetimepicker/DateTimePickerTypes.kt

@@ -1,29 +0,0 @@
-package vn.momo.kits.components.datetimepicker
-
-import kotlinx.datetime.LocalDateTime
-
-data class PickerData(
-    var day: Int,
-    var month: Int,
-    var year: Int,
-    var hour: Int = 0,
-    var minute: Int = 0,
-    var timeMode: String = ""
-) {
-    fun toLocalDateTime(): LocalDateTime {
-        return LocalDateTime(
-            year = year,
-            monthNumber = month,
-            dayOfMonth = day,
-            hour = hour,
-            minute = minute,
-            second = 0,
-            nanosecond = 0
-        )
-    }
-}
-
-data class DateComponent(
-    val name: String,
-    val data: List<String>
-)

package/compose/src/commonMain/kotlin/vn/momo/kits/components/datetimepicker/DateTimePickerUtils.kt

@@ -1,237 +0,0 @@
-package vn.momo.kits.components.datetimepicker
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import kotlinx.datetime.Clock
-import kotlinx.datetime.DatePeriod
-import kotlinx.datetime.LocalDateTime
-import kotlinx.datetime.TimeZone
-import kotlinx.datetime.minus
-import kotlinx.datetime.number
-import kotlinx.datetime.plus
-import kotlinx.datetime.toLocalDateTime
-
-/**
- * Format a LocalDateTime object into a string
- */
-fun formatLocalDateTime(dateTime: LocalDateTime, format: String = "yyyy-MM-dd HH:mm"): String {
-    return when (format) {
-        "yyyy-MM-dd HH:mm" -> "${dateTime.year}-${paddingNum(dateTime.month.number)}-${
-            paddingNum(
-                dateTime.dayOfMonth
-            )
-        } ${paddingNum(dateTime.hour)}:${paddingNum(dateTime.minute)}"
-
-        "dd-MM-yyyy" -> "${paddingNum(dateTime.dayOfMonth)}-${paddingNum(dateTime.month.number)}-${dateTime.year}"
-        "HH:mm" -> "${paddingNum(dateTime.hour)}:${paddingNum(dateTime.minute)}"
-        else -> "${dateTime.year}-${paddingNum(dateTime.month.number)}-${paddingNum(dateTime.dayOfMonth)} ${
-            paddingNum(
-                dateTime.hour
-            )
-        }:${paddingNum(dateTime.minute)}"
-    }
-}
-
-/**
- * Pad a number with a leading zero if it's less than 10
- */
-fun paddingNum(num: Int): String {
-    return if (num > 9) num.toString() else "0$num"
-}
-
-/**
- * Get a list of days in a month
- */
-fun getDaysInMonth(
-    year: Int,
-    month: Int,
-    minDate: LocalDateTime,
-    maxDate: LocalDateTime
-): List<String> {
-    val daysInMonth = when (month) {
-        1, 3, 5, 7, 8, 10, 12 -> 31
-        4, 6, 9, 11 -> 30
-        2 -> if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) 29 else 28
-        else -> throw IllegalArgumentException("Invalid month: $month")
-    }
-
-    var startDay = 1
-    var endDay = daysInMonth
-
-    if (year == minDate.year && month == minDate.month.number) {
-        startDay = minDate.dayOfMonth
-    }
-
-    if (year == maxDate.year && month == maxDate.month.number) {
-        endDay = maxDate.dayOfMonth
-    }
-
-    val days = mutableListOf<String>()
-    for (day in startDay..endDay) {
-        days.add(paddingNum(day))
-    }
-
-    return days
-}
-
-/**
- * Get a list of months
- */
-fun getMonths(
-    minDate: LocalDateTime,
-    maxDate: LocalDateTime,
-    currentYear: Int
-): List<String> {
-    var startMonth = 1
-    var endMonth = 12
-
-    if (currentYear == minDate.year) {
-        startMonth = minDate.month.number
-    }
-
-    if (currentYear == maxDate.year) {
-        endMonth = maxDate.month.number
-    }
-
-    val months = mutableListOf<String>()
-    for (month in startMonth..endMonth) {
-        months.add(paddingNum(month))
-    }
-
-    return months
-}
-
-/**
- * Get a list of years
- */
-fun getYears(minDate: LocalDateTime, maxDate: LocalDateTime): List<String> {
-    val startYear = minDate.year
-    val endYear = maxDate.year
-    val years = mutableListOf<String>()
-
-    for (year in startYear..endYear) {
-        years.add(year.toString())
-    }
-
-    return years
-}
-
-/**
- * Get a list of hours
- */
-fun getHours(hourMode: Int): List<String> {
-    val hours = mutableListOf<String>()
-    for (i in 0 until hourMode) {
-        val hour = if (hourMode == 12) i + 1 else i
-        hours.add(paddingNum(hour))
-    }
-    return hours
-}
-
-/**
- * Get a list of minutes
- */
-fun getMinutes(interval: Int): List<String> {
-    val minutes = mutableListOf<String>()
-    var min = 0
-    while (min < 60) {
-        minutes.add(paddingNum(min))
-        min += interval
-    }
-    return minutes
-}
-
-/**
- * Time mode for 12-hour clock
- */
-val timeMode = listOf("AM", "PM")
-
-/**
- * Get today's date
- */
-fun getCurrentDateTime(): LocalDateTime {
-    return Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault())
-}
-
-/**
- * Create a date that's a certain number of years before or after the current date
- */
-fun createRelativeDate(years: Int): LocalDateTime {
-    val currentDateTime = getCurrentDateTime()
-    val period = DatePeriod(years = if (years < 0) -years else years)
-
-    val adjustedDate = if (years < 0) {
-        currentDateTime.date.minus(period)
-    } else {
-        currentDateTime.date.plus(period)
-    }
-
-    return LocalDateTime(
-        adjustedDate.year,
-        adjustedDate.monthNumber,
-        adjustedDate.dayOfMonth,
-        currentDateTime.hour,
-        currentDateTime.minute
-    )
-}
-
-@Composable
-internal fun getDateComponents(
-    format: String,
-    currentDate: PickerData,
-    effectiveMinDate: LocalDateTime,
-    effectiveMaxDate: LocalDateTime,
-    minuteInterval: Int,
-): List<DateComponent> {
-    val formatParts = remember(format) {
-        format.split(Regex("[^A-Za-z]+"))
-    }
-
-    val isOnlyHour = remember(formatParts) {
-        formatParts.size == 1 && formatParts[0] == "HH"
-    }
-
-    val dayData =
-        remember(currentDate.year, currentDate.month, effectiveMinDate, effectiveMaxDate) {
-            getDaysInMonth(currentDate.year, currentDate.month, effectiveMinDate, effectiveMaxDate)
-        }
-
-    val monthData = remember(currentDate.year, effectiveMinDate, effectiveMaxDate) {
-        getMonths(effectiveMinDate, effectiveMaxDate, currentDate.year)
-    }
-
-    val yearData = remember(effectiveMinDate, effectiveMaxDate) {
-        getYears(effectiveMinDate, effectiveMaxDate)
-    }
-
-    val hourData = remember(isOnlyHour) {
-        getHours(if (isOnlyHour) 12 else 24)
-    }
-
-    val minData = remember(minuteInterval) {
-        getMinutes(minuteInterval)
-    }
-
-    val dateComponents =
-        remember(formatParts, dayData, monthData, yearData, hourData, minData, isOnlyHour) {
-            val components = mutableListOf<DateComponent>()
-
-            formatParts.forEach { part ->
-                when (part) {
-                    "DD" -> components.add(DateComponent("day", dayData))
-                    "MM" -> components.add(DateComponent("month", monthData))
-                    "YYYY" -> components.add(DateComponent("year", yearData))
-                    "HH" -> components.add(DateComponent("hour", hourData))
-                    "mm" -> components.add(DateComponent("minute", minData))
-                }
-            }
-
-            if (isOnlyHour) {
-                components.add(DateComponent("timeMode", timeMode))
-            }
-
-            components
-        }
-
-    return dateComponents
-}

package/compose/src/commonMain/kotlin/vn/momo/kits/components/datetimepicker/WheelPicker.kt

@@ -1,191 +0,0 @@
-package vn.momo.kits.components.datetimepicker
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.border
-import androidx.compose.foundation.gestures.animateScrollBy
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.LazyListState
-import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.runtime.snapshotFlow
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.zIndex
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.collect
-import kotlinx.coroutines.flow.debounce
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.onEach
-import vn.momo.kits.components.Text
-import vn.momo.kits.const.AppTheme
-import vn.momo.kits.const.Colors
-import vn.momo.kits.const.Radius
-import vn.momo.kits.const.Typography
-import kotlin.math.abs
-
-private val wheelItemHeight = 42.dp
-private val wheelPickerBorderWidth = 1.dp
-
-@Composable
-fun WheelPicker(
-    name: String,
-    data: List<String>,
-    selectedData: String,
-    onChange: (String, String) -> Unit,
-    modifier: Modifier = Modifier
-) {
-    val listState = rememberLazyListState()
-    val itemHeightPx = with(LocalDensity.current) { wheelItemHeight.toPx() }
-
-    val paddedData = remember(data) {
-        listOf("", "") + data + listOf("", "")
-    }
-
-    val initialIndex = remember(selectedData, paddedData) {
-        paddedData.indexOf(selectedData).coerceAtLeast(2)
-    }
-
-    LaunchedEffect(initialIndex) {
-        listState.scrollToItem(initialIndex - 2)
-    }
-
-    var selectedIndex by remember { mutableStateOf(0) }
-
-    LaunchedEffect(paddedData) {
-        snapshotFlow { selectedIndex }
-            .distinctUntilChanged()
-            .debounce(50)
-            .onEach {
-                val value = paddedData.getOrNull(it)
-                if (!value.isNullOrEmpty()) {
-                    onChange(name, value)
-                }
-            }
-            .collect()
-    }
-
-    LaunchedEffect(paddedData) {
-        snapshotFlow { listState.isScrollInProgress }
-            .onEach {
-                if (it) return@onEach
-                val firstItem = listState.layoutInfo.visibleItemsInfo.firstOrNull() ?: return@onEach
-                val firstItemIdx = firstItem.index
-                val firstItemOffset = firstItem.offset
-                if (firstItemOffset == 0) {
-                    selectedIndex = firstItemIdx + 2
-                    return@onEach
-                }
-                val isScrollUp = abs(firstItemOffset) > itemHeightPx / 2
-                val offset = if (isScrollUp) {
-                    itemHeightPx - abs(firstItemOffset)
-                } else {
-                    -abs(firstItemOffset)
-                }
-                delay(50)
-                listState.animateScrollBy(offset.toFloat())
-                val centeredIndex = firstItemIdx + (if (isScrollUp) 1 else 0) + 2
-                if (centeredIndex in 2 until paddedData.size - 2) {
-                    selectedIndex = centeredIndex
-                }
-            }
-            .collect()
-    }
-
-    Box(
-        modifier = modifier
-            .border(
-                width = wheelPickerBorderWidth,
-                color = AppTheme.current.colors.border.default,
-                shape = RoundedCornerShape(Radius.S)
-            )
-            .background(
-                color = AppTheme.current.colors.background.surface,
-            )
-    ) {
-        LazyColumn(
-            state = listState,
-            modifier = Modifier
-                .fillMaxWidth()
-        ) {
-            items(paddedData.size) { index ->
-                WheelPickerItem(
-                    text = paddedData[index],
-                    isSelected = index == selectedIndex,
-                    index = index,
-                    listState = listState,
-                    itemHeight = wheelItemHeight
-                )
-            }
-        }
-
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .height(wheelItemHeight)
-                .background(Colors.blue_10)
-                .align(Alignment.Center)
-                .alpha(0.2f)
-                .zIndex(-2f)
-        )
-    }
-}
-
-@Composable
-fun WheelPickerItem(
-    text: String,
-    isSelected: Boolean,
-    index: Int,
-    listState: LazyListState,
-    itemHeight: Dp
-) {
-    Box(
-        modifier = Modifier
-            .fillMaxWidth()
-            .height(itemHeight)
-            .graphicsLayer {
-                val firstVisibleIndex = listState.firstVisibleItemIndex
-                val visibleItemOffset = listState.firstVisibleItemScrollOffset
-
-                val viewportHeight = 5 * itemHeight.value
-                val itemHeightValue = itemHeight.value
-
-                val absoluteOffset =
-                    (index - firstVisibleIndex) * itemHeightValue - (visibleItemOffset / itemHeightValue)
-                val relativePosition = absoluteOffset / viewportHeight
-
-                val distance = abs(2 - relativePosition)
-
-                alpha = when {
-                    distance <= 1 -> 1f
-                    distance <= 2 -> 0.8f
-                    distance <= 3 -> 0.4f
-                    else -> 0.4f
-                }
-            },
-        contentAlignment = Alignment.Center
-    ) {
-        Text(
-            text = text,
-            style = Typography.actionSBold,
-            modifier = Modifier.graphicsLayer {
-                val scale = if (isSelected) 1f else 0.87f
-                scaleX = scale
-                scaleY = scale
-            }
-        )
-    }
-}