@momo-kits/native-kits 0.160.9-debug → 0.160.10-debug

package/compose/build.gradle.kts

@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.160.9-debug"
+        version = "0.160.10-debug"
         summary = "IOS Shared module"
         homepage = "https://momo.vn"
         ios.deploymentTarget = "15.0"

package/compose/src/commonMain/kotlin/vn/momo/kits/application/LiteScreen.kt

@@ -1,5 +1,6 @@
 package vn.momo.kits.application
 
+import androidx.annotation.FloatRange
 import androidx.compose.animation.animateContentSize
 import androidx.compose.foundation.ScrollState
 import androidx.compose.foundation.background
@@ -9,22 +10,18 @@ import androidx.compose.foundation.interaction.FocusInteraction
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.asPaddingValues
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.ime
 import androidx.compose.foundation.layout.navigationBars
 import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.sizeIn
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.BasicTextField
 import androidx.compose.foundation.text.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
@@ -48,6 +45,7 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.drawBehind
 import androidx.compose.ui.draw.drawWithContent
 import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
 import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.graphicsLayer
@@ -70,13 +68,17 @@ import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.graphics.Color.Companion
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.unit.lerp
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.mapNotNull
 import vn.momo.kits.components.Icon
 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.Spacing
 import vn.momo.kits.const.Typography
 import vn.momo.kits.modifier.conditional
@@ -86,6 +88,30 @@ import vn.momo.kits.modifier.setAutomationId
 import vn.momo.kits.modifier.shadow
 import vn.momo.kits.utils.getAppStatusBarHeight
 import kotlin.math.max
+import kotlin.math.roundToInt
+
+
+data class AnimationOption(
+    val targetBounds: Rect,
+    val progress: State<Float>,
+    @param:FloatRange(from = 0.0, to = 1.0)
+    val opacityLimitFraction: Float = 0f,
+) {
+    val opacityCap: Float
+        get() = 1f - opacityLimitFraction
+
+    val animateOpacity: Float
+        get() {
+            if (progress.value < opacityLimitFraction) return 0f
+            return androidx.compose.ui.util.lerp(
+                0f,
+                1f,
+                (progress.value - opacityLimitFraction) / (opacityCap),
+            )
+        }
+}
+
+val LocalAnimationOption = staticCompositionLocalOf<AnimationOption?> { null }
 
 @Composable
 fun LiteScreen(
@@ -114,48 +140,46 @@ fun LiteScreen(
 
     val finalScrollState = scrollState ?: rememberScrollState()
 
-    Column(
+    val contentModifier = remember(
+        key1 = scrollable,
+        key2 = finalScrollState,
+    ) {
+        var res: Modifier = Modifier
+            .background(color = backgroundColor)
+        if (scrollable) {
+            res = res.verticalScroll(finalScrollState)
+        }
+        res
+    }
+
+    LiteScreenLayout(
+        scrollState = finalScrollState,
         modifier = Modifier
             .fillMaxSize()
-            .background(color = backgroundColor)
             .hideKeyboardOnTap(),
+        contentModifier = contentModifier,
         verticalArrangement = verticalArrangement,
         horizontalAlignment = horizontalAlignment,
+        title = title,
+        headerRight = headerRight,
+        headerType = headerType,
+        onGoBack = goBack,
+        inputSearchProps = inputSearchProps,
+        titlePosition = titlePosition,
+        useAnimationSearch = useAnimationSearch,
+        headerRightData = headerRightData,
+        tintColor = headerTintColor,
+        headerBackgroundColor = headerBackgroundColor,
+        headerSpaceBetween = headerSpaceBetween,
     ) {
-        val contentModifier = remember(scrollable, finalScrollState) {
-            var res = Modifier.weight(1f)
-            if (scrollable) {
-                res = res.verticalScroll(finalScrollState)
-            }
-            res
-        }
-
-        LiteScreenHeader(
-            scrollState = finalScrollState,
-            title = title,
-            headerRight = headerRight,
-            headerType = headerType,
-            onGoBack = goBack,
-            inputSearchProps = inputSearchProps,
-            titlePosition = titlePosition,
-            useAnimationSearch = useAnimationSearch,
-            headerRightData = headerRightData,
-            tintColor = headerTintColor,
-            headerBackgroundColor = headerBackgroundColor,
-            headerSpaceBetween = headerSpaceBetween,
-        )
-
-        Box(
-            modifier = contentModifier,
-            contentAlignment = Alignment.TopCenter,
-        ) {
-            content()
-        }
+        content()
     }
 }
 
 private object HeaderId {
     private const val PACKAGE_NAME = "vn.momo.compose.kits"
+    const val CONTENT_ID = "${PACKAGE_NAME}.content"
+    const val BACKGROUND_ID = "${PACKAGE_NAME}.background"
     const val BACK_ID = "${PACKAGE_NAME}.back"
     const val HEADER_RIGHT_ID = "${PACKAGE_NAME}.headerRight"
     const val INPUT_SEARCH_ID = "${PACKAGE_NAME}.inputSearch"
@@ -165,8 +189,12 @@ private object HeaderId {
 }
 
 @Composable
-private fun LiteScreenHeader(
+private fun LiteScreenLayout(
     scrollState: ScrollState?,
+    modifier: Modifier = Modifier,
+    contentModifier: Modifier = Modifier,
+    verticalArrangement: Arrangement.Vertical = Arrangement.Top,
+    horizontalAlignment: Alignment.Horizontal = Alignment.Start,
     title: String? = null,
     tintColor: Color? = null,
     headerRightData: HeaderRightData? = null,
@@ -178,11 +206,11 @@ private fun LiteScreenHeader(
     headerSpaceBetween: Dp? = null,
     inputSearchProps: LiteInputSearchProps? = null,
     headerRight: @Composable (() -> Unit)? = null,
+    content: @Composable () -> Unit,
 ) {
     val statusBarHeight = getAppStatusBarHeight()
-    if (headerType == HeaderType.NONE) {
-        Box(modifier = Modifier.height(statusBarHeight))
-        return
+    val isHeaderNone = remember(headerType) {
+        headerType == HeaderType.NONE
     }
     val theme = AppTheme.current
     val density = LocalDensity.current
@@ -190,9 +218,12 @@ private fun LiteScreenHeader(
     val isHeaderExtend = remember(headerType) {
         headerType == HeaderType.EXTENDED
     }
-    val backgroundHeight = remember(isHeaderExtend, statusBarHeight) {
-        if (!isHeaderExtend) statusBarHeight + HEADER_HEIGHT.dp
-        else HeaderId.EXTENDED_HEADER_HEIGHT
+    val backgroundHeight = remember(isHeaderNone, isHeaderExtend, statusBarHeight) {
+        when {
+            isHeaderNone -> statusBarHeight
+            !isHeaderExtend -> statusBarHeight + HEADER_HEIGHT.dp
+            else -> HeaderId.EXTENDED_HEADER_HEIGHT
+        }
     }
     val listGradientColors = remember {
         listOf(
@@ -235,79 +266,107 @@ private fun LiteScreenHeader(
         )
     }
 
-    val titleModifier = remember {
-        Modifier
-            .kitsAutomationId("title_navigation_header")
-            .layoutId(HeaderId.TITLE_ID)
-            .graphicsLayer {
-                alpha = if (isHeaderExtend && inputSearchProps != null && useAnimationSearch)
-                    (1 - scrollPercentage.value * 2).coerceIn(0f, 1f)
-                else 1f
-            }
+    val animationOption = LocalAnimationOption.current
+    val animationOpacityModifier = Modifier.graphicsLayer {
+        alpha = animationOption?.animateOpacity ?: 1f
     }
+    val titleModifier = Modifier
+        .kitsAutomationId("title_navigation_header")
+        .layoutId(HeaderId.TITLE_ID)
+        .graphicsLayer {
+            val titleAlpha = if (isHeaderExtend && inputSearchProps != null && useAnimationSearch)
+                (1 - scrollPercentage.value * 2).coerceIn(0f, 1f)
+            else 1f
+            alpha = titleAlpha * (animationOption?.progress?.value ?: 1f)
+        }
 
     val policy = remember(
         useAnimationSearch,
+        isHeaderNone,
         isHeaderExtend,
         statusBarHeight,
         titlePosition,
         scrollPercentage,
         headerSpaceBetween,
+        animationOption,
+        verticalArrangement,
+        horizontalAlignment,
     ) {
-        LiteScreenHeaderPolicy(
+        LiteScreenLayoutPolicy(
             useAnimationSearch = useAnimationSearch,
+            isHeaderNone = isHeaderNone,
             isHeaderExtend = isHeaderExtend,
             statusBarHeight = statusBarHeight,
             titlePosition = titlePosition,
             scrollPercentage = scrollPercentage,
             headerSpaceBetween = headerSpaceBetween,
+            animationOption = animationOption,
+            verticalArrangement = verticalArrangement,
+            horizontalAlignment = horizontalAlignment,
         )
     }
 
     Layout(
-        modifier = Modifier
-            .animateContentSize()
-            .drawBehind {
-                val headerHeight = max(
-                    HeaderId.EXTENDED_HEADER_HEIGHT.toPx(),
-                    size.height,
-                )
-                headerBackgroundColor?.let {
-                    drawRect(color = it)
-                } ?: run {
-                    drawRect(color = Colors.black_01)
-                    drawRect(
-                        brush = Brush.linearGradient(
-                            colors = listGradientColors,
-                            start = Offset.Zero,
-                            end = Offset(
-                                x = 0f,
-                                y = headerHeight * (1 - scrollPercentage.value),
-                            ),
-                        )
-                    )
-                }
-            },
+        modifier = modifier
+            .animateContentSize(),
         content = {
-            if (onGoBack != null) {
+            Box(
+                modifier = animationOpacityModifier
+                    .layoutId(HeaderId.CONTENT_ID)
+                    .then(contentModifier),
+                contentAlignment = Alignment.TopCenter,
+            ) {
+                content()
+            }
+
+            if (!isHeaderNone) {
                 Box(
                     modifier = Modifier
-                        .size(28.dp)
-                        .layoutId(HeaderId.BACK_ID)
-                        .clip(CircleShape)
-                        .conditional(inputSearchProps?.customBackIcon == null) {
-                            this.border(
-                                width = 0.2.dp,
-                                color = headerColor.borderColor,
-                                shape = CircleShape,
+                        .layoutId(HeaderId.BACKGROUND_ID)
+                        .then(animationOpacityModifier)
+                        .drawBehind {
+                            val headerHeight = max(
+                                HeaderId.EXTENDED_HEADER_HEIGHT.toPx(),
+                                size.height,
                             )
-                                .background(color = headerColor.backgroundButton)
-                        }
-                        .noFeedbackClickable(onClick = onGoBack)
-                        .setAutomationId("btn_navigation_back")
+                            headerBackgroundColor?.let {
+                                drawRect(color = it)
+                            } ?: run {
+                                drawRect(color = Colors.black_01)
+                                drawRect(
+                                    brush = Brush.linearGradient(
+                                        colors = listGradientColors,
+                                        start = Offset.Zero,
+                                        end = Offset(
+                                            x = 0f,
+                                            y = headerHeight * (1 - scrollPercentage.value),
+                                        ),
+                                    )
+                                )
+                            }
+                        },
+                )
+            }
+
+            if (!isHeaderNone && onGoBack != null) {
+                val coreModifier = Modifier
+                    .layoutId(HeaderId.BACK_ID)
+                    .then(animationOpacityModifier)
+                    .clip(CircleShape)
+                    .noFeedbackClickable(onClick = onGoBack)
+                    .setAutomationId("btn_navigation_back")
+                inputSearchProps?.customBackIcon?.invoke(coreModifier) ?: Box(
+                    modifier = coreModifier
+                        .size(28.dp)
+                        .border(
+                            width = 0.2.dp,
+                            color = headerColor.borderColor,
+                            shape = CircleShape,
+                        )
+                        .background(color = headerColor.backgroundButton)
                         .padding(Spacing.XS),
                 ) {
-                    inputSearchProps?.customBackIcon?.invoke() ?: Icon(
+                    Icon(
                         source = "arrow-back",
                         color = headerColor.tintIconColor,
                         size = 20.dp,
@@ -315,27 +374,30 @@ private fun LiteScreenHeader(
                 }
             }
 
-            Box(
-                modifier = Modifier
-                    .layoutId(HeaderId.HEADER_RIGHT_ID)
-            ) {
-                if (headerRight != null) {
-                    headerRight()
-                } else {
-                    HeaderRight(
-                        headerRight = headerRightData,
-                        tintColor = tintColor,
-                    )
+            if (!isHeaderNone) {
+                Box(
+                    modifier = Modifier
+                        .layoutId(HeaderId.HEADER_RIGHT_ID)
+                        .then(animationOpacityModifier)
+                ) {
+                    if (headerRight != null) {
+                        headerRight()
+                    } else {
+                        HeaderRight(
+                            headerRight = headerRightData,
+                            tintColor = tintColor,
+                        )
+                    }
                 }
             }
 
-            if (inputSearchProps != null) {
+            if (!isHeaderNone && inputSearchProps != null) {
                 LiteInputSearch(
                     modifier = Modifier.layoutId(HeaderId.INPUT_SEARCH_ID),
                     inputSearchProps = inputSearchProps,
                 )
             }
-            if (title != null && (inputSearchProps == null || isHeaderExtend)) {
+            if (!isHeaderNone && title != null && (inputSearchProps == null || isHeaderExtend)) {
                 Text(
                     text = title,
                     color = headerColor.tintIconColor,
@@ -350,15 +412,28 @@ private fun LiteScreenHeader(
     )
 }
 
-private class LiteScreenHeaderPolicy(
+private class LiteScreenLayoutPolicy(
     private val useAnimationSearch: Boolean,
+    private val isHeaderNone: Boolean,
     private val isHeaderExtend: Boolean,
     private val statusBarHeight: Dp,
     private val scrollPercentage: State<Float>,
     private val titlePosition: TitlePosition,
     private val headerSpaceBetween: Dp? = null,
+    private val animationOption: AnimationOption?,
+    private val verticalArrangement: Arrangement.Vertical,
+    private val horizontalAlignment: Alignment.Horizontal,
 ) : MeasurePolicy {
 
+    val searchStartPosition: IntOffset by lazy {
+        if (animationOption == null) return@lazy IntOffset.Zero
+        val offset = animationOption.targetBounds.topLeft
+        IntOffset(
+            x = offset.x.roundToInt(),
+            y = offset.y.roundToInt(),
+        )
+    }
+
     override fun MeasureScope.measure(
         measurables: List<Measurable>,
         constraints: Constraints
@@ -368,6 +443,8 @@ private class LiteScreenHeaderPolicy(
         val statusBarPx = statusBarHeight.roundToPx()
         val scrollPercent = scrollPercentage.value
 
+        val contentMeasurable = measurables.find { it.layoutId == HeaderId.CONTENT_ID }
+
         val realConstraints = constraints.copy(
             minWidth = 0,
             minHeight = 0,
@@ -382,7 +459,7 @@ private class LiteScreenHeaderPolicy(
                     maxWidth = realConstraints.maxWidth / 2,
                 )
             )
-        val inputSearchConstraints = if (isHeaderExtend) {
+        val baseInputSearchConstraints = if (isHeaderExtend) {
             val minWidth =
                 if (useAnimationSearch) realConstraints.maxWidth - backIconPlaceable.safeWidth - headerRightPlaceable.safeWidth - spaceBetween * 2
                 else realConstraints.maxWidth
@@ -398,6 +475,7 @@ private class LiteScreenHeaderPolicy(
                 maxWidth = realConstraints.maxWidth - spaceConsumed
             )
         }
+        val inputSearchConstraints = baseInputSearchConstraints.withAnimationTargetBounds()
         val inputSearchPlaceable = measurables.find { it.layoutId == HeaderId.INPUT_SEARCH_ID }
             ?.measure(inputSearchConstraints)
         val titlePlaceable = measurables.find { it.layoutId == HeaderId.TITLE_ID }?.measure(
@@ -412,6 +490,7 @@ private class LiteScreenHeaderPolicy(
             if (!isHeaderExtend) {
                 add(inputSearchPlaceable.safeHeight)
             }
+            add(HEADER_HEIGHT.dp.roundToPx())
             if (isHeaderExtend) {
                 add(titlePlaceable.safeHeight)
             }
@@ -421,20 +500,69 @@ private class LiteScreenHeaderPolicy(
         if (isHeaderExtend) {
             defaultHeight += inputSearchPlaceable.safeHeight + spacing12
         }
-        val height = when {
+        val headerHeight = when {
+            isHeaderNone -> statusBarPx
             !useAnimationSearch && !isHeaderExtend -> defaultHeight
             else -> (defaultHeight - scrollPercent * (defaultHeight - statusBarPx - HEADER_HEIGHT.dp.roundToPx())).toInt()
         }
 
+        val layoutWidth = constraints.maxWidth
+        val layoutHeight = constraints.maxHeight
+        val contentHeight = (layoutHeight - headerHeight).coerceAtLeast(0)
+        val contentPlaceable = contentMeasurable?.measure(
+            constraints.copy(
+                minWidth = 0,
+                minHeight = contentHeight,
+                maxHeight = contentHeight,
+            )
+        )
+        val backgroundPlaceable = measurables.find { it.layoutId == HeaderId.BACKGROUND_ID }
+            ?.measure(
+                Constraints.fixed(
+                    width = layoutWidth,
+                    height = headerHeight,
+                )
+            )
+        val childrenHeights = intArrayOf(
+            headerHeight,
+            contentPlaceable.safeHeight,
+        )
+        val childrenY = IntArray(childrenHeights.size)
+        with(verticalArrangement) {
+            arrange(
+                totalSize = layoutHeight,
+                sizes = childrenHeights,
+                outPositions = childrenY,
+            )
+        }
+        val headerY = childrenY[0]
+        val contentY = childrenY[1]
+
         return layout(
-            width = constraints.maxWidth,
-            height = height,
+            width = layoutWidth,
+            height = layoutHeight,
         ) {
+            val progress = animationOption?.progress?.value ?: 1f
+
             val startX = spacing12
-            val startY = statusBarPx + spacing12
+            val startY = headerY + statusBarPx
             var curX = startX
             var curY = startY
 
+            contentPlaceable?.place(
+                x = horizontalAlignment.align(
+                    size = contentPlaceable.width,
+                    space = layoutWidth,
+                    layoutDirection = layoutDirection,
+                ),
+                y = contentY,
+            )
+
+            backgroundPlaceable?.place(
+                x = 0,
+                y = headerY,
+            )
+
             if (backIconPlaceable != null) {
                 backIconPlaceable.place(
                     x = startX,
@@ -444,14 +572,14 @@ private class LiteScreenHeaderPolicy(
             }
 
             headerRightPlaceable?.place(
-                x = constraints.maxWidth - spacing12 - headerRightPlaceable.safeWidth,
+                x = layoutWidth - spacing12 - headerRightPlaceable.safeWidth,
                 y = startY + headerRightPlaceable.verticalCenterOffset(firstRowMaxHeight),
             )
 
             val titleOffset = IntOffset(
                 x = if (titlePosition == TitlePosition.LEFT) curX
                 else titlePlaceable.horizontalCenterOffset(
-                    space = constraints.maxWidth,
+                    space = layoutWidth,
                     layoutDirection = layoutDirection,
                 ),
                 y = startY + titlePlaceable.verticalCenterOffset(firstRowMaxHeight),
@@ -460,17 +588,19 @@ private class LiteScreenHeaderPolicy(
             titlePlaceable?.place(titleOffset)
 
             if (backIconPlaceable != null || headerRightPlaceable != null || titlePlaceable != null) {
-                curY += firstRowMaxHeight + spacing12
+                curY += firstRowMaxHeight
             }
 
             val inputSearchOffset = if (isHeaderExtend) {
+                val baseY = curY + inputSearchPlaceable.verticalCenterOffset(firstRowMaxHeight)
+                val y = (baseY * (1 - scrollPercent)).toInt().coerceAtLeast(
+                    startY + inputSearchPlaceable.verticalCenterOffset(firstRowMaxHeight)
+                )
                 IntOffset(
                     x = startX + ((backIconPlaceable.safeWidth + spaceBetween) * (scrollPercent * 2f).coerceIn(
                         0f, 1f
                     )).toInt(),
-                    y = (curY * (1 - scrollPercent)).toInt().coerceAtLeast(
-                        startY + inputSearchPlaceable.verticalCenterOffset(firstRowMaxHeight)
-                    ),
+                    y = y,
                 )
             } else {
                 IntOffset(
@@ -478,8 +608,15 @@ private class LiteScreenHeaderPolicy(
                     y = startY + inputSearchPlaceable.verticalCenterOffset(firstRowMaxHeight),
                 )
             }
+            val finalPosition = lerp(
+                searchStartPosition,
+                inputSearchOffset,
+                progress,
+            )
 
-            inputSearchPlaceable?.place(inputSearchOffset)
+            inputSearchPlaceable?.place(
+                finalPosition
+            )
         }
     }
 
@@ -488,6 +625,54 @@ private class LiteScreenHeaderPolicy(
     private val Placeable?.safeWidth
         get() = this?.width ?: 0
 
+    private fun Constraints.withAnimationTargetBounds(): Constraints {
+        val option = animationOption ?: return this
+        val progress = option.progress.value
+        if (progress >= 1f) return this
+
+        val targetWidth = option.targetBounds.width.roundToInt().coerceAtLeast(0)
+        val targetHeight = option.targetBounds.height.roundToInt().coerceAtLeast(0)
+        val animatedMinWidth = lerpPx(targetWidth, minWidth, progress)
+            .coerceInBounds(maxWidth)
+        val animatedMaxWidth = lerpMaxPx(targetWidth, maxWidth, progress)
+            .coerceAtLeast(animatedMinWidth)
+        val animatedMinHeight = lerpPx(targetHeight, minHeight, progress)
+            .coerceInBounds(maxHeight)
+        val animatedMaxHeight = lerpMaxPx(targetHeight, maxHeight, progress)
+            .coerceAtLeast(animatedMinHeight)
+
+        return copy(
+            minWidth = animatedMinWidth,
+            maxWidth = animatedMaxWidth,
+            minHeight = animatedMinHeight,
+            maxHeight = animatedMaxHeight,
+        )
+    }
+
+    private fun lerpPx(
+        start: Int,
+        stop: Int,
+        fraction: Float,
+    ): Int = androidx.compose.ui.util.lerp(
+        start.toFloat(),
+        stop.toFloat(),
+        fraction,
+    ).roundToInt()
+
+    private fun lerpMaxPx(
+        start: Int,
+        stop: Int,
+        fraction: Float,
+    ): Int {
+        if (stop == Constraints.Infinity) return Constraints.Infinity
+        return lerpPx(start, stop, fraction)
+    }
+
+    private fun Int.coerceInBounds(max: Int): Int {
+        if (max == Constraints.Infinity) return coerceAtLeast(0)
+        return coerceIn(0, max)
+    }
+
     private fun Placeable?.verticalCenterOffset(space: Int): Int {
         if (this == null) return 0
         return Alignment.CenterVertically.align(safeHeight, space)
@@ -524,7 +709,8 @@ data class LiteInputSearchProps(
 
     val placeHolder: String? = null,
 
-    val customBackIcon: @Composable (() -> Unit)? = null,
+    val cursorBrush: Brush? = null,
+    val customBackIcon: @Composable ((Modifier) -> Unit)? = null,
     val customSearchIcon: @Composable (() -> Unit)? = null,
     val customPlaceHolder: @Composable (() -> Unit)? = null,
     val customTextStyle: TextStyle? = null,
@@ -580,6 +766,7 @@ private fun LiteInputSearch(
             modifier = textFieldModifier,
             textStyle = inputSearchProps.customTextStyle ?: inputFieldStyle,
             singleLine = true,
+            cursorBrush = inputSearchProps.cursorBrush ?: SolidColor(Color.Black),
             interactionSource = interactionSource,
             decorationBox = { innerTextField ->
                 val isShowClear by remember(inputSearchProps.clearCondition, isFocused.value) {

package/gradle.properties

@@ -18,7 +18,7 @@ kotlin.apple.xcodeCompatibility.nowarn=true
 name="ComposeKits"
 group=vn.momo.kits
 artifact.id=kits
-version=0.160.9
+version=0.160.10
 
 repo=GitLab
 url=https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.160.9-debug",
+  "version": "0.160.10-debug",
   "private": false,
   "dependencies": {},
   "devDependencies": {},