lottie-ios 3.4.4 → 4.0.0

package/Sources/Private/CoreAnimation/Animations/StrokeAnimation.swift

@@ -8,8 +8,8 @@ import QuartzCore
 
 /// A `ShapeItem` that represents a stroke
 protocol StrokeShapeItem: OpacityAnimationModel {
-  var strokeColor: KeyframeGroup<Color>? { get }
-  var width: KeyframeGroup<Vector1D> { get }
+  var strokeColor: KeyframeGroup<LottieColor>? { get }
+  var width: KeyframeGroup<LottieVector1D> { get }
   var lineCap: LineCap { get }
   var lineJoin: LineJoin { get }
   var miterLimit: Double { get }
@@ -19,13 +19,13 @@ protocol StrokeShapeItem: OpacityAnimationModel {
 // MARK: - Stroke + StrokeShapeItem
 
 extension Stroke: StrokeShapeItem {
-  var strokeColor: KeyframeGroup<Color>? { color }
+  var strokeColor: KeyframeGroup<LottieColor>? { color }
 }
 
 // MARK: - GradientStroke + StrokeShapeItem
 
 extension GradientStroke: StrokeShapeItem {
-  var strokeColor: KeyframeGroup<Color>? { nil }
+  var strokeColor: KeyframeGroup<LottieColor>? { nil }
 }
 
 // MARK: - CAShapeLayer + StrokeShapeItem

package/Sources/Private/CoreAnimation/Animations/TransformAnimations.swift

@@ -10,39 +10,39 @@ import QuartzCore
 /// both transform types to share the same animation implementation.
 protocol TransformModel {
   /// The anchor point of the transform.
-  var anchorPoint: KeyframeGroup<Vector3D> { get }
+  var anchorPoint: KeyframeGroup<LottieVector3D> { get }
 
   /// The position of the transform. This is nil if the position data was split.
-  var _position: KeyframeGroup<Vector3D>? { get }
+  var _position: KeyframeGroup<LottieVector3D>? { get }
 
   /// The positionX of the transform. This is nil if the position property is set.
-  var _positionX: KeyframeGroup<Vector1D>? { get }
+  var _positionX: KeyframeGroup<LottieVector1D>? { get }
 
   /// The positionY of the transform. This is nil if the position property is set.
-  var _positionY: KeyframeGroup<Vector1D>? { get }
+  var _positionY: KeyframeGroup<LottieVector1D>? { get }
 
   /// The scale of the transform
-  var scale: KeyframeGroup<Vector3D> { get }
+  var scale: KeyframeGroup<LottieVector3D> { get }
 
   /// The rotation of the transform. Note: This is single dimensional rotation.
-  var rotation: KeyframeGroup<Vector1D> { get }
+  var rotation: KeyframeGroup<LottieVector1D> { get }
 }
 
 // MARK: - Transform + TransformModel
 
 extension Transform: TransformModel {
-  var _position: KeyframeGroup<Vector3D>? { position }
-  var _positionX: KeyframeGroup<Vector1D>? { positionX }
-  var _positionY: KeyframeGroup<Vector1D>? { positionY }
+  var _position: KeyframeGroup<LottieVector3D>? { position }
+  var _positionX: KeyframeGroup<LottieVector1D>? { positionX }
+  var _positionY: KeyframeGroup<LottieVector1D>? { positionY }
 }
 
 // MARK: - ShapeTransform + TransformModel
 
 extension ShapeTransform: TransformModel {
-  var anchorPoint: KeyframeGroup<Vector3D> { anchor }
-  var _position: KeyframeGroup<Vector3D>? { position }
-  var _positionX: KeyframeGroup<Vector1D>? { nil }
-  var _positionY: KeyframeGroup<Vector1D>? { nil }
+  var anchorPoint: KeyframeGroup<LottieVector3D> { anchor }
+  var _position: KeyframeGroup<LottieVector3D>? { position }
+  var _positionX: KeyframeGroup<LottieVector1D>? { nil }
+  var _positionY: KeyframeGroup<LottieVector1D>? { nil }
 }
 
 // MARK: - CALayer + TransformModel

package/Sources/Private/CoreAnimation/CoreAnimationLayer.swift

@@ -15,7 +15,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   ///  - This initializer is throwing, but will only throw when using
   ///    `CompatibilityTracker.Mode.abort`.
   init(
-    animation: Animation,
+    animation: LottieAnimation,
     imageProvider: AnimationImageProvider,
     textProvider: AnimationTextProvider,
     fontProvider: AnimationFontProvider,
@@ -31,7 +31,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     compatibilityTracker = CompatibilityTracker(mode: compatibilityTrackerMode, logger: logger)
     valueProviderStore = ValueProviderStore(logger: logger)
     super.init()
-
+    masksToBounds = true
     setup()
     try setupChildLayers()
   }
@@ -156,7 +156,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
       } catch {
         if case CompatibilityTracker.Error.encounteredCompatibilityIssue(let compatibilityIssue) = error {
           // Even though the animation setup failed, we still update the layer's playback state
-          // so it can be read by the parent `AnimationView` when handling this error
+          // so it can be read by the parent `LottieAnimationView` when handling this error
           currentPlaybackState = pendingAnimationConfiguration.playbackState
 
           didSetUpAnimation?([compatibilityIssue])
@@ -187,7 +187,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   /// which is also the realtime animation progress of this layer's animation
   @objc private var animationProgress: CGFloat = 0
 
-  private let animation: Animation
+  private let animation: LottieAnimation
   private let valueProviderStore: ValueProviderStore
   private let compatibilityTracker: CompatibilityTracker
   private let logger: LottieLogger

package/Sources/Private/CoreAnimation/Extensions/KeyframeGroup+exactlyOneKeyframe.swift

@@ -6,17 +6,9 @@
 extension KeyframeGroup {
   /// Retrieves the first `Keyframe` from this group,
   /// and asserts that there are not any extra keyframes that would be ignored
-  ///
-  ///  - There are several places in Lottie animation definitions where multiple
-  ///    sets of keyframe timings can be provided for properties that have to
-  ///    be applied to a single `CALayer` property (for example, the definition for a
-  ///    `Rectangle` technically lets you animate `size`, `position`, and `cornerRadius`
-  ///    separately, but these all have to be combined into a single `CAKeyframeAnimation`
-  ///    on the `CAShapeLayer.path` property.
-  ///
-  ///  - In those sorts of cases, we currently choose one one `KeyframeGroup` to provide the
-  ///    timing information, and disallow simultaneous animations on the other properties.
-  ///
+  ///  - This should only be used in cases where it's fundamentally not possible to
+  ///    support animating a given property (e.g. if Core Animation itself doesn't
+  ///    support the property).
   func exactlyOneKeyframe(
     context: CompatibilityTrackerProviding,
     description: String,
@@ -29,7 +21,7 @@ extension KeyframeGroup {
       keyframes.count == 1,
       """
       The Core Animation rendering engine does not support animating multiple keyframes
-      for \(description) values (due to limitations of Core Animation `CAKeyframeAnimation`s).
+      for \(description) values, due to limitations of Core Animation.
       """)
 
     return keyframes[0].value

package/Sources/Private/CoreAnimation/Extensions/Keyframes+combined.swift

@@ -0,0 +1,222 @@
+// Created by Cal Stephens on 1/28/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+// MARK: - Keyframes
+
+enum Keyframes {
+
+  // MARK: Internal
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of of `Keyframe<[T]>`s
+  ///  - If all of the `KeyframeGroup`s have the exact same animation timing, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  static func combined<T>(_ allGroups: [KeyframeGroup<T>]) -> KeyframeGroup<[T]>
+    where T: AnyInterpolatable
+  {
+    Keyframes.combined(allGroups, makeCombinedResult: { untypedValues in
+      untypedValues.compactMap { $0 as? T }
+    })
+  }
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of of `Keyframe<[T]>`s
+  ///  - If all of the `KeyframeGroup`s have the exact same animation timing, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  static func combined<T1, T2, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    makeCombinedResult: (T1, T2) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>
+    where T1: AnyInterpolatable, T2: AnyInterpolatable
+  {
+    Keyframes.combined(
+      [k1, k2],
+      makeCombinedResult: { untypedValues in
+        guard
+          let t1 = untypedValues[0] as? T1,
+          let t2 = untypedValues[1] as? T2
+        else { return nil }
+
+        return makeCombinedResult(t1, t2)
+      })
+  }
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of of `Keyframe<[T]>`s
+  ///  - If all of the `KeyframeGroup`s have the exact same animation timing, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  static func combined<T1, T2, T3, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    makeCombinedResult: (T1, T2, T3) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>
+    where T1: AnyInterpolatable, T2: AnyInterpolatable, T3: AnyInterpolatable
+  {
+    Keyframes.combined(
+      [k1, k2, k3],
+      makeCombinedResult: { untypedValues in
+        guard
+          let t1 = untypedValues[0] as? T1,
+          let t2 = untypedValues[1] as? T2,
+          let t3 = untypedValues[2] as? T3
+        else { return nil }
+
+        return makeCombinedResult(t1, t2, t3)
+      })
+  }
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of of `Keyframe<[T]>`s
+  ///  - If all of the `KeyframeGroup`s have the exact same animation timing, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  static func combined<T1, T2, T3, T4, T5, T6, T7, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    _ k4: KeyframeGroup<T4>,
+    _ k5: KeyframeGroup<T5>,
+    _ k6: KeyframeGroup<T6>,
+    _ k7: KeyframeGroup<T7>,
+    makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>
+    where T1: AnyInterpolatable, T2: AnyInterpolatable, T3: AnyInterpolatable, T4: AnyInterpolatable,
+    T5: AnyInterpolatable, T6: AnyInterpolatable, T7: AnyInterpolatable
+  {
+    Keyframes.combined(
+      [k1, k2, k3, k4, k5, k6, k7],
+      makeCombinedResult: { untypedValues in
+        guard
+          let t1 = untypedValues[0] as? T1,
+          let t2 = untypedValues[1] as? T2,
+          let t3 = untypedValues[2] as? T3,
+          let t4 = untypedValues[3] as? T4,
+          let t5 = untypedValues[4] as? T5,
+          let t6 = untypedValues[5] as? T6,
+          let t7 = untypedValues[6] as? T7
+        else { return nil }
+
+        return makeCombinedResult(t1, t2, t3, t4, t5, t6, t7)
+      })
+  }
+
+  // MARK: Private
+
+  /// Combines the given `[KeyframeGroup]` of `Keyframe<T>`s into a single `KeyframeGroup` of `Keyframe<CombinedResult>`s
+  ///  - If all of the `KeyframeGroup`s have the exact same animation timing, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  ///
+  /// `makeCombinedResult` is a closure that takes an array of keyframe values (with the exact same length as `AnyKeyframeGroup`),
+  /// casts them to the expected type, and combined them into the final resulting keyframe.
+  private static func combined<CombinedResult>(
+    _ allGroups: [AnyKeyframeGroup],
+    makeCombinedResult: ([Any]) -> CombinedResult?)
+    -> KeyframeGroup<CombinedResult>
+  {
+    let untypedGroups = allGroups.map { $0.untyped }
+
+    // Animations with no timing information (e.g. with just a single keyframe)
+    // can be trivially combined with any other set of keyframes, so we don't need
+    // to check those.
+    let animatingKeyframes = untypedGroups.filter { $0.keyframes.count > 1 }
+
+    guard
+      !allGroups.isEmpty,
+      animatingKeyframes.allSatisfy({ $0.hasSameTimingParameters(as: animatingKeyframes[0]) })
+    else {
+      // If the keyframes don't all share the same timing information,
+      // we have to interpolate the value at each individual frame
+      return Keyframes.manuallyInterpolated(allGroups, makeCombinedResult: makeCombinedResult)
+    }
+
+    var combinedKeyframes = ContiguousArray<Keyframe<CombinedResult>>()
+    let baseKeyframes = (animatingKeyframes.first ?? untypedGroups[0]).keyframes
+
+    for index in baseKeyframes.indices {
+      let baseKeyframe = baseKeyframes[index]
+      let untypedValues = untypedGroups.map { $0.valueForCombinedKeyframes(at: index) }
+
+      if let combinedValue = makeCombinedResult(untypedValues) {
+        combinedKeyframes.append(baseKeyframe.withValue(combinedValue))
+      } else {
+        LottieLogger.shared.assertionFailure("""
+          Failed to cast untyped keyframe values to expected type. This is an internal error.
+          """)
+      }
+    }
+
+    return KeyframeGroup(keyframes: combinedKeyframes)
+  }
+
+  private static func manuallyInterpolated<CombinedResult>(
+    _ allGroups: [AnyKeyframeGroup],
+    makeCombinedResult: ([Any]) -> CombinedResult?)
+    -> KeyframeGroup<CombinedResult>
+  {
+    let untypedGroups = allGroups.map { $0.untyped }
+    let untypedInterpolators = allGroups.map { $0.interpolator }
+
+    let times = untypedGroups.flatMap { $0.keyframes.map { $0.time } }
+
+    let minimumTime = times.min() ?? 0
+    let maximumTime = times.max() ?? 0
+    let animationLocalTimeRange = Int(minimumTime)...Int(maximumTime)
+
+    let interpolatedKeyframes = animationLocalTimeRange.compactMap { localTime -> Keyframe<CombinedResult>? in
+      let interpolatedValues = untypedInterpolators.map { interpolator in
+        interpolator.value(frame: AnimationFrameTime(localTime))
+      }
+
+      guard let combinedResult = makeCombinedResult(interpolatedValues) else {
+        LottieLogger.shared.assertionFailure("""
+          Failed to cast untyped keyframe values to expected type. This is an internal error.
+          """)
+        return nil
+      }
+
+      return Keyframe(
+        value: combinedResult,
+        time: AnimationFrameTime(localTime))
+    }
+
+    return KeyframeGroup(keyframes: ContiguousArray(interpolatedKeyframes))
+  }
+
+}
+
+extension KeyframeGroup {
+  /// Whether or not all of the keyframes in this `KeyframeGroup` have the same
+  /// timing parameters as the corresponding keyframe in the other given `KeyframeGroup`
+  func hasSameTimingParameters<T>(as other: KeyframeGroup<T>) -> Bool {
+    guard keyframes.count == other.keyframes.count else {
+      return false
+    }
+
+    return zip(keyframes, other.keyframes).allSatisfy {
+      $0.hasSameTimingParameters(as: $1)
+    }
+  }
+}
+
+extension Keyframe {
+  /// Whether or not this keyframe has the same timing parameters as the given keyframe,
+  /// excluding `spatialInTangent` and `spatialOutTangent`.
+  fileprivate func hasSameTimingParameters<T>(as other: Keyframe<T>) -> Bool {
+    time == other.time
+      && isHold == other.isHold
+      && inTangent == other.inTangent
+      && outTangent == other.outTangent
+    // We intentionally don't compare spatial in/out tangents,
+    // since those values are only used in very specific cases
+    // (animating the x/y position of a layer), which aren't ever
+    // combined in this way.
+  }
+}
+
+extension KeyframeGroup {
+  /// The value to use for a combined set of keyframes, for the given index
+  fileprivate func valueForCombinedKeyframes(at index: Int) -> T {
+    if keyframes.count == 1 {
+      return keyframes[0].value
+    } else {
+      return keyframes[index].value
+    }
+  }
+}

package/Sources/Private/CoreAnimation/Layers/AnimationLayer.swift

@@ -18,7 +18,7 @@ protocol AnimationLayer: CALayer {
 // Context describing the timing parameters of the current animation
 struct LayerAnimationContext {
   /// The animation being played
-  let animation: Animation
+  let animation: LottieAnimation
 
   /// The timing configuration that should be applied to `CAAnimation`s
   let timingConfiguration: CoreAnimationLayer.CAMediaTimingConfiguration

package/Sources/Private/CoreAnimation/Layers/CALayer+setupLayerHierarchy.swift

@@ -15,7 +15,7 @@ extension CALayer {
     context: LayerContext)
     throws
   {
-    // An `Animation`'s `LayerModel`s are listed from front to back,
+    // A `LottieAnimation`'s `LayerModel`s are listed from front to back,
     // but `CALayer.sublayers` are listed from back to front.
     // We reverse the layer ordering to match what Core Animation expects.
     // The final view hierarchy must display the layers in this exact order.
@@ -51,7 +51,7 @@ extension CALayer {
     }
 
     // Create an `AnimationLayer` for each `LayerModel`
-    for (layerModel, mask) in try layersInZAxisOrder.pairedLayersAndMasks(context: context) {
+    for (layerModel, mask) in try layersInZAxisOrder.pairedLayersAndMasks() {
       guard let layer = try layerModel.makeAnimationLayer(context: context) else {
         continue
       }
@@ -106,8 +106,8 @@ extension CALayer {
   fileprivate func maskLayer(
     for matteLayerModel: LayerModel,
     type: MatteType,
-    context: LayerContext) throws
-    -> CALayer?
+    context: LayerContext)
+    throws -> CALayer?
   {
     switch type {
     case .add:
@@ -123,7 +123,9 @@ extension CALayer {
       // layer being masked, this creates an inverted mask where only areas _outside_
       // of the mask layer are visible.
       // https://developer.apple.com/documentation/coregraphics/cgblendmode/xor
-      let base = BaseAnimationLayer()
+      //  - The inverted mask is supposed to expand infinitely around the shape,
+      //    so we use `InfiniteOpaqueAnimationLayer`
+      let base = InfiniteOpaqueAnimationLayer()
       base.backgroundColor = .rgb(0, 0, 0)
       base.addSublayer(maskLayer)
       maskLayer.compositingFilter = "xor"
@@ -141,7 +143,7 @@ extension Collection where Element == LayerModel {
   /// a `LayerModel` to use as its mask, if applicable
   /// based on the layer's `MatteType` configuration.
   ///  - Assumes the layers are sorted in z-axis order.
-  fileprivate func pairedLayersAndMasks(context _: LayerContext) throws
+  fileprivate func pairedLayersAndMasks() throws
     -> [(layer: LayerModel, mask: (model: LayerModel, matteType: MatteType)?)]
   {
     var layersAndMasks = [(layer: LayerModel, mask: (model: LayerModel, matteType: MatteType)?)]()

package/Sources/Private/CoreAnimation/Layers/GradientRenderLayer.swift

@@ -45,8 +45,8 @@ final class GradientRenderLayer: CAGradientLayer {
     }
 
     let pointInBounds = CGPoint(
-      x: referencePoint.x + gradientPadding,
-      y: referencePoint.y + gradientPadding)
+      x: referencePoint.x + CALayer.veryLargeLayerPadding,
+      y: referencePoint.y + CALayer.veryLargeLayerPadding)
 
     return CGPoint(
       x: CGFloat(pointInBounds.x) / bounds.width,
@@ -55,20 +55,14 @@ final class GradientRenderLayer: CAGradientLayer {
 
   // MARK: Private
 
-  /// Extra padding around the `gradientReferenceBounds` where the gradient is also rendered
-  ///  - This specific value is arbitrary and can be increased if necessary.
-  ///    Theoretically this should be "infinite", to match the behavior of
-  ///    `CGContext.drawLinearGradient` with `[.drawsAfterEndLocation, .drawsBeforeStartLocation]`.
-  private let gradientPadding: CGFloat = 10_000
-
   private func updateLayout() {
     anchorPoint = .zero
 
     bounds = CGRect(
       x: gradientReferenceBounds.origin.x,
       y: gradientReferenceBounds.origin.y,
-      width: gradientPadding + gradientReferenceBounds.width + gradientPadding,
-      height: gradientPadding + gradientReferenceBounds.height + gradientPadding)
+      width: CALayer.veryLargeLayerPadding + gradientReferenceBounds.width + CALayer.veryLargeLayerPadding,
+      height: CALayer.veryLargeLayerPadding + gradientReferenceBounds.height + CALayer.veryLargeLayerPadding)
 
     // Align the center of this layer to be at the center point of its parent layer
     let superlayerSize = superlayer?.frame.size ?? gradientReferenceBounds.size
@@ -92,3 +86,12 @@ extension GradientRenderLayer: CustomLayoutLayer {
     }
   }
 }
+
+extension CALayer {
+  /// Extra padding to add around layers that should be very large or "infinite" in size.
+  /// Examples include `GradientRenderLayer` and `InfiniteOpaqueAnimationLayer`.
+  ///  - This specific value is arbitrary and can be increased if necessary.
+  ///  - Theoretically this should be "infinite", to match the behavior of
+  ///    `CGContext.drawLinearGradient` with `[.drawsAfterEndLocation, .drawsBeforeStartLocation]` etc.
+  static let veryLargeLayerPadding: CGFloat = 10_000
+}

package/Sources/Private/CoreAnimation/Layers/InfiniteOpaqueAnimationLayer.swift

@@ -0,0 +1,56 @@
+// Created by Cal Stephens on 10/10/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - ExpandedAnimationLayer
+
+/// A `BaseAnimationLayer` subclass that renders its background color
+/// as if the layer is infinitely large, without affecting its bounds
+/// or the bounds of its sublayers
+final class InfiniteOpaqueAnimationLayer: BaseAnimationLayer {
+
+  // MARK: Lifecycle
+
+  override init() {
+    super.init()
+    addSublayer(additionalPaddingLayer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  /// Called by CoreAnimation to create a shadow copy of this layer
+  /// More details: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+  override init(layer: Any) {
+    super.init(layer: layer)
+  }
+
+  // MARK: Internal
+
+  override func layoutSublayers() {
+    super.layoutSublayers()
+
+    masksToBounds = false
+    additionalPaddingLayer.backgroundColor = backgroundColor
+
+    // Scale `additionalPaddingLayer` to be larger than this layer
+    // by `additionalPadding` at each size, and centered at the center
+    // of this layer. Since `additionalPadding` is very large, this has
+    // the affect of making `additionalPaddingLayer` appear infinite.
+    let scaleRatioX = (bounds.width + (CALayer.veryLargeLayerPadding * 2)) / bounds.width
+    let scaleRatioY = (bounds.height + (CALayer.veryLargeLayerPadding * 2)) / bounds.height
+
+    additionalPaddingLayer.transform = CATransform3DScale(
+      CATransform3DMakeTranslation(-CALayer.veryLargeLayerPadding, -CALayer.veryLargeLayerPadding, 0),
+      scaleRatioX,
+      scaleRatioY,
+      1)
+  }
+
+  // MARK: Private
+
+  private let additionalPaddingLayer = CALayer()
+
+}

package/Sources/Private/CoreAnimation/Layers/LayerModel+makeAnimationLayer.swift

@@ -7,7 +7,7 @@ import QuartzCore
 
 /// Context available when constructing an `AnimationLayer`
 struct LayerContext {
-  let animation: Animation
+  let animation: LottieAnimation
   let imageProvider: AnimationImageProvider
   let textProvider: AnimationTextProvider
   let fontProvider: AnimationFontProvider

package/Sources/Private/CoreAnimation/Layers/PreCompLayer.swift

@@ -108,10 +108,9 @@ extension PreCompLayer: CustomLayoutLayer {
 extension KeyframeInterpolator where ValueType == AnimationFrameTime {
   /// A `KeyframeInterpolator` for the given `timeRemapping` keyframes
   static func timeRemapping(
-    keyframes timeRemappingKeyframes: KeyframeGroup<Vector1D>,
+    keyframes timeRemappingKeyframes: KeyframeGroup<LottieVector1D>,
     context: LayerContext)
-    throws
-    -> KeyframeInterpolator<AnimationFrameTime>
+    throws -> KeyframeInterpolator<AnimationFrameTime>
   {
     try context.logCompatibilityIssue("""
       The Core Animation rendering engine partially supports time remapping keyframes,

package/Sources/Private/CoreAnimation/Layers/RepeaterLayer.swift

@@ -56,11 +56,11 @@ private struct RepeaterTransform {
     scale = repeater.scale
 
     rotation = repeater.rotation.map { rotation in
-      Vector1D(rotation.value * Double(index))
+      LottieVector1D(rotation.value * Double(index))
     }
 
     position = repeater.position.map { position in
-      Vector3D(
+      LottieVector3D(
         x: position.x * Double(index),
         y: position.y * Double(index),
         z: position.z * Double(index))
@@ -69,17 +69,17 @@ private struct RepeaterTransform {
 
   // MARK: Internal
 
-  let anchorPoint: KeyframeGroup<Vector3D>
-  let position: KeyframeGroup<Vector3D>
-  let rotation: KeyframeGroup<Vector1D>
-  let scale: KeyframeGroup<Vector3D>
+  let anchorPoint: KeyframeGroup<LottieVector3D>
+  let position: KeyframeGroup<LottieVector3D>
+  let rotation: KeyframeGroup<LottieVector1D>
+  let scale: KeyframeGroup<LottieVector3D>
 
 }
 
 // MARK: TransformModel
 
 extension RepeaterTransform: TransformModel {
-  var _position: KeyframeGroup<Vector3D>? { position }
-  var _positionX: KeyframeGroup<Vector1D>? { nil }
-  var _positionY: KeyframeGroup<Vector1D>? { nil }
+  var _position: KeyframeGroup<LottieVector3D>? { position }
+  var _positionX: KeyframeGroup<LottieVector1D>? { nil }
+  var _positionY: KeyframeGroup<LottieVector1D>? { nil }
 }

package/Sources/Private/CoreAnimation/Layers/ShapeItemLayer.swift

@@ -217,7 +217,11 @@ final class ShapeItemLayer: BaseAnimationLayer {
         """)
     }
 
-    try shapeLayer.addAnimations(for: shape.item, context: context.for(shape), pathMultiplier: trimPathMultiplier ?? 1)
+    try shapeLayer.addAnimations(
+      for: shape.item,
+      context: context.for(shape),
+      pathMultiplier: trimPathMultiplier ?? 1,
+      roundedCorners: otherItems.first(RoundedCorners.self))
 
     if let (fill, context) = otherItems.first(Fill.self, context: context) {
       try shapeLayer.addAnimations(for: fill, context: context)
@@ -236,7 +240,8 @@ final class ShapeItemLayer: BaseAnimationLayer {
     try layers.shapeMaskLayer.addAnimations(
       for: shape.item,
       context: context.for(shape),
-      pathMultiplier: 1)
+      pathMultiplier: 1,
+      roundedCorners: otherItems.first(RoundedCorners.self))
 
     if let (gradientFill, context) = otherItems.first(GradientFill.self, context: context) {
       layers.shapeMaskLayer.fillRule = gradientFill.fillRule.caFillRule
@@ -258,7 +263,8 @@ final class ShapeItemLayer: BaseAnimationLayer {
     try layers.shapeMaskLayer.addAnimations(
       for: shape.item,
       context: context.for(shape),
-      pathMultiplier: trimPathMultiplier ?? 1)
+      pathMultiplier: trimPathMultiplier ?? 1,
+      roundedCorners: otherItems.first(RoundedCorners.self))
 
     if let (gradientStroke, context) = otherItems.first(GradientStroke.self, context: context) {
       try layers.gradientColorLayer.addGradientAnimations(for: gradientStroke, type: .rgb, context: context)