@momo-kits/native-kits 0.167.1-duo.3-debug → 0.167.1-duo.4

package/ios/Application/StackScreen.swift

@@ -104,9 +104,6 @@ public struct StackScreen<Content: View>: View {
     @State private var isBottomTabRoot: Bool = false
 
     @Environment(\.applicationEnvironment) private var appEnv
-    @Environment(\.screenLayout) private var layout
-    @Environment(\.duoTabBarInsets) private var duoTabBarInsets
-    @State private var footerHeight: CGFloat = 0
 
     // Auto-tracking state (mirrors Compose's `remember { ScreenTrackingState() }` +
     // the once-computed push/back `action`).
@@ -128,30 +125,6 @@ public struct StackScreen<Content: View>: View {
 
     private static var headerHeight: CGFloat { 52 }
 
-    private var toolkit: (data: HeaderRightData?, tintColor: Color?)? { toolkitHeaderRight(headerRight) }
-
-    private var showsSideBar: Bool {
-        layout.sideBar != nil && headerType != .none && !isBottomTabRoot && (goBack != nil || toolkit != nil)
-    }
-
-    /// iPhone Duo: content scrolls under a glass header instead of starting below it.
-    private var useDuoGlass: Bool {
-        layout.sideBar != nil && headerType != .none && animatedHeader == nil
-            && inputSearchProps == nil && !headerTransparent && !fullScreenContent
-    }
-
-    /// Height the footer, tab bar or home indicator takes from the bottom of the window.
-    private var bottomBarsHeight: CGFloat {
-        if footer != nil { return footerHeight + NavigationFooter.safeAreaBottom }
-        if duoTabBarInsets.sideBarReserve > 0 { return duoTabBarInsets.sideBarReserve - Spacing.XL }
-        return NavigationFooter.navigationBarInset
-    }
-
-    /// Keyboard frames are in screen coordinates; UIScreen stays on the outer display on iPhone Duo.
-    private var keyboardReferenceHeight: CGFloat {
-        layout.isIPhoneDuo ? layout.height : UIScreen.main.bounds.height
-    }
-
     /// Extra top space reserved inside the content so the animated search bar has
     /// room below the header at scroll 0; it shrinks to 0 as the bar slides up.
     private var animatedSearchInset: CGFloat {
@@ -190,18 +163,9 @@ public struct StackScreen<Content: View>: View {
                             hasFooter: footer != nil,
                             scrollOffset: scrollOffset
                         )
-                        .padding(.bottom, footer == nil ? duoTabBarInsets.overlay : 0)
                     }
 
                     NavigationFooter(footerComponent: footer, keyboardSize: keyboardSize)
-                        .padding(.bottom, duoTabBarInsets.overlay)
-                        .background(
-                            GeometryReader { proxy in
-                                Color.clear
-                                    .onAppear { footerHeight = proxy.size.height }
-                                    .onChange(of: proxy.size.height) { footerHeight = $0 }
-                            }
-                        )
                 }
 
                 // Animated search bar overlay (mirrors Compose's SearchAnimated layer).
@@ -212,24 +176,7 @@ public struct StackScreen<Content: View>: View {
                         hiddenBack: !isBack,
                         hasHeaderRight: headerRight != nil,
                         headerRightWidth: headerRightWidth,
-                        headerHeight: Self.headerHeight,
-                        useSideBar: layout.sideBar != nil,
-                        hasToolkit: toolkit != nil
-                    )
-                }
-
-                if showsSideBar, let sideBar = layout.sideBar {
-                    HeaderSideBar(
-                        sideBar: sideBar,
-                        goBack: goBack,
-                        toolkit: toolkit,
-                        headerColor: getHeaderColor(
-                            isAnimated: animatedHeader != nil,
-                            isSurface: animatedHeader?.isSurface ?? true,
-                            opacity: scrollOpacity,
-                            tintColor: tintColor
-                        ),
-                        bottomInset: bottomBarsHeight
+                        headerHeight: Self.headerHeight
                     )
                 }
             }
@@ -244,7 +191,7 @@ public struct StackScreen<Content: View>: View {
                 guard useAvoidKeyboard,
                       let endFrame = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else { return }
                 withAnimation(.easeOut(duration: 0.25)) {
-                    keyboardHeight = keyboardReferenceHeight - endFrame.origin.y
+                    keyboardHeight = UIScreen.main.bounds.height - endFrame.origin.y
                 }
             }
             // Mirrors Compose's `hideKeyboardOnTap()`: a simultaneous gesture so
@@ -299,25 +246,15 @@ public struct StackScreen<Content: View>: View {
                     scrollOffset: $scrollOffset,
                     scrollToTopCallback: scrollToTopCallback,
                     animatedSearchInset: animatedSearchInset,
-                    bottomInset: duoTabBarInsets.overlay,
                     content: { animatedHeroBody(animatedHeader) }
                 )
                 .edgesIgnoringSafeArea(.all)
 
                 header
                     .background(
-                        Group {
-                            if layout.sideBar != nil {
-                                // glass shows once the banner has scrolled under the header
-                                Color.clear.modifier(DuoBarMaterial(
-                                    shape: Rectangle(),
-                                    visible: scrollOffset > heroGlassStart(animatedHeader)
-                                ))
-                            } else {
-                                Colors.black01.opacity(scrollOpacity)
-                            }
-                        }
-                        .edgesIgnoringSafeArea([.top, .horizontal])
+                        Colors.black01
+                            .opacity(scrollOpacity)
+                            .edgesIgnoringSafeArea(.top)
                     )
                     .zIndex(100)
             }
@@ -334,34 +271,9 @@ public struct StackScreen<Content: View>: View {
                     )
                     .zIndex(100)
 
-                StackScreenContent(scrollable: scrollable, scrollOffset: $scrollOffset, scrollToTopCallback: scrollToTopCallback, animatedSearchInset: animatedSearchInset, bottomInset: duoTabBarInsets.overlay, content: { duoInsetContent })
+                StackScreenContent(scrollable: scrollable, scrollOffset: $scrollOffset, scrollToTopCallback: scrollToTopCallback, animatedSearchInset: animatedSearchInset, content: content)
                     .edgesIgnoringSafeArea(.all)
             }
-        } else if useDuoGlass {
-            ZStack(alignment: .top) {
-                DuoScrollGradient(
-                    scrollOffset: scrollOffset,
-                    headerHeight: layout.headerHeight,
-                    extended: headerType == .extended
-                )
-
-                StackScreenContent(
-                    scrollable: scrollable,
-                    scrollOffset: $scrollOffset,
-                    scrollToTopCallback: scrollToTopCallback,
-                    topInset: layout.headerHeight - layout.insets.top,
-                    bottomInset: duoTabBarInsets.overlay,
-                    content: content
-                )
-
-                header
-                    .background(
-                        Color.clear
-                            .modifier(DuoBarMaterial(shape: Rectangle(), visible: scrollOffset > 0))
-                            .edgesIgnoringSafeArea([.top, .horizontal])
-                    )
-                    .zIndex(100)
-            }
         } else {
             header
                 .background(
@@ -371,40 +283,28 @@ public struct StackScreen<Content: View>: View {
                         headerTransparent: headerTransparent,
                         fullScreenContent: fullScreenContent
                     )
-                    .edgesIgnoringSafeArea([.top, .horizontal])
+                    .edgesIgnoringSafeArea(.top)
                 )
 
-            StackScreenContent(scrollable: scrollable, scrollOffset: $scrollOffset, scrollToTopCallback: scrollToTopCallback, animatedSearchInset: animatedSearchInset, bottomInset: duoTabBarInsets.overlay, content: content)
+            StackScreenContent(scrollable: scrollable, scrollOffset: $scrollOffset, scrollToTopCallback: scrollToTopCallback, animatedSearchInset: animatedSearchInset, content: content)
         }
     }
 
-    /// Edge-to-edge branches lay out outside the safe area; iPhone Duo content still keeps
-    /// clear of the side strips, as RN's Screen does.
-    private var duoInsetContent: some View {
-        content()
-            .padding(.leading, layout.insetLeft)
-            .padding(.trailing, layout.insetRight)
-    }
-
-    private func heroGlassStart(_ animatedHeader: AnimatedHeader) -> CGFloat {
-        max(layout.width / animatedHeader.aspectRatio.value - layout.headerHeight, 0)
-    }
-
     /// Hero image + body for an animated header. The image fills the width at its
     /// aspect-ratio height; the body is offset below the header band so it overlaps
     /// the lower part of the image (mirrors Compose's image box + padded content).
     @ViewBuilder
     private func animatedHeroBody(_ animatedHeader: AnimatedHeader) -> some View {
-        let width = layout.width
+        let width = UIScreen.main.bounds.width
         let imageHeight = width / animatedHeader.aspectRatio.value
-        let contentTopInset = layout.headerHeight + layoutOffset
+        let contentTopInset = safeAreaTopInset() + HEADER_HEIGHT + layoutOffset
 
         ZStack(alignment: .top) {
             animatedHeader.composable(scrollOffset)
                 .frame(width: width, height: imageHeight)
                 .clipped()
 
-            duoInsetContent
+            content()
                 .padding(.top, contentTopInset)
         }
         .frame(maxWidth: .infinity, alignment: .top)
@@ -443,10 +343,6 @@ private struct StackScreenContent<Content: View>: View {
     /// Extra top space reserved for the animated search bar (mirrors Compose's
     /// MainContent animated top spacer). Zero for non-animated screens.
     var animatedSearchInset: CGFloat = 0
-    /// Room for a header the content scrolls under (iPhone Duo glass header).
-    var topInset: CGFloat = 0
-    /// Room for a bar that overlays the content (iPhone Duo floating tab bar).
-    var bottomInset: CGFloat = 0
     let content: () -> Content
 
     private let topAnchorID = "stack_screen_top_anchor"
@@ -473,17 +369,13 @@ private struct StackScreenContent<Content: View>: View {
                                     }
                             })
 
-                        if animatedSearchInset + topInset > 0 {
-                            Spacer().frame(height: animatedSearchInset + topInset)
+                        if animatedSearchInset > 0 {
+                            Spacer().frame(height: animatedSearchInset)
                         }
 
                         VStack {
                             content()
                         }
-
-                        if bottomInset > 0 {
-                            Spacer().frame(height: bottomInset)
-                        }
                     }
                 }
                 .coordinateSpace(name: scrollSpace)
@@ -498,8 +390,6 @@ private struct StackScreenContent<Content: View>: View {
             }
         } else {
             content()
-                .padding(.top, topInset)
-                .padding(.bottom, bottomInset)
         }
     }
 }
@@ -517,23 +407,16 @@ private struct SearchAnimatedHeader: View {
     let hasHeaderRight: Bool
     let headerRightWidth: CGFloat
     let headerHeight: CGFloat
-    var useSideBar: Bool = false
-    var hasToolkit: Bool = false
-
-    @Environment(\.screenLayout) private var layout
 
     var body: some View {
         let scroll = max(scrollOffset, 0)
 
-        // Insets are measured from the safe-area top; collapsed, the search is centered in the bar row.
-        let rowTop = min(layout.headerStatusBarHeight - layout.insets.top, 0)
-        let minTop = rowTop + (layout.headerBarHeight - headerHeight) / 2
-        let maxTop = layout.headerHeight - layout.insets.top
+        // Insets are measured from the safe-area top (status bar handled by layout).
+        let minTop: CGFloat = 0
+        let maxTop = headerHeight
         let minSide = Spacing.M
-        let maxStart: CGFloat = hiddenBack || useSideBar ? Spacing.M : 48
-        let maxEnd: CGFloat = useSideBar && hasToolkit
-            ? Spacing.M
-            : headerRightWidth + (hasHeaderRight ? Spacing.M * 2 : Spacing.M)
+        let maxStart: CGFloat = hiddenBack ? Spacing.M : 48
+        let maxEnd = headerRightWidth + (hasHeaderRight ? Spacing.M * 2 : Spacing.M)
 
         let top = min(max(maxTop - scroll, minTop), maxTop)
         let start = min(max(minSide + scroll, minSide), maxStart)

package/ios/CalculatorKeyboard/CalculatorKeyboard.swift

@@ -26,7 +26,10 @@ public struct CalculatorKeyboard: View {
         if (value.count > 0 ){
             value.removeLast()
         }
-        
+        // Keys map 1:1 onto `tempValue` characters, so both trims stay aligned.
+        if (tempValue.count > 0 ){
+            tempValue.removeLast()
+        }
     }
     
     func onPressClear(key: String){
@@ -41,12 +44,63 @@ public struct CalculatorKeyboard: View {
         if (tempValue.last?.isNumber == false){
             tempValue.removeLast()
         }
-        let expression = NSExpression(format: tempValue)
-        
-        value = String(expression.expressionValue(with: nil, context: nil) as! Int)
-        if (Int(value) ?? 0 < 0){
+        // Overflow and division by zero are treated like a negative result: cleared.
+        if let result = Self.evaluate(tempValue), result >= 0 {
+            value = String(result)
+        } else {
             value = ""
         }
+        // The next keys continue from the shown result, not the old expression.
+        tempValue = value
+    }
+
+    /// Integer `+ - * /` with the usual precedence, as NSExpression did, but nil instead of a
+    /// crash when a number or result leaves `Int` range.
+    static func evaluate(_ expression: String) -> Int? {
+        var numbers: [Int] = []
+        var operators: [Character] = []
+        var digits = ""
+        for char in expression {
+            if ("0"..."9").contains(char) {
+                digits.append(char)
+                continue
+            }
+            guard let number = Int(digits) else { return nil }
+            numbers.append(number)
+            operators.append(char)
+            digits = ""
+        }
+        guard let last = Int(digits) else { return nil }
+        numbers.append(last)
+
+        var terms = [numbers[0]]
+        var signs: [Character] = []
+        for (op, number) in zip(operators, numbers.dropFirst()) {
+            switch op {
+            case "*":
+                let (product, overflow) = terms[terms.count - 1].multipliedReportingOverflow(by: number)
+                if overflow { return nil }
+                terms[terms.count - 1] = product
+            case "/":
+                guard number != 0 else { return nil }
+                terms[terms.count - 1] /= number
+            case "+", "-":
+                terms.append(number)
+                signs.append(op)
+            default:
+                return nil
+            }
+        }
+
+        var result = terms[0]
+        for (sign, term) in zip(signs, terms.dropFirst()) {
+            let (next, overflow) = sign == "+"
+                ? result.addingReportingOverflow(term)
+                : result.subtractingReportingOverflow(term)
+            if overflow { return nil }
+            result = next
+        }
+        return result
     }
     
     func onPressKey(key:String){

package/ios/Colors+Radius+Spacing/Colors.swift

@@ -133,7 +133,7 @@ public enum Colors {
     public static let yellow06 = Color(hex: "ffe066")
     public static let yellow05 = Color(hex: "ffd633")
     public static let yellow04 = Color(hex: "ffd119")
-    public static let yellow03 = Color(hex: "fc0")
+    public static let yellow03 = Color(hex: "ffcc00")
     public static let yellow02 = Color(hex: "e6b800")
     public static let yellow01 = Color(hex: "cca300")
 

package/ios/Extensions/Color++.swift

@@ -43,15 +43,26 @@ public extension Color {
         )
     }
 
+    /// CSS-style `RGB`, `RGBA`, `RRGGBB` or `RRGGBBAA`, `#` optional; anything else is black.
     init(hex: String) {
-        let scanner = Scanner(string: hex)
-        var rgbValue: UInt64 = 0
-        scanner.scanHexInt64(&rgbValue)
-        
-        let r = (rgbValue & 0xff0000) >> 16
-        let g = (rgbValue & 0xff00) >> 8
-        let b = rgbValue & 0xff
-        
-        self.init(red: Double(r) / 0xff, green: Double(g) / 0xff, blue: Double(b) / 0xff)
+        var digits = hex.trimmingCharacters(in: .whitespacesAndNewlines)
+        if digits.hasPrefix("#") { digits.removeFirst() }
+        if digits.count == 3 || digits.count == 4 {
+            digits = String(digits.flatMap { [$0, $0] })
+        }
+        guard digits.count == 6 || digits.count == 8,
+              digits.allSatisfy(\.isHexDigit),
+              let value = UInt64(digits, radix: 16) else {
+            self.init(red: 0, green: 0, blue: 0)
+            return
+        }
+        let rgba = digits.count == 8 ? value : value << 8 | 0xFF
+        self.init(
+            .sRGB,
+            red: Double((rgba >> 24) & 0xFF) / 255,
+            green: Double((rgba >> 16) & 0xFF) / 255,
+            blue: Double((rgba >> 8) & 0xFF) / 255,
+            opacity: Double(rgba & 0xFF) / 255
+        )
     }
 }

package/ios/Extensions/OptionalEnvironmentObject.swift

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// `@EnvironmentObject` that reads nil instead of trapping when nothing was injected.
+/// `_store` is the backing field of the `@frozen` `EnvironmentObject`, so its layout is ABI-stable.
+@propertyWrapper
+struct OptionalEnvironmentObject<Object: ObservableObject>: DynamicProperty {
+    @EnvironmentObject private var object: Object
+
+    var wrappedValue: Object? {
+        Mirror(reflecting: _object).descendant("_store") as? Object
+    }
+}

package/ios/Icon/Icon.swift

@@ -4,27 +4,16 @@ struct IconSource: Codable {
     let uri: String
 }
 
-func loadIconSources() -> [String: IconSource] {
-    guard let url = Bundle.main.url(forResource: "icon", withExtension: "json") else {
-        print("Error: icon.json not found")
-        return [:]
+// The compiled-in map (Icons.swift) wins; a host `icon.json` in the main bundle only adds keys
+// the kit doesn't know, so hosts that shipped one keep their extra icons.
+let iconSources: [String: String] = {
+    guard let url = Bundle.main.url(forResource: "icon", withExtension: "json"),
+          let data = try? Data(contentsOf: url),
+          let hostIcons = try? JSONDecoder().decode([String: IconSource].self, from: data) else {
+        return kitIcons
     }
-    
-    do {
-        let data = try Data(contentsOf: url)
-        let decoded = try JSONDecoder().decode([String: IconSource].self, from: data)
-        return decoded
-    } catch {
-        print("Error decoding icon.json: \(error)")
-        return [:]
-    }
-}
-
-// Load the JSON data into a global variable
-let iconSources: [String: IconSource] = loadIconSources()
-
-// Icons that must never be tinted (mirror Compose `noThemeIcons`)
-let noThemeIcons: [String] = ["ic_round_momo_tiny"]
+    return kitIcons.merging(hostIcons.mapValues(\.uri)) { kit, _ in kit }
+}()
 
 // 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
@@ -53,8 +42,8 @@ public struct Icon: View {
         }
 
     public var body: some View {
-        // 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 {
+        // Mirror Compose: an https source is used as-is, anything else is a key into the icon map
+        if let uri = source.contains("https") ? source : iconSources[source] {
             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 : requestedColor
@@ -63,6 +52,9 @@ public struct Icon: View {
                 // Mirrors Compose's auto-generated `contentDescription = "img|$iconUrl"`
                 // when no explicit label is provided.
                 .accessibilityLabel(accessibilityLabel ?? "img|\(uri)")
+        } else {
+            // Compose keeps the sized box for an unknown key, so layouts don't collapse.
+            Color.clear.frame(width: size, height: size)
         }
     }
 }