@momo-kits/native-kits 0.164.1-beta.13 → 0.164.1-beta.14-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,105 @@
+package vn.momo.kits.utils
+
+import androidx.compose.foundation.layout.WindowInsets
+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
+    }
+}
+
+@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/iosMain/kotlin/vn/momo/kits/const/HostFont.ios.kt

@@ -0,0 +1,40 @@
+@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.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): FontFamily? = remember(fileName) {
+    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)
+            },
+        ),
+    )
+}
+
+@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,125 @@
+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
+import kotlinx.cinterop.ExperimentalForeignApi
+import platform.Foundation.NSThread
+import platform.darwin.dispatch_async
+import platform.darwin.dispatch_get_main_queue
+
+/**
+ * Kit end of the host's edge-pan recogniser.
+ *
+ * iOS keeps exactly one back-gesture recogniser and it belongs to the host app — the kit never
+ * installs its own, so the `.failed -> completed` conflict between two competing recognisers is
+ * unreachable by construction. The host replays its drag here; the events are fed into the
+ * `NavigationEventDispatcher` that [NavigationContainer] provides, which drives NavHost's
+ * `PredictiveBackHandler` and therefore `SeekableTransitionState.seekTo`. Parallax, scrim and edge
+ * shadow are children of that same transition, so they follow the finger for free.
+ *
+ * Only primitives cross the Swift boundary: `androidx.navigationevent` is a private transitive
+ * dependency and is absent from the generated framework header.
+ *
+ * Call every method from the main thread; anything else is re-posted to the main queue.
+ */
+object HostBackGestureBridge {
+    private val attachedInputs = mutableListOf<HostNavigationEventInput>()
+    private var gestureInput: HostNavigationEventInput? = null
+
+    /**
+     * Whether the top-most mounted container has an enabled back handler, i.e. the authoritative
+     * answer to "will Compose consume this back?". `false` means no container is mounted, or the
+     * mounted one deliberately opts out (kill switch, overlay showing, custom back handler), and
+     * the host should fall back to its own navigation.
+     */
+    val hasEnabledHandlers: Boolean
+        get() = attachedInputs.lastOrNull()?.hasEnabledHandlers == true
+
+    /** Begins a drag. Pairs with exactly one [completed] or [cancelled]. */
+    fun started() = onMain {
+        val input = attachedInputs.lastOrNull() ?: return@onMain
+        gestureInput = input
+        input.backStarted()
+    }
+
+    /** Drag progress in `0f..1f` — the fraction of the screen width travelled. */
+    fun progressed(progress: Float) = onMain {
+        gestureInput?.backProgressed(progress.coerceIn(0f, 1f))
+    }
+
+    /**
+     * Released past the commit threshold: the screen pops.
+     *
+     * Falls back to the attached input when no drag was started, so a host that commits without
+     * ever seeking still gets a back. Dispatching a bare completion is the documented
+     * non-predictive path — the same shape as a back button press — and dropping it here is what
+     * silently stranded the mini-app root, where the host never seeks.
+     */
+    fun completed() = onMain {
+        (gestureInput ?: attachedInputs.lastOrNull())?.backCompleted()
+        gestureInput = null
+    }
+
+    /** Released below the commit threshold: the screen springs back. */
+    fun cancelled() = onMain {
+        gestureInput?.backCancelled()
+        gestureInput = null
+    }
+
+    internal fun attach(input: HostNavigationEventInput) {
+        attachedInputs += input
+    }
+
+    internal fun detach(input: HostNavigationEventInput) {
+        attachedInputs -= input
+        // A container unmounted mid-drag must not hand its pending terminal event to whichever
+        // container is on top now: NavigationEventInput fabricates a non-predictive start for a
+        // completed/cancelled it never saw begin, which would pop a screen out of nowhere.
+        if (gestureInput === input) gestureInput = null
+    }
+}
+
+/** Wires one [NavigationContainer]'s dispatcher to [HostBackGestureBridge] while it is composed. */
+@Composable
+internal fun AttachHostBackGesture(dispatcher: NavigationEventDispatcher) {
+    val input = remember(dispatcher) { HostNavigationEventInput() }
+
+    DisposableEffect(dispatcher, input) {
+        dispatcher.addInput(input)
+        HostBackGestureBridge.attach(input)
+        onDispose {
+            HostBackGestureBridge.detach(input)
+            dispatcher.removeInput(input)
+        }
+    }
+}
+
+internal class HostNavigationEventInput : NavigationEventInput() {
+    var hasEnabledHandlers: Boolean = false
+        private set
+
+    override fun onHasEnabledHandlersChanged(hasEnabledHandlers: Boolean) {
+        this.hasEnabledHandlers = hasEnabledHandlers
+    }
+
+    // Touch coordinates are not forwarded — the stack transition is seeked by progress alone, and
+    // leaving them out keeps the bridge's Swift-facing signatures primitive.
+    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()
+}
+
+@OptIn(ExperimentalForeignApi::class)
+private fun onMain(block: () -> Unit) {
+    if (NSThread.isMainThread()) block() else dispatch_async(dispatch_get_main_queue()) { block() }
+}

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

@@ -0,0 +1,32 @@
+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
+
+private const val STATUS_BAR_TAPPED_NOTIFICATION = "statusBarSelected"
+
+@Composable
+internal actual fun RegisterScrollToTop(callback: (() -> Unit)?) {
+    val maxApi = LocalMaxApi.current
+    DisposableEffect(callback) {
+        val token: NSObjectProtocol? = if (callback != null) {
+            NSNotificationCenter.defaultCenter.addObserverForName(
+                name = STATUS_BAR_TAPPED_NOTIFICATION,
+                `object` = null,
+                queue = NSOperationQueue.mainQueue,
+            ) { _: NSNotification? ->
+                runCatching { callback() }.onFailure {
+                    maxApi?.logFile("[ScrollToTop] callback threw: ${it.message}") {}
+
+                }
+            }
+        } else null
+        onDispose {
+            token?.let { NSNotificationCenter.defaultCenter.removeObserver(it) }
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+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
+
+// NavigationEventDispatcher.transitionState is a passive observer: UIKitNavigationEventInput
+// publishes every edge-pan event to it without any handler consuming the gesture. Its `progress`
+// is touch.x / view width, i.e. a plain fraction of the screen 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
+}

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()
+    }
+}