@momo-kits/native-kits 0.0.1-beta.4 → 0.2.0-kt22

package/ios/PopupView/Utils++.swift

@@ -0,0 +1,281 @@
+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

@@ -0,0 +1,110 @@
+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

@@ -10,9 +10,9 @@ public struct SwipeCellModifier: ViewModifier {
     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?
@@ -22,15 +22,23 @@ public struct SwipeCellModifier: ViewModifier {
             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)
-                .gesture(DragGesture(minimumDistance: 30, coordinateSpace: .local).onChanged(self.dragOnChanged(value:)).onEnded(dragOnEnded(value:)))
-                    
+                .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()
@@ -43,7 +51,7 @@ public struct SwipeCellModifier: ViewModifier {
                 }
             }
     }
-    
+
     internal func swipeToRevealArea(swipeItemGroup: [SwipeCellActionItem], side: SwipeGroupSide)->some View {
         HStack {
             if side == .trailing {
@@ -63,17 +71,17 @@ public struct SwipeCellModifier: ViewModifier {
                     }
                 }
             }.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!()
@@ -81,28 +89,28 @@ public struct SwipeCellModifier: ViewModifier {
                     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)
@@ -110,9 +118,9 @@ public struct SwipeCellModifier: ViewModifier {
             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
@@ -120,11 +128,11 @@ public struct SwipeCellModifier: ViewModifier {
             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
 
@@ -139,7 +147,7 @@ public struct SwipeCellModifier: ViewModifier {
                 } else {
                     self.lockSideMenu(side: .leading)
                 }
-                
+
             } else {
                 // leading group emtpy
                 self.setOffsetX(value: 0)
@@ -160,7 +168,7 @@ public struct SwipeCellModifier: ViewModifier {
             }
         }
     }
-    
+
     internal func triggerHapticFeedbackIfNeeded(horizontalTranslation: CGFloat) {
         let side: SwipeGroupSide = horizontalTranslation > 0 ? .leading : .trailing
         let group = side == .leading ? self.leadingSideGroup : self.trailingSideGroup
@@ -170,7 +178,7 @@ public struct SwipeCellModifier: ViewModifier {
             self.hapticFeedbackOccurred = true
         }
     }
-    
+
     internal func swipeOutItemWithHapticFeedback(group: [SwipeCellActionItem])->SwipeCellActionItem? {
         if let item = group.filter({ $0.swipeOutAction == true }).first {
             if item.swipeOutHapticFeedbackType != nil {
@@ -179,7 +187,7 @@ public struct SwipeCellModifier: ViewModifier {
         }
         return nil
     }
-    
+
     internal func swipeOutAction(item: SwipeCellActionItem, sideFactor: CGFloat) {
         if item.swipeOutIsDestructive {
             let swipeOutWidth = cellWidth + 10
@@ -188,12 +196,12 @@ public struct SwipeCellModifier: ViewModifier {
         } 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
@@ -214,7 +222,7 @@ public struct SwipeCellModifier: ViewModifier {
         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 }) {
@@ -223,12 +231,12 @@ public struct SwipeCellModifier: ViewModifier {
             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
@@ -236,11 +244,11 @@ public struct SwipeCellModifier: ViewModifier {
         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

package/ios/Switch/Switch.swift

@@ -0,0 +1,44 @@
+import Foundation
+import SwiftUI
+
+public struct Switch: View{
+    @Binding var value: Bool
+    var disabled: Bool
+    var onChange: ((Bool)->Void)?
+    
+    public init(_ value: Binding<Bool>,disabled: Bool = false, onChange: ((Bool)->Void)? = nil){
+        self._value = value
+        self.disabled = disabled
+        self.onChange = onChange
+    }
+    
+    
+    public var body: some View {
+        SwiftUI.Button(action: {
+            withAnimation{
+                value.toggle()
+                onChange?(value)
+            }
+        }){
+              HStack{
+                  HStack {
+                  }
+                  .frame(width: 6, height: 6)
+                  .background(value ? Colors.pink03 : Colors.black07)
+                  .clipShape(Circle())
+                  .opacity(disabled ? 0.4 : 1)
+              }
+              .frame(width: 14, height: 14)
+              .background(Colors.black01)
+              .clipShape(Circle())
+              .padding(.leading,5)
+              .padding(.trailing,5)
+              
+          }
+          .disabled(disabled)
+          .frame(width: 40, height: 24, alignment: value == true ? .trailing : .leading)
+          .background(value ? Colors.pink03 : Colors.black07)
+          .clipShape(Capsule())
+          .opacity(disabled ? 0.4 : 1)
+    }
+}