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

package/compose/compose.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |spec|
     spec.name                     = 'compose'
-    spec.version                  = '0.161.0-debug'
+    spec.version                  = '0.161.2-beta.15'
     spec.homepage                 = 'https://momo.vn'
     spec.source                   = { :http=> ''}
     spec.authors                  = ''

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

@@ -28,9 +28,8 @@ data class MiniAppContext(
     val providerId: String = "",
     val permissions: List<Map<String, Any>>? = emptyList(),
     val features: FeatureFlags? = null,
-    val scaleSizeMaxRate: Float? = null,
-    val followOSScale: Boolean? = null,
-    val fontSizeRatio: Float? = null,
+    val useDeviceFontScale: Boolean? = null,
+    val appFontScale: Float? = null,
 ) {
     companion object {
 
@@ -62,9 +61,8 @@ 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),
-                scaleSizeMaxRate = parent.scaleSizeMaxRate ?: child.scaleSizeMaxRate,
-                followOSScale = parent.followOSScale ?: child.followOSScale,
-                fontSizeRatio = parent.fontSizeRatio ?: child.fontSizeRatio,
+                useDeviceFontScale = parent.useDeviceFontScale ?: child.useDeviceFontScale,
+                appFontScale = parent.appFontScale ?: child.appFontScale,
             )
         }
 
@@ -110,8 +108,6 @@ val LocalComponentInformation = staticCompositionLocalOf<ComponentInformation?>
     null
 }
 
-val ScaleSizeMaxRate = staticCompositionLocalOf<Float?> { null }
+val LocalUseDeviceFontScale = staticCompositionLocalOf<Boolean> { true }
 
-val FollowOSScale = staticCompositionLocalOf<Boolean?> { null }
-
-val FontSizeRatio = staticCompositionLocalOf<Float?> { null }
+val LocalAppFontScale = staticCompositionLocalOf<Float> { 1f }

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

@@ -15,9 +15,8 @@ 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.FollowOSScale
-import vn.momo.kits.application.FontSizeRatio
-import vn.momo.kits.application.ScaleSizeMaxRate
+import vn.momo.kits.application.LocalAppFontScale
+import vn.momo.kits.application.LocalUseDeviceFontScale
 import vn.momo.kits.platform.getScreenDimensions
 import vn.momo.uikits.resources.Res
 import vn.momo.uikits.resources.momosignature
@@ -40,9 +39,8 @@ const val MAX_DEVICE_SCALE = 5
 
 @Composable
 fun scaleSize(size: Float): Float {
-    val scaleSizeMaxRate: Float = ScaleSizeMaxRate.current ?: MAX_FONT_SCALE
-    val followOSScale: Boolean = FollowOSScale.current ?: false
-    val fontSizeRatio: Float = FontSizeRatio.current ?: 1f
+    val useDeviceFontScale = LocalUseDeviceFontScale.current
+    val appFontScale = LocalAppFontScale.current
     val deviceWidth = getScreenDimensions().width
     val deviceScale = deviceWidth / DEFAULT_SCREEN_SIZE
 
@@ -50,26 +48,24 @@ fun scaleSize(size: Float): Float {
     val fontScale = density.fontScale
 
     var fontSizeScaleDevice = size
-    var fontSizeScaleUser = size
+    var fontSizeScaleOS = size
 
     if (deviceScale > 1) {
         fontSizeScaleDevice =
             min(deviceScale * fontSizeScaleDevice, fontSizeScaleDevice + MAX_DEVICE_SCALE)
     }
 
-    if (followOSScale) {
-        // Follow OS font scale (capped). User ratio is ignored in this mode.
+    if (useDeviceFontScale) {
         if (fontScale > 1) {
-            fontSizeScaleUser = min(fontScale * fontSizeScaleUser, fontSizeScaleUser * scaleSizeMaxRate)
+            fontSizeScaleOS = min(fontScale * fontSizeScaleOS, fontSizeScaleOS * MAX_FONT_SCALE)
         }
-    } else if (fontSizeRatio > 1) {
-        // Custom in-app ratio. OS font scale is ignored.
-        fontSizeScaleUser = fontSizeScaleUser * fontSizeRatio
+    } else {
+        fontSizeScaleOS = size * appFontScale
     }
 
     return max(
         fontSizeScaleDevice,
-        fontSizeScaleUser
+        fontSizeScaleOS
     )
 }
 

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

@@ -64,9 +64,8 @@ fun NavigationContainer(
             ApplicationContext provides mergedContext,
             AppConfig provides config,
             AppLanguage provides language,
-            ScaleSizeMaxRate provides mergedContext?.scaleSizeMaxRate,
-            FollowOSScale provides mergedContext?.followOSScale,
-            FontSizeRatio provides mergedContext?.fontSizeRatio,
+            LocalUseDeviceFontScale provides (mergedContext?.useDeviceFontScale ?: true),
+            LocalAppFontScale provides (mergedContext?.appFontScale ?: 1f),
         ) {
             LaunchedEffect(Unit) {
                 setNavigator?.invoke(navigator)

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-beta.1
+version=0.162.2-test.1
 
 repo=GitLab
 url=https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven

package/ios/Typography/Text.swift

@@ -8,30 +8,23 @@ public func scaleSize(_ size: CGFloat, _ scaleRate: CGFloat? = nil) -> CGFloat {
     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
+
     var fontSizeDeviceScale = size
-    var fontSizeUserScale = size
+    var fontSizeOSScale = size
+
 
     if deviceScale > 1 {
         fontSizeDeviceScale = min(fontSizeDeviceScale * deviceScale, fontSizeDeviceScale + maxDeviceScale)
     }
 
-    if MomoFontScale.shared.followOSScale {
-        // Follow OS font scale (capped). User ratio is ignored in this mode.
-        let defaultFont = UIFont.systemFont(ofSize: UIFont.labelFontSize)
-        let scaledFont = UIFontMetrics.default.scaledFont(for: defaultFont)
-        let fontScale = scaledFont.pointSize / defaultFont.pointSize
-        if fontScale > 1 {
-            fontSizeUserScale = min(fontSizeUserScale * fontScale, fontSizeUserScale * maxFontScale)
-        }
-    } else {
-        // Custom in-app ratio. OS font scale is ignored.
-        let ratio = MomoFontScale.shared.ratio
-        if ratio > 1 {
-            fontSizeUserScale = fontSizeUserScale * ratio
-        }
+    if fontScale > 1 {
+        fontSizeOSScale = min(fontSizeOSScale * fontScale, fontSizeOSScale * maxFontScale)
     }
 
-    return max(fontSizeDeviceScale, fontSizeUserScale)
+    return max(fontSizeDeviceScale, fontSizeOSScale)
 }
 
 public enum TypographyStyle {
@@ -125,9 +118,6 @@ public struct MomoText: View {
     private let content: String
     private let typography: TypographyStyle
     private let color: Color
-    // Observe so the text re-renders immediately when the user changes the
-    // font-size setting (live update, no app restart).
-    @ObservedObject private var fontScale = MomoFontScale.shared
 
     public init(
         _ content: String,

package/ios/Typography/Typography.swift

@@ -1,13 +1,29 @@
 import SwiftUI
 
 public extension Font {
-    // Shares the same scaling logic as `scaleSize` so it honors the user's
-    // font-size preference (follow-OS vs in-app ratio).
-    // NOTE: the `static let` constants below are evaluated once on first
-    // access, so they reflect the setting at launch but do not live-update.
-    // Components that need live updates should use `MomoText` / `scaleSize`.
     static func appFont(size: CGFloat) -> Font {
-        return Font.system(size: scaleSize(size))
+        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
+
+        var fontSize = size
+
+        if deviceScale > 1 {
+            fontSize = min(fontSize * deviceScale, fontSize + maxDeviceScale)
+        }
+
+        if fontScale > 1 {
+            fontSize = min(fontSize * fontScale, fontSize * maxFontScale)
+        }
+
+        return Font.system(size: fontSize)
     }
     
     // New supported typography styles

package/package.json

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

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

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

package/ios/Typography/MomoFontScale.swift

@@ -1,36 +0,0 @@
-import SwiftUI
-
-/// Process-wide holder for the user's in-app font-size preference.
-///
-/// `momo-native-kits` is a UI library; it does not read persistent storage
-/// itself. The host app (momo-app) reads the persisted setting from the shared
-/// Observable Storage and pushes it here at launch and on every change via
-/// `update(followOSScale:ratio:)`. All native typography (`scaleSize`,
-/// `Font.appFont`, `MomoText`) reads from this single source so the three
-/// render stacks (RN / Compose / SwiftUI) stay in sync.
-///
-/// Live update: `MomoText` observes this object, so changing the setting
-/// re-renders typed text immediately. Views built from the `Font.appFont`
-/// static constants pick up the value at launch (static `let` is evaluated
-/// once); making those live would require turning them into functions.
-public final class MomoFontScale: ObservableObject {
-    public static let shared = MomoFontScale()
-
-    /// When true, follow the OS font scale (capped). `ratio` is ignored.
-    @Published public private(set) var followOSScale: Bool = false
-
-    /// In-app font-size ratio (e.g. 1.0 / 1.1 / 1.2). Ignored when
-    /// `followOSScale` is true.
-    @Published public private(set) var ratio: CGFloat = 1
-
-    private init() {}
-
-    public func update(followOSScale: Bool, ratio: CGFloat) {
-        if self.followOSScale != followOSScale {
-            self.followOSScale = followOSScale
-        }
-        if self.ratio != ratio {
-            self.ratio = ratio
-        }
-    }
-}