@momo-kits/native-kits 0.162.2-test.1-debug → 0.162.2-test.10-debug

package/.codegraph/.gitignore

@@ -0,0 +1,5 @@
+# CodeGraph data files — local to each machine, not for committing.
+# Ignore everything in .codegraph/ except this file itself, so transient
+# files (the database, daemon.pid, sockets, logs) never show up in git.
+*
+!.gitignore

package/compose/build.gradle.kts

@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.161.0-debug"
+        version = "0.162.2-test.10-debug"
         summary = "IOS Shared module"
         homepage = "https://momo.vn"
         ios.deploymentTarget = "15.0"

package/compose/build.gradle.kts.backup

@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.161.0-debug"
+        version = gitlabVersion
         summary = "IOS Shared module"
         homepage = "https://momo.vn"
         ios.deploymentTarget = "15.0"
@@ -86,14 +86,14 @@ kotlin {
 }
 
 android {
-    namespace = "vn.momo.kits.kits"
-    compileSdk = 35
+    namespace = "$gitlabGroup.$gitlabArtifactId"
+    compileSdk = libs.versions.android.compileSdk.get().toInt()
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
     }
     defaultConfig {
-        minSdk = 24
+        minSdk = libs.versions.android.minSdk.get().toInt()
     }
 }
 

package/compose/src/commonMain/kotlin/vn/momo/kits/application/Context.kt

@@ -28,8 +28,7 @@ data class MiniAppContext(
     val providerId: String = "",
     val permissions: List<Map<String, Any>>? = emptyList(),
     val features: FeatureFlags? = null,
-    val useDeviceFontScale: Boolean? = null,
-    val appFontScale: Float? = null,
+    val fontScaleConfig: FontScaleConfig? = null,
 ) {
     companion object {
 
@@ -61,8 +60,7 @@ data class MiniAppContext(
                 providerId = parent.providerId.ifBlank { child.providerId },
                 permissions = if (!parent.permissions.isNullOrEmpty()) parent.permissions else child.permissions,
                 features = mergeFeatureFlags(parent.features, child.features),
-                useDeviceFontScale = parent.useDeviceFontScale ?: child.useDeviceFontScale,
-                appFontScale = parent.appFontScale ?: child.appFontScale,
+                fontScaleConfig = parent.fontScaleConfig ?: child.fontScaleConfig,
             )
         }
 
@@ -108,6 +106,14 @@ val LocalComponentInformation = staticCompositionLocalOf<ComponentInformation?>
     null
 }
 
-val LocalUseDeviceFontScale = staticCompositionLocalOf<Boolean> { true }
+@Immutable
+data class FontScaleConfig(
+    val useOSFontScale: Boolean = true,
+    val userScaleRate: Float? = null,
+    // Host-measured OS font scale, pushed live on resume/config change (MainActivity has
+    // configChanges=fontScale so LocalDensity.fontScale can be stale). Falls back to density when null.
+    val osFontScale: Float? = null,
+)
 
-val LocalAppFontScale = staticCompositionLocalOf<Float> { 1f }
+// Single source of truth: holds both the OS flag and the user-adjusted rate.
+val LocalFontScaleConfig = staticCompositionLocalOf { FontScaleConfig() }

package/compose/src/commonMain/kotlin/vn/momo/kits/components/Text.kt

@@ -40,6 +40,7 @@ fun Text(
     softWrap: Boolean = true,
     accessibilityId: String? = null,
     inlineContent: Map<String, InlineTextContent> = mapOf(),
+    userScaleRate: Float? = null,
     ) {
     Text(
         text = AnnotatedString(text),
@@ -56,7 +57,8 @@ fun Text(
         letterSpacing = letterSpacing,
         softWrap = softWrap,
         accessibilityId = accessibilityId,
-        inlineContent = inlineContent
+        inlineContent = inlineContent,
+        userScaleRate = userScaleRate
     )
 }
 
@@ -78,13 +80,14 @@ fun Text(
     softWrap: Boolean = true,
     accessibilityId: String? = null,
     inlineContent: Map<String, InlineTextContent> = mapOf(),
+    userScaleRate: Float? = null,
 ) {
     // Cache theme access to avoid repeated lookups
     val theme = AppTheme.current
 
     // Call @Composable functions directly in composable context
-    val scaledFontSize = scaleSize(style.fontSize)
-    val scaledLineHeight = scaleSize(style.lineHeight)
+    val scaledFontSize = scaleSize(style.fontSize, userScaleRate)
+    val scaledLineHeight = scaleSize(style.lineHeight, userScaleRate)
     val fontFamilyResult = getFontFamily(fontFamily ?: theme.font, style.fontWeight)
 
     // Now memoize the results

package/compose/src/commonMain/kotlin/vn/momo/kits/const/Typography.kt

@@ -15,8 +15,7 @@ import androidx.compose.ui.unit.sp
 import org.jetbrains.compose.resources.Font
 import org.jetbrains.compose.resources.FontResource
 import org.jetbrains.compose.resources.InternalResourceApi
-import vn.momo.kits.application.LocalAppFontScale
-import vn.momo.kits.application.LocalUseDeviceFontScale
+import vn.momo.kits.application.LocalFontScaleConfig
 import vn.momo.kits.platform.getScreenDimensions
 import vn.momo.uikits.resources.Res
 import vn.momo.uikits.resources.momosignature
@@ -38,64 +37,67 @@ const val MAX_FONT_SCALE = 1.5f
 const val MAX_DEVICE_SCALE = 5
 
 @Composable
-fun scaleSize(size: Float): Float {
-    val useDeviceFontScale = LocalUseDeviceFontScale.current
-    val appFontScale = LocalAppFontScale.current
-    val deviceWidth = getScreenDimensions().width
-    val deviceScale = deviceWidth / DEFAULT_SCREEN_SIZE
+fun scaleSize(size: Float, userScaleRate: Float? = null): Float {
+    // single source of truth: useOSFontScale + userScaleRate both read from LocalFontScaleConfig
+    val fontScaleConfig = LocalFontScaleConfig.current
+    val useOSFontScale = fontScaleConfig.useOSFontScale
+    // param userScaleRate overrides config; if absent -> config.userScaleRate -> 1f (no scaling)
+    val customRate = userScaleRate ?: fontScaleConfig.userScaleRate ?: 1f
 
-    val density = LocalDensity.current
-    val fontScale = density.fontScale
+    // Read composables unconditionally (rule of Compose) before branching on the math below.
+    val deviceScale = getScreenDimensions().width / DEFAULT_SCREEN_SIZE
+    // OS font scale: prefer the host-pushed value (live on resume/config change, since the activity
+    // isn't recreated on fontScale change); fall back to the Compose density when not reported yet.
+    val fontScale = fontScaleConfig.osFontScale ?: LocalDensity.current.fontScale
+
+    // useOSFontScale off -> the user has full control via customRate; skip device-width scaling
+    // entirely and apply only the custom rate (capped at MAX_FONT_SCALE).
+    if (!useOSFontScale) {
+        // custom rate is uncapped (full user control); only the OS-follow path below caps at MAX_FONT_SCALE.
+        return if (customRate > 1f) customRate * size else size
+    }
 
+    // useOSFontScale on -> device-width scale + OS font scale, take the larger.
     var fontSizeScaleDevice = size
     var fontSizeScaleOS = size
-
     if (deviceScale > 1) {
         fontSizeScaleDevice =
             min(deviceScale * fontSizeScaleDevice, fontSizeScaleDevice + MAX_DEVICE_SCALE)
     }
-
-    if (useDeviceFontScale) {
-        if (fontScale > 1) {
-            fontSizeScaleOS = min(fontScale * fontSizeScaleOS, fontSizeScaleOS * MAX_FONT_SCALE)
-        }
-    } else {
-        fontSizeScaleOS = size * appFontScale
+    if (fontScale > 1f) {
+        fontSizeScaleOS = min(fontScale * fontSizeScaleOS, fontSizeScaleOS * MAX_FONT_SCALE)
     }
 
-    return max(
-        fontSizeScaleDevice,
-        fontSizeScaleOS
-    )
+    return max(fontSizeScaleDevice, fontSizeScaleOS)
 }
 
 @Composable
-fun scaleSize(size: TextUnit): TextUnit {
+fun scaleSize(size: TextUnit, userScaleRate: Float? = null): TextUnit {
     if (!size.isSp) return size
 
     val density = LocalDensity.current
 
-    val scaled = scaleSize(size.value)
+    val scaled = scaleSize(size.value, userScaleRate)
     val spValue = scaled / density.fontScale
 
     return TextUnit(value = spValue, type = TextUnitType.Sp)
 }
 
 @Composable
-fun scaleSize(size: Dp): Dp {
-    return scaleSize(size.value).dp
+fun scaleSize(size: Dp, userScaleRate: Float? = null): Dp {
+    return scaleSize(size.value, userScaleRate).dp
 }
 
 @Composable
-fun scaleSize(textStyle: TextStyle): TextStyle {
+fun scaleSize(textStyle: TextStyle, userScaleRate: Float? = null): TextStyle {
     return textStyle.copy(
         fontSize = if (textStyle.fontSize != TextUnit.Unspecified)
-            scaleSize(textStyle.fontSize)
+            scaleSize(textStyle.fontSize, userScaleRate)
         else
             TextUnit.Unspecified,
 
         lineHeight = if (textStyle.lineHeight != TextUnit.Unspecified)
-            scaleSize(textStyle.lineHeight)
+            scaleSize(textStyle.lineHeight, userScaleRate)
         else
             TextUnit.Unspecified,
     )

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

@@ -9,6 +9,7 @@ import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.rememberNavController
 import androidx.navigation.toRoute
+import kotlinx.coroutines.flow.collect
 import vn.momo.kits.application.*
 import vn.momo.kits.const.*
 import vn.momo.kits.platform.ProvideNavigationEventDispatcherOwner
@@ -37,6 +38,19 @@ fun NavigationContainer(
     val parentContext = ApplicationContext.current
     val mergedContext = MiniAppContext.merge(parentContext, applicationContext)
 
+    // Default = the host-seeded fontScaleConfig from the merged context, so the first frame is
+    // already scaled (no flash). The observer below overwrites it on later host writes (live rate
+    // changes); a null emit (host cleared) falls back to the ambient LocalFontScaleConfig default.
+    var observerFontScaleConfig by remember { mutableStateOf(mergedContext?.fontScaleConfig) }
+    LaunchedEffect(maxApi) {
+        val api = maxApi ?: return@LaunchedEffect
+        runCatching {
+            api.observer(FONT_SCALE_OBSERVER_KEY).collect { data ->
+                observerFontScaleConfig = parseFontScaleConfig(data)
+            }
+        }
+    }
+
     val theme = remember { mutableStateOf(initialTheme) }
 
     LaunchedEffect(Unit) {
@@ -64,8 +78,7 @@ fun NavigationContainer(
             ApplicationContext provides mergedContext,
             AppConfig provides config,
             AppLanguage provides language,
-            LocalUseDeviceFontScale provides (mergedContext?.useDeviceFontScale ?: true),
-            LocalAppFontScale provides (mergedContext?.appFontScale ?: 1f),
+            LocalFontScaleConfig provides (observerFontScaleConfig ?: LocalFontScaleConfig.current),
         ) {
             LaunchedEffect(Unit) {
                 setNavigator?.invoke(navigator)
@@ -144,3 +157,33 @@ fun NavigationContainer(
 val LocalMaxApi = staticCompositionLocalOf<IMaxApi?> {
     error("No MaxApi provided")
 }
+
+// Observer storage key the host app writes FontScaleConfig to. Lowercased natively.
+private const val FONT_SCALE_OBSERVER_KEY = "font_scale_config"
+
+// Host returns object {useOSFontScale, userScaleRate}; guard against envelope wrapping / type mismatch from marshaling.
+private fun parseFontScaleConfig(raw: Map<String, Any?>?): FontScaleConfig? {
+    if (raw.isNullOrEmpty()) return null
+    @Suppress("UNCHECKED_CAST")
+    val data = (raw["response"] as? Map<String, Any?>)
+        ?: (raw["data"] as? Map<String, Any?>)
+        ?: raw
+    if (!data.containsKey("useOSFontScale") && !data.containsKey("userScaleRate")) return null
+    val useOS = when (val v = data["useOSFontScale"]) {
+        is Boolean -> v
+        is String -> v.equals("true", ignoreCase = true)
+        is Number -> v.toInt() != 0
+        else -> true
+    }
+    val rate = when (val v = data["userScaleRate"]) {
+        is Number -> v.toFloat()
+        is String -> v.toFloatOrNull()
+        else -> null
+    }
+    val osScale = when (val v = data["osFontScale"]) {
+        is Number -> v.toFloat()
+        is String -> v.toFloatOrNull()
+        else -> null
+    }
+    return FontScaleConfig(useOSFontScale = useOS, userScaleRate = rate, osFontScale = osScale)
+}

package/gradle.properties

@@ -18,7 +18,7 @@ kotlin.apple.xcodeCompatibility.nowarn=true
 name="ComposeKits"
 group=vn.momo.kits
 artifact.id=kits
-version=0.162.2-test.1
+version=0.162.2-test.10
 
 repo=GitLab
 url=https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven

package/ios/Application/ApplicationEnvironment.swift

@@ -46,5 +46,7 @@ public class ApplicationEnvironment: ObservableObject {
         self.applicationContext = applicationContext
         self.composeApi = composeApi
         self.config = config
+        // Load + observe the host font-scale config into the global store read by scaleSize/appFont.
+        FontScaleStore.shared.bind(composeApi)
     }
 }

package/ios/Application/FontScaleStore.swift

@@ -0,0 +1,77 @@
+//
+//  FontScaleStore.swift
+//  Momo Design System (SwiftUI)
+//
+//  Global font-scale config read by scaleSize/appFont. SwiftUI counterpart of the
+//  Compose LocalFontScaleConfig and the RN ScaleSizeContext. Populated from the host's
+//  `font_scale_config` observer-storage key via the KitComposeApi bridge.
+//
+
+import SwiftUI
+
+public struct FontScaleConfig {
+    public var useOSFontScale: Bool
+    public var userScaleRate: CGFloat?
+
+    public init(useOSFontScale: Bool = true, userScaleRate: CGFloat? = nil) {
+        self.useOSFontScale = useOSFontScale
+        self.userScaleRate = userScaleRate
+    }
+}
+
+/// Single source of truth for the font scale. `scaleSize`/`appFont` read `shared.config`.
+/// Views that want live updates observe this object (e.g. MomoText).
+public final class FontScaleStore: ObservableObject {
+    public static let shared = FontScaleStore()
+
+    @Published public private(set) var config = FontScaleConfig()
+
+    private var didBind = false
+    private var observerId: String?
+
+    private init() {}
+
+    public func update(_ newConfig: FontScaleConfig) {
+        if Thread.isMainThread {
+            config = newConfig
+        } else {
+            DispatchQueue.main.async { [weak self] in self?.config = newConfig }
+        }
+    }
+
+    /// Load the current config + subscribe to live changes through the host MaxApi bridge.
+    /// Safe no-op when no bridge is provided (config stays at default = no scaling).
+    public func bind(_ api: KitComposeApi?) {
+        guard let api = api, !didBind else { return }
+        didBind = true
+
+        // Synchronous snapshot — flash-free first frame. The compose bridge runs the platform API
+        // synchronously (getFontScaleConfig's storage flow is take(1), so it completes inline and
+        // returns the current value before the first render reads scaleSize/appFont).
+        apply(api.request(funcName: "getFontScaleConfig", params: nil))
+        // live: re-read on every host write to the key
+        observerId = api.request(funcName: "observer", params: ["font_scale_config"]) { [weak self] response in
+            self?.apply(response)
+        }
+    }
+
+    private func apply(_ response: String) {
+        guard let parsed = FontScaleStore.parse(response) else { return }
+        update(parsed)
+    }
+
+    /// Tolerates the MaxApi envelope {"status":..,"response":{..}} as well as a bare config object.
+    static func parse(_ response: String) -> FontScaleConfig? {
+        guard
+            let data = response.data(using: .utf8),
+            let json = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any]
+        else { return nil }
+
+        let obj = (json["response"] as? [String: Any]) ?? (json["data"] as? [String: Any]) ?? json
+        guard obj["useOSFontScale"] != nil || obj["userScaleRate"] != nil else { return nil }
+
+        let useOS = (obj["useOSFontScale"] as? Bool) ?? true
+        let rate = (obj["userScaleRate"] as? NSNumber).map { CGFloat($0.doubleValue) }
+        return FontScaleConfig(useOSFontScale: useOS, userScaleRate: rate)
+    }
+}

package/ios/Typography/Text.swift

@@ -1,27 +1,36 @@
 import SwiftUI
 
 public func scaleSize(_ size: CGFloat, _ scaleRate: CGFloat? = nil) -> CGFloat {
+    // Single source of truth: useOSFontScale + userScaleRate from the host config.
+    // `scaleRate` param keeps its existing meaning: a hard cap override (default 1.5).
+    let config = FontScaleStore.shared.config
     let defaultScreenSize: CGFloat = 375
     let maxFontScale: CGFloat = scaleRate ?? 1.5
     let maxDeviceScale: CGFloat = 5
 
-    let deviceWidth = UIScreen.main.bounds.width
-    let deviceScale = deviceWidth / defaultScreenSize
+    // useOSFontScale off -> the user has full control via userScaleRate; skip device-width scaling
+    // entirely and apply only the custom rate (capped at maxFontScale). Mirrors Compose / RN.
+    if !config.useOSFontScale {
+        // custom rate is uncapped (full user control); only the OS-follow path below caps at maxFontScale.
+        let customRate = config.userScaleRate ?? 1
+        return customRate > 1 ? size * customRate : size
+    }
+
+    // useOSFontScale on -> device-width scale + OS font scale, take the larger.
+    let deviceScale = UIScreen.main.bounds.width / defaultScreenSize
 
     let defaultFont = UIFont.systemFont(ofSize: UIFont.labelFontSize)
     let scaledFont = UIFontMetrics.default.scaledFont(for: defaultFont)
-    let fontScale = scaledFont.pointSize / defaultFont.pointSize
+    let osFontScale = scaledFont.pointSize / defaultFont.pointSize
 
     var fontSizeDeviceScale = size
     var fontSizeOSScale = size
 
-
     if deviceScale > 1 {
         fontSizeDeviceScale = min(fontSizeDeviceScale * deviceScale, fontSizeDeviceScale + maxDeviceScale)
     }
-
-    if fontScale > 1 {
-        fontSizeOSScale = min(fontSizeOSScale * fontScale, fontSizeOSScale * maxFontScale)
+    if osFontScale > 1 {
+        fontSizeOSScale = min(fontSizeOSScale * osFontScale, fontSizeOSScale * maxFontScale)
     }
 
     return max(fontSizeDeviceScale, fontSizeOSScale)
@@ -118,6 +127,8 @@ public struct MomoText: View {
     private let content: String
     private let typography: TypographyStyle
     private let color: Color
+    // Observe the global store so the text re-renders live when the host changes the config.
+    @ObservedObject private var fontScale = FontScaleStore.shared
 
     public init(
         _ content: String,
@@ -130,6 +141,7 @@ public struct MomoText: View {
     }
 
     public var body: some View {
+        _ = fontScale.config
         let text = SwiftUI.Text(content)
             .font(.system(size: scaleSize(typography.fontSize), weight: typography.fontWeight))
             .foregroundColor(color)

package/ios/Typography/Typography.swift

@@ -2,25 +2,38 @@ import SwiftUI
 
 public extension Font {
     static func appFont(size: CGFloat) -> Font {
+        // Single source of truth: useOSFontScale + userScaleRate from the host config.
+        // NOTE: the static Font.xxx constants below are evaluated once at type load, so they
+        // capture the config at first access. Live updates apply to scaleSize()/MomoText and
+        // any fresh appFont(size:) call, not to the cached static constants.
+        let config = FontScaleStore.shared.config
         let defaultScreenSize: CGFloat = 375
         let maxFontScale: CGFloat = 1.5
         let maxDeviceScale: CGFloat = 5
-        
-        let deviceWidth = UIScreen.main.bounds.width
-        let deviceScale = deviceWidth / defaultScreenSize
-        
+
+        // useOSFontScale off -> the user has full control via userScaleRate; skip device-width
+        // scaling entirely and apply only the custom rate (capped at maxFontScale).
+        if !config.useOSFontScale {
+            // custom rate is uncapped (full user control); only the OS-follow path below caps at maxFontScale.
+            let customRate = config.userScaleRate ?? 1
+            let scaled = customRate > 1 ? size * customRate : size
+            return Font.system(size: scaled)
+        }
+
+        // useOSFontScale on -> device-width scale, then OS font scale on top (existing behavior).
+        let deviceScale = UIScreen.main.bounds.width / defaultScreenSize
+
         let defaultFont = UIFont.systemFont(ofSize: UIFont.labelFontSize)
         let scaledFont = UIFontMetrics.default.scaledFont(for: defaultFont)
-        let fontScale = scaledFont.pointSize / defaultFont.pointSize
+        let osFontScale = scaledFont.pointSize / defaultFont.pointSize
 
         var fontSize = size
 
         if deviceScale > 1 {
             fontSize = min(fontSize * deviceScale, fontSize + maxDeviceScale)
         }
-
-        if fontScale > 1 {
-            fontSize = min(fontSize * fontScale, fontSize * maxFontScale)
+        if osFontScale > 1 {
+            fontSize = min(fontSize * osFontScale, fontSize * maxFontScale)
         }
 
         return Font.system(size: fontSize)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.162.2-test.1-debug",
+  "version": "0.162.2-test.10-debug",
   "private": false,
   "dependencies": {},
   "devDependencies": {},