@momo-kits/native-kits 0.300.3-debug → 0.300.4-debug

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

@@ -1,378 +0,0 @@
-package vn.momo.kits.application
-
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.ScrollState
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.layout.LayoutCoordinates
-import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalSoftwareKeyboardController
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.IntOffset
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.zIndex
-import kotlinx.coroutines.*
-import vn.momo.kits.components.InputSearchProps
-import vn.momo.kits.const.AppNavigationBar
-import vn.momo.kits.const.AppTheme
-import vn.momo.kits.const.Colors
-import vn.momo.kits.const.Spacing
-import vn.momo.kits.modifier.conditional
-import vn.momo.kits.modifier.DeprecatedModifier
-import vn.momo.kits.modifier.shadow
-import vn.momo.kits.navigation.component.SnackBar
-import vn.momo.kits.platform.supportsImePadding
-import vn.momo.kits.utils.getAppStatusBarHeight
-import vn.momo.kits.utils.getNavigationBarHeight
-import kotlin.time.Duration.Companion.milliseconds
-
-enum class HeaderType {
-    DEFAULT,
-    EXTENDED,
-    NONE
-}
-
-const val HEADER_HEIGHT = 52
-
-@Deprecated("Use NavigationContainer(StackScreen) instead", ReplaceWith("NavigationContainer(StackScreen)"))
-@Composable
-fun Screen(
-    backgroundColor: Color? = null,
-    tintColor: Color? = null,
-    headerTransparent: Boolean = false,
-    fullScreenContent: Boolean = false,
-    isBack: Boolean = true,
-    headerType: HeaderType = HeaderType.DEFAULT,
-    verticalArrangement: Arrangement.Vertical = Arrangement.Top,
-    horizontalAlignment: Alignment.Horizontal = Alignment.Start,
-    title: String = "Stack",
-    titlePosition: TitlePosition = TitlePosition.LEFT,
-    goBack: (() -> Unit)? = null,
-    scrollable: Boolean = true,
-    scrollState: ScrollState = rememberScrollState(),
-    onContentLayout: ((LayoutCoordinates) -> Unit)? = null,
-    useAvoidKeyboard: Boolean = true,
-    footer: @Composable (() -> Unit)? = null,
-    headerRight: @Composable (() -> Unit)? = null,
-    fabProps: FabProps? = null,
-    animatedHeader: AnimatedHeader? = null,
-    layoutOffset: Dp = 56.dp,
-    inputSearchProps: InputSearchProps? = null,
-    useAnimationSearch: Boolean = false,
-    headerRightWidth: Dp = 0.dp,
-    content: @Composable () -> Unit,
-) {
-    val statusBarHeight = getAppStatusBarHeight()
-    val keyboardController = LocalSoftwareKeyboardController.current
-
-    val isKeyboardVisible = isKeyboardVisible()
-    val indicator = getNavigationBarHeight()
-    val bottomPadding = if (isKeyboardVisible) 0.dp else indicator
-
-    val headerHeight = if (animatedHeader !== null)
-        with(LocalDensity.current) { layoutOffset.roundToPx() }
-    else HEADER_HEIGHT
-    val opacity by animateFloatAsState(
-        targetValue = ((scrollState.value.toFloat() / headerHeight)).coerceIn(0f, 1f),
-    )
-
-    val headerAnimated =
-        @Composable {
-            Box(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .aspectRatio(animatedHeader?.aspectRatio?.value ?: AnimatedHeaderRatio.RATIO_16_9.value)
-            ) {
-                animatedHeader?.composable?.invoke(scrollState.value)
-            }
-        }
-    val helper = remember { ScreenHelper() }
-
-    DisposableEffect(Unit) {
-        onDispose { helper.dispose() }
-    }
-
-    CompositionLocalProvider(
-        LocalScreenHelper provides helper
-    ) {
-        Box(
-            Modifier.fillMaxSize()
-                .background(backgroundColor ?: AppTheme.current.colors.background.default)
-                .conditional(useAvoidKeyboard && supportsImePadding()) {
-                    imePadding()
-                }.then(DeprecatedModifier())
-        ) {
-            val footerHeightPx = remember { mutableStateOf(0) }
-
-            Box(Modifier.zIndex(1f)) {
-                if (animatedHeader === null) {
-                    HeaderBackground(
-                        headerType = headerType,
-                        scrollState = scrollState.value,
-                        headerTransparent = headerTransparent
-                    )
-                }
-            }
-
-            Box(Modifier.zIndex(5f)) {
-                Header(
-                    headerType = headerType,
-                    title = title,
-                    titlePosition = titlePosition,
-                    headerRight = headerRight,
-                    headerRightWidth = headerRightWidth,
-                    goBack = goBack,
-                    opacity = opacity,
-                    animatedHeader = animatedHeader,
-                    inputSearchProps = inputSearchProps,
-                    scrollState = scrollState.value,
-                    useAnimationSearch = useAnimationSearch,
-                    tintColor = tintColor
-                )
-            }
-
-            Box(Modifier.zIndex(2f).fillMaxSize()){
-                Column(
-                    modifier = Modifier.fillMaxSize()
-                        .padding( top = when {
-                            animatedHeader != null -> 0.dp
-                            headerType == HeaderType.NONE -> 0.dp
-                            fullScreenContent -> 0.dp
-                            else -> statusBarHeight + HEADER_HEIGHT.dp
-                        })
-                        .pointerInput(Unit) {
-                            detectTapGestures(onTap = {
-                                keyboardController?.hide()
-                            })
-                        }
-                        .zIndex(1f),
-                ) {
-
-                    Column(
-                        modifier = Modifier
-                            .conditional(scrollable) { weight(1f) }
-                            .conditional(onContentLayout != null) {
-                                onGloballyPositioned(onContentLayout ?: {})
-                            }
-                            .conditional(scrollable) { verticalScroll(scrollState) },
-                        verticalArrangement = verticalArrangement,
-                        horizontalAlignment = horizontalAlignment
-                    ) {
-                        Box {
-                            if (animatedHeader !== null) headerAnimated()
-                            Column {
-                                if (animatedHeader !== null) {
-                                    Spacer(modifier = Modifier.padding(top = statusBarHeight + HEADER_HEIGHT.dp + layoutOffset))
-                                }
-
-                                if (useAnimationSearch && inputSearchProps != null && headerType == HeaderType.EXTENDED) {
-                                    Spacer(modifier = Modifier.padding(top = (HEADER_HEIGHT.dp + Spacing.S)))
-                                }
-                                content()
-                            }
-                        }
-                    }
-
-                    footer?.let {
-                        val footerHeight = with(LocalDensity.current) { footerHeightPx.value.toDp() }
-                        Spacer(Modifier.height(footerHeight))
-                    }
-                }
-            }
-
-            Box(Modifier.zIndex(4f).align(Alignment.BottomCenter)) {
-                footer?.let {
-                    Footer(
-                        footer = footer,
-                        bottom = bottomPadding,
-                        onFooterMeasured = { footerHeightPx.value = it }
-                    )
-                }
-            }
-
-            Column (Modifier.zIndex(6f)) {
-                if (fabProps != null) {
-                    FloatingButton(
-                        scrollPosition = fabProps.scrollState?.value ?: scrollState.value,
-                        onClick = fabProps.onClick,
-                        containerColor = AppTheme.current.colors.primary,
-                        bottom = fabProps.bottom
-                            ?: if (footer != null) bottomPadding + 76.dp else bottomPadding + 12.dp,
-                        icon = fabProps.icon,
-                        iconColor = fabProps.iconColor,
-                        text = fabProps.label,
-                        size = fabProps.size,
-                        position = fabProps.position ?: FABPosition.END,
-                    )
-                }
-            }
-
-            Box(
-                modifier = Modifier
-                    .align(Alignment.BottomCenter)
-                    .zIndex(3f)
-            ) {
-                ScreenSnackBarHost(if (footer == null) 0 else footerHeightPx.value)
-            }
-        }
-    }
-}
-
-@Composable
-internal fun isKeyboardVisible(): Boolean {
-    val ime = WindowInsets.ime
-    val density = LocalDensity.current
-    val bottom = ime.getBottom(density)
-    return bottom > 0
-}
-
-@Composable
-fun Footer(
-    footer: @Composable (() -> Unit)? = null,
-    bottom: Dp = 0.dp,
-    onFooterMeasured: ((Int) -> Unit)? = null
-) {
-    Box(
-        Modifier
-            .shadow(
-                color = Colors.black_20.copy(alpha = 0.05f),
-                blurRadius = 24f,
-                offsetX = 0.dp,
-                offsetY = (-4).dp
-            )
-            .background(AppTheme.current.colors.background.surface)
-            .onGloballyPositioned {
-                onFooterMeasured?.invoke(it.size.height)
-            }
-            
-    ) {
-        Box(
-            Modifier.fillMaxWidth()
-                .padding(bottom = bottom)
-                .padding(vertical = Spacing.S, horizontal = Spacing.M)
-        ) {
-            footer?.invoke()
-        }
-    }
-}
-
-
-class ScreenHelper {
-
-    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
-
-    internal var snackBarState by mutableStateOf<SnackBarData?>(null)
-
-    internal var requestHide by mutableStateOf(false)
-
-    fun showSnackBar(snackBar: SnackBar, onDismiss: (() -> Unit)? = null) {
-        scope.launch {
-            requestHide = false
-            snackBarState = SnackBarData(snackBar, onDismiss)
-        }
-    }
-
-    fun hideSnackBar() {
-        scope.launch {
-            requestHide = true
-        }
-    }
-
-    internal fun removeSnackBarNow() {
-        snackBarState = null
-        requestHide = false
-    }
-
-    fun dispose() {
-        scope.cancel()
-    }
-}
-data class SnackBarData(
-    val type: SnackBar,
-    val onDismiss: (() -> Unit)?
-)
-
-val LocalScreenHelper = staticCompositionLocalOf<ScreenHelper> {
-    error("No Screen helper provided")
-}
-
-@Composable
-internal fun ScreenSnackBarHost(footerHeightPx: Int) {
-    val helper = LocalScreenHelper.current
-    val snackBarData = helper.snackBarState ?: return
-    val density = LocalDensity.current
-    val navigationBar = AppNavigationBar.current
-
-    val footerHeight = if (footerHeightPx > 0) {
-            footerHeightPx
-    } else {
-        with(density) {
-            navigationBar.toPx()
-        }
-    }.toInt()
-
-    var startPosition by remember { mutableStateOf(Float.MAX_VALUE) }
-    val targetPosition = 0f
-
-    var offsetY by remember { mutableStateOf(Animatable(startPosition)) }
-
-    LaunchedEffect(startPosition) {
-        if (startPosition != Float.MAX_VALUE){
-            offsetY.snapTo(startPosition)
-            offsetY.animateTo(targetPosition, tween(350))
-        }
-    }
-
-    LaunchedEffect(helper.requestHide) {
-        if (helper.requestHide) {
-            offsetY.animateTo(startPosition, tween(200))
-            helper.removeSnackBarNow()
-            snackBarData.onDismiss?.invoke()
-        }
-    }
-
-    LaunchedEffect(snackBarData.type.duration) {
-        val duration = snackBarData.type.duration
-        if (duration != null) {
-            delay(duration.milliseconds)
-            helper.hideSnackBar()
-        }
-    }
-
-    DisposableEffect(Unit) {
-        onDispose { snackBarData.onDismiss?.invoke() }
-    }
-
-    Box(
-        modifier = Modifier
-            .offset { IntOffset(0, offsetY.value.toInt() - footerHeight) }
-            .onGloballyPositioned {
-                if (startPosition != it.size.height.toFloat()) {
-                    startPosition = it.size.height.toFloat()
-                    offsetY = Animatable(startPosition)
-                }
-            }
-            .fillMaxWidth()
-    ) {
-        when (val type = snackBarData.type) {
-            is SnackBar.Custom -> type.content()
-            is SnackBar.Toast -> {}
-        }
-    }
-}
-
-
-
-
-

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

@@ -1,69 +0,0 @@
-package vn.momo.kits.application
-
-import androidx.compose.animation.animateColorAsState
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import vn.momo.kits.const.AppTheme
-import vn.momo.kits.const.Colors
-import vn.momo.kits.platform.getScreenDimensions
-
-data class HeaderAnimations(
-    val opacity: Float,
-    val backgroundSearch: Color,
-    val translateX: Float,
-    val width: Float,
-    val translateY: Float
-)
-
-private const val SCREEN_PADDING = 12
-private const val BACK_WIDTH = 28
-
-@Deprecated("Use vn.momo.kits.navigation.component.Header instead", ReplaceWith("vn.momo.kits.navigation.component.Header"))
-@Composable
-internal fun useHeaderSearchAnimation(
-    opacityAni: Float,
-    scrollState: Int,
-    headerRightWidth: Dp,
-    isBack: Boolean
-): HeaderAnimations {
-    val screenWidth = getScreenDimensions().width
-    val leftPosition = if (isBack) (BACK_WIDTH + 20).dp else 12.dp
-    val searchWidth = screenWidth - (SCREEN_PADDING * 2)
-
-    val backgroundSearch by animateColorAsState(
-        targetValue = animateColor(
-            Colors.black_01,
-            AppTheme.current.colors.background.default,
-            opacityAni
-        ),
-    )
-
-    val animatedTranslateX by animateFloatAsState(
-        targetValue = (scrollState / HEADER_HEIGHT * 1f).coerceIn(
-            0f,
-            1f
-        ) * (leftPosition.value - 12) + 12,
-    )
-
-    val animatedWidth by animateFloatAsState(
-        targetValue = (scrollState / HEADER_HEIGHT * 1f).coerceIn(
-            0f,
-            1f
-        ) * ((searchWidth - leftPosition.value - headerRightWidth.value + 12) - searchWidth) + searchWidth,
-    )
-
-    val animatedTranslateY by animateFloatAsState(
-        targetValue = (1 - (scrollState / HEADER_HEIGHT * 1f).coerceIn(0f, 1f)) * HEADER_HEIGHT
-    )
-    return HeaderAnimations(
-        opacity = opacityAni,
-        backgroundSearch = backgroundSearch,
-        translateX = animatedTranslateX,
-        width = animatedWidth,
-        translateY = animatedTranslateY
-    )
-}

package/compose/src/commonMain/kotlin/vn/momo/kits/const/KitDesignSystem.kt

@@ -1,18 +0,0 @@
-package vn.momo.kits.const
-
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-
-// Design-system rollout holder, same shape as KitFontScale: the kit is sandboxed and can't read the
-// host config, so the host seeds this once at startup from DesignSystemConfig. getFontFamily() reads
-// it to decide whether the new default font applies, so every screen follows the flag with no prop
-// threading. Backed by snapshot state: writes recompose text automatically.
-object KitDesignSystem {
-    var isWhiteList by mutableStateOf(false)
-        private set
-
-    fun update(isWhiteList: Boolean) {
-        this.isWhiteList = isWhiteList
-    }
-}

package/compose/src/commonMain/kotlin/vn/momo/kits/const/KitFontScale.kt

@@ -1,22 +0,0 @@
-package vn.momo.kits.const
-
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-
-// App-wide font-scale holder. The kit is sandboxed and can't read the host cache directly, so the
-// host (which sees both core and this kit) seeds this once at startup and pushes runtime updates into
-// it. scaleSize() reads it as the fallback, so every screen — including direct NavigationContainer
-// screens with no host-pushed MiniAppContext — scales with no per-render prop and no async flicker.
-// Backed by snapshot state: writes recompose text automatically.
-object KitFontScale {
-    var userScaleRate by mutableStateOf(1f)
-        private set
-    var useOSScaleRate by mutableStateOf(true)
-        private set
-
-    fun update(userScaleRate: Float, useOSScaleRate: Boolean) {
-        this.userScaleRate = userScaleRate
-        this.useOSScaleRate = useOSScaleRate
-    }
-}