lottie-ios 3.4.3 → 3.5.0

package/Sources/Public/Animation/{AnimationView.swift → LottieAnimationView.swift}

@@ -1,5 +1,5 @@
 //
-//  AnimationView.swift
+//  LottieAnimationView.swift
 //  lottie-swift
 //
 //  Created by Brandon Withrow on 1/23/19.
@@ -37,7 +37,7 @@ public enum LottieBackgroundBehavior {
 
   /// The default background behavior, based on the rendering engine being used to play the animation.
   ///  - Playing an animation using the Main Thread rendering engine comes with CPU overhead,
-  ///    so the animation should be paused or stopped when the `AnimationView` is not visible.
+  ///    so the animation should be paused or stopped when the `LottieAnimationView` is not visible.
   ///  - Playing an animation using the Core Animation rendering engine does not come with any
   ///    CPU overhead, so these animations do not need to be paused in the background.
   public static func `default`(for renderingEngine: RenderingEngine) -> LottieBackgroundBehavior {
@@ -86,8 +86,16 @@ extension LottieLoopMode: Equatable {
 
 // MARK: - AnimationView
 
+@available(*, deprecated, renamed: "LottieAnimationView", message: """
+  `AnimationView` has been renamed to `LottieAnimationView`, for consistency with \
+  the new `LottieAnimation` type. This notice will be removed in Lottie 4.0.
+  """)
+public typealias AnimationView = LottieAnimationView
+
+// MARK: - LottieAnimationView
+
 @IBDesignable
-final public class AnimationView: AnimationViewBase {
+final public class LottieAnimationView: LottieAnimationViewBase {
 
   // MARK: Lifecycle
 
@@ -95,7 +103,7 @@ final public class AnimationView: AnimationViewBase {
 
   /// Initializes an AnimationView with an animation.
   public init(
-    animation: Animation?,
+    animation: LottieAnimation?,
     imageProvider: AnimationImageProvider? = nil,
     textProvider: AnimationTextProvider = DefaultTextProvider(),
     fontProvider: AnimationFontProvider = DefaultFontProvider(),
@@ -153,7 +161,7 @@ final public class AnimationView: AnimationViewBase {
 
   // MARK: Public
 
-  /// The configuration that this `AnimationView` uses when playing its animation
+  /// The configuration that this `LottieAnimationView` uses when playing its animation
   public let configuration: LottieConfiguration
 
   /// Value Providers that have been registered using `setValueProvider(_:keypath:)`
@@ -195,7 +203,7 @@ final public class AnimationView: AnimationViewBase {
   /// Sets the animation backing the animation view. Setting this will clear the
   /// view's contents, completion blocks and current state. The new animation will
   /// be loaded up and set to the beginning of its timeline.
-  public var animation: Animation? {
+  public var animation: LottieAnimation? {
     didSet {
       makeAnimationLayer(usingEngine: configuration.renderingEngine)
     }
@@ -341,7 +349,7 @@ final public class AnimationView: AnimationViewBase {
   }
 
   /// When `true` the animation will play back at the framerate encoded in the
-  /// `Animation` model. When `false` the animation will play at the framerate
+  /// `LottieAnimation` model. When `false` the animation will play at the framerate
   /// of the device.
   ///
   /// Defaults to false
@@ -513,6 +521,32 @@ final public class AnimationView: AnimationViewBase {
     addNewAnimationForContext(context)
   }
 
+  /// Plays the animation from a named marker to the end of the marker's duration.
+  ///
+  /// A marker is a point in time with an associated duration that is encoded into the
+  /// animation data and assigned a name.
+  ///
+  /// NOTE: If marker is not found the play command will exit.
+  ///
+  /// - Parameter marker: The start marker for the animation playback.
+  /// - Parameter loopMode: The loop behavior of the animation. If `nil` the view's `loopMode` property will be used.
+  /// - Parameter completion: An optional completion closure to be called when the animation stops.
+  public func play(
+    marker: String,
+    loopMode: LottieLoopMode? = nil,
+    completion: LottieCompletionBlock? = nil)
+  {
+    guard let from = animation?.markerMap?[marker] else {
+      return
+    }
+
+    play(
+      fromFrame: from.frameTime,
+      toFrame: from.frameTime + from.durationFrameTime,
+      loopMode: loopMode,
+      completion: completion)
+  }
+
   /// Stops the animation and resets the view to its start frame.
   ///
   /// The completion closure will be called with `false`
@@ -533,7 +567,7 @@ final public class AnimationView: AnimationViewBase {
     animationLayer?.reloadImages()
   }
 
-  /// Forces the AnimationView to redraw its contents.
+  /// Forces the LottieAnimationView to redraw its contents.
   public func forceDisplayUpdate() {
     animationLayer?.forceDisplayUpdate()
   }
@@ -625,7 +659,7 @@ final public class AnimationView: AnimationViewBase {
     }
   }
 
-  /// Converts a CGRect from the AnimationView's coordinate space into the
+  /// Converts a CGRect from the LottieAnimationView's coordinate space into the
   /// coordinate space of the layer found at Keypath.
   ///
   /// If no layer is found, nil is returned
@@ -646,7 +680,7 @@ final public class AnimationView: AnimationViewBase {
     return animationLayer.convert(rect, to: sublayer)
   }
 
-  /// Converts a CGPoint from the AnimationView's coordinate space into the
+  /// Converts a CGPoint from the LottieAnimationView's coordinate space into the
   /// coordinate space of the layer found at Keypath.
   ///
   /// If no layer is found, nil is returned
@@ -713,6 +747,21 @@ final public class AnimationView: AnimationViewBase {
     return animation.frameTime(forMarker: named)
   }
 
+  /// Markers are a way to describe a point in time and a duration by a key name.
+  ///
+  /// Markers are encoded into animation JSON. By using markers a designer can mark
+  /// playback points for a developer to use without having to worry about keeping
+  /// track of animation frames. If the animation file is updated, the developer
+  /// does not need to update playback code.
+  ///
+  /// - Returns: The duration frame time for the marker, or `nil` if no marker found.
+  public func durationFrameTime(forMarker named: String) -> AnimationFrameTime? {
+    guard let animation = animation else {
+      return nil
+    }
+    return animation.durationFrameTime(forMarker: named)
+  }
+
   // MARK: Internal
 
   var animationLayer: RootAnimationLayer? = nil
@@ -721,7 +770,7 @@ final public class AnimationView: AnimationViewBase {
   @IBInspectable var animationName: String? {
     didSet {
       self.animation = animationName.flatMap {
-        Animation.named($0, animationCache: nil)
+        LottieAnimation.named($0, animationCache: nil)
       }
     }
   }
@@ -925,12 +974,12 @@ final public class AnimationView: AnimationViewBase {
 
   // MARK: Fileprivate
 
-  /// Context describing the animation that is currently playing in this `AnimationView`
+  /// Context describing the animation that is currently playing in this `LottieAnimationView`
   ///  - When non-nil, an animation is currently playing in this view. Otherwise,
   ///    the view is paused on a specific frame.
   fileprivate var animationContext: AnimationContext?
 
-  fileprivate var _activeAnimationName: String = AnimationView.animationName
+  fileprivate var _activeAnimationName: String = LottieAnimationView.animationName
   fileprivate var animationID = 0
 
   fileprivate var waitingToPlayAnimation = false
@@ -982,7 +1031,7 @@ final public class AnimationView: AnimationViewBase {
     currentFrame = CGFloat(animation.startFrame)
   }
 
-  fileprivate func makeMainThreadAnimationLayer(for animation: Animation) -> MainThreadAnimationLayer {
+  fileprivate func makeMainThreadAnimationLayer(for animation: LottieAnimation) -> MainThreadAnimationLayer {
     MainThreadAnimationLayer(
       animation: animation,
       imageProvider: imageProvider.cachedImageProvider,
@@ -991,7 +1040,7 @@ final public class AnimationView: AnimationViewBase {
       logger: logger)
   }
 
-  fileprivate func makeCoreAnimationLayer(for animation: Animation) -> CoreAnimationLayer? {
+  fileprivate func makeCoreAnimationLayer(for animation: LottieAnimation) -> CoreAnimationLayer? {
     do {
       let coreAnimationLayer = try CoreAnimationLayer(
         animation: animation,
@@ -1024,7 +1073,7 @@ final public class AnimationView: AnimationViewBase {
     }
   }
 
-  fileprivate func makeAutomaticEngineLayer(for animation: Animation) -> CoreAnimationLayer? {
+  fileprivate func makeAutomaticEngineLayer(for animation: LottieAnimation) -> CoreAnimationLayer? {
     do {
       // Attempt to set up the Core Animation layer. This can either throw immediately in `init`,
       // or throw an error later in `CALayer.display()` that will be reported in `didSetUpAnimation`.
@@ -1135,7 +1184,7 @@ final public class AnimationView: AnimationViewBase {
   ///    this step lets us avoid building the animations twice (once paused
   ///    and once again playing)
   ///  - This method should only be called immediately before setting up another
-  ///    animation -- otherwise this AnimationView could be put in an inconsistent state.
+  ///    animation -- otherwise this LottieAnimationView could be put in an inconsistent state.
   fileprivate func removeCurrentAnimationIfNecessary() {
     switch currentRenderingEngine {
     case .mainThread:
@@ -1144,7 +1193,7 @@ final public class AnimationView: AnimationViewBase {
       // We still need to remove the `animationContext`, since it should only be present
       // when an animation is actually playing. Without this calling `removeCurrentAnimationIfNecessary()`
       // and then setting the animation to a specific paused frame would put this
-      // `AnimationView` in an inconsistent state.
+      // `LottieAnimationView` in an inconsistent state.
       animationContext = nil
     }
   }
@@ -1208,7 +1257,7 @@ final public class AnimationView: AnimationViewBase {
     }
 
     animationID = animationID + 1
-    _activeAnimationName = AnimationView.animationName + String(animationID)
+    _activeAnimationName = LottieAnimationView.animationName + String(animationID)
 
     if let coreAnimationLayer = animationlayer as? CoreAnimationLayer {
       var animationContext = animationContext

package/Sources/Public/Animation/{AnimationViewInitializers.swift → LottieAnimationViewInitializers.swift}

@@ -7,7 +7,7 @@
 
 import Foundation
 
-extension AnimationView {
+extension LottieAnimationView {
 
   // MARK: Lifecycle
 
@@ -26,7 +26,7 @@ extension AnimationView {
     animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache,
     configuration: LottieConfiguration = .shared)
   {
-    let animation = Animation.named(name, bundle: bundle, subdirectory: nil, animationCache: animationCache)
+    let animation = LottieAnimation.named(name, bundle: bundle, subdirectory: nil, animationCache: animationCache)
     let provider = imageProvider ?? BundleImageProvider(bundle: bundle, searchPath: nil)
     self.init(animation: animation, imageProvider: provider, configuration: configuration)
   }
@@ -42,7 +42,7 @@ extension AnimationView {
     animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache,
     configuration: LottieConfiguration = .shared)
   {
-    let animation = Animation.filepath(filePath, animationCache: animationCache)
+    let animation = LottieAnimation.filepath(filePath, animationCache: animationCache)
     let provider = imageProvider ??
       FilepathImageProvider(filepath: URL(fileURLWithPath: filePath).deletingLastPathComponent().path)
     self.init(animation: animation, imageProvider: provider, configuration: configuration)
@@ -57,7 +57,7 @@ extension AnimationView {
   public convenience init(
     url: URL,
     imageProvider: AnimationImageProvider? = nil,
-    closure: @escaping AnimationView.DownloadClosure,
+    closure: @escaping LottieAnimationView.DownloadClosure,
     animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache,
     configuration: LottieConfiguration = .shared)
   {
@@ -67,7 +67,7 @@ extension AnimationView {
     } else {
       self.init(animation: nil, imageProvider: imageProvider, configuration: configuration)
 
-      Animation.loadedFrom(url: url, closure: { animation in
+      LottieAnimation.loadedFrom(url: url, closure: { animation in
         if let animation = animation {
           self.animation = animation
           closure(nil)
@@ -91,7 +91,7 @@ extension AnimationView {
     animationCache: AnimationCacheProvider? = LRUAnimationCache.sharedCache,
     configuration: LottieConfiguration = .shared)
   {
-    let animation = Animation.asset(name, bundle: bundle, animationCache: animationCache)
+    let animation = LottieAnimation.asset(name, bundle: bundle, animationCache: animationCache)
     let provider = imageProvider ?? BundleImageProvider(bundle: bundle, searchPath: nil)
     self.init(animation: animation, imageProvider: provider, configuration: configuration)
   }

package/Sources/Public/AnimationCache/AnimationCacheProvider.swift

@@ -7,15 +7,15 @@
 
 import Foundation
 /// `AnimationCacheProvider` is a protocol that describes an Animation Cache.
-/// Animation Cache is used when loading `Animation` models. Using an Animation Cache
+/// Animation Cache is used when loading `LottieAnimation` models. Using an Animation Cache
 /// can increase performance when loading an animation multiple times.
 ///
 /// Lottie comes with a prebuilt LRU Animation Cache.
 public protocol AnimationCacheProvider {
 
-  func animation(forKey: String) -> Animation?
+  func animation(forKey: String) -> LottieAnimation?
 
-  func setAnimation(_ animation: Animation, forKey: String)
+  func setAnimation(_ animation: LottieAnimation, forKey: String)
 
   func clearCache()
 

package/Sources/Public/AnimationCache/LRUAnimationCache.swift

@@ -31,7 +31,7 @@ public class LRUAnimationCache: AnimationCacheProvider {
     lruList.removeAll()
   }
 
-  public func animation(forKey: String) -> Animation? {
+  public func animation(forKey: String) -> LottieAnimation? {
     guard let animation = cacheMap[forKey] else {
       return nil
     }
@@ -42,7 +42,7 @@ public class LRUAnimationCache: AnimationCacheProvider {
     return animation
   }
 
-  public func setAnimation(_ animation: Animation, forKey: String) {
+  public func setAnimation(_ animation: LottieAnimation, forKey: String) {
     cacheMap[forKey] = animation
     lruList.append(forKey)
     if lruList.count > cacheSize {
@@ -55,7 +55,7 @@ public class LRUAnimationCache: AnimationCacheProvider {
 
   // MARK: Fileprivate
 
-  fileprivate var cacheMap: [String: Animation] = [:]
+  fileprivate var cacheMap: [String: LottieAnimation] = [:]
   fileprivate var lruList: [String] = []
 
 }

package/Sources/Public/DynamicProperties/AnimationKeypath.swift

@@ -8,11 +8,11 @@
 import Foundation
 
 /// `AnimationKeypath` is an object that describes a keypath search for nodes in the
-/// animation JSON. `AnimationKeypath` matches views and properties inside of `AnimationView`
-/// to their backing `Animation` model by name.
+/// animation JSON. `AnimationKeypath` matches views and properties inside of `LottieAnimationView`
+/// to their backing `LottieAnimation` model by name.
 ///
 /// A keypath can be used to set properties on an existing animation, or can be validated
-/// with an existing `Animation`.
+/// with an existing `LottieAnimation`.
 ///
 /// `AnimationKeypath` can describe a specific object, or can use wildcards for fuzzy matching
 /// of objects. Acceptable wildcards are either "*" (star) or "**" (double star).

package/Sources/Public/DynamicProperties/AnyValueProvider.swift

@@ -11,8 +11,8 @@ import Foundation
 // MARK: - AnyValueProvider
 
 /// `AnyValueProvider` is a protocol that return animation data for a property at a
-/// given time. Every frame an `AnimationView` queries all of its properties and asks
-/// if their ValueProvider has an update. If it does the AnimationView will read the
+/// 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.

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

@@ -16,12 +16,12 @@ public final class ColorValueProvider: ValueProvider {
   /// Initializes with a block provider
   public init(block: @escaping ColorValueBlock) {
     self.block = block
-    color = Color(r: 0, g: 0, b: 0, a: 1)
+    color = LottieColor(r: 0, g: 0, b: 0, a: 1)
     keyframes = nil
   }
 
   /// Initializes with a single color.
-  public init(_ color: Color) {
+  public init(_ color: LottieColor) {
     self.color = color
     block = nil
     keyframes = nil
@@ -29,20 +29,20 @@ public final class ColorValueProvider: ValueProvider {
   }
 
   /// Initializes with multiple colors, with timing information
-  public init(_ keyframes: [Keyframe<Color>]) {
+  public init(_ keyframes: [Keyframe<LottieColor>]) {
     self.keyframes = keyframes
-    color = Color(r: 0, g: 0, b: 0, a: 1)
+    color = LottieColor(r: 0, g: 0, b: 0, a: 1)
     block = nil
     hasUpdate = true
   }
 
   // MARK: Public
 
-  /// Returns a Color for a CGColor(Frame Time)
-  public typealias ColorValueBlock = (CGFloat) -> Color
+  /// Returns a LottieColor for a CGColor(Frame Time)
+  public typealias ColorValueBlock = (CGFloat) -> LottieColor
 
   /// The color value of the provider.
-  public var color: Color {
+  public var color: LottieColor {
     didSet {
       hasUpdate = true
     }
@@ -51,10 +51,10 @@ public final class ColorValueProvider: ValueProvider {
   // MARK: ValueProvider Protocol
 
   public var valueType: Any.Type {
-    Color.self
+    LottieColor.self
   }
 
-  public var storage: ValueProviderStorage<Color> {
+  public var storage: ValueProviderStorage<LottieColor> {
     if let block = block {
       return .closure { frame in
         self.hasUpdate = false
@@ -80,5 +80,5 @@ public final class ColorValueProvider: ValueProvider {
   private var hasUpdate = true
 
   private var block: ColorValueBlock?
-  private var keyframes: [Keyframe<Color>]?
+  private var keyframes: [Keyframe<LottieColor>]?
 }

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

@@ -40,18 +40,18 @@ public final class FloatValueProvider: ValueProvider {
   // MARK: ValueProvider Protocol
 
   public var valueType: Any.Type {
-    Vector1D.self
+    LottieVector1D.self
   }
 
-  public var storage: ValueProviderStorage<Vector1D> {
+  public var storage: ValueProviderStorage<LottieVector1D> {
     if let block = block {
       return .closure { frame in
         self.hasUpdate = false
-        return Vector1D(Double(block(frame)))
+        return LottieVector1D(Double(block(frame)))
       }
     } else {
       hasUpdate = false
-      return .singleValue(Vector1D(Double(float)))
+      return .singleValue(LottieVector1D(Double(float)))
     }
   }
 

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

@@ -26,7 +26,7 @@ public final class GradientValueProvider: ValueProvider {
 
   /// Initializes with an array of colors.
   public init(
-    _ colors: [Color],
+    _ colors: [LottieColor],
     locations: [Double] = [])
   {
     self.colors = colors
@@ -37,13 +37,13 @@ public final class GradientValueProvider: ValueProvider {
 
   // MARK: Public
 
-  /// Returns a [Color] for a CGFloat(Frame Time).
-  public typealias ColorsValueBlock = (CGFloat) -> [Color]
+  /// 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: [Color] {
+  public var colors: [LottieColor] {
     didSet {
       updateValueArray()
       hasUpdate = true
@@ -93,7 +93,7 @@ public final class GradientValueProvider: ValueProvider {
   private var locationsBlock: ColorLocationsBlock?
   private var value: [Double] = []
 
-  private func value(from colors: [Color], locations: [Double]) -> [Double] {
+  private func value(from colors: [LottieColor], locations: [Double]) -> [Double] {
     var colorValues = [Double]()
     var alphaValues = [Double]()
     var shouldAddAlphaValues = false

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

@@ -39,10 +39,10 @@ public final class PointValueProvider: ValueProvider {
   // MARK: ValueProvider Protocol
 
   public var valueType: Any.Type {
-    Vector3D.self
+    LottieVector3D.self
   }
 
-  public var storage: ValueProviderStorage<Vector3D> {
+  public var storage: ValueProviderStorage<LottieVector3D> {
     if let block = block {
       return .closure { frame in
         self.hasUpdate = false

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

@@ -40,10 +40,10 @@ public final class SizeValueProvider: ValueProvider {
   // MARK: ValueProvider Protocol
 
   public var valueType: Any.Type {
-    Vector3D.self
+    LottieVector3D.self
   }
 
-  public var storage: ValueProviderStorage<Vector3D> {
+  public var storage: ValueProviderStorage<LottieVector3D> {
     if let block = block {
       return .closure { frame in
         self.hasUpdate = false

package/Sources/Public/FontProvider/AnimationFontProvider.swift

@@ -12,7 +12,7 @@ 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 `LottieAnimationView`.
 ///
 public protocol AnimationFontProvider {
   func fontFor(family: String, size: CGFloat) -> CTFont?

package/Sources/Public/ImageProvider/AnimationImageProvider.swift

@@ -8,10 +8,10 @@
 import CoreGraphics
 import Foundation
 
-/// Image provider is a protocol that is used to supply images to `AnimationView`.
+/// 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 `AnimationView`.  Lottie includes a couple of
+/// 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,

package/Sources/Public/Keyframes/Interpolatable.swift

@@ -168,11 +168,11 @@ extension CGPoint: SpatialInterpolatable {
   }
 }
 
-// MARK: - Color + Interpolatable
+// MARK: - LottieColor + Interpolatable
 
-extension Color: Interpolatable {
-  public func interpolate(to: Color, amount: CGFloat) -> Color {
-    Color(
+extension LottieColor: Interpolatable {
+  public func interpolate(to: LottieColor, amount: CGFloat) -> LottieColor {
+    LottieColor(
       r: r.interpolate(to: to.r, amount: amount),
       g: g.interpolate(to: to.g, amount: amount),
       b: b.interpolate(to: to.b, amount: amount),
@@ -180,23 +180,23 @@ extension Color: Interpolatable {
   }
 }
 
-// MARK: - Vector1D + Interpolatable
+// MARK: - LottieVector1D + Interpolatable
 
-extension Vector1D: Interpolatable {
-  public func interpolate(to: Vector1D, amount: CGFloat) -> Vector1D {
+extension LottieVector1D: Interpolatable {
+  public func interpolate(to: LottieVector1D, amount: CGFloat) -> LottieVector1D {
     value.interpolate(to: to.value, amount: amount).vectorValue
   }
 }
 
-// MARK: - Vector2D + SpatialInterpolatable
+// MARK: - LottieVector2D + SpatialInterpolatable
 
-extension Vector2D: SpatialInterpolatable {
+extension LottieVector2D: SpatialInterpolatable {
   public func interpolate(
-    to: Vector2D,
+    to: LottieVector2D,
     amount: CGFloat,
     spatialOutTangent: CGPoint?,
     spatialInTangent: CGPoint?)
-    -> Vector2D
+    -> LottieVector2D
   {
     pointValue.interpolate(
       to: to.pointValue,
@@ -207,15 +207,15 @@ extension Vector2D: SpatialInterpolatable {
   }
 }
 
-// MARK: - Vector3D + SpatialInterpolatable
+// MARK: - LottieVector3D + SpatialInterpolatable
 
-extension Vector3D: SpatialInterpolatable {
+extension LottieVector3D: SpatialInterpolatable {
   public func interpolate(
-    to: Vector3D,
+    to: LottieVector3D,
     amount: CGFloat,
     spatialOutTangent: CGPoint?,
     spatialInTangent: CGPoint?)
-    -> Vector3D
+    -> LottieVector3D
   {
     if spatialInTangent != nil || spatialOutTangent != nil {
       // TODO Support third dimension spatial interpolation
@@ -225,13 +225,13 @@ extension Vector3D: SpatialInterpolatable {
         spatialOutTangent: spatialOutTangent,
         spatialInTangent: spatialInTangent)
 
-      return Vector3D(
+      return LottieVector3D(
         x: point.x,
         y: point.y,
         z: CGFloat(z.interpolate(to: to.z, amount: amount)))
     }
 
-    return Vector3D(
+    return LottieVector3D(
       x: x.interpolate(to: to.x, amount: amount),
       y: y.interpolate(to: to.y, amount: amount),
       z: z.interpolate(to: to.z, amount: amount))

package/Sources/Public/Keyframes/Keyframe.swift

@@ -13,8 +13,8 @@ public final class Keyframe<T> {
   /// Initialize a value-only keyframe with no time data.
   public init(
     _ value: T,
-    spatialInTangent: Vector3D? = nil,
-    spatialOutTangent: Vector3D? = nil)
+    spatialInTangent: LottieVector3D? = nil,
+    spatialOutTangent: LottieVector3D? = nil)
   {
     self.value = value
     time = 0
@@ -30,10 +30,10 @@ public final class Keyframe<T> {
     value: T,
     time: AnimationFrameTime,
     isHold: Bool = false,
-    inTangent: Vector2D? = nil,
-    outTangent: Vector2D? = nil,
-    spatialInTangent: Vector3D? = nil,
-    spatialOutTangent: Vector3D? = nil)
+    inTangent: LottieVector2D? = nil,
+    outTangent: LottieVector2D? = nil,
+    spatialInTangent: LottieVector3D? = nil,
+    spatialOutTangent: LottieVector3D? = nil)
   {
     self.value = value
     self.time = time
@@ -53,14 +53,14 @@ public final class Keyframe<T> {
   /// A hold keyframe freezes interpolation until the next keyframe that is not a hold.
   public let isHold: Bool
   /// The in tangent for the time interpolation curve.
-  public let inTangent: Vector2D?
+  public let inTangent: LottieVector2D?
   /// The out tangent for the time interpolation curve.
-  public let outTangent: Vector2D?
+  public let outTangent: LottieVector2D?
 
   /// The spatial in tangent of the vector.
-  public let spatialInTangent: Vector3D?
+  public let spatialInTangent: LottieVector3D?
   /// The spatial out tangent of the vector.
-  public let spatialOutTangent: Vector3D?
+  public let spatialOutTangent: LottieVector3D?
 }
 
 // MARK: Equatable

package/Sources/Public/LottieConfiguration.swift

@@ -15,7 +15,7 @@ public struct LottieConfiguration: Hashable {
   }
 
   /// The global configuration of Lottie,
-  /// which applies to all `AnimationView`s by default.
+  /// which applies to all `LottieAnimationView`s by default.
   public static var shared = LottieConfiguration()
 
   /// The rendering engine implementation to use when displaying an animation