@momo-kits/native-kits 0.152.1-beta.1 → 0.152.2-beta.121

package/ios/PopupView/Utils++.swift

@@ -1,281 +0,0 @@
-import SwiftUI
-import Combine
-
-final class DispatchWorkHolder {
-    var work: DispatchWorkItem?
-}
-
-final class ClassReference<T> {
-    var value: T
-
-    init(_ value: T) {
-        self.value = value
-    }
-}
-
-public extension View {
-    
-    @ViewBuilder
-    func valueChanged<T: Equatable>(value: T, onChange: @escaping (T) -> Void) -> some View {
-        if #available(iOS 14.0, tvOS 14.0, macOS 11.0, watchOS 7.0, *) {
-            self.onChange(of: value, perform: onChange)
-        } else {
-            self.onReceive(Just(value)) { value in
-                onChange(value)
-            }
-        }
-    }
-}
-
-public extension View {
-    @ViewBuilder
-    func applyIf<T: View>(_ condition: Bool, apply: (Self) -> T) -> some View {
-        if condition {
-            apply(self)
-        } else {
-            self
-        }
-    }
-
-    @ViewBuilder
-    func addTapIf(if condition: Bool, onTap: @escaping ()->()) -> some View {
-        if condition {
-            self.simultaneousGesture(
-                TapGesture().onEnded {
-                    onTap()
-                }
-            )
-        } else {
-            self
-        }
-    }
-}
-
-struct FrameGetter: ViewModifier {
-
-    @Binding var frame: CGRect
-
-    func body(content: Content) -> some View {
-        content
-            .background(
-                GeometryReader { proxy -> AnyView in
-                    DispatchQueue.main.async {
-                        let rect = proxy.frame(in: .global)
-                        // This avoids an infinite layout loop
-                        if rect.integral != self.frame.integral {
-                            self.frame = rect
-                        }
-                    }
-                    return AnyView(EmptyView())
-                }
-            )
-    }
-}
-
-extension View {
-    public func frameGetter(_ frame: Binding<CGRect>) -> some View {
-        modifier(FrameGetter(frame: frame))
-    }
-}
-
-struct AnimationCompletionObserverModifier<Value>: AnimatableModifier where Value: VectorArithmetic, Value: Comparable {
-
-    /// While animating, SwiftUI changes the old input value to the new target value using this property. This value is set to the old value until the animation completes.
-    var animatableData: Value {
-        didSet {
-            notifyCompletionIfFinished()
-        }
-    }
-
-    /// The target value for which we're observing. This value is directly set once the animation starts. During animation, `animatableData` will hold the oldValue and is only updated to the target value once the animation completes.
-    private var targetValue: Value
-
-    /// The completion callback which is called once the animation completes.
-    private var completion: () -> Void
-
-    init(observedValue: Value, completion: @escaping () -> Void) {
-        self.completion = completion
-        self.animatableData = observedValue
-        targetValue = observedValue
-    }
-
-    /// Verifies whether the current animation is finished and calls the completion callback if true.
-    private func notifyCompletionIfFinished() {
-        guard animatableData == targetValue else { return }
-
-        /// Dispatching is needed to take the next runloop for the completion callback.
-        /// This prevents errors like "Modifying state during view update, this will cause undefined behavior."
-        DispatchQueue.main.async {
-            self.completion()
-        }
-    }
-
-    func body(content: Content) -> some View {
-        /// We're not really modifying the view so we can directly return the original input value.
-        return content
-    }
-}
-
-struct AnimatableModifierDouble: AnimatableModifier {
-
-    var targetValue: Double
-    static var done = false
-
-    // SwiftUI gradually varies it from old value to the new value
-    var animatableData: Double {
-        didSet {
-            checkIfFinished()
-        }
-    }
-    var completion: () -> ()
-
-    // Re-created every time the control argument changes
-    init(bindedValue: Double, completion: @escaping () -> ()) {
-        self.completion = completion
-
-        // Set animatableData to the new value. But SwiftUI again directly
-        // and gradually varies the value while the body
-        // is being called to animate. Following line serves the purpose of
-        // associating the extenal argument with the animatableData.
-        self.animatableData = bindedValue
-        targetValue = bindedValue
-        AnimatableModifierDouble.done = false
-    }
-
-    func checkIfFinished() -> () {
-        if AnimatableModifierDouble.done { return }
-        let delta = 0.1
-        if animatableData > targetValue - delta &&
-            animatableData < targetValue + delta {
-            //print("check", animatableData, targetValue)
-            AnimatableModifierDouble.done = true
-            DispatchQueue.main.async {
-                self.completion()
-            }
-        }
-    }
-
-    func body(content: Content) -> some View {
-        content
-    }
-}
-
-extension View {
-
-    func onAnimationCompleted(for value: Double, completion: @escaping () -> Void) -> some View {
-        modifier(AnimatableModifierDouble(bindedValue: value, completion: completion))
-    }
-}
-
-extension UIApplication {
-    var keyWindow: UIWindow? {
-        connectedScenes
-            .compactMap {
-                $0 as? UIWindowScene
-            }
-            .flatMap {
-                $0.windows
-            }
-            .first {
-                $0.isKeyWindow
-            }
-    }
-}
-
-private struct SafeAreaInsetsKey: EnvironmentKey {
-    static var defaultValue: EdgeInsets {
-        UIApplication.shared.keyWindow?.safeAreaInsets.swiftUiInsets ?? EdgeInsets()
-    }
-}
-
-extension EnvironmentValues {
-    var safeAreaInsets: EdgeInsets {
-        self[SafeAreaInsetsKey.self]
-    }
-}
-
-private extension UIEdgeInsets {
-    var swiftUiInsets: EdgeInsets {
-        EdgeInsets(top: top, leading: left, bottom: bottom, trailing: right)
-    }
-}
-
-extension View {
-
-    func transparentNonAnimatingFullScreenCover<Content: View>(isPresented: Binding<Bool>, content: @escaping () -> Content) -> some View {
-        modifier(TransparentNonAnimatableFullScreenModifier(isPresented: isPresented, fullScreenContent: content))
-    }
-}
-
-private struct TransparentNonAnimatableFullScreenModifier<FullScreenContent: View>: ViewModifier {
-
-    @Binding var isPresented: Bool
-    let fullScreenContent: () -> (FullScreenContent)
-
-    func body(content: Content) -> some View {
-        if #available(iOS 14.0, *) {
-            content
-                .valueChanged(value: isPresented, onChange: { isPresented in
-                    UIView.setAnimationsEnabled(false)
-                })
-                .fullScreenCover(isPresented: $isPresented, content: {
-                    ZStack {
-                        fullScreenContent()
-                    }
-                    .background(FullScreenCoverBackgroundRemovalView())
-                    .onAppear {
-                        if !UIView.areAnimationsEnabled {
-                            UIView.setAnimationsEnabled(true)
-                        }
-                    }
-                    .onDisappear {
-                        if !UIView.areAnimationsEnabled {
-                            UIView.setAnimationsEnabled(true)
-                        }
-                    }
-                })
-        } else {
-            content
-                .valueChanged(value: isPresented, onChange: { isPresented in
-                    UIView.setAnimationsEnabled(false)
-                })
-                .sheet(isPresented: $isPresented, content: {
-                    ZStack {
-                        fullScreenContent()
-                    }
-                    .background(FullScreenCoverBackgroundRemovalView())
-                    .onAppear {
-                        if !UIView.areAnimationsEnabled {
-                            UIView.setAnimationsEnabled(true)
-                        }
-                    }
-                    .onDisappear {
-                        if !UIView.areAnimationsEnabled {
-                            UIView.setAnimationsEnabled(true)
-                        }
-                    }
-                })
-        }
-    }
-
-}
-
-private struct FullScreenCoverBackgroundRemovalView: UIViewRepresentable {
-
-    private class BackgroundRemovalView: UIView {
-
-        override func didMoveToWindow() {
-            super.didMoveToWindow()
-
-            superview?.superview?.backgroundColor = .clear
-        }
-
-    }
-
-    func makeUIView(context: Context) -> UIView {
-        return BackgroundRemovalView()
-    }
-
-    func updateUIView(_ uiView: UIView, context: Context) {}
-
-}

package/ios/ScrollIndicator/ScrollIndicator.swift

@@ -1,110 +0,0 @@
-import Foundation
-import SwiftUI
-
-public struct ScrollViewWithScrollBar<Content: View>: View {
-    let INDICATOR_HEIGHT: CGFloat = 4
-    @State var position = CGPoint(x: 0, y: 2)  //2 is INDICATOR_HEIGHT/2
-    @State var contentSize: CGFloat = 0
-    @State var scrollViewWidth: CGFloat = 0
-    var indicatorWidth: CGFloat
-    var indicatorContainerWidth: CGFloat
-    var indicatorColor: Color
-    var indicatorContainerColor: Color
-    var spacing: CGFloat = 4
-    @ViewBuilder var content: () -> Content
-
-    public init(
-        indicatorWidth: CGFloat = 12, indicatorContainerWidth: CGFloat = 36,
-        indicatorColor: Color = Colors.primary, indicatorContainerColor: Color = Colors.black06,
-        spacing: CGFloat = 4,
-        @ViewBuilder content: @escaping () -> Content
-    ) {
-        self.indicatorWidth = indicatorWidth
-        self.indicatorContainerWidth = indicatorContainerWidth
-        self.indicatorColor = indicatorColor
-        self.indicatorContainerColor = indicatorContainerColor
-        self.content = content
-        self.spacing = spacing
-    }
-
-  // MARK: Public
-
-    public var body: some View {
-        return VStack(spacing: spacing) {
-        ScrollView(.horizontal, showsIndicators: false) {
-            HStack {
-            content()
-            }
-            .fixedSize(horizontal: true, vertical: false)
-            .overlay(
-            GeometryReader { proxy in
-                Color.clear
-                .preference(
-                    key: ViewOffsetKey.self,
-                    value: -proxy.frame(in: .named("scroll")).origin.x
-                )
-                .preference(
-                    key: ContentSizeKey.self,
-                    value: proxy.size.width)
-            },
-            alignment: .topLeading
-            )
-            .onPreferenceChange(ContentSizeKey.self) { newContentSize in
-            if newContentSize > 0 {
-                self.contentSize = newContentSize
-                if self.position == CGPoint(x: 0, y: 2) {
-                self.position = CGPoint(x: indicatorWidth / 2, y: INDICATOR_HEIGHT / 2)
-                }
-            }
-            }
-            .onPreferenceChange(ViewOffsetKey.self) { offset in
-            let newPosition =
-                (offset * ((indicatorContainerWidth - indicatorWidth) / (contentSize - scrollViewWidth)))
-                + indicatorWidth / 2
-
-            if !newPosition.isNaN {
-                self.position = CGPoint(x: newPosition, y: INDICATOR_HEIGHT / 2)
-            }
-            }
-        }.background(
-            GeometryReader { proxy in
-            Color.clear.onAppear {
-                self.scrollViewWidth = proxy.size.width
-            }
-            }
-        ).coordinateSpace(name: "scroll")
-
-        HStack(spacing: 0) {
-            HStack(spacing: 0) {}.frame(width: indicatorWidth, height: INDICATOR_HEIGHT)
-            .background(indicatorColor)
-            .cornerRadius(8)
-            .position(self.position)
-        }.frame(width: indicatorContainerWidth, height: INDICATOR_HEIGHT, alignment: .leading)
-            .background(indicatorContainerColor).cornerRadius(8)
-        }
-    }
-}
-
-// MARK: - ViewOffsetKey
-
-struct ViewOffsetKey: PreferenceKey {
-    typealias Value = CGFloat
-
-    static var defaultValue = CGFloat.zero
-
-    static func reduce(value: inout Value, nextValue: () -> Value) {
-        value += nextValue()
-    }
-}
-
-// MARK: - ContentSizeKey
-
-struct ContentSizeKey: PreferenceKey {
-    typealias Value = CGFloat
-
-    static var defaultValue = CGFloat.zero
-
-    static func reduce(value: inout Value, nextValue: () -> Value) {
-        value = nextValue()
-    }
-}

package/ios/Swipeable/SwipeCell.swift

@@ -1,278 +0,0 @@
-import Foundation
-import SwiftUI
-
-// MARK: - SwipeCellModifier
-
-public struct SwipeCellModifier: ViewModifier {
-    var id: String
-    var cellWidth: CGFloat = .infinity
-    var leadingSideGroup: [SwipeCellActionItem] = []
-    var trailingSideGroup: [SwipeCellActionItem] = []
-    @Binding var currentUserInteractionCellID: String?
-    var settings: SwipeCellSettings = .init()
-
-    @State private var offsetX: CGFloat = 0
-
-    let generator = UINotificationFeedbackGenerator()
-    @State private var hapticFeedbackOccurred: Bool = false
-    @State private var openSideLock: SwipeGroupSide?
-
-    public func body(content: Content)->some View {
-        ZStack {
-            if self.leadingSideGroup.isEmpty == false && self.offsetX != 0 {
-                self.swipeToRevealArea(swipeItemGroup: self.leadingSideGroup, side: .leading)
-            }
-
-            if self.trailingSideGroup.isEmpty == false && self.offsetX != 0 {
-                self.swipeToRevealArea(swipeItemGroup: self.trailingSideGroup, side: .trailing)
-            }
-
-            content
-                .offset(x: self.offsetX)
-                .simultaneousGesture(
-                    DragGesture(minimumDistance: 30, coordinateSpace: .local)
-                        .onChanged { value in
-                            self.dragOnChanged(value: value)
-                        }
-                        .onEnded { value in
-                            self.dragOnEnded(value: value)
-                        }
-                )
-
-        }.frame(width: cellWidth)
-            .edgesIgnoringSafeArea(.horizontal)
-            .clipped()
-            .valueChanged(value: self.currentUserInteractionCellID) { _ in
-                if let currentDragCellID = self.currentUserInteractionCellID, currentDragCellID != self.id && self.openSideLock != nil {
-                    // if this cell has an open side area and is not the cell being dragged, close the cell
-                    self.setOffsetX(value: 0)
-                    // reset the drag cell id to nil
-                    self.currentUserInteractionCellID = nil
-                }
-            }
-    }
-
-    internal func swipeToRevealArea(swipeItemGroup: [SwipeCellActionItem], side: SwipeGroupSide)->some View {
-        HStack {
-            if side == .trailing {
-                Spacer()
-            }
-            ZStack {
-                HStack(spacing: 0) {
-                    ForEach(swipeItemGroup) { item in
-                        SwiftUI.Button {
-                            self.setOffsetX(value: 0)
-                            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
-                                item.actionCallback()
-                            }
-                        } label: {
-                            self.buttonContentView(item: item, group: swipeItemGroup, side: side)
-                        }.buttonStyle(BorderlessButtonStyle())
-                    }
-                }
-            }.opacity(self.swipeRevealAreaOpacity(side: side))
-
-            if side == .leading {
-                Spacer()
-            }
-        }
-    }
-
-    internal func buttonContentView(item: SwipeCellActionItem, group: [SwipeCellActionItem], side: SwipeGroupSide)->some View {
-        ZStack {
-            item.backgroundColor
-
-            HStack {
-                if self.warnSwipeOutCondition(side: side, hasSwipeOut: item.swipeOutAction) && item.swipeOutButtonView != nil {
-                    item.swipeOutButtonView!()
-                } else {
-                    item.buttonView()
-                }
-            }
-
-        }.frame(width: self.itemButtonWidth(item: item, itemGroup: group, side: side))
-    }
-
-    internal func menuWidth(side: SwipeGroupSide)->CGFloat {
-        switch side {
-        case .leading:
-            return self.leadingSideGroup.map { $0.buttonWidth }.reduce(0, +)
-
-        case .trailing:
-            return self.trailingSideGroup.map { $0.buttonWidth }.reduce(0, +)
-        }
-    }
-
-    // MARK: drag gesture
-
-    internal func dragOnChanged(value: DragGesture.Value) {
-        let horizontalTranslation = value.translation.width
-        if self.nonDraggableCondition(horizontalTranslation: horizontalTranslation) {
-            return
-        }
-
-        if self.openSideLock != nil {
-            // if one side is open, we need to add the menu width!
-            let menuWidth = self.openSideLock == .leading ? self.menuWidth(side: .leading) : self.menuWidth(side: .trailing)
-            self.offsetX = menuWidth * openSideLock!.sideFactor + horizontalTranslation
-            self.triggerHapticFeedbackIfNeeded(horizontalTranslation: horizontalTranslation)
-            return
-        }
-
-        self.triggerHapticFeedbackIfNeeded(horizontalTranslation: horizontalTranslation)
-
-        if horizontalTranslation > 8 || horizontalTranslation < -8 { // makes sure the swipe cell doesn't open too easily
-            self.currentUserInteractionCellID = self.id
-            self.offsetX = horizontalTranslation
-        } else {
-            self.offsetX = 0
-        }
-    }
-
-    internal func nonDraggableCondition(horizontalTranslation: CGFloat)->Bool {
-        return self.offsetX == 0 && (self.leadingSideGroup.isEmpty && horizontalTranslation > 0 || self.trailingSideGroup.isEmpty && horizontalTranslation < 0)
-    }
-
-    internal func dragOnEnded(value: DragGesture.Value) {
-        let swipeOutTriggerValue = self.cellWidth * self.settings.swipeOutTriggerRatio
-
-        if self.offsetX == 0 {
-            self.openSideLock = nil
-        } else if self.offsetX > 0 {
-            if self.leadingSideGroup.isEmpty == false {
-                if self.offsetX < settings.openTriggerValue || (self.openSideLock == .leading && self.offsetX < self.menuWidth(side: .leading) * 0.8) {
-                    self.setOffsetX(value: 0)
-                } else if let leftItem = self.leadingSideGroup.filter({ $0.swipeOutAction == true }).first, self.offsetX.magnitude > swipeOutTriggerValue {
-                    self.swipeOutAction(item: leftItem, sideFactor: 1)
-                } else {
-                    self.lockSideMenu(side: .leading)
-                }
-
-            } else {
-                // leading group emtpy
-                self.setOffsetX(value: 0)
-            }
-        } else if self.offsetX < 0 {
-            if self.trailingSideGroup.isEmpty == false {
-                if self.offsetX.magnitude < settings.openTriggerValue || (self.openSideLock == .trailing && self.offsetX > -self.menuWidth(side: .trailing) * 0.8) {
-                    self.setOffsetX(value: 0)
-                } else if let rightItem = self.trailingSideGroup.filter({ $0.swipeOutAction == true }).first, self.offsetX.magnitude > swipeOutTriggerValue {
-                    self.swipeOutAction(item: rightItem, sideFactor: -1)
-                } else {
-                    self.lockSideMenu(side: .trailing)
-                }
-
-            } else {
-                // trailing group emtpy
-                self.setOffsetX(value: 0)
-            }
-        }
-    }
-
-    internal func triggerHapticFeedbackIfNeeded(horizontalTranslation: CGFloat) {
-        let side: SwipeGroupSide = horizontalTranslation > 0 ? .leading : .trailing
-        let group = side == .leading ? self.leadingSideGroup : self.trailingSideGroup
-        let swipeOutActionCondition = self.warnSwipeOutCondition(side: side, hasSwipeOut: true)
-        if let item = self.swipeOutItemWithHapticFeedback(group: group), self.hapticFeedbackOccurred == false, swipeOutActionCondition == true {
-            self.generator.notificationOccurred(item.swipeOutHapticFeedbackType!)
-            self.hapticFeedbackOccurred = true
-        }
-    }
-
-    internal func swipeOutItemWithHapticFeedback(group: [SwipeCellActionItem])->SwipeCellActionItem? {
-        if let item = group.filter({ $0.swipeOutAction == true }).first {
-            if item.swipeOutHapticFeedbackType != nil {
-                return item
-            }
-        }
-        return nil
-    }
-
-    internal func swipeOutAction(item: SwipeCellActionItem, sideFactor: CGFloat) {
-        if item.swipeOutIsDestructive {
-            let swipeOutWidth = cellWidth + 10
-            self.setOffsetX(value: swipeOutWidth * sideFactor)
-            self.openSideLock = nil
-        } else {
-            self.setOffsetX(value: 0) // open side lock set in function!
-        }
-
-        DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
-            item.actionCallback()
-        }
-    }
-
-    internal func lockSideMenu(side: SwipeGroupSide) {
-        self.setOffsetX(value: side.sideFactor * self.menuWidth(side: side))
-        self.openSideLock = side
-        self.hapticFeedbackOccurred = false
-    }
-
-    internal func setOffsetX(value: CGFloat) {
-        withAnimation(.spring()) {
-            self.offsetX = value
-        }
-        if self.offsetX == 0 {
-            self.openSideLock = nil
-            self.hapticFeedbackOccurred = false
-        }
-    }
-
-    internal func itemButtonWidth(item: SwipeCellActionItem, itemGroup: [SwipeCellActionItem], side: SwipeGroupSide)->CGFloat {
-        let dynamicButtonWidth = self.dynamicButtonWidth(item: item, itemCount: itemGroup.count, side: side)
-        let triggerValue = self.cellWidth * settings.swipeOutTriggerRatio
-        let swipeOutActionCondition = side == .leading ? self.offsetX > triggerValue : self.offsetX < -triggerValue
-
-        if item.swipeOutAction && swipeOutActionCondition {
-            return self.offsetX.magnitude + settings.addWidthMargin
-        } else if swipeOutActionCondition && item.swipeOutAction == false && itemGroup.contains(where: { $0.swipeOutAction == true }) {
-            return 0
-        } else {
-            return dynamicButtonWidth
-        }
-    }
-
-    internal func dynamicButtonWidth(item: SwipeCellActionItem, itemCount: Int, side: SwipeGroupSide)->CGFloat {
-        let menuWidth = self.menuWidth(side: side)
-        return (self.offsetX.magnitude + settings.addWidthMargin) * (item.buttonWidth / menuWidth)
-    }
-
-    internal func warnSwipeOutCondition(side: SwipeGroupSide, hasSwipeOut: Bool)->Bool {
-        if hasSwipeOut == false {
-            return false
-        }
-        let triggerValue = self.cellWidth * settings.swipeOutTriggerRatio
-        return (side == .trailing && self.offsetX < -triggerValue) || (side == .leading && self.offsetX > triggerValue)
-    }
-
-    internal func swipeRevealAreaOpacity(side: SwipeGroupSide)->Double {
-        switch side {
-        case .leading:
-
-            return self.offsetX > 5 ? 1 : 0
-        case .trailing:
-            return self.offsetX < -5 ? 1 : 0
-        }
-    }
-}
-
-public extension View {
-    /// swipe cell modifier
-    /// - Parameters:
-    ///   - id: the string id of this cell. The default value is a uuid string. If you want to set the currentUserInteractionCellID yourself, e.g. for tap to close functionality, you need to override this id value with your own cell id.
-    ///   - cellWidth: the width of the content view - typically a cell or row in a list under which the swipe to reveal menu should appear.
-    ///   - leadingSideGroup: the button group on the leading side that shall appear when the user swipes the cell to the right
-    ///   - trailingSideGroup: the button group on the trailing side that shall appear when the user swipes the cell to the left
-    ///   - currentUserInteractionCellID: a Binding of an optional UUID that should be set either in the view model of the parent view in which the cells appear or as a State variable into the parent view itself. Don't assign it a value!
-    ///   - settings: settings. can be omitted in which case the settings struct default values apply.
-    /// - Returns: the modified view of the view that can be swiped.
-    func swipeCell(id: String = UUID().uuidString, cellWidth: CGFloat = .infinity, leadingSideGroup: [SwipeCellActionItem], trailingSideGroup: [SwipeCellActionItem], currentUserInteractionCellID: Binding<String?> = .constant(""), settings: SwipeCellSettings = SwipeCellSettings())->some View {
-        self.modifier(SwipeCellModifier(id: id, cellWidth: cellWidth, leadingSideGroup: leadingSideGroup, trailingSideGroup: trailingSideGroup, currentUserInteractionCellID: currentUserInteractionCellID, settings: settings))
-    }
-}
-
-public extension View {
-    func castToAnyView()->AnyView {
-        return AnyView(self)
-    }
-}