@momo-kits/native-kits 0.162.2-beta.1 → 0.162.2-test.1

package/ios/Typography/Text.swift

@@ -8,30 +8,23 @@ public func scaleSize(_ size: CGFloat, _ scaleRate: CGFloat? = nil) -> CGFloat {
     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 fontSizeUserScale = size
+    var fontSizeOSScale = size
+
 
     if deviceScale > 1 {
         fontSizeDeviceScale = min(fontSizeDeviceScale * deviceScale, fontSizeDeviceScale + maxDeviceScale)
     }
 
-    if MomoFontScale.shared.followOSScale {
-        // Follow OS font scale (capped). User ratio is ignored in this mode.
-        let defaultFont = UIFont.systemFont(ofSize: UIFont.labelFontSize)
-        let scaledFont = UIFontMetrics.default.scaledFont(for: defaultFont)
-        let fontScale = scaledFont.pointSize / defaultFont.pointSize
-        if fontScale > 1 {
-            fontSizeUserScale = min(fontSizeUserScale * fontScale, fontSizeUserScale * maxFontScale)
-        }
-    } else {
-        // Custom in-app ratio. OS font scale is ignored.
-        let ratio = MomoFontScale.shared.ratio
-        if ratio > 1 {
-            fontSizeUserScale = fontSizeUserScale * ratio
-        }
+    if fontScale > 1 {
+        fontSizeOSScale = min(fontSizeOSScale * fontScale, fontSizeOSScale * maxFontScale)
     }
 
-    return max(fontSizeDeviceScale, fontSizeUserScale)
+    return max(fontSizeDeviceScale, fontSizeOSScale)
 }
 
 public enum TypographyStyle {
@@ -125,9 +118,6 @@ public struct MomoText: View {
     private let content: String
     private let typography: TypographyStyle
     private let color: Color
-    // Observe so the text re-renders immediately when the user changes the
-    // font-size setting (live update, no app restart).
-    @ObservedObject private var fontScale = MomoFontScale.shared
 
     public init(
         _ content: String,

package/ios/Typography/Typography.swift

@@ -1,13 +1,29 @@
 import SwiftUI
 
 public extension Font {
-    // Shares the same scaling logic as `scaleSize` so it honors the user's
-    // font-size preference (follow-OS vs in-app ratio).
-    // NOTE: the `static let` constants below are evaluated once on first
-    // access, so they reflect the setting at launch but do not live-update.
-    // Components that need live updates should use `MomoText` / `scaleSize`.
     static func appFont(size: CGFloat) -> Font {
-        return Font.system(size: scaleSize(size))
+        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)
     }
     
     // New supported typography styles

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.162.2-beta.1",
+  "version": "0.162.2-test.1",
   "private": false,
   "dependencies": {},
   "devDependencies": {},

package/ios/Typography/MomoFontScale.swift

@@ -1,36 +0,0 @@
-import SwiftUI
-
-/// Process-wide holder for the user's in-app font-size preference.
-///
-/// `momo-native-kits` is a UI library; it does not read persistent storage
-/// itself. The host app (momo-app) reads the persisted setting from the shared
-/// Observable Storage and pushes it here at launch and on every change via
-/// `update(followOSScale:ratio:)`. All native typography (`scaleSize`,
-/// `Font.appFont`, `MomoText`) reads from this single source so the three
-/// render stacks (RN / Compose / SwiftUI) stay in sync.
-///
-/// Live update: `MomoText` observes this object, so changing the setting
-/// re-renders typed text immediately. Views built from the `Font.appFont`
-/// static constants pick up the value at launch (static `let` is evaluated
-/// once); making those live would require turning them into functions.
-public final class MomoFontScale: ObservableObject {
-    public static let shared = MomoFontScale()
-
-    /// When true, follow the OS font scale (capped). `ratio` is ignored.
-    @Published public private(set) var followOSScale: Bool = false
-
-    /// In-app font-size ratio (e.g. 1.0 / 1.1 / 1.2). Ignored when
-    /// `followOSScale` is true.
-    @Published public private(set) var ratio: CGFloat = 1
-
-    private init() {}
-
-    public func update(followOSScale: Bool, ratio: CGFloat) {
-        if self.followOSScale != followOSScale {
-            self.followOSScale = followOSScale
-        }
-        if self.ratio != ratio {
-            self.ratio = ratio
-        }
-    }
-}