@momo-kits/native-kits 0.162.30 → 0.162.31

package/ios/Application/Navigation/NavigatorManager.swift

@@ -0,0 +1,49 @@
+//
+//  NavigatorManager.swift
+//  MoMoUIKits
+//
+//  Host bridge for the native iOS edge-swipe back — the SwiftUI mirror of Compose's
+//  `ComposeNavigatorManager` (momo-app `vn.momo.compose.uikits.ComposeNavigatorManager`).
+//
+//  The kit does NOT own the swipe gesture. In the host app a kit screen lives inside a
+//  `UIHostingController` hosted by the mini-app container VC, and that VC owns the
+//  `UIScreenEdgePanGestureRecognizer`. When the swipe fires the host asks this manager
+//  whether a kit stack is mounted (`checkCanPop`) and, if so, routes the back into it
+//  (`pop` → `Navigator.onBackSafe`) instead of dismissing the whole mini-app. Standalone
+//  (no such host, e.g. the demo app) there is no edge swipe — same as Compose on iOS,
+//  whose `BackHandler` is a no-op and which relies entirely on the host.
+//
+
+import Foundation
+
+@available(iOS 16.0, *)
+public final class NavigatorManager {
+    public static let shared = NavigatorManager()
+    private init() {}
+
+    /// Stack of mounted navigators; the last one is the visible top (nested mini-apps
+    /// push more than one). Held strongly, mirroring `ComposeNavigatorManager` — entries
+    /// are released by `NavigationContainer` on disappear, not by ARC.
+    private var navigators: [Navigator] = []
+
+    /// Idempotent: SwiftUI can re-run a view's `onAppear`, and a double push would need a
+    /// matching double remove to unwind.
+    public func push(_ navigator: Navigator) {
+        guard !navigators.contains(where: { $0 === navigator }) else { return }
+        navigators.append(navigator)
+    }
+
+    /// Removes by identity rather than `removeLast` so a spurious disappear of a covered
+    /// (non-top) container can't drop the wrong navigator.
+    public func remove(_ navigator: Navigator) {
+        navigators.removeAll { $0 === navigator }
+    }
+
+    /// True while any kit stack is mounted — tells the host to route the back into the kit
+    /// instead of dismissing the mini-app. Matches `ComposeNavigatorManager.checkCanPop`:
+    /// it does not inspect stack depth; `onBackSafe` handles the at-root case itself by
+    /// asking the host to dismiss (via `composeApi`).
+    public func checkCanPop() -> Bool { !navigators.isEmpty }
+
+    public func pop() { navigators.last?.onBackSafe() }
+}

package/ios/Application/Navigation/component/NavigationFooter.swift

@@ -0,0 +1,90 @@
+//
+//  NavigationFooter.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `Footer` (navigation/StackScreen.kt): the band
+//  pinned under the screen content — surface background, S/M padding, the
+//  navigation-bar reserve, and the 6pt gradient shadow cast up onto the content.
+//
+//  Named `NavigationFooter` to coexist with the legacy `Footer` in `Screen.swift`
+//  (kept as-is for the old `Screen` path). Used by `StackScreen`.
+//
+
+import SwiftUI
+
+public struct NavigationFooter: View {
+    /// Compose's `footerComponent`: nothing renders when nil.
+    var footerComponent: (() -> AnyView)?
+    /// Current keyboard height, measured from the bottom of the screen.
+    var keyboardSize: CGFloat
+
+    public init(
+        footerComponent: (() -> AnyView)?,
+        keyboardSize: CGFloat = 0
+    ) {
+        self.footerComponent = footerComponent
+        self.keyboardSize = keyboardSize
+    }
+
+    @Environment(\.appTheme) private var theme
+
+    /// Read from the window, not from an enclosing `GeometryProxy`: the proxy's bottom
+    /// inset grows to the keyboard height while the keyboard is up.
+    static var safeAreaBottom: CGFloat {
+        UIApplication.shared.connectedScenes
+            .compactMap { ($0 as? UIWindowScene)?.keyWindow?.safeAreaInsets.bottom }
+            .first ?? 0
+    }
+
+    /// Compose's `AppNavigationBar.current` (`getNavigationBarHeight` clamps iOS to 21pt).
+    static var navigationBarInset: CGFloat { min(safeAreaBottom, 21) }
+
+    /// Compose's `bottomPadding + Spacing.S` with the keyboard down. The footer is laid
+    /// out inside the safe area, which already covers part of that gap.
+    static var bottomPadding: CGFloat {
+        max(navigationBarInset + Spacing.S - safeAreaBottom, 0)
+    }
+
+    /// Deliberately an offset and not padding: growing the footer feeds back into SwiftUI's
+    /// keyboard avoidance, so a padding-based lift never settles at the right place.
+    /// Negative lifts the band over the keyboard; positive shaves the few points by which
+    /// the safe area over-reserves compared to Compose. `FloatingContent` rides the same
+    /// amount so the FAB keeps its distance above the band.
+    ///
+    /// Natural position is `safeAreaBottom + bottomPadding` above the bottom of the screen;
+    /// Compose puts it at `(AppNavigationBar - keyboard).coerceAtLeast(0) + Spacing.S` on
+    /// top of the `imePadding()` lift — i.e. `max(navigationBar, keyboard) + Spacing.S`.
+    static func verticalOffset(keyboardSize: CGFloat) -> CGFloat {
+        (safeAreaBottom + bottomPadding) - (max(navigationBarInset, keyboardSize) + Spacing.S)
+    }
+
+    public var body: some View {
+        if let footerComponent = footerComponent {
+            VStack(alignment: .leading, spacing: 0) {
+                footerComponent()
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(.top, Spacing.S)
+            .padding(.horizontal, Spacing.M)
+            .padding(.bottom, Self.bottomPadding)
+            // Compose paints the surface all the way to the bottom of the screen; the
+            // footer's own frame stops at the safe area, so only the fill bleeds down.
+            .background(theme.colors.background.surface.ignoresSafeArea(.container, edges: .bottom))
+            .overlay(alignment: .top) { shadow }
+            .offset(y: Self.verticalOffset(keyboardSize: keyboardSize))
+        }
+    }
+
+    /// Compose offsets the shadow box by -6dp, so it lands on the content above the
+    /// footer rather than on the footer surface itself.
+    private var shadow: some View {
+        LinearGradient(
+            colors: [Color.clear, Color.black.opacity(0.05)],
+            startPoint: .top,
+            endPoint: .bottom
+        )
+        .frame(height: 6)
+        .offset(y: -6)
+        .allowsHitTesting(false)
+    }
+}

package/ios/Application/StackScreen.swift

@@ -5,7 +5,7 @@
 //  SwiftUI mirror of Compose's `StackScreen`. This is a refactor of `Screen`:
 //  the body is decomposed into the same focused pieces Compose uses — header
 //  layer, scrollable content (`StackScreenContent`), floating button
-//  (`FloatingContent`) and footer (`FooterContent`) — instead of one
+//  (`FloatingContent`) and footer (`NavigationFooter`) — instead of one
 //  monolithic, partially-duplicated view. The public init matches `Screen`
 //  so call sites (e.g. NavigationContainer's ScreenHost) can swap over.
 //
@@ -143,13 +143,8 @@ public struct StackScreen<Content: View>: View {
     // MARK: - Body
 
     public var body: some View {
-        GeometryReader { geometry in
+        GeometryReader { _ in
             let keyboardSize: CGFloat = useAvoidKeyboard ? max(keyboardHeight, 0) : 0
-            let bottomInset = min(geometry.safeAreaInsets.bottom, 21)
-            // Skip this screen's own bottom-inset reservation when hosting a footer
-            // OR a self-contained BottomTab surface (mirrors Compose's
-            // `if (options.footerComponent != null || isBottomTab) 0.dp else navigationBar`).
-            let contentBottomInset = (footer == nil && !isBottomTabRoot) ? bottomInset : 0
 
             ZStack(alignment: .top) {
                 // Background color
@@ -161,16 +156,16 @@ public struct StackScreen<Content: View>: View {
                         VStack(alignment: horizontalAlignment, spacing: 0) {
                             headerAndContent
                         }
-                        .padding(.bottom, contentBottomInset)
 
                         FloatingContent(
                             fabProps: fabProps,
-                            keyboardOffset: 0,
+                            keyboardSize: keyboardSize,
+                            hasFooter: footer != nil,
                             scrollOffset: scrollOffset
                         )
                     }
 
-                    FooterContent(footer: footer, keyboardSize: keyboardSize, bottomInset: bottomInset)
+                    NavigationFooter(footerComponent: footer, keyboardSize: keyboardSize)
                 }
 
                 // Animated search bar overlay (mirrors Compose's SearchAnimated layer).
@@ -444,17 +439,29 @@ private struct SearchAnimatedHeader: View {
 /// Mirrors Compose's `FloatingContent`: no FAB props means nothing renders.
 private struct FloatingContent: View {
     let fabProps: FabProps?
-    let keyboardOffset: CGFloat
+    let keyboardSize: CGFloat
+    /// With a footer the FAB is anchored to the footer's *layout* top, which does not move
+    /// when the band offsets itself over the keyboard — so it rides the same offset.
+    let hasFooter: Bool
     let scrollOffset: CGFloat
 
+    /// Compose keeps the FAB `Spacing.M + AppNavigationBar` above the bottom of the screen
+    /// and lifts it with `imePadding()`; here it sits `Spacing.M` above the safe area and
+    /// nothing lifts it, so the difference is applied as an offset (see NavigationFooter).
+    private var verticalOffset: CGFloat {
+        if hasFooter { return NavigationFooter.verticalOffset(keyboardSize: keyboardSize) }
+        return NavigationFooter.safeAreaBottom - NavigationFooter.navigationBarInset - keyboardSize
+    }
+
     var body: some View {
         if let fabProps = fabProps {
             FloatingButton(
                 props: fabProps,
-                keyboardOffset: keyboardOffset,
+                keyboardOffset: 0,
                 scrollOffset: scrollOffset
             )
             .padding(.horizontal, Spacing.M)
+            .offset(y: verticalOffset)
             .ignoresSafeArea(.keyboard, edges: .bottom)
         }
     }
@@ -483,19 +490,3 @@ private struct HideKeyboardOnTap: ViewModifier {
         }
     }
 }
-
-// MARK: - Footer content
-
-/// Mirrors Compose's `FooterContent`: renders the footer chrome only when a
-/// footer component is supplied. Reuses the existing `Footer` view from Screen.swift.
-private struct FooterContent: View {
-    let footer: (() -> AnyView)?
-    let keyboardSize: CGFloat
-    let bottomInset: CGFloat
-
-    var body: some View {
-        if let footerView = footer?() {
-            Footer(footerView: footerView, keyboardSize: keyboardSize, bottomInset: bottomInset)
-        }
-    }
-}

package/ios/Badge/Badge.swift

@@ -2,6 +2,7 @@ import SwiftUI
 
 public struct Badge: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
     let label: String
     let backgroundColor: Color?
     
@@ -55,7 +56,7 @@ public struct Badge: View {
     public var body: some View {
         MomoText(formatTitle(label), typography: .actionXxsBold, color: Colors.black01)
             .padding(.horizontal, Spacing.XS)
-            .frame(minWidth: scaleSize(16), minHeight: scaleSize(16))
+            .frame(minWidth: fontScale(16), minHeight: fontScale(16))
             .background(badgeColor)
             .cornerRadius(Radius.M)
             .overlay(

package/ios/Badge/BadgeRibbon.swift

@@ -174,6 +174,7 @@ public struct BadgeRibbon: View {
         )
         .frame(width: RibbonConstants.headTailWidth, height: RibbonConstants.headTailHeight)
         .rotationEffect(.degrees(180))
+        .offset(x: 1)
         .clipped()
     }
     
@@ -183,6 +184,7 @@ public struct BadgeRibbon: View {
             placeholder: AnyView(Color.clear)
         )
         .frame(width: RibbonConstants.headTailWidth, height: RibbonConstants.headTailHeight)
+        .offset(x: 1)
         .clipped()
     }
     
@@ -192,6 +194,7 @@ public struct BadgeRibbon: View {
             placeholder: AnyView(Color.clear)
         )
         .frame(width: RibbonConstants.skewTailWidth, height: RibbonConstants.skewTailHeight)
+        .offset(x: -2)
         .clipped()
     }
 }
@@ -201,6 +204,7 @@ 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(\.momoFontScale) private var fontScale
     let text: String
     let position: RibbonPosition
 
@@ -219,7 +223,7 @@ public struct RoundedBadgeRibbon: View {
     }
 
     private var measuredTextSize: CGSize {
-        let fontSize = scaleSize(TypographyStyle.labelXsMedium.fontSize)
+        let fontSize = fontScale(TypographyStyle.labelXsMedium.fontSize)
         let font = UIFont.systemFont(ofSize: fontSize, weight: .medium)
         return text.size(withAttributes: [.font: font])
     }
@@ -281,7 +285,7 @@ private struct RibbonConstants {
     static let ribbonHeight: CGFloat = 20
     static let roundHeight: CGFloat = 16
     static let skewBodyHeight: CGFloat = 16
-    static let roundRightRadius: CGFloat = 12
+    static let roundRightRadius: CGFloat = 8
     static let roundPaddingEnd: CGFloat = 6
     static let skewTailWidth: CGFloat = 8
     static let skewTailHeight: CGFloat = 16

package/ios/Button/Button.swift

@@ -133,19 +133,19 @@ public struct Button: View {
     var action: () -> Void
     var type: ButtonType
     var size: ButtonSize
-    var iconLeft: AnyView?
-    var iconRight: AnyView?
+    var iconLeft: String
+    var iconRight: String
     var isFull: Bool
     var loading: Bool
     var useTintColor: Bool
 
     public init(
-        title: String = "",
+        title: String = "Button",
         action: @escaping () -> Void,
         type: ButtonType = .primary,
         size: ButtonSize = .large,
-        iconLeft: AnyView? = nil,
-        iconRight: AnyView? = nil,
+        iconLeft: String = "",
+        iconRight: String = "",
         isFull: Bool = true,
         loading: Bool = false,
         useTintColor: Bool = true
@@ -161,38 +161,9 @@ public struct Button: View {
         self.useTintColor = useTintColor
     }
 
-    /// Mirrors Kotlin's `Button(iconLeft: String, iconRight: String, ...)`, which resolves
-    /// icons by design-system source name through the shared `Icon` component rather than
-    /// a caller-supplied view. `iconLeft` is required here (unlike Kotlin's `= ""` default)
-    /// solely to keep this initializer unambiguous alongside the `AnyView`-based one above —
-    /// pass `""` explicitly for an icon-right-only button.
-    public init(
-        title: String = "Button",
-        action: @escaping () -> Void,
-        type: ButtonType = .primary,
-        size: ButtonSize = .large,
-        iconLeft: String,
-        iconRight: String = "",
-        isFull: Bool = true,
-        loading: Bool = false,
-        useTintColor: Bool = true
-    ) {
-        self.init(
-            title: title,
-            action: action,
-            type: type,
-            size: size,
-            iconLeft: iconLeft.isEmpty ? nil : AnyView(Icon(source: iconLeft)),
-            iconRight: iconRight.isEmpty ? nil : AnyView(Icon(source: iconRight)),
-            isFull: isFull,
-            loading: loading,
-            useTintColor: useTintColor
-        )
-    }
-
-    private func shouldLoadingOnLeft(_ left: AnyView?, _ right: AnyView?) -> Bool {
-        let hasLeft = left != nil
-        let hasRight = right != nil
+    private func shouldLoadingOnLeft(_ left: String, _ right: String) -> Bool {
+        let hasLeft = !left.isEmpty
+        let hasRight = !right.isEmpty
 
         switch (hasLeft, hasRight) {
         case (false, false): return true
@@ -217,27 +188,13 @@ public struct Button: View {
             }
         }) {
             HStack(spacing: size.iconSpacing) {
-                if loading && loadingOnLeft {
-                    LottieView(name: "lottie_circle_loader", loopMode: .loop)
-                        .frame(width: size.iconSize, height: size.iconSize)
-                        .colorMultiply(fg)
-
-                } else if let iconLeft = iconLeft {
-                    tintedIcon(iconLeft, color: fg)
-                }
+                renderIcon(icon: iconLeft, forceLoading: loading && loadingOnLeft, textColor: fg)
 
                 MomoText(title, typography: size.typographyStyle, color: fg)
                     .lineLimit(1)
                     .truncationMode(.tail)
 
-                if loading && !loadingOnLeft {
-                    LottieView(name: "lottie_circle_loader", loopMode: .loop)
-                        .frame(width: size.iconSize, height: size.iconSize)
-                        .colorMultiply(fg)
-
-                } else if let iconRight = iconRight {
-                    tintedIcon(iconRight, color: fg)
-                }
+                renderIcon(icon: iconRight, forceLoading: loading && !loadingOnLeft, textColor: fg)
             }
             .frame(maxWidth: isFull ? .infinity : nil)
             .padding(.horizontal, size.padding)
@@ -249,20 +206,24 @@ public struct Button: View {
             border: border,
             borderWidth: borderWidth,
             radius: size.radius,
-            height: size.height
+            height: size.height,
+            isFull: isFull
         ))
         .disabled(!isEnabled)
     }
 
+    /// Mirrors Kotlin `RenderIcon`: the loader replaces the icon slot entirely, and
+    /// `useTintColor == false` leaves the icon at its own colors.
     @ViewBuilder
-    private func tintedIcon(_ icon: AnyView, color: Color) -> some View {
-        if useTintColor {
-            icon
-                .frame(width: size.iconSize, height: size.iconSize)
-                .colorMultiply(color)
-        } else {
-            icon
+    private func renderIcon(icon: String, forceLoading: Bool, textColor: Color) -> some View {
+        let color: Color? = useTintColor ? textColor : nil
+
+        if forceLoading {
+            LottieView(name: "lottie_circle_loader", loopMode: .loop)
                 .frame(width: size.iconSize, height: size.iconSize)
+                .colorMultiply(color ?? Colors.black01)
+        } else if !icon.isEmpty {
+            Icon(source: icon, size: size.iconSize, color: color)
         }
     }
 }
@@ -277,11 +238,13 @@ private struct ButtonPressFeedbackStyle: ButtonStyle {
     let borderWidth: CGFloat
     let radius: CGFloat
     let height: CGFloat
+    let isFull: Bool
 
     func makeBody(configuration: Configuration) -> some View {
         let pressed = configuration.isPressed && isEnabled
 
         configuration.label
+            .modifier(HugContentOnLegacyOS(isFull: isFull))
             .opacity(pressed ? 0.5 : 1)
             .background(
                 RoundedRectangle(cornerRadius: radius)
@@ -297,3 +260,20 @@ private struct ButtonPressFeedbackStyle: ButtonStyle {
             .animation(.easeInOut(duration: 0.1), value: pressed)
     }
 }
+
+/// `ButtonStyleConfiguration.Label` is greedy on iOS 16 and earlier — it accepts
+/// the full proposed width, so the background drawn in `makeBody` stretches past
+/// the content even when `isFull == false`. iOS 17 fixed the label to hug its
+/// content, so only legacy OSes need the `fixedSize` clamp (kept off on 17+ to
+/// preserve tail truncation of long titles).
+private struct HugContentOnLegacyOS: ViewModifier {
+    let isFull: Bool
+
+    func body(content: Content) -> some View {
+        if #available(iOS 17.0, *) {
+            content
+        } else {
+            content.fixedSize(horizontal: !isFull, vertical: false)
+        }
+    }
+}

package/ios/Chip/Chip.swift

@@ -3,6 +3,7 @@ import Foundation
 
 public struct Chip: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
     public enum ChipSize { case small, large }
 
     public struct Dimensions {
@@ -54,11 +55,11 @@ public struct Chip: View {
         let dims = (size == .small) ? Self.Small : Self.Large
         // Mirrors Compose's `scaleSize(...)` on every chip dimension so it responds
         // to Dynamic Type scaling the same way the rest of the kit does.
-        let height = scaleSize(dims.height)
-        let horizontal = scaleSize(dims.horizontal)
-        let iconSize = scaleSize(dims.iconSize)
-        let iconSpacing = scaleSize(dims.iconSpacing)
-        let radius = scaleSize(Radius.L)
+        let height = fontScale(dims.height)
+        let horizontal = fontScale(dims.horizontal)
+        let iconSize = fontScale(dims.iconSize)
+        let iconSpacing = fontScale(dims.iconSpacing)
+        let radius = fontScale(Radius.L)
 
         let bg: Color = {
             if selected { return theme.colors.background.selected }

package/ios/Icon/Icon.swift

@@ -26,17 +26,24 @@ let iconSources: [String: IconSource] = loadIconSources()
 // Icons that must never be tinted (mirror Compose `noThemeIcons`)
 let noThemeIcons: [String] = ["ic_round_momo_tiny"]
 
+// Compose defaults `color` to the theme text color while `color = null` means "no tint".
+// Swift can't tell an omitted argument from an explicit `nil`, so the default is this
+// unrepresentable sentinel: omitted -> theme text color, `nil` -> untinted.
+public let iconThemeColor = Color(.sRGB, red: -1, green: -1, blue: -1, opacity: -1)
+
 // Icon ViewModel
 public struct Icon: View {
+    @Environment(\.appTheme) private var theme
+
     var source: String
     var size: CGFloat
     var color: Color?
     var accessibilityLabel: String?
-    
+
     public init(
             source: String,
             size: CGFloat = 24,
-            color: Color? = nil,
+            color: Color? = iconThemeColor,
             accessibilityLabel: String? = nil
         ) {
             self.source = source
@@ -46,9 +53,11 @@ public struct Icon: View {
         }
 
     public var body: some View {
-        if let uri = iconSources[source]?.uri {
+        // Mirror Compose: an https source is used as-is, anything else is a key into icon.json
+        if let uri = source.contains("https") ? source : iconSources[source]?.uri {
+            let requestedColor = color == iconThemeColor ? theme.colors.text.default : color
             // Mirror Compose: certain icons (e.g. branded glyphs) are never tinted
-            let resolvedColor = noThemeIcons.contains(source) ? nil : color
+            let resolvedColor = noThemeIcons.contains(source) ? nil : requestedColor
             ImageView(uri, color: resolvedColor)
                 .frame(width: size, height: size)
                 // Mirrors Compose's auto-generated `contentDescription = "img|$iconUrl"`

package/ios/Input/ErrorView.swift

@@ -9,6 +9,7 @@ import SwiftUI
 
 public struct ErrorView: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
 
     public var errorMessage: String
     public var errorSpacing: Bool
@@ -27,7 +28,7 @@ public struct ErrorView: View {
     public var body: some View {
         if !errorMessage.isEmpty || !hintText.isEmpty {
             HStack(alignment: .top, spacing: 4) {
-                Icon(source: "ic_error", size: scaleSize(16), color: displayColor())
+                Icon(source: "ic_error", size: fontScale(16), color: displayColor())
                 MomoText(
                     displayText(),
                     typography: .descriptionDefaultRegular,

package/ios/Input/Input.swift

@@ -4,6 +4,7 @@ import Combine
 
 public struct Input: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
     @Binding public var text: String
     
     public var placeholder: String
@@ -163,7 +164,7 @@ public struct Input: View {
                             SecureInputField(
                                 text: $text,
                                 keyboardType: keyboardType,
-                                fontSize: scaleSize(14),
+                                fontSize: fontScale(14),
                                 fontWeight: fontWeight == .bold ? .bold : .regular,
                                 textColor: UIColor(getTextColor()),
                                 cursorColor: UIColor(theme.colors.primary),
@@ -189,6 +190,12 @@ public struct Input: View {
                             .onAppear {
                                 if autofocus { isFieldFocused = true }
                             }
+                            // SwiftUI reads a TextField's UIKit input traits only when it
+                            // builds the backing UITextField, so a later `keyboardType`
+                            // change is silently dropped. The secure path can call
+                            // `reloadInputViews()` in `updateUIView`; here the only lever
+                            // is to force a rebuild.
+                            .id(keyboardType.rawValue)
                         }
                     }
                     
@@ -230,7 +237,7 @@ public struct Input: View {
                     }
                 }
                 .padding(.horizontal, Spacing.M)
-                .frame(height: scaleSize(size == .small ? 48 : 56, 1.1))
+                .frame(height: fontScale(size == .small ? 48 : 56))
                 .background(
                     RoundedRectangle(cornerRadius: Radius.S)
                         .fill(theme.colors.background.surface)

package/ios/Input/InputPhoneNumber.swift

@@ -8,6 +8,7 @@
 import SwiftUI
 public struct InputPhoneNumber: View {
     @Environment(\.appTheme) private var theme
+    @Environment(\.momoFontScale) private var fontScale
     @Binding public var text: String
     
     public var placeholder: String
@@ -143,7 +144,7 @@ public struct InputPhoneNumber: View {
                 }
             }
             .padding(.horizontal, Spacing.M)
-            .frame(height: scaleSize(size == .small ? 48 : 56, 1.1))
+            .frame(height: fontScale(size == .small ? 48 : 56))
             .background(
                 RoundedRectangle(cornerRadius: Radius.S)
                     .fill(theme.colors.background.surface)

package/ios/Input/InputSearch.swift

@@ -104,6 +104,7 @@ 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
@@ -214,7 +215,7 @@ public struct InputSearch: View {
                             } else {
                                 Text(placeholder)
                                     .foregroundColor(disabled ? theme.colors.text.disable : theme.colors.text.hint)
-                                    .font(.system(size: scaleSize(14), weight: fontWeight))
+                                    .font(.system(size: fontScale(14), weight: fontWeight))
                                     .ignoreBoldTextSetting()
                             }
                         }
@@ -231,7 +232,7 @@ public struct InputSearch: View {
                         }, onCommit: {})
                         .disabled(disabled)
                         .foregroundColor(disabled ? theme.colors.text.disable : theme.colors.text.default)
-                        .font(.system(size: scaleSize(14), weight: fontWeight))
+                        .font(.system(size: fontScale(14), weight: fontWeight))
                         .ignoreBoldTextSetting()
                         .keyboardType(keyboardType)
                         .applyCursorColor(theme.colors.primary)

package/ios/Input/InputTextArea.swift

@@ -37,7 +37,12 @@ struct UITextViewWrapper: UIViewRepresentable {
         }
         uiView.textColor = UIColor(textColor)
         uiView.tintColor = UIColor(cursorColor)
-        uiView.font = UIFont.systemFont(ofSize: scaleSize(16), weight: fontWeight == .bold ? .bold : .regular)
+        // 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.isEditable = !disabled
     }