@momo-kits/native-kits 0.167.1-duo.2-debug → 0.167.1-duo.20

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-demo/README.md

@@ -1,120 +0,0 @@
-# MoMoUIKitsDemo
-
-SwiftUI demo browser for `MoMoUIKits`.
-
-The package can optionally host a Compose UIKits screen by receiving a
-`UIViewController` factory from the host app. It does not import the KMP
-`shared` module directly.
-
-SwiftUI mode reuses the full demo screen set from
-`sample/iosApp/iosApp/Demo`, including the sample `HomeView` registry and demo
-screens for all currently available components.
-
-## CocoaPods
-
-In the host app `Podfile`, include both local pods:
-
-```ruby
-pod 'MoMoUIKits', :path => '../momo-native-kits/ios/native-kits.podspec'
-pod 'MoMoUIKitsDemo', :path => '../momo-native-kits/ios-demo'
-```
-
-Adjust the relative paths to match the host app checkout.
-
-## Host App Usage
-
-```swift
-import MoMoUIKitsDemo
-import shared
-
-class UIKitsViewController: BaseComposeAppViewController {
-  override func getViewController() -> UIViewController? {
-    let params = self.application.data as? [String: Any]
-
-    return MoMoUIKitsDemoViewControllerFactory.make(
-      context: MoMoUIKitsDemoContext(
-        appId: params?["appId"] as? String ?? "",
-        appCode: params?["code"] as? String ?? "",
-        appName: params?["name"] as? String,
-        appIcon: params?["icon"] as? String ?? ""
-      ),
-      composeViewController: {
-        UIKitsScreenComposeViewControllerKt.UIKitsScreenComposeViewController(
-          params: params
-        )
-      }
-    )
-  }
-
-  override func viewDidDisappear(_ animated: Bool) {
-    super.viewDidDisappear(animated)
-    composeViewController = nil
-  }
-}
-```
-
-If the host does not pass `composeViewController`, the demo opens directly in
-SwiftUI mode.
-
-## Included SwiftUI Demos
-
-The pod includes the sample demo screens for:
-
-- Animated Header
-- Avatar
-- Badge
-- Baseline View
-- Bottom Tab
-- Button
-- Carousel
-- Checkbox
-- Chip
-- Collapse
-- DateTimePicker
-- Divider
-- Header User
-- Icon Button
-- Image
-- Information
-- Input
-- Input DropDown
-- Input Money
-- Input OTP
-- Input Phone Number
-- Input Search
-- Input TextArea
-- Loader
-- Navigation
-- Pagination
-- Popup Display
-- Popup Notify
-- Popup Promotion
-- Progress Info
-- Radio
-- Rating
-- Skeleton
-- Slider
-- SnackBar
-- Stepper
-- Steps
-- Suggest Action
-- Swipe
-- Switch
-- TabView
-- Tag
-- Theme
-- Title
-- Tooltip
-- Typography
-- Uploader
-
-## Validation Notes
-
-Validated locally with:
-
-```sh
-pod ipc spec ios/MoMoUIKits.podspec
-pod ipc spec ios-demo/MoMoUIKitsDemo.podspec
-pod lib lint ios/MoMoUIKits.podspec --allow-warnings --skip-import-validation
-pod lib lint ios-demo/MoMoUIKitsDemo.podspec --allow-warnings --skip-import-validation --include-podspecs=ios/MoMoUIKits.podspec
-```

package/settings.gradle.kts

@@ -1,64 +0,0 @@
-import org.gradle.kotlin.dsl.maven
-
-rootProject.name = "momo-native-kits"
-enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
-
-pluginManagement {
-    repositories {
-        google {
-            mavenContent {
-                includeGroupAndSubgroups("androidx")
-                includeGroupAndSubgroups("com.android")
-                includeGroupAndSubgroups("com.google")
-            }
-        }
-        mavenCentral()
-        gradlePluginPortal()
-        maven {
-            url = uri("https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven")
-            credentials {username = "download_packages"; password = "gldt-bjDqLpU_sPcHDuXau2ws" }
-        }
-        maven {
-            url = uri("https://artifacts.mservice.com.vn/repository/maven-momo-app/")
-            credentials {
-                username = "viewer"
-                password = "viewer"
-            }
-            isAllowInsecureProtocol = true
-        }
-    }
-}
-
-dependencyResolutionManagement {
-    repositories {
-        google {
-            mavenContent {
-                includeGroupAndSubgroups("androidx")
-                includeGroupAndSubgroups("com.android")
-                includeGroupAndSubgroups("com.google")
-            }
-        }
-        mavenCentral()
-        maven { url = uri("https://maven.pkg.jetbrains.space/public/p/compose/dev") }
-        maven {
-            url = uri("https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven")
-            credentials {
-                username = "download_packages";
-                password = "gldt-bjDqLpU_sPcHDuXau2ws"
-            }
-        }
-        maven {
-            url = uri("https://artifacts.mservice.com.vn/repository/maven-momo-app/")
-            credentials {
-                username = "viewer"
-                password = "viewer"
-            }
-            isAllowInsecureProtocol = true
-        }
-    }
-}
-
-include(":compose")
-
-include(":sample:androidApp")
-include(":sample:shared")