@momo-kits/native-kits 0.162.30-debug → 0.162.31-debug

package/ios/Stepper/Stepper.swift

@@ -84,6 +84,7 @@ 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
@@ -105,7 +106,7 @@ private struct StepperNumberView: View {
                 MomoText(text, typography: .descriptionDefaultRegular, color: textColor)
             }
         }
-        .font(.system(size: scaleSize(12)))
+        .font(.system(size: fontScale(12)))
         .ignoreBoldTextSetting()
         .foregroundColor(textColor)
         .frame(minWidth: specs.numberMinWidth)

package/ios/SuggestAction/SuggestAction.swift

@@ -3,6 +3,7 @@ import Foundation
 
 public struct SuggestAction: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
 
     private let message: String
     private let buttonTitle: String
@@ -32,7 +33,7 @@ public struct SuggestAction: View {
 
     // Builds an attributed string with `boldMessage` (case-insensitive) emphasized.
     private var annotatedMessage: AttributedString {
-        let baseFont = Font.system(size: scaleSize(TypographyStyle.bodyDefaultRegular.fontSize), weight: .regular)
+        let baseFont = Font.system(size: fontScale(TypographyStyle.bodyDefaultRegular.fontSize), weight: .regular)
         var attributed = AttributedString(message)
         attributed.font = baseFont
 
@@ -44,7 +45,7 @@ public struct SuggestAction: View {
 
         if let boldRange = Range(range, in: attributed) {
             attributed[boldRange].font = Font.system(
-                size: scaleSize(TypographyStyle.bodyDefaultRegular.fontSize),
+                size: fontScale(TypographyStyle.bodyDefaultRegular.fontSize),
                 weight: .bold
             )
         }

package/ios/Tag/Tag.swift

@@ -1,6 +1,7 @@
 import SwiftUI
 
 public struct Tag: View {
+    @Environment(\.momoFontScale) private var fontScale
     public enum TagSize {
         case large
         case medium
@@ -71,7 +72,7 @@ public struct Tag: View {
             }
             MomoText(label, typography: .labelSMedium, color: labelColor)
         }
-        .frame(height: scaleSize(size.height))
+        .frame(height: fontScale(size.height))
         .padding(.horizontal, Spacing.S)
         .background(
             RoundedRectangle(cornerRadius: Radius.S, style: .continuous)

package/ios/Template/TrustBanner/TrustBanner.swift

@@ -74,7 +74,8 @@ public struct TrustBanner: View {
                 .scaledToFit()
                 .frame(width: 64, height: 64)
             VStack(alignment: .leading){
-                Text(applicationEnvironment.config?.trustBanner?.content[localize.currentLanguage] ?? defaultBanner.content[localize.currentLanguage])
+                Text(applicationEnvironment.config?.trustBanner?.content[localize.currentLanguage]
+                     ?? localize.translateData(defaultBanner.content))
                     .foregroundColor(Color(hex: "484848"))
                     .lineLimit(2)
                     .font(.system(size: 13, weight: Font.Weight.regular))
@@ -83,7 +84,8 @@ public struct TrustBanner: View {
                     .padding(.bottom, 8)
                 HStack {
                     HStack(spacing: 0) {
-                        Text(applicationEnvironment.config?.trustBanner?.subContent[localize.currentLanguage] ?? defaultBanner.subContent[localize.currentLanguage])
+                        Text(applicationEnvironment.config?.trustBanner?.subContent[localize.currentLanguage]
+                             ?? localize.translateData(defaultBanner.subContent))
                             .foregroundColor(Colors.pink03)
                             .font(.system(size: 13, weight: .bold))
                             .ignoreBoldTextSetting()

package/ios/Title/Title.swift

@@ -28,6 +28,7 @@ public enum TitleButtonSize {
 
 public struct Title: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
 
     private let title: String
     private let type: TitleType
@@ -152,10 +153,10 @@ public struct Title: View {
 
     private var titleText: some View {
         SwiftUI.Text(title)
-            .font(.system(size: scaleSize(titleFontSize), weight: titleFontWeight))
+            .font(.system(size: fontScale(titleFontSize), weight: titleFontWeight))
             .ignoreBoldTextSetting()
             .foregroundColor(theme.colors.text.default)
-            .lineSpacing(scaleSize(titleLineHeight) - scaleSize(titleFontSize))
+            .lineSpacing(fontScale(titleLineHeight) - fontScale(titleFontSize))
             .lineLimit(titleMaxLines)
             .truncationMode(.tail)
     }

package/ios/Tooltip/Tooltip.swift

@@ -469,11 +469,12 @@ private struct TooltipSecondaryButton: View {
 }
 
 private struct TooltipIconButton: View {
+    @Environment(\.momoFontScale) private var fontScale
     let icon: String
     let onPress: () -> Void
 
     var body: some View {
-        let iconButtonSize = scaleSize(36)
+        let iconButtonSize = fontScale(36)
         SwiftUI.Button(action: onPress) {
             Icon(source: icon, size: 24)
                 .frame(width: iconButtonSize, height: iconButtonSize)

package/ios/Typography/FontScale.swift

@@ -0,0 +1,103 @@
+// File: ios/Typography/FontScale.swift
+// Created At: 2026-08-06 10:00:00 +07:00
+// Created By: AI
+// AI Agent: Claude Code
+// Model: claude-opus-5
+
+// AI-GENERATED START: reactive font-scale snapshot injected through the environment
+import SwiftUI
+
+/// Immutable snapshot of the kit's font-scale inputs. The formula is a 1:1 port of Compose's
+/// `scaleSize()` (`const/Typography.kt`): the device-width scale and the OS Dynamic Type scale are
+/// computed independently and the larger one wins.
+public struct FontScale: Equatable {
+    private static let defaultScreenSize: CGFloat = 375
+    private static let maxFontScale: CGFloat = 1.5
+    private static let maxDeviceScale: CGFloat = 5
+
+    public let userScaleRate: CGFloat
+    public let useOSScaleRate: Bool
+    /// OS Dynamic Type factor at the time the snapshot was taken.
+    public let osFontScale: CGFloat
+
+    public init(userScaleRate: CGFloat = 1, useOSScaleRate: Bool = true, osFontScale: CGFloat = 1) {
+        self.userScaleRate = userScaleRate
+        self.useOSScaleRate = useOSScaleRate
+        self.osFontScale = osFontScale
+    }
+
+    /// `callAsFunction` so call sites keep reading like Compose's `scaleSize(16)`.
+    public func callAsFunction(_ size: CGFloat) -> CGFloat {
+        guard useOSScaleRate else { return size * userScaleRate }
+
+        // Device width is read live rather than snapshotted, matching Compose's
+        // getScreenDimensions() read inside scaleSize(), so a rotation or split-view resize counts.
+        let deviceScale = UIScreen.main.bounds.width / Self.defaultScreenSize
+
+        var deviceScaled = size
+        var osScaled = size
+        if deviceScale > 1 {
+            deviceScaled = min(size * deviceScale, size + Self.maxDeviceScale)
+        }
+        if osFontScale > 1 {
+            osScaled = min(size * osFontScale, size * Self.maxFontScale)
+        }
+        return max(deviceScaled, osScaled)
+    }
+
+    /// `.system(size:)` is a fixed-size font — SwiftUI does not Dynamic-Type it — so the scale has to
+    /// be baked into the point size here, and there is no double-scaling to undo.
+    public func font(size: CGFloat, weight: Font.Weight = .regular) -> Font {
+        .system(size: self(size), weight: weight)
+    }
+
+    /// A host-pushed mini-app context wins per field, matching Compose's
+    /// `context?.useOSScaleRate ?: KitFontScale.useOSScaleRate`.
+    public func overriding(userScaleRate: CGFloat?, useOSScaleRate: Bool?) -> FontScale {
+        guard userScaleRate != nil || useOSScaleRate != nil else { return self }
+        return FontScale(
+            userScaleRate: userScaleRate ?? self.userScaleRate,
+            useOSScaleRate: useOSScaleRate ?? self.useOSScaleRate,
+            osFontScale: osFontScale
+        )
+    }
+}
+
+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 }
+}
+
+public extension EnvironmentValues {
+    var momoFontScale: FontScale {
+        get { self[FontScaleKey.self] }
+        set { self[FontScaleKey.self] = newValue }
+    }
+}
+
+public extension View {
+    /// Injects a Dynamic-Type-observing font scale 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 {
+        modifier(MomoFontScaleModifier(store: store, context: context))
+    }
+}
+
+/// `@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
+    let context: MiniAppContext?
+
+    func body(content: Content) -> some View {
+        content.environment(
+            \.momoFontScale,
+            store.snapshot.overriding(
+                userScaleRate: context?.userScaleRate,
+                useOSScaleRate: context?.useOSScaleRate
+            )
+        )
+    }
+}
+// AI-GENERATED END: reactive font-scale snapshot injected through the environment

package/ios/Typography/FontScaleStore.swift

@@ -1,19 +1,58 @@
-import CoreGraphics
-
-/// 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 {
+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()
-    private init() {}
 
-    public private(set) var userScaleRate: CGFloat = 1
-    public private(set) var useOSScaleRate: Bool = true
+    @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) {
-        self.userScaleRate = userScaleRate
-        self.useOSScaleRate = useOSScaleRate
+        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/Text.swift

@@ -1,33 +1,15 @@
 import SwiftUI
 
-public func scaleSize(_ size: CGFloat, _ scaleRate: CGFloat? = nil) -> CGFloat {
-    if !FontScaleStore.shared.useOSScaleRate {
-        return size * FontScaleStore.shared.userScaleRate
-    }
-    let defaultScreenSize: CGFloat = 375
-    let maxFontScale: CGFloat = scaleRate ?? 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 fontSizeDeviceScale = size
-    var fontSizeOSScale = size
-
-
-    if deviceScale > 1 {
-        fontSizeDeviceScale = min(fontSizeDeviceScale * deviceScale, fontSizeDeviceScale + maxDeviceScale)
-    }
-
-    if fontScale > 1 {
-        fontSizeOSScale = min(fontSizeOSScale * fontScale, fontSizeOSScale * maxFontScale)
-    }
+/// Non-reactive entry point, for call sites that cannot read the environment (UIKit bridges,
+/// 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)
+}
 
-    return max(fontSizeDeviceScale, fontSizeOSScale)
+@available(*, deprecated, message: "Max font scale is fixed at 1.5; this override is no longer applied. Drop the second argument.")
+public func scaleSize(_ size: CGFloat, _ scaleRate: CGFloat?) -> CGFloat {
+    scaleSize(size)
 }
 
 public enum TypographyStyle {
@@ -119,6 +101,7 @@ public extension TypographyStyle {
 
 public struct MomoText: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
     private let content: String
     private let typography: TypographyStyle
     private let color: Color?
@@ -176,7 +159,7 @@ public struct MomoText: View {
         let isStrikethrough = strikethrough || typography.isStrikethrough
 
         var text = SwiftUI.Text(content)
-            .font(.system(size: scaleSize(typography.fontSize), weight: typography.fontWeight))
+            .font(fontScale.font(size: typography.fontSize, weight: typography.fontWeight))
             .foregroundColor(textColor)
             .strikethrough(isStrikethrough, color: textColor)
             .underline(underline, color: textColor)
@@ -187,7 +170,7 @@ public struct MomoText: View {
 
         return text
             .multilineTextAlignment(textAlign)
-            .lineSpacing(scaleSize(typography.lineHeight) - scaleSize(typography.fontSize))
+            .lineSpacing(fontScale(typography.lineHeight) - fontScale(typography.fontSize))
             .modifier(LineLimitModifier(range: lineLimitRange))
             .truncationMode(truncationMode)
             .fixedSize(horizontal: !softWrap, vertical: false)

package/ios/Typography/Typography.swift

@@ -10,98 +10,78 @@ public extension View {
 }
 
 public extension Font {
+    /// Non-reactive: resolves against the current `FontScaleStore` snapshot 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 {
-        if !FontScaleStore.shared.useOSScaleRate {
-            return Font.system(size: size * FontScaleStore.shared.userScaleRate)
-        }
-        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)
+        FontScaleStore.shared.snapshot.font(size: size)
     }
 
     // New supported typography styles
-    static let headline_default_bold = appFont(size: 24).weight(.bold)
-    static let header_m_bold = appFont(size: 18).weight(.bold)
-    static let header_default_bold = appFont(size: 16).weight(.bold)
-    static let header_default_semibold = appFont(size: 16).weight(.semibold)
-    static let header_s_semibold = appFont(size: 14).weight(.semibold)
-    static let header_xs_semibold = appFont(size: 12).weight(.semibold)
-    static let body_default_regular = appFont(size: 14).weight(.regular)
-    static let description_default_regular = appFont(size: 12).weight(.regular)
-    static let description_xs_regular = appFont(size: 10).weight(.regular)
-    static let label_default_medium = appFont(size: 14).weight(.medium)
-    static let label_s_medium = appFont(size: 12).weight(.medium)
-    static let label_xs_medium = appFont(size: 10).weight(.medium)
-    static let action_default_bold = appFont(size: 16).weight(.bold)
-    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)
+    static var headline_default_bold: Font { appFont(size: 24).weight(.bold) }
+    static var header_m_bold: Font { appFont(size: 18).weight(.bold) }
+    static var header_default_bold: Font { appFont(size: 16).weight(.bold) }
+    static var header_default_semibold: Font { appFont(size: 16).weight(.semibold) }
+    static var header_s_semibold: Font { appFont(size: 14).weight(.semibold) }
+    static var header_xs_semibold: Font { appFont(size: 12).weight(.semibold) }
+    static var body_default_regular: Font { appFont(size: 14).weight(.regular) }
+    static var description_default_regular: Font { appFont(size: 12).weight(.regular) }
+    static var description_xs_regular: Font { appFont(size: 10).weight(.regular) }
+    static var label_default_medium: Font { appFont(size: 14).weight(.medium) }
+    static var label_s_medium: Font { appFont(size: 12).weight(.medium) }
+    static var label_xs_medium: Font { appFont(size: 10).weight(.medium) }
+    static var action_default_bold: Font { appFont(size: 16).weight(.bold) }
+    static var action_s_bold: Font { appFont(size: 14).weight(.bold) }
+    static var action_xs_bold: Font { appFont(size: 12).weight(.bold) }
+    static var action_xxs_bold: Font { 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)
-    static let headline_l = appFont(size: 32).weight(.semibold)
-    static let headline_xl = appFont(size: 36).weight(.semibold)
-    static let title_default = appFont(size: 20).weight(.bold)
-    static let title_xs = appFont(size: 16).weight(.bold)
-    static let title_s = appFont(size: 18).weight(.bold)
-    static let header_default = appFont(size: 15).weight(.semibold)
-    static let header_xs = appFont(size: 12).weight(.semibold)
-    static let header_s = appFont(size: 14).weight(.semibold)
-    static let paragraph_default = appFont(size: 15).weight(.regular)
-    static let paragraph_bold = appFont(size: 15).weight(.bold)
-    static let description_default = appFont(size: 14).weight(.regular)
-    static let description_xs = appFont(size: 10).weight(.regular)
-    static let description_s = appFont(size: 12).weight(.regular)
-    static let label_default = appFont(size: 14).weight(.medium)
-    static let label_xxs = appFont(size: 8).weight(.medium)
-    static let label_xs = appFont(size: 10).weight(.medium)
-    static let label_s = appFont(size: 12).weight(.medium)
-    static let action_default = appFont(size: 16).weight(.bold)
-    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)
+    static var headline_default: Font { appFont(size: 28).weight(.semibold) }
+    static var headline_s: Font { appFont(size: 24).weight(.semibold) }
+    static var headline_l: Font { appFont(size: 32).weight(.semibold) }
+    static var headline_xl: Font { appFont(size: 36).weight(.semibold) }
+    static var title_default: Font { appFont(size: 20).weight(.bold) }
+    static var title_xs: Font { appFont(size: 16).weight(.bold) }
+    static var title_s: Font { appFont(size: 18).weight(.bold) }
+    static var header_default: Font { appFont(size: 15).weight(.semibold) }
+    static var header_xs: Font { appFont(size: 12).weight(.semibold) }
+    static var header_s: Font { appFont(size: 14).weight(.semibold) }
+    static var paragraph_default: Font { appFont(size: 15).weight(.regular) }
+    static var paragraph_bold: Font { appFont(size: 15).weight(.bold) }
+    static var description_default: Font { appFont(size: 14).weight(.regular) }
+    static var description_xs: Font { appFont(size: 10).weight(.regular) }
+    static var description_s: Font { appFont(size: 12).weight(.regular) }
+    static var label_default: Font { appFont(size: 14).weight(.medium) }
+    static var label_xxs: Font { appFont(size: 8).weight(.medium) }
+    static var label_xs: Font { appFont(size: 10).weight(.medium) }
+    static var label_s: Font { appFont(size: 12).weight(.medium) }
+    static var action_default: Font { appFont(size: 16).weight(.bold) }
+    static var action_xxs: Font { appFont(size: 10).weight(.bold) }
+    static var action_xs: Font { appFont(size: 12).weight(.bold) }
+    static var action_s: Font { appFont(size: 15).weight(.bold) }
 
     // deprecated
-    static let h1 = appFont(size: 36).weight(.semibold) //headline_xl
-    static let h2 = appFont(size: 32).weight(.semibold)
-    static let h3 = appFont(size: 28).weight(.semibold)
-    static let h4 = appFont(size: 24).weight(.semibold)
-    static let title1 = appFont(size: 20).weight(.bold)
-    static let title2 = appFont(size: 18).weight(.bold)
-    static let title3 = appFont(size: 16).weight(.bold)
-    static let headerText1 = appFont(size: 15).weight(.semibold) //header_default
-    static let headerText2 = appFont(size: 14).weight(.semibold)
-    static let headerText3 = appFont(size: 12).weight(.semibold)
-    static let paragraph = appFont(size: 15).weight(.regular) //paragraph_default
-    static let description1 = appFont(size: 14).weight(.regular)
-    static let description2 = appFont(size: 12).weight(.regular)
-    static let description3 = appFont(size: 10).weight(.regular)
-    static let label1 = appFont(size: 14).weight(.medium)
-    static let label2 = appFont(size: 12).weight(.medium)
-    static let label3 = appFont(size: 10).weight(.medium)
-    static let label4 = appFont(size: 8).weight(.medium)
-    static let action1 = appFont(size: 16).weight(.bold)
-    static let action2 = appFont(size: 15).weight(.bold)
-    static let action3 = appFont(size: 12).weight(.bold)
-    static let action4 = appFont(size: 10).weight(.bold)
+    static var h1: Font { appFont(size: 36).weight(.semibold) } //headline_xl
+    static var h2: Font { appFont(size: 32).weight(.semibold) }
+    static var h3: Font { appFont(size: 28).weight(.semibold) }
+    static var h4: Font { appFont(size: 24).weight(.semibold) }
+    static var title1: Font { appFont(size: 20).weight(.bold) }
+    static var title2: Font { appFont(size: 18).weight(.bold) }
+    static var title3: Font { appFont(size: 16).weight(.bold) }
+    static var headerText1: Font { appFont(size: 15).weight(.semibold) } //header_default
+    static var headerText2: Font { appFont(size: 14).weight(.semibold) }
+    static var headerText3: Font { appFont(size: 12).weight(.semibold) }
+    static var paragraph: Font { appFont(size: 15).weight(.regular) } //paragraph_default
+    static var description1: Font { appFont(size: 14).weight(.regular) }
+    static var description2: Font { appFont(size: 12).weight(.regular) }
+    static var description3: Font { appFont(size: 10).weight(.regular) }
+    static var label1: Font { appFont(size: 14).weight(.medium) }
+    static var label2: Font { appFont(size: 12).weight(.medium) }
+    static var label3: Font { appFont(size: 10).weight(.medium) }
+    static var label4: Font { appFont(size: 8).weight(.medium) }
+    static var action1: Font { appFont(size: 16).weight(.bold) }
+    static var action2: Font { appFont(size: 15).weight(.bold) }
+    static var action3: Font { appFont(size: 12).weight(.bold) }
+    static var action4: Font { appFont(size: 10).weight(.bold) }
 }

package/ios/native-kits.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'MoMoUIKits'
-  s.version          = '0.163.1-beta.16'
+  s.version          = '0.163.1-sp.10'
   s.summary          = 'MoMoUIKits for iOS'
   s.homepage         = 'https://momo.vn'
   s.license          = { :type => 'MIT' }
@@ -34,6 +34,7 @@ Pod::Spec.new do |s|
     "InputDropDown/**/*.{swift,m,h}",
     "InputMoney/**/*.{swift,m,h}",
     "InputOTP/**/*.{swift,m,h}",
+    "Layout/**/*.{swift,m,h}",
     "Loader/**/*.{swift,m,h}",
     "Lottie/**/*.{swift,m,h}",
     "OTPKeyboard/**/*.{swift,m,h}",

package/ios-demo/MoMoUIKitsDemo.podspec

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