@momo-kits/native-kits 0.162.2-beta.23-debug → 0.162.2-beta.24-debug

package/CLAUDE.md

@@ -40,7 +40,7 @@ Publishing is automated (`publish.sh` + GitLab CI on `[ci build]` / `main`). Do
 ## Architecture essentials
 
 - **Entry point:** wrap content in `NavigationContainer(...)` from `navigation/`. It builds the `Navigator`, takes a host-supplied `Localize` (falls back to an empty one), and provides the CompositionLocals below. **Do not use** `ApplicationContainer` (`application/NavigationContainer.kt`) — deprecated and does **not** wire `LocalLocalize` / `LocalNavigator` / `LocalMaxApi`.
-- **Configuration flows via CompositionLocals**, not params. Public ones: `AppTheme`, `AppStatusBar`, `AppNavigationBar` (`const/Theme.kt`); `ApplicationContext`, `AppConfig`, `AppLanguage`, `LocalLocalize`, `ScaleSizeMaxRate` (`application/`); `LocalNavigator`, `LocalMaxApi` (`navigation/`). Read with `X.current`.
+- **Configuration flows via CompositionLocals**, not params. Public ones: `AppTheme`, `AppStatusBar`, `AppNavigationBar` (`const/Theme.kt`); `ApplicationContext`, `AppConfig`, `AppLanguage`, `LocalLocalize` (`application/`); `LocalNavigator`, `LocalMaxApi` (`navigation/`). Read with `X.current`.
 - **Platform code** goes through `expect`/`actual` in `platform/` — never reference Android/iOS APIs from `commonMain` directly.
 - **Native bridge:** `IMaxApi` (`vn.momo.maxapi`, exposed as `LocalMaxApi`) is the host-app bridge (dismiss, tracking, device info, language).
 - Navigation uses a runtime `DynamicScreenRegistry`; overlays (modal/bottom-sheet/snackbar) go through `Navigator` + `OverplayComponentRegistry`.

package/compose/build.gradle.kts

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

package/compose/compose.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |spec|
     spec.name                     = 'compose'
-    spec.version                  = '0.162.2-beta.19'
+    spec.version                  = '0.162.2-sp.7-debug'
     spec.homepage                 = 'https://momo.vn'
     spec.source                   = { :http=> ''}
     spec.authors                  = ''

package/compose/src/androidMain/kotlin/vn/momo/kits/platform/OsFontScale.android.kt

@@ -0,0 +1,7 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+
+// Android's LocalDensity.fontScale already tracks Configuration.fontScale live.
+@Composable
+actual fun ProvideOsFontScale(content: @Composable () -> Unit) = content()

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

@@ -29,6 +29,8 @@ data class MiniAppContext(
     val permissions: List<Map<String, Any>>? = emptyList(),
     val features: FeatureFlags? = null,
     val scaleSizeMaxRate: Float? = null,
+    val userScaleRate: Float? = null,
+    val useOSScaleRate: Boolean? = null,
 ) {
     companion object {
 
@@ -61,6 +63,8 @@ data class MiniAppContext(
                 permissions = if (!parent.permissions.isNullOrEmpty()) parent.permissions else child.permissions,
                 features = mergeFeatureFlags(parent.features, child.features),
                 scaleSizeMaxRate = parent.scaleSizeMaxRate ?: child.scaleSizeMaxRate,
+                userScaleRate = parent.userScaleRate ?: child.userScaleRate,
+                useOSScaleRate = parent.useOSScaleRate ?: child.useOSScaleRate,
             )
         }
 
@@ -98,4 +102,5 @@ val LocalComponentInformation = staticCompositionLocalOf<ComponentInformation?>
     null
 }
 
+@Deprecated("Max font scale is fixed at MAX_FONT_SCALE (1.5); this CompositionLocal is no longer read.")
 val ScaleSizeMaxRate = staticCompositionLocalOf<Float?> { null }

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

@@ -7,6 +7,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.Dp
 import vn.momo.kits.const.*
 import vn.momo.kits.modifier.DeprecatedModifier
+import vn.momo.kits.platform.ProvideOsFontScale
 import vn.momo.kits.platform.getStatusBarHeight
 
 @Deprecated("Use IMaxApi instead", ReplaceWith("IMaxApi"))
@@ -93,6 +94,7 @@ fun ApplicationContainer(
 
     val appStatusBarHeight = statusBarHeight ?: getStatusBarHeight()
 
+    ProvideOsFontScale {
     CompositionLocalProvider(
         AppTheme provides appTheme,
         PlatformApi provides composeApi,
@@ -103,5 +105,6 @@ fun ApplicationContainer(
             content()
         }
     }
+    }
 
 }

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

@@ -0,0 +1,56 @@
+package vn.momo.kits.application
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import vn.momo.kits.const.AppTheme
+import vn.momo.kits.const.Theme
+import vn.momo.kits.navigation.LocalMaxApi
+import vn.momo.kits.platform.ProvideOsFontScale
+import vn.momo.maxapi.IMaxApi
+
+
+@Composable
+fun WidgetContainer(
+    theme: Theme? = null,
+    miniAppContext: MiniAppContext? = null,
+    maxApi: IMaxApi? = null,
+    localize: Localize? = null,
+    content: @Composable () -> Unit,
+) {
+    val parentContext = LocalContext.current
+    val mergedContext = remember(parentContext, miniAppContext) {
+        MiniAppContext.merge(parentContext, miniAppContext)
+    }
+    val resolvedTheme = theme ?: AppTheme.current
+    val resolvedLocalize = localize ?: LocalLocalize.current
+    val resolvedMaxApi = maxApi ?: LocalMaxApi.current
+
+    LaunchedEffect(resolvedMaxApi, localize) {
+        val api = resolvedMaxApi ?: return@LaunchedEffect
+        val target = localize ?: return@LaunchedEffect
+        runCatching {
+            api.getLanguage(callback = { data ->
+                if (parseLanguage(data) == Localize.EN) target.changeLanguage(Localize.EN)
+            })
+        }
+    }
+
+    ProvideOsFontScale {
+        CompositionLocalProvider(
+            AppTheme provides resolvedTheme,
+            LocalContext provides mergedContext,
+            LocalLocalize provides resolvedLocalize,
+            LocalMaxApi provides resolvedMaxApi,
+        ) {
+            content()
+        }
+    }
+}
+
+private fun parseLanguage(raw: Map<String, Any?>?): String? {
+    val code = (raw?.get("response") as? String)?.trim()?.lowercase()
+    if (code.isNullOrEmpty()) return null
+    return if (code.startsWith(Localize.EN)) Localize.EN else Localize.VI
+}

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

@@ -5,6 +5,7 @@ import androidx.compose.foundation.border
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
@@ -19,65 +20,32 @@ import vn.momo.kits.application.IsShowBaseLineDebug
 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.modifier.conditional
 
 data class IconSpecs(
-    val width: Dp,
-    val height: Dp,
-    val radius: Dp,
-    val size: Dp
+    val box: Dp,
+    val icon: Dp,
 )
 
 enum class IconSize(val value: IconSpecs) {
-    LARGE(
-        IconSpecs(
-            height = 48.dp,
-            radius = Radius.XL,
-            width = 48.dp,
-            size = 48.dp
-        )
-    ),
-    SMALL(
-        IconSpecs(
-            height = 40.dp,
-            radius = Radius.XL,
-            width = 40.dp,
-            size = 40.dp
-        )
-    )
+    LARGE(IconSpecs(box = 48.dp, icon = 24.dp)),
+    MEDIUM(IconSpecs(box = 36.dp, icon = 16.dp)),
+    SMALL(IconSpecs(box = 28.dp, icon = 16.dp)),
 }
 
-enum class IconButtonShape {
+enum class IconShape {
     CIRCLE,
     SQUARE,
-    RECTANGLE
 }
 
-// Resolved footprint + corner radius for a (size, shape) pair.
-data class IconButtonGeometry(
-    val width: Dp,
-    val height: Dp,
-    val radius: Dp
-)
+// Square keeps an 8dp rounded corner; circle is fully rounded regardless of size.
+private val squareShape = RoundedCornerShape(Radius.S)
 
-// CIRCLE keeps the square footprint fully rounded (legacy default); SQUARE/RECTANGLE use the
-// standard button corner (Radius.S) and RECTANGLE widens the footprint so it reads horizontal.
-internal fun resolveIconButtonGeometry(size: IconSize, shape: IconButtonShape): IconButtonGeometry {
-    val base = size.value.height
-    return when (shape) {
-        IconButtonShape.CIRCLE -> IconButtonGeometry(base, base, size.value.radius)
-        IconButtonShape.SQUARE -> IconButtonGeometry(base, base, Radius.S)
-        IconButtonShape.RECTANGLE -> IconButtonGeometry(base + Spacing.S, base, Radius.S)
-    }
+private fun IconShape.toShape(): Shape = when (this) {
+    IconShape.CIRCLE -> CircleShape
+    IconShape.SQUARE -> squareShape
 }
 
-// Cache for icon sizes to avoid repeated calculations
-private val iconSizeMap = mapOf(
-    IconSize.SMALL to 16.dp,
-    IconSize.LARGE to 24.dp
-)
-
 @Composable
 internal fun getIconStyle(type: ButtonType, shape: Shape, color: Color? = null): Modifier {
     val theme = AppTheme.current
@@ -126,42 +94,32 @@ fun IconButton(
     onClick: () -> Unit,
     type: ButtonType = ButtonType.PRIMARY,
     size: IconSize = IconSize.SMALL,
-    shape: IconButtonShape = IconButtonShape.CIRCLE,
+    shape: IconShape = IconShape.CIRCLE,
     icon: String = "",
 ) {
-    // Memoize icon size calculation
-    val iconSize = remember(size) {
-        iconSizeMap[size] ?: 16.dp
-    }
+    val specs = size.value
 
-    // Memoize enabled state
     val isEnabled = remember(type) {
         type != ButtonType.DISABLED
     }
 
-    // Memoize footprint + corner shape for the requested shape
-    val geometry = remember(size, shape) {
-        resolveIconButtonGeometry(size, shape)
-    }
-    val cornerShape = remember(geometry.radius) {
-        RoundedCornerShape(geometry.radius)
-    }
+    val boxShape = remember(shape) { shape.toShape() }
 
     Box(
         modifier = Modifier
-            .size(width = geometry.width, height = geometry.height)
-            .then(getIconStyle(type, cornerShape))
+            .size(specs.box)
+            .then(getIconStyle(type, boxShape))
             .conditional(IsShowBaseLineDebug) {
                 border(1.dp, Colors.blue_03)
             }
-            .clip(cornerShape)
+            .clip(boxShape)
             .clickable(enabled = isEnabled, onClick = onClick),
         contentAlignment = Alignment.Center
     ) {
         Icon(
             source = icon,
             color = getIconColor(type),
-            size = iconSize,
+            size = specs.icon,
         )
     }
-}
+}

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

@@ -4,6 +4,10 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import vn.momo.kits.application.ScaleSizeMaxRate
 
+@Deprecated(
+    "Max font scale is fixed at MAX_FONT_SCALE (1.5); this override is no longer applied. Remove the wrapper.",
+    ReplaceWith("content()"),
+)
 @Composable
 fun ScaleSizeScope(
     scaleSizeMaxRate: Float? = null,

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

@@ -0,0 +1,22 @@
+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
+    }
+}

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

@@ -11,7 +11,7 @@ import androidx.compose.ui.unit.*
 import org.jetbrains.compose.resources.Font
 import org.jetbrains.compose.resources.FontResource
 import org.jetbrains.compose.resources.InternalResourceApi
-import vn.momo.kits.application.ScaleSizeMaxRate
+import vn.momo.kits.application.LocalContext
 import vn.momo.kits.platform.getScreenDimensions
 import vn.momo.uikits.resources.*
 import kotlin.math.max
@@ -23,7 +23,13 @@ const val MAX_DEVICE_SCALE = 5
 
 @Composable
 fun scaleSize(size: Float): Float {
-    val scaleSizeMaxRate: Float = ScaleSizeMaxRate.current ?: MAX_FONT_SCALE
+    val context = LocalContext.current
+    // Host-pushed context wins; otherwise fall back to the app-wide KitFontScale holder.
+    val useOsScale = context?.useOSScaleRate ?: KitFontScale.useOSScaleRate
+    if (!useOsScale) {
+        return size * (context?.userScaleRate ?: KitFontScale.userScaleRate)
+    }
+    val scaleSizeMaxRate: Float = MAX_FONT_SCALE
     val deviceWidth = getScreenDimensions().width
     val deviceScale = deviceWidth / DEFAULT_SCREEN_SIZE
 

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

@@ -85,7 +85,9 @@ data class NavigationOptions(
     val footerComponent: @Composable (() -> Unit)? = null,
     val floatingButtonProps: FloatingButtonProps? = null,
     val keyboardOptions: KeyboardOptions = KeyboardOptions()
-)
+) {
+    internal fun hasFooter() : Boolean = footerComponent != null
+}
 
 data class KeyboardOptions(
     val keyboardShouldPersistTaps: Boolean = false,

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

@@ -1,17 +1,35 @@
 package vn.momo.kits.navigation
 
-import androidx.compose.animation.*
 import androidx.compose.animation.core.tween
-import androidx.compose.runtime.*
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.staticCompositionLocalOf
 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 vn.momo.kits.application.*
-import vn.momo.kits.const.*
+import vn.momo.kits.application.LocalContext
+import vn.momo.kits.application.LocalLocalize
+import vn.momo.kits.application.Localize
+import vn.momo.kits.application.MiniAppContext
+import vn.momo.kits.const.AppNavigationBar
+import vn.momo.kits.const.AppStatusBar
+import vn.momo.kits.const.AppTheme
+import vn.momo.kits.const.Theme
+import vn.momo.kits.const.defaultTheme
 import vn.momo.kits.platform.ProvideNavigationEventDispatcherOwner
+import vn.momo.kits.platform.ProvideOsFontScale
 import vn.momo.kits.utils.getAppStatusBarHeight
 import vn.momo.kits.utils.getNavigationBarHeight
 import vn.momo.maxapi.IMaxApi
@@ -27,7 +45,7 @@ fun NavigationContainer(
     setNavigator: ((Navigator) -> Unit)? = null,
     statusBarHeight: Dp? = null,
     localize: Localize? = null,
-){
+) {
     val navController = rememberNavController()
     val registry = remember { DynamicScreenRegistry() }
     val navigator = remember { Navigator(navController = navController, maxApi = maxApi, registry = registry) }
@@ -57,77 +75,79 @@ fun NavigationContainer(
     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,
-            LocalContext provides mergedContext,
-            LocalLocalize provides resolvedLocalize,
+    ProvideOsFontScale {
+        ProvideNavigationEventDispatcherOwner {
+            CompositionLocalProvider(
+                LocalNavigator provides navigator,
+                LocalDynamicScreenRegistry provides registry,
+                LocalMaxApi provides maxApi,
+                AppTheme provides theme.value,
+                AppStatusBar provides statusBarHeight,
+                AppNavigationBar provides navigationBarHeight,
+                LocalContext provides mergedContext,
+                LocalLocalize provides resolvedLocalize,
             ) {
-            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
-                        )
-                    }
+                LaunchedEffect(Unit) {
+                    setNavigator?.invoke(navigator)
                 }
 
-                composable<DynamicDialogRoute>(
-                    enterTransition = {
-                        slideInVertically(
-                            animationSpec = tween(300),
-                            initialOffsetY = { it }
-                        )
-                    },
-                    exitTransition = null,
-                    popEnterTransition = { fadeIn(animationSpec = tween(0)) },
-                    popExitTransition = {
-                        slideOutVertically(
-                            animationSpec = tween(300),
-                            targetOffsetY = { it }
-                        )
+                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
+                            )
+                        }
                     }
-                ) { 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
-                        )
+
+                    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
+                            )
+                        }
                     }
                 }
             }
@@ -142,9 +162,7 @@ fun NavigationContainer(
     }
 }
 
-val LocalMaxApi = staticCompositionLocalOf<IMaxApi?> {
-    error("No MaxApi provided")
-}
+val LocalMaxApi = staticCompositionLocalOf<IMaxApi?> { null }
 
 private fun parseLanguage(raw: Map<String, Any?>?): String? {
     val code = (raw?.get("response") as? String)?.trim()?.lowercase()

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

@@ -56,6 +56,7 @@ import vn.momo.kits.const.Colors
 import vn.momo.kits.const.Spacing
 import vn.momo.kits.modifier.conditional
 import vn.momo.kits.modifier.hideKeyboardOnTap
+import vn.momo.kits.navigation.bottomtab.BOTTOM_TAB_BAR_HEIGHT
 import vn.momo.kits.navigation.component.FABPosition
 import vn.momo.kits.navigation.component.FloatingButton
 import vn.momo.kits.navigation.component.HEADER_HEIGHT
@@ -77,6 +78,13 @@ import kotlin.time.ExperimentalTime
 internal val LocalFooterHeightPx = staticCompositionLocalOf { mutableIntStateOf(0) }
 internal val LocalHeaderRightWidthPx = staticCompositionLocalOf { mutableIntStateOf(0) }
 
+@Composable
+private fun bottomTabBarInset(): Dp {
+    if (LocalNavigation.current.bottomTabIndex == -1) return 0.dp
+    val keyboard = keyboardSizeState().value
+    return (BOTTOM_TAB_BAR_HEIGHT.dp + Spacing.S - keyboard).coerceAtLeast(0.dp)
+}
+
 @OptIn(ExperimentalMaterialApi::class, ExperimentalTime::class)
 @Composable
 internal fun StackScreen(
@@ -195,12 +203,12 @@ internal fun StackScreen(
             }
 
             Column(Modifier.zIndex(2f).fillMaxSize()) {
-                MainContent(content = content, isBottomTab = isBottomTabRoot)
+                MainContent(content = content, isBottomTabRoot = isBottomTabRoot, isBottomTabChild = isBottomTabChild)
                 FooterContent()
             }
 
             Box(Modifier.zIndex(6f)) {
-                FloatingContent()
+                FloatingContent(isBottomTabChild = isBottomTabChild)
             }
 
             OverplayView(isBottomTabChild = isBottomTabChild, id = id)
@@ -210,7 +218,7 @@ internal fun StackScreen(
 
 @Suppress("FrequentlyChangingValue")
 @Composable
-internal fun FloatingContent() {
+internal fun FloatingContent(isBottomTabChild: Boolean) {
     val options = LocalOptions.current
     val density = LocalDensity.current
     val footerHeightPx = LocalFooterHeightPx.current
@@ -219,7 +227,11 @@ internal fun FloatingContent() {
 
     val fabProps = options.floatingButtonProps ?: return
     val bottomPadding = fabProps.bottom
-        ?: (Spacing.M + if (options.footerComponent != null) with(density) { footerHeightPx.intValue.toDp() } else navigationBar)
+        ?: (Spacing.M + when {
+            options.hasFooter() -> with(density) { footerHeightPx.intValue.toDp() }
+            isBottomTabChild -> bottomTabBarInset() + (navigationBar - keyboardSizeState().value).coerceAtLeast(0.dp)
+            else -> navigationBar
+        })
 
     FloatingButton(
         scrollPosition = fabProps.scrollState?.value ?: scrollState.value,
@@ -235,7 +247,7 @@ internal fun FloatingContent() {
 }
 
 @Composable
-internal fun ColumnScope.MainContent(content: @Composable () -> Unit, isBottomTab: Boolean) {
+internal fun ColumnScope.MainContent(content: @Composable () -> Unit, isBottomTabRoot: Boolean, isBottomTabChild: Boolean) {
     val options = LocalOptions.current
     val inputSearchType = getInputSearchType(options)
     val density = LocalDensity.current
@@ -264,7 +276,13 @@ internal fun ColumnScope.MainContent(content: @Composable () -> Unit, isBottomTa
             .conditional(options.scrollData.scrollable && options.scrollData.scrollState is ScrollState) {
                 verticalScroll(scrollState)
             }
-            .padding(bottom = if (options.footerComponent != null || isBottomTab) 0.dp else navigationBar)
+            .padding(
+                bottom = when {
+                    options.hasFooter() || isBottomTabRoot -> 0.dp
+                    isBottomTabChild -> bottomTabBarInset() + (navigationBar - keyboardSizeState().value).coerceAtLeast(0.dp)
+                    else -> navigationBar
+                }
+            )
     ) {
         ScreenContent(content = content)
     }
@@ -294,7 +312,7 @@ internal fun ScreenContent(content: @Composable () -> Unit) {
 @Composable
 internal fun FooterContent() {
     val options = LocalOptions.current
-    if (options.footerComponent != null) {
+    if (options.hasFooter()) {
         val keyboardSize = keyboardSizeState()
         val bottomPadding = (AppNavigationBar.current - keyboardSize.value).coerceAtLeast(0.dp)
         Footer(footerComponent = options.footerComponent, bottomPadding = bottomPadding)

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

@@ -18,6 +18,7 @@ import androidx.navigation.compose.rememberNavController
 import vn.momo.kits.const.AppNavigationBar
 import vn.momo.kits.const.AppTheme
 import vn.momo.kits.const.Spacing
+import vn.momo.kits.navigation.KeyboardOptions
 import vn.momo.kits.navigation.LocalNavigation
 import vn.momo.kits.navigation.LocalNavigator
 import vn.momo.kits.navigation.NavigationOptions
@@ -53,7 +54,8 @@ fun BottomTab(
     LaunchedEffect(Unit){
         navigation.markAsBottomTabRoot()
         navigation.setOptions(
-            headerType = HeaderType.None
+            headerType = HeaderType.None,
+            keyboardOptions = KeyboardOptions(useAvoidKeyboard = false)
         )
     }