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

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

@@ -0,0 +1,215 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.slideInVertically
+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 kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.collectLatest
+import vn.momo.kits.application.DesignSystemConfig
+import vn.momo.kits.application.DesignSystemKits
+import vn.momo.kits.application.LocalContext
+import vn.momo.kits.application.LocalDesignSystemConfig
+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.layout.LocalScreenLayout
+import vn.momo.kits.layout.calculateScreenLayout
+import vn.momo.kits.platform.ProvideNavigationEventDispatcherOwner
+import vn.momo.kits.platform.ProvideOsFontScale
+import vn.momo.kits.utils.getAppStatusBarHeight
+import vn.momo.kits.utils.getNavigationBarHeight
+// AI-GENERATED START: consume typed NativeMaxApi results
+import vn.momo.maxapi.IMaxApi
+import vn.momo.maxapi.runtime.ApiResult
+// AI-GENERATED END: consume typed NativeMaxApi results
+import kotlin.time.Duration.Companion.milliseconds
+
+@Composable
+fun NavigationContainer(
+    initialScreenName: String,
+    initialScreen: @Composable () -> Unit,
+    maxApi: IMaxApi,
+    options: NavigationOptions? = null,
+    initialTheme: Theme = defaultTheme,
+    miniAppContext: MiniAppContext? = null,
+    setNavigator: ((Navigator) -> Unit)? = null,
+    statusBarHeight: Dp? = null,
+    localize: Localize? = null,
+    designSystemConfig: DesignSystemConfig? = null,
+) {
+    val navController = rememberNavController()
+    val registry = remember { DynamicScreenRegistry() }
+    // AI-GENERATED START: retain the current host client after recomposition
+    val navigator = remember(navController, maxApi, registry) {
+        Navigator(navController = navController, maxApi = maxApi, registry = registry)
+    }
+    // AI-GENERATED END: retain the current host client after recomposition
+    val statusBarHeight = statusBarHeight ?: getAppStatusBarHeight()
+    val navigationBarHeight = getNavigationBarHeight()
+    val screenLayout = calculateScreenLayout(statusBarHeight, parent = LocalScreenLayout.current)
+
+    val parentContext = LocalContext.current
+    val mergedContext = MiniAppContext.merge(parentContext, miniAppContext)
+
+    val stackTransition = remember { StackTransitionCoordinator() }
+    val theme = remember { mutableStateOf(initialTheme) }
+    val resolvedDesignSystemConfig =
+        designSystemConfig ?: LocalDesignSystemConfig.current ?: DesignSystemKits.getConfigs().designSystemConfig
+    val headerBar = resolvedDesignSystemConfig?.headerBar
+    // RN parity: the theme's own header image wins; config headerBar is only the fallback.
+    val resolvedTheme = remember(theme.value, headerBar) {
+        if (theme.value.isHeaderImage() || headerBar.isNullOrEmpty()) {
+            theme.value
+        } else {
+            theme.value.copy(assets = theme.value.assets.copy(headerBackground = headerBar))
+        }
+    }
+    val fallbackLocalize = remember { Localize() }
+
+    val resolvedLocalize = localize ?: fallbackLocalize
+
+    // AI-GENERATED START: cancel language delivery when its composition owner changes
+    DisposableEffect(maxApi, resolvedLocalize) {
+        val api = maxApi
+        val target = resolvedLocalize
+        var active = true
+        val handle = runCatching {
+            api.getLanguage { result ->
+                if (active && result is ApiResult.Success &&
+                    result.value.trim().lowercase().startsWith(Localize.EN)) {
+                    target.changeLanguage(Localize.EN)
+                }
+            }
+        }.getOrNull()
+        onDispose {
+            active = false
+            handle?.cancel()
+        }
+    }
+    // AI-GENERATED END: cancel language delivery when its composition owner changes
+
+    val screenId = rememberSaveable { registry.nextId() }
+    registry.bind(screenId, initialScreenName, initialScreen, options)
+    val startDestination = remember(screenId) { DynamicScreenRoute(screenId) }
+
+    ProvideOsFontScale {
+        ProvideNavigationEventDispatcherOwner(navigator) {
+            CompositionLocalProvider(
+                LocalNavigator provides navigator,
+                LocalDynamicScreenRegistry provides registry,
+                LocalMaxApi provides maxApi,
+                AppTheme provides resolvedTheme,
+                AppStatusBar provides statusBarHeight,
+                AppNavigationBar provides navigationBarHeight,
+                LocalScreenLayout provides screenLayout,
+                LocalContext provides mergedContext,
+                LocalDesignSystemConfig provides resolvedDesignSystemConfig,
+                LocalLocalize provides resolvedLocalize,
+                LocalStackTransition provides stackTransition,
+            ) {
+                LaunchedEffect(Unit) {
+                    setNavigator?.invoke(navigator)
+                }
+
+                SwipeBackHaptic(maxApi)
+
+                LaunchedEffect(navController, registry) {
+                    navController.currentBackStack.collectLatest { entries ->
+                        delay(STACK_TRANSITION_DURATION.milliseconds)
+                        val aliveIds = entries.mapNotNullTo(mutableSetOf()) { entry ->
+                            runCatching { entry.toRoute<DynamicScreenRoute>().id }.getOrNull()
+                                ?: runCatching { entry.toRoute<DynamicDialogRoute>().id }.getOrNull()
+                        }
+                        aliveIds.add(screenId)
+                        registry.retainOnly(aliveIds)
+                    }
+                }
+
+                NavHost(
+                    navController,
+                    startDestination = startDestination,
+                    enterTransition = { stackEnter() },
+                    exitTransition = { stackExit() },
+                    popEnterTransition = { stackPopEnter() },
+                    popExitTransition = { stackPopExit() },
+                ) {
+                    composable<DynamicScreenRoute> { backStackEntry ->
+                        val route = backStackEntry.toRoute<DynamicScreenRoute>()
+                        val screen = registry.getScreen(route.id)
+
+                        if (screen != null) {
+                            StackTransitionDecor(id = route.id, isStackRoute = true) {
+                                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) {
+                            StackTransitionDecor(id = route.id, isStackRoute = false) {
+                                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?> { null }
+

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

@@ -0,0 +1,404 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.navigation.NavController
+import androidx.navigation.toRoute
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.serialization.Serializable
+import vn.momo.kits.components.PopupAction
+import vn.momo.kits.components.PopupNotify
+import vn.momo.kits.navigation.BottomHeader.*
+import vn.momo.kits.navigation.component.SnackBar
+import vn.momo.maxapi.IMaxApi
+// AI-GENERATED START: dismiss through the typed navigator target
+import vn.momo.maxapi.contract.navigation.model.DismissTarget
+// AI-GENERATED END: dismiss through the typed navigator target
+import kotlin.time.Duration.Companion.milliseconds
+
+class Navigator(
+    private val navController: NavController,
+    private val maxApi: IMaxApi?,
+    private val registry: DynamicScreenRegistry
+) {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+    // currentScreen() reads the root back stack, so it never sees the nested tab NavHost.
+    internal var tabBackHandler: (() -> Unit)? = null
+
+    private fun currentScreen(): DynamicScreen? {
+        val entry = navController.currentBackStackEntry ?: return null
+        val id = runCatching { entry.toRoute<DynamicScreenRoute>().id }.getOrNull()
+            ?: runCatching { entry.toRoute<DynamicDialogRoute>().id }.getOrNull()
+            ?: return null
+        return registry.getScreen(id)
+    }
+
+    fun push(screenName: String, content: @Composable () -> Unit, options: NavigationOptions? = null) {
+        val route = registry.register(screenName, content, options)
+        navController.navigate(DynamicScreenRoute(route.id))
+    }
+
+    fun replace(screenName: String, content: @Composable () -> Unit, options: NavigationOptions? = null) {
+        val replacedScreen = currentScreen()
+        replacedScreen?.let { registry.unregisterScreen(it.id) }
+        navController.popBackStack()
+        push(screenName, content, options)
+    }
+
+    fun onBackSafe(callBack: (() -> Unit)? = null) {
+        // An open modal or bottom sheet takes the back first, as its BackHandler does for gestures.
+        val overplayType = OverplayComponentRegistry.getOverplayType()
+        if (overplayType != null && overplayType != OverplayComponentType.SNACK_BAR) {
+            pop(1, callBack)
+            return
+        }
+        tabBackHandler?.let {
+            it()
+            return
+        }
+        val currentScreen = currentScreen()
+        val options = currentScreen?.options
+        if (options?.onBackHandler != null) {
+            options.onBackHandler.invoke()
+            return
+        }
+        val preventBack = options?.headerBackProps?.preventBack
+        if (preventBack != null) {
+            showModal(
+                content = {
+                    PopupNotify(preventBack.copy(
+                        primary = PopupAction(
+                            title = preventBack.primary?.title ?: "",
+                            onPress = {
+                                preventBack.primary?.onPress?.invoke()
+                                pop(2, callBack) // close popup notify, then close the screen
+                            }
+                        )
+                    ))
+                }
+            )
+        } else {
+            pop(1, callBack)
+        }
+    }
+
+    // The swipe-back opt-out predicate in StackScreen needs this: the root screen must keep custom
+    // back handling so it still reaches maxApi.dismiss.
+    // Public: the iOS host asks this to decide whether the kit owns the swipe on this screen.
+    fun canPop(): Boolean = navController.previousBackStackEntry != null
+
+    fun pop(count: Int = 1, callBack: (() -> Unit)? = null) {
+        scope.launch {
+            repeat(count) {
+                if (OverplayComponentRegistry.getOverplayType() == OverplayComponentType.SNACK_BAR){
+                    dismissScreen()
+                    OverplayComponentRegistry.hardClearAfterDismiss()
+                }
+                else if (OverplayComponentRegistry.isOverplayShowing()){
+                    dismissOverplay()
+                } else {
+                    dismissScreen()
+                }
+            }
+            callBack?.invoke()
+        }
+    }
+    private suspend fun dismissOverplay(isDelay: Boolean = true) {
+        OverplayComponentRegistry.clear()
+        if (isDelay) delay(300L.milliseconds)
+        OverplayComponentRegistry.hardClearAfterDismiss()
+    }
+
+    private suspend fun dismissScreen() {
+        if (navController.previousBackStackEntry != null){
+            val dismissing = currentScreen()
+            navController.popBackStack()
+            delay(STACK_TRANSITION_DURATION.milliseconds)
+            dismissing?.let { registry.unregisterScreen(it.id) }
+        } else {
+            // AI-GENERATED START: preserve root-screen dismissal
+            maxApi?.dismiss(DismissTarget.Current()) {}
+            // AI-GENERATED END: preserve root-screen dismissal
+        }
+    }
+
+    fun present(screenName: String, content: @Composable () -> Unit, options: NavigationOptions? = null) {
+        val route = registry.register(screenName, content, options)
+        navController.navigate(DynamicDialogRoute(route.id))
+    }
+
+    fun reset(screenName: String, content: @Composable () -> Unit, options: NavigationOptions? = null) {
+        registry.unregisterAll()
+
+        val route = registry.register(screenName, content, options)
+        navController.navigate(DynamicScreenRoute(route.id)) {
+            popUpTo(0) { inclusive = true }
+        }
+    }
+
+    fun showModal(
+        content: @Composable () -> Unit,
+        barrierDismissible: Boolean = true,
+        onDismiss: (() -> Unit)? = null
+    ){
+        val id = currentScreen()?.id ?: -1
+        OverplayComponentRegistry.registerOverplay(id, content, OverplayComponentType.MODAL, false, barrierDismissible, onDismiss)
+    }
+
+    fun showBottomSheet(
+        content: @Composable () -> Unit,
+        isSurface: Boolean = false,
+        barrierDismissible: Boolean = true,
+        onDismiss: (() -> Unit)? = null,
+        bottomSheetHeader: BottomHeader? = null,
+        draggable: Boolean = true,
+        useBottomInset: Boolean = true,
+        footerComponent: (@Composable () -> Unit)? = null
+    ){
+        val id = currentScreen()?.id ?: -1
+        OverplayComponentRegistry.registerOverplay(id, content, OverplayComponentType.BOTTOM_SHEET, isSurface, barrierDismissible, onDismiss, bottomSheetHeader, draggable, useBottomInset, footerComponent)
+    }
+
+    fun showSnackBar(snackBar: SnackBar, onDismiss: (() -> Unit)? = null) {
+        val id = currentScreen()?.id ?: -1
+        scope.launch {
+            OverplayComponentRegistry.registerOverplay(
+                id = id,
+                content = {
+                    SnackBar(snackBar, onDismiss)
+                },
+                type = OverplayComponentType.SNACK_BAR,
+                onDismiss = onDismiss
+            )
+        }
+    }
+
+    fun hideSnackBar() {
+        scope.launch {
+            OverplayComponentRegistry.clear()
+            delay(250L.milliseconds)
+            OverplayComponentRegistry.hardClearAfterDismiss()
+        }
+    }
+
+    fun dispose(){
+        scope.cancel()
+    }
+}
+
+val LocalNavigator = staticCompositionLocalOf<Navigator> {
+    error("No NavigationStack provided")
+}
+
+@Serializable
+data class DynamicScreenRoute(val id: Int)
+
+@Serializable
+data class DynamicDialogRoute(val id: Int)
+
+data class DynamicScreen(
+    val id: Int,
+    val name: String,
+    val content: @Composable () -> Unit,
+    var options: NavigationOptions? = null
+)
+
+class DynamicScreenRegistry {
+    private val screens = mutableMapOf<Int, DynamicScreen>()
+
+    fun register(screenName: String, content: @Composable () -> Unit, options: NavigationOptions?): DynamicScreenRoute {
+        val id = nextGlobalId()
+        screens[id] = DynamicScreen(
+            id = id,
+            name = screenName,
+            content = content,
+            options = options
+        )
+        return DynamicScreenRoute(id)
+    }
+
+    fun nextId(): Int = nextGlobalId()
+
+    fun bind(id: Int, screenName: String, content: @Composable () -> Unit, options: NavigationOptions?) {
+        screens[id] = DynamicScreen(
+            id = id,
+            name = screenName,
+            content = content,
+            options = options
+        )
+        advanceGlobalIdPast(id) // keep counter ahead after process-death restore
+    }
+
+    fun unregisterScreen(id: Int) {
+        screens.remove(id)
+    }
+
+    // Gesture pops go through composeNavigator.popBackStack() inside NavHost and never reach
+    // Navigator.dismissScreen(), so screens would leak without a stack-driven prune.
+    fun retainOnly(ids: Set<Int>) {
+        val stale = screens.keys.filter { it !in ids }
+        for (id in stale) {
+            screens.remove(id)
+        }
+    }
+
+    fun unregisterAll(){
+        val ids = screens.keys.toList()
+        for (id in ids) {
+            unregisterScreen(id)
+        }
+    }
+
+    fun getScreen(id: Int): DynamicScreen? = screens[id]
+
+    fun setOptions(id: Int, options: NavigationOptions){
+        screens[id]?.options = options
+    }
+
+    companion object {
+        private var globalIdCounter = 1
+
+        private fun nextGlobalId(): Int = globalIdCounter++
+
+        private fun advanceGlobalIdPast(id: Int) {
+            if (id >= globalIdCounter) globalIdCounter = id + 1
+        }
+    }
+}
+
+val LocalDynamicScreenRegistry = staticCompositionLocalOf<DynamicScreenRegistry?> { null }
+
+
+sealed class OverplayComponentParams {
+    class Modal(
+        val onDismiss: (() -> Unit)? = null,
+        val barrierDismissible: Boolean = true
+    ) : OverplayComponentParams()
+
+    class BottomSheet(
+        val isSurface: Boolean = false,
+        val onDismiss: (() -> Unit)? = null,
+        val barrierDismissible: Boolean = true,
+        val bottomSheetHeader: BottomHeader? = null,
+        val draggable: Boolean = true,
+        val useBottomInset: Boolean = true,
+        val footerComponent: (@Composable () -> Unit)? = null,
+    ) : OverplayComponentParams()
+
+    class SnackBar : OverplayComponentParams()
+}
+
+data class OverplayComponent(
+    val id: Int,
+    val type: OverplayComponentType? = null,
+    val content: @Composable () -> Unit,
+    val params: OverplayComponentParams? = null
+)
+
+enum class OverplayComponentType {
+    MODAL, BOTTOM_SHEET, SNACK_BAR
+}
+
+object OverplayComponentRegistry {
+    private var currentOverlayComponent : MutableState<OverplayComponent?> = mutableStateOf(null)
+    private var requestClose: (() -> Unit)? = null
+    internal fun bindClose(handler: (() -> Unit)?) {
+        requestClose = handler
+    }
+
+    fun registerOverplay(
+        id: Int,
+        content: @Composable () -> Unit,
+        type: OverplayComponentType,
+        isSurface: Boolean = false,
+        barrierDismissible: Boolean = true,
+        onDismiss: (() -> Unit)?,
+        bottomSheetHeader: BottomHeader? = null,
+        draggable: Boolean = true,
+        useBottomInset: Boolean = true,
+        footerComponent: (@Composable () -> Unit)? = null,
+    ){
+        val params = when(type){
+            OverplayComponentType.MODAL -> OverplayComponentParams.Modal(onDismiss, barrierDismissible)
+            OverplayComponentType.BOTTOM_SHEET -> OverplayComponentParams.BottomSheet(isSurface, onDismiss, barrierDismissible, bottomSheetHeader, draggable, useBottomInset, footerComponent)
+            OverplayComponentType.SNACK_BAR -> OverplayComponentParams.SnackBar()
+        }
+
+        currentOverlayComponent.value = OverplayComponent(
+            id = id,
+            type = type,
+            content = content,
+            params = params
+        )
+    }
+
+    fun isOverplayShowing(): Boolean = currentOverlayComponent.value != null
+
+    fun getOverplayType(): OverplayComponentType? = currentOverlayComponent.value?.type
+
+    fun currentRootId(): Int? = currentOverlayComponent.value?.id
+
+    fun clear(){
+        if (requestClose != null) {
+            requestClose?.invoke()
+        } else {
+            currentOverlayComponent.value = null
+        }
+    }
+
+    internal fun hardClearAfterDismiss() {
+        currentOverlayComponent.value = null
+        requestClose = null
+    }
+
+    @Composable
+    internal fun OverlayComponent(){
+        val overplay = currentOverlayComponent.value ?: return
+
+        when (val params = overplay.params) {
+            is OverplayComponentParams.BottomSheet -> {
+                BottomSheet(
+                    content = overplay.content,
+                    header = params.bottomSheetHeader ?: Title(),
+                    isSurface = params.isSurface,
+                    barrierDismissible = params.barrierDismissible,
+                    draggable = params.draggable,
+                    useBottomInset = params.useBottomInset,
+                    footerComponent = params.footerComponent,
+                    onDismiss = params.onDismiss
+                )
+            }
+
+            is OverplayComponentParams.Modal -> {
+                ModalScreen(
+                    content = overplay.content,
+                    barrierDismissible = params.barrierDismissible,
+                    onDismiss = params.onDismiss
+                )
+            }
+
+            is OverplayComponentParams.SnackBar -> {
+                Box(
+                    modifier = Modifier.fillMaxSize(),
+                    contentAlignment = Alignment.BottomCenter
+                ) {
+                    overplay.content()
+                }
+            }
+
+            null -> {}
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.runtime.Composable
+
+@Composable
+internal expect fun RegisterScrollToTop(callback: (() -> Unit)?)
+
+