@momo-kits/native-kits 0.162.3-fontscale.3-debug → 0.162.3-fontscale.4-debug

package/compose/build.gradle.kts

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

package/compose/src/androidMain/kotlin/vn/momo/kits/platform/OsFontScale.android.kt

@@ -0,0 +1,7 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+
+// Android's LocalDensity.fontScale already tracks Configuration.fontScale live.
+@Composable
+actual fun ProvideOsFontScale(content: @Composable () -> Unit) = content()

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

@@ -7,6 +7,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.Dp
 import vn.momo.kits.const.*
 import vn.momo.kits.modifier.DeprecatedModifier
+import vn.momo.kits.platform.ProvideOsFontScale
 import vn.momo.kits.platform.getStatusBarHeight
 
 @Deprecated("Use IMaxApi instead", ReplaceWith("IMaxApi"))
@@ -93,6 +94,7 @@ fun ApplicationContainer(
 
     val appStatusBarHeight = statusBarHeight ?: getStatusBarHeight()
 
+    ProvideOsFontScale {
     CompositionLocalProvider(
         AppTheme provides appTheme,
         PlatformApi provides composeApi,
@@ -103,5 +105,6 @@ fun ApplicationContainer(
             content()
         }
     }
+    }
 
 }

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

@@ -0,0 +1,22 @@
+package vn.momo.kits.const
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+
+// App-wide font-scale holder. The kit is sandboxed and can't read the host cache directly, so the
+// host (which sees both core and this kit) seeds this once at startup and pushes runtime updates into
+// it. scaleSize() reads it as the fallback, so every screen — including direct NavigationContainer
+// screens with no host-pushed MiniAppContext — scales with no per-render prop and no async flicker.
+// Backed by snapshot state: writes recompose text automatically.
+object KitFontScale {
+    var userScaleRate by mutableStateOf(1f)
+        private set
+    var useOSScaleRate by mutableStateOf(true)
+        private set
+
+    fun update(userScaleRate: Float, useOSScaleRate: Boolean) {
+        this.userScaleRate = userScaleRate
+        this.useOSScaleRate = useOSScaleRate
+    }
+}

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

@@ -24,8 +24,10 @@ const val MAX_DEVICE_SCALE = 5
 @Composable
 fun scaleSize(size: Float): Float {
     val context = LocalContext.current
-    if (context?.useOSScaleRate == false) {
-        return size * (context.userScaleRate ?: 1f)
+    // Host-pushed context wins; otherwise fall back to the app-wide KitFontScale holder.
+    val useOsScale = context?.useOSScaleRate ?: KitFontScale.useOSScaleRate
+    if (!useOsScale) {
+        return size * (context?.userScaleRate ?: KitFontScale.userScaleRate)
     }
     val scaleSizeMaxRate: Float = MAX_FONT_SCALE
     val deviceWidth = getScreenDimensions().width

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

@@ -12,6 +12,7 @@ import androidx.navigation.toRoute
 import vn.momo.kits.application.*
 import vn.momo.kits.const.*
 import vn.momo.kits.platform.ProvideNavigationEventDispatcherOwner
+import vn.momo.kits.platform.ProvideOsFontScale
 import vn.momo.kits.utils.getAppStatusBarHeight
 import vn.momo.kits.utils.getNavigationBarHeight
 import vn.momo.maxapi.IMaxApi
@@ -57,6 +58,7 @@ fun NavigationContainer(
     registry.bind(screenId, initialScreenName, initialScreen, options)
     val startDestination = remember(screenId) { DynamicScreenRoute(screenId) }
 
+    ProvideOsFontScale {
     ProvideNavigationEventDispatcherOwner {
         CompositionLocalProvider(
             LocalNavigator provides navigator,
@@ -133,6 +135,7 @@ fun NavigationContainer(
             }
         }
     }
+    }
 
     DisposableEffect(Unit) {
         onDispose {

package/compose/src/commonMain/kotlin/vn/momo/kits/platform/OsFontScale.kt

@@ -0,0 +1,9 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+
+// Overrides LocalDensity.fontScale with the live OS Dynamic Type scale so text re-scales while a
+// screen is visible. Wrapped inside the containers so every screen is covered, not just callers of
+// the app-level wrappers.
+@Composable
+expect fun ProvideOsFontScale(content: @Composable () -> Unit)

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

@@ -0,0 +1,66 @@
+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/gradle.properties

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

package/ios/Typography/FontScaleStore.swift

@@ -1,17 +1,16 @@
-import Combine
 import CoreGraphics
 
-/// App-wide font-scale preference for the SwiftUI kit. Populated by the host container
-/// (`KitContainer`), which reads `FontScaleProvider.configFlow` — the cache-backed source, same
-/// as RN/Compose. `scaleSize`/`appFont` read the snapshot; `MomoText` observes it for live redraw.
-/// When `useOSScaleRate` is false the kit applies `userScaleRate` instead of the OS Dynamic Type
-/// factor. `update` must be called on the main thread.
-public final class FontScaleStore: ObservableObject {
+/// App-wide font-scale preference for the SwiftUI kit. An exported holder the host writes once at
+/// app startup (from the cache-backed `FontScaleProvider`); `scaleSize`/`appFont` read the snapshot.
+/// No realtime: the SwiftUI kit has no navigation container to scope reactive updates, so a startup
+/// snapshot is enough. When `useOSScaleRate` is false the kit applies `userScaleRate` instead of the
+/// OS Dynamic Type factor.
+public final class FontScaleStore {
     public static let shared = FontScaleStore()
     private init() {}
 
-    @Published public private(set) var userScaleRate: CGFloat = 1
-    @Published public private(set) var useOSScaleRate: Bool = true
+    public private(set) var userScaleRate: CGFloat = 1
+    public private(set) var useOSScaleRate: Bool = true
 
     public func update(userScaleRate: CGFloat, useOSScaleRate: Bool) {
         self.userScaleRate = userScaleRate

package/ios/Typography/Text.swift

@@ -118,7 +118,6 @@ public extension TypographyStyle {
 }
 
 public struct MomoText: View {
-    @ObservedObject private var fontScale = FontScaleStore.shared
     private let content: String
     private let typography: TypographyStyle
     private let color: Color

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.162.3-fontscale.3-debug",
+  "version": "0.162.3-fontscale.4-debug",
   "private": false,
   "dependencies": {},
   "devDependencies": {},