@momo-kits/native-kits 0.162.13-debug → 0.162.14-debug

package/compose/build.gradle.kts

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

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

@@ -28,7 +28,7 @@ data class MiniAppContext(
     val providerId: String = "",
     val permissions: List<Map<String, Any>>? = emptyList(),
     val features: FeatureFlags? = null,
-    val fontScaleConfig: FontScaleConfig? = null,
+    val scaleSizeMaxRate: Float? = null,
 ) {
     companion object {
 
@@ -60,7 +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),
-                fontScaleConfig = parent.fontScaleConfig ?: child.fontScaleConfig,
+                scaleSizeMaxRate = parent.scaleSizeMaxRate ?: child.scaleSizeMaxRate,
             )
         }
 
@@ -98,11 +98,4 @@ val LocalComponentInformation = staticCompositionLocalOf<ComponentInformation?>
     null
 }
 
-@Immutable
-data class FontScaleConfig(
-    val useOSFontScale: Boolean = true,
-    val userScaleRate: Float? = null,
-    val osFontScale: Float? = null,
-)
-
-val LocalFontScaleConfig = staticCompositionLocalOf { FontScaleConfig() }
+val ScaleSizeMaxRate = staticCompositionLocalOf<Float?> { null }

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

@@ -0,0 +1,17 @@
+package vn.momo.kits.components
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import vn.momo.kits.application.ScaleSizeMaxRate
+
+@Composable
+fun ScaleSizeScope(
+    scaleSizeMaxRate: Float? = null,
+    content: @Composable () -> Unit
+) {
+    CompositionLocalProvider(
+        ScaleSizeMaxRate provides scaleSizeMaxRate,
+    ) {
+        content()
+    }
+}

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

@@ -36,7 +36,6 @@ fun Text(
     softWrap: Boolean = true,
     accessibilityId: String? = null,
     inlineContent: Map<String, InlineTextContent> = mapOf(),
-    userScaleRate: Float? = null,
     ) {
     Text(
         text = AnnotatedString(text),
@@ -53,8 +52,7 @@ fun Text(
         letterSpacing = letterSpacing,
         softWrap = softWrap,
         accessibilityId = accessibilityId,
-        inlineContent = inlineContent,
-        userScaleRate = userScaleRate
+        inlineContent = inlineContent
     )
 }
 
@@ -76,14 +74,13 @@ 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, userScaleRate)
-    val scaledLineHeight = scaleSize(style.lineHeight, userScaleRate)
+    val scaledFontSize = scaleSize(style.fontSize)
+    val scaledLineHeight = scaleSize(style.lineHeight)
     val fontFamilyResult = getFontFamily(fontFamily ?: theme.font, style.fontWeight)
 
     // Now memoize the results

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

@@ -11,7 +11,7 @@ import androidx.compose.ui.unit.*
 import org.jetbrains.compose.resources.Font
 import org.jetbrains.compose.resources.FontResource
 import org.jetbrains.compose.resources.InternalResourceApi
-import vn.momo.kits.application.LocalFontScaleConfig
+import vn.momo.kits.application.ScaleSizeMaxRate
 import vn.momo.kits.platform.getScreenDimensions
 import vn.momo.uikits.resources.*
 import kotlin.math.max
@@ -22,58 +22,59 @@ const val MAX_FONT_SCALE = 1.5f
 const val MAX_DEVICE_SCALE = 5
 
 @Composable
-fun scaleSize(size: Float, userScaleRate: Float? = null): Float {
-    val fontScaleConfig = LocalFontScaleConfig.current
-    val useOSFontScale = fontScaleConfig.useOSFontScale
-    val customRate = userScaleRate ?: fontScaleConfig.userScaleRate ?: 1f
+fun scaleSize(size: Float): Float {
+    val scaleSizeMaxRate: Float = ScaleSizeMaxRate.current ?: MAX_FONT_SCALE
+    val deviceWidth = getScreenDimensions().width
+    val deviceScale = deviceWidth / DEFAULT_SCREEN_SIZE
 
-    val deviceScale = getScreenDimensions().width / DEFAULT_SCREEN_SIZE
-    val fontScale = fontScaleConfig.osFontScale ?: LocalDensity.current.fontScale
-
-    if (!useOSFontScale) {
-        return if (customRate > 1f) customRate * size else size
-    }
+    val density = LocalDensity.current
+    val fontScale = density.fontScale
 
     var fontSizeScaleDevice = size
     var fontSizeScaleOS = size
+
     if (deviceScale > 1) {
         fontSizeScaleDevice =
             min(deviceScale * fontSizeScaleDevice, fontSizeScaleDevice + MAX_DEVICE_SCALE)
     }
-    if (fontScale > 1f) {
-        fontSizeScaleOS = min(fontScale * fontSizeScaleOS, fontSizeScaleOS * MAX_FONT_SCALE)
+
+    if (fontScale > 1) {
+        fontSizeScaleOS = min(fontScale * fontSizeScaleOS, fontSizeScaleOS * scaleSizeMaxRate)
     }
 
-    return max(fontSizeScaleDevice, fontSizeScaleOS)
+    return max(
+        fontSizeScaleDevice,
+        fontSizeScaleOS
+    )
 }
 
 @Composable
-fun scaleSize(size: TextUnit, userScaleRate: Float? = null): TextUnit {
+fun scaleSize(size: TextUnit): TextUnit {
     if (!size.isSp) return size
 
     val density = LocalDensity.current
 
-    val scaled = scaleSize(size.value, userScaleRate)
+    val scaled = scaleSize(size.value)
     val spValue = scaled / density.fontScale
 
     return TextUnit(value = spValue, type = TextUnitType.Sp)
 }
 
 @Composable
-fun scaleSize(size: Dp, userScaleRate: Float? = null): Dp {
-    return scaleSize(size.value, userScaleRate).dp
+fun scaleSize(size: Dp): Dp {
+    return scaleSize(size.value).dp
 }
 
 @Composable
-fun scaleSize(textStyle: TextStyle, userScaleRate: Float? = null): TextStyle {
+fun scaleSize(textStyle: TextStyle): TextStyle {
     return textStyle.copy(
         fontSize = if (textStyle.fontSize != TextUnit.Unspecified)
-            scaleSize(textStyle.fontSize, userScaleRate)
+            scaleSize(textStyle.fontSize)
         else
             TextUnit.Unspecified,
 
         lineHeight = if (textStyle.lineHeight != TextUnit.Unspecified)
-            scaleSize(textStyle.lineHeight, userScaleRate)
+            scaleSize(textStyle.lineHeight)
         else
             TextUnit.Unspecified,
     )

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

@@ -42,7 +42,6 @@ fun NavigationContainer(
 
     val resolvedLocalize = localize ?: fallbackLocalize
 
-    var observerFontScaleConfig by remember { mutableStateOf(mergedContext?.fontScaleConfig) }
     LaunchedEffect(maxApi, resolvedLocalize) {
         val api = maxApi ?: return@LaunchedEffect
         runCatching {
@@ -51,9 +50,6 @@ fun NavigationContainer(
                     resolvedLocalize.changeLanguage(Localize.EN)
                 }
             })
-            api.observer(FONT_SCALE_OBSERVER_KEY).collect { data ->
-                observerFontScaleConfig = parseFontScaleConfig(data)
-            }
         }
     }
 
@@ -71,7 +67,6 @@ fun NavigationContainer(
             AppNavigationBar provides navigationBarHeight,
             LocalContext provides mergedContext,
             LocalLocalize provides resolvedLocalize,
-            LocalFontScaleConfig provides (observerFontScaleConfig ?: LocalFontScaleConfig.current),
             ) {
             LaunchedEffect(Unit) {
                 setNavigator?.invoke(navigator)
@@ -151,36 +146,9 @@ val LocalMaxApi = staticCompositionLocalOf<IMaxApi?> {
     error("No MaxApi provided")
 }
 
-private const val FONT_SCALE_OBSERVER_KEY = "font_scale_config"
-
 private fun parseLanguage(raw: Map<String, Any?>?): String? {
     val code = (raw?.get("response") as? String)?.trim()?.lowercase()
     if (code.isNullOrEmpty()) return null
     return if (code.startsWith(Localize.EN)) Localize.EN else Localize.VI
 }
 
-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.13
+version=0.162.14
 
 repo=GitLab
 url=https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven

package/ios/Application/ApplicationEnvironment.swift

@@ -46,6 +46,5 @@ public class ApplicationEnvironment: ObservableObject {
         self.applicationContext = applicationContext
         self.composeApi = composeApi
         self.config = config
-        FontScaleStore.shared.bind(composeApi)
     }
 }

package/ios/Typography/Text.swift

@@ -1,30 +1,27 @@
 import SwiftUI
 
 public func scaleSize(_ size: CGFloat, _ scaleRate: CGFloat? = nil) -> CGFloat {
-    let config = FontScaleStore.shared.config
     let defaultScreenSize: CGFloat = 375
     let maxFontScale: CGFloat = scaleRate ?? 1.5
     let maxDeviceScale: CGFloat = 5
 
-    if !config.useOSFontScale {
-        let customRate = config.userScaleRate ?? 1
-        return customRate > 1 ? size * customRate : size
-    }
-
-    let deviceScale = UIScreen.main.bounds.width / defaultScreenSize
+    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 osFontScale = scaledFont.pointSize / defaultFont.pointSize
+    let fontScale = scaledFont.pointSize / defaultFont.pointSize
 
     var fontSizeDeviceScale = size
     var fontSizeOSScale = size
 
+
     if deviceScale > 1 {
         fontSizeDeviceScale = min(fontSizeDeviceScale * deviceScale, fontSizeDeviceScale + maxDeviceScale)
     }
-    if osFontScale > 1 {
-        fontSizeOSScale = min(fontSizeOSScale * osFontScale, fontSizeOSScale * maxFontScale)
+
+    if fontScale > 1 {
+        fontSizeOSScale = min(fontSizeOSScale * fontScale, fontSizeOSScale * maxFontScale)
     }
 
     return max(fontSizeDeviceScale, fontSizeOSScale)
@@ -121,7 +118,6 @@ public struct MomoText: View {
     private let content: String
     private let typography: TypographyStyle
     private let color: Color
-    @ObservedObject private var fontScale = FontScaleStore.shared
 
     public init(
         _ content: String,
@@ -134,7 +130,6 @@ 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

@@ -11,35 +11,30 @@ public extension View {
 
 public extension Font {
     static func appFont(size: CGFloat) -> Font {
-        let config = FontScaleStore.shared.config
         let defaultScreenSize: CGFloat = 375
         let maxFontScale: CGFloat = 1.5
         let maxDeviceScale: CGFloat = 5
 
-        if !config.useOSFontScale {
-            let customRate = config.userScaleRate ?? 1
-            let scaled = customRate > 1 ? size * customRate : size
-            return Font.system(size: scaled)
-        }
-
-        let deviceScale = UIScreen.main.bounds.width / defaultScreenSize
+        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 osFontScale = scaledFont.pointSize / defaultFont.pointSize
+        let fontScale = scaledFont.pointSize / defaultFont.pointSize
 
         var fontSize = size
 
         if deviceScale > 1 {
             fontSize = min(fontSize * deviceScale, fontSize + maxDeviceScale)
         }
-        if osFontScale > 1 {
-            fontSize = min(fontSize * osFontScale, fontSize * maxFontScale)
+
+        if fontScale > 1 {
+            fontSize = min(fontSize * fontScale, fontSize * maxFontScale)
         }
 
         return Font.system(size: fontSize)
     }
-    
+
     // New supported typography styles
     static let headline_default_bold = appFont(size: 24).weight(.bold)
     static let header_m_bold = appFont(size: 18).weight(.bold)
@@ -57,7 +52,7 @@ public extension Font {
     static let action_s_bold = appFont(size: 14).weight(.bold)
     static let action_xs_bold = appFont(size: 12).weight(.bold)
     static let action_xxs_bold = appFont(size: 10).weight(.bold)
-    
+
     // Legacy styles
     static let headline_default = appFont(size: 28).weight(.semibold)
     static let headline_s = appFont(size: 24).weight(.semibold)
@@ -82,7 +77,7 @@ public extension Font {
     static let action_xxs = appFont(size: 10).weight(.bold)
     static let action_xs = appFont(size: 12).weight(.bold)
     static let action_s = appFont(size: 15).weight(.bold)
-    
+
     // deprecated
     static let h1 = appFont(size: 36).weight(.semibold) //headline_xl
     static let h2 = appFont(size: 32).weight(.semibold)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.162.13-debug",
+  "version": "0.162.14-debug",
   "private": false,
   "dependencies": {},
   "devDependencies": {},

package/ios/Application/FontScaleStore.swift

@@ -1,59 +0,0 @@
-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
-    }
-}
-
-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 }
-        }
-    }
-
-    public func bind(_ api: KitComposeApi?) {
-        guard let api = api, !didBind else { return }
-        didBind = true
-
-        apply(api.request(funcName: "getFontScaleConfig", params: nil))
-        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)
-    }
-
-    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)
-    }
-}