@momo-kits/native-kits 0.300.3-debug → 0.300.4-debug

package/ios/Application/StackScreen.swift

@@ -1,492 +0,0 @@
-//
-//  StackScreen.swift
-//  Pods
-//
-//  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 (`NavigationFooter`) — instead of one
-//  monolithic, partially-duplicated view. The public init matches `Screen`
-//  so call sites (e.g. NavigationContainer's ScreenHost) can swap over.
-//
-
-import SwiftUI
-
-public struct StackScreen<Content: View>: View {
-    // MARK: - Properties
-
-    var backgroundColor: Color?
-    var headerTransparent: Bool = false
-    var fullScreenContent: Bool = false
-    var tintColor: Color? = Colors.black17
-    var isBack: Bool
-    var headerType: HeaderType
-    var useAnimated: Bool = false
-    var verticalAlignment: VerticalAlignment
-    var horizontalAlignment: HorizontalAlignment
-    var title: String
-    var headerTitle: HeaderTitle?
-    var titlePosition: TitlePosition
-    var goBack: (() -> Void)?
-    var scrollable: Bool
-    var scrollToTopCallback: (() -> Void)?
-    var onContentLayout: ((CGRect) -> Void)?
-    var useAvoidKeyboard: Bool
-    var keyboardShouldPersistTaps: Bool
-    var footer: (() -> AnyView)?
-    var headerRight: (()->any View)? = {HeaderRight()}
-    var animatedHeader: AnimatedHeader? = nil
-    var layoutOffset: CGFloat
-    var inputSearchProps: InputSearchProps?
-    var fabProps: FabProps?
-    var screenName: String = ""
-    var content: () -> Content
-
-    public init(
-        backgroundColor: Color? = nil,
-        headerTransparent: Bool = false,
-        fullScreenContent: Bool = false,
-        tintColor: Color = Colors.black17,
-        isBack: Bool = true,
-        headerType: HeaderType = .default,
-        useAnimated: Bool = false,
-        verticalAlignment: VerticalAlignment = .top,
-        horizontalAlignment: HorizontalAlignment = .leading,
-        title: String = "Stack",
-        headerTitle: HeaderTitle? = nil,
-        titlePosition: TitlePosition = .left,
-        goBack: (() -> Void)? = nil,
-        scrollable: Bool = true,
-        scrollToTopCallback: (() -> Void)? = nil,
-        onContentLayout: ((CGRect) -> Void)? = nil,
-        useAvoidKeyboard: Bool = true,
-        keyboardShouldPersistTaps: Bool = false,
-        footer: (() -> AnyView)? = nil,
-        headerRight:  (()->any View)? = {HeaderRight()},
-        animatedHeader: AnimatedHeader? = nil,
-        layoutOffset: CGFloat = 56,
-        inputSearchProps: InputSearchProps? = nil,
-        fabProps: FabProps? = nil,
-        screenName: String = "",
-        @ViewBuilder content: @escaping () -> Content
-    ) {
-        self.backgroundColor = backgroundColor
-        self.headerTransparent = headerTransparent
-        self.fullScreenContent = fullScreenContent
-        self.tintColor = tintColor
-        self.isBack = isBack
-        self.headerType = headerType
-        self.useAnimated = useAnimated
-        self.verticalAlignment = verticalAlignment
-        self.horizontalAlignment = horizontalAlignment
-        self.title = title
-        self.headerTitle = headerTitle
-        self.titlePosition = titlePosition
-        self.goBack = goBack
-        self.scrollable = scrollable
-        self.scrollToTopCallback = scrollToTopCallback
-        self.onContentLayout = onContentLayout
-        self.useAvoidKeyboard = useAvoidKeyboard
-        self.keyboardShouldPersistTaps = keyboardShouldPersistTaps
-        self.footer = footer
-        self.headerRight = headerRight
-        self.animatedHeader = animatedHeader
-        self.layoutOffset = layoutOffset
-        self.inputSearchProps = inputSearchProps
-        self.fabProps = fabProps
-        self.screenName = screenName
-        self.content = content
-    }
-
-    @State private var scrollOffset: CGFloat = 0
-    @State private var keyboardHeight: CGFloat = 0
-    @State private var headerRightWidth: CGFloat = 0
-    @State private var isBottomTabRoot: Bool = false
-
-    @Environment(\.applicationEnvironment) private var appEnv
-
-    // Auto-tracking state (mirrors Compose's `remember { ScreenTrackingState() }` +
-    // the once-computed push/back `action`).
-    @State private var trackingState = ScreenTrackingState()
-    @State private var trackingAction: String = ScreenTracker.getLastScreenName() != nil ? "push" : "back"
-
-    /// Header background fade tied to scroll: 0 → transparent (over a hero image
-    /// or transparent header), 1 → opaque surface with the drop shadow.
-    private var scrollOpacity: CGFloat { min(scrollOffset / 114, 1) }
-
-    // MARK: - Search header (mirrors Compose's getInputSearchType / SearchAnimated)
-
-    private enum InputSearchType { case none, header, animated }
-
-    private var inputSearchType: InputSearchType {
-        guard inputSearchProps != nil else { return .none }
-        return useAnimated ? .animated : .header
-    }
-
-    private static var headerHeight: CGFloat { 52 }
-
-    /// 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 {
-        guard inputSearchType == .animated else { return 0 }
-        let scroll = max(scrollOffset, 0)
-        return min(max(Self.headerHeight - scroll, 0), Self.headerHeight)
-    }
-
-    /// Title fades out as the animated search bar rises into the header.
-    private var titleOpacity: CGFloat {
-        guard inputSearchType == .animated else { return 1 }
-        let scroll = max(scrollOffset, 0)
-        return 1 - min(max(scroll / Self.headerHeight, 0), 1)
-    }
-
-    // MARK: - Body
-
-    public var body: some View {
-        GeometryReader { _ in
-            let keyboardSize: CGFloat = useAvoidKeyboard ? max(keyboardHeight, 0) : 0
-
-            ZStack(alignment: .top) {
-                // Background color
-                (backgroundColor ?? Color.white)
-                    .edgesIgnoringSafeArea(.all)
-
-                VStack(spacing: 0) {
-                    ZStack(alignment: fabProps?.position == .center ? .bottom : .bottomTrailing) {
-                        VStack(alignment: horizontalAlignment, spacing: 0) {
-                            headerAndContent
-                        }
-
-                        FloatingContent(
-                            fabProps: fabProps,
-                            keyboardSize: keyboardSize,
-                            hasFooter: footer != nil,
-                            scrollOffset: scrollOffset
-                        )
-                    }
-
-                    NavigationFooter(footerComponent: footer, keyboardSize: keyboardSize)
-                }
-
-                // Animated search bar overlay (mirrors Compose's SearchAnimated layer).
-                if inputSearchType == .animated, let props = inputSearchProps {
-                    SearchAnimatedHeader(
-                        props: props,
-                        scrollOffset: scrollOffset,
-                        hiddenBack: !isBack,
-                        hasHeaderRight: headerRight != nil,
-                        headerRightWidth: headerRightWidth,
-                        headerHeight: Self.headerHeight
-                    )
-                }
-            }
-            .ignoresSafeArea(.keyboard, edges: .bottom)
-            .onPreferenceChange(HeaderRightWidthKey.self) { width in
-                if headerRightWidth != width { headerRightWidth = width }
-            }
-            .onPreferenceChange(IsBottomTabRootKey.self) { isRoot in
-                if isBottomTabRoot != isRoot { isBottomTabRoot = isRoot }
-            }
-            .onReceive(NotificationCenter.default.publisher(for: UIResponder.keyboardWillChangeFrameNotification)) { notification in
-                guard useAvoidKeyboard,
-                      let endFrame = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else { return }
-                withAnimation(.easeOut(duration: 0.25)) {
-                    keyboardHeight = UIScreen.main.bounds.height - endFrame.origin.y
-                }
-            }
-            // Mirrors Compose's `hideKeyboardOnTap()`: a simultaneous gesture so
-            // taps still reach buttons/fields while also dismissing the keyboard.
-            .modifier(HideKeyboardOnTap(enabled: keyboardShouldPersistTaps))
-        }
-        .task(id: screenName) {
-            ScreenTracker.trackScreenNavigated(
-                maxApi: appEnv.maxApi,
-                context: appEnv.applicationContext,
-                screenName: screenName,
-                action: trackingAction,
-                state: trackingState
-            )
-            do {
-                try await Task.sleep(nanoseconds: 2_000_000_000)
-            } catch {
-                return
-            }
-            let loadTime = Date().timeIntervalSince1970 * 1000 - trackingState.time
-            ScreenTracker.trackScreenDisplayed(
-                maxApi: appEnv.maxApi,
-                context: appEnv.applicationContext,
-                screenName: screenName,
-                duration: loadTime,
-                state: trackingState
-            )
-            let interactionTime = Date().timeIntervalSince1970 * 1000 - trackingState.time
-            ScreenTracker.trackScreenInteracted(
-                maxApi: appEnv.maxApi,
-                context: appEnv.applicationContext,
-                screenName: screenName,
-                duration: interactionTime - loadTime,
-                totalDuration: interactionTime,
-                state: trackingState
-            )
-        }
-    }
-
-    // MARK: - Header + content layer
-
-    @ViewBuilder
-    private var headerAndContent: some View {
-        if let animatedHeader = animatedHeader {
-            // Animated (hero) header: the image is the top of the scroll content
-            // and the body overlaps its lower part; the header bar background
-            // fades in over the image as the screen scrolls (mirrors Compose's
-            // ScreenContent for HeaderType.Animated).
-            ZStack(alignment: .top) {
-                StackScreenContent(
-                    scrollable: scrollable,
-                    scrollOffset: $scrollOffset,
-                    scrollToTopCallback: scrollToTopCallback,
-                    animatedSearchInset: animatedSearchInset,
-                    content: { animatedHeroBody(animatedHeader) }
-                )
-                .edgesIgnoringSafeArea(.all)
-
-                header
-                    .background(
-                        Colors.black01
-                            .opacity(scrollOpacity)
-                            .edgesIgnoringSafeArea(.top)
-                    )
-                    .zIndex(100)
-            }
-        } else if headerTransparent && fullScreenContent {
-            ZStack(alignment: .top) {
-                header
-                    .background(
-                        NavigationHeaderBackground(
-                            headerType: headerType,
-                            scrollState: scrollOffset,
-                            headerTransparent: headerTransparent,
-                            fullScreenContent: fullScreenContent
-                        )
-                    )
-                    .zIndex(100)
-
-                StackScreenContent(scrollable: scrollable, scrollOffset: $scrollOffset, scrollToTopCallback: scrollToTopCallback, animatedSearchInset: animatedSearchInset, content: content)
-                    .edgesIgnoringSafeArea(.all)
-            }
-        } else {
-            header
-                .background(
-                    NavigationHeaderBackground(
-                        headerType: headerType,
-                        scrollState: scrollOffset,
-                        headerTransparent: headerTransparent,
-                        fullScreenContent: fullScreenContent
-                    )
-                    .edgesIgnoringSafeArea(.top)
-                )
-
-            StackScreenContent(scrollable: scrollable, scrollOffset: $scrollOffset, scrollToTopCallback: scrollToTopCallback, animatedSearchInset: animatedSearchInset, content: content)
-        }
-    }
-
-    /// 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 = UIScreen.main.bounds.width
-        let imageHeight = width / animatedHeader.aspectRatio.value
-        let contentTopInset = safeAreaTopInset() + HEADER_HEIGHT + layoutOffset
-
-        ZStack(alignment: .top) {
-            animatedHeader.composable(scrollOffset)
-                .frame(width: width, height: imageHeight)
-                .clipped()
-
-            content()
-                .padding(.top, contentTopInset)
-        }
-        .frame(maxWidth: .infinity, alignment: .top)
-    }
-
-    private var header: NavigationHeader {
-        NavigationHeader(
-            headerType: headerType,
-            titlePosition: titlePosition,
-            title: title,
-            headerTitle: headerTitle,
-            headerRight: headerRight,
-            goBack: goBack,
-            opacity: scrollOpacity,
-            animatedHeader: animatedHeader,
-            scrollState: scrollOffset,
-            // For the animated search the bar is rendered by the overlay, so the
-            // header shows the (fading) title instead of an inline search field.
-            inputSearchProps: inputSearchType == .header ? inputSearchProps : nil,
-            tintColor: tintColor,
-            titleOpacity: titleOpacity
-        )
-    }
-}
-
-// MARK: - Screen content (scrollable body)
-
-/// Mirrors Compose's `ScreenContent`/`MainContent`: renders the screen body and,
-/// when scrollable, tracks the scroll offset so the header/FAB can react to it.
-private struct StackScreenContent<Content: View>: View {
-    let scrollable: Bool
-    @Binding var scrollOffset: CGFloat
-    /// Mirrors Compose's `ScrollData.scrollToTopCallback`; fired alongside the
-    /// scroll-to-top triggered by a status-bar tap.
-    let scrollToTopCallback: (() -> Void)?
-    /// 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
-    let content: () -> Content
-
-    private let topAnchorID = "stack_screen_top_anchor"
-    private let scrollSpace = "stack_screen_scroll_space"
-
-    var body: some View {
-        if scrollable {
-            ScrollViewReader { proxy in
-                ScrollView(.vertical, showsIndicators: false) {
-                    VStack(spacing: 0) {
-                        // Top probe + scroll-to-top anchor. Measured in the scroll's
-                        // own coordinate space so the offset is a clean 0-based
-                        // "pixels scrolled" value, independent of the inset below.
-                        Color.clear
-                            .frame(height: 0)
-                            .id(topAnchorID)
-                            .background(GeometryReader { geo in
-                                Color.clear
-                                    .onAppear {
-                                        scrollOffset = -geo.frame(in: .named(scrollSpace)).minY
-                                    }
-                                    .onChange(of: geo.frame(in: .named(scrollSpace)).minY) { minY in
-                                        scrollOffset = -minY
-                                    }
-                            })
-
-                        if animatedSearchInset > 0 {
-                            Spacer().frame(height: animatedSearchInset)
-                        }
-
-                        VStack {
-                            content()
-                        }
-                    }
-                }
-                .coordinateSpace(name: scrollSpace)
-                // Status-bar tap (via MoMoStatusBarTap swizzle) scrolls to top and
-                // notifies the consumer, mirroring Compose's scrollToTopCallback.
-                .onReceive(NotificationCenter.default.publisher(for: MoMoStatusBarTap.notificationName)) { _ in
-                    withAnimation {
-                        proxy.scrollTo(topAnchorID, anchor: .top)
-                    }
-                    scrollToTopCallback?()
-                }
-            }
-        } else {
-            content()
-        }
-    }
-}
-
-// MARK: - Animated search header
-
-/// Mirrors Compose's `SearchAnimated`: the search bar slides from below the
-/// header (scroll 0) up into the header band as the user scrolls, while its
-/// horizontal insets grow to make room for the back button and header-right.
-/// Note: Compose's scroll-end snap and background-color lerp are not ported.
-private struct SearchAnimatedHeader: View {
-    let props: InputSearchProps
-    let scrollOffset: CGFloat
-    let hiddenBack: Bool
-    let hasHeaderRight: Bool
-    let headerRightWidth: CGFloat
-    let headerHeight: CGFloat
-
-    var body: some View {
-        let scroll = max(scrollOffset, 0)
-
-        // 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 ? 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)
-        let end = min(max(minSide + scroll, minSide), maxEnd)
-
-        VStack(spacing: 0) {
-            Spacer().frame(height: top)
-            InputSearch(props: props)
-                .frame(height: headerHeight)
-                .padding(.leading, start)
-                .padding(.trailing, end)
-            Spacer(minLength: 0)
-        }
-        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
-    }
-}
-
-// MARK: - Floating content
-
-/// Mirrors Compose's `FloatingContent`: no FAB props means nothing renders.
-private struct FloatingContent: View {
-    let fabProps: FabProps?
-    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: 0,
-                scrollOffset: scrollOffset
-            )
-            .padding(.horizontal, Spacing.M)
-            .offset(y: verticalOffset)
-            .ignoresSafeArea(.keyboard, edges: .bottom)
-        }
-    }
-}
-
-// MARK: - Hide keyboard on tap
-
-/// Mirrors Compose's `Modifier.hideKeyboardOnTap()`. When enabled, a tap
-/// anywhere resigns the first responder. Uses `simultaneousGesture` so the tap
-/// is not consumed — buttons and text fields keep working.
-private struct HideKeyboardOnTap: ViewModifier {
-    let enabled: Bool
-
-    func body(content: Content) -> some View {
-        if enabled {
-            content.simultaneousGesture(
-                TapGesture().onEnded {
-                    UIApplication.shared.sendAction(
-                        #selector(UIResponder.resignFirstResponder),
-                        to: nil, from: nil, for: nil
-                    )
-                }
-            )
-        } else {
-            content
-        }
-    }
-}

package/ios/Typography/FontScaleStore.swift

@@ -1,58 +0,0 @@
-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()
-
-    @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) {
-        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/KitDesignSystem.swift

@@ -1,17 +0,0 @@
-import Foundation
-
-/// Design-system rollout flag for the SwiftUI kit, mirroring Compose's `KitDesignSystem`.
-/// The kit is sandboxed and can't read the host config, so the host writes `update(_:)` once at
-/// startup from `DesignSystemConfig`. Startup-only and non-reactive, like `FontScaleStore` was
-/// before it gained live updates: there is no SwiftUI navigation container to re-render from.
-public final class KitDesignSystem {
-    public static let shared = KitDesignSystem()
-
-    public private(set) var isWhiteList: Bool = false
-
-    private init() {}
-
-    public func update(isWhiteList: Bool) {
-        self.isWhiteList = isWhiteList
-    }
-}