@momo-kits/native-kits 0.162.2-test.5-debug → 0.162.2-test.6-debug

package/compose/build.gradle.kts

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

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

@@ -112,5 +112,5 @@ data class FontScaleConfig(
     val userScaleRate: Float? = null,
 )
 
-// Single source of truth: chứa cả flag OS lẫn rate user tự chỉnh.
+// 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/const/Typography.kt

@@ -38,10 +38,10 @@ const val MAX_DEVICE_SCALE = 5
 
 @Composable
 fun scaleSize(size: Float, userScaleRate: Float? = null): Float {
-    // single source of truth: useOSFontScale + userScaleRate cùng lấy từ LocalFontScaleConfig
+    // single source of truth: useOSFontScale + userScaleRate both read from LocalFontScaleConfig
     val fontScaleConfig = LocalFontScaleConfig.current
     val useOSFontScale = fontScaleConfig.useOSFontScale
-    // param userScaleRate override config; không có -> config.userScaleRate -> 1f (không scale)
+    // param userScaleRate overrides config; if absent -> config.userScaleRate -> 1f (no scaling)
     val customRate = userScaleRate ?: fontScaleConfig.userScaleRate ?: 1f
 
     val deviceWidth = getScreenDimensions().width
@@ -58,8 +58,8 @@ fun scaleSize(size: Float, userScaleRate: Float? = null): Float {
             min(deviceScale * fontSizeScaleDevice, fontSizeScaleDevice + MAX_DEVICE_SCALE)
     }
 
-    // useOSFontScale bật -> lấy scale của OS đè lên, ignore custom rate của user.
-    // tắt -> dùng custom rate user tự chỉnh. Cap cứng MAX_FONT_SCALE (150%) cả hai.
+    // useOSFontScale on -> apply the OS scale, ignore the user's custom rate.
+    // off -> use the user's custom rate. Both hard-capped at MAX_FONT_SCALE (150%).
     val appliedRate = if (useOSFontScale) fontScale else customRate
     if (appliedRate > 1f) {
         fontSizeScaleOS = min(appliedRate * fontSizeScaleOS, fontSizeScaleOS * MAX_FONT_SCALE)

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

@@ -38,11 +38,11 @@ fun NavigationContainer(
     val parentContext = ApplicationContext.current
     val mergedContext = MiniAppContext.merge(parentContext, applicationContext)
 
-    // FontScaleConfig host ghi xuống observer storage (single source of truth khi có).
+    // FontScaleConfig the host writes to observer storage (single source of truth when present).
     var observerFontScaleConfig by remember { mutableStateOf<FontScaleConfig?>(null) }
     LaunchedEffect(maxApi) {
         val api = maxApi ?: return@LaunchedEffect
-        // getDataObserver = snapshot lúc mount; observer = subscribe các lần host ghi sau đó.
+        // getDataObserver = snapshot at mount; observer = subscribe to later host writes.
         runCatching {
             api.getDataObserver(FONT_SCALE_OBSERVER_KEY) { data ->
                 parseFontScaleConfig(data)?.let { observerFontScaleConfig = it }
@@ -162,10 +162,10 @@ val LocalMaxApi = staticCompositionLocalOf<IMaxApi?> {
     error("No MaxApi provided")
 }
 
-// Key observer storage host app ghi FontScaleConfig. Native lowercase key.
+// Observer storage key the host app writes FontScaleConfig to. Lowercased natively.
 private const val FONT_SCALE_OBSERVER_KEY = "font_scale_config"
 
-// Host trả object {useOSFontScale, userScaleRate}; phòng marshaling bọc envelope / lệch kiểu.
+// 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")

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.5
+version=0.162.2-test.6
 
 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 = false, 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
+
+        // snapshot at mount
+        api.requestCallback(funcName: "getFontScaleConfig", params: nil) { [weak self] response in
+            self?.apply(response)
+        }
+        // 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) ?? false
+        let rate = (obj["userScaleRate"] as? NSNumber).map { CGFloat($0.doubleValue) }
+        return FontScaleConfig(useOSFontScale: useOS, userScaleRate: rate)
+    }
+}

package/ios/Typography/Text.swift

@@ -1,6 +1,9 @@
 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
@@ -10,7 +13,7 @@ public func scaleSize(_ size: CGFloat, _ scaleRate: CGFloat? = nil) -> CGFloat {
 
     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
@@ -20,8 +23,11 @@ public func scaleSize(_ size: CGFloat, _ scaleRate: CGFloat? = nil) -> CGFloat {
         fontSizeDeviceScale = min(fontSizeDeviceScale * deviceScale, fontSizeDeviceScale + maxDeviceScale)
     }
 
-    if fontScale > 1 {
-        fontSizeOSScale = min(fontSizeOSScale * fontScale, fontSizeOSScale * maxFontScale)
+    // useOSFontScale on -> follow OS Dynamic Type; off -> use the user rate (default 1 = no scaling).
+    // Both capped at maxFontScale. Mirrors Compose scaleSize / RN useScaleSize.
+    let appliedRate = config.useOSFontScale ? osFontScale : (config.userScaleRate ?? 1)
+    if appliedRate > 1 {
+        fontSizeOSScale = min(fontSizeOSScale * appliedRate, fontSizeOSScale * maxFontScale)
     }
 
     return max(fontSizeDeviceScale, fontSizeOSScale)
@@ -118,6 +124,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 +138,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,16 +2,21 @@ 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
-        
+
         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
 
@@ -19,8 +24,9 @@ public extension Font {
             fontSize = min(fontSize * deviceScale, fontSize + maxDeviceScale)
         }
 
-        if fontScale > 1 {
-            fontSize = min(fontSize * fontScale, fontSize * maxFontScale)
+        let appliedRate = config.useOSFontScale ? osFontScale : (config.userScaleRate ?? 1)
+        if appliedRate > 1 {
+            fontSize = min(fontSize * appliedRate, fontSize * maxFontScale)
         }
 
         return Font.system(size: fontSize)

package/package.json

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