@momo-kits/native-kits 0.0.1-beta.3 → 0.0.1-beta.5

package/example/ios/Pods/SDWebImageSwiftUI/SDWebImageSwiftUI/Classes/ImagePlayer.swift

@@ -0,0 +1,122 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) DreamPiggy <lizhuoli1126@126.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import SwiftUI
+import SDWebImage
+
+/// A Image observable object for handle aniamted image playback. This is used to avoid `@State` update may capture the View struct type and cause memory leak.
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public final class ImagePlayer : ObservableObject {
+    var player: SDAnimatedImagePlayer?
+    
+    /// Max buffer size
+    public var maxBufferSize: UInt?
+    
+    /// Custom loop count
+    public var customLoopCount: UInt?
+    
+    /// Animation runloop mode
+    public var runLoopMode: RunLoop.Mode = .common
+    
+    /// Animation playback rate
+    public var playbackRate: Double = 1.0
+    
+    /// Animation playback mode
+    public var playbackMode: SDAnimatedImagePlaybackMode = .normal
+    
+    deinit {
+        player?.stopPlaying()
+    }
+    
+    /// Current playing frame image
+    @Published public var currentFrame: PlatformImage?
+    
+    /// Current playing frame index
+    @Published public var currentFrameIndex: UInt = 0
+    
+    /// Current playing loop count
+    @Published public var currentLoopCount: UInt = 0
+    
+    var currentAnimatedImage: (PlatformImage & SDAnimatedImageProvider)?
+    
+    /// Whether current player is valid for playing. This will check the internal player exist or not
+    public var isValid: Bool {
+        player != nil
+    }
+    
+    /// Current playing status
+    public var isPlaying: Bool {
+        player?.isPlaying ?? false
+    }
+    
+    /// Start the animation
+    public func startPlaying() {
+        player?.startPlaying()
+    }
+    
+    /// Pause the animation
+    public func pausePlaying() {
+        player?.pausePlaying()
+    }
+    
+    /// Stop the animation
+    public func stopPlaying() {
+        player?.stopPlaying()
+    }
+    
+    /// Seek to frame and loop count
+    public func seekToFrame(at: UInt, loopCount: UInt) {
+        player?.seekToFrame(at: at, loopCount: loopCount)
+    }
+    
+    /// Clear the frame buffer
+    public func clearFrameBuffer() {
+        player?.clearFrameBuffer()
+    }
+    
+    /// Setup the player using Animated Image.
+    /// After setup, you can always check `isValid` status, or call `startPlaying` to play the animation.
+    /// - Parameter image: animated image
+    public func setupPlayer(animatedImage: PlatformImage & SDAnimatedImageProvider) {
+        if isValid {
+            return
+        }
+        currentAnimatedImage = animatedImage
+        if let imagePlayer = SDAnimatedImagePlayer(provider: animatedImage) {
+            imagePlayer.animationFrameHandler = { [weak self] (index, frame) in
+                guard let self = self else {
+                    return
+                }
+                if (self.isPlaying) {
+                    self.currentFrameIndex = index
+                    self.currentFrame = frame
+                }
+            }
+            imagePlayer.animationLoopHandler = { [weak self] (loopCount) in
+                guard let self = self else {
+                    return
+                }
+                if (self.isPlaying) {
+                    self.currentLoopCount = loopCount
+                }
+            }
+            // Setup configuration
+            if let maxBufferSize = maxBufferSize {
+                imagePlayer.maxBufferSize = maxBufferSize
+            }
+            if let customLoopCount = customLoopCount {
+                imagePlayer.totalLoopCount = customLoopCount
+            }
+            imagePlayer.runLoopMode = runLoopMode
+            imagePlayer.playbackRate = playbackRate
+            imagePlayer.playbackMode = playbackMode
+            
+            self.player = imagePlayer
+        }
+    }
+}

package/example/ios/Pods/SDWebImageSwiftUI/SDWebImageSwiftUI/Classes/ImageViewWrapper.swift

@@ -0,0 +1,133 @@
+/*
+* This file is part of the SDWebImage package.
+* (c) DreamPiggy <lizhuoli1126@126.com>
+*
+* For the full copyright and license information, please view the LICENSE
+* file that was distributed with this source code.
+*/
+
+import Foundation
+import SDWebImage
+
+#if os(iOS) || os(tvOS) || os(macOS)
+
+/// Use wrapper to solve tne `UIImageView`/`NSImageView` frame size become image size issue (SwiftUI's Bug)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public class AnimatedImageViewWrapper : PlatformView {
+    var wrapped = SDAnimatedImageView()
+    var interpolationQuality = CGInterpolationQuality.default
+    var shouldAntialias = false
+    var resizable = false
+    
+    override public func draw(_ rect: CGRect) {
+        #if os(macOS)
+        guard let ctx = NSGraphicsContext.current?.cgContext else {
+            return
+        }
+        #else
+        guard let ctx = UIGraphicsGetCurrentContext() else {
+            return
+        }
+        #endif
+        ctx.interpolationQuality = interpolationQuality
+        ctx.setShouldAntialias(shouldAntialias)
+    }
+    
+    #if os(macOS)
+    public override func layout() {
+        super.layout()
+        wrapped.frame = self.bounds
+    }
+    #else
+    public override func layoutSubviews() {
+        super.layoutSubviews()
+        wrapped.frame = self.bounds
+    }
+    #endif
+    
+    public override var intrinsicContentSize: CGSize {
+        /// Match the behavior of SwiftUI.Image, only when image is resizable, use the super implementation to calculate size
+        if resizable {
+            return super.intrinsicContentSize
+        } else {
+            /// Not resizable, always use image size, like SwiftUI.Image
+            return wrapped.intrinsicContentSize
+        }
+    }
+    
+    public override init(frame frameRect: CGRect) {
+        super.init(frame: frameRect)
+        addSubview(wrapped)
+    }
+    
+    public required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        addSubview(wrapped)
+    }
+}
+
+/// Use wrapper to solve the `UIProgressView`/`NSProgressIndicator` frame origin NaN crash (SwiftUI's bug)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public class ProgressIndicatorWrapper : PlatformView {
+    #if os(macOS)
+    var wrapped = NSProgressIndicator()
+    #else
+    var wrapped = UIProgressView(progressViewStyle: .default)
+    #endif
+    
+    #if os(macOS)
+    public override func layout() {
+        super.layout()
+        wrapped.setFrameOrigin(CGPoint(x: round(self.bounds.width - wrapped.frame.width) / 2, y: round(self.bounds.height - wrapped.frame.height) / 2))
+    }
+    #else
+    public override func layoutSubviews() {
+        super.layoutSubviews()
+        wrapped.center = self.center
+    }
+    #endif
+    
+    public override init(frame frameRect: CGRect) {
+        super.init(frame: frameRect)
+        addSubview(wrapped)
+    }
+    
+    public required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        addSubview(wrapped)
+    }
+}
+
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension PlatformView {
+    /// Adds constraints to this `UIView` instances `superview` object to make sure this always has the same size as the superview.
+    /// Please note that this has no effect if its `superview` is `nil` – add this `UIView` instance as a subview before calling this.
+    func bindFrameToSuperviewBounds() {
+        guard let superview = self.superview else {
+            print("Error! `superview` was nil – call `addSubview(view: UIView)` before calling `bindFrameToSuperviewBounds()` to fix this.")
+            return
+        }
+
+        self.translatesAutoresizingMaskIntoConstraints = false
+        self.topAnchor.constraint(equalTo: superview.topAnchor, constant: 0).isActive = true
+        self.bottomAnchor.constraint(equalTo: superview.bottomAnchor, constant: 0).isActive = true
+        self.leadingAnchor.constraint(equalTo: superview.leadingAnchor, constant: 0).isActive = true
+        self.trailingAnchor.constraint(equalTo: superview.trailingAnchor, constant: 0).isActive = true
+    }
+    
+    /// Finding the HostingView for UIKit/AppKit View.
+    /// - Parameter entry: The entry platform view
+    /// - Returns: The hosting view.
+    func findHostingView() -> PlatformView? {
+        var superview = self.superview
+        while let s = superview {
+            if NSStringFromClass(type(of: s)).contains("HostingView") {
+                return s
+            }
+            superview = s.superview
+        }
+        return nil
+    }
+}
+
+#endif

package/example/ios/Pods/SDWebImageSwiftUI/SDWebImageSwiftUI/Classes/Indicator/ActivityIndicator.swift

@@ -0,0 +1,82 @@
+/*
+* This file is part of the SDWebImage package.
+* (c) DreamPiggy <lizhuoli1126@126.com>
+*
+* For the full copyright and license information, please view the LICENSE
+* file that was distributed with this source code.
+*/
+
+import SwiftUI
+
+#if os(macOS) || os(iOS) || os(tvOS)
+/// An activity indicator (system style)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public struct ActivityIndicator: PlatformViewRepresentable {
+    @Binding var isAnimating: Bool
+    var style: Style
+    
+    /// Create the indicator with animation binding and style
+    /// - Parameters:
+    ///   - isAnimating: The binding to control the animation
+    ///   - style: The indicator style
+    public init(_ isAnimating: Binding<Bool>, style: Style = .medium) {
+        self._isAnimating = isAnimating
+        self.style = style
+    }
+    
+    #if os(macOS)
+    public typealias NSViewType = NSProgressIndicator
+    #elseif os(iOS) || os(tvOS)
+    public typealias UIViewType = UIActivityIndicatorView
+    #endif
+    
+    #if os(iOS) || os(tvOS)
+    public func makeUIView(context: UIViewRepresentableContext<ActivityIndicator>) -> UIActivityIndicatorView {
+        let activityStyle: UIActivityIndicatorView.Style
+        switch style {
+        case .medium:
+            activityStyle = .medium
+        case .large:
+            activityStyle = .large
+        }
+        let indicator = UIActivityIndicatorView(style: activityStyle)
+        indicator.hidesWhenStopped = true
+        return indicator
+    }
+    
+    public func updateUIView(_ uiView: UIActivityIndicatorView, context: UIViewRepresentableContext<ActivityIndicator>) {
+        isAnimating ? uiView.startAnimating() : uiView.stopAnimating()
+    }
+    #endif
+    
+    #if os(macOS)
+    public func makeNSView(context: NSViewRepresentableContext<ActivityIndicator>) -> NSProgressIndicator {
+        let controlSize: NSControl.ControlSize
+        switch style {
+        case .medium:
+            controlSize = .small
+        case .large:
+            controlSize = .regular
+        }
+        let indicator = NSProgressIndicator()
+        indicator.style = .spinning
+        indicator.controlSize = controlSize
+        indicator.isDisplayedWhenStopped = false
+        return indicator
+    }
+    
+    public func updateNSView(_ nsView: NSProgressIndicator, context: NSViewRepresentableContext<ActivityIndicator>) {
+        isAnimating ? nsView.startAnimation(nil) : nsView.stopAnimation(nil)
+    }
+    
+    #endif
+}
+
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension ActivityIndicator {
+    public enum Style {
+        case medium
+        case large
+    }
+}
+#endif

package/example/ios/Pods/SDWebImageSwiftUI/SDWebImageSwiftUI/Classes/Indicator/Indicator.swift

@@ -0,0 +1,97 @@
+/*
+* This file is part of the SDWebImage package.
+* (c) DreamPiggy <lizhuoli1126@126.com>
+*
+* For the full copyright and license information, please view the LICENSE
+* file that was distributed with this source code.
+*/
+
+import Foundation
+import SwiftUI
+
+/// A  type to build the indicator
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public struct Indicator<T> where T : View {
+    var content: (Binding<Bool>, Binding<Double>) -> T
+    
+    /// Create a indicator with builder
+    /// - Parameter builder: A builder to build indicator
+    /// - Parameter isAnimating: A Binding to control the animation. If image is during loading, the value is true, else (like start loading) the value is false.
+    /// - Parameter progress: A Binding to control the progress during loading. Value between [0.0, 1.0]. If no progress can be reported, the value is 0.
+    /// Associate a indicator when loading image with url
+    public init(@ViewBuilder content: @escaping (_ isAnimating: Binding<Bool>, _ progress: Binding<Double>) -> T) {
+        self.content = content
+    }
+}
+
+/// A observable model to report indicator loading status
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public class IndicatorStatus : ObservableObject {
+    /// whether indicator is loading or not
+    @Published var isLoading: Bool = false
+    /// indicator progress, should only be used for indicator binding, value between [0.0, 1.0]
+    @Published var progress: Double = 0
+}
+
+/// A implementation detail View Modifier with indicator
+/// SwiftUI View Modifier construced by using a internal View type which modify the `body`
+/// It use type system to represent the view hierarchy, and Swift `some View` syntax to hide the type detail for users
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public struct IndicatorViewModifier<T> : ViewModifier where T : View {
+    
+    /// The loading status
+    @ObservedObject public var status: IndicatorStatus
+    
+    /// The indicator
+    public var indicator: Indicator<T>
+    
+    public func body(content: Content) -> some View {
+        ZStack {
+            content
+            .backport
+            .overlay {
+                if status.isLoading {
+                    indicator.content($status.isLoading, $status.progress)
+                }
+            }
+        }
+    }
+}
+
+#if os(macOS) || os(iOS) || os(tvOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension Indicator where T == ActivityIndicator {
+    /// Activity Indicator
+    public static var activity: Indicator {
+        Indicator { isAnimating, _ in
+            ActivityIndicator(isAnimating)
+        }
+    }
+    
+    /// Activity Indicator with style
+    /// - Parameter style: style
+    public static func activity(style: ActivityIndicator.Style) -> Indicator {
+        Indicator { isAnimating, _ in
+            ActivityIndicator(isAnimating, style: style)
+        }
+    }
+}
+
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension Indicator where T == ProgressIndicator {
+    /// Progress Indicator
+    public static var progress: Indicator {
+        Indicator { isAnimating, progress in
+            ProgressIndicator(isAnimating, progress: progress)
+        }
+    }
+    
+    /// Progress Indicator with style
+    /// - Parameter style: style
+    public static func progress(style: ProgressIndicator.Style) -> Indicator {
+        Indicator { isAnimating, progress in
+            ProgressIndicator(isAnimating, progress: progress, style: style)
+        }
+    }
+}
+#endif

package/example/ios/Pods/SDWebImageSwiftUI/SDWebImageSwiftUI/Classes/Indicator/ProgressIndicator.swift

@@ -0,0 +1,114 @@
+/*
+* This file is part of the SDWebImage package.
+* (c) DreamPiggy <lizhuoli1126@126.com>
+*
+* For the full copyright and license information, please view the LICENSE
+* file that was distributed with this source code.
+*/
+
+import SwiftUI
+
+#if os(macOS) || os(iOS) || os(tvOS)
+/// A progress bar indicator (system style)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public struct ProgressIndicator: PlatformViewRepresentable {
+    @Binding var isAnimating: Bool
+    @Binding var progress: Double
+    var style: Style
+    
+    /// Create indicator with animation binding, progress binding and the style
+    /// - Parameters:
+    ///   - isAnimating: The binding to control the animation
+    ///   - progress: The binding to update the progress
+    ///   - style: The indicator style
+    public init(_ isAnimating: Binding<Bool>, progress: Binding<Double>, style: Style = .default) {
+        self._isAnimating = isAnimating
+        self._progress = progress
+        self.style = style
+    }
+    
+    #if os(macOS)
+    public typealias NSViewType = ProgressIndicatorWrapper
+    #elseif os(iOS) || os(tvOS)
+    public typealias UIViewType = ProgressIndicatorWrapper
+    #endif
+    
+    #if os(iOS) || os(tvOS)
+    public func makeUIView(context: UIViewRepresentableContext<ProgressIndicator>) -> ProgressIndicatorWrapper {
+        let progressStyle: UIProgressView.Style
+        switch style {
+        #if os(iOS)
+        case .bar:
+            progressStyle = .bar
+        #endif
+        case .default:
+            progressStyle = .default
+        }
+        let uiView = ProgressIndicatorWrapper()
+        let view = uiView.wrapped
+        view.progressViewStyle = progressStyle
+        return uiView
+    }
+    
+    public func updateUIView(_ uiView: ProgressIndicatorWrapper, context: UIViewRepresentableContext<ProgressIndicator>) {
+        let view = uiView.wrapped
+        if isAnimating {
+            view.setProgress(Float(progress), animated: true)
+        } else {
+            if progress == 0 {
+                view.isHidden = false
+                view.progress = 0
+            } else {
+                view.isHidden = true
+                view.progress = 1
+            }
+        }
+    }
+    #endif
+    
+    #if os(macOS)
+    public func makeNSView(context: NSViewRepresentableContext<ProgressIndicator>) -> ProgressIndicatorWrapper {
+        let nsView = ProgressIndicatorWrapper()
+        let view = nsView.wrapped
+        view.style = .bar
+        view.isDisplayedWhenStopped = false
+        view.controlSize = .small
+        view.frame = CGRect(x: 0, y: 0, width: 160, height: 0) // Width from `UIProgressView` default width
+        view.sizeToFit()
+        view.autoresizingMask = [.maxXMargin, .minXMargin, .maxYMargin, .minYMargin]
+        return nsView
+    }
+    
+    public func updateNSView(_ nsView: ProgressIndicatorWrapper, context: NSViewRepresentableContext<ProgressIndicator>) {
+        let view = nsView.wrapped
+        if isAnimating {
+            view.isIndeterminate = false
+            view.doubleValue = Double(progress) * 100
+            view.startAnimation(nil)
+        } else {
+            if progress == 0 {
+                view.isHidden = false
+                view.isIndeterminate = true
+                view.doubleValue = 0
+                view.stopAnimation(nil)
+            } else {
+                view.isHidden = true
+                view.isIndeterminate = false
+                view.doubleValue = 100
+                view.stopAnimation(nil)
+            }
+        }
+    }
+    #endif
+}
+
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension ProgressIndicator {
+    public enum Style {
+        case `default`
+        #if os(iOS)
+        case bar
+        #endif
+    }
+}
+#endif

package/example/ios/Pods/SDWebImageSwiftUI/SDWebImageSwiftUI/Classes/SDWebImageSwiftUI.swift

@@ -0,0 +1,64 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) DreamPiggy <lizhuoli1126@126.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import Foundation
+import SwiftUI
+@_exported import SDWebImage // Automatically import SDWebImage
+
+#if os(macOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public typealias PlatformImage = NSImage
+#else
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public typealias PlatformImage = UIImage
+#endif
+
+#if os(macOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public typealias PlatformView = NSView
+#endif
+#if os(iOS) || os(tvOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public typealias PlatformView = UIView
+#endif
+#if os(watchOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public typealias PlatformView = WKInterfaceObject
+#endif
+
+#if os(macOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public typealias PlatformViewRepresentable = NSViewRepresentable
+#endif
+#if os(iOS) || os(tvOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public typealias PlatformViewRepresentable = UIViewRepresentable
+#endif
+#if os(watchOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public typealias PlatformViewRepresentable = WKInterfaceObjectRepresentable
+#endif
+
+#if os(macOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension NSViewRepresentable {
+    typealias PlatformViewType = NSViewType
+}
+#endif
+#if os(iOS) || os(tvOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension UIViewRepresentable {
+    typealias PlatformViewType = UIViewType
+}
+#endif
+#if os(watchOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension WKInterfaceObjectRepresentable {
+    typealias PlatformViewType = WKInterfaceObjectType
+}
+#endif