@momo-kits/native-kits 0.167.1-duo.12-debug → 0.167.1-duo.13

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

@@ -1,831 +0,0 @@
-package vn.momo.kits.application
-
-import androidx.annotation.FloatRange
-import androidx.compose.animation.animateContentSize
-import androidx.compose.foundation.*
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.interaction.FocusInteraction
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.text.BasicTextField
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.composed
-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.SolidColor
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.layout.*
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.platform.LocalSoftwareKeyboardController
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.*
-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.Spacing
-import vn.momo.kits.const.Typography
-import vn.momo.kits.const.getFontFamily
-import vn.momo.kits.modifier.kitsAutomationId
-import vn.momo.kits.modifier.noFeedbackClickable
-import vn.momo.kits.modifier.setAutomationId
-import vn.momo.kits.navigation.component.HEADER_FONT_FAMILY
-import vn.momo.kits.navigation.component.HEADER_HEIGHT
-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(
-    scrollable: Boolean = true,
-    scrollState: ScrollState? = null,
-    headerType: HeaderType = HeaderType.DEFAULT,
-    verticalArrangement: Arrangement.Vertical = Arrangement.Top,
-    horizontalAlignment: Alignment.Horizontal = Alignment.Start,
-    backgroundColor: Color = AppTheme.current.colors.background.default,
-    /*  Begin of header props  */
-    title: String? = null,
-    inputSearchProps: LiteInputSearchProps? = null,
-    goBack: (() -> Unit)? = null,
-    headerRight: @Composable (() -> Unit)? = null,
-    useAnimationSearch: Boolean = true,
-    titlePosition: TitlePosition = TitlePosition.LEFT,
-    headerRightData: HeaderRightData? = null,
-    headerTintColor: Color? = null,
-    headerBackgroundColor: Color? = null,
-    headerSpaceBetween: Dp? = null,
-    /*  End of header props  */
-
-    screenContent: @Composable () -> Unit,
-) {
-    val content by rememberUpdatedState(screenContent)
-
-    val finalScrollState = scrollState ?: rememberScrollState()
-
-    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()
-            .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,
-    ) {
-        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"
-    const val TITLE_ID = "${PACKAGE_NAME}.title"
-
-    val EXTENDED_HEADER_HEIGHT = 154.dp
-}
-
-@Composable
-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,
-    headerType: HeaderType = HeaderType.DEFAULT,
-    titlePosition: TitlePosition = TitlePosition.LEFT,
-    useAnimationSearch: Boolean = true,
-    onGoBack: (() -> Unit)? = null,
-    headerBackgroundColor: Color? = null,
-    headerSpaceBetween: Dp? = null,
-    inputSearchProps: LiteInputSearchProps? = null,
-    headerRight: @Composable (() -> Unit)? = null,
-    content: @Composable () -> Unit,
-) {
-    val statusBarHeight = getAppStatusBarHeight()
-    val isHeaderNone = remember(headerType) {
-        headerType == HeaderType.NONE
-    }
-    val theme = AppTheme.current
-    val density = LocalDensity.current
-
-    val isHeaderExtend = remember(headerType) {
-        headerType == HeaderType.EXTENDED
-    }
-    val backgroundHeight = remember(isHeaderNone, isHeaderExtend, statusBarHeight) {
-        when {
-            isHeaderNone -> statusBarHeight
-            !isHeaderExtend -> statusBarHeight + HEADER_HEIGHT.dp
-            else -> HeaderId.EXTENDED_HEADER_HEIGHT
-        }
-    }
-    val listGradientColors = remember {
-        listOf(
-            Color(0xFFFDCADE),
-            Color(0x00FDCADE),
-        )
-    }
-
-    val headerColor = remember(tintColor, theme) {
-        if (tintColor == Colors.black_01) HeaderColor(
-            tintIconColor = tintColor,
-            backgroundButton = Colors.black_20.copy(alpha = 0.6f),
-            borderColor = Colors.black_01.copy(alpha = 0.2f)
-        )
-        else HeaderColor(
-            tintIconColor = tintColor ?: theme.colors.text.default,
-            backgroundButton = Colors.black_01.copy(alpha = 0.6f),
-            borderColor = Colors.black_20.copy(alpha = 0.2f)
-        )
-    }
-
-    val scrollPercentage = produceState(
-        initialValue = 0f,
-        key1 = useAnimationSearch,
-        key2 = scrollState,
-        key3 = backgroundHeight,
-    ) {
-        if (!useAnimationSearch) return@produceState
-        scrollState ?: return@produceState
-        val rangePx = with(density) { backgroundHeight.toPx() }
-        snapshotFlow { scrollState.value }.collectLatest {
-            value = (it / rangePx).coerceIn(0f, 1f)
-        }
-    }
-
-    val titleStyle = remember {
-        Typography.actionSBold.copy(
-            fontSize = 15.sp,
-            lineHeight = 22.sp,
-        )
-    }
-
-    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,
-    ) {
-        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(),
-        content = {
-            Box(
-                modifier = animationOpacityModifier
-                    .layoutId(HeaderId.CONTENT_ID)
-                    .then(contentModifier),
-                contentAlignment = Alignment.TopCenter,
-            ) {
-                content()
-            }
-
-            if (!isHeaderNone) {
-                Box(
-                    modifier = Modifier
-                        .layoutId(HeaderId.BACKGROUND_ID)
-                        .then(animationOpacityModifier)
-                        .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),
-                                        ),
-                                    )
-                                )
-                            }
-                        },
-                )
-            }
-
-            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),
-                ) {
-                    Icon(
-                        source = "arrow-back",
-                        color = headerColor.tintIconColor,
-                        size = 20.dp,
-                    )
-                }
-            }
-
-            if (!isHeaderNone) {
-                Box(
-                    modifier = Modifier
-                        .layoutId(HeaderId.HEADER_RIGHT_ID)
-                        .then(animationOpacityModifier)
-                ) {
-                    if (headerRight != null) {
-                        headerRight()
-                    } else {
-                        HeaderRight(
-                            headerRight = headerRightData,
-                            tintColor = tintColor,
-                        )
-                    }
-                }
-            }
-
-            if (!isHeaderNone && inputSearchProps != null) {
-                LiteInputSearch(
-                    modifier = Modifier.layoutId(HeaderId.INPUT_SEARCH_ID),
-                    inputSearchProps = inputSearchProps,
-                )
-            }
-            if (!isHeaderNone && title != null && (inputSearchProps == null || isHeaderExtend)) {
-                Text(
-                    text = title,
-                    color = headerColor.tintIconColor,
-                    style = titleStyle,
-                    fontFamily = HEADER_FONT_FAMILY,
-                    modifier = titleModifier,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis
-                )
-            }
-        },
-        measurePolicy = policy,
-    )
-}
-
-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
-    ): MeasureResult {
-        val spacing12 = Spacing.M.roundToPx()
-        val spaceBetween = headerSpaceBetween?.roundToPx() ?: spacing12
-        val statusBarPx = statusBarHeight.roundToPx()
-        val headerRowDefault = HEADER_HEIGHT.dp.roundToPx()
-        val scrollPercent = scrollPercentage.value
-
-        val contentMeasurable = measurables.find { it.layoutId == HeaderId.CONTENT_ID }
-
-        val realConstraints = constraints.copy(
-            minWidth = 0,
-            minHeight = 0,
-            maxWidth = (constraints.maxWidth - spacing12 * 2)
-                .coerceAtLeast(0),
-        )
-        val backIconPlaceable =
-            measurables.find { it.layoutId == HeaderId.BACK_ID }?.measure(realConstraints)
-        val headerRightPlaceable =
-            measurables.find { it.layoutId == HeaderId.HEADER_RIGHT_ID }?.measure(
-                realConstraints.copy(
-                    maxWidth = realConstraints.maxWidth / 2,
-                )
-            )
-        val baseInputSearchConstraints = if (isHeaderExtend) {
-            val minWidth =
-                if (useAnimationSearch) realConstraints.maxWidth - backIconPlaceable.safeWidth - headerRightPlaceable.safeWidth - spaceBetween * 2
-                else realConstraints.maxWidth
-            realConstraints.copy(
-                maxWidth = (realConstraints.maxWidth * (1 - scrollPercent)).toInt()
-                    .coerceAtLeast(minWidth)
-            )
-        } else {
-            var spaceConsumed = 0
-            if (backIconPlaceable.safeWidth != 0) spaceConsumed += backIconPlaceable.safeWidth + spaceBetween
-            if (headerRightPlaceable.safeWidth != 0) spaceConsumed += headerRightPlaceable.safeWidth + spaceBetween
-            realConstraints.copy(
-                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(
-            constraints = realConstraints.copy(
-                maxWidth = realConstraints.maxWidth - backIconPlaceable.safeWidth - headerRightPlaceable.safeWidth - spaceBetween * 2
-            )
-        )
-
-        /**
-         * replicate logic from [vn.momo.kits.navigation.component.HeaderBackground]
-         * */
-        var defaultHeight = statusBarPx + headerRowDefault
-        if (isHeaderExtend) {
-            defaultHeight = 154.dp.roundToPx()
-        }
-        val headerHeight = when {
-            isHeaderNone -> statusBarPx
-            !useAnimationSearch && !isHeaderExtend -> defaultHeight
-            else -> {
-                val collapsableSpace = defaultHeight - statusBarPx - headerRowDefault
-                (defaultHeight - scrollPercent * collapsableSpace).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 = layoutWidth,
-            height = layoutHeight,
-        ) {
-            val progress = animationOption?.progress?.value ?: 1f
-
-            val startX = 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,
-                    y = startY + backIconPlaceable.verticalCenterOffset(headerRowDefault),
-                )
-                curX += backIconPlaceable.safeWidth + spaceBetween
-            }
-
-            headerRightPlaceable?.place(
-                x = layoutWidth - spacing12 - headerRightPlaceable.safeWidth,
-                y = startY + headerRightPlaceable.verticalCenterOffset(headerRowDefault),
-            )
-
-            val titleOffset = IntOffset(
-                x = if (titlePosition == TitlePosition.LEFT) curX
-                else titlePlaceable.horizontalCenterOffset(
-                    space = layoutWidth,
-                    layoutDirection = layoutDirection,
-                ),
-                y = startY + titlePlaceable.verticalCenterOffset(headerRowDefault),
-            )
-
-            titlePlaceable?.place(titleOffset)
-
-            if (backIconPlaceable != null || headerRightPlaceable != null || titlePlaceable != null) {
-                curY += headerRowDefault
-            }
-
-            val inputSearchOffset = if (isHeaderExtend) {
-                val baseY = curY + inputSearchPlaceable.verticalCenterOffset(headerRowDefault)
-                val y = (baseY * (1 - scrollPercent)).toInt().coerceAtLeast(
-                    startY + inputSearchPlaceable.verticalCenterOffset(headerRowDefault)
-                )
-                IntOffset(
-                    x = startX + ((backIconPlaceable.safeWidth + spaceBetween) * (scrollPercent * 2f).coerceIn(
-                        0f, 1f
-                    )).toInt(),
-                    y = y,
-                )
-            } else {
-                IntOffset(
-                    x = curX,
-                    y = startY + inputSearchPlaceable.verticalCenterOffset(headerRowDefault),
-                )
-            }
-            val finalPosition = lerp(
-                searchStartPosition,
-                inputSearchOffset,
-                progress,
-            )
-
-            inputSearchPlaceable?.place(
-                finalPosition
-            )
-        }
-    }
-
-    private val Placeable?.safeHeight
-        get() = this?.height ?: 0
-    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)
-    }
-
-    private fun Placeable?.horizontalCenterOffset(
-        space: Int,
-        layoutDirection: LayoutDirection
-    ): Int {
-        if (this == null) return 0
-        return Alignment.CenterHorizontally.align(safeWidth, space, layoutDirection)
-    }
-}
-
-private val EMPTY_FUNC = {}
-
-@Stable
-data class LiteInputSearchProps(
-    val textFieldState: MutableState<String>,
-    val onValueChange: (String) -> Unit,
-    val onClear: () -> Unit = EMPTY_FUNC,
-    val clearCondition: (() -> Boolean)? = null,
-    val modifier: Modifier = Modifier,
-    val onFocused: (() -> Unit) = EMPTY_FUNC,
-    val keyboardOptions: KeyboardOptions = KeyboardOptions.Default,
-    val keyboardActions: KeyboardActions = KeyboardActions.Default,
-    val onKeyboardAction: (() -> Unit) = EMPTY_FUNC,
-
-    val btnText: String? = null,
-    val isShowBtnText: Boolean = !btnText.isNullOrEmpty(),
-    val onPressBtnText: (() -> Unit) = EMPTY_FUNC,
-
-    val disabled: Boolean = false,
-
-    val placeHolder: String? = 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,
-    val customIconClear: @Composable (() -> Unit)? = null,
-    val iconRightTextField: @Composable ((Modifier) -> Unit)? = null,
-)
-
-@Composable
-private fun LiteInputSearch(
-    modifier: Modifier = Modifier,
-    inputSearchProps: LiteInputSearchProps? = null,
-) {
-    inputSearchProps ?: return
-    val theme = AppTheme.current
-
-    val isFocused = remember { mutableStateOf(false) }
-    val interactionSource = remember { MutableInteractionSource() }
-    val textState by remember { inputSearchProps.textFieldState }
-
-    val isShowBtnText by remember(inputSearchProps.isShowBtnText, inputSearchProps.btnText) {
-        derivedStateOf {
-            inputSearchProps.isShowBtnText && !inputSearchProps.btnText.isNullOrEmpty()
-        }
-    }
-    val inputFieldFontFamily = getFontFamily(theme.font, Typography.bodyDefaultRegular.fontWeight)
-    val inputFieldStyle = remember(theme, inputFieldFontFamily) {
-        Typography.bodyDefaultRegular.copy(
-            color = theme.colors.text.default,
-            fontFamily = inputFieldFontFamily,
-        )
-    }
-
-    LaunchedEffect(inputSearchProps.onFocused) {
-        interactionSource.interactions.mapNotNull { it as? FocusInteraction }.collectLatest {
-            val isFocus = it is FocusInteraction.Focus
-            isFocused.value = isFocus
-            if (isFocus) inputSearchProps.onFocused()
-        }
-    }
-
-    Row(
-        modifier = modifier,
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        val textFieldModifier = remember(inputSearchProps.modifier) {
-            inputSearchProps.modifier
-                .weight(1f)
-        }
-        BasicTextField(
-            value = textState,
-            onValueChange = inputSearchProps.onValueChange,
-            enabled = !inputSearchProps.disabled,
-            keyboardOptions = inputSearchProps.keyboardOptions,
-            keyboardActions = inputSearchProps.keyboardActions,
-            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) {
-                    derivedStateOf {
-                        inputSearchProps.clearCondition?.invoke() == true || (isFocused.value && textState.isNotEmpty())
-                    }
-                }
-                val placeHolder by produceState<String?>(null, inputSearchProps.placeHolder) {
-                    if (inputSearchProps.placeHolder.isNullOrEmpty()) return@produceState
-                    snapshotFlow { textState }.collectLatest {
-                        value = if (it.isEmpty()) inputSearchProps.placeHolder else null
-                    }
-                }
-                val iconRightModifier = remember {
-                    Modifier
-                        .padding(start = Spacing.L)
-                        .drawWithContent {
-                            val offsetX = -Spacing.S.toPx()
-                            drawLine(
-                                start = Offset(
-                                    x = offsetX,
-                                    y = 0f,
-                                ),
-                                end = Offset(
-                                    x = offsetX,
-                                    y = size.height,
-                                ),
-                                color = theme.colors.primary,
-                                strokeWidth = 1.dp.toPx(),
-                            )
-                            drawContent()
-                        }
-                }
-
-                Row(
-                    modifier = Modifier
-                        .padding(
-                            horizontal = Spacing.M,
-                            vertical = Spacing.S,
-                        ),
-                    horizontalArrangement = Arrangement.Start,
-                    verticalAlignment = Alignment.CenterVertically,
-                ) {
-                    inputSearchProps.customSearchIcon?.invoke() ?: Icon(
-                        source = "navigation_search",
-                        modifier = Modifier.padding(end = Spacing.XS),
-                        size = 24.dp,
-                        color = theme.colors.text.hint
-                    )
-                    Box(
-                        modifier = Modifier.weight(1f),
-                        contentAlignment = Alignment.CenterStart,
-                    ) {
-                        if (!placeHolder.isNullOrEmpty()) {
-                            inputSearchProps.customPlaceHolder?.invoke() ?: Text(
-                                text = placeHolder ?: "",
-                                style = inputSearchProps.customTextStyle
-                                    ?: Typography.bodyDefaultRegular,
-                                maxLines = 1,
-                                color = theme.colors.text.hint,
-                                overflow = TextOverflow.Ellipsis
-                            )
-                        }
-                        innerTextField()
-                    }
-
-                    if (isShowClear) {
-                        inputSearchProps.customIconClear?.invoke() ?: Icon(
-                            source = "24_navigation_close_circle_full",
-                            size = 16.dp,
-                            color = theme.colors.text.hint,
-                            modifier = Modifier.padding(start = Spacing.XS)
-                                .noFeedbackClickable(onClick = inputSearchProps.onClear),
-                        )
-                    }
-
-                    inputSearchProps.iconRightTextField?.invoke(iconRightModifier)
-                }
-            }
-        )
-
-        if (isShowBtnText) {
-            Text(
-                text = inputSearchProps.btnText ?: "",
-                style = Typography.actionDefaultBold,
-                color = theme.colors.text.default,
-                modifier = Modifier.padding(start = Spacing.L)
-                    .noFeedbackClickable(onClick = inputSearchProps.onPressBtnText)
-            )
-        }
-    }
-}
-
-fun Modifier.hideKeyboardOnTap() = composed {
-    val focusManager = LocalFocusManager.current
-    val keyboardManager = LocalSoftwareKeyboardController.current
-
-    pointerInput(Unit) {
-        detectTapGestures {
-            keyboardManager?.hide()
-            focusManager.clearFocus()
-        }
-    }
-}