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

package/compose/src/commonMain/kotlin/vn/momo/kits/utils/Resources.kt

@@ -0,0 +1,55 @@
+package vn.momo.kits.utils
+
+import androidx.compose.runtime.*
+import org.jetbrains.compose.resources.DrawableResource
+import org.jetbrains.compose.resources.InternalResourceApi
+import org.jetbrains.compose.resources.ResourceItem
+import org.jetbrains.compose.resources.readResourceBytes
+@OptIn(InternalResourceApi::class)
+@Composable
+internal fun readJson(name: String): String {
+    val path = name.plus(".json")
+    val candidatePaths = listOf(
+        path,
+        "composeResources/vn.momo.compose.resources/$path",
+    )
+
+    val jsonContent by rememberState(path, { "" }) {
+        val cached = resourceCache.getOrPut(path) {
+            var content = ""
+            for (candidate in candidatePaths) {
+                try {
+                    content = readResourceBytes(candidate).decodeToString()
+                    break
+                } catch (_: Exception) {
+                    // try next candidate
+                }
+            }
+            ResourceCache.JSON(content)
+        } as ResourceCache.JSON
+
+        cached.json
+    }
+
+    return jsonContent
+}
+
+
+private val resourceCache = mutableMapOf<String, ResourceCache>()
+
+private sealed interface ResourceCache {
+    class JSON(val json: String) : ResourceCache
+}
+
+@Composable
+fun <T> rememberState(
+    key: Any,
+    getDefault: () -> T,
+    block: suspend () -> T
+): MutableState<T> {
+    val state = remember(key) { mutableStateOf(getDefault()) }
+    LaunchedEffect(key) {
+        state.value = block()
+    }
+    return state
+}

package/compose/src/commonMain/kotlin/vn/momo/kits/utils/Tracking.kt

@@ -0,0 +1,15 @@
+package vn.momo.kits.utils
+
+import androidx.compose.runtime.Composable
+import vn.momo.kits.application.LocalComponentInformation
+
+@Composable
+internal fun getComponentId(
+    componentName: String? = null,
+    accessibilityLabel: String? = null,
+): String {
+    val componentInformation = LocalComponentInformation.current
+    if (accessibilityLabel != null) return accessibilityLabel
+    if (componentInformation?.componentId != null) return componentInformation.componentId
+    return ""
+}

package/compose/src/commonMain/kotlin/vn/momo/kits/utils/Utils.kt

@@ -0,0 +1,118 @@
+package vn.momo.kits.utils
+
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.WindowInsetsSides
+import androidx.compose.foundation.layout.displayCutout
+import androidx.compose.foundation.layout.only
+import androidx.compose.foundation.layout.union
+import androidx.compose.foundation.layout.windowInsetsPadding
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.composed
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.min
+import vn.momo.kits.const.AppNavigationBar
+import vn.momo.kits.const.AppStatusBar
+import vn.momo.kits.platform.getPlatformName
+import kotlin.math.abs
+
+
+internal fun Modifier.bottomBorder(strokeWidth: Dp, color: Color) = composed(
+    factory = {
+        val density = LocalDensity.current
+        val strokeWidthPx = density.run { strokeWidth.toPx() }
+        if (strokeWidth > 0.dp) {
+            Modifier.drawBehind {
+                val width = size.width
+                val height = size.height - strokeWidthPx / 2
+
+                drawLine(
+                    color = color,
+                    start = Offset(x = 0f, y = height),
+                    end = Offset(x = width, y = height),
+                    strokeWidth = strokeWidthPx
+                )
+            }
+        } else {
+            Modifier
+        }
+    }
+)
+
+fun <T> Boolean.ifTrue(trueCase: T, falseCase: T): T = if (this) trueCase else falseCase
+fun <T> String.ifNotNull(trueCase: T, falseCase: T): T =
+    if (this.isBlank()) falseCase else trueCase
+
+fun formatNumberToMoney(number: Long, currency: String = "đ"): String {
+    if (number == 0L) {
+        return "0$currency"
+    }
+    val array = mutableListOf<Char>()
+    var result = ""
+    var isNegative = false
+
+    if (number < 0) {
+        isNegative = true
+    }
+    val numberString = abs(number).toString() // Convert to Int to avoid decimal places
+    if (numberString.length < 3) {
+        return numberString + currency
+    }
+    var count = 0
+    for (i in numberString.length - 1 downTo 0) {
+        count += 1
+        array.add(numberString[i])
+        if (count == 3 && i >= 1) {
+            array.add('.')
+            count = 0
+        }
+    }
+
+    for (i in array.size - 1 downTo 0) {
+        result += array[i]
+    }
+
+    if (isNegative) {
+        result = "-$result"
+    }
+
+    return result + currency
+}
+
+@Composable
+fun getAppStatusBarHeight(): Dp {
+    return if (AppStatusBar.current == 0.dp) {
+        WindowInsets.systemBars.asPaddingValues().calculateTopPadding()
+    } else {
+        AppStatusBar.current
+    }
+}
+
+internal val horizontalSafeAreaInsets: WindowInsets
+    @Composable get() = WindowInsets.systemBars.union(WindowInsets.displayCutout).only(WindowInsetsSides.Horizontal)
+
+// Left/right safe area like SwiftUI (landscape camera/notch); consumed, so nested StackScreens don't pad twice.
+internal fun Modifier.horizontalSafeAreaPadding(): Modifier = composed {
+    windowInsetsPadding(horizontalSafeAreaInsets)
+}
+
+@Composable
+internal fun getNavigationBarHeight(): Dp {
+    return if (AppNavigationBar.current == 0.dp) {
+        val systemBottomPadding = WindowInsets.systemBars.asPaddingValues().calculateBottomPadding()
+        if (getPlatformName() == "iOS") {
+            min(systemBottomPadding, 21.dp)
+        } else {
+            systemBottomPadding
+        }
+    } else {
+        AppNavigationBar.current
+    }
+}

package/compose/src/commonTest/kotlin/vn/momo/kits/navigation/component/HelpCenterRequestTest.kt

@@ -0,0 +1,44 @@
+// File: HelpCenterRequestTest.kt
+// Created At: 2026-10-19 +07:00
+// Created By: AI | AI Agent: Codex | Model: GPT-6
+// AI-GENERATED START: verify Help Center identity and localized payload preservation
+package vn.momo.kits.navigation.component
+
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import vn.momo.kits.application.MiniAppContext
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class HelpCenterRequestTest {
+    @Test
+    fun preservesApplicationIdentityAndLocalizedObjects() {
+        val context = MiniAppContext(
+            appId = "app-id",
+            appCode = "app-code",
+            appIcon = "app-icon",
+            appName = mapOf("vi" to "Tên ứng dụng", "en" to "App name"),
+            description = mapOf("vi" to "Mô tả", "en" to "Description"),
+        )
+        val request = context.helpCenterRequest().context
+        assertEquals(context.appId, request.appId)
+        assertEquals(context.appCode, request.code)
+        assertEquals(context.appIcon, request.icon)
+        assertEquals(JsonObject(mapOf("vi" to JsonPrimitive("Tên ứng dụng"),
+            "en" to JsonPrimitive("App name"))), request.name)
+        assertEquals(JsonObject(mapOf("vi" to JsonPrimitive("Mô tả"),
+            "en" to JsonPrimitive("Description"))), request.description)
+        assertNull(request.support)
+        assertNull(request.toolkitConfig)
+        assertNull(request.permissions)
+    }
+
+    @Test
+    fun preservesPlainStringsAndAbsentValues() {
+        val request = MiniAppContext(appName = "App name").helpCenterRequest().context
+        assertEquals(JsonPrimitive("App name"), request.name)
+        assertNull(request.description)
+    }
+}
+// AI-GENERATED END: verify Help Center identity and localized payload preservation

package/compose/src/commonTest/kotlin/vn/momo/kits/navigation/component/ToolkitRequestsTest.kt

@@ -0,0 +1,62 @@
+// File: ToolkitRequestsTest.kt
+// Created At: 2026-10-12 +07:00 | Created By: AI | AI Agent: Codex | Model: GPT-6
+// AI-GENERATED START: verify cancellation and late callback suppression for toolkit UI
+package vn.momo.kits.navigation.component
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import vn.momo.maxapi.runtime.ApiCallback
+import vn.momo.maxapi.runtime.ApiRequestHandle
+import vn.momo.maxapi.runtime.ApiResult
+
+class ToolkitRequestsTest {
+    @Test
+    fun closingCancelsPendingRequestsAndSuppressesLateCallbacks() {
+        val owner = ToolkitRequests()
+        val handle = Handle()
+        var callback: ApiCallback<Boolean> = {}
+        var results = 0
+        owner.launch<Boolean>({ callback = it; handle }) { results++ }
+        owner.close()
+        owner.close()
+        callback(ApiResult.Success(true))
+        assertEquals(1, handle.cancellations)
+        assertEquals(0, results)
+    }
+
+    @Test
+    fun completedRequestsAreReleasedAndClosedOwnersNeverStartNewRequests() {
+        val owner = ToolkitRequests()
+        val handle = Handle()
+        var starts = 0
+        var results = 0
+        owner.launch<Boolean>({ callback -> starts++; callback(ApiResult.Success(false)); handle }) { results++ }
+        owner.close()
+        owner.launch<Boolean>({ starts++; handle }) { results++ }
+        assertEquals(0, handle.cancellations)
+        assertEquals(1, starts)
+        assertEquals(1, results)
+    }
+
+    @Test
+    fun sheetEventsKeepTheirSubscriptionUntilTheOwnerCloses() {
+        val owner = ToolkitRequests()
+        val handle = Handle()
+        var callback: ApiCallback<Boolean> = {}
+        var results = 0
+        owner.observe<Boolean>({ callback = it; handle }) { results++ }
+        callback(ApiResult.Success(true))
+        callback(ApiResult.Success(false))
+        owner.close()
+        callback(ApiResult.Success(true))
+        assertEquals(2, results)
+        assertEquals(1, handle.cancellations)
+    }
+
+    private class Handle : ApiRequestHandle {
+        override val requestId = "toolkit-test"
+        var cancellations = 0
+        override fun cancel() { cancellations++ }
+    }
+}
+// AI-GENERATED END: verify cancellation and late callback suppression for toolkit UI

package/compose/src/iosMain/kotlin/vn/momo/kits/const/HostFont.ios.kt

@@ -0,0 +1,42 @@
+@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
+
+package vn.momo.kits.const
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.platform.Font
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.addressOf
+import kotlinx.cinterop.usePinned
+import platform.Foundation.NSBundle
+import platform.Foundation.NSData
+import platform.Foundation.dataWithContentsOfFile
+import platform.posix.memcpy
+
+@Composable
+internal actual fun hostFontFamily(fileName: String, weight: FontWeight): FontFamily? = remember(fileName, weight) {
+    val name = fileName.substringBeforeLast('.')
+    val ext = fileName.substringAfterLast('.', "")
+    // Font từ font-source nằm rời ở bundle root, không nằm trong compose-resources.
+    val path = NSBundle.mainBundle.pathForResource(name, ext) ?: return@remember null
+    FontFamily(
+        Font(
+            identity = fileName,
+            getData = {
+                NSData.dataWithContentsOfFile(path)?.toByteArray() ?: ByteArray(0)
+            },
+            weight = weight,
+        ),
+    )
+}
+
+@OptIn(ExperimentalForeignApi::class)
+private fun NSData.toByteArray(): ByteArray {
+    val size = length.toInt()
+    if (size == 0) return ByteArray(0)
+    return ByteArray(size).apply {
+        usePinned { pinned -> memcpy(pinned.addressOf(0), bytes, length) }
+    }
+}

package/compose/src/iosMain/kotlin/vn/momo/kits/navigation/HostBackGesture.ios.kt

@@ -0,0 +1,45 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.remember
+import androidx.navigationevent.NavigationEvent
+import androidx.navigationevent.NavigationEventDispatcher
+import androidx.navigationevent.NavigationEventInput
+
+@Suppress("ParamsComparedByRef")
+@Composable
+internal fun AttachHostBackGesture(dispatcher: NavigationEventDispatcher, navigator: Navigator) {
+    val input = remember(dispatcher) { HostNavigationEventInput() }
+    val target = remember(input, navigator) {
+        object : HostBackTarget {
+            override fun canPop() = navigator.canPop()
+            override fun onBack() = navigator.onBackSafe()
+            override fun backStarted() = input.backStarted()
+            override fun backProgressed(progress: Float) = input.backProgressed(progress)
+            override fun backCompleted() = input.backCompleted()
+            override fun backCancelled() = input.backCancelled()
+        }
+    }
+
+    DisposableEffect(dispatcher, target) {
+        dispatcher.addInput(input)
+        HostBackGestureBridge.attach(target)
+        onDispose {
+            HostBackGestureBridge.detach(target)
+            dispatcher.removeInput(input)
+        }
+    }
+}
+
+internal class HostNavigationEventInput : NavigationEventInput() {
+    fun backStarted() = dispatchOnBackStarted(NavigationEvent(swipeEdge = NavigationEvent.EDGE_LEFT))
+
+    fun backProgressed(progress: Float) = dispatchOnBackProgressed(
+        NavigationEvent(swipeEdge = NavigationEvent.EDGE_LEFT, progress = progress)
+    )
+
+    fun backCancelled() = dispatchOnBackCancelled()
+
+    fun backCompleted() = dispatchOnBackCompleted()
+}

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

@@ -0,0 +1,34 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import platform.Foundation.NSNotification
+import platform.Foundation.NSNotificationCenter
+import platform.Foundation.NSOperationQueue
+import platform.darwin.NSObjectProtocol
+import vn.momo.maxapi.contract.observability.logging.model.LogLevel
+
+private const val STATUS_BAR_TAPPED_NOTIFICATION = "statusBarSelected"
+
+@Composable
+internal actual fun RegisterScrollToTop(callback: (() -> Unit)?) {
+    val maxApi = LocalMaxApi.current
+    DisposableEffect(callback, maxApi) {
+        val logger = if (callback != null) maxApi?.openLogger() else null
+        val token: NSObjectProtocol? = if (callback != null) {
+            NSNotificationCenter.defaultCenter.addObserverForName(
+                name = STATUS_BAR_TAPPED_NOTIFICATION,
+                `object` = null,
+                queue = NSOperationQueue.mainQueue,
+            ) { _: NSNotification? ->
+                runCatching { callback() }.onFailure {
+                    logger?.log(LogLevel.ERROR, "[ScrollToTop] callback failed")
+                }
+            }
+        } else null
+        onDispose {
+            token?.let { NSNotificationCenter.defaultCenter.removeObserver(it) }
+            logger?.close()
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.State
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.InternalComposeUiApi
+import androidx.compose.ui.backhandler.LocalCompatNavigationEventDispatcherOwner
+import androidx.navigationevent.NavigationEventTransitionState
+import vn.momo.kits.navigation.HostBackGestureBridge
+
+// transitionState is a passive observer; its progress is touch.x / view width.
+@OptIn(InternalComposeUiApi::class)
+@Composable
+actual fun rememberBackGestureProgress(): State<Float?> {
+    val dispatcher = LocalCompatNavigationEventDispatcherOwner.current?.navigationEventDispatcher
+    val progress = remember { mutableStateOf<Float?>(null) }
+
+    LaunchedEffect(dispatcher) {
+        if (dispatcher == null) {
+            progress.value = null
+            return@LaunchedEffect
+        }
+        dispatcher.transitionState.collect { state ->
+            progress.value = (state as? NavigationEventTransitionState.InProgress)
+                ?.takeIf { it.direction == NavigationEventTransitionState.TRANSITIONING_BACK }
+                ?.latestEvent
+                ?.progress
+        }
+    }
+
+    return progress
+}
+
+actual fun reportFloatingArrowBack(shouldUse: Boolean) {
+    HostBackGestureBridge.shouldUseFloatingArrowBack = shouldUse
+}

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

@@ -0,0 +1,66 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Density
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.ObjCAction
+import platform.Foundation.NSNotification
+import platform.Foundation.NSNotificationCenter
+import platform.Foundation.NSSelectorFromString
+import platform.UIKit.UIContentSizeCategoryDidChangeNotification
+import platform.UIKit.UIFont
+import platform.UIKit.UIFontTextStyleBody
+import platform.darwin.NSObject
+
+// Compose MP iOS reads LocalDensity.fontScale once at ComposeUIViewController creation and does not
+// recompose it when UIContentSizeCategory changes (Android tracks Configuration.fontScale live). We
+// observe the notification and override LocalDensity.fontScale so scaleSize() recomposes live. The
+// formula matches the SwiftUI kit (UIFont body point size / 17) so both iOS surfaces scale alike.
+private const val DEFAULT_BODY_POINT_SIZE = 17.0
+
+private fun currentOsFontScale(): Float =
+    (UIFont.preferredFontForTextStyle(UIFontTextStyleBody).pointSize / DEFAULT_BODY_POINT_SIZE).toFloat()
+
+@OptIn(ExperimentalForeignApi::class)
+@Composable
+actual fun ProvideOsFontScale(content: @Composable () -> Unit) {
+    val osFontScale = remember { mutableStateOf(currentOsFontScale()) }
+
+    val listener = remember {
+        object : NSObject() {
+            @Suppress("unused")
+            @ObjCAction
+            fun contentSizeChanged(arg: NSNotification) {
+                osFontScale.value = currentOsFontScale()
+            }
+        }
+    }
+
+    DisposableEffect(Unit) {
+        NSNotificationCenter.defaultCenter.addObserver(
+            observer = listener,
+            selector = NSSelectorFromString(listener::contentSizeChanged.name + ":"),
+            name = UIContentSizeCategoryDidChangeNotification,
+            `object` = null,
+        )
+        onDispose {
+            NSNotificationCenter.defaultCenter.removeObserver(
+                observer = listener,
+                name = UIContentSizeCategoryDidChangeNotification,
+                `object` = null,
+            )
+        }
+    }
+
+    val density = LocalDensity.current
+    CompositionLocalProvider(
+        LocalDensity provides Density(density.density, osFontScale.value),
+    ) {
+        content()
+    }
+}