@momo-kits/native-kits 0.163.1-beta.3 → 0.163.1-beta.5-debug

package/ios/Application/Navigation/Navigator.swift

@@ -0,0 +1,364 @@
+//
+//  Navigator.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's Navigator + DynamicScreenRegistry.
+//  Screens are registered by Int id; the NavigationStack path stores routes
+//  by id and looks up content from the registry on render.
+//
+
+import SwiftUI
+import Combine
+
+// MARK: - Routes
+
+public struct DynamicScreenRoute: Hashable, Identifiable {
+    public let id: Int
+}
+
+public struct DynamicDialogRoute: Hashable, Identifiable {
+    public let id: Int
+}
+
+// MARK: - Registry
+
+public struct DynamicScreen {
+    public let id: Int
+    public let name: String
+    public let content: () -> AnyView
+    public var options: NavigationOptions?
+}
+
+public final class DynamicScreenRegistry {
+    public static let shared = DynamicScreenRegistry()
+
+    private var screens: [Int: DynamicScreen] = [:]
+    private var idCounter: Int = 1
+
+    private init() {}
+
+    @discardableResult
+    public func register(
+        screenName: String = "",
+        content: @escaping () -> AnyView,
+        options: NavigationOptions? = nil
+    ) -> DynamicScreenRoute {
+        let id = idCounter
+        idCounter += 1
+        screens[id] = DynamicScreen(id: id, name: screenName, content: content, options: options)
+        return DynamicScreenRoute(id: id)
+    }
+
+    public func unregister(id: Int) {
+        screens.removeValue(forKey: id)
+    }
+
+    public func unregisterAll() {
+        screens.removeAll()
+    }
+
+    public func getScreen(id: Int) -> DynamicScreen? { screens[id] }
+
+    public func latest() -> DynamicScreen? {
+        screens.max(by: { $0.key < $1.key })?.value
+    }
+
+    public func setOptions(id: Int, options: NavigationOptions) {
+        screens[id]?.options = options
+    }
+}
+
+// MARK: - Overplay
+
+public enum OverplayType {
+    case modal, bottomSheet, snackBar
+}
+
+public struct OverplayItem: Identifiable {
+    public let id = UUID()
+    public let type: OverplayType
+    public let content: () -> AnyView
+    public let barrierDismissible: Bool
+    public let onDismiss: (() -> Void)?
+    // Bottom-sheet params (mirrors Compose's OverplayComponentParams.BottomSheet).
+    public var isSurface: Bool = false
+    public var header: BottomSheetHeader? = nil
+    // Snack-bar payload (mirrors Compose's SnackBar value).
+    public var snackBar: SnackBar? = nil
+}
+
+// MARK: - Navigator
+
+@available(iOS 16.0, *)
+public final class Navigator: ObservableObject {
+    @Published public var path: [DynamicScreenRoute] = []
+    @Published public var presented: DynamicDialogRoute?
+    @Published public var overplay: OverplayItem?
+
+    /// Animated-close handler registered by the active overplay component
+    /// (mirrors Compose's `OverplayComponentRegistry.bindClose`). When set, a
+    /// dismiss request runs the component's exit animation before the item is
+    /// actually removed via `finishOverplayDismiss`.
+    private var overplayDismissHandler: (() -> Void)?
+
+    public private(set) var rootRoute: DynamicScreenRoute
+    public var composeApi: KitComposeApi?
+
+    public init(
+        initialScreenName: String = "",
+        initialContent: @escaping () -> AnyView,
+        options: NavigationOptions? = nil,
+        composeApi: KitComposeApi? = nil
+    ) {
+        self.composeApi = composeApi
+        self.rootRoute = DynamicScreenRegistry.shared.register(
+            screenName: initialScreenName,
+            content: initialContent,
+            options: options
+        )
+    }
+
+    // MARK: Stack
+
+    public func push<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: options?.screenName ?? "",
+            content: { AnyView(content()) },
+            options: options
+        )
+        path.append(route)
+    }
+
+    public func push<V: View>(
+        screenName: String,
+        @ViewBuilder _ content: @escaping () -> V,
+        options: NavigationOptions? = nil
+    ) {
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: screenName,
+            content: { AnyView(content()) },
+            options: options
+        )
+        path.append(route)
+    }
+
+    public func replace<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
+        guard !path.isEmpty else { return }
+        let removed = path.removeLast()
+        DynamicScreenRegistry.shared.unregister(id: removed.id)
+        push(content, options: options)
+    }
+
+    public func replace<V: View>(
+        screenName: String,
+        @ViewBuilder _ content: @escaping () -> V,
+        options: NavigationOptions? = nil
+    ) {
+        guard !path.isEmpty else { return }
+        let removed = path.removeLast()
+        DynamicScreenRegistry.shared.unregister(id: removed.id)
+        push(screenName: screenName, content, options: options)
+    }
+
+    public func reset<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
+        for route in path { DynamicScreenRegistry.shared.unregister(id: route.id) }
+        DynamicScreenRegistry.shared.unregister(id: rootRoute.id)
+        path.removeAll()
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: options?.screenName ?? "",
+            content: { AnyView(content()) },
+            options: options
+        )
+        rootRoute = route
+    }
+
+    public func reset<V: View>(
+        screenName: String,
+        @ViewBuilder _ content: @escaping () -> V,
+        options: NavigationOptions? = nil
+    ) {
+        for route in path { DynamicScreenRegistry.shared.unregister(id: route.id) }
+        DynamicScreenRegistry.shared.unregister(id: rootRoute.id)
+        path.removeAll()
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: screenName,
+            content: { AnyView(content()) },
+            options: options
+        )
+        rootRoute = route
+    }
+
+    public func pop(_ count: Int = 1, callback: (() -> Void)? = nil) {
+        var remaining = count
+        while remaining > 0 {
+            if overplay != nil {
+                hideOverplay()
+            } else if presented != nil {
+                let dismissedId = presented?.id
+                presented = nil
+                if let id = dismissedId { DynamicScreenRegistry.shared.unregister(id: id) }
+            } else if !path.isEmpty {
+                let removed = path.removeLast()
+                DynamicScreenRegistry.shared.unregister(id: removed.id)
+            } else {
+                composeApi?.requestCallback(funcName: "dismiss", params: nil, onResponse: nil)
+                break
+            }
+            remaining -= 1
+        }
+        callback?()
+    }
+
+    public func popToRoot() {
+        for route in path { DynamicScreenRegistry.shared.unregister(id: route.id) }
+        path.removeAll()
+    }
+
+    public func onBackSafe(callback: (() -> Void)? = nil) {
+        let latest = DynamicScreenRegistry.shared.latest()
+        if let onBack = latest?.options?.onBackHandler {
+            onBack()
+            return
+        }
+        if let preventBack = latest?.options?.headerBackProps?.preventBack {
+            showModal {
+                PopupDisplay(
+                    isPresented: .constant(true),
+                    title: preventBack.title,
+                    description: preventBack.description,
+                    url: preventBack.image,
+                    buttonDirection: preventBack.buttonDirection,
+                    buttonType: .button,
+                    actionButtonTitle: preventBack.primary?.title ?? "",
+                    closeButtonTitle: preventBack.secondary?.title ?? "",
+                    onPressAction: { [weak self] in
+                        preventBack.primary?.onPress?()
+                        // Close the popup, then leave the screen (matches Compose's pop(2)).
+                        self?.pop(2, callback: callback)
+                    },
+                    onPressCloseButton: { [weak self] in
+                        preventBack.secondary?.onPress?()
+                        self?.hideOverplay()
+                    },
+                    onClose: { [weak self] in
+                        preventBack.onIconClose?()
+                        self?.hideOverplay()
+                    },
+                    errorCode: preventBack.error,
+                    isShowCloseIcon: preventBack.isShowCloseIcon
+                )
+            }
+            return
+        }
+        pop(1, callback: callback)
+    }
+
+    // MARK: Modal-style screen (vertical slide)
+
+    public func present<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: options?.screenName ?? "",
+            content: { AnyView(content()) },
+            options: options
+        )
+        presented = DynamicDialogRoute(id: route.id)
+    }
+
+    public func present<V: View>(
+        screenName: String,
+        @ViewBuilder _ content: @escaping () -> V,
+        options: NavigationOptions? = nil
+    ) {
+        let route = DynamicScreenRegistry.shared.register(
+            screenName: screenName,
+            content: { AnyView(content()) },
+            options: options
+        )
+        presented = DynamicDialogRoute(id: route.id)
+    }
+
+    public func dismiss() {
+        if let id = presented?.id {
+            DynamicScreenRegistry.shared.unregister(id: id)
+        }
+        presented = nil
+    }
+
+    // MARK: Overplay
+
+    public func showModal<V: View>(
+        @ViewBuilder _ content: @escaping () -> V,
+        barrierDismissible: Bool = true,
+        onDismiss: (() -> Void)? = nil
+    ) {
+        overplayDismissHandler = nil
+        overplay = OverplayItem(
+            type: .modal,
+            content: { AnyView(content()) },
+            barrierDismissible: barrierDismissible,
+            onDismiss: onDismiss
+        )
+    }
+
+    public func showBottomSheet<V: View>(
+        @ViewBuilder _ content: @escaping () -> V,
+        isSurface: Bool = false,
+        barrierDismissible: Bool = true,
+        header: BottomSheetHeader? = nil,
+        onDismiss: (() -> Void)? = nil
+    ) {
+        overplayDismissHandler = nil
+        overplay = OverplayItem(
+            type: .bottomSheet,
+            content: { AnyView(content()) },
+            barrierDismissible: barrierDismissible,
+            onDismiss: onDismiss,
+            isSurface: isSurface,
+            header: header
+        )
+    }
+
+    /// Mirrors Compose's `showSnackBar(snackBar:)`.
+    public func showSnackBar(_ snackBar: SnackBar, onDismiss: (() -> Void)? = nil) {
+        overplayDismissHandler = nil
+        overplay = OverplayItem(
+            type: .snackBar,
+            content: { AnyView(EmptyView()) },
+            barrierDismissible: false,
+            onDismiss: onDismiss,
+            snackBar: snackBar
+        )
+    }
+
+    // MARK: Overplay dismissal
+
+    /// Registered by the active overplay component so external dismiss requests
+    /// run its exit animation (mirrors Compose's `bindClose`).
+    public func registerOverplayDismiss(_ handler: @escaping () -> Void) {
+        overplayDismissHandler = handler
+    }
+
+    /// Removes the overplay and fires its `onDismiss` (mirrors Compose's
+    /// `hardClearAfterDismiss`). Called by a component once its exit animation
+    /// has completed.
+    public func finishOverplayDismiss() {
+        let dismissCallback = overplay?.onDismiss
+        overplayDismissHandler = nil
+        overplay = nil
+        dismissCallback?()
+    }
+
+    public func hideOverplay() {
+        if let close = overplayDismissHandler {
+            // Component runs its exit animation, then calls finishOverplayDismiss.
+            overplayDismissHandler = nil
+            close()
+        } else {
+            finishOverplayDismiss()
+        }
+    }
+
+    public func hideSnackBar() {
+        if overplay?.type == .snackBar { hideOverplay() }
+    }
+}

package/ios/Application/Navigation/Overplay/BottomSheet.swift

@@ -0,0 +1,188 @@
+//
+//  BottomSheet.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `BottomSheet` (navigation/BottomSheet.kt).
+//  A sheet that slides up from the bottom over a dimmed scrim, with a drag
+//  handle, a header (title or custom), a divider and the content body.
+//  Dragging down past a threshold (or tapping the scrim) dismisses it.
+//  Driven by `Navigator.showBottomSheet`.
+//
+
+import SwiftUI
+
+// MARK: - Header model
+
+/// Mirrors Compose's `sealed class BottomHeader` (Title / Custom).
+public struct BottomSheetHeader {
+    enum Style {
+        case title(String)
+        case custom(() -> AnyView)
+    }
+
+    let style: Style
+
+    /// Mirrors `BottomHeader.Title`.
+    public static func title(_ text: String = "Bottom Sheet Title") -> BottomSheetHeader {
+        BottomSheetHeader(style: .title(text))
+    }
+
+    /// Mirrors `BottomHeader.Custom`.
+    public static func custom<V: View>(@ViewBuilder _ content: @escaping () -> V) -> BottomSheetHeader {
+        BottomSheetHeader(style: .custom({ AnyView(content()) }))
+    }
+}
+
+// MARK: - Bottom sheet view
+
+@available(iOS 16.0, *)
+struct BottomSheetView<Content: View>: View {
+    let header: BottomSheetHeader
+    let isSurface: Bool
+    let barrierDismissible: Bool
+    let content: () -> Content
+
+    @EnvironmentObject private var navigator: Navigator
+
+    /// Vertical translation of the sheet; starts off-screen and animates to 0.
+    @State private var sheetOffset: CGFloat = UIScreen.main.bounds.height
+    @State private var scrimAlpha: CGFloat = 0
+    @State private var sheetHeight: CGFloat = 0
+    @State private var didAppear = false
+
+    /// Mirrors Compose's `sheetCloseOffset` (100dp drag threshold to dismiss).
+    private let closeThreshold: CGFloat = 100
+
+    private var screenHeight: CGFloat { UIScreen.main.bounds.height }
+    private var bottomInset: CGFloat { safeAreaBottomInset() }
+
+    private var backgroundColor: Color {
+        // Compose uses background.surface (white) for `isSurface`, otherwise
+        // background.default. Both resolve to white in the current iOS palette.
+        isSurface ? Colors.black01 : Colors.black01
+    }
+
+    var body: some View {
+        ZStack(alignment: .bottom) {
+            // Dimmed scrim (max 0.3 alpha, mirrors Compose).
+            Color.black.opacity(scrimAlpha)
+                .ignoresSafeArea()
+                .contentShape(Rectangle())
+                .onTapGesture {
+                    if barrierDismissible { close() }
+                }
+
+            sheet
+                .offset(y: sheetOffset)
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .onAppear {
+            guard !didAppear else { return }
+            didAppear = true
+            navigator.registerOverplayDismiss { close() }
+            open()
+        }
+    }
+
+    private var sheet: some View {
+        VStack(spacing: 0) {
+            // Drag handle + header (the draggable region).
+            VStack(spacing: 0) {
+                Spacer().frame(height: 8)
+                Capsule()
+                    .fill(Colors.black06)
+                    .frame(width: 40, height: 4)
+                Spacer().frame(height: 4)
+                headerView
+                    .frame(height: 56)
+                    .padding(.horizontal, Spacing.M)
+            }
+            .frame(maxWidth: .infinity)
+            .frame(height: 72)
+            .contentShape(Rectangle())
+            .gesture(dragGesture)
+
+            Rectangle()
+                .fill(Colors.black04)
+                .frame(height: 1)
+
+            content()
+
+            backgroundColor
+                .frame(height: bottomInset)
+        }
+        .frame(maxWidth: .infinity)
+        .frame(maxHeight: screenHeight - safeAreaTopInset() - 90, alignment: .bottom)
+        .background(
+            GeometryReader { geo in
+                Color.clear.onAppear { sheetHeight = geo.size.height }
+            }
+        )
+        .background(backgroundColor)
+        .clipShape(RoundedCorner(radius: Radius.M, corners: [.topLeft, .topRight]))
+    }
+
+    @ViewBuilder
+    private var headerView: some View {
+        switch header.style {
+        case .title(let text):
+            HStack(spacing: 0) {
+                Color.clear.frame(width: 24, height: 24)
+                MomoText(text, typography: .headerDefaultBold, color: Colors.black17)
+                    .frame(maxWidth: .infinity, alignment: .center)
+                Icon(source: "navigation_close", size: 24, color: Colors.black17)
+                    .frame(width: 24, height: 24)
+                    .contentShape(Rectangle())
+                    .onTapGesture { close() }
+            }
+        case .custom(let builder):
+            builder()
+        }
+    }
+
+    // MARK: - Drag handling (mirrors Compose's detectDragGestures)
+
+    private var dragGesture: some Gesture {
+        DragGesture()
+            .onChanged { value in
+                let newOffset = max(value.translation.height, 0)
+                sheetOffset = newOffset
+            }
+            .onEnded { _ in
+                if sheetOffset > closeThreshold {
+                    close()
+                } else {
+                    withAnimation(.spring(response: 0.3, dampingFraction: 0.9)) {
+                        sheetOffset = 0
+                    }
+                }
+            }
+    }
+
+    // MARK: - Open / close animations
+
+    private func open() {
+        DispatchQueue.main.async {
+            withAnimation(.easeOut(duration: 0.1)) { scrimAlpha = 0.3 }
+            withAnimation(.timingCurve(0.05, 0.7, 0.1, 1, duration: 0.35)) { sheetOffset = 0 }
+        }
+    }
+
+    private func close() {
+        withAnimation(.timingCurve(0.3, 0, 0.8, 0.15, duration: 0.2)) {
+            sheetOffset = max(sheetHeight, screenHeight)
+            scrimAlpha = 0
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            navigator.finishOverplayDismiss()
+        }
+    }
+}
+
+@available(iOS 16.0, *)
+private func safeAreaBottomInset() -> CGFloat {
+    let bottomInset = UIApplication.shared.connectedScenes
+        .compactMap { ($0 as? UIWindowScene)?.keyWindow?.safeAreaInsets.bottom }
+        .first ?? 0
+    return min(bottomInset, 21)
+}

package/ios/Application/Navigation/Overplay/ModalScreen.swift

@@ -0,0 +1,68 @@
+//
+//  ModalScreen.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `ModalScreen` (navigation/ModalScreen.kt).
+//  A centered overlay that fades + scales in over a dimmed scrim, and animates
+//  back out before the overplay is removed. Driven by `Navigator.showModal`.
+//
+
+import SwiftUI
+
+@available(iOS 16.0, *)
+struct ModalScreen<Content: View>: View {
+    let barrierDismissible: Bool
+    let content: () -> Content
+
+    @EnvironmentObject private var navigator: Navigator
+
+    @State private var scrimOpacity: CGFloat = 0
+    @State private var contentScale: CGFloat = 0.8
+    @State private var contentOpacity: CGFloat = 0
+    @State private var didAppear = false
+
+    var body: some View {
+        ZStack {
+            // Dimmed scrim (mirrors `Color.Black.copy(alpha = 0.6f * alpha)`).
+            Color.black.opacity(0.6 * scrimOpacity)
+                .ignoresSafeArea()
+                .contentShape(Rectangle())
+                .onTapGesture {
+                    if barrierDismissible { navigator.hideOverplay() }
+                }
+
+            content()
+                .scaleEffect(contentScale)
+                .opacity(contentOpacity)
+        }
+        .onAppear {
+            guard !didAppear else { return }
+            didAppear = true
+            navigator.registerOverplayDismiss { close() }
+            open()
+        }
+    }
+
+    // Mirrors Compose's `openEvent`: 250ms fade + scale to 1.
+    private func open() {
+        DispatchQueue.main.async {
+            withAnimation(.easeOut(duration: 0.25)) {
+                scrimOpacity = 1
+                contentScale = 1
+                contentOpacity = 1
+            }
+        }
+    }
+
+    // Mirrors Compose's `closeEvent`: 200ms fade + scale back to 0.8, then remove.
+    private func close() {
+        withAnimation(.easeIn(duration: 0.2)) {
+            scrimOpacity = 0
+            contentScale = 0.8
+            contentOpacity = 0
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+            navigator.finishOverplayDismiss()
+        }
+    }
+}