@momo-kits/native-kits 0.152.4-beta.6 → 0.152.4-maxapi

package/ios/PopupView/FullscreenPopup.swift

@@ -0,0 +1,251 @@
+
+import Foundation
+import SwiftUI
+
+public struct FullscreenPopup<Item: Equatable, PopupContent: View>: ViewModifier {
+
+    // MARK: - Presentaion
+    @Binding var isPresented: Bool
+    @Binding var item: Item?
+
+    var isBoolMode: Bool
+
+    var sheetPresented: Bool {
+        item != nil || isPresented
+    }
+
+    // MARK: - Parameters
+    var type: Popup<Item, PopupContent>.PopupType
+    var position: Popup<Item, PopupContent>.Position
+
+    var animation: Animation
+
+    /// If nil - never hides on its own
+    var autohideIn: Double?
+
+    /// Should allow dismiss by dragging
+    var dragToDismiss: Bool
+
+    /// Should close on tap outside - default is `true`
+    var closeOnTapOutside: Bool
+
+    /// Background color for outside area - default is `Color.clear`
+    var backgroundColor: Color
+
+    /// is called on any close action
+    var dismissCallback: (DismissSource) -> ()
+
+    var view: () -> PopupContent
+
+    // MARK: - Presentation animation
+    /// Trigger popup showing/hiding animations and...
+    @State private var shouldShowContent = false
+
+    /// ... once hiding animation is finished remove popup from the memory using this flag
+    @State private var showContent = false
+
+    /// show transparentNonAnimatingFullScreenCover
+    @State private var showSheet = false
+
+    /// opacity of background color
+    @State private var opacity = 0.0
+
+    // MARK: - Autohide
+    /// Class reference for capturing a weak reference later in dispatch work holder.
+    private var isPresentedRef: ClassReference<Binding<Bool>>?
+    private var itemRef: ClassReference<Binding<Item?>>?
+
+    /// holder for autohiding dispatch work (to be able to cancel it when needed)
+    private var dispatchWorkHolder = DispatchWorkHolder()
+
+    // MARK: - Internal
+    /// Set dismiss souce to pass to dismiss callback
+    @State private var dismissSource: DismissSource?
+
+    init(isPresented: Binding<Bool>,
+         type: Popup<Item, PopupContent>.PopupType = .`default`,
+         position: Popup<Item, PopupContent>.Position = .bottom,
+         animation: Animation,
+         autohideIn: Double?,
+         dragToDismiss: Bool,
+         closeOnTapOutside: Bool,
+         backgroundColor: Color,
+         dismissCallback: @escaping (DismissSource) -> (),
+         view: @escaping () -> PopupContent) {
+        self._isPresented = isPresented
+        self._item = .constant(nil)
+        self.isBoolMode = true
+
+        self.type = type
+        self.position = position
+        self.animation = animation
+        self.autohideIn = autohideIn
+        self.dragToDismiss = dragToDismiss
+        self.closeOnTapOutside = closeOnTapOutside
+        self.backgroundColor = backgroundColor
+        self.dismissCallback = dismissCallback
+        self.view = view
+
+        self.isPresentedRef = ClassReference(self.$isPresented)
+        self.itemRef = ClassReference(self.$item)
+    }
+
+    init(item: Binding<Item?>,
+         type: Popup<Item, PopupContent>.PopupType = .`default`,
+         position: Popup<Item, PopupContent>.Position = .bottom,
+         animation: Animation,
+         autohideIn: Double?,
+         dragToDismiss: Bool,
+         closeOnTapOutside: Bool,
+         backgroundColor: Color,
+         dismissCallback: @escaping (DismissSource) -> (),
+         view: @escaping () -> PopupContent) {
+        self._isPresented = .constant(false)
+        self._item = item
+        self.isBoolMode = false
+
+        self.type = type
+        self.position = position
+        self.animation = animation
+        self.autohideIn = autohideIn
+        self.dragToDismiss = dragToDismiss
+        self.closeOnTapOutside = closeOnTapOutside
+        self.backgroundColor = backgroundColor
+        self.dismissCallback = dismissCallback
+        self.view = view
+
+        self.isPresentedRef = ClassReference(self.$isPresented)
+        self.itemRef = ClassReference(self.$item)
+    }
+
+    public func body(content: Content) -> some View {
+        if isBoolMode {
+            boolBody(content: content)
+        } else {
+            itemBody(content: content)
+        }
+    }
+
+    func backgroundColorView() -> some View {
+        backgroundColor.opacity(opacity)
+            .applyIf(closeOnTapOutside) { view in
+                view.contentShape(Rectangle())
+            }
+            .addTapIf(if: closeOnTapOutside) {
+                dismissSource = .tapOutside
+                isPresented = false
+                item = nil
+            }
+            .edgesIgnoringSafeArea(.all)
+            .animation(.linear(duration: 0.2), value: opacity)
+    }
+
+    public func boolBody(content: Content) -> some View {
+        content
+            .transparentNonAnimatingFullScreenCover(isPresented: $showSheet) {
+                backgroundColorView()
+                    .modifier(
+                        Popup(
+                            isPresented: $isPresented,
+                            type: type,
+                            position: position,
+                            animation: animation,
+                            autohideIn: autohideIn,
+                            dragToDismiss: dragToDismiss,
+                            closeOnTapOutside: closeOnTapOutside,
+                            shouldShowContent: shouldShowContent,
+                            showContent: showContent,
+                            dismissCallback: { _ in },
+                            dismissSource: $dismissSource,
+                            animationCompletedCallback: onAnimationCompleted,
+                            view: view)
+                    )
+            }
+            .valueChanged(value: isPresented, onChange: { newValue in
+                appearAction(sheetPresented: newValue)
+            })
+    }
+
+    public func itemBody(content: Content) -> some View {
+        content
+            .transparentNonAnimatingFullScreenCover(isPresented: $showSheet) {
+                backgroundColorView()
+                    .modifier(
+                        Popup(
+                            item: $item,
+                            type: type,
+                            position: position,
+                            animation: animation,
+                            autohideIn: autohideIn,
+                            dragToDismiss: dragToDismiss,
+                            closeOnTapOutside: closeOnTapOutside,
+                            shouldShowContent: shouldShowContent,
+                            showContent: showContent,
+                            dismissCallback: { _ in },
+                            dismissSource: $dismissSource,
+                            animationCompletedCallback: onAnimationCompleted,
+                            view: view)
+                    )
+            }
+            .valueChanged(value: item, onChange: { newValue in
+                appearAction(sheetPresented: newValue != nil)
+            })
+    }
+
+    func appearAction(sheetPresented: Bool) {
+        if sheetPresented {
+            dismissSource = nil
+            showSheet = true // show transparent fullscreen sheet
+            showContent = true // immediately load popup body
+            performWithDelay(0.01) {
+                shouldShowContent = true // this will cause currentOffset change thus triggering the sliding showing animation
+                opacity = 1 // this will cause cross disolving animation for background color
+                setupAutohide()
+            }
+        } else {
+            dispatchWorkHolder.work?.cancel()
+            shouldShowContent = false // this will cause currentOffset change thus triggering the sliding hiding animation
+            opacity = 0
+            // do the rest once the animation is finished (see onAnimationCompleted())
+            performWithDelay(0.3) { // TEMP: imitate onAnimationCompleted for now
+                onAnimationCompleted()
+            }
+        }
+    }
+
+    func onAnimationCompleted() -> () {
+        if shouldShowContent { // return if this was called on showing animation, only proceed if called on hiding
+            return
+        }
+        showContent = false // unload popup body after hiding animation is done
+        performWithDelay(0.01) {
+            showSheet = false
+        }
+        dismissCallback(dismissSource ?? .binding)
+    }
+
+    func setupAutohide() {
+        // if needed, dispatch autohide and cancel previous one
+        if let autohideIn = autohideIn {
+            dispatchWorkHolder.work?.cancel()
+
+            // Weak reference to avoid the work item capturing the struct,
+            // which would create a retain cycle with the work holder itself.
+            dispatchWorkHolder.work = DispatchWorkItem(block: { [weak isPresentedRef, weak itemRef] in
+                isPresentedRef?.value.wrappedValue = false
+                itemRef?.value.wrappedValue = nil
+                dismissSource = .autohide
+            })
+            if sheetPresented, let work = dispatchWorkHolder.work {
+                DispatchQueue.main.asyncAfter(deadline: .now() + autohideIn, execute: work)
+            }
+        }
+    }
+
+    func performWithDelay(_ delay: Double, block: @escaping ()->()) {
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
+            block()
+        }
+    }
+
+}

package/ios/PopupView/Modifiers.swift

@@ -0,0 +1,158 @@
+import SwiftUI
+
+extension View {
+
+    public func popup<Item: Equatable, PopupContent: View>(
+        item: Binding<Item?>,
+        type: Popup<Item, PopupContent>.PopupType = .`default`,
+        position: Popup<Item, PopupContent>.Position = .bottom,
+        animation: Animation = Animation.easeOut(duration: 0.3),
+        autohideIn: Double? = nil,
+        dragToDismiss: Bool = true,
+        closeOnTapOutside: Bool = false,
+        backgroundColor: Color = Color.clear,
+        @ViewBuilder view: @escaping () -> PopupContent) -> some View {
+            self.modifier(
+                FullscreenPopup(
+                    item: item,
+                    type: type,
+                    position: position,
+                    animation: animation,
+                    autohideIn: autohideIn,
+                    dragToDismiss: dragToDismiss,
+                    closeOnTapOutside: closeOnTapOutside,
+                    backgroundColor: backgroundColor,
+                    dismissCallback: { _ in },
+                    view: view)
+            )
+        }
+
+    public func popup<PopupContent: View>(
+        isPresented: Binding<Bool>,
+        type: Popup<Int, PopupContent>.PopupType = .`default`,
+        position: Popup<Int, PopupContent>.Position = .bottom,
+        animation: Animation = Animation.easeOut(duration: 0.3),
+        autohideIn: Double? = nil,
+        dragToDismiss: Bool = true,
+        closeOnTapOutside: Bool = false,
+        backgroundColor: Color = Color.clear,
+        @ViewBuilder view: @escaping () -> PopupContent) -> some View {
+            self.modifier(
+                FullscreenPopup<Int, PopupContent>(
+                    isPresented: isPresented,
+                    type: type,
+                    position: position,
+                    animation: animation,
+                    autohideIn: autohideIn,
+                    dragToDismiss: dragToDismiss,
+                    closeOnTapOutside: closeOnTapOutside,
+                    backgroundColor: backgroundColor,
+                    dismissCallback: { _ in },
+                    view: view)
+            )
+        }
+
+    public func popup<Item: Equatable, PopupContent: View>(
+        item: Binding<Item?>,
+        type: Popup<Item, PopupContent>.PopupType = .`default`,
+        position: Popup<Item, PopupContent>.Position = .bottom,
+        animation: Animation = Animation.easeOut(duration: 0.3),
+        autohideIn: Double? = nil,
+        dragToDismiss: Bool = true,
+        closeOnTapOutside: Bool = false,
+        backgroundColor: Color = Color.clear,
+        dismissCallback: @escaping () -> (),
+        @ViewBuilder view: @escaping () -> PopupContent) -> some View {
+            self.modifier(
+                FullscreenPopup(
+                    item: item,
+                    type: type,
+                    position: position,
+                    animation: animation,
+                    autohideIn: autohideIn,
+                    dragToDismiss: dragToDismiss,
+                    closeOnTapOutside: closeOnTapOutside,
+                    backgroundColor: backgroundColor,
+                    dismissCallback: { _ in dismissCallback() },
+                    view: view)
+            )
+        }
+
+    public func popup<PopupContent: View>(
+        isPresented: Binding<Bool>,
+        type: Popup<Int, PopupContent>.PopupType = .`default`,
+        position: Popup<Int, PopupContent>.Position = .bottom,
+        animation: Animation = Animation.easeOut(duration: 0.3),
+        autohideIn: Double? = nil,
+        dragToDismiss: Bool = true,
+        closeOnTapOutside: Bool = false,
+        backgroundColor: Color = Color.clear,
+        dismissCallback: @escaping () -> (),
+        @ViewBuilder view: @escaping () -> PopupContent) -> some View {
+            self.modifier(
+                FullscreenPopup<Int, PopupContent>(
+                    isPresented: isPresented,
+                    type: type,
+                    position: position,
+                    animation: animation,
+                    autohideIn: autohideIn,
+                    dragToDismiss: dragToDismiss,
+                    closeOnTapOutside: closeOnTapOutside,
+                    backgroundColor: backgroundColor,
+                    dismissCallback: { _ in dismissCallback() },
+                    view: view)
+            )
+        }
+
+    public func popup<Item: Equatable, PopupContent: View>(
+        item: Binding<Item?>,
+        type: Popup<Item, PopupContent>.PopupType = .`default`,
+        position: Popup<Item, PopupContent>.Position = .bottom,
+        animation: Animation = Animation.easeOut(duration: 0.3),
+        autohideIn: Double? = nil,
+        dragToDismiss: Bool = true,
+        closeOnTapOutside: Bool = false,
+        backgroundColor: Color = Color.clear,
+        dismissSourceCallback: @escaping (DismissSource) -> (),
+        @ViewBuilder view: @escaping () -> PopupContent) -> some View {
+            self.modifier(
+                FullscreenPopup(
+                    item: item,
+                    type: type,
+                    position: position,
+                    animation: animation,
+                    autohideIn: autohideIn,
+                    dragToDismiss: dragToDismiss,
+                    closeOnTapOutside: closeOnTapOutside,
+                    backgroundColor: backgroundColor,
+                    dismissCallback: dismissSourceCallback,
+                    view: view)
+            )
+        }
+
+    public func popup<PopupContent: View>(
+        isPresented: Binding<Bool>,
+        type: Popup<Int, PopupContent>.PopupType = .`default`,
+        position: Popup<Int, PopupContent>.Position = .bottom,
+        animation: Animation = Animation.easeOut(duration: 0.3),
+        autohideIn: Double? = nil,
+        dragToDismiss: Bool = true,
+        closeOnTapOutside: Bool = false,
+        backgroundColor: Color = Color.clear,
+        dismissSourceCallback: @escaping (DismissSource) -> (),
+        @ViewBuilder view: @escaping () -> PopupContent) -> some View {
+            self.modifier(
+                FullscreenPopup<Int, PopupContent>(
+                    isPresented: isPresented,
+                    type: type,
+                    position: position,
+                    animation: animation,
+                    autohideIn: autohideIn,
+                    dragToDismiss: dragToDismiss,
+                    closeOnTapOutside: closeOnTapOutside,
+                    backgroundColor: backgroundColor,
+                    dismissCallback: dismissSourceCallback,
+                    view: view)
+            )
+        }
+}

package/ios/PopupView/PopupView.swift

@@ -0,0 +1,289 @@
+import SwiftUI
+
+public enum DismissSource {
+    case binding // set isPresented to false ot item to nil
+    case tapInside
+    case tapOutside
+    case drag
+    case autohide
+}
+
+public struct Popup<Item: Equatable, PopupContent: View>: ViewModifier {
+    
+    init(isPresented: Binding<Bool>,
+         type: PopupType,
+         position: Position,
+         animation: Animation,
+         autohideIn: Double?,
+         dragToDismiss: Bool,
+         closeOnTapOutside: Bool,
+         shouldShowContent: Bool = true,
+         showContent: Bool = true,
+         dismissCallback: @escaping (DismissSource) -> (),
+         dismissSource: Binding<DismissSource?>,
+         animationCompletedCallback: @escaping () -> (),
+         view: @escaping () -> PopupContent) {
+        self._isPresented = isPresented
+        self._item = .constant(nil)
+        self.type = type
+        self.position = position
+        self.animation = animation
+        self.autohideIn = autohideIn
+        self.dragToDismiss = dragToDismiss
+        self.closeOnTapOutside = closeOnTapOutside
+        self.shouldShowContent = shouldShowContent
+        self.showContent = showContent
+        self.dismissCallback = dismissCallback
+        self._dismissSource = dismissSource
+        self.animationCompletedCallback = animationCompletedCallback
+        self.view = view
+    }
+
+    init(item: Binding<Item?>,
+         type: PopupType,
+         position: Position,
+         animation: Animation,
+         autohideIn: Double?,
+         dragToDismiss: Bool,
+         closeOnTapOutside: Bool,
+         shouldShowContent: Bool = true,
+         showContent: Bool = true,
+         dismissCallback: @escaping (DismissSource) -> (),
+         dismissSource: Binding<DismissSource?>,
+         animationCompletedCallback: @escaping () -> (),
+         view: @escaping () -> PopupContent) {
+        self._isPresented = .constant(false)
+        self._item = item
+        self.type = type
+        self.position = position
+        self.animation = animation
+        self.autohideIn = autohideIn
+        self.dragToDismiss = dragToDismiss
+        self.closeOnTapOutside = closeOnTapOutside
+        self.shouldShowContent = shouldShowContent
+        self.showContent = showContent
+        self.dismissCallback = dismissCallback
+        self._dismissSource = dismissSource
+        self.animationCompletedCallback = animationCompletedCallback
+        self.view = view
+    }
+    
+    public enum PopupType {
+
+        case `default`
+        case toast
+        case floater(verticalPadding: CGFloat = 10, useSafeAreaInset: Bool = true)
+
+        func shouldBeCentered() -> Bool {
+            switch self {
+            case .`default`:
+                return true
+            default:
+                return false
+            }
+        }
+    }
+
+    public enum Position {
+        case top
+        case bottom
+    }
+
+    private enum DragState {
+        case inactive
+        case dragging(translation: CGSize)
+
+        var translation: CGSize {
+            switch self {
+            case .inactive:
+                return .zero
+            case .dragging(let translation):
+                return translation
+            }
+        }
+
+        var isDragging: Bool {
+            switch self {
+            case .inactive:
+                return false
+            case .dragging:
+                return true
+            }
+        }
+    }
+
+    // MARK: - Public Properties
+    /// Tells if the sheet should be presented or not
+    @Binding var isPresented: Bool
+    @Binding var item: Item?
+
+    var type: PopupType
+    var position: Position
+
+    var animation: Animation
+
+    /// If nil - never hides on its own
+    var autohideIn: Double?
+
+    /// Should allow dismiss by dragging
+    var dragToDismiss: Bool
+
+    /// Should close on tap outside - default is `true`
+    var closeOnTapOutside: Bool
+
+    /// Trigger popup showing/hiding animations and...
+    var shouldShowContent: Bool
+
+    /// ... once hiding animation is finished remove popup from the memory using this flag
+    var showContent: Bool
+
+    /// is called on any close action
+    var dismissCallback: (DismissSource) -> ()
+
+    /// Set dismiss souce to pass to dismiss callback
+    @Binding private var dismissSource: DismissSource?
+
+    /// called on showing/hiding sliding animation completed
+    var animationCompletedCallback: () -> ()
+
+    var view: () -> PopupContent
+
+    // MARK: - Private Properties
+    @Environment(\.safeAreaInsets) private var safeAreaInsets
+
+    /// The rect and safe area of the hosting controller
+    @State private var presenterContentRect: CGRect = .zero
+
+    /// The rect and safe area of popup content
+    @State private var sheetContentRect: CGRect = .zero
+
+    /// Drag to dismiss gesture state
+    @GestureState private var dragState = DragState.inactive
+
+    /// Last position for drag gesture
+    @State private var lastDragPosition: CGFloat = 0
+    
+    /// The offset when the popup is displayed
+    private var displayedOffset: CGFloat {
+        switch type {
+        case .`default`:
+            return -presenterContentRect.midY + screenHeight/2
+        case .toast:
+            if position == .bottom {
+                return presenterContentRect.minY + safeAreaInsets.bottom + presenterContentRect.height - presenterContentRect.midY - sheetContentRect.height/2
+            } else {
+                return presenterContentRect.minY - safeAreaInsets.top - presenterContentRect.midY + sheetContentRect.height/2
+            }
+        case .floater(let verticalPadding, let useSafeAreaInset):
+            if position == .bottom {
+                return presenterContentRect.minY + safeAreaInsets.bottom + presenterContentRect.height - presenterContentRect.midY - sheetContentRect.height/2 - verticalPadding + (useSafeAreaInset ? -safeAreaInsets.bottom : 0)
+            } else {
+                return presenterContentRect.minY - safeAreaInsets.top - presenterContentRect.midY + sheetContentRect.height/2 + verticalPadding + (useSafeAreaInset ? safeAreaInsets.top : 0)
+            }
+        }
+    }
+
+    /// The offset when the popup is hidden
+    private var hiddenOffset: CGFloat {
+        if position == .top {
+            if presenterContentRect.isEmpty {
+                return -1000
+            }
+            return -presenterContentRect.midY - sheetContentRect.height/2 - 5
+        } else {
+            if presenterContentRect.isEmpty {
+                return 1000
+            }
+            return screenHeight - presenterContentRect.midY + sheetContentRect.height/2 + 5
+        }
+    }
+
+    /// The current offset, based on the **presented** property
+    private var currentOffset: CGFloat {
+        return shouldShowContent ? displayedOffset : hiddenOffset
+    }
+
+    private var screenSize: CGSize {
+        #if os(iOS) || os(tvOS)
+        return UIScreen.main.bounds.size
+        #elseif os(watchOS)
+        return WKInterfaceDevice.current().screenBounds.size
+        #else
+        return NSScreen.main?.frame.size ?? .zero
+        #endif
+    }
+
+    private var screenHeight: CGFloat {
+        screenSize.height
+    }
+
+    // MARK: - Content Builders
+    public func body(content: Content) -> some View {
+        content
+            .frameGetter($presenterContentRect)
+            .overlay(
+                Group {
+                    if showContent {
+                        sheet()
+                    }
+                }
+            )
+    }
+
+    /// This is the builder for the sheet content
+    func sheet() -> some View {
+        let sheet = ZStack {
+            self.view()
+                .frameGetter($sheetContentRect)
+                .offset(y: currentOffset)
+                .onAnimationCompleted(for: currentOffset) {
+                    animationCompletedCallback()
+                }
+                .animation(animation)
+        }
+
+        #if !os(tvOS)
+        let drag = DragGesture()
+            .updating($dragState) { drag, state, _ in
+                state = .dragging(translation: drag.translation)
+            }
+            .onEnded(onDragEnded)
+
+        return sheet
+            .applyIf(dragToDismiss) {
+                $0.offset(y: dragOffset())
+                    .simultaneousGesture(drag)
+            }
+        #else
+        return sheet
+        #endif
+    }
+
+    #if !os(tvOS)
+    func dragOffset() -> CGFloat {
+        if (position == .bottom && dragState.translation.height > 0) ||
+           (position == .top && dragState.translation.height < 0) {
+            return dragState.translation.height
+        }
+        return lastDragPosition
+    }
+
+    private func onDragEnded(drag: DragGesture.Value) {
+        let reference = sheetContentRect.height / 3
+        if (position == .bottom && drag.translation.height > reference) ||
+            (position == .top && drag.translation.height < -reference) {
+            lastDragPosition = drag.translation.height
+            withAnimation {
+                lastDragPosition = 0
+            }
+            dismissSource = .drag
+            dismiss()
+        }
+    }
+    #endif
+    
+    private func dismiss() {
+        isPresented = false
+        item = nil
+    }
+}