lottie-ios 3.2.0 → 3.4.0

package/Sources/Public/DynamicProperties/ValueProviders/GradientValueProvider.swift

@@ -0,0 +1,125 @@
+//
+//  GradientValueProvider.swift
+//  lottie-swift
+//
+//  Created by Enrique Bermúdez on 10/27/19.
+//
+
+import CoreGraphics
+import Foundation
+
+/// 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 = []
+  }
+
+  /// Initializes with an array of colors.
+  public init(
+    _ colors: [Color],
+    locations: [Double] = [])
+  {
+    self.colors = colors
+    self.locations = locations
+    updateValueArray()
+    hasUpdate = true
+  }
+
+  // MARK: Public
+
+  /// Returns a [Color] for a CGFloat(Frame Time).
+  public typealias ColorsValueBlock = (CGFloat) -> [Color]
+  /// Returns a [Double](Color locations) for a CGFloat(Frame Time).
+  public typealias ColorLocationsBlock = (CGFloat) -> [Double]
+
+  /// The colors values of the provider.
+  public var colors: [Color] {
+    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]> {
+    .closure { [self] frame in
+      hasUpdate = false
+
+      if let block = block {
+        let newColors = block(frame)
+        let newLocations = locationsBlock?(frame) ?? []
+        value = value(from: newColors, locations: newLocations)
+      }
+
+      return 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 func value(from colors: [Color], 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)
+  }
+}

package/{lottie-swift/src → Sources}/Public/DynamicProperties/ValueProviders/PointValueProvider.swift

@@ -5,60 +5,65 @@
 //  Created by Brandon Withrow on 2/4/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 /// A `ValueProvider` that returns a CGPoint Value
-public final class PointValueProvider: AnyValueProvider {
-  
-  /// Returns a CGPoint for a CGFloat(Frame Time)
-  public typealias PointValueBlock = (CGFloat) -> CGPoint
-  
-  public var point: CGPoint {
-    didSet {
-      hasUpdate = true
-    }
-  }
-  
+public final class PointValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
   /// Initializes with a block provider
   public init(block: @escaping PointValueBlock) {
     self.block = block
-    self.point = .zero
+    point = .zero
   }
-  
+
   /// Initializes with a single point.
   public init(_ point: CGPoint) {
     self.point = point
-    self.block = nil
+    block = nil
     hasUpdate = true
   }
-  
+
+  // 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 {
-    return Vector3D.self
+    Vector3D.self
+  }
+
+  public var storage: ValueProviderStorage<Vector3D> {
+    if let block = 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 {
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
     if block != nil {
       return true
     }
     return hasUpdate
   }
-  
-  public func value(frame: CGFloat) -> Any {
-    hasUpdate = false
-    let newPoint: CGPoint
-    if let block = block {
-      newPoint = block(frame)
-    } else {
-      newPoint = point
-    }
-    return newPoint.vector3dValue
-  }
-  
+
   // MARK: Private
-  
-  private var hasUpdate: Bool = true
-  
+
+  private var hasUpdate = true
+
   private var block: PointValueBlock?
 }

package/{lottie-swift/src → Sources}/Public/DynamicProperties/ValueProviders/SizeValueProvider.swift

@@ -5,61 +5,66 @@
 //  Created by Brandon Withrow on 2/4/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
 /// A `ValueProvider` that returns a CGSize Value
-public final class SizeValueProvider: AnyValueProvider {
-  
-  /// Returns a CGSize for a CGFloat(Frame Time)
-  public typealias SizeValueBlock = (CGFloat) -> CGSize
-  
-  public var size: CGSize {
-    didSet {
-      hasUpdate = true
-    }
-  }
-  
+public final class SizeValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
   /// Initializes with a block provider
   public init(block: @escaping SizeValueBlock) {
     self.block = block
-    self.size = .zero
+    size = .zero
   }
-  
+
   /// Initializes with a single size.
   public init(_ size: CGSize) {
     self.size = size
-    self.block = nil
+    block = nil
     hasUpdate = true
   }
-  
+
+  // 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 {
-    return Vector3D.self
+    Vector3D.self
+  }
+
+  public var storage: ValueProviderStorage<Vector3D> {
+    if let block = 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 {
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
     if block != nil {
       return true
     }
     return hasUpdate
   }
-  
-  public func value(frame: CGFloat) -> Any {
-    hasUpdate = false
-    let newSize: CGSize
-    if let block = block {
-      newSize = block(frame)
-    } else {
-      newSize = size
-    }
-    return newSize.vector3dValue
-  }
-  
+
   // MARK: Private
-  
-  private var hasUpdate: Bool = true
-  
+
+  private var hasUpdate = true
+
   private var block: SizeValueBlock?
 }

package/{lottie-swift/src → Sources}/Public/FontProvider/AnimationFontProvider.swift

@@ -6,23 +6,30 @@
 //  Copyright © 2020 YurtvilleProds. All rights reserved.
 //
 
-import Foundation
 import CoreGraphics
 import CoreText
+import Foundation
+
+// MARK: - AnimationFontProvider
 
-/**
- Font provider is a protocol that is used to supply fonts to `AnimationView`.
- 
- */
+/// Font provider is a protocol that is used to supply fonts to `AnimationView`.
+///
 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? {
-    return CTFontCreateWithName(family as CFString, size, nil)
+    CTFontCreateWithName(family as CFString, size, nil)
   }
-  
-  public init() {}
 }

package/Sources/Public/ImageProvider/AnimationImageProvider.swift

@@ -0,0 +1,21 @@
+//
+//  LottieImageProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+import CoreGraphics
+import Foundation
+
+/// Image provider is a protocol that is used to supply images to `AnimationView`.
+///
+/// Some animations require a reference to an image. The image provider loads and
+/// provides those images to the `AnimationView`.  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 {
+  func imageForAsset(asset: ImageAsset) -> CGImage?
+}

package/Sources/Public/Keyframes/Interpolatable.swift

@@ -0,0 +1,253 @@
+// Created by Cal Stephens on 1/24/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import CoreGraphics
+
+// MARK: - Interpolatable
+
+/// A type that can be interpolated between two values
+public protocol Interpolatable: AnyInterpolatable {
+  /// Interpolates the `self` to the given number by `amount`.
+  ///  - Parameter to: The number to interpolate to.
+  ///  - Parameter amount: The amount to interpolate,
+  ///    relative to 0.0 (self) and 1.0 (to).
+  ///    `amount` can be greater than one and less than zero,
+  ///    and interpolation should not be clamped.
+  ///
+  ///  ```
+  ///  let number = 5
+  ///  let interpolated = number.interpolateTo(10, amount: 0.5)
+  ///  print(interpolated) // 7.5
+  ///  ```
+  ///
+  ///  ```
+  ///  let number = 5
+  ///  let interpolated = number.interpolateTo(10, amount: 1.5)
+  ///  print(interpolated) // 12.5
+  ///  ```
+  func interpolate(to: Self, amount: CGFloat) -> Self
+}
+
+// MARK: - SpatialInterpolatable
+
+/// A type that can be interpolated between two values,
+/// additionally using optional `spatialOutTangent` and `spatialInTangent` values.
+///  - If your implementation doesn't use the `spatialOutTangent` and `spatialInTangent`
+///    parameters, prefer implementing the simpler `Interpolatable` protocol.
+public protocol SpatialInterpolatable: AnyInterpolatable {
+  /// Interpolates the `self` to the given number by `amount`.
+  ///  - Parameter to: The number to interpolate to.
+  ///  - Parameter amount: The amount to interpolate,
+  ///    relative to 0.0 (self) and 1.0 (to).
+  ///    `amount` can be greater than one and less than zero,
+  ///    and interpolation should not be clamped.
+  func interpolate(
+    to: Self,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?)
+    -> Self
+}
+
+// MARK: - AnyInterpolatable
+
+/// The base protocol that is implemented by both `Interpolatable` and `SpatialInterpolatable`
+/// Types should not directly implement this protocol.
+public protocol AnyInterpolatable {
+  /// Interpolates by calling either `Interpolatable.interpolate`
+  /// or `SpatialInterpolatable.interpolate`.
+  /// Should not be implemented or called by consumers.
+  func _interpolate(
+    to: Self,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?)
+    -> Self
+}
+
+extension Interpolatable {
+  public func _interpolate(
+    to: Self,
+    amount: CGFloat,
+    spatialOutTangent _: CGPoint?,
+    spatialInTangent _: CGPoint?)
+    -> Self
+  {
+    interpolate(to: to, amount: amount)
+  }
+}
+
+extension SpatialInterpolatable {
+  /// Helper that interpolates this `SpatialInterpolatable`
+  /// with `nil` spatial in/out tangents
+  public func interpolate(to: Self, amount: CGFloat) -> Self {
+    interpolate(
+      to: to,
+      amount: amount,
+      spatialOutTangent: nil,
+      spatialInTangent: nil)
+  }
+
+  public func _interpolate(
+    to: Self,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?)
+    -> Self
+  {
+    interpolate(
+      to: to,
+      amount: amount,
+      spatialOutTangent: spatialOutTangent,
+      spatialInTangent: spatialInTangent)
+  }
+}
+
+// MARK: - Double + Interpolatable
+
+extension Double: Interpolatable { }
+
+// MARK: - CGFloat + Interpolatable
+
+extension CGFloat: Interpolatable { }
+
+// MARK: - Float + Interpolatable
+
+extension Float: Interpolatable { }
+
+extension Interpolatable where Self: BinaryFloatingPoint {
+  public func interpolate(to: Self, amount: CGFloat) -> Self {
+    self + ((to - self) * Self(amount))
+  }
+}
+
+// MARK: - CGRect + Interpolatable
+
+extension CGRect: Interpolatable {
+  public func interpolate(to: CGRect, amount: CGFloat) -> CGRect {
+    CGRect(
+      x: origin.x.interpolate(to: to.origin.x, amount: amount),
+      y: origin.y.interpolate(to: to.origin.y, amount: amount),
+      width: width.interpolate(to: to.width, amount: amount),
+      height: height.interpolate(to: to.height, amount: amount))
+  }
+}
+
+// MARK: - CGSize + Interpolatable
+
+extension CGSize: Interpolatable {
+  public func interpolate(to: CGSize, amount: CGFloat) -> CGSize {
+    CGSize(
+      width: width.interpolate(to: to.width, amount: amount),
+      height: height.interpolate(to: to.height, amount: amount))
+  }
+}
+
+// MARK: - CGPoint + SpatialInterpolatable
+
+extension CGPoint: SpatialInterpolatable {
+  public func interpolate(
+    to: CGPoint,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?)
+    -> CGPoint
+  {
+    guard
+      let outTan = spatialOutTangent,
+      let inTan = spatialInTangent
+    else {
+      return CGPoint(
+        x: x.interpolate(to: to.x, amount: amount),
+        y: y.interpolate(to: to.y, amount: amount))
+    }
+
+    let cp1 = self + outTan
+    let cp2 = to + inTan
+    return interpolate(to, outTangent: cp1, inTangent: cp2, amount: amount)
+  }
+}
+
+// MARK: - Color + Interpolatable
+
+extension Color: Interpolatable {
+  public func interpolate(to: Color, amount: CGFloat) -> Color {
+    Color(
+      r: r.interpolate(to: to.r, amount: amount),
+      g: g.interpolate(to: to.g, amount: amount),
+      b: b.interpolate(to: to.b, amount: amount),
+      a: a.interpolate(to: to.a, amount: amount))
+  }
+}
+
+// MARK: - Vector1D + Interpolatable
+
+extension Vector1D: Interpolatable {
+  public func interpolate(to: Vector1D, amount: CGFloat) -> Vector1D {
+    value.interpolate(to: to.value, amount: amount).vectorValue
+  }
+}
+
+// MARK: - Vector2D + SpatialInterpolatable
+
+extension Vector2D: SpatialInterpolatable {
+  public func interpolate(
+    to: Vector2D,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?)
+    -> Vector2D
+  {
+    pointValue.interpolate(
+      to: to.pointValue,
+      amount: amount,
+      spatialOutTangent: spatialOutTangent,
+      spatialInTangent: spatialInTangent)
+      .vector2dValue
+  }
+}
+
+// MARK: - Vector3D + SpatialInterpolatable
+
+extension Vector3D: SpatialInterpolatable {
+  public func interpolate(
+    to: Vector3D,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?)
+    -> Vector3D
+  {
+    if spatialInTangent != nil || spatialOutTangent != nil {
+      // TODO Support third dimension spatial interpolation
+      let point = pointValue.interpolate(
+        to: to.pointValue,
+        amount: amount,
+        spatialOutTangent: spatialOutTangent,
+        spatialInTangent: spatialInTangent)
+
+      return Vector3D(
+        x: point.x,
+        y: point.y,
+        z: CGFloat(z.interpolate(to: to.z, amount: amount)))
+    }
+
+    return Vector3D(
+      x: x.interpolate(to: to.x, amount: amount),
+      y: y.interpolate(to: to.y, amount: amount),
+      z: z.interpolate(to: to.z, amount: amount))
+  }
+}
+
+// MARK: - Array + Interpolatable, AnyInterpolatable
+
+extension Array: Interpolatable, AnyInterpolatable where Element: Interpolatable {
+  public func interpolate(to: [Element], amount: CGFloat) -> [Element] {
+    LottieLogger.shared.assert(
+      count == to.count,
+      "When interpolating Arrays, both array sound have the same element count.")
+
+    return zip(self, to).map { lhs, rhs in
+      lhs.interpolate(to: rhs, amount: amount)
+    }
+  }
+}