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

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Angle/AngleInteractor.swift

@@ -0,0 +1,29 @@
+import Combine
+import SwiftUI
+
+// sourcery: AutoMockable
+protocol AngleInteractable: AnyObject {
+    var presenter: AnglePresenter { get }
+    var animation: CurrentValueSubject<Animation?, Never> { get }
+    var value: CurrentValueSubject<Double, Never> { get }
+    var range: CurrentValueSubject<ClosedRange<Double>, Never> { get }
+}
+
+final class AngleInteractor: AngleInteractable {
+    let presenter = AnglePresenter()
+    let animation: CurrentValueSubject<Animation?, Never>
+    let value: CurrentValueSubject<Double, Never>
+    let range: CurrentValueSubject<ClosedRange<Double>, Never>
+
+    private var cancellables = Set<AnyCancellable>()
+
+    init() {
+        value = CurrentValueSubject<Double, Never>(presenter.value)
+        animation = CurrentValueSubject<Animation?, Never>(presenter.animation)
+        range = CurrentValueSubject<ClosedRange<Double>, Never>(presenter.range)
+        range.assign(to: \.range, on: presenter).store(in: &cancellables)
+        value.assign(to: \.value, on: presenter).store(in: &cancellables)
+        animation.assign(to: \.animation, on: presenter).store(in: &cancellables)
+        range.map { $0.lowerBound }.assign(to: \.value, on: presenter).store(in: &cancellables)
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Angle/AnglePresenter.swift

@@ -0,0 +1,7 @@
+import SwiftUI
+
+final class AnglePresenter: ObservableObject {
+    @Published var animation: Animation?
+    @Published var value: Double = .zero
+    @Published var range: ClosedRange<Double> = .zero ... 360
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Animation/AnimationInteractor.swift

@@ -0,0 +1,56 @@
+import Combine
+import SwiftUI
+
+public enum AnimationType: Equatable {
+    case none
+    case pulse(range: ClosedRange<Double> = .zero ... 1, duration: Double = 2, delay: Double = 1, speed: Double = 2, autoreverses: Bool = true)
+    case linear(range: ClosedRange<CGFloat> = .zero ... 1, duration: Double = 4, delay: Double = 1, speed: Double = 5, autoreverses: Bool = false)
+}
+
+// sourcery: AutoMockable
+protocol AnimationInteractable: AnyObject {
+    var position: PositionInteractable { get }
+    var opacity: OpacityInteractable { get }
+    var radius: RadiusInteractable { get }
+    var angle: AngleInteractable { get }
+    var type: CurrentValueSubject<AnimationType, Never> { get }
+}
+
+final class AnimationInteractor: AnimationInteractable {
+    let position: PositionInteractable
+    let opacity: OpacityInteractable
+    let radius: RadiusInteractable
+    let angle: AngleInteractable
+    let type: CurrentValueSubject<AnimationType, Never>
+
+    private var cancellables = Set<AnyCancellable>()
+
+    init(position: PositionInteractable = PositionInteractor(), opacity: OpacityInteractable = OpacityInteractor(), radius: RadiusInteractable = RadiusInteractor(), angle: AngleInteractable = AngleInteractor()) {
+        self.position = position
+        self.opacity = opacity
+        self.radius = radius
+        self.angle = angle
+        type = CurrentValueSubject<AnimationType, Never>(.linear())
+        type.sink { type in
+            position.animation.send(nil)
+            opacity.animation.send(nil)
+            radius.animation.send(nil)
+            angle.animation.send(nil)
+            switch type {
+            case .none:
+                break
+            case let .pulse(range, duration, delay, speed, autoreverses):
+                opacity.range.send(range)
+                opacity.animation.send(Animation.easeIn(duration: duration).delay(delay).speed(speed).repeatForever(autoreverses: autoreverses))
+            case let .linear(range, duration, delay, speed, autoreverses):
+                position.range.send(position.presenter.range.normalize(with: range))
+                radius.range.send(radius.presenter.range.normalize(with: range))
+                angle.range.send(angle.presenter.range.normalize(with: range))
+                position.animation.send(Animation.easeInOut(duration: duration).delay(delay).speed(speed).repeatForever(autoreverses: autoreverses))
+                opacity.animation.send(autoreverses ? nil : Animation.easeIn(duration: duration).delay(delay).speed(speed * 2).repeatForever(autoreverses: true))
+                radius.animation.send(Animation.easeInOut(duration: duration).delay(delay).speed(speed).repeatForever(autoreverses: autoreverses))
+                angle.animation.send(Animation.easeInOut(duration: duration).delay(delay).speed(speed).repeatForever(autoreverses: autoreverses))
+            }
+        }.store(in: &cancellables)
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Appearance/AppearanceInteractor.swift

@@ -0,0 +1,58 @@
+import Combine
+import SwiftUI
+
+public enum GradientType: Equatable {
+    case linear
+    case angular
+    case radial
+}
+
+public struct SkeletonColor {
+    public static var primary: Color {
+        #if os(iOS)
+            return Color(.systemGray4)
+        #elseif os(tvOS)
+            return Color(.tertiaryLabel)
+        #elseif os(watchOS)
+            return Color.secondary
+        #elseif os(macOS)
+            return Color(.alternateSelectedControlColor)
+        #endif
+    }
+
+    public static var background: Color {
+        #if os(iOS)
+            return Color(.systemGray6)
+        #elseif os(tvOS)
+            return Color(.secondaryLabel)
+        #elseif os(watchOS)
+            return Color.primary
+        #elseif os(macOS)
+            return Color(.unemphasizedSelectedContentBackgroundColor)
+        #endif
+    }
+}
+
+
+public enum AppearanceType: Equatable {
+    case solid(color: Color = SkeletonColor.primary, background: Color = SkeletonColor.background)
+    case gradient(GradientType = .linear, color: Color = SkeletonColor.primary, background: Color = SkeletonColor.background, radius: CGFloat = 1, angle: CGFloat = .zero)
+}
+
+// sourcery: AutoMockable
+protocol AppearanceInteractable: AnyObject {
+    var presenter: AppearancePresenter { get }
+    var type: CurrentValueSubject<AppearanceType, Never> { get }
+}
+
+final class AppearanceInteractor: AppearanceInteractable {
+    let presenter = AppearancePresenter()
+    let type: CurrentValueSubject<AppearanceType, Never>
+
+    private var cancellables = Set<AnyCancellable>()
+
+    init() {
+        type = CurrentValueSubject<AppearanceType, Never>(presenter.type)
+        type.assign(to: \.type, on: presenter).store(in: &cancellables)
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Appearance/AppearancePresenter.swift

@@ -0,0 +1,5 @@
+import SwiftUI
+
+final class AppearancePresenter: ObservableObject {
+    @Published var type: AppearanceType = .gradient()
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Extensions/ClosedRange+Normalize.swift

@@ -0,0 +1,16 @@
+import CoreGraphics
+
+extension ClosedRange where Bound == CGFloat {
+    func normalize(with range: ClosedRange) -> ClosedRange {
+        let lowerBound = range.lowerBound == .zero ? self.lowerBound : range.lowerBound
+        let upperBound = range.upperBound == 1 ? self.upperBound : range.upperBound
+        return lowerBound < upperBound ? lowerBound ... upperBound : self
+    }
+}
+
+extension ClosedRange where Bound == Double {
+    func normalize(with range: ClosedRange<CGFloat>) -> ClosedRange {
+        let normalized = (CGFloat(lowerBound) ... CGFloat(upperBound)).normalize(with: range)
+        return Double(normalized.lowerBound) ... Double(normalized.upperBound)
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Extensions/Image+OptionalType.swift

@@ -0,0 +1,102 @@
+import SwiftUI
+
+public extension Image {
+    #if os(iOS) || os(tvOS) || os(watchOS)
+        init(uiImage: UIImage?) {
+            if let uiImage = uiImage {
+                self.init(uiImage: uiImage)
+            } else {
+                self.init(uiImage: UIImage())
+            }
+        }
+
+    #elseif os(macOS)
+        init(nsImage: NSImage?) {
+            if let nsImage = nsImage {
+                self.init(nsImage: nsImage)
+            } else {
+                self.init(nsImage: NSImage())
+            }
+        }
+    #endif
+
+    init(_ name: String?, bundle: Bundle? = nil) {
+        if let name = name {
+            self.init(name, bundle: bundle)
+        } else {
+            self.init(String(), bundle: bundle)
+        }
+    }
+
+    init(_ name: String?, bundle: Bundle? = nil, label: Text) {
+        if let name = name {
+            self.init(name, bundle: bundle, label: label)
+        } else {
+            self.init(String(), bundle: bundle, label: label)
+        }
+    }
+
+    init(decorative name: String?, bundle: Bundle? = nil) {
+        if let name = name {
+            self.init(decorative: name, bundle: bundle)
+        } else {
+            self.init(decorative: String(), bundle: bundle)
+        }
+    }
+
+    #if os(iOS) || os(tvOS) || os(watchOS)
+        init(systemName: String?) {
+            if let systemName = systemName {
+                self.init(systemName: systemName)
+            } else {
+                self.init(systemName: String())
+            }
+        }
+    #endif
+
+    #if os(iOS) || os(tvOS) || os(watchOS)
+        init(_ cgImage: CGImage?, scale: CGFloat, orientation: Image.Orientation = .up, label: Text) {
+            if let cgImage = cgImage {
+                self.init(cgImage, scale: scale, orientation: orientation, label: label)
+            } else if let image = UIImage().cgImage {
+                self.init(image, scale: scale, orientation: orientation, label: label)
+            } else {
+                self.init(String())
+            }
+        }
+
+    #elseif os(macOS)
+        init(_ cgImage: CGImage?, scale: CGFloat, orientation: Image.Orientation = .up, label: Text) {
+            if let cgImage = cgImage {
+                self.init(cgImage, scale: scale, orientation: orientation, label: label)
+            } else if let image = NSImage().cgImage(forProposedRect: nil, context: nil, hints: nil) {
+                self.init(image, scale: scale, orientation: orientation, label: label)
+            } else {
+                self.init(String())
+            }
+        }
+    #endif
+
+    #if os(iOS) || os(tvOS) || os(watchOS)
+        init(decorative cgImage: CGImage?, scale: CGFloat, orientation: Image.Orientation = .up) {
+            if let cgImage = cgImage {
+                self.init(decorative: cgImage, scale: scale, orientation: orientation)
+            } else if let image = UIImage().cgImage {
+                self.init(decorative: image, scale: scale, orientation: orientation)
+            } else {
+                self.init(String())
+            }
+        }
+
+    #elseif os(macOS)
+        init(decorative cgImage: CGImage?, scale: CGFloat, orientation: Image.Orientation = .up) {
+            if let cgImage = cgImage {
+                self.init(decorative: cgImage, scale: scale, orientation: orientation)
+            } else if let image = NSImage().cgImage(forProposedRect: nil, context: nil, hints: nil) {
+                self.init(decorative: image, scale: scale, orientation: orientation)
+            } else {
+                self.init(String())
+            }
+        }
+    #endif
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Extensions/ModifiedContent+SkeletonModifier.swift

@@ -0,0 +1,26 @@
+import SwiftUI
+
+@available(iOS 13.0, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
+public extension ModifiedContent where Content: View, Modifier == SkeletonModifier {
+    func animation(type: AnimationType) -> ModifiedContent<Content, SkeletonModifier> {
+        modifier.skeleton.animation.type.send(type)
+        return self
+    }
+
+    func appearance(type: AppearanceType) -> ModifiedContent<Content, SkeletonModifier> {
+        modifier.skeleton.appearance.type.send(type)
+        return self
+    }
+
+    func multiline(lines: Int, scales: [Int: CGFloat]? = nil, spacing: CGFloat? = nil) -> ModifiedContent<Content, SkeletonModifier> {
+        modifier.skeleton.multiline.lines.send(lines)
+        modifier.skeleton.multiline.scales.send(scales)
+        modifier.skeleton.multiline.spacing.send(spacing)
+        return self
+    }
+
+    func shape(type: ShapeType) -> ModifiedContent<Content, SkeletonModifier> {
+        modifier.skeleton.shape.type.send(type)
+        return self
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Extensions/Optional+OptionalType.swift

@@ -0,0 +1,5 @@
+extension Optional: OptionalType {
+    public var wrapped: Wrapped? {
+        self
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Extensions/SecureField+OptionalType.swift

@@ -0,0 +1,19 @@
+import SwiftUI
+
+public extension SecureField where Label == Text {
+    init(_ titleKey: LocalizedStringKey?, text: Binding<String>, onCommit: @escaping () -> Void = {}) {
+        if let titleKey = titleKey {
+            self.init(titleKey, text: text, onCommit: onCommit)
+        } else {
+            self.init(LocalizedStringKey(String()), text: text, onCommit: onCommit)
+        }
+    }
+
+    init<S>(_ title: S?, text: Binding<String>, onCommit: @escaping () -> Void = {}) where S: OptionalType, S.Wrapped: StringProtocol {
+        if let title = title?.wrapped {
+            self.init(title, text: text, onCommit: onCommit)
+        } else {
+            self.init(String(), text: text, onCommit: onCommit)
+        }
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Extensions/Text+OptionalType.swift

@@ -0,0 +1,27 @@
+import SwiftUI
+
+public extension Text {
+    init<S>(_ content: S?) where S: OptionalType, S.Wrapped: StringProtocol {
+        if let content = content?.wrapped {
+            self.init(content)
+        } else {
+            self.init(String())
+        }
+    }
+
+    init(_ key: LocalizedStringKey?, tableName: String? = nil, bundle: Bundle? = nil, comment: StaticString? = nil) {
+        if let key = key {
+            self.init(key, tableName: tableName, bundle: bundle, comment: comment)
+        } else {
+            self.init(LocalizedStringKey(String()), tableName: tableName, bundle: bundle, comment: comment)
+        }
+    }
+
+    init(verbatim content: String?) {
+        if let content = content {
+            self.init(verbatim: content)
+        } else {
+            self.init(verbatim: String())
+        }
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Extensions/TextField+OptionalType.swift

@@ -0,0 +1,35 @@
+import SwiftUI
+
+public extension TextField where Label == Text {
+    init(titleKey: LocalizedStringKey?, text: Binding<String>, onEditingChanged: @escaping (Bool) -> Void = { _ in }, onCommit: @escaping () -> Void = {}) {
+        if let titleKey = titleKey {
+            self.init(titleKey, text: text, onEditingChanged: onEditingChanged, onCommit: onCommit)
+        } else {
+            self.init(LocalizedStringKey(String()), text: text, onEditingChanged: onEditingChanged, onCommit: onCommit)
+        }
+    }
+
+    init<S>(_ title: S?, text: Binding<String>, onEditingChanged: @escaping (Bool) -> Void = { _ in }, onCommit: @escaping () -> Void = {}) where S: OptionalType, S.Wrapped: StringProtocol {
+        if let title = title?.wrapped {
+            self.init(title, text: text, onEditingChanged: onEditingChanged, onCommit: onCommit)
+        } else {
+            self.init(String(), text: text, onEditingChanged: onEditingChanged, onCommit: onCommit)
+        }
+    }
+
+    init<T>(titleKey: LocalizedStringKey?, value: Binding<T>, formatter: Formatter, onEditingChanged: @escaping (Bool) -> Void = { _ in }, onCommit: @escaping () -> Void = {}) {
+        if let titleKey = titleKey {
+            self.init(titleKey, value: value, formatter: formatter, onEditingChanged: onEditingChanged, onCommit: onCommit)
+        } else {
+            self.init(LocalizedStringKey(String()), value: value, formatter: formatter, onEditingChanged: onEditingChanged, onCommit: onCommit)
+        }
+    }
+
+    init<S, T>(_ title: S?, value: Binding<T>, formatter: Formatter, onEditingChanged: @escaping (Bool) -> Void = { _ in }, onCommit: @escaping () -> Void = {}) where S: OptionalType, S.Wrapped: StringProtocol {
+        if let title = title?.wrapped {
+            self.init(title, value: value, formatter: formatter, onEditingChanged: onEditingChanged, onCommit: onCommit)
+        } else {
+            self.init(String(), value: value, formatter: formatter, onEditingChanged: onEditingChanged, onCommit: onCommit)
+        }
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Extensions/Toggle+OptionalType.swift

@@ -0,0 +1,29 @@
+import SwiftUI
+
+public extension Toggle where Label: View {
+    init(isOn: Binding<Bool>?, @ViewBuilder label: () -> Label) {
+        if let isOn = isOn {
+            self.init(isOn: isOn, label: label)
+        } else {
+            self.init(isOn: Binding.constant(Bool()), label: label)
+        }
+    }
+}
+
+public extension Toggle where Label == Text {
+    init(_ titleKey: LocalizedStringKey?, isOn: Binding<Bool>) {
+        if let titleKey = titleKey {
+            self.init(titleKey, isOn: isOn)
+        } else {
+            self.init(String(), isOn: isOn)
+        }
+    }
+
+    init<S>(_ title: S?, isOn: Binding<Bool>) where S: OptionalType, S.Wrapped: StringProtocol {
+        if let title = title?.wrapped {
+            self.init(title, isOn: isOn)
+        } else {
+            self.init(String(), isOn: isOn)
+        }
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Extensions/UnitPoint+Angle.swift

@@ -0,0 +1,8 @@
+import SwiftUI
+
+extension UnitPoint {
+    static func point(with position: CGFloat, _ radius: CGFloat, _ angle: CGFloat) -> UnitPoint {
+        let radians = angle * .pi / 180.0
+        return UnitPoint(x: (position + radius) * cos(radians), y: (position + radius) * sin(radians))
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Extensions/View+SkeletonModifier.swift

@@ -0,0 +1,8 @@
+import SwiftUI
+
+@available(iOS 13.0, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
+public extension View {
+    func skeleton(with loading: Bool, size: CGSize? = .none, transition: AnyTransition? = nil, animated: Animation? = nil) -> ModifiedContent<Self, SkeletonModifier> {
+        modifier(SkeletonModifier(skeleton: SkeletonInteractor(loading, size: size, transition: transition, animated: animated)))
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Modifiers/SkeletonModifier.swift

@@ -0,0 +1,52 @@
+import SwiftUI
+
+@available(iOS 13.0, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
+public struct SkeletonModifier: ViewModifier {
+    let skeleton: SkeletonInteractable
+    @State var animation: Bool = false
+
+    public func body(content: Content) -> some View {
+        ZStack {
+            if skeleton.presenter.loading {
+                VStack(spacing: skeleton.multiline.presenter.spacing) {
+                    ForEach(0 ..< skeleton.multiline.presenter.lines, id: \.self) { line in
+                        GeometryReader { geometry in
+                            SkeletonView(skeleton: skeleton, line: line)
+                                .frame(width: skeleton.multiline.presenter.scale * geometry.size.width, height: geometry.size.height)
+                                .onReceive([animation].publisher.filter { $0 }.removeDuplicates().first()) { _ in
+                                    withAnimation(skeleton.animation.position.presenter.animation) {
+                                        skeleton.animation.position.value.send(skeleton.animation.position.presenter.range.upperBound)
+                                    }
+                                    withAnimation(skeleton.animation.opacity.presenter.animation) {
+                                        skeleton.animation.opacity.value.send(skeleton.animation.opacity.presenter.range.upperBound)
+                                    }
+                                    withAnimation(skeleton.animation.radius.presenter.animation) {
+                                        skeleton.animation.radius.value.send(skeleton.animation.radius.presenter.range.upperBound)
+                                    }
+                                    withAnimation(skeleton.animation.angle.presenter.animation) {
+                                        skeleton.animation.angle.value.send(skeleton.animation.angle.presenter.range.upperBound)
+                                    }
+                                }
+                                .onAppear {
+                                    DispatchQueue.main.async {
+                                        animation = true
+                                    }
+                                }
+                                .onDisappear {
+                                    DispatchQueue.main.async {
+                                        animation = false
+                                    }
+                                }
+                        }
+                    }
+                }
+                .frame(width: skeleton.presenter.size?.width, height: skeleton.presenter.size?.height)
+                .transition(skeleton.presenter.transition)
+            } else {
+                content
+                    .transition(skeleton.presenter.transition)
+            }
+        }
+        .animation(skeleton.presenter.animated, value: skeleton.presenter.loading)
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Multiline/MultilineInteractor.swift

@@ -0,0 +1,41 @@
+import Combine
+import SwiftUI
+
+// sourcery: AutoMockable
+protocol MultilineInteractable: AnyObject {
+    var presenter: MultilinePresenter { get }
+    var line: CurrentValueSubject<Int, Never> { get }
+    var lines: CurrentValueSubject<Int, Never> { get }
+    var scale: CurrentValueSubject<CGFloat, Never> { get }
+    var spacing: CurrentValueSubject<CGFloat?, Never> { get }
+    var scales: CurrentValueSubject<[Int: CGFloat]?, Never> { get }
+}
+
+final class MultilineInteractor: MultilineInteractable {
+    let presenter = MultilinePresenter()
+    let line: CurrentValueSubject<Int, Never>
+    let lines: CurrentValueSubject<Int, Never>
+    let scale: CurrentValueSubject<CGFloat, Never>
+    let spacing: CurrentValueSubject<CGFloat?, Never>
+    let scales: CurrentValueSubject<[Int: CGFloat]?, Never>
+
+    private var cancellables = Set<AnyCancellable>()
+
+    init() {
+        line = CurrentValueSubject<Int, Never>(presenter.line)
+        lines = CurrentValueSubject<Int, Never>(presenter.lines)
+        scale = CurrentValueSubject<CGFloat, Never>(presenter.scale)
+        spacing = CurrentValueSubject<CGFloat?, Never>(presenter.spacing)
+        scales = CurrentValueSubject<[Int: CGFloat]?, Never>(presenter.scales)
+        line.map { [weak self] line in
+            guard let self = self else { fatalError() }
+            if let scale = self.scales.value?[line] {
+                return scale
+            }
+            return 1
+        }.assign(to: \.scale, on: presenter).store(in: &cancellables)
+        lines.assign(to: \.lines, on: presenter).store(in: &cancellables)
+        scales.assign(to: \.scales, on: presenter).store(in: &cancellables)
+        spacing.assign(to: \.spacing, on: presenter).store(in: &cancellables)
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Multiline/MultilinePresenter.swift

@@ -0,0 +1,9 @@
+import SwiftUI
+
+final class MultilinePresenter: ObservableObject {
+    @Published var line: Int = 0
+    @Published var lines: Int = 1
+    @Published var spacing: CGFloat?
+    @Published var scale: CGFloat = 1
+    @Published var scales: [Int: CGFloat]?
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Opacity/OpacityInteractor.swift

@@ -0,0 +1,29 @@
+import Combine
+import SwiftUI
+
+// sourcery: AutoMockable
+protocol OpacityInteractable: AnyObject {
+    var presenter: OpacityPresenter { get }
+    var animation: CurrentValueSubject<Animation?, Never> { get }
+    var value: CurrentValueSubject<Double, Never> { get }
+    var range: CurrentValueSubject<ClosedRange<Double>, Never> { get }
+}
+
+final class OpacityInteractor: OpacityInteractable {
+    let presenter = OpacityPresenter()
+    let animation: CurrentValueSubject<Animation?, Never>
+    let value: CurrentValueSubject<Double, Never>
+    let range: CurrentValueSubject<ClosedRange<Double>, Never>
+
+    private var cancellables = Set<AnyCancellable>()
+
+    init() {
+        value = CurrentValueSubject<Double, Never>(presenter.value)
+        animation = CurrentValueSubject<Animation?, Never>(presenter.animation)
+        range = CurrentValueSubject<ClosedRange<Double>, Never>(presenter.range)
+        range.assign(to: \.range, on: presenter).store(in: &cancellables)
+        value.assign(to: \.value, on: presenter).store(in: &cancellables)
+        animation.assign(to: \.animation, on: presenter).store(in: &cancellables)
+        range.map { $0.lowerBound }.assign(to: \.value, on: presenter).store(in: &cancellables)
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Opacity/OpacityPresenter.swift

@@ -0,0 +1,7 @@
+import SwiftUI
+
+final class OpacityPresenter: ObservableObject {
+    @Published var animation: Animation?
+    @Published var value: Double = .zero
+    @Published var range: ClosedRange<Double> = .zero ... 1
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Position/PositionInteractor.swift

@@ -0,0 +1,29 @@
+import Combine
+import SwiftUI
+
+// sourcery: AutoMockable
+protocol PositionInteractable: AnyObject {
+    var presenter: PositionPresenter { get }
+    var animation: CurrentValueSubject<Animation?, Never> { get }
+    var value: CurrentValueSubject<CGFloat, Never> { get }
+    var range: CurrentValueSubject<ClosedRange<CGFloat>, Never> { get }
+}
+
+final class PositionInteractor: PositionInteractable {
+    let presenter = PositionPresenter()
+    let animation: CurrentValueSubject<Animation?, Never>
+    let value: CurrentValueSubject<CGFloat, Never>
+    let range: CurrentValueSubject<ClosedRange<CGFloat>, Never>
+
+    private var cancellables = Set<AnyCancellable>()
+
+    init() {
+        value = CurrentValueSubject<CGFloat, Never>(presenter.value)
+        animation = CurrentValueSubject<Animation?, Never>(presenter.animation)
+        range = CurrentValueSubject<ClosedRange<CGFloat>, Never>(presenter.range)
+        range.assign(to: \.range, on: presenter).store(in: &cancellables)
+        value.assign(to: \.value, on: presenter).store(in: &cancellables)
+        animation.assign(to: \.animation, on: presenter).store(in: &cancellables)
+        range.map { $0.lowerBound }.assign(to: \.value, on: presenter).store(in: &cancellables)
+    }
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Position/PositionPresenter.swift

@@ -0,0 +1,7 @@
+import SwiftUI
+
+final class PositionPresenter: ObservableObject {
+    @Published var animation: Animation?
+    @Published var value: CGFloat = .zero
+    @Published var range: ClosedRange<CGFloat> = .zero ... 1
+}

package/example/ios/Pods/SkeletonUI/Sources/SkeletonUI/Protocols/OptionalType.swift

@@ -0,0 +1,4 @@
+public protocol OptionalType {
+    associatedtype Wrapped
+    var wrapped: Wrapped? { get }
+}