@momo-kits/native-kits 0.168.1-beta.5-debug → 0.168.1-beta.6-debug

package/CLAUDE.md

@@ -48,7 +48,9 @@ Publishing is automated (`publish.sh` + GitLab CI on `[ci build]` / `main`). Do
 
 - **Entry point:** wrap content in `NavigationContainer(...)` from `navigation/`. It builds the `Navigator`, takes a host-supplied `Localize` (falls back to an empty one), and provides the CompositionLocals below. The legacy `Screen` / `ApplicationContainer` / `ComposeApi` stack has been removed on both sides — don't reintroduce it.
 - **Configuration flows via CompositionLocals**, not params. Public ones: `AppTheme`, `AppStatusBar`, `AppNavigationBar` (`const/Theme.kt`); `ApplicationContext`, `AppConfig`, `AppLanguage`, `LocalLocalize` (`application/`); `LocalNavigator`, `LocalMaxApi` (`navigation/`). Read with `X.current`.
-- **Design-system config** (`trustBanner`, `headerBar`, `headerGradient`): the host seeds `KitDesignSystemConfig.update(...)` once (same pattern as `KitFontScale`); `NavigationContainer` provides it as `LocalDesignSystemConfig` (param `designSystemConfig` → parent → global) and applies `headerBar` as the header image when the theme has none.
+- **`DesignSystemKits`** (`application/DesignSystemKits.kt`) is the single app-wide holder for the host-owned design-system inputs: font scale (`userScaleRate` / `useOSScaleRate`), whitelist (`isWhiteList`) and the remote `DesignSystemConfig`, bundled as `DesignSystemKitsConfigs`. The host calls `DesignSystemKits.init(source)` once at startup with its `DesignSystemKitsSource` (sync `getConfigs()` seed + `configsFlow`); `init` is idempotent. Without a source, call `setConfigs(...)` directly. Read with `getConfigs()` (snapshot state, recomposes); non-Compose observers use `configsFlow`.
+- **SwiftUI twin:** `ios/Application/DesignSystemKits.swift` mirrors it field for field (`DesignSystemKitsConfigs` with `designSystemConfig: KitConfig?`, `setConfigs` / `getConfigs`), plus the OS Dynamic Type factor (`osFontScale`). There is no `init(source:)` (Swift reserves `init`): the host observes its own bridge and pushes. A host that can't share Swift types (the KMP bridge) calls `DesignSystemKits.shared.setConfigs(json:)` (`ios/Application/DesignSystemKitsPayload.swift`); the JSON field names are a contract with momo-app's serializer (`HostDesignSystemKits.observeConfigsJson`, payload classes in `DesignSystemData.kt`) — change both together. Invalid JSON is ignored. The SwiftUI kit can't link the Kotlin `kits` framework (a second Kotlin/Native runtime would hold a second, never-initialized singleton), so the render-time logic — `FontScale` formula, Dynamic Type observation — is intentionally duplicated in Swift; only values flow across.
+- **Design-system config** (`trustBanner`, `headerBar`, `headerGradient`): `NavigationContainer` provides it as `LocalDesignSystemConfig` (param `designSystemConfig` → parent → `DesignSystemKits`) and applies `headerBar` as the header image when the theme has none.
 - **Platform code** goes through `expect`/`actual` in `platform/` — never reference Android/iOS APIs from `commonMain` directly.
 - **Native bridge:** `IMaxApi` (`vn.momo.maxapi`, exposed as `LocalMaxApi`) is the host-app bridge (dismiss, tracking, device info, language).
 - Navigation uses a runtime `DynamicScreenRegistry`; overlays (modal/bottom-sheet/snackbar) go through `Navigator` + `OverplayComponentRegistry`.
@@ -104,9 +106,9 @@ The SwiftUI port differs from Compose in one important way: **it follows the hos
 
 One formula, both platforms: the device-width scale (`width / 375`, capped at `+5pt`) and the OS Dynamic Type scale (capped at `1.5×`) are computed independently and the **larger wins**. When `useOSScaleRate` is false neither applies — the size is just multiplied by `userScaleRate`. Max font scale is fixed at 1.5; the old per-call/per-scope override is deprecated and ignored on both sides.
 
-- **Compose** — `const/Typography.kt` (`scaleSize` overloads for `Float`/`Dp`/`TextUnit`/`TextStyle`). The `TextUnit` overload divides by `density.fontScale` so Compose's own `sp` scaling isn't applied twice. Inputs: `LocalContext.current` (`MiniAppContext.userScaleRate` / `useOSScaleRate`, per-field) falling back to the `KitFontScale` global. On iOS, `platform/OsFontScale.ios.kt` observes `UIContentSizeCategoryDidChangeNotification` and overrides `LocalDensity` — Compose MP otherwise reads `fontScale` once at `ComposeUIViewController` creation. Wired at `NavigationContainer`.
-- **SwiftUI** — `ios/Typography/FontScale.swift`. `FontScale` is an immutable snapshot with `callAsFunction`, so a view reads `@Environment(\.momoFontScale) private var fontScale` and calls `fontScale(16)`. `FontScaleStore.shared` is the `ObservableObject` holding both inputs and the OS factor (it observes `UIContentSizeCategory.didChangeNotification`); the host pushes its preference with `update(userScaleRate:useOSScaleRate:)`.
-- **Never set `\.momoFontScale` directly** — same trap as `\.localize`. Inject via `.momoFontScale(_:context:)`, which holds the store as `@ObservedObject`; that is what re-publishes the snapshot. `NavigationContainer` does it (passing `MiniAppContext` so the per-mini-app override applies); a bare `UIHostingController` root must too. The environment default reads the live store, so an un-injected subtree still gets correct values — just not live ones.
+- **Compose** — `const/Typography.kt` (`scaleSize` overloads for `Float`/`Dp`/`TextUnit`/`TextStyle`). The `TextUnit` overload divides by `density.fontScale` so Compose's own `sp` scaling isn't applied twice. Inputs: `LocalContext.current` (`MiniAppContext.userScaleRate` / `useOSScaleRate`, per-field) falling back to `DesignSystemKits.getConfigs()`. On iOS, `platform/OsFontScale.ios.kt` observes `UIContentSizeCategoryDidChangeNotification` and overrides `LocalDensity` — Compose MP otherwise reads `fontScale` once at `ComposeUIViewController` creation. Wired at `NavigationContainer`.
+- **SwiftUI** — `ios/Typography/FontScale.swift`. `FontScale` is an immutable snapshot with `callAsFunction`, so a view reads `@Environment(\.momoFontScale) private var fontScale` and calls `fontScale(16)`. `DesignSystemKits.shared` is the `ObservableObject` holding the host inputs and the OS factor (it observes `UIContentSizeCategory.didChangeNotification`); the host pushes them with `setConfigs(_:)`.
+- **Never set `\.momoFontScale` directly** — same trap as `\.localize`. Inject via `.momoFontScale(_:context:)`, which holds `DesignSystemKits` as `@ObservedObject`; that is what re-publishes the snapshot. It also injects `\.designSystemKitsConfigs`, which `MomoText` (whitelist font) and `TrustBanner` (fallback after `ApplicationEnvironment.config`) read so a host push re-renders them. `NavigationContainer` does it (passing `MiniAppContext` so the per-mini-app override applies); a bare `UIHostingController` root must too. The environment default reads the live store, so an un-injected subtree still gets correct values — just not live ones.
 - The global `scaleSize(_:)` and `Font.appFont(size:)` remain for call sites that can't read the environment (UIKit bridges, free functions). They are **not** reactive. `Font.header_default_bold` & friends are computed `static var`s for the same reason — as stored `static let`s they froze the scale at first access. `UIViewRepresentable`s should read `context.environment.momoFontScale` instead, and re-apply the font in `updateUIView`, not only in `makeUIView`.
 
 ## Code conventions

package/compose/build.gradle.kts

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

package/compose/compose.podspec

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

package/compose/src/androidMain/kotlin/vn/momo/kits/const/HostFont.android.kt

@@ -5,15 +5,16 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.font.Font
 import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
 
 @Composable
-internal actual fun hostFontFamily(fileName: String): FontFamily? {
+internal actual fun hostFontFamily(fileName: String, weight: FontWeight): FontFamily? {
     val assets = LocalContext.current.applicationContext.assets
-    return remember(fileName) {
+    return remember(fileName, weight) {
         val path = "fonts/$fileName"
         // AssetManager.open ném IOException nếu thiếu file; Font(path, assetManager) thì lỗi
         // muộn lúc render nên phải kiểm tra tồn tại trước.
         val exists = runCatching { assets.open(path).close() }.isSuccess
-        if (exists) FontFamily(Font(path = path, assetManager = assets)) else null
+        if (exists) FontFamily(Font(path = path, assetManager = assets, weight = weight)) else null
     }
 }

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

@@ -1,9 +1,6 @@
 package vn.momo.kits.application
 
 import androidx.compose.runtime.Immutable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
 import androidx.compose.runtime.staticCompositionLocalOf
 import vn.momo.kits.components.TrustBannerData
 
@@ -19,17 +16,6 @@ data class DesignSystemConfig(
     val headerGradient: String? = null,
 )
 
-// App-wide holder seeded by the host (same pattern as KitFontScale), so direct NavigationContainer
-// callers get the config without passing it. Snapshot state: a config fetched after first frame recomposes.
-object KitDesignSystemConfig {
-    var config by mutableStateOf<DesignSystemConfig?>(null)
-        private set
-
-    fun update(config: DesignSystemConfig?) {
-        this.config = config
-    }
-}
-
 @Immutable
 data class MiniAppContext(
     val appIcon: String = "",

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

@@ -0,0 +1,62 @@
+package vn.momo.kits.application
+
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+@Immutable
+data class DesignSystemKitsConfigs(
+    val userScaleRate: Float = 1f,
+    val useOSScaleRate: Boolean = true,
+    val isWhiteList: Boolean = false,
+    val designSystemConfig: DesignSystemConfig? = null,
+)
+
+// The kit is sandboxed from the host's storage/config, so the host implements this and hands it to init().
+interface DesignSystemKitsSource {
+    // Sync read: seeds the kit before the first frame, so there is no default-then-real flicker.
+    fun getConfigs(): DesignSystemKitsConfigs
+
+    val configsFlow: Flow<DesignSystemKitsConfigs>
+}
+
+// App-wide design-system inputs (font scale, whitelist, remote config). scaleSize(), defaultTheme and
+// NavigationContainer fall back to these when no MiniAppContext / LocalDesignSystemConfig is provided.
+object DesignSystemKits {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+    private var observeJob: Job? = null
+
+    // Snapshot state so Compose readers recompose (including non-composable getters like defaultTheme);
+    // the StateFlow is for non-Compose observers, e.g. the host's SwiftUI bridge, where Compose's
+    // global snapshot apply loop may never have started.
+    private var currentConfigs by mutableStateOf(DesignSystemKitsConfigs())
+    private val mutableConfigsFlow = MutableStateFlow(currentConfigs)
+    val configsFlow: StateFlow<DesignSystemKitsConfigs> = mutableConfigsFlow.asStateFlow()
+
+    // Idempotent: a repeated call (e.g. Activity re-creation) replaces the previous observer.
+    fun init(source: DesignSystemKitsSource) {
+        observeJob?.cancel()
+        setConfigs(source.getConfigs())
+        observeJob = scope.launch {
+            source.configsFlow.collect { setConfigs(it) }
+        }
+    }
+
+    // While init() is observing a source, its next emission overrides a value set here.
+    fun setConfigs(configs: DesignSystemKitsConfigs) {
+        currentConfigs = configs
+        mutableConfigsFlow.value = configs
+    }
+
+    fun getConfigs(): DesignSystemKitsConfigs = currentConfigs
+}

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

@@ -2,6 +2,7 @@ package vn.momo.kits.const
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
 
 /**
  * Nạp font từ tài nguyên native của app host thay vì đóng gói bản copy riêng trong SDK.
@@ -13,4 +14,4 @@ import androidx.compose.ui.text.font.FontFamily
  * Trả về `null` nếu host không có font đó — caller tự fallback [FontFamily.Default].
  */
 @Composable
-internal expect fun hostFontFamily(fileName: String): FontFamily?
+internal expect fun hostFontFamily(fileName: String, weight: FontWeight): FontFamily?

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

@@ -8,6 +8,7 @@ import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.unit.*
+import vn.momo.kits.application.DesignSystemKits
 import vn.momo.kits.application.LocalContext
 import vn.momo.kits.platform.getScreenDimensions
 import kotlin.math.max
@@ -20,10 +21,9 @@ const val MAX_DEVICE_SCALE = 5
 @Composable
 fun scaleSize(size: Float): Float {
     val context = LocalContext.current
-    // Host-pushed context wins; otherwise fall back to the app-wide KitFontScale holder.
-    val useOsScale = context?.useOSScaleRate ?: KitFontScale.useOSScaleRate
+    val useOsScale = context?.useOSScaleRate ?: DesignSystemKits.getConfigs().useOSScaleRate
     if (!useOsScale) {
-        return size * (context?.userScaleRate ?: KitFontScale.userScaleRate)
+        return size * (context?.userScaleRate ?: DesignSystemKits.getConfigs().userScaleRate)
     }
     val scaleSizeMaxRate: Float = MAX_FONT_SCALE
     // Short side, not width: landscape must not inflate every font.
@@ -84,12 +84,6 @@ fun scaleSize(textStyle: TextStyle): TextStyle {
 }
 
 
-/**
- * Tên file font trong tài nguyên native của app host (xem [hostFontFamily]).
- *
- * SDK không đóng gói font riêng nữa: app host đã bundle sẵn toàn bộ font từ `font-source`
- * cho cả React Native lẫn native, nên bản copy trong `composeResources` chỉ làm phình app.
- */
 private const val LEGACY_DEFAULT_FONT_FILE = "SFProText-Regular.ttf"
 private const val NEW_DEFAULT_FONT_FILE = "MomoTrustSans-Regular.ttf"
 
@@ -124,17 +118,27 @@ private val hostFontFiles: Map<String, String> = mapOf(
 private const val NEW_DEFAULT_FONT_FAMILY = "MomoTrustSans"
 private const val LEGACY_DEFAULT_FONT_FAMILY = "SFProText"
 
+// Families that ship one file per weight; the others map every weight to a single file.
+private val weightedFontFamilies = setOf(NEW_DEFAULT_FONT_FAMILY, LEGACY_DEFAULT_FONT_FAMILY)
+
 internal val defaultFontFamily: String
-    get() = if (KitDesignSystem.isWhiteList) NEW_DEFAULT_FONT_FAMILY else LEGACY_DEFAULT_FONT_FAMILY
+    get() = if (DesignSystemKits.getConfigs().isWhiteList) NEW_DEFAULT_FONT_FAMILY else LEGACY_DEFAULT_FONT_FAMILY
 
 @Composable
 fun getFontFamily(fontFamily: String, fontWeight: FontWeight? = FontWeight.Normal): FontFamily {
-    val isWhiteList = KitDesignSystem.isWhiteList
+    val isWhiteList = DesignSystemKits.getConfigs().isWhiteList
     val defaultFile = if (isWhiteList) NEW_DEFAULT_FONT_FILE else LEGACY_DEFAULT_FONT_FILE
     val key = "$fontFamily-${fontWeight?.weight}"
-    val fileName = hostFontFiles[key] ?: defaultFile
-    return hostFontFamily(fileName)
-        ?: hostFontFamily(defaultFile)
+    val mappedFile = hostFontFiles[key]
+    val fileName = mappedFile ?: defaultFile
+    // Declaring the file's real weight keeps Compose from synthesizing bold on top of a bold file.
+    val fileWeight = if (mappedFile != null && fontFamily in weightedFontFamilies) {
+        fontWeight ?: FontWeight.Normal
+    } else {
+        FontWeight.Normal
+    }
+    return hostFontFamily(fileName, fileWeight)
+        ?: hostFontFamily(defaultFile, FontWeight.Normal)
         ?: FontFamily.Default
 }
 

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

@@ -20,7 +20,7 @@ import androidx.navigation.toRoute
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.collectLatest
 import vn.momo.kits.application.DesignSystemConfig
-import vn.momo.kits.application.KitDesignSystemConfig
+import vn.momo.kits.application.DesignSystemKits
 import vn.momo.kits.application.LocalContext
 import vn.momo.kits.application.LocalDesignSystemConfig
 import vn.momo.kits.application.LocalLocalize
@@ -66,7 +66,7 @@ fun NavigationContainer(
     val stackTransition = remember { StackTransitionCoordinator() }
     val theme = remember { mutableStateOf(initialTheme) }
     val resolvedDesignSystemConfig =
-        designSystemConfig ?: LocalDesignSystemConfig.current ?: KitDesignSystemConfig.config
+        designSystemConfig ?: LocalDesignSystemConfig.current ?: DesignSystemKits.getConfigs().designSystemConfig
     val headerBar = resolvedDesignSystemConfig?.headerBar
     // RN parity: the theme's own header image wins; config headerBar is only the fallback.
     val resolvedTheme = remember(theme.value, headerBar) {

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

@@ -8,13 +8,13 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.sp
 import androidx.compose.ui.zIndex
+import vn.momo.kits.application.DesignSystemKits
 import vn.momo.kits.components.Text
-import vn.momo.kits.const.KitDesignSystem
 import vn.momo.kits.const.Typography
 import vn.momo.kits.modifier.setAutomationId
 
 internal val headerFontFamily: String?
-    get() = if (KitDesignSystem.isWhiteList) "MoMoTrustDisplay" else null
+    get() = if (DesignSystemKits.getConfigs().isWhiteList) "MoMoTrustDisplay" else null
 
 @Composable
 internal fun HeaderTitle(

package/compose/src/iosMain/kotlin/vn/momo/kits/const/HostFont.ios.kt

@@ -5,6 +5,7 @@ package vn.momo.kits.const
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.platform.Font
 import kotlinx.cinterop.ExperimentalForeignApi
 import kotlinx.cinterop.addressOf
@@ -15,7 +16,7 @@ import platform.Foundation.dataWithContentsOfFile
 import platform.posix.memcpy
 
 @Composable
-internal actual fun hostFontFamily(fileName: String): FontFamily? = remember(fileName) {
+internal actual fun hostFontFamily(fileName: String, weight: FontWeight): FontFamily? = remember(fileName, weight) {
     val name = fileName.substringBeforeLast('.')
     val ext = fileName.substringAfterLast('.', "")
     // Font từ font-source nằm rời ở bundle root, không nằm trong compose-resources.
@@ -26,6 +27,7 @@ internal actual fun hostFontFamily(fileName: String): FontFamily? = remember(fil
             getData = {
                 NSData.dataWithContentsOfFile(path)?.toByteArray() ?: ByteArray(0)
             },
+            weight = weight,
         ),
     )
 }

package/gradle.properties

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

package/ios/Application/ApplicationEnvironment.swift

@@ -17,8 +17,8 @@ public class MiniAppContext {
     public var toolkitConfig: [String: Any] = [:]
     public var providerId: String = "momo"
     public var permissions: [[String: Any]] = []
-    // Per-mini-app font-scale override; nil falls back to FontScaleStore. Mirrors Compose's
-    // MiniAppContext.userScaleRate / useOSScaleRate, which win per field over KitFontScale.
+    // Per-mini-app font-scale override; nil falls back to DesignSystemKits. Mirrors Compose's
+    // MiniAppContext.userScaleRate / useOSScaleRate, which win per field over DesignSystemKits.
     public var userScaleRate: CGFloat? = nil
     public var useOSScaleRate: Bool? = nil
 
@@ -37,10 +37,11 @@ public class MiniAppContext {
     }
 }
 
-public class KitConfig {
-    public var trustBanner: TrustBannerData? = nil
-    public var headerBar: String? = nil
-    public var headerGradient: String? = nil
+// Value type so DesignSystemKitsConfigs can dedupe host pushes; mirrors Compose's DesignSystemConfig.
+public struct KitConfig: Equatable {
+    public var trustBanner: TrustBannerData?
+    public var headerBar: String?
+    public var headerGradient: String?
 
     public init(trustBanner: TrustBannerData? = nil, headerBar: String? = nil, headerGradient: String? = nil) {
         self.trustBanner = trustBanner

package/ios/Application/DesignSystemKits.swift

@@ -0,0 +1,100 @@
+// File: ios/Application/DesignSystemKits.swift
+// Created At: 2026-10-02 14:17:29 +07:00
+// Created By: AI
+// AI Agent: Claude Code
+// Model: claude-opus-5-5
+
+// AI-GENERATED START: app-wide design-system holder mirroring Compose's DesignSystemKits
+import SwiftUI
+
+/// Host-owned design-system inputs; mirrors Compose's `DesignSystemKitsConfigs` field for field.
+public struct DesignSystemKitsConfigs: Equatable {
+    public var userScaleRate: CGFloat
+    public var useOSScaleRate: Bool
+    public var isWhiteList: Bool
+    public var designSystemConfig: KitConfig?
+
+    public init(
+        userScaleRate: CGFloat = 1,
+        useOSScaleRate: Bool = true,
+        isWhiteList: Bool = false,
+        designSystemConfig: KitConfig? = nil
+    ) {
+        self.userScaleRate = userScaleRate
+        self.useOSScaleRate = useOSScaleRate
+        self.isWhiteList = isWhiteList
+        self.designSystemConfig = designSystemConfig
+    }
+}
+
+/// App-wide holder for the SwiftUI kit, mirroring Compose's `DesignSystemKits`. The kit is sandboxed from the
+/// host, so the host pushes `setConfigs(_:)` at startup and on every change; the OS Dynamic Type factor is
+/// tracked here. Views re-render on change as long as the subtree got `.momoFontScale()` (`NavigationContainer`
+/// applies it). Swift reserves `init`, so there is no `init(source:)` twin: the host observes and pushes.
+public final class DesignSystemKits: ObservableObject {
+    public static let shared = DesignSystemKits()
+
+    @Published private var configs = DesignSystemKitsConfigs()
+    @Published public private(set) var osFontScale: CGFloat = DesignSystemKits.currentOsFontScale()
+
+    private init() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(contentSizeCategoryDidChange),
+            name: UIContentSizeCategory.didChangeNotification,
+            object: nil
+        )
+    }
+
+    public func setConfigs(_ configs: DesignSystemKitsConfigs) {
+        onMain {
+            // Re-assigning an unchanged value would still publish and invalidate every kit subtree.
+            guard self.configs != configs else { return }
+            self.configs = configs
+        }
+    }
+
+    public func getConfigs() -> DesignSystemKitsConfigs {
+        configs
+    }
+
+    public var fontScale: FontScale {
+        FontScale(
+            userScaleRate: configs.userScaleRate,
+            useOSScaleRate: configs.useOSScaleRate,
+            osFontScale: osFontScale
+        )
+    }
+
+    @objc private func contentSizeCategoryDidChange() {
+        let next = Self.currentOsFontScale()
+        guard next != osFontScale else { return }
+        osFontScale = next
+    }
+
+    /// Same factor Compose's iOS `ProvideOsFontScale` derives from
+    /// `UIFont.preferredFont(forTextStyle: .body).pointSize / 17`, so both iOS surfaces scale alike.
+    static func currentOsFontScale() -> CGFloat {
+        let base = UIFont.systemFont(ofSize: UIFont.labelFontSize)
+        return UIFontMetrics.default.scaledFont(for: base).pointSize / base.pointSize
+    }
+
+    /// Synchronous when already on main — an async hop would defer the change by a frame.
+    private func onMain(_ work: @escaping () -> Void) {
+        if Thread.isMainThread { work() } else { DispatchQueue.main.async(execute: work) }
+    }
+}
+
+private struct DesignSystemKitsConfigsKey: EnvironmentKey {
+    /// Computed, never stored: an un-injected subtree still reads the live holder, just not reactively.
+    static var defaultValue: DesignSystemKitsConfigs { DesignSystemKits.shared.getConfigs() }
+}
+
+public extension EnvironmentValues {
+    /// Injected by `.momoFontScale()`; never set it directly (same trap as `\.momoFontScale`).
+    var designSystemKitsConfigs: DesignSystemKitsConfigs {
+        get { self[DesignSystemKitsConfigsKey.self] }
+        set { self[DesignSystemKitsConfigsKey.self] = newValue }
+    }
+}
+// AI-GENERATED END: app-wide design-system holder mirroring Compose's DesignSystemKits

package/ios/Application/DesignSystemKitsPayload.swift

@@ -0,0 +1,68 @@
+// File: ios/Application/DesignSystemKitsPayload.swift
+// Created At: 2026-10-02 15:40:00 +07:00
+// Created By: AI
+// AI Agent: Claude Code
+// Model: claude-opus-5-5
+
+// AI-GENERATED START: JSON entry point for hosts that can't share Swift types with the kit
+import Foundation
+
+public extension DesignSystemKits {
+    /// Applies configs pushed as JSON by a host that can't share Swift types with the kit (e.g. the KMP bridge).
+    /// Invalid JSON is ignored and the current configs are kept.
+    func setConfigs(json: String) {
+        guard let data = json.data(using: .utf8),
+              let payload = try? JSONDecoder().decode(DesignSystemKitsPayload.self, from: data) else { return }
+        setConfigs(payload.configs)
+    }
+}
+
+// Wire format; field names match the host's serializer (momo-app HostDesignSystemKits / DesignSystemData.kt).
+private struct DesignSystemKitsPayload: Decodable {
+    let userScaleRate: CGFloat
+    let useOSScaleRate: Bool
+    let isWhiteList: Bool
+    let designSystemConfig: KitConfigPayload?
+
+    var configs: DesignSystemKitsConfigs {
+        DesignSystemKitsConfigs(
+            userScaleRate: userScaleRate,
+            useOSScaleRate: useOSScaleRate,
+            isWhiteList: isWhiteList,
+            designSystemConfig: designSystemConfig?.kitConfig
+        )
+    }
+}
+
+private struct KitConfigPayload: Decodable {
+    let trustBanner: TrustBannerPayload?
+    let headerBar: String?
+    let headerGradient: String?
+
+    var kitConfig: KitConfig {
+        KitConfig(trustBanner: trustBanner?.trustBannerData, headerBar: headerBar, headerGradient: headerGradient)
+    }
+}
+
+private struct TrustBannerPayload: Decodable {
+    let content: [String: String]
+    let subContent: [String: String]
+    let pciImage: String?
+    let sslImage: String?
+    let urlConfig: String?
+    let icons: [String]?
+    let momoImage: String?
+
+    var trustBannerData: TrustBannerData {
+        TrustBannerData(
+            content: content,
+            subContent: subContent,
+            pciImage: pciImage,
+            momoImage: momoImage,
+            sslImage: sslImage,
+            icons: icons,
+            urlConfig: urlConfig ?? ""
+        )
+    }
+}
+// AI-GENERATED END: JSON entry point for hosts that can't share Swift types with the kit

package/ios/Badge/BadgeRibbon.swift

@@ -203,7 +203,9 @@ public struct BadgeRibbon: View {
 /// rotation) — the label gets the same scale applied a second time so it stays right-reading
 /// while only the ribbon shape flips.
 public struct RoundedBadgeRibbon: View {
+    @Environment(\.appTheme) private var theme
     @Environment(\.momoFontScale) private var fontScale
+    @Environment(\.designSystemKitsConfigs) private var designSystemKitsConfigs
     let text: String
     let position: RibbonPosition
 
@@ -223,7 +225,12 @@ public struct RoundedBadgeRibbon: View {
 
     private var measuredTextSize: CGSize {
         let fontSize = fontScale(TypographyStyle.labelXsMedium.fontSize)
-        let font = UIFont.systemFont(ofSize: fontSize, weight: .medium)
+        let font = momoUIFont(
+            size: fontSize,
+            weight: .medium,
+            family: theme.font,
+            isWhiteList: designSystemKitsConfigs.isWhiteList
+        )
         return text.size(withAttributes: [.font: font])
     }
 

package/ios/Input/Input.swift

@@ -153,7 +153,7 @@ public struct Input: View {
                             handleFocusChange(focused)
                         })
                         .keyboardType(keyboardType)
-                        .font(fontScale.font(size: 14, weight: fontWeight == .bold ? .bold : .regular))
+                        .kitFont(fontWeight == .bold ? .actionSBold : .bodyDefaultRegular)
                         .ignoreBoldTextSetting()
                         .foregroundColor(getTextColor())
                         .disabled(disabled || readOnly)
@@ -345,7 +345,12 @@ private struct SecureInputField: UIViewRepresentable {
         textField.spellCheckingType = .no
         textField.delegate = context.coordinator
         textField.keyboardType = keyboardType
-        textField.font = UIFont.systemFont(ofSize: fontSize, weight: fontWeight)
+        textField.font = momoUIFont(
+            size: fontSize,
+            weight: fontWeight,
+            family: context.environment.appTheme.font,
+            isWhiteList: context.environment.designSystemKitsConfigs.isWhiteList
+        )
         textField.textColor = textColor
         textField.isEnabled = !isDisabled
         textField.setContentHuggingPriority(.defaultLow, for: .horizontal)
@@ -370,7 +375,12 @@ private struct SecureInputField: UIViewRepresentable {
         if textField.text != text {
             textField.text = text
         }
-        let font = UIFont.systemFont(ofSize: fontSize, weight: fontWeight)
+        let font = momoUIFont(
+            size: fontSize,
+            weight: fontWeight,
+            family: context.environment.appTheme.font,
+            isWhiteList: context.environment.designSystemKitsConfigs.isWhiteList
+        )
         if textField.font != font {
             textField.font = font
         }

package/ios/Input/InputPhoneNumber.swift

@@ -104,9 +104,7 @@ public struct InputPhoneNumber: View {
                         handleFocusChange(focused)
                     })
                     .keyboardType(.numberPad)
-                    .font(size == .small
-                          ? fontScale.font(size: 14, weight: .semibold)
-                          : fontScale.font(size: 18, weight: .bold))
+                    .kitFont(size == .small ? .headerSSemibold : .headerMBold)
                     .ignoreBoldTextSetting()
                     .foregroundColor(theme.colors.text.default)
                     .applyCursorColor(theme.colors.primary)

package/ios/Input/InputSearch.swift

@@ -120,7 +120,6 @@ public struct InputSearchProps {
 
 public struct InputSearch: View {
     @Environment(\.appTheme) private var theme
-    @Environment(\.momoFontScale) private var fontScale
     @Binding var text: String
     var buttonText: String = ""
     var showButtonText: Bool = false
@@ -263,7 +262,7 @@ public struct InputSearch: View {
                     }, onCommit: onSubmit)
                     .disabled(disabled)
                     .foregroundColor(disabled ? theme.colors.text.disable : theme.colors.text.default)
-                    .font(.system(size: fontScale(14), weight: fontWeight))
+                    .kitFont(size: 14, weight: fontWeight)
                     .ignoreBoldTextSetting()
                     .keyboardType(keyboardType)
                     .applyCursorColor(theme.colors.primary)

package/ios/Input/InputTextArea.swift

@@ -41,9 +41,11 @@ struct UITextViewWrapper: UIViewRepresentable {
         uiView.tintColor = UIColor(cursorColor)
         // Read through `context.environment` rather than the global `scaleSize`: that is what makes
         // SwiftUI re-run updateUIView when the font scale changes.
-        uiView.font = UIFont.systemFont(
-            ofSize: context.environment.momoFontScale(16),
-            weight: fontWeight == .bold ? .bold : .regular
+        uiView.font = momoUIFont(
+            size: context.environment.momoFontScale(16),
+            weight: fontWeight == .bold ? .bold : .regular,
+            family: context.environment.appTheme.font,
+            isWhiteList: context.environment.designSystemKitsConfigs.isWhiteList
         )
         uiView.isEditable = !disabled
         if uiView.keyboardType != keyboardType {

package/ios/InputMoney/InputMoney.swift

@@ -356,14 +356,13 @@ private struct MoneyTextField: UIViewRepresentable {
         return numeric.isEmpty ? "" : formatNumberToMoney(numeric)
     }
 
-    // Theme family as Compose `getFontFamily`: Momo Trust Sans only for whitelisted hosts, else system.
     private func font(_ context: Context) -> UIFont {
-        let size = context.environment.momoFontScale(20)
-        if KitDesignSystem.shared.isWhiteList, fontFamily == "MomoTrustSans",
-           let font = UIFont(name: fontWeight == .bold ? "MomoTrustSans-Bold" : "MomoTrustSans-Regular", size: size) {
-            return font
-        }
-        return .systemFont(ofSize: size, weight: fontWeight)
+        momoUIFont(
+            size: context.environment.momoFontScale(20),
+            weight: fontWeight,
+            family: fontFamily,
+            isWhiteList: context.environment.designSystemKitsConfigs.isWhiteList
+        )
     }
 
     final class Coordinator: NSObject, UITextFieldDelegate {

package/ios/Stepper/Stepper.swift

@@ -84,7 +84,6 @@ private struct StepperButton: View {
 
 private struct StepperNumberView: View {
     @Environment(\.appTheme) private var theme
-    @Environment(\.momoFontScale) private var fontScale
 
     @Binding var text: String
     var size: StepperSize
@@ -106,7 +105,7 @@ private struct StepperNumberView: View {
                 MomoText(text, typography: .descriptionDefaultRegular, color: textColor)
             }
         }
-        .font(.system(size: fontScale(12)))
+        .kitFont(size: 12)
         .ignoreBoldTextSetting()
         .foregroundColor(textColor)
         // Compose's min width includes the horizontal padding.

package/ios/Template/TrustBanner/TrustBanner.swift

@@ -11,7 +11,7 @@ import SDWebImageSwiftUI
 
 let jsonUrl = "https://static.momocdn.net/app/json/component-kits/design_system.json"
 
-public struct TrustBannerData: Decodable {
+public struct TrustBannerData: Decodable, Equatable {
     public let content: [String: String]
     public let subContent: [String: String]
     public let pciImage: String?
@@ -85,6 +85,7 @@ let defaultBanner = TrustBannerData(
 public struct TrustBanner: View {
     @Environment(\.applicationEnvironment) var applicationEnvironment
     @Environment(\.localize) private var localize
+    @Environment(\.designSystemKitsConfigs) private var designSystemKitsConfigs
 
     var onPress: ((String)->Void)?
     private let serviceName: String
@@ -104,7 +105,8 @@ public struct TrustBanner: View {
     }
 
     private var banner: TrustBannerData {
-        applicationEnvironment.config?.trustBanner ?? defaultBanner
+        // Container config wins, else the host-pushed DesignSystemKits config (Compose parity).
+        (applicationEnvironment.config ?? designSystemKitsConfigs.designSystemConfig)?.trustBanner ?? defaultBanner
     }
 
     func onPressSecurity() {

package/ios/Typography/FontScale.swift

@@ -52,7 +52,7 @@ public struct FontScale: Equatable {
     }
 
     /// A host-pushed mini-app context wins per field, matching Compose's
-    /// `context?.useOSScaleRate ?: KitFontScale.useOSScaleRate`.
+    /// `context?.useOSScaleRate ?: DesignSystemKits.getConfigs().useOSScaleRate`.
     public func overriding(userScaleRate: CGFloat?, useOSScaleRate: Bool?) -> FontScale {
         guard userScaleRate != nil || useOSScaleRate != nil else { return self }
         return FontScale(
@@ -66,7 +66,7 @@ public struct FontScale: Equatable {
 private struct FontScaleKey: EnvironmentKey {
     /// Computed, never stored: a bare `UIHostingController` root that never got `.momoFontScale()`
     /// still reads the live store instead of a value frozen at first access.
-    static var defaultValue: FontScale { FontScaleStore.shared.snapshot }
+    static var defaultValue: FontScale { DesignSystemKits.shared.fontScale }
 }
 
 public extension EnvironmentValues {
@@ -77,9 +77,10 @@ public extension EnvironmentValues {
 }
 
 public extension View {
-    /// Injects a Dynamic-Type-observing font scale and re-renders this subtree on change.
+    /// Injects a Dynamic-Type-observing font scale plus `\.designSystemKitsConfigs` (whitelist, remote config)
+    /// and re-renders this subtree on change.
     /// Use at every `UIHostingController` root that is not inside a `NavigationContainer`.
-    func momoFontScale(_ store: FontScaleStore = .shared, context: MiniAppContext? = nil) -> some View {
+    func momoFontScale(_ store: DesignSystemKits = .shared, context: MiniAppContext? = nil) -> some View {
         modifier(MomoFontScaleModifier(store: store, context: context))
     }
 }
@@ -87,17 +88,19 @@ public extension View {
 /// `@ObservedObject` is load-bearing, same as `MomoLocalizeModifier`: `@Environment(\.momoFontScale)`
 /// only invalidates when the boxed snapshot changes, which requires *this* body to re-run on publish.
 private struct MomoFontScaleModifier: ViewModifier {
-    @ObservedObject var store: FontScaleStore
+    @ObservedObject var store: DesignSystemKits
     let context: MiniAppContext?
 
     func body(content: Content) -> some View {
-        content.environment(
-            \.momoFontScale,
-            store.snapshot.overriding(
-                userScaleRate: context?.userScaleRate,
-                useOSScaleRate: context?.useOSScaleRate
+        content
+            .environment(
+                \.momoFontScale,
+                store.fontScale.overriding(
+                    userScaleRate: context?.userScaleRate,
+                    useOSScaleRate: context?.useOSScaleRate
+                )
             )
-        )
+            .environment(\.designSystemKitsConfigs, store.getConfigs())
     }
 }
 // AI-GENERATED END: reactive font-scale snapshot injected through the environment

package/ios/Typography/Text.swift

@@ -4,7 +4,7 @@ import SwiftUI
 /// free functions). Inside a SwiftUI view prefer `@Environment(\.momoFontScale)` so the view
 /// re-renders when Dynamic Type or the host preference changes.
 public func scaleSize(_ size: CGFloat) -> CGFloat {
-    FontScaleStore.shared.snapshot(size)
+    DesignSystemKits.shared.fontScale(size)
 }
 
 @available(*, deprecated, message: "Max font scale is fixed at 1.5; this override is no longer applied. Drop the second argument.")
@@ -105,10 +105,10 @@ private enum MomoFontFace {
 }
 
 /// Port of Compose `getFontFamily`; SF Pro Text is the iOS system font, so the legacy family is `.system`.
-private func momoFontFace(family: String, weight: Font.Weight) -> MomoFontFace? {
+private func momoFontFace(family: String, weight: Font.Weight, isWhiteList: Bool) -> MomoFontFace? {
     let isNewFamily = family == "MomoTrustSans" || family == headerFontFamily
     // Outside the whitelist the new DS families drop to the legacy font, as before DS-791.
-    if family == "SFProText" || (isNewFamily && !KitDesignSystem.shared.isWhiteList) { return .system }
+    if family == "SFProText" || (isNewFamily && !isWhiteList) { return .system }
     // single-file families (Compose maps every weight to the same .otf)
     if family == headerFontFamily || family == "MoMoSignature" { return .named(family) }
     guard family == "MomoTrustSans" else { return nil }
@@ -127,8 +127,14 @@ private func momoFontFace(family: String, weight: Font.Weight) -> MomoFontFace?
 /// Header title family (Compose `HEADER_FONT_FAMILY`), whitelist only like the default font.
 let headerFontFamily = "MoMoTrustDisplay"
 
-private func momoFont(size: CGFloat, weight: Font.Weight, family: String, fallbackFamily: String? = nil) -> Font {
-    switch momoFontFace(family: family, weight: weight) {
+private func momoFont(
+    size: CGFloat,
+    weight: Font.Weight,
+    family: String,
+    fallbackFamily: String? = nil,
+    isWhiteList: Bool
+) -> Font {
+    switch momoFontFace(family: family, weight: weight, isWhiteList: isWhiteList) {
     case .system:
         return .system(size: size, weight: weight)
     case .named(let name) where UIFont(name: name, size: size) != nil:
@@ -136,15 +142,15 @@ private func momoFont(size: CGFloat, weight: Font.Weight, family: String, fallba
     default:
         // Compose falls back to the default font file when a family is missing
         if let fallbackFamily, fallbackFamily != family {
-            return momoFont(size: size, weight: weight, family: fallbackFamily)
+            return momoFont(size: size, weight: weight, family: fallbackFamily, isWhiteList: isWhiteList)
         }
         return .system(size: size, weight: weight)
     }
 }
 
 // lineHeight is identical across weights of a family, so the regular face is enough.
-private func momoLineHeight(size: CGFloat, family: String, fallbackFamily: String? = nil) -> CGFloat {
-    switch momoFontFace(family: family, weight: .regular) {
+private func momoLineHeight(size: CGFloat, family: String, fallbackFamily: String? = nil, isWhiteList: Bool) -> CGFloat {
+    switch momoFontFace(family: family, weight: .regular, isWhiteList: isWhiteList) {
     case .system:
         break
     case .named(let name):
@@ -152,15 +158,71 @@ private func momoLineHeight(size: CGFloat, family: String, fallbackFamily: Strin
         fallthrough
     case nil:
         if let fallbackFamily, fallbackFamily != family {
-            return momoLineHeight(size: size, family: fallbackFamily)
+            return momoLineHeight(size: size, family: fallbackFamily, isWhiteList: isWhiteList)
         }
     }
     return UIFont.systemFont(ofSize: size).lineHeight
 }
 
+/// UIKit counterpart of `momoFont`, for text that is not a `MomoText` (UITextField/UITextView, text measuring).
+func momoUIFont(size: CGFloat, weight: UIFont.Weight, family: String, isWhiteList: Bool) -> UIFont {
+    guard case .named(let name) = momoFontFace(family: family, weight: Font.Weight(weight), isWhiteList: isWhiteList),
+          let font = UIFont(name: name, size: size) else {
+        return .systemFont(ofSize: size, weight: weight)
+    }
+    return font
+}
+
+private extension Font.Weight {
+    init(_ weight: UIFont.Weight) {
+        switch weight {
+        case .ultraLight: self = .ultraLight
+        case .thin: self = .thin
+        case .light: self = .light
+        case .medium: self = .medium
+        case .semibold: self = .semibold
+        case .bold: self = .bold
+        case .heavy: self = .heavy
+        case .black: self = .black
+        default: self = .regular
+        }
+    }
+}
+
+/// Gives input text the same family as `MomoText` (Compose's `getFontFamily`), e.g. a TextField
+/// next to a `MomoText` placeholder. `size` is unscaled; the environment font scale is applied here.
+private struct KitFontModifier: ViewModifier {
+    @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
+    @Environment(\.designSystemKitsConfigs) private var designSystemKitsConfigs
+    let size: CGFloat
+    let weight: Font.Weight
+
+    func body(content: Content) -> some View {
+        content.font(momoFont(
+            size: fontScale(size),
+            weight: weight,
+            family: theme.font,
+            isWhiteList: designSystemKitsConfigs.isWhiteList
+        ))
+    }
+}
+
+extension View {
+    func kitFont(_ typography: TypographyStyle) -> some View {
+        modifier(KitFontModifier(size: typography.fontSize, weight: typography.fontWeight))
+    }
+
+    func kitFont(size: CGFloat, weight: Font.Weight = .regular) -> some View {
+        modifier(KitFontModifier(size: size, weight: weight))
+    }
+}
+
 public struct MomoText: View {
     @Environment(\.appTheme) private var theme
     @Environment(\.momoFontScale) private var fontScale
+    // From the environment, not DesignSystemKits.shared, so a whitelist flip re-renders the text.
+    @Environment(\.designSystemKitsConfigs) private var designSystemKitsConfigs
     private let content: String
     private let typography: TypographyStyle
     private let color: Color?
@@ -236,7 +298,8 @@ public struct MomoText: View {
             size: fontScale(fontSize),
             weight: typography.fontWeight,
             family: fontFamily ?? theme.font,
-            fallbackFamily: theme.font
+            fallbackFamily: theme.font,
+            isWhiteList: designSystemKitsConfigs.isWhiteList
         )
     }
 
@@ -244,7 +307,13 @@ public struct MomoText: View {
     private var baseText: SwiftUI.Text {
         let keywords = highlightText.filter { !$0.isEmpty }.sorted { $0.count > $1.count }
         guard !keywords.isEmpty else { return SwiftUI.Text(content) }
-        let highlightFont = momoFont(size: fontScale(fontSize), weight: TypographyStyle.headerXsSemibold.fontWeight, family: fontFamily ?? theme.font, fallbackFamily: theme.font)
+        let highlightFont = momoFont(
+            size: fontScale(fontSize),
+            weight: TypographyStyle.headerXsSemibold.fontWeight,
+            family: fontFamily ?? theme.font,
+            fallbackFamily: theme.font,
+            isWhiteList: designSystemKitsConfigs.isWhiteList
+        )
         func isWordChar(_ character: Character?) -> Bool {
             guard let character else { return false }
             return character.isLetter || character.isNumber || character == "_"
@@ -282,7 +351,12 @@ public struct MomoText: View {
 
         // lineSpacing is added on top of the font's natural line height, not on top of fontSize.
         let lineSpacing = max(0, fontScale(lineHeight)
-            - momoLineHeight(size: fontScale(fontSize), family: fontFamily ?? theme.font, fallbackFamily: theme.font))
+            - momoLineHeight(
+                size: fontScale(fontSize),
+                family: fontFamily ?? theme.font,
+                fallbackFamily: theme.font,
+                isWhiteList: designSystemKitsConfigs.isWhiteList
+            ))
 
         var text = baseText
             .font(font)

package/ios/Typography/Typography.swift

@@ -10,12 +10,12 @@ public extension View {
 }
 
 public extension Font {
-    /// Non-reactive: resolves against the current `FontScaleStore` snapshot at each access. The
+    /// Non-reactive: resolves against the current `DesignSystemKits` font scale at each access. The
     /// styles below are computed properties for that reason — as stored `static let`s they would
     /// freeze the scale at first access and never pick up a Dynamic Type change.
     /// Inside a view, `@Environment(\.momoFontScale)` + `fontScale.font(size:weight:)` also re-renders.
     static func appFont(size: CGFloat) -> Font {
-        FontScaleStore.shared.snapshot.font(size: size)
+        DesignSystemKits.shared.fontScale.font(size: size)
     }
 
     // New supported typography styles

package/ios/native-kits.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'MoMoUIKits'
-  s.version          = '0.167.1-duo.15'
+  s.version          = '0.167.1-beta.22'
   s.summary          = 'MoMoUIKits for iOS'
   s.homepage         = 'https://momo.vn'
   s.license          = { :type => 'MIT' }

package/ios-demo/MoMoUIKitsDemo.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'MoMoUIKitsDemo'
-  s.version          = '0.167.1-duo.15'
+  s.version          = '0.167.1-beta.22'
   s.summary          = 'Demo browser for MoMoUIKits SwiftUI components'
   s.homepage         = 'https://momo.vn'
   s.license          = { :type => 'MIT' }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.168.1-beta.5-debug",
+  "version": "0.168.1-beta.6-debug",
   "private": false,
   "dependeNavigationncies": {},
   "devDependencies": {},

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

@@ -1,18 +0,0 @@
-package vn.momo.kits.const
-
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-
-// Design-system rollout holder, same shape as KitFontScale: the kit is sandboxed and can't read the
-// host config, so the host seeds this once at startup from DesignSystemConfig. getFontFamily() reads
-// it to decide whether the new default font applies, so every screen follows the flag with no prop
-// threading. Backed by snapshot state: writes recompose text automatically.
-object KitDesignSystem {
-    var isWhiteList by mutableStateOf(false)
-        private set
-
-    fun update(isWhiteList: Boolean) {
-        this.isWhiteList = isWhiteList
-    }
-}

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

@@ -1,22 +0,0 @@
-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/ios/Typography/FontScaleStore.swift

@@ -1,58 +0,0 @@
-import SwiftUI
-
-/// App-wide font-scale inputs for the SwiftUI kit, and the single place they publish from.
-/// The host writes `update(...)` at startup (from the cache-backed `FontScaleProvider`) and again
-/// whenever the in-app font-size preference changes; the OS Dynamic Type factor is tracked here.
-/// Mirrors Compose's `KitFontScale` + `ProvideOsFontScale` pair, including its live behaviour —
-/// views re-render on change as long as the subtree got `.momoFontScale()` (`NavigationContainer`
-/// applies it). When `useOSScaleRate` is false the kit applies `userScaleRate` instead of the OS factor.
-public final class FontScaleStore: ObservableObject {
-    public static let shared = FontScaleStore()
-
-    @Published public private(set) var userScaleRate: CGFloat = 1
-    @Published public private(set) var useOSScaleRate: Bool = true
-    @Published public private(set) var osFontScale: CGFloat = FontScaleStore.currentOsFontScale()
-
-    private init() {
-        NotificationCenter.default.addObserver(
-            self,
-            selector: #selector(contentSizeCategoryDidChange),
-            name: UIContentSizeCategory.didChangeNotification,
-            object: nil
-        )
-    }
-
-    public var snapshot: FontScale {
-        FontScale(
-            userScaleRate: userScaleRate,
-            useOSScaleRate: useOSScaleRate,
-            osFontScale: osFontScale
-        )
-    }
-
-    public func update(userScaleRate: CGFloat, useOSScaleRate: Bool) {
-        onMain {
-            // Re-assigning an unchanged value would still publish and invalidate every kit subtree.
-            if self.userScaleRate != userScaleRate { self.userScaleRate = userScaleRate }
-            if self.useOSScaleRate != useOSScaleRate { self.useOSScaleRate = useOSScaleRate }
-        }
-    }
-
-    @objc private func contentSizeCategoryDidChange() {
-        let next = Self.currentOsFontScale()
-        guard next != osFontScale else { return }
-        osFontScale = next
-    }
-
-    /// Same factor Compose's iOS `ProvideOsFontScale` derives from
-    /// `UIFont.preferredFont(forTextStyle: .body).pointSize / 17`, so both iOS surfaces scale alike.
-    static func currentOsFontScale() -> CGFloat {
-        let base = UIFont.systemFont(ofSize: UIFont.labelFontSize)
-        return UIFontMetrics.default.scaledFont(for: base).pointSize / base.pointSize
-    }
-
-    /// Synchronous when already on main — an async hop would defer the change by a frame.
-    private func onMain(_ work: @escaping () -> Void) {
-        if Thread.isMainThread { work() } else { DispatchQueue.main.async(execute: work) }
-    }
-}

package/ios/Typography/KitDesignSystem.swift

@@ -1,17 +0,0 @@
-import Foundation
-
-/// Design-system rollout flag for the SwiftUI kit, mirroring Compose's `KitDesignSystem`.
-/// The kit is sandboxed and can't read the host config, so the host writes `update(_:)` once at
-/// startup from `DesignSystemConfig`. Startup-only and non-reactive, like `FontScaleStore` was
-/// before it gained live updates: there is no SwiftUI navigation container to re-render from.
-public final class KitDesignSystem {
-    public static let shared = KitDesignSystem()
-
-    public private(set) var isWhiteList: Bool = false
-
-    private init() {}
-
-    public func update(isWhiteList: Bool) {
-        self.isWhiteList = isWhiteList
-    }
-}