@momo-kits/native-kits 0.0.1-beta.5 → 0.0.2-alpha.1

package/ios/Application/Navigation/Navigator.swift

@@ -0,0 +1,453 @@
+//
+//  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 {
+    private var screens: [Int: DynamicScreen] = [:]
+    private var idCounter: Int = 1
+
+    public 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] = [] {
+        // Disposal hangs off the path so every route that leaves the stack — pop,
+        // replace, reset — is released the same way, after its exit transition.
+        didSet { disposeScreens(droppedFrom: oldValue) }
+    }
+    @Published public var presented: DynamicDialogRoute?
+    @Published public var overplay: OverplayItem?
+
+    /// Owned per-Navigator (mirrors Compose's `remember { DynamicScreenRegistry() }` +
+    /// disposal): screens registered by this navigator are released via ARC when the
+    /// navigator itself deallocates, instead of accumulating in a process-wide singleton.
+    public let registry = DynamicScreenRegistry()
+
+    /// 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 = registry.register(
+            screenName: initialScreenName,
+            content: initialContent,
+            options: options
+        )
+    }
+
+    // MARK: Stack
+
+    public func push<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
+        let route = registry.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 = registry.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 }
+        path.removeLast()
+        push(content, options: options)
+    }
+
+    public func replace<V: View>(
+        screenName: String,
+        @ViewBuilder _ content: @escaping () -> V,
+        options: NavigationOptions? = nil
+    ) {
+        guard !path.isEmpty else { return }
+        path.removeLast()
+        push(screenName: screenName, content, options: options)
+    }
+
+    public func reset<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
+        let previousRoot = rootRoute.id
+        path.removeAll()
+        let route = registry.register(
+            screenName: options?.screenName ?? "",
+            content: { AnyView(content()) },
+            options: options
+        )
+        rootRoute = route
+        disposeScreens([previousRoot])
+    }
+
+    public func reset<V: View>(
+        screenName: String,
+        @ViewBuilder _ content: @escaping () -> V,
+        options: NavigationOptions? = nil
+    ) {
+        let previousRoot = rootRoute.id
+        path.removeAll()
+        let route = registry.register(
+            screenName: screenName,
+            content: { AnyView(content()) },
+            options: options
+        )
+        rootRoute = route
+        disposeScreens([previousRoot])
+    }
+
+    public func pop(_ count: Int = 1, callback: (() -> Void)? = nil) {
+        popStep(remaining: count, callback: callback)
+    }
+
+    /// One `pop` iteration. Compose runs the loop in a coroutine and suspends over the
+    /// overplay's exit animation before the next step; the same wait is needed here, or
+    /// a `pop(2)` (prevent-back: close the popup, then leave) would spend both steps on
+    /// the overplay that is still animating out and never pop the screen.
+    private func popStep(remaining: Int, callback: (() -> Void)?) {
+        guard remaining > 0 else {
+            callback?()
+            return
+        }
+
+        if overplay?.type == .snackBar {
+            // Mirrors Kotlin: a snackbar doesn't block back-navigation, so popping
+            // while one is showing pops the screen underneath and clears the
+            // snackbar immediately, without playing its dismiss animation.
+            overplayDismissHandler = nil
+            overplay = nil
+            guard popScreen() else {
+                callback?()
+                return
+            }
+            popStep(remaining: remaining - 1, callback: callback)
+        } else if overplay != nil {
+            hideOverplay()
+            DispatchQueue.main.asyncAfter(deadline: .now() + Self.overplayDismissDelay) { [weak self] in
+                guard let self else { return }
+                // The component reports back through `finishOverplayDismiss` once its exit
+                // animation ends; clear it here if it never did, so the step is not wasted.
+                if self.overplay != nil { self.finishOverplayDismiss() }
+                self.popStep(remaining: remaining - 1, callback: callback)
+            }
+        } else {
+            guard popScreen() else {
+                callback?()
+                return
+            }
+            popStep(remaining: remaining - 1, callback: callback)
+        }
+    }
+
+    /// Pops the topmost presented screen or stack entry. Returns `false` (and requests
+    /// a host dismiss) when there is nothing left to pop.
+    @discardableResult
+    private func popScreen() -> Bool {
+        if presented != nil {
+            let dismissedId = presented?.id
+            presented = nil
+            if let id = dismissedId { disposeScreens([id]) }
+            return true
+        } else if !path.isEmpty {
+            path.removeLast()
+            return true
+        } else {
+            composeApi?.requestCallback(funcName: "dismiss", params: nil, onResponse: nil)
+            return false
+        }
+    }
+
+    public func popToRoot() {
+        path.removeAll()
+    }
+
+    /// The entry a back action applies to — mirrors Compose's `currentScreen()`
+    /// (`navController.currentBackStackEntry`): a presented screen sits on top of
+    /// the stack, otherwise it is the last pushed screen, otherwise the root.
+    private func currentScreen() -> DynamicScreen? {
+        registry.getScreen(id: presented?.id ?? path.last?.id ?? rootRoute.id)
+    }
+
+    public func onBackSafe(callback: (() -> Void)? = nil) {
+        let latest = currentScreen()
+        if let onBack = latest?.options?.onBackHandler {
+            onBack()
+            return
+        }
+        if let preventBack = latest?.options?.headerBackProps?.preventBack {
+            showModal {
+                PopupNotify(
+                    props: PopupNotifyProps(
+                        image: preventBack.image,
+                        title: preventBack.title,
+                        description: preventBack.description,
+                        error: preventBack.error,
+                        primary: PopupAction(
+                            title: preventBack.primary?.title ?? "",
+                            onPress: { [weak self] in
+                                preventBack.primary?.onPress?()
+                                // Close the popup, then leave the screen (matches Compose's pop(2)).
+                                self?.pop(2, callback: callback)
+                            }
+                        ),
+                        secondary: preventBack.secondary.map { secondary in
+                            PopupAction(
+                                title: secondary.title,
+                                onPress: { [weak self] in
+                                    secondary.onPress?()
+                                    self?.hideOverplay()
+                                }
+                            )
+                        },
+                        buttonDirection: preventBack.buttonDirection,
+                        onIconClose: { [weak self] in
+                            preventBack.onIconClose?()
+                            self?.hideOverplay()
+                        },
+                        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 = registry.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 = registry.register(
+            screenName: screenName,
+            content: { AnyView(content()) },
+            options: options
+        )
+        presented = DynamicDialogRoute(id: route.id)
+    }
+
+    public func dismiss() {
+        if let id = presented?.id {
+            registry.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() }
+    }
+
+    // MARK: Screen disposal
+
+    /// Matches the `delay(300)` Compose waits in `dismissScreen` before unregistering,
+    /// with a little headroom for the pop transition.
+    private static let screenDisposeDelay: TimeInterval = 0.35
+
+    /// Longest overplay exit animation (the bottom sheet's), so a queued pop step runs
+    /// after the component has taken itself down.
+    private static let overplayDismissDelay: TimeInterval = 0.3
+
+    private func disposeScreens(droppedFrom previous: [DynamicScreenRoute]) {
+        let live = Set(path.map(\.id))
+        disposeScreens(previous.map(\.id).filter { !live.contains($0) })
+    }
+
+    /// Screens are released only once the pop transition has played out: the outgoing
+    /// view is still on screen while it animates and the registry is what renders it —
+    /// dropping it right away blanks the screen mid-transition. Liveness is re-checked
+    /// when the timer fires, so a route pushed back before then keeps its screen.
+    private func disposeScreens(_ ids: [Int]) {
+        guard !ids.isEmpty else { return }
+        DispatchQueue.main.asyncAfter(deadline: .now() + Self.screenDisposeDelay) { [weak self] in
+            guard let self else { return }
+            var live = Set(self.path.map(\.id))
+            live.insert(self.rootRoute.id)
+            if let presented = self.presented { live.insert(presented.id) }
+            for id in ids where !live.contains(id) {
+                self.registry.unregister(id: id)
+            }
+        }
+    }
+}

package/ios/Application/Navigation/NavigatorManager.swift

@@ -0,0 +1,22 @@
+import Foundation
+
+@available(iOS 16.0, *)
+public final class NavigatorManager {
+    public static let shared = NavigatorManager()
+    private init() {}
+
+    private var navigators: [Navigator] = []
+
+    public func push(_ navigator: Navigator) {
+        guard !navigators.contains(where: { $0 === navigator }) else { return }
+        navigators.append(navigator)
+    }
+
+    public func remove(_ navigator: Navigator) {
+        navigators.removeAll { $0 === navigator }
+    }
+
+    public func checkCanPop() -> Bool { !navigators.isEmpty }
+
+    public func pop() { navigators.last?.onBackSafe() }
+}