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

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

@@ -0,0 +1,59 @@
+import SwiftUI
+import ObjectiveC
+
+/// Provides a convenient method for backporting API,
+/// including types, functions, properties, property wrappers and more.
+///
+/// To backport a SwiftUI Label for example, you could apply the
+/// following extension:
+///
+///     extension Backport where Content == Any {
+///         public struct Label<Title, Icon> { }
+///     }
+///
+/// Now if we want to provide further extensions to our backport type,
+/// we need to ensure we retain the `Content == Any` generic requirement:
+///
+///     extension Backport.Label where Content == Any, Title == Text, Icon == Image {
+///         public init<S: StringProtocol>(_ title: S, systemName: String) { }
+///     }
+///
+/// In addition to types, we can also provide backports for properties
+/// and methods:
+///
+///     extension Backport.Label where Content: View {
+///         func onChange<Value: Equatable>(of value: Value, perform action: (Value) -> Void) -> some View {
+///             // `content` provides access to the extended type
+///             content.modifier(OnChangeModifier(value, action))
+///         }
+///     }
+///
+public struct Backport<Wrapped> {
+
+    /// The underlying content this backport represents.
+    public let content: Wrapped
+
+    /// Initializes a new Backport for the specified content.
+    /// - Parameter content: The content (type) that's being backported
+    public init(_ content: Wrapped) {
+        self.content = content
+    }
+
+}
+
+public extension View {
+    /// Wraps a SwiftUI `View` that can be extended to provide backport functionality.
+    var backport: Backport<Self> { .init(self) }
+}
+
+public extension NSObjectProtocol {
+    /// Wraps an `NSObject` that can be extended to provide backport functionality.
+    var backport: Backport<Self> { .init(self) }
+}
+
+public extension AnyTransition {
+    /// Wraps an `AnyTransition` that can be extended to provide backport functionality.
+    static var backport: Backport<AnyTransition>{
+        Backport(.identity)
+    }
+}

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

@@ -0,0 +1,52 @@
+import SwiftUI
+import Combine
+
+@available(iOS, deprecated: 14.0)
+@available(macOS, deprecated: 11.0)
+@available(tvOS, deprecated: 14.0)
+@available(watchOS, deprecated: 7.0)
+public extension Backport where Wrapped: View {
+
+    /// Adds a modifier for this view that fires an action when a specific
+    /// value changes.
+    ///
+    /// `onChange` is called on the main thread. Avoid performing long-running
+    /// tasks on the main thread. If you need to perform a long-running task in
+    /// response to `value` changing, you should dispatch to a background queue.
+    ///
+    /// The new value is passed into the closure.
+    ///
+    /// - Parameters:
+    ///   - value: The value to observe for changes
+    ///   - action: A closure to run when the value changes.
+    ///   - newValue: The new value that changed
+    ///
+    /// - Returns: A view that fires an action when the specified value changes.
+    @ViewBuilder
+    func onChange<Value: Equatable>(of value: Value, perform action: @escaping (Value) -> Void) -> some View {
+        content.modifier(ChangeModifier(value: value, action: action))
+    }
+
+}
+
+private struct ChangeModifier<Value: Equatable>: ViewModifier {
+    let value: Value
+    let action: (Value) -> Void
+
+    @State var oldValue: Value?
+
+    init(value: Value, action: @escaping (Value) -> Void) {
+        self.value = value
+        self.action = action
+        _oldValue = .init(initialValue: value)
+    }
+
+    func body(content: Content) -> some View {
+        content
+            .onReceive(Just(value)) { newValue in
+                guard newValue != oldValue else { return }
+                action(newValue)
+                oldValue = newValue
+            }
+    }
+}

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

@@ -0,0 +1,124 @@
+import SwiftUI
+
+public extension Backport where Wrapped: View {
+
+    /// Layers the views that you specify in front of this view.
+    ///
+    /// Use this modifier to place one or more views in front of another view.
+    /// For example, you can place a group of stars on a ``RoundedRectangle``:
+    ///
+    ///     RoundedRectangle(cornerRadius: 8)
+    ///         .frame(width: 200, height: 100)
+    ///         .overlay(alignment: .topLeading) { Star(color: .red) }
+    ///         .overlay(alignment: .topTrailing) { Star(color: .yellow) }
+    ///         .overlay(alignment: .bottomLeading) { Star(color: .green) }
+    ///         .overlay(alignment: .bottomTrailing) { Star(color: .blue) }
+    ///
+    /// The example above assumes that you've defined a `Star` view with a
+    /// parameterized color:
+    ///
+    ///     struct Star: View {
+    ///         var color = Color.yellow
+    ///
+    ///         var body: some View {
+    ///             Image(systemName: "star.fill")
+    ///                 .foregroundStyle(color)
+    ///         }
+    ///     }
+    ///
+    /// By setting different `alignment` values for each modifier, you make the
+    /// stars appear in different places on the rectangle:
+    ///
+    /// ![A screenshot of a rounded rectangle with a star in each corner. The
+    /// star in the upper-left is red; the start in the upper-right is yellow;
+    /// the star in the lower-left is green; the star the lower-right is
+    /// blue.](View-overlay-2)
+    ///
+    /// If you specify more than one view in the `content` closure, the modifier
+    /// collects all of the views in the closure into an implicit ``ZStack``,
+    /// taking them in order from back to front. For example, you can place a
+    /// star and a ``Circle`` on a field of ``ShapeStyle/blue``:
+    ///
+    ///     Color.blue
+    ///         .frame(width: 200, height: 200)
+    ///         .overlay {
+    ///             Circle()
+    ///                 .frame(width: 100, height: 100)
+    ///             Star()
+    ///         }
+    ///
+    /// Both the overlay modifier and the implicit ``ZStack`` composed from the
+    /// overlay content --- the circle and the star --- use a default
+    /// ``Alignment/center`` alignment. The star appears centered on the circle,
+    /// and both appear as a composite view centered in front of the square:
+    ///
+    /// ![A screenshot of a star centered on a circle, which is
+    /// centered on a square.](View-overlay-3)
+    ///
+    /// If you specify an alignment for the overlay, it applies to the implicit
+    /// stack rather than to the individual views in the closure. You can see
+    /// this if you add the ``Alignment/bottom`` alignment:
+    ///
+    ///     Color.blue
+    ///         .frame(width: 200, height: 200)
+    ///         .overlay(alignment: .bottom) {
+    ///             Circle()
+    ///                 .frame(width: 100, height: 100)
+    ///             Star()
+    ///         }
+    ///
+    /// The circle and the star move down as a unit to align the stack's bottom
+    /// edge with the bottom edge of the square, while the star remains
+    /// centered on the circle:
+    ///
+    /// ![A screenshot of a star centered on a circle, which is on a square.
+    /// The circle's bottom edge is aligned with the square's bottom
+    /// edge.](View-overlay-3a)
+    ///
+    /// To control the placement of individual items inside the `content`
+    /// closure, either use a different overlay modifier for each item, as the
+    /// earlier example of stars in the corners of a rectangle demonstrates, or
+    /// add an explicit ``ZStack`` inside the content closure with its own
+    /// alignment:
+    ///
+    ///     Color.blue
+    ///         .frame(width: 200, height: 200)
+    ///         .overlay(alignment: .bottom) {
+    ///             ZStack(alignment: .bottom) {
+    ///                 Circle()
+    ///                     .frame(width: 100, height: 100)
+    ///                 Star()
+    ///             }
+    ///         }
+    ///
+    /// The stack alignment ensures that the star's bottom edge aligns with the
+    /// circle's, while the overlay aligns the composite view with the square:
+    ///
+    /// ![A screenshot of a star, a circle, and a square with all their
+    /// bottom edges aligned.](View-overlay-4)
+    ///
+    /// You can achieve layering without an overlay modifier by putting both the
+    /// modified view and the overlay content into a ``ZStack``. This can
+    /// produce a simpler view hierarchy, but changes the layout priority that
+    /// SwiftUI applies to the views. Use the overlay modifier when you want the
+    /// modified view to dominate the layout.
+    ///
+    /// If you want to specify a ``ShapeStyle`` like a ``Color`` or a
+    /// ``Material`` as the overlay, use
+    /// ``View/overlay(_:ignoresSafeAreaEdges:)`` instead. To specify a
+    /// ``Shape``, use ``View/overlay(_:in:fillStyle:)``.
+    ///
+    /// - Parameters:
+    ///   - alignment: The alignment that the modifier uses to position the
+    ///     implicit ``ZStack`` that groups the foreground views. The default
+    ///     is ``Alignment/center``.
+    ///   - content: A ``ViewBuilder`` that you use to declare the views to
+    ///     draw in front of this view, stacked in the order that you list them.
+    ///     The last view that you list appears at the front of the stack.
+    ///
+    /// - Returns: A view that uses the specified content as a foreground.
+    func overlay<Content: View>(alignment: Alignment = .center, @ViewBuilder _ content: () -> Content) -> some View {
+        self.content.overlay(content(), alignment: alignment)
+    }
+
+}

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

@@ -0,0 +1,151 @@
+import Combine
+import SwiftUI
+
+@available(iOS, deprecated: 14.0)
+@available(macOS, deprecated: 11.0)
+@available(tvOS, deprecated: 14.0)
+@available(watchOS, deprecated: 7.0)
+public extension Backport where Wrapped: ObservableObject {
+
+    /// A property wrapper type that instantiates an observable object.
+    ///
+    /// Create a state object in a ``SwiftUI/View``, ``SwiftUI/App``, or
+    /// ``SwiftUI/Scene`` by applying the `@Backport.StateObject` attribute to a property
+    /// declaration and providing an initial value that conforms to the
+    /// <doc://com.apple.documentation/documentation/Combine/ObservableObject>
+    /// protocol:
+    ///
+    ///     @Backport.StateObject var model = DataModel()
+    ///
+    /// SwiftUI creates a new instance of the object only once for each instance of
+    /// the structure that declares the object. When published properties of the
+    /// observable object change, SwiftUI updates the parts of any view that depend
+    /// on those properties:
+    ///
+    ///     Text(model.title) // Updates the view any time `title` changes.
+    ///
+    /// You can pass the state object into a property that has the
+    /// ``SwiftUI/ObservedObject`` attribute. You can alternatively add the object
+    /// to the environment of a view hierarchy by applying the
+    /// ``SwiftUI/View/environmentObject(_:)`` modifier:
+    ///
+    ///     ContentView()
+    ///         .environmentObject(model)
+    ///
+    /// If you create an environment object as shown in the code above, you can
+    /// read the object inside `ContentView` or any of its descendants
+    /// using the ``SwiftUI/EnvironmentObject`` attribute:
+    ///
+    ///     @EnvironmentObject var model: DataModel
+    ///
+    /// Get a ``SwiftUI/Binding`` to one of the state object's properties using the
+    /// `$` operator. Use a binding when you want to create a two-way connection to
+    /// one of the object's properties. For example, you can let a
+    /// ``SwiftUI/Toggle`` control a Boolean value called `isEnabled` stored in the
+    /// model:
+    ///
+    ///     Toggle("Enabled", isOn: $model.isEnabled)
+    @propertyWrapper struct StateObject: DynamicProperty {
+        private final class Wrapper: ObservableObject {
+            private var subject = PassthroughSubject<Void, Never>()
+
+            var value: Wrapped? {
+                didSet {
+                    cancellable = nil
+                    cancellable = value?.objectWillChange
+                        .sink { [subject] _ in subject.send() }
+                }
+            }
+
+            private var cancellable: AnyCancellable?
+
+            var objectWillChange: AnyPublisher<Void, Never> {
+                subject.eraseToAnyPublisher()
+            }
+        }
+
+        @State private var state = Wrapper()
+
+        @ObservedObject private var observedObject = Wrapper()
+
+        private var thunk: () -> Wrapped
+
+        /// The underlying value referenced by the state object.
+        ///
+        /// The wrapped value property provides primary access to the value's data.
+        /// However, you don't access `wrappedValue` directly. Instead, use the
+        /// property variable created with the `@Backport.StateObject` attribute:
+        ///
+        ///     @Backport.StateObject var contact = Contact()
+        ///
+        ///     var body: some View {
+        ///         Text(contact.name) // Accesses contact's wrapped value.
+        ///     }
+        ///
+        /// When you change a property of the wrapped value, you can access the new
+        /// value immediately. However, SwiftUI updates views displaying the value
+        /// asynchronously, so the user interface might not update immediately.
+        public var wrappedValue: Wrapped {
+            if let object = state.value {
+                return object
+            } else {
+                let object = thunk()
+                state.value = object
+                return object
+            }
+        }
+
+        /// A projection of the state object that creates bindings to its
+        /// properties.
+        ///
+        /// Use the projected value to pass a binding value down a view hierarchy.
+        /// To get the projected value, prefix the property variable with `$`. For
+        /// example, you can get a binding to a model's `isEnabled` Boolean so that
+        /// a ``SwiftUI/Toggle`` view can control the value:
+        ///
+        ///     struct MyView: View {
+        ///         @Backport.StateObject var model = DataModel()
+        ///
+        ///         var body: some View {
+        ///             Toggle("Enabled", isOn: $model.isEnabled)
+        ///         }
+        ///     }
+        public var projectedValue: ObservedObject<Wrapped>.Wrapper {
+            ObservedObject(wrappedValue: wrappedValue).projectedValue
+        }
+
+        /// Creates a new state object with an initial wrapped value.
+        ///
+        /// You don’t call this initializer directly. Instead, declare a property
+        /// with the `@Backport.StateObject` attribute in a ``SwiftUI/View``,
+        /// ``SwiftUI/App``, or ``SwiftUI/Scene``, and provide an initial value:
+        ///
+        ///     struct MyView: View {
+        ///         @Backport.StateObject var model = DataModel()
+        ///
+        ///         // ...
+        ///     }
+        ///
+        /// SwiftUI creates only one instance of the state object for each
+        /// container instance that you declare. In the code above, SwiftUI
+        /// creates `model` only the first time it initializes a particular instance
+        /// of `MyView`. On the other hand, each different instance of `MyView`
+        /// receives a distinct copy of the data model.
+        ///
+        /// - Parameter thunk: An initial value for the state object.
+        public init(wrappedValue thunk: @autoclosure @escaping () -> Wrapped) {
+            self.thunk = thunk
+        }
+
+        public mutating func update() {
+            if state.value == nil {
+                state.value = thunk()
+            }
+            if observedObject.value !== state.value {
+                observedObject.value = state.value
+            }
+        }
+    }
+    
+}
+

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

@@ -0,0 +1,78 @@
+/*
+* 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
+
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension Image {
+    @inlinable init(platformImage: PlatformImage) {
+        #if os(macOS)
+        self.init(nsImage: platformImage)
+        #else
+        self.init(uiImage: platformImage)
+        #endif
+    }
+}
+
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension PlatformImage {
+    static var empty = PlatformImage()
+}
+
+#if os(iOS) || os(tvOS) || os(watchOS)
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension PlatformImage.Orientation {
+    @inlinable var toSwiftUI: Image.Orientation {
+        switch self {
+        case .up:
+            return .up
+        case .upMirrored:
+            return .upMirrored
+        case .down:
+            return .down
+        case .downMirrored:
+            return .downMirrored
+        case .left:
+            return .left
+        case .leftMirrored:
+            return .leftMirrored
+        case .right:
+            return .right
+        case .rightMirrored:
+            return .rightMirrored
+        @unknown default:
+            return .up
+        }
+    }
+}
+
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension Image.Orientation {
+    @inlinable var toPlatform: PlatformImage.Orientation {
+        switch self {
+        case .up:
+            return .up
+        case .upMirrored:
+            return .upMirrored
+        case .down:
+            return .down
+        case .downMirrored:
+            return .downMirrored
+        case .left:
+            return .left
+        case .leftMirrored:
+            return .leftMirrored
+        case .right:
+            return .right
+        case .rightMirrored:
+            return .rightMirrored
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,132 @@
+/*
+ * 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 image load process. This drive the Source of Truth for image loading status.
+/// You can use `@ObservedObject` to associate each instance of manager to your View type, which update your view's body from SwiftUI framework when image was loaded.
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+public final class ImageManager : ObservableObject {
+    /// loaded image, note when progressive loading, this will published multiple times with different partial image
+    @Published public var image: PlatformImage?
+    /// loaded image data, may be nil if hit from memory cache. This will only published once even on incremental image loading
+    @Published public var imageData: Data?
+    /// loaded image cache type, .none means from network
+    @Published public var cacheType: SDImageCacheType = .none
+    /// loading error, you can grab the error code and reason listed in `SDWebImageErrorDomain`, to provide a user interface about the error reason
+    @Published public var error: Error?
+    /// true means during incremental loading
+    @Published public var isIncremental: Bool = false
+    /// A observed object to pass through the image manager loading status to indicator
+    @Published public var indicatorStatus = IndicatorStatus()
+    
+    weak var currentOperation: SDWebImageOperation? = nil
+
+    var currentURL: URL?
+    var successBlock: ((PlatformImage, Data?, SDImageCacheType) -> Void)?
+    var failureBlock: ((Error) -> Void)?
+    var progressBlock: ((Int, Int) -> Void)?
+    
+    public init() {}
+    
+    /// Start to load the url operation
+    /// - Parameter url: The image url
+    /// - Parameter options: The options to use when downloading the image. See `SDWebImageOptions` for the possible values.
+    /// - Parameter context: A context contains different options to perform specify changes or processes, see `SDWebImageContextOption`. This hold the extra objects which `options` enum can not hold.
+    public func load(url: URL?, options: SDWebImageOptions = [], context: [SDWebImageContextOption : Any]? = nil) {
+        let manager: SDWebImageManager
+        if let customManager = context?[.customManager] as? SDWebImageManager {
+            manager = customManager
+        } else {
+            manager = .shared
+        }
+        if (currentOperation != nil && currentURL == url) {
+            return
+        }
+        currentURL = url
+        indicatorStatus.isLoading = true
+        indicatorStatus.progress = 0
+        currentOperation = manager.loadImage(with: url, options: options, context: context, progress: { [weak self] (receivedSize, expectedSize, _) in
+            guard let self = self else {
+                return
+            }
+            let progress: Double
+            if (expectedSize > 0) {
+                progress = Double(receivedSize) / Double(expectedSize)
+            } else {
+                progress = 0
+            }
+            DispatchQueue.main.async {
+                self.indicatorStatus.progress = progress
+            }
+            self.progressBlock?(receivedSize, expectedSize)
+        }) { [weak self] (image, data, error, cacheType, finished, _) in
+            guard let self = self else {
+                return
+            }
+            if let error = error as? SDWebImageError, error.code == .cancelled {
+                // Ignore user cancelled
+                // There are race condition when quick scroll
+                // Indicator modifier disapper and trigger `WebImage.body`
+                // So previous View struct call `onDisappear` and cancel the currentOperation
+                return
+            }
+            self.image = image
+            self.error = error
+            self.isIncremental = !finished
+            if finished {
+                self.imageData = data
+                self.cacheType = cacheType
+                self.indicatorStatus.isLoading = false
+                self.indicatorStatus.progress = 1
+                if let image = image {
+                    self.successBlock?(image, data, cacheType)
+                } else {
+                    self.failureBlock?(error ?? NSError())
+                }
+            }
+        }
+    }
+    
+    /// Cancel the current url loading
+    public func cancel() {
+        if let operation = currentOperation {
+            operation.cancel()
+            currentOperation = nil
+        }
+        indicatorStatus.isLoading = false
+        currentURL = nil
+    }
+    
+}
+
+// Completion Handler
+@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
+extension ImageManager {
+    /// Provide the action when image load fails.
+    /// - Parameters:
+    ///   - action: The action to perform. The first arg is the error during loading. If `action` is `nil`, the call has no effect.
+    public func setOnFailure(perform action: ((Error) -> Void)? = nil) {
+        self.failureBlock = action
+    }
+    
+    /// Provide the action when image load successes.
+    /// - Parameters:
+    ///   - action: The action to perform. The first arg is the loaded image, the second arg is the loaded image data, the third arg is the cache type loaded from. If `action` is `nil`, the call has no effect.
+    public func setOnSuccess(perform action: ((PlatformImage, Data?, SDImageCacheType) -> Void)? = nil) {
+        self.successBlock = action
+    }
+    
+    /// Provide the action when image load progress changes.
+    /// - Parameters:
+    ///   - action: The action to perform. The first arg is the received size, the second arg is the total size, all in bytes. If `action` is `nil`, the call has no effect.
+    public func setOnProgress(perform action: ((Int, Int) -> Void)? = nil) {
+        self.progressBlock = action
+    }
+}