@momo-kits/native-kits 0.168.1-beta.2-debug → 0.168.1-beta.24-debug

package/ios/Application/DesignSystemKits.swift

@@ -0,0 +1,163 @@
+// 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()
+    // AI-GENERATED START: republish the font scale when the window scene is resized (iPhone Duo fold/unfold)
+    @Published public private(set) var windowShortSide: CGFloat = DesignSystemKits.currentWindowShortSide()
+    private var geometryObservations: [ObjectIdentifier: NSKeyValueObservation] = [:]
+    // AI-GENERATED END: republish the font scale when the window scene is resized (iPhone Duo fold/unfold)
+
+    private init() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(contentSizeCategoryDidChange),
+            name: UIContentSizeCategory.didChangeNotification,
+            object: nil
+        )
+        // AI-GENERATED START: republish the font scale when the window scene is resized (iPhone Duo fold/unfold)
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(sceneDidActivate(_:)),
+            name: UIScene.didActivateNotification,
+            object: nil
+        )
+        onMain {
+            UIApplication.shared.connectedScenes
+                .compactMap { $0 as? UIWindowScene }
+                .forEach(self.observeGeometry(of:))
+        }
+        // AI-GENERATED END: republish the font scale when the window scene is resized (iPhone Duo fold/unfold)
+    }
+
+    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,
+            // AI-GENERATED START: republish the font scale when the window scene is resized (iPhone Duo fold/unfold)
+            windowShortSide: windowShortSide
+            // AI-GENERATED END: republish the font scale when the window scene is resized (iPhone Duo fold/unfold)
+        )
+    }
+
+    @objc private func contentSizeCategoryDidChange() {
+        let next = Self.currentOsFontScale()
+        guard next != osFontScale else { return }
+        osFontScale = next
+    }
+
+    // AI-GENERATED START: republish the font scale when the window scene is resized (iPhone Duo fold/unfold)
+    @objc private func sceneDidActivate(_ notification: Notification) {
+        guard let scene = notification.object as? UIWindowScene else { return }
+        observeGeometry(of: scene)
+        refreshWindowShortSide()
+    }
+
+    private func observeGeometry(of scene: UIWindowScene) {
+        guard #available(iOS 16.0, *) else { return }
+        let key = ObjectIdentifier(scene)
+        guard geometryObservations[key] == nil else { return }
+        geometryObservations[key] = scene.observe(\.effectiveGeometry, options: [.new]) { [weak self] _, _ in
+            // The window is resized after the scene geometry, so read it on the next turn.
+            DispatchQueue.main.async { self?.refreshWindowShortSide() }
+        }
+    }
+
+    private func refreshWindowShortSide() {
+        let next = Self.currentWindowShortSide()
+        guard next > 0, next != windowShortSide else { return }
+        windowShortSide = next
+    }
+
+    /// UIScreen.main stays on one display on iPhone Duo, so measure the foreground window instead.
+    static func currentWindowShortSide() -> CGFloat {
+        guard Thread.isMainThread else {
+            return min(UIScreen.main.bounds.width, UIScreen.main.bounds.height)
+        }
+        let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+        let scene = scenes.first { $0.activationState == .foregroundActive } ?? scenes.first
+        let window = scene?.windows.first { $0.isKeyWindow } ?? scene?.windows.first
+        let size: CGSize
+        if let window, window.bounds.width > 0 {
+            size = window.bounds.size
+        } else if let scene {
+            size = scene.coordinateSpace.bounds.size
+        } else {
+            size = UIScreen.main.bounds.size
+        }
+        return min(size.width, size.height)
+    }
+    // AI-GENERATED END: republish the font scale when the window scene is resized (iPhone Duo fold/unfold)
+
+    /// 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/Extensions/Color++.swift

@@ -4,16 +4,14 @@ import Foundation
 private final class MoMoUIKitsBundleToken {}
 
 enum MoMoUIKitsResources {
+
     static let bundle: Bundle = {
         let bundleName = "MoMoUIKitsResources"
         let tokenBundle = Bundle(for: MoMoUIKitsBundleToken.self)
-        let frameworkBundle = Bundle(identifier: "org.cocoapods.MoMoUIKits")
         let candidates = [
             Bundle.main.resourceURL,
             tokenBundle.resourceURL,
-            tokenBundle.bundleURL,
-            frameworkBundle?.resourceURL,
-            frameworkBundle?.bundleURL
+            tokenBundle.bundleURL
         ]
 
         for candidate in candidates {

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/Layout/ScreenLayout.swift

@@ -32,6 +32,9 @@ public struct ScreenLayout: Equatable {
     public let width: CGFloat
     public let height: CGFloat
     public let isIPhoneDuo: Bool
+    /// iPhone Duo folded or not, whatever the window size (its hinge, or the outer display's one-sided strip);
+    /// drives popups, modal and bottom sheet.
+    public let isDuoDevice: Bool
     public let insets: EdgeInsets
     public let insetLeft: CGFloat
     public let insetRight: CGFloat
@@ -68,8 +71,16 @@ enum DuoMetrics {
     // (x 550–643 of 669, clock digits centered on y 47); its reserved region is taller than the glyphs.
     static let innerStatusBarCenterY: CGFloat = 47
     static let innerStatusBarWidth: CGFloat = 120
-    // Widest short side of any single-display iPhone.
-    static let iPhoneMaxShortSide: CGFloat = 440
+    // Host app's iOS 26 tab bar on the inner display in portrait: a 62pt glass pill sized to its tabs,
+    // QR as a 62pt platter beside it, ≥ 20pt from the sides, 13pt into the home indicator inset.
+    static let floatingTabBarHeight: CGFloat = 62
+    static let floatingTabBarMargin: CGFloat = 20
+    static let floatingTabBarInsetOverlap: CGFloat = 13
+    // Width of a system alert on the inner display, in both orientations.
+    static let modalMaxWidth: CGFloat = 440
+    // Fits a PopupNotify with image, scrolled description and actions at the max width (RN
+    // Application/device.ts); taller content scrolls instead of filling the inner display.
+    static let modalMaxHeight: CGFloat = 640
 }
 
 enum HeaderMetrics {
@@ -104,15 +115,17 @@ extension ScreenLayout {
         size: CGSize,
         insets: EdgeInsets,
         reservedRegions: [CGRect] = ReservedRegions.current,
-        isPhone: Bool = isPhoneIdiom
+        isPhone: Bool = isPhoneIdiom,
+        isFoldable: Bool = FoldableDevice.isFoldable(measuredIn: keyWindow)
     ) -> ScreenLayout {
         let width = size.width
         let height = size.height
+        let isDuoDevice = isPhone && isFoldable
         var (headerHeight, headerStatusBarHeight) = headerGeometry(topInset: insets.top, isPhone: isPhone)
         let isDuo = isPhone && isIPhoneDuoWindow(width: width, height: height, insets: insets)
         guard isDuo else {
             return ScreenLayout(
-                width: width, height: height, isIPhoneDuo: false, insets: insets,
+                width: width, height: height, isIPhoneDuo: false, isDuoDevice: isDuoDevice, insets: insets,
                 insetLeft: 0, insetRight: 0, contentWidth: width,
                 headerHeight: headerHeight, headerStatusBarHeight: headerStatusBarHeight, sideBar: nil,
                 statusBarClearance: nil
@@ -171,8 +184,10 @@ extension ScreenLayout {
             )
         }
 
+        // the outer display reports no hinge; its one-sided strip still gives it away
         return ScreenLayout(
-            width: width, height: height, isIPhoneDuo: true, insets: insets,
+            width: width, height: height, isIPhoneDuo: true,
+            isDuoDevice: isDuoDevice || insets.leading != insets.trailing, insets: insets,
             insetLeft: insets.leading, insetRight: insets.trailing,
             contentWidth: width - insets.leading - insets.trailing,
             headerHeight: headerHeight, headerStatusBarHeight: headerStatusBarHeight, sideBar: sideBar,
@@ -249,15 +264,54 @@ extension ScreenLayout {
     public var duoTopInset: CGFloat {
         max(insets.top, height > width ? max(insets.leading, insets.trailing) * 2 : 0)
     }
+
+    /// Room for a dialog on iPhone Duo: inside the safe area, so clear of the side toolbar strip, and
+    /// capped so it stays a dialog on the inner display.
+    var duoModalMaxWidth: CGFloat {
+        min(width - insets.leading - insets.trailing - Spacing.XL * 2, DuoMetrics.modalMaxWidth)
+    }
+
+    var duoModalMaxHeight: CGFloat {
+        min(height - insets.top - insets.bottom - Spacing.XL * 2, DuoMetrics.modalMaxHeight)
+    }
 }
 
-/// Port of RN `device.ts` `isIPhoneDuo()`: UIScreen stays on the outer display, so this
-/// still matches when Split View narrows the window. Used by popups and overlays.
+/// Snapshot for call sites without `\.screenLayout`; not reactive. `windowSize` is ignored,
+/// kept for host call sites.
 public func isIPhoneDuoDevice(windowSize: CGSize? = nil) -> Bool {
     guard isPhoneIdiom else { return false }
-    let screen = UIScreen.main.bounds.size
-    let window = windowSize ?? keyWindow?.bounds.size ?? screen
-    return max(min(screen.width, screen.height), min(window.width, window.height)) > DuoMetrics.iPhoneMaxShortSide
+    let insets = keyWindow?.safeAreaInsets
+    return FoldableDevice.isFoldable(measuredIn: keyWindow) || insets.map { $0.left != $0.right } == true
+}
+
+/// Apple's foldable check (as the host's `SideTabRailView.isFoldableDevice`): only a device with a
+/// hinge reports a `.division` region, inactive while flat but still there. Screen size cannot tell
+/// it apart from a large iPhone in landscape or a narrowed window.
+enum FoldableDevice {
+    // a hinge never goes away, so a positive answer is kept
+    private static var isKnownFoldable = false
+
+    static func isFoldable(measuredIn view: UIView?) -> Bool {
+        if isKnownFoldable { return true }
+        // compiled out on SDKs older than iOS 27.1 (UIKit 9127.0.85.28)
+        #if canImport(UIKit, _version: 9127.0.85.28)
+        guard #available(iOS 27.1, *), let view, view.window != nil || view is UIWindow else { return false }
+        isKnownFoldable = !view.reservedRegions(kind: .division, options: .includeInactive).isEmpty
+        #endif
+        return isKnownFoldable
+    }
+
+    /// Catches the hinge when the regions were read too early (before the window had them).
+    static func observe(in view: UIView) {
+        #if canImport(UIKit, _version: 9127.0.85.28)
+        guard #available(iOS 27.1, *) else { return }
+        view.addInteraction(UIHingeInteraction { _, update in
+            guard update.hinge != nil, !isKnownFoldable else { return }
+            isKnownFoldable = true
+            NotificationCenter.default.post(name: ReservedRegions.didChange, object: nil)
+        })
+        #endif
+    }
 }
 
 // MARK: - Reserved regions
@@ -282,6 +336,7 @@ private final class ReservedRegionsProbe: UIView {
     override init(frame: CGRect) {
         super.init(frame: frame)
         isUserInteractionEnabled = false
+        FoldableDevice.observe(in: self)
     }
 
     required init?(coder: NSCoder) { nil }