@momo-kits/native-kits 0.162.6-debug → 0.162.6

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/BottomSheet.kt

@@ -1,253 +0,0 @@
-package vn.momo.kits.navigation
-
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.CubicBezierEasing
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.border
-import androidx.compose.foundation.gestures.detectDragGestures
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.BoxWithConstraints
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxHeight
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.offset
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-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.platform.LocalDensity
-import androidx.compose.ui.unit.IntOffset
-import androidx.compose.ui.unit.dp
-import kotlinx.coroutines.launch
-import vn.momo.kits.components.Divider
-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.application.ApplicationContext
-import vn.momo.kits.application.IsShowBaseLineDebug
-import vn.momo.kits.const.Typography
-import vn.momo.kits.navigation.tracking.ScreenTracker
-import vn.momo.kits.modifier.conditional
-import vn.momo.kits.modifier.noFeedbackClickable
-import vn.momo.kits.platform.BackHandler
-import vn.momo.kits.platform.getScreenHeight
-
-@Composable
-internal fun BottomSheet(
-    content: @Composable () -> Unit,
-    header: BottomHeader,
-    isSurface: Boolean = false,
-    barrierDismissible: Boolean = true,
-    onDismiss: (() -> Unit)?
-) {
-    val navigator = LocalNavigator.current
-
-    val screenHeightDp = getScreenHeight()
-    val screenHeightPx = with(LocalDensity.current) { screenHeightDp.toPx() }
-    val sheetOffset = remember { Animatable(screenHeightPx) }
-
-    val backgroundAlpha = remember { Animatable(0f) }
-    val dynamicAlpha = ((1f - (sheetOffset.value / screenHeightPx)).coerceIn(0f, 1f)) * 0.3f
-    val alpha = backgroundAlpha.value + dynamicAlpha
-
-    val sheetCloseOffset = with(LocalDensity.current) { 100.dp.toPx() }
-
-    val coroutineScope = rememberCoroutineScope()
-
-    val maxApi = LocalMaxApi.current
-    val context = ApplicationContext.current
-
-    DisposableEffect(Unit) {
-        ScreenTracker.trackPopupDisplayed(
-            maxApi = maxApi,
-            context = context,
-            parentScreenName = ScreenTracker.getLastScreenName()
-        )
-        onDispose { }
-    }
-
-    suspend fun openEvent(){
-        backgroundAlpha.animateTo(
-            targetValue = 0.3f,
-            animationSpec = tween(
-                durationMillis = 100,
-                easing = CubicBezierEasing(0.05f, 0.7f, 0.1f, 1f)
-            )
-        )
-        sheetOffset.animateTo(
-            targetValue = 0f,
-            animationSpec = tween(
-                durationMillis = 350,
-                easing = CubicBezierEasing(0.05f, 0.7f, 0.1f, 1f)
-            )
-        )
-    }
-
-    fun closeEvent(){
-        coroutineScope.launch {
-            sheetOffset.animateTo(
-                targetValue = screenHeightPx,
-                animationSpec = tween(
-                    durationMillis = 200,
-                    easing = CubicBezierEasing(0.3f, 0.0f, 0.8f, 0.15f)
-                )
-            )
-            backgroundAlpha.animateTo(
-                targetValue = 0f,
-                animationSpec = tween(
-                    durationMillis = 100,
-                    easing = CubicBezierEasing(0.3f, 0.0f, 0.8f, 0.15f)
-                )
-            )
-            navigator.pop()
-        }
-    }
-
-    LaunchedEffect(Unit) {
-        openEvent()
-    }
-
-    DisposableEffect(Unit) {
-        OverplayComponentRegistry.bindClose { closeEvent() }
-        onDispose {
-            onDismiss?.invoke()
-        }
-    }
-
-    BackHandler(true){
-        closeEvent()
-    }
-
-    BoxWithConstraints(
-        modifier = Modifier
-            .fillMaxSize()
-            .background(Color.Black.copy(alpha = alpha))
-            .noFeedbackClickable {
-                if(barrierDismissible) closeEvent()
-            }
-    ) {
-        val parentHeight = with(LocalDensity.current) { constraints.maxHeight.toDp() }
-
-        Box(
-            modifier = Modifier
-                .align(Alignment.BottomCenter)
-                .offset { IntOffset(x = 0, y = sheetOffset.value.toInt()) }
-                .fillMaxWidth()
-                .heightIn(max = parentHeight - 90.dp)
-                .background(
-                    color = if (isSurface) AppTheme.current.colors.background.surface else AppTheme.current.colors.background.default,
-                    shape = RoundedCornerShape(topStart = Radius.M, topEnd = Radius.M)
-                )
-                .conditional(IsShowBaseLineDebug) {
-                    border(1.dp, Colors.blue_03)
-                }
-                .noFeedbackClickable {  },
-            contentAlignment = Alignment.BottomCenter
-        ) {
-            Column {
-                Box(
-                    modifier = Modifier
-                        .height(72.dp)
-                        .fillMaxWidth()
-                        .pointerInput(Unit) {
-                            detectDragGestures(
-                                onDrag = { change, dragAmount ->
-                                    change.consume()
-                                    coroutineScope.launch {
-                                        val newOffset = (sheetOffset.value + dragAmount.y).coerceAtLeast(0f)
-                                        sheetOffset.snapTo(newOffset)
-                                    }
-                                },
-                                onDragEnd = {
-                                    coroutineScope.launch {
-                                        if (sheetOffset.value > sheetCloseOffset) {
-                                            closeEvent()
-                                        } else {
-                                            sheetOffset.animateTo(0f)
-                                        }
-                                    }
-                                }
-                            )
-                        }
-                ) {
-                    Column(
-                        modifier = Modifier
-                            .fillMaxSize()
-                            .padding(horizontal = Spacing.M),
-                        horizontalAlignment = Alignment.CenterHorizontally
-                    ) {
-                        Spacer(Modifier.height(8.dp))
-                        Box(
-                            modifier = Modifier
-                                .height(4.dp)
-                                .width(40.dp)
-                                .background(
-                                    color = Colors.black_06,
-                                    shape = RoundedCornerShape(Radius.S)
-                                )
-                        )
-                        Spacer(Modifier.height(4.dp))
-                        Box(Modifier.fillMaxWidth().height(56.dp), contentAlignment = Alignment.Center){
-                            when (header) {
-                                is BottomHeader.Title -> {
-                                    Row(modifier = Modifier.fillMaxSize(), verticalAlignment = Alignment.CenterVertically) {
-                                        Box(Modifier.size(24.dp))
-                                        Box(Modifier.fillMaxHeight().weight(1f), contentAlignment = Alignment.Center){
-                                            Text(
-                                                text = header.data,
-                                                color = Colors.black_17,
-                                                style = Typography.headerDefaultBold
-                                            )
-                                        }
-                                        Box(Modifier
-                                            .size(24.dp)
-                                            .noFeedbackClickable {
-                                                closeEvent()
-                                            },
-                                            contentAlignment = Alignment.Center
-                                        ){
-                                            Icon(source = "navigation_close")
-                                        }
-                                    }
-                                }
-                                is BottomHeader.Custom -> {
-                                    header.content()
-                                }
-                            }
-                        }
-                    }
-                }
-                Divider()
-                content()
-            }
-        }
-    }
-}
-
-sealed class BottomHeader {
-    data class Title(
-        val data: String = "Bottom Sheet Title",
-    ) : BottomHeader()
-
-    data class Custom(
-        val content: @Composable () -> Unit
-    ) : BottomHeader()
-}

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/ModalScreen.kt

@@ -1,129 +0,0 @@
-package vn.momo.kits.navigation
-
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.CubicBezierEasing
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.wrapContentSize
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
-import androidx.compose.ui.draw.scale
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.unit.dp
-import kotlinx.coroutines.launch
-import vn.momo.kits.application.ApplicationContext
-import vn.momo.kits.application.IsShowBaseLineDebug
-import vn.momo.kits.const.Colors
-import vn.momo.kits.modifier.conditional
-import vn.momo.kits.modifier.noFeedbackClickable
-import vn.momo.kits.navigation.tracking.ScreenTracker
-import vn.momo.kits.platform.BackHandler
-
-@Composable
-internal fun ModalScreen(
-    content: @Composable () -> Unit,
-    barrierDismissible: Boolean = true,
-    onDismiss: (() -> Unit)? = null
-) {
-    val navigator = LocalNavigator.current
-
-    val alpha = remember { Animatable(0f) }
-    val scale = remember { Animatable(0.8f) }
-
-    val coroutineScope = rememberCoroutineScope()
-
-    val maxApi = LocalMaxApi.current
-    val context = ApplicationContext.current
-
-    DisposableEffect(Unit) {
-        ScreenTracker.trackPopupDisplayed(
-            maxApi = maxApi,
-            context = context,
-            parentScreenName = ScreenTracker.getLastScreenName()
-        )
-        onDispose { }
-    }
-
-    fun openEvent() {
-        coroutineScope.launch {
-            launch {
-                alpha.animateTo(
-                    targetValue = 1f,
-                    animationSpec = tween(durationMillis = 250)
-                )
-            }
-            launch {
-                scale.animateTo(
-                    targetValue = 1f,
-                    animationSpec = tween(
-                        durationMillis = 250,
-                        easing = CubicBezierEasing(0.2f, 0.0f, 0f, 1f)
-                    )
-                )
-            }
-        }
-    }
-
-    fun closeEvent() {
-        coroutineScope.launch {
-            alpha.animateTo(
-                targetValue = 0f,
-                animationSpec = tween(durationMillis = 200)
-            )
-            scale.animateTo(
-                targetValue = 0.8f,
-                animationSpec = tween(durationMillis = 200)
-            )
-            navigator.pop()
-        }
-    }
-
-    LaunchedEffect(Unit) {
-        openEvent()
-    }
-
-    DisposableEffect(Unit) {
-        OverplayComponentRegistry.bindClose { closeEvent() }
-        onDispose {
-            onDismiss?.invoke()
-        }
-    }
-
-    BackHandler(enabled = true) {
-        closeEvent()
-    }
-
-    Box(
-        modifier = Modifier
-            .fillMaxSize()
-            .background(Color.Black.copy(alpha = 0.6f * alpha.value))
-            .noFeedbackClickable {
-                if(barrierDismissible) closeEvent()
-            },
-        contentAlignment = Alignment.Center
-    ) {
-        Box(
-            modifier = Modifier
-                .scale(scale.value)
-                .alpha(alpha.value)
-                .wrapContentSize()
-                .conditional(IsShowBaseLineDebug) {
-                    border(1.dp, Colors.blue_03)
-                }
-                .clickable(
-                    indication = null,
-                    interactionSource = remember { MutableInteractionSource() }
-                ) {},
-        contentAlignment = Alignment.Center
-        ) {
-            content()
-        }
-    }
-}

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/Navigation.kt

@@ -1,94 +0,0 @@
-package vn.momo.kits.navigation
-
-import androidx.compose.foundation.gestures.ScrollableState
-import androidx.compose.runtime.*
-import androidx.compose.ui.graphics.Color
-import vn.momo.kits.navigation.bottomtab.setBottomTabOption
-import vn.momo.kits.navigation.component.*
-
-class Navigation(
-    val id: Int = -1,
-    val bottomTabIndex: Int = -1,
-    val initOptions: NavigationOptions? = null,
-    private val registry: DynamicScreenRegistry? = null
-) {
-    private val _options = mutableStateOf(initOptions ?: NavigationOptions())
-    val currentOptions: State<NavigationOptions> get() = _options
-    val options: NavigationOptions get() = _options.value
-
-    fun setOptions(
-        onBackHandler: (() -> Unit)? = null,
-        hiddenBack: Boolean? = null,
-        headerBackProps: HeaderBackProps? = null,
-        headerTitle: HeaderTitle? = null,
-        titlePosition: TitlePosition? = null,
-        headerRight: HeaderRight? = null,
-        headerType: HeaderType? = null,
-        scrollData: ScrollData? = null,
-        backgroundColor: Color? = null,
-        tintColor: Color? = null,
-        footerComponent: (@Composable () -> Unit)? = null,
-        floatingButtonProps: FloatingButtonProps? = null,
-        keyboardOptions: KeyboardOptions? = null
-    ) {
-        updateOptions(
-            options.copy(
-                onBackHandler = onBackHandler ?: options.onBackHandler,
-                hiddenBack = hiddenBack ?: options.hiddenBack,
-                headerBackProps = headerBackProps ?: options.headerBackProps,
-                headerTitle = headerTitle ?: options.headerTitle,
-                titlePosition = titlePosition ?: options.titlePosition,
-                headerRight = headerRight ?: options.headerRight,
-                headerType = headerType ?: options.headerType,
-                scrollData = scrollData ?: options.scrollData,
-                backgroundColor = backgroundColor ?: options.backgroundColor,
-                tintColor = tintColor ?: options.tintColor,
-                footerComponent = footerComponent ?: options.footerComponent,
-                floatingButtonProps = floatingButtonProps ?: options.floatingButtonProps,
-                keyboardOptions = keyboardOptions ?: options.keyboardOptions,
-            )
-        )
-    }
-
-    fun setOptions(newOptions: NavigationOptions) {
-        updateOptions(newOptions)
-    }
-
-    private fun updateOptions(updated: NavigationOptions) {
-        _options.value = updated
-        if (bottomTabIndex != -1) setBottomTabOption(bottomTabIndex, updated)
-        if (id != -1) registry?.setOptions(id, updated)
-    }
-}
-
-val LocalNavigation = staticCompositionLocalOf<Navigation> {
-    error("No NavigationStack provided")
-}
-
-@Stable
-data class NavigationOptions(
-    val screenName: String? = null,
-    val onBackHandler: (() -> Unit)? = null,
-    val hiddenBack: Boolean = false,
-    val headerBackProps: HeaderBackProps = HeaderBackProps(),
-    val headerTitle: HeaderTitle = HeaderTitle.Default("Stack"),
-    val titlePosition: TitlePosition = TitlePosition.LEFT,
-    val headerRight: HeaderRight = HeaderRight.Toolkit(),
-    val headerType: HeaderType = HeaderType.Default(),
-    val scrollData: ScrollData = ScrollData(),
-    val backgroundColor: Color? = null,
-    val tintColor: Color? = null,
-    val footerComponent: @Composable (() -> Unit)? = null,
-    val floatingButtonProps: FloatingButtonProps? = null,
-    val keyboardOptions: KeyboardOptions = KeyboardOptions()
-)
-
-data class KeyboardOptions(
-    val keyboardShouldPersistTaps: Boolean = false,
-    val useAvoidKeyboard: Boolean = true
-)
-data class ScrollData(
-    val scrollable: Boolean = true,
-    val scrollState: ScrollableState? = null,
-    val scrollToTopCallback: (() -> Unit)? = null,
-)

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/NavigationContainer.kt

@@ -1,186 +0,0 @@
-package vn.momo.kits.navigation
-
-import androidx.compose.animation.*
-import androidx.compose.animation.core.tween
-import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.ui.unit.Dp
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import androidx.navigation.compose.rememberNavController
-import androidx.navigation.toRoute
-import kotlinx.coroutines.flow.collect
-import vn.momo.kits.application.*
-import vn.momo.kits.const.*
-import vn.momo.kits.platform.ProvideNavigationEventDispatcherOwner
-import vn.momo.kits.utils.getAppStatusBarHeight
-import vn.momo.kits.utils.getNavigationBarHeight
-import vn.momo.maxapi.IMaxApi
-
-@Composable
-fun NavigationContainer(
-    initialScreenName: String,
-    initialScreen: @Composable () -> Unit,
-    options: NavigationOptions? = null,
-    initialTheme: Theme = defaultTheme,
-    applicationContext: MiniAppContext? = null,
-    maxApi: IMaxApi? = null,
-    setNavigator: ((Navigator) -> Unit)? = null,
-    statusBarHeight: Dp? = null,
-    config: KitConfig? = null,
-    language: String? = null
-){
-    val navController = rememberNavController()
-    val registry = remember { DynamicScreenRegistry() }
-    val navigator = remember { Navigator(navController = navController, maxApi = maxApi, registry = registry) }
-    val statusBarHeight = statusBarHeight ?: getAppStatusBarHeight()
-    val navigationBarHeight = getNavigationBarHeight()
-
-    val parentContext = ApplicationContext.current
-    val mergedContext = MiniAppContext.merge(parentContext, applicationContext)
-
-    var observerFontScaleConfig by remember { mutableStateOf(mergedContext?.fontScaleConfig) }
-    LaunchedEffect(maxApi) {
-        val api = maxApi ?: return@LaunchedEffect
-        runCatching {
-            api.observer(FONT_SCALE_OBSERVER_KEY).collect { data ->
-                observerFontScaleConfig = parseFontScaleConfig(data)
-            }
-        }
-    }
-
-    val theme = remember { mutableStateOf(initialTheme) }
-
-    LaunchedEffect(Unit) {
-        val headerBar = config?.headerBar
-        if (headerBar != null && theme.value.assets.headerBackground == null) {
-            theme.value = theme.value.copy(
-                assets = ThemeAssets(
-                    headerBackground = headerBar
-                )
-            )
-        }
-    }
-
-    val screenId = rememberSaveable { registry.nextId() }
-    registry.bind(screenId, initialScreenName, initialScreen, options)
-    val startDestination = remember(screenId) { DynamicScreenRoute(screenId) }
-
-    ProvideNavigationEventDispatcherOwner {
-        CompositionLocalProvider(
-            LocalNavigator provides navigator,
-            LocalDynamicScreenRegistry provides registry,
-            LocalMaxApi provides maxApi,
-            AppTheme provides theme.value,
-            AppStatusBar provides statusBarHeight,
-            AppNavigationBar provides navigationBarHeight,
-            ApplicationContext provides mergedContext,
-            AppConfig provides config,
-            AppLanguage provides language,
-            LocalFontScaleConfig provides (observerFontScaleConfig ?: LocalFontScaleConfig.current),
-        ) {
-            LaunchedEffect(Unit) {
-                setNavigator?.invoke(navigator)
-            }
-
-            NavHost(navController, startDestination = startDestination) {
-                composable<DynamicScreenRoute>(
-                    enterTransition = {
-                        slideInHorizontally(
-                            animationSpec = tween(300),
-                            initialOffsetX = { it }
-                        )
-                    },
-                    exitTransition = null,
-                    popEnterTransition = { fadeIn(animationSpec = tween(0)) },
-                    popExitTransition = {
-                        slideOutHorizontally(
-                            animationSpec = tween(300),
-                            targetOffsetX = { it }
-                        )
-                    }
-                ) { backStackEntry ->
-                    val route = backStackEntry.toRoute<DynamicScreenRoute>()
-                    val screen = registry.getScreen(route.id)
-
-                    if (screen != null) {
-                        StackScreen(
-                            id = route.id,
-                            name = screen.name,
-                            content = screen.content,
-                            navigationOptions = screen.options
-                        )
-                    }
-                }
-
-                composable<DynamicDialogRoute>(
-                    enterTransition = {
-                        slideInVertically(
-                            animationSpec = tween(300),
-                            initialOffsetY = { it }
-                        )
-                    },
-                    exitTransition = null,
-                    popEnterTransition = { fadeIn(animationSpec = tween(0)) },
-                    popExitTransition = {
-                        slideOutVertically(
-                            animationSpec = tween(300),
-                            targetOffsetY = { it }
-                        )
-                    }
-                ) { backStackEntry ->
-                    val route = backStackEntry.toRoute<DynamicDialogRoute>()
-                    val screen = registry.getScreen(route.id)
-
-                    if (screen != null) {
-                        StackScreen(
-                            id = route.id,
-                            name = screen.name,
-                            content = screen.content,
-                            navigationOptions = screen.options
-                        )
-                    }
-                }
-            }
-        }
-    }
-
-    DisposableEffect(Unit) {
-        onDispose {
-            navigator.dispose()
-            registry.unregisterScreen(screenId)
-        }
-    }
-}
-
-val LocalMaxApi = staticCompositionLocalOf<IMaxApi?> {
-    error("No MaxApi provided")
-}
-
-private const val FONT_SCALE_OBSERVER_KEY = "font_scale_config"
-
-private fun parseFontScaleConfig(raw: Map<String, Any?>?): FontScaleConfig? {
-    if (raw.isNullOrEmpty()) return null
-    @Suppress("UNCHECKED_CAST")
-    val data = (raw["response"] as? Map<String, Any?>)
-        ?: (raw["data"] as? Map<String, Any?>)
-        ?: raw
-    if (!data.containsKey("useOSFontScale") && !data.containsKey("userScaleRate")) return null
-    val useOS = when (val v = data["useOSFontScale"]) {
-        is Boolean -> v
-        is String -> v.equals("true", ignoreCase = true)
-        is Number -> v.toInt() != 0
-        else -> true
-    }
-    val rate = when (val v = data["userScaleRate"]) {
-        is Number -> v.toFloat()
-        is String -> v.toFloatOrNull()
-        else -> null
-    }
-    val osScale = when (val v = data["osFontScale"]) {
-        is Number -> v.toFloat()
-        is String -> v.toFloatOrNull()
-        else -> null
-    }
-    return FontScaleConfig(useOSFontScale = useOS, userScaleRate = rate, osFontScale = osScale)
-}