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

package/compose/build/cocoapods/synthetic/ios/Pods/lottie-ios/Sources/Public/DynamicProperties/AnyValueProvider.swift

@@ -0,0 +1,131 @@
+//
+//  AnyValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import Foundation
+
+// MARK: - AnyValueProvider
+
+/// `AnyValueProvider` is a protocol that return animation data for a property at a
+/// given time. Every frame a `LottieAnimationView` queries all of its properties and asks
+/// if their ValueProvider has an update. If it does the LottieAnimationView will read the
+/// property and update that portion of the animation.
+///
+/// Value Providers can be used to dynamically set animation properties at run time.
+public protocol AnyValueProvider {
+
+  /// The Type of the value provider
+  var valueType: Any.Type { get }
+
+  /// The type-erased storage for this Value Provider
+  var typeErasedStorage: AnyValueProviderStorage { get }
+
+  /// Asks the provider if it has an update for the given frame.
+  func hasUpdate(frame: AnimationFrameTime) -> Bool
+
+}
+
+extension AnyValueProvider {
+  /// Asks the provider to update the container with its value for the frame.
+  public func value(frame: AnimationFrameTime) -> Any {
+    typeErasedStorage.value(frame: frame)
+  }
+}
+
+// MARK: - ValueProvider
+
+/// A base protocol for strongly-typed Value Providers
+protocol ValueProvider: AnyValueProvider {
+  associatedtype Value: AnyInterpolatable
+
+  /// The strongly-typed storage for this Value Provider
+  var storage: ValueProviderStorage<Value> { get }
+}
+
+extension ValueProvider {
+  public var typeErasedStorage: AnyValueProviderStorage {
+    switch storage {
+    case .closure(let typedClosure):
+      return .closure(typedClosure)
+
+    case .singleValue(let typedValue):
+      return .singleValue(typedValue)
+
+    case .keyframes(let keyframes):
+      return .keyframes(
+        keyframes.map { keyframe in
+          keyframe.withValue(keyframe.value as Any)
+        },
+        interpolate: storage.value(frame:))
+    }
+  }
+}
+
+// MARK: - ValueProviderStorage
+
+/// The underlying storage of a `ValueProvider`
+public enum ValueProviderStorage<T: AnyInterpolatable> {
+  /// The value provider stores a single value that is used on all frames
+  case singleValue(T)
+
+  /// The value provider stores a group of keyframes
+  ///  - The main-thread rendering engine interpolates values in these keyframes
+  ///    using `T`'s `Interpolatable` implementation.
+  ///  - The Core Animation rendering engine constructs a `CAKeyframeAnimation`
+  ///    using these keyframes. The Core Animation render server performs
+  ///    the interpolation, without calling `T`'s `Interpolatable` implementation.
+  case keyframes([Keyframe<T>])
+
+  /// The value provider stores a closure that is invoked on every frame
+  ///  - This is only supported by the main-thread rendering engine
+  case closure((AnimationFrameTime) -> T)
+
+  // MARK: Internal
+
+  func value(frame: AnimationFrameTime) -> T {
+    switch self {
+    case .singleValue(let value):
+      return value
+
+    case .closure(let closure):
+      return closure(frame)
+
+    case .keyframes(let keyframes):
+      return KeyframeInterpolator(keyframes: ContiguousArray(keyframes)).storage.value(frame: frame)
+    }
+  }
+}
+
+// MARK: - AnyValueProviderStorage
+
+/// A type-erased representation of `ValueProviderStorage`
+public enum AnyValueProviderStorage {
+  /// The value provider stores a single value that is used on all frames
+  case singleValue(Any)
+
+  /// The value provider stores a group of keyframes
+  ///  - Since we can't interpolate a type-erased `KeyframeGroup`,
+  ///    the interpolation has to be performed in the `interpolate` closure.
+  case keyframes([Keyframe<Any>], interpolate: (AnimationFrameTime) -> Any)
+
+  /// The value provider stores a closure that is invoked on every frame
+  case closure((AnimationFrameTime) -> Any)
+
+  // MARK: Internal
+
+  func value(frame: AnimationFrameTime) -> Any {
+    switch self {
+    case .singleValue(let value):
+      return value
+
+    case .closure(let closure):
+      return closure(frame)
+
+    case .keyframes(_, let valueForFrame):
+      return valueForFrame(frame)
+    }
+  }
+}

package/compose/build/cocoapods/synthetic/ios/Pods/lottie-ios/Sources/Public/DynamicProperties/ValueProviders/ColorValueProvider.swift

@@ -0,0 +1,98 @@
+//
+//  ColorValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - ColorValueProvider
+
+/// A `ValueProvider` that returns a CGColor Value
+public final class ColorValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes with a block provider
+  public init(block: @escaping ColorValueBlock) {
+    self.block = block
+    color = LottieColor(r: 0, g: 0, b: 0, a: 1)
+    keyframes = nil
+    identity = UUID()
+  }
+
+  /// Initializes with a single color.
+  public init(_ color: LottieColor) {
+    self.color = color
+    block = nil
+    keyframes = nil
+    hasUpdate = true
+    identity = color
+  }
+
+  /// Initializes with multiple colors, with timing information
+  public init(_ keyframes: [Keyframe<LottieColor>]) {
+    self.keyframes = keyframes
+    color = LottieColor(r: 0, g: 0, b: 0, a: 1)
+    block = nil
+    hasUpdate = true
+    identity = keyframes
+  }
+
+  // MARK: Public
+
+  /// Returns a LottieColor for a CGColor(Frame Time)
+  public typealias ColorValueBlock = (CGFloat) -> LottieColor
+
+  /// The color value of the provider.
+  public var color: LottieColor {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  // MARK: ValueProvider Protocol
+
+  public var valueType: Any.Type {
+    LottieColor.self
+  }
+
+  public var storage: ValueProviderStorage<LottieColor> {
+    if let block {
+      return .closure { frame in
+        self.hasUpdate = false
+        return block(frame)
+      }
+    } else if let keyframes {
+      return .keyframes(keyframes)
+    } else {
+      hasUpdate = false
+      return .singleValue(color)
+    }
+  }
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
+    if block != nil {
+      return true
+    }
+    return hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+
+  private var block: ColorValueBlock?
+  private var keyframes: [Keyframe<LottieColor>]?
+  private var identity: AnyHashable
+}
+
+// MARK: Equatable
+
+extension ColorValueProvider: Equatable {
+  public static func ==(_ lhs: ColorValueProvider, _ rhs: ColorValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
+}

package/compose/build/cocoapods/synthetic/ios/Pods/lottie-ios/Sources/Public/DynamicProperties/ValueProviders/FloatValueProvider.swift

@@ -0,0 +1,83 @@
+//
+//  DoubleValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - FloatValueProvider
+
+/// A `ValueProvider` that returns a CGFloat Value
+public final class FloatValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes with a block provider
+  public init(block: @escaping CGFloatValueBlock) {
+    self.block = block
+    float = 0
+    identity = UUID()
+  }
+
+  /// Initializes with a single float.
+  public init(_ float: CGFloat) {
+    self.float = float
+    block = nil
+    hasUpdate = true
+    identity = float
+  }
+
+  // MARK: Public
+
+  /// Returns a CGFloat for a CGFloat(Frame Time)
+  public typealias CGFloatValueBlock = (CGFloat) -> CGFloat
+
+  public var float: CGFloat {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  // MARK: ValueProvider Protocol
+
+  public var valueType: Any.Type {
+    LottieVector1D.self
+  }
+
+  public var storage: ValueProviderStorage<LottieVector1D> {
+    if let block {
+      return .closure { frame in
+        self.hasUpdate = false
+        return LottieVector1D(Double(block(frame)))
+      }
+    } else {
+      hasUpdate = false
+      return .singleValue(LottieVector1D(Double(float)))
+    }
+  }
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
+    if block != nil {
+      return true
+    }
+    return hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+
+  private var block: CGFloatValueBlock?
+  private var identity: AnyHashable
+}
+
+// MARK: Equatable
+
+extension FloatValueProvider: Equatable {
+  public static func ==(_ lhs: FloatValueProvider, _ rhs: FloatValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
+}

package/compose/build/cocoapods/synthetic/ios/Pods/lottie-ios/Sources/Public/DynamicProperties/ValueProviders/GradientValueProvider.swift

@@ -0,0 +1,140 @@
+//
+//  GradientValueProvider.swift
+//  lottie-swift
+//
+//  Created by Enrique Bermúdez on 10/27/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - GradientValueProvider
+
+/// A `ValueProvider` that returns a Gradient Color Value.
+public final class GradientValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes with a block provider.
+  public init(
+    block: @escaping ColorsValueBlock,
+    locations: ColorLocationsBlock? = nil)
+  {
+    self.block = block
+    locationsBlock = locations
+    colors = []
+    self.locations = []
+    identity = UUID()
+  }
+
+  /// Initializes with an array of colors.
+  public init(
+    _ colors: [LottieColor],
+    locations: [Double] = [])
+  {
+    self.colors = colors
+    self.locations = locations
+    identity = [AnyHashable(colors), AnyHashable(locations)]
+    updateValueArray()
+    hasUpdate = true
+  }
+
+  // MARK: Public
+
+  /// Returns a [LottieColor] for a CGFloat(Frame Time).
+  public typealias ColorsValueBlock = (CGFloat) -> [LottieColor]
+  /// Returns a [Double](Color locations) for a CGFloat(Frame Time).
+  public typealias ColorLocationsBlock = (CGFloat) -> [Double]
+
+  /// The colors values of the provider.
+  public var colors: [LottieColor] {
+    didSet {
+      updateValueArray()
+      hasUpdate = true
+    }
+  }
+
+  /// The color location values of the provider.
+  public var locations: [Double] {
+    didSet {
+      updateValueArray()
+      hasUpdate = true
+    }
+  }
+
+  // MARK: ValueProvider Protocol
+
+  public var valueType: Any.Type {
+    [Double].self
+  }
+
+  public var storage: ValueProviderStorage<[Double]> {
+    if let block {
+      return .closure { [self] frame in
+        hasUpdate = false
+
+        let newColors = block(frame)
+        let newLocations = locationsBlock?(frame) ?? []
+        value = value(from: newColors, locations: newLocations)
+
+        return value
+      }
+    } else {
+      return .singleValue(value)
+    }
+  }
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
+    if block != nil || locationsBlock != nil {
+      return true
+    }
+    return hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+
+  private var block: ColorsValueBlock?
+  private var locationsBlock: ColorLocationsBlock?
+  private var value: [Double] = []
+
+  private let identity: AnyHashable
+
+  private func value(from colors: [LottieColor], locations: [Double]) -> [Double] {
+    var colorValues = [Double]()
+    var alphaValues = [Double]()
+    var shouldAddAlphaValues = false
+
+    for i in 0..<colors.count {
+      if colors[i].a < 1 { shouldAddAlphaValues = true }
+
+      let location = locations.count > i
+        ? locations[i]
+        : (Double(i) / Double(colors.count - 1))
+
+      colorValues.append(location)
+      colorValues.append(colors[i].r)
+      colorValues.append(colors[i].g)
+      colorValues.append(colors[i].b)
+
+      alphaValues.append(location)
+      alphaValues.append(colors[i].a)
+    }
+
+    return colorValues + (shouldAddAlphaValues ? alphaValues : [])
+  }
+
+  private func updateValueArray() {
+    value = value(from: colors, locations: locations)
+  }
+
+}
+
+// MARK: Equatable
+
+extension GradientValueProvider: Equatable {
+  public static func ==(_ lhs: GradientValueProvider, _ rhs: GradientValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
+}

package/compose/build/cocoapods/synthetic/ios/Pods/lottie-ios/Sources/Public/DynamicProperties/ValueProviders/PointValueProvider.swift

@@ -0,0 +1,83 @@
+//
+//  PointValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - PointValueProvider
+
+/// A `ValueProvider` that returns a CGPoint Value
+public final class PointValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes with a block provider
+  public init(block: @escaping PointValueBlock) {
+    self.block = block
+    point = .zero
+    identity = UUID()
+  }
+
+  /// Initializes with a single point.
+  public init(_ point: CGPoint) {
+    self.point = point
+    block = nil
+    hasUpdate = true
+    identity = [point.x, point.y]
+  }
+
+  // MARK: Public
+
+  /// Returns a CGPoint for a CGFloat(Frame Time)
+  public typealias PointValueBlock = (CGFloat) -> CGPoint
+
+  public var point: CGPoint {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  // MARK: ValueProvider Protocol
+
+  public var valueType: Any.Type {
+    LottieVector3D.self
+  }
+
+  public var storage: ValueProviderStorage<LottieVector3D> {
+    if let block {
+      return .closure { frame in
+        self.hasUpdate = false
+        return block(frame).vector3dValue
+      }
+    } else {
+      hasUpdate = false
+      return .singleValue(point.vector3dValue)
+    }
+  }
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
+    if block != nil {
+      return true
+    }
+    return hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+
+  private var block: PointValueBlock?
+  private let identity: AnyHashable
+}
+
+// MARK: Equatable
+
+extension PointValueProvider: Equatable {
+  public static func ==(_ lhs: PointValueProvider, _ rhs: PointValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
+}

package/compose/build/cocoapods/synthetic/ios/Pods/lottie-ios/Sources/Public/DynamicProperties/ValueProviders/SizeValueProvider.swift

@@ -0,0 +1,83 @@
+//
+//  SizeValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - SizeValueProvider
+
+/// A `ValueProvider` that returns a CGSize Value
+public final class SizeValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes with a block provider
+  public init(block: @escaping SizeValueBlock) {
+    self.block = block
+    size = .zero
+    identity = UUID()
+  }
+
+  /// Initializes with a single size.
+  public init(_ size: CGSize) {
+    self.size = size
+    block = nil
+    hasUpdate = true
+    identity = [size.width, size.height]
+  }
+
+  // MARK: Public
+
+  /// Returns a CGSize for a CGFloat(Frame Time)
+  public typealias SizeValueBlock = (CGFloat) -> CGSize
+
+  public var size: CGSize {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  // MARK: ValueProvider Protocol
+
+  public var valueType: Any.Type {
+    LottieVector3D.self
+  }
+
+  public var storage: ValueProviderStorage<LottieVector3D> {
+    if let block {
+      return .closure { frame in
+        self.hasUpdate = false
+        return block(frame).vector3dValue
+      }
+    } else {
+      hasUpdate = false
+      return .singleValue(size.vector3dValue)
+    }
+  }
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
+    if block != nil {
+      return true
+    }
+    return hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+
+  private var block: SizeValueBlock?
+  private let identity: AnyHashable
+}
+
+// MARK: Equatable
+
+extension SizeValueProvider: Equatable {
+  public static func ==(_ lhs: SizeValueProvider, _ rhs: SizeValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
+}

package/compose/build/cocoapods/synthetic/ios/Pods/lottie-ios/Sources/Public/FontProvider/AnimationFontProvider.swift

@@ -0,0 +1,41 @@
+//
+//  AnimationFontProvider.swift
+//  Lottie
+//
+//  Created by Brandon Withrow on 8/5/20.
+//  Copyright © 2020 YurtvilleProds. All rights reserved.
+//
+
+import CoreText
+
+// MARK: - AnimationFontProvider
+
+/// Font provider is a protocol that is used to supply fonts to `LottieAnimationView`.
+///
+public protocol AnimationFontProvider {
+  func fontFor(family: String, size: CGFloat) -> CTFont?
+}
+
+// MARK: - DefaultFontProvider
+
+/// Default Font provider.
+public final class DefaultFontProvider: AnimationFontProvider {
+
+  // MARK: Lifecycle
+
+  public init() { }
+
+  // MARK: Public
+
+  public func fontFor(family: String, size: CGFloat) -> CTFont? {
+    CTFontCreateWithName(family as CFString, size, nil)
+  }
+}
+
+// MARK: Equatable
+
+extension DefaultFontProvider: Equatable {
+  public static func ==(_: DefaultFontProvider, _: DefaultFontProvider) -> Bool {
+    true
+  }
+}

package/compose/build/cocoapods/synthetic/ios/Pods/lottie-ios/Sources/Public/ImageProvider/AnimationImageProvider.swift

@@ -0,0 +1,43 @@
+//
+//  LottieImageProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+import QuartzCore
+
+// MARK: - AnimationImageProvider
+
+/// Image provider is a protocol that is used to supply images to `LottieAnimationView`.
+///
+/// Some animations require a reference to an image. The image provider loads and
+/// provides those images to the `LottieAnimationView`.  Lottie includes a couple of
+/// prebuilt Image Providers that supply images from a Bundle, or from a FilePath.
+///
+/// Additionally custom Image Providers can be made to load images from a URL,
+/// or to Cache images.
+public protocol AnimationImageProvider {
+
+  /// Whether or not the resulting image of this image provider can be cached by Lottie. Defaults to true.
+  /// If true, Lottie may internally cache the result of `imageForAsset`
+  var cacheEligible: Bool { get }
+
+  /// The image to display for the given `ImageAsset` defined in the `LottieAnimation` JSON file.
+  func imageForAsset(asset: ImageAsset) -> CGImage?
+
+  /// Specifies how the layer's contents are positioned or scaled within its bounds for a given asset.
+  /// Defaults to `.resize`, which stretches the image to fill the layer.
+  func contentsGravity(for asset: ImageAsset) -> CALayerContentsGravity
+}
+
+extension AnimationImageProvider {
+  public var cacheEligible: Bool {
+    true
+  }
+
+  /// The default value is `.resize`, similar to that of `CALayer`.
+  public func contentsGravity(for _: ImageAsset) -> CALayerContentsGravity {
+    .resize
+  }
+}