@momo-kits/native-kits 0.162.46-debug → 0.162.46

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

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

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

@@ -1,118 +0,0 @@
-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/iosMain/kotlin/vn/momo/kits/const/HostFont.ios.kt

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

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

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

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

@@ -1,66 +0,0 @@
-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()
-    }
-}

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

@@ -1,217 +0,0 @@
-package vn.momo.kits.platform
-
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.asPaddingValues
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.systemBars
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberUpdatedState
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.ExperimentalComposeUiApi
-import androidx.compose.ui.InternalComposeUiApi
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.backhandler.LocalCompatNavigationEventDispatcherOwner
-import androidx.compose.ui.backhandler.BackHandler as ComposeBackHandler
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.NativePaint
-import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.viewinterop.UIKitInteropProperties
-import androidx.compose.ui.viewinterop.UIKitView
-import cocoapods.lottie_ios.CompatibleAnimation
-import cocoapods.lottie_ios.CompatibleAnimationKeypath
-import cocoapods.lottie_ios.CompatibleAnimationView
-import kotlinx.cinterop.ExperimentalForeignApi
-import kotlinx.cinterop.get
-import kotlinx.cinterop.memScoped
-import androidx.navigationevent.NavigationEventDispatcher
-import androidx.navigationevent.NavigationEventDispatcherOwner
-import org.jetbrains.skia.FilterBlurMode
-import org.jetbrains.skia.MaskFilter
-import platform.Foundation.NSBundle
-import platform.UIKit.UIColor
-import platform.UIKit.UIDevice
-import platform.UIKit.UIScreen
-import platform.UIKit.UIUserInterfaceIdiomPhone
-import vn.momo.kits.navigation.AttachHostBackGesture
-import vn.momo.kits.navigation.Navigator
-
-actual fun getPlatformName(): String = "iOS"
-
-actual fun isPhoneIdiom(): Boolean =
-    UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPhone
-
-@OptIn(ExperimentalForeignApi::class)
-@Composable
-actual fun getScreenDimensions(): ScreenDimension = memScoped {
-    val config = UIScreen.mainScreen.bounds.ptr[0]
-    return ScreenDimension(
-        config.size.width.toInt(),
-        config.size.height.toInt()
-    )
-}
-
-actual fun NativePaint.setMaskFilter(blurRadius: Float) {
-    this.maskFilter = MaskFilter.makeBlur(FilterBlurMode.NORMAL, blurRadius / 2, true)
-}
-
-@Composable
-actual fun getStatusBarHeight(): Dp {
-    return WindowInsets.systemBars.asPaddingValues().calculateTopPadding()
-}
-
-@Suppress("DEPRECATION")
-@OptIn(ExperimentalComposeUiApi::class)
-@Composable
-actual fun BackHandler(enabled: Boolean, onBack: () -> Unit) {
-    ComposeBackHandler(enabled = enabled, onBack = onBack)
-}
-
-@OptIn(InternalComposeUiApi::class)
-@Composable
-actual fun ProvideNavigationEventDispatcherOwner(navigator: Navigator, content: @Composable () -> Unit) {
-    val navigationEventDispatcherOwner = remember {
-        object : NavigationEventDispatcherOwner {
-            override val navigationEventDispatcher = NavigationEventDispatcher()
-        }
-    }
-
-    AttachHostBackGesture(navigationEventDispatcherOwner.navigationEventDispatcher, navigator)
-
-    CompositionLocalProvider(
-        LocalCompatNavigationEventDispatcherOwner provides navigationEventDispatcherOwner,
-        content = content
-    )
-}
-
-@Composable
-actual fun getScreenHeight(): Dp {
-    return getScreenDimensions().height.dp
-}
-
-actual fun getOSVersion(): OSVersion = OSVersion.IOS(
-    major = UIDevice.currentDevice.systemVersion.substringBefore(".").toIntOrNull() ?: 0
-)
-
-@OptIn(ExperimentalForeignApi::class, ExperimentalComposeUiApi::class)
-@Composable
-actual fun LottieAnimation(
-    path: String,
-    tintColor: Color?,
-    bgColor: Color?,
-    placedAsOverlay: Boolean,
-    iterations: Int,
-    isPlaying: Boolean,
-    onEvent: ((String) -> Unit)?,
-    modifier: Modifier,
-    useCompose: Boolean
-) {
-    if (useCompose) {
-        ComposeLottieAnimation(path, tintColor, bgColor, iterations, isPlaying, onEvent, modifier)
-        return
-    }
-
-    val loopCount = if (iterations == LottieIterateForever) -1.0 else iterations.toDouble()
-
-    var animation by remember { mutableStateOf<CompatibleAnimation?>(null) }
-    val animationView = remember { mutableStateOf<CompatibleAnimationView?>(null) }
-
-    LaunchedEffect(Unit) {
-        animation = CompatibleAnimation(name = "compose-resources/composeResources/vn.momo.compose.resources/".plus(path), subdirectory = null, NSBundle.mainBundle)
-    }
-
-    val currentOnEvent by rememberUpdatedState(onEvent)
-
-    LaunchedEffect(isPlaying) {
-        currentOnEvent?.invoke(if (isPlaying) LottieEvent.Start else LottieEvent.Pause)
-    }
-
-    LaunchedEffect(animationView.value, isPlaying) {
-        val view = animationView.value ?: return@LaunchedEffect
-        if (isPlaying) {
-            view.playWithCompletion(completion = { finished -> if (finished) currentOnEvent?.invoke(LottieEvent.Finish) })
-        } else {
-            view.pause()
-        }
-    }
-
-    when (val value = animation) {
-        null -> {
-            Box(modifier)
-        }
-
-        else -> {
-            Box(modifier) {
-                UIKitView(
-                    modifier = Modifier.fillMaxSize(),
-                    properties = UIKitInteropProperties(placedAsOverlay = placedAsOverlay),
-                    factory = {
-                        CompatibleAnimationView(value).apply {
-                            translatesAutoresizingMaskIntoConstraints = true
-
-                            setBackgroundColor(bgColor?.toUIColor() ?: UIColor.clearColor)
-
-                            setLoopAnimationCount(loopCount)
-                            setAnimationSpeed(1.0)
-
-                            if (tintColor != null) {
-                                val uiColor = tintColor.toUIColor()
-                                setColorValue(uiColor,
-                                    CompatibleAnimationKeypath("**.Fill 1.Color")
-                                )
-                                setColorValue(uiColor, CompatibleAnimationKeypath("**.Fill.Color"))
-                                setColorValue(uiColor, CompatibleAnimationKeypath("**.Color"))
-                                setColorValue(uiColor, CompatibleAnimationKeypath("**.Stroke 1.Color"))
-                                setColorValue(uiColor, CompatibleAnimationKeypath("**.Stroke.Color"))
-                            }
-
-                            animationView.value = this
-                        }
-                    },
-
-                    update = { view ->
-                        view.setBackgroundColor(bgColor?.toUIColor() ?: UIColor.clearColor)
-                        view.setLoopAnimationCount(loopCount)
-
-                        if (tintColor != null) {
-                            val uiColor = tintColor.toUIColor()
-
-                            view.setColorValue(uiColor, CompatibleAnimationKeypath("**.Fill 1.Color"))
-                            view.setColorValue(uiColor, CompatibleAnimationKeypath("**.Fill.Color"))
-                            view.setColorValue(uiColor, CompatibleAnimationKeypath("**.Color"))
-                            view.setColorValue(uiColor, CompatibleAnimationKeypath("**.Stroke 1.Color"))
-                            view.setColorValue(uiColor, CompatibleAnimationKeypath("**.Stroke.Color"))
-                        }
-                    }
-                )
-            }
-        }
-    }
-}
-
-fun Color.toUIColor(): UIColor {
-    val argb = this.toArgb()
-
-    val a = ((argb shr 24) and 0xFF) / 255.0
-    val r = ((argb shr 16) and 0xFF) / 255.0
-    val g = ((argb shr 8) and 0xFF) / 255.0
-    val b = (argb and 0xFF) / 255.0
-
-    return UIColor(
-        red = r,
-        green = g,
-        blue = b,
-        alpha = a
-    )
-}
-
-actual fun NativePaint.setColor(color: Color){
-    this.color = color.toArgb()
-}