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

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

@@ -0,0 +1,133 @@
+package vn.momo.kits.navigation.component
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.offset
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.delay
+import vn.momo.kits.application.IsShowBaseLineDebug
+import vn.momo.kits.const.Colors
+import vn.momo.kits.modifier.conditional
+import kotlinx.coroutines.launch
+import vn.momo.kits.const.AppNavigationBar
+import vn.momo.kits.navigation.LocalFooterHeightPx
+import vn.momo.kits.navigation.LocalNavigator
+import vn.momo.kits.navigation.LocalOptions
+import vn.momo.kits.navigation.OverplayComponentRegistry
+import kotlin.time.Duration.Companion.milliseconds
+
+sealed class SnackBar(open val duration: Long? = null) {
+    data class Custom(
+        val content: @Composable () -> Unit,
+        override val duration: Long? = 3000L
+    ) : SnackBar(duration)
+
+    data class Toast(
+        override val duration: Long? = 3000L
+    ) : SnackBar(duration)
+}
+
+@Composable
+internal fun SnackBar(
+    data: SnackBar,
+    onDismiss: (() -> Unit)?
+) {
+    val navigator = LocalNavigator.current
+    val options = LocalOptions.current
+    val density = LocalDensity.current
+    val footerHeightPxState = LocalFooterHeightPx.current
+    val navigationBar = AppNavigationBar.current
+
+    val footerHeight = if (options.footerComponent != null) {
+        footerHeightPxState.value
+    } else {
+        with(density){ navigationBar.toPx() }
+    }.toInt()
+
+    var startPosition by remember { mutableStateOf(Float.MAX_VALUE) }
+    val targetPosition = 0f
+
+    var offsetY by remember { mutableStateOf(Animatable(startPosition)) }
+    val coroutineScope = rememberCoroutineScope()
+
+    suspend fun openEvent() {
+        offsetY.snapTo(startPosition)
+        offsetY.animateTo(
+            targetValue = targetPosition,
+            animationSpec = tween(
+                durationMillis = 350,
+            )
+        )
+    }
+
+    fun closeEvent() {
+        coroutineScope.launch {
+            offsetY.animateTo(
+                targetValue = startPosition,
+                animationSpec = tween(
+                    durationMillis = 200,
+                )
+            )
+            // hideSnackBar() would call clear() -> this close again while still bound
+            OverplayComponentRegistry.hardClearAfterDismiss()
+        }
+    }
+
+    LaunchedEffect(startPosition) {
+        if (startPosition != Float.MAX_VALUE){
+            openEvent()
+        }
+    }
+
+    LaunchedEffect(data.duration) {
+        val duration = data.duration
+        if (duration != null) {
+            delay(duration.milliseconds)
+            navigator.hideSnackBar()
+        }
+    }
+
+    DisposableEffect(Unit) {
+        OverplayComponentRegistry.bindClose {
+            closeEvent()
+        }
+        onDispose {
+            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()
+            .conditional(IsShowBaseLineDebug) {
+                border(1.dp, Colors.blue_03)
+            }
+    ) {
+        when (data) {
+            is SnackBar.Custom -> data.content()
+            is SnackBar.Toast -> {}
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+// File: ToolkitRequests.kt
+// Created At: 2026-10-12 +07:00 | Created By: AI | AI Agent: Codex | Model: GPT-6
+// AI-GENERATED START: cancel only toolkit requests owned by this composition
+package vn.momo.kits.navigation.component
+
+import vn.momo.maxapi.runtime.ApiCallback
+import vn.momo.maxapi.runtime.ApiRequestHandle
+
+internal class ToolkitRequests {
+    private var active = true
+    private val handles = mutableSetOf<ApiRequestHandle>()
+
+    fun <T> launch(request: (ApiCallback<T>) -> ApiRequestHandle, onResult: ApiCallback<T>) {
+        if (!active) return
+        var completed = false
+        var handle: ApiRequestHandle? = null
+        val created = request { result ->
+            completed = true
+            handle?.let(handles::remove)
+            if (active) onResult(result)
+        }
+        handle = created
+        if (!active) created.cancel() else if (!completed) handles.add(created)
+    }
+
+    // AI-GENERATED START: retain subscriptions across nonterminal sheet events
+    fun <T> observe(request: (ApiCallback<T>) -> ApiRequestHandle, onResult: ApiCallback<T>) {
+        if (!active) return
+        val handle = request { result -> if (active) onResult(result) }
+        if (active) handles.add(handle) else handle.cancel()
+    }
+    // AI-GENERATED END: retain subscriptions across nonterminal sheet events
+
+    fun close() {
+        active = false
+        val pending = handles.toList()
+        handles.clear()
+        pending.forEach { it.cancel() }
+    }
+}
+// AI-GENERATED END: cancel only toolkit requests owned by this composition

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

@@ -0,0 +1,135 @@
+package vn.momo.kits.navigation.tracking
+
+import vn.momo.kits.application.MiniAppContext
+import vn.momo.maxapi.IMaxApi
+// AI-GENERATED START: serialize tracking attributes with their existing value types
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+// AI-GENERATED END: serialize tracking attributes with their existing value types
+import kotlin.time.Clock
+import kotlin.time.ExperimentalTime
+
+class ScreenTrackingState {
+    @OptIn(ExperimentalTime::class)
+    var time: Long = Clock.System.now().toEpochMilliseconds()
+    var releaseNavigated: Boolean = false
+    var releaseLoad: Boolean = false
+    var releaseInteraction: Boolean = false
+    var previousScreenName: String? = null
+    var action: String = "push"
+}
+
+// AI-GENERATED START: retain screen event names and typed tracking attributes
+object ScreenTracker {
+
+    private var lastScreenName: String? = null
+
+    fun trackScreenNavigated(
+        maxApi: IMaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        action: String,
+        state: ScreenTrackingState
+    ) {
+        if (state.releaseNavigated) return
+
+        val previousScreen = lastScreenName
+        lastScreenName = screenName
+
+        maxApi?.trackEvent(
+            eventName = "auto_screen_navigated",
+            attributes = JsonObject(buildBaseParams(context, screenName).apply {
+                put("pre_screen_name", JsonPrimitive(previousScreen))
+                put("state", JsonPrimitive("navigated"))
+                put("action", JsonPrimitive(action))
+            })
+        )
+
+        state.releaseNavigated = true
+        state.previousScreenName = previousScreen
+    }
+
+    fun trackScreenDisplayed(
+        maxApi: IMaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        duration: Long,
+        state: ScreenTrackingState
+    ) {
+        if (state.releaseLoad) return
+
+        maxApi?.trackEvent(
+            eventName = "auto_screen_displayed",
+            attributes = JsonObject(buildBaseParams(context, screenName).apply {
+                put("state", JsonPrimitive("load"))
+                put("duration", JsonPrimitive(duration))
+            })
+        )
+
+        state.releaseLoad = true
+    }
+
+    fun trackScreenInteracted(
+        maxApi: IMaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        duration: Long,
+        totalDuration: Long,
+        state: ScreenTrackingState
+    ) {
+        if (state.releaseInteraction) return
+
+        maxApi?.trackEvent(
+            eventName = "auto_screen_interacted",
+            attributes = JsonObject(buildBaseParams(context, screenName).apply {
+                put("state", JsonPrimitive("interaction"))
+                put("duration", JsonPrimitive(duration))
+                put("total_duration", JsonPrimitive(totalDuration))
+            })
+        )
+
+        state.releaseInteraction = true
+    }
+
+    private fun buildBaseParams(
+        context: MiniAppContext?,
+        screenName: String,
+        componentName: String = "Screen"
+    ): MutableMap<String, JsonElement> {
+        return mutableMapOf(
+            "app_id" to JsonPrimitive(context?.appId),
+            "feature_code" to JsonPrimitive(context?.appCode),
+            "screen_name" to JsonPrimitive(screenName),
+            "component_name" to JsonPrimitive(componentName),
+            "tracking_source" to JsonPrimitive(1)
+        )
+    }
+
+    fun trackPopupDisplayed(
+        maxApi: IMaxApi?,
+        context: MiniAppContext?,
+        parentScreenName: String?
+    ) {
+        maxApi?.trackEvent(
+            eventName = "auto_popup_displayed",
+            attributes = JsonObject(mapOf(
+                "screen_name" to JsonPrimitive(parentScreenName),
+                "tracking_source" to JsonPrimitive(1),
+                "app_id" to JsonPrimitive(context?.appId),
+                "feature_code" to JsonPrimitive(context?.appCode),
+                "kits_version" to JsonNull,
+                "component_name" to JsonPrimitive("Modal")
+            ))
+        )
+    }
+
+    fun getLastScreenName(): String? = lastScreenName
+
+    @Suppress("UNUSED")
+    fun reset() {
+        lastScreenName = null
+    }
+}
+// AI-GENERATED END: retain screen event names and typed tracking attributes

package/compose/src/commonMain/kotlin/vn/momo/kits/platform/BackGesture.kt

@@ -0,0 +1,12 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.State
+
+/** Fraction of container width, `null` when idle. Observe only — consuming would steal the
+ *  gesture from NavHost. Always `null` on Android. */
+@Composable
+expect fun rememberBackGestureProgress(): State<Float?>
+
+/** Android is a no-op: no host-owned recogniser to hand the gesture to. */
+expect fun reportFloatingArrowBack(shouldUse: Boolean)

package/compose/src/commonMain/kotlin/vn/momo/kits/platform/ComposeLottieAnimation.kt

@@ -0,0 +1,91 @@
+package vn.momo.kits.platform
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import io.github.alexzhirkevich.compottie.ExperimentalCompottieApi
+import io.github.alexzhirkevich.compottie.LottieCompositionSpec
+import io.github.alexzhirkevich.compottie.animateLottieCompositionAsState
+import io.github.alexzhirkevich.compottie.dynamic.rememberLottieDynamicProperties
+import io.github.alexzhirkevich.compottie.rememberLottieComposition
+import io.github.alexzhirkevich.compottie.rememberLottiePainter
+import vn.momo.kits.utils.readJson
+
+@OptIn(ExperimentalCompottieApi::class)
+@Composable
+internal fun ComposeLottieAnimation(
+    path: String,
+    tintColor: Color?,
+    bgColor: Color?,
+    iterations: Int,
+    isPlaying: Boolean,
+    onEvent: ((String) -> Unit)?,
+    modifier: Modifier,
+) {
+    val json = readJson(path)
+
+    if (json.isEmpty()) {
+        Box(modifier.background(bgColor ?: Color.Transparent))
+        return
+    }
+
+    val composition by rememberLottieComposition(json) {
+        LottieCompositionSpec.JsonString(json)
+    }
+
+    val dynamicProperties = if (tintColor != null) {
+        rememberLottieDynamicProperties(tintColor) {
+            shapeLayer("**") {
+                fill("**") { color { tintColor } }
+                stroke("**") { color { tintColor } }
+            }
+        }
+    } else {
+        null
+    }
+
+    val lottieState = animateLottieCompositionAsState(
+        composition = composition,
+        iterations = iterations,
+        isPlaying = isPlaying,
+        restartOnPlay = false,
+    )
+
+    val currentOnEvent by rememberUpdatedState(onEvent)
+
+    LaunchedEffect(isPlaying) {
+        currentOnEvent?.invoke(if (isPlaying) LottieEvent.Start else LottieEvent.Pause)
+    }
+
+    LaunchedEffect(lottieState) {
+        var armed = false
+        snapshotFlow { lottieState.isAtEnd }.collect { atEnd ->
+            if (!atEnd) armed = true
+            else if (armed) { armed = false; currentOnEvent?.invoke(LottieEvent.Finish) }
+        }
+    }
+
+    Box(modifier.background(bgColor ?: Color.Transparent)) {
+        Image(
+            painter = rememberLottiePainter(
+                composition = composition,
+                progress = lottieState::value,
+                dynamicProperties = dynamicProperties,
+                enableExpressions = false,
+                expressionEngineFactory = { _, _ ->
+                    error("Lottie JS expressions are disabled in MoMo kits")
+                },
+            ),
+            contentDescription = null,
+            modifier = Modifier.fillMaxSize(),
+        )
+    }
+}

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

@@ -0,0 +1,9 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+
+// Overrides LocalDensity.fontScale with the live OS Dynamic Type scale so text re-scales while a
+// screen is visible. Wrapped inside the containers so every screen is covered, not just callers of
+// the app-level wrappers.
+@Composable
+expect fun ProvideOsFontScale(content: @Composable () -> Unit)

package/compose/src/commonMain/kotlin/vn/momo/kits/platform/Platform.kt

@@ -0,0 +1,74 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.NativePaint
+import androidx.compose.ui.unit.Dp
+import vn.momo.kits.navigation.Navigator
+
+data class ScreenDimension(
+    val width: Int,
+    val height: Int,
+)
+
+expect fun getPlatformName(): String
+
+// iPhone idiom only; iPad windows and Android never get the iPhone / iPhone Duo layout.
+expect fun isPhoneIdiom(): Boolean
+
+@Composable
+expect fun getScreenDimensions(): ScreenDimension
+
+expect fun NativePaint.setMaskFilter(blurRadius: Float)
+
+@Composable
+expect fun getStatusBarHeight(): Dp
+
+@Composable
+expect fun BackHandler(enabled: Boolean, onBack: () -> Unit)
+
+@Suppress("ParamsComparedByRef")
+@Composable
+expect fun ProvideNavigationEventDispatcherOwner(navigator: Navigator, content: @Composable () -> Unit)
+
+@Composable
+expect fun getScreenHeight(): Dp
+
+sealed interface OSVersion {
+    val value: Int
+    data class Android(val sdk: Int) : OSVersion { override val value: Int get() = sdk }
+    data class IOS(val major: Int) : OSVersion { override val value: Int get() = major }
+
+    operator fun compareTo(other: Int): Int = value.compareTo(other)
+}
+expect fun getOSVersion(): OSVersion
+
+fun supportsImePadding(): Boolean = when (val v = getOSVersion()) {
+    is OSVersion.Android -> v.sdk > 29
+    is OSVersion.IOS -> true
+}
+const val LottieIterateForever: Int = Int.MAX_VALUE
+
+object LottieEvent {
+    const val Start = "start"
+    const val Pause = "pause"
+    const val Finish = "finish"
+}
+
+@Composable
+expect fun LottieAnimation(
+    path: String,
+    tintColor: Color? = null,
+    bgColor: Color? = null,
+    placedAsOverlay: Boolean = false,
+    iterations: Int = LottieIterateForever,
+    isPlaying: Boolean = true,
+    onEvent: ((String) -> Unit)? = null,
+    modifier: Modifier = Modifier,
+    useCompose: Boolean = false
+)
+
+expect fun NativePaint.setColor(
+    color: Color = Color.Black
+)

package/compose/src/commonMain/kotlin/vn/momo/kits/platform/ReservedRegions.kt

@@ -0,0 +1,20 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.ui.unit.Dp
+
+@Immutable
+internal data class ReservedRegion(val x: Dp, val y: Dp, val width: Dp, val height: Dp)
+
+// occlusion: regions the system occludes (iOS 27.1+), in the coordinates of the Compose root view:
+// the iPhone Duo camera, and the status bar cluster as it grows for a call or a Live Activity.
+// isFoldable: the device reports a `.division` (hinge) region, Apple's foldable check.
+@Immutable
+internal data class ReservedRegions(
+    val occlusion: List<ReservedRegion> = emptyList(),
+    val isFoldable: Boolean = false,
+)
+
+@Composable
+internal expect fun rememberReservedRegions(): ReservedRegions