lottie-ios 3.4.4 → 4.0.0

package/Lottie.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -19,6 +19,24 @@
           "version": "0.7.0"
         }
       },
+      {
+        "package": "AirbnbSwift",
+        "repositoryURL": "https://github.com/airbnb/swift",
+        "state": {
+          "branch": null,
+          "revision": "7884f265499752cc5eccaa9eba08b4a2f8b73357",
+          "version": null
+        }
+      },
+      {
+        "package": "swift-argument-parser",
+        "repositoryURL": "https://github.com/apple/swift-argument-parser",
+        "state": {
+          "branch": null,
+          "revision": "fddd1c00396eed152c45a46bea9f47b98e59301d",
+          "version": "1.2.0"
+        }
+      },
       {
         "package": "swift-snapshot-testing",
         "repositoryURL": "https://github.com/pointfreeco/swift-snapshot-testing.git",

package/Lottie.xcworkspace/xcuserdata/calstephens.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist

@@ -5,33 +5,12 @@
    version = "2.0">
    <Breakpoints>
       <BreakpointProxy
-         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         BreakpointExtensionID = "Xcode.Breakpoint.SwiftErrorBreakpoint">
          <BreakpointContent
-            uuid = "8C528A5F-B345-4B34-BD67-A167DC41704A"
-            shouldBeEnabled = "Yes"
-            ignoreCount = "0"
-            continueAfterRunningActions = "No"
-            filePath = "Sources/Private/CoreAnimation/Animations/VisibilityAnimation.swift"
-            startingColumnNumber = "9223372036854775807"
-            endingColumnNumber = "9223372036854775807"
-            startingLineNumber = "44"
-            endingLineNumber = "44">
-         </BreakpointContent>
-      </BreakpointProxy>
-      <BreakpointProxy
-         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
-         <BreakpointContent
-            uuid = "90B95B81-4B28-4BCD-AE7B-59ED8AA81AC1"
+            uuid = "C6EE3985-FE51-481D-807F-F4B9BE9FB067"
             shouldBeEnabled = "No"
             ignoreCount = "0"
-            continueAfterRunningActions = "No"
-            filePath = "Sources/Private/MainThread/NodeRenderSystem/NodeProperties/NodeProperty.swift"
-            startingColumnNumber = "9223372036854775807"
-            endingColumnNumber = "9223372036854775807"
-            startingLineNumber = "49"
-            endingLineNumber = "49"
-            landmarkName = "update(frame:)"
-            landmarkType = "7">
+            continueAfterRunningActions = "No">
          </BreakpointContent>
       </BreakpointProxy>
    </Breakpoints>

package/Package.swift

@@ -1,8 +1,8 @@
-// swift-tools-version:5.3
+// swift-tools-version:5.5
 import PackageDescription
 
 let package = Package(
   name: "Lottie",
   platforms: [.iOS("11.0"), .macOS("10.10"), .tvOS("11.0")],
   products: [.library(name: "Lottie", targets: ["Lottie"])],
-  targets: [.target(name: "Lottie", path: "Sources")])
+  targets: [.target(name: "Lottie", path: "Sources")])

package/README.md

@@ -1,13 +1,13 @@
 # Lottie for iOS
  [![Version](https://img.shields.io/cocoapods/v/lottie-ios.svg?style=flat)](https://cocoapods.org/pods/lottie-ios) [![Carthage Compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage) [![SwiftPM](https://img.shields.io/badge/SPM-supported-DE5C43.svg?style=flat)](https://swift.org/package-manager/) [![License](https://img.shields.io/cocoapods/l/lottie-ios.svg?style=flat)](https://cocoapods.org/pods/lottie-ios) [![Platform](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2Fairbnb%2Flottie-ios%2Fbadge%3Ftype%3Dplatforms)](https://swiftpackageindex.com/airbnb/lottie-ios) [![Swift Versions](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2Fairbnb%2Flottie-ios%2Fbadge%3Ftype%3Dswift-versions)](https://swiftpackageindex.com/airbnb/lottie-ios)
 
-**View documentation, FAQ, help, examples, and more at [airbnb.io/lottie](http://airbnb.io/lottie/)**
+**View documentation, FAQ, help, examples, and more at [airbnb.io/lottie](https://airbnb.io/lottie/)**
 
-Lottie is a cross-platform library for iOS, macOS, tvOS, [Android](https://github.com/airbnb/lottie), and [Web](https://github.com/airbnb/lottie-web) that natively renders vector-based animations and art in realtime with minimal code.
+Lottie is a cross-platform library for iOS, macOS, tvOS, [Android](https://github.com/airbnb/lottie-android), and [Web](https://github.com/airbnb/lottie-web) that natively renders vector-based animations and art in realtime with minimal code.
 
 Lottie loads and renders animations and vectors exported in the bodymovin JSON format. Bodymovin JSON can be created and exported from After Effects with [bodymovin](https://github.com/bodymovin/bodymovin), Sketch with [Lottie Sketch Export](https://github.com/buba447/Lottie-Sketch-Export), and from [Haiku](https://www.haiku.ai).
 
-Designers can create **and ship** beautiful animations without an engineer painstakingly recreating it by hand.
+Designers can create **and ship** beautiful animations without an engineer painstakingly recreating them by hand.
 Since the animation is backed by JSON they are extremely small in size but can be large in complexity!
 Animations can be played, resized, looped, sped up, slowed down, reversed, and even interactively scrubbed.
 Lottie can play or loop just a portion of the animation as well, the possibilities are endless!
@@ -75,6 +75,13 @@ We always appreciate contributions from the community. To make changes to the pr
  - unit tests and snapshot tests (for iOS, must be run on an iPhone 8 simulator)
  - an Example iOS app that lets you browse and test over 100 sample animations included in the repo
 
+To reduce the size of the repository, snapshot images are stored using [Git Large File Storage](https://git-lfs.github.com/). Before running the snapshot tests, you'll need to install Git LFS:
+
+```bash
+$ brew install git-lfs
+$ git lfs install
+```
+
 All pull requests with new features or bug fixes that affect how animations render should include snapshot test cases that validate the included changes. 
   - To add a new sample animation to the snapshot testing suite, you can add the `.json` file to `Tests/Samples`. Re-run the snapshot tests to generate the new snapshot image files.
   - To update existing snapshots after making changes, you can set `isRecording = true` in `SnapshotTests.swift` and then re-run the snapshot tests.

package/Rakefile

@@ -136,7 +136,7 @@ def formatTool(command)
       url: "https://github.com/airbnb/swift",
       // Since we don't have a Package.resolved for this, we need to reference a specific commit
       // so changes to the style guide don't cause this repo's checks to start failing.
-      .revision("cec29280c35dd6eccba415fa3bfc24c819eae887")))
+      .revision("7884f265499752cc5eccaa9eba08b4a2f8b73357")))
   #endif
   EOC
 

package/Sources/Private/CoreAnimation/Animations/CALayer+addAnimation.swift

@@ -44,8 +44,7 @@ extension CALayer {
     keyframes: ContiguousArray<Keyframe<KeyframeValue>>,
     value keyframeValueMapping: (KeyframeValue) throws -> ValueRepresentation,
     context: LayerAnimationContext)
-    throws
-    -> CAAnimation?
+    throws -> CAAnimation?
   {
     guard !keyframes.isEmpty else { return nil }
 
@@ -82,13 +81,12 @@ extension CALayer {
 
   /// A `CAAnimation` that applies the custom value from the `AnyValueProvider`
   /// registered for this specific property's `AnimationKeypath`,
-  /// if one has been registered using `AnimationView.setValueProvider(_:keypath:)`.
+  /// if one has been registered using `LottieAnimationView.setValueProvider(_:keypath:)`.
   @nonobjc
   private func customizedAnimation<ValueRepresentation>(
     for property: LayerProperty<ValueRepresentation>,
     context: LayerAnimationContext)
-    throws
-    -> CAPropertyAnimation?
+    throws -> CAPropertyAnimation?
   {
     guard
       let customizableProperty = property.customizableProperty,
@@ -162,8 +160,7 @@ extension CALayer {
     animationSegments: [[Keyframe<KeyframeValue>]],
     value keyframeValueMapping: (KeyframeValue) throws -> ValueRepresentation,
     context: LayerAnimationContext)
-    throws
-    -> CAAnimationGroup
+    throws -> CAAnimationGroup
   {
     // Build the `CAKeyframeAnimation` for each segment of keyframes
     // with the same `CAAnimationCalculationMode`.
@@ -233,8 +230,8 @@ extension CALayer {
       NSNumber(value: Float(context.progressTime(for: keyframeModel.time)))
     }
 
-    var timingFunctions = self.timingFunctions(for: keyframes)
-    let calculationMode = self.calculationMode(for: keyframes)
+    var timingFunctions = timingFunctions(for: keyframes)
+    let calculationMode = calculationMode(for: keyframes)
 
     let animation = CAKeyframeAnimation(keyPath: property.caLayerKeypath)
 

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

@@ -10,14 +10,24 @@ extension CAShapeLayer {
     for customPath: KeyframeGroup<BezierPath>,
     context: LayerAnimationContext,
     pathMultiplier: PathMultiplier = 1,
-    transformPath: (CGPath) -> CGPath = { $0 })
+    transformPath: (CGPath) -> CGPath = { $0 },
+    roundedCorners: RoundedCorners? = nil)
     throws
   {
+    let combinedKeyframes = try BezierPathKeyframe.combining(
+      path: customPath,
+      cornerRadius: roundedCorners?.radius)
+
     try addAnimation(
       for: .path,
-      keyframes: customPath.keyframes,
+      keyframes: combinedKeyframes.keyframes,
       value: { pathKeyframe in
-        transformPath(pathKeyframe.cgPath().duplicated(times: pathMultiplier))
+        var path = pathKeyframe.path
+        if let cornerRadius = pathKeyframe.cornerRadius {
+          path = path.roundCorners(radius: cornerRadius.cgFloatValue)
+        }
+
+        return transformPath(path.cgPath().duplicated(times: pathMultiplier))
       },
       context: context)
   }
@@ -39,3 +49,32 @@ extension CGPath {
     return cgPath
   }
 }
+
+// MARK: - BezierPathKeyframe
+
+/// Data that represents how to render a bezier path at a specific point in time
+struct BezierPathKeyframe {
+  let path: BezierPath
+  let cornerRadius: LottieVector1D?
+
+  /// Creates a single array of animatable keyframes from the given sets of keyframes
+  /// that can have different counts / timing parameters
+  static func combining(
+    path: KeyframeGroup<BezierPath>,
+    cornerRadius: KeyframeGroup<LottieVector1D>?) throws
+    -> KeyframeGroup<BezierPathKeyframe>
+  {
+    guard
+      let cornerRadius = cornerRadius,
+      cornerRadius.keyframes.contains(where: { $0.value.cgFloatValue > 0 })
+    else {
+      return path.map { path in
+        BezierPathKeyframe(path: path, cornerRadius: nil)
+      }
+    }
+
+    return Keyframes.combined(
+      path, cornerRadius,
+      makeCombinedResult: BezierPathKeyframe.init)
+  }
+}

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

@@ -14,7 +14,7 @@ extension CAShapeLayer {
   {
     try addAnimation(
       for: .path,
-      keyframes: ellipse.combinedKeyframes(context: context).keyframes,
+      keyframes: ellipse.combinedKeyframes().keyframes,
       value: { keyframe in
         BezierPath.ellipse(
           size: keyframe.size.sizeValue,
@@ -30,26 +30,14 @@ extension CAShapeLayer {
 extension Ellipse {
   /// Data that represents how to render an ellipse at a specific point in time
   struct Keyframe {
-    let size: Vector3D
-    let position: Vector3D
+    let size: LottieVector3D
+    let position: LottieVector3D
   }
 
   /// Creates a single array of animatable keyframes from the separate arrays of keyframes in this Ellipse
-  func combinedKeyframes(context: LayerAnimationContext) throws-> KeyframeGroup<Ellipse.Keyframe> {
-    let combinedKeyframes = Keyframes.combinedIfPossible(
+  func combinedKeyframes() throws -> KeyframeGroup<Ellipse.Keyframe> {
+    Keyframes.combined(
       size, position,
       makeCombinedResult: Ellipse.Keyframe.init)
-
-    if let combinedKeyframes = combinedKeyframes {
-      return combinedKeyframes
-    } else {
-      // If we weren't able to combine all of the keyframes, we have to take the timing values
-      // from one property and use a fixed value for the other properties.
-      return try size.map { sizeValue in
-        Keyframe(
-          size: sizeValue,
-          position: try position.exactlyOneKeyframe(context: context, description: "ellipse position"))
-      }
-    }
   }
 }

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

@@ -7,8 +7,8 @@ import QuartzCore
 
 /// A `ShapeItem` that represents a gradient
 protocol GradientShapeItem: OpacityAnimationModel {
-  var startPoint: KeyframeGroup<Vector3D> { get }
-  var endPoint: KeyframeGroup<Vector3D> { get }
+  var startPoint: KeyframeGroup<LottieVector3D> { get }
+  var endPoint: KeyframeGroup<LottieVector3D> { get }
   var gradientType: GradientType { get }
   var numberOfColors: Int { get }
   var colors: KeyframeGroup<[Double]> { get }
@@ -111,23 +111,31 @@ extension GradientRenderLayer {
   private func addRadialGradientAnimations(for gradient: GradientShapeItem, context: LayerAnimationContext) throws {
     type = .radial
 
-    // To draw the correct gradients, we have to derive a custom `endPoint`
-    // relative to the `startPoint` value. Since calculating the `endPoint`
-    // at any given time requires knowing the current `startPoint`,
-    // we can't allow them to animate separately.
-    let absoluteStartPoint = try gradient.startPoint
-      .exactlyOneKeyframe(context: context, description: "gradient startPoint").pointValue
-
-    let absoluteEndPoint = try gradient.endPoint
-      .exactlyOneKeyframe(context: context, description: "gradient endPoint").pointValue
+    let combinedKeyframes = Keyframes.combined(
+      gradient.startPoint, gradient.endPoint,
+      makeCombinedResult: { absoluteStartPoint, absoluteEndPoint -> (startPoint: CGPoint, endPoint: CGPoint) in
+        // Convert the absolute start / end points to the relative structure used by Core Animation
+        let relativeStartPoint = percentBasedPointInBounds(from: absoluteStartPoint.pointValue)
+        let radius = absoluteStartPoint.pointValue.distanceTo(absoluteEndPoint.pointValue)
+        let relativeEndPoint = percentBasedPointInBounds(
+          from: CGPoint(
+            x: absoluteStartPoint.x + radius,
+            y: absoluteStartPoint.y + radius))
+
+        return (startPoint: relativeStartPoint, endPoint: relativeEndPoint)
+      })
 
-    startPoint = percentBasedPointInBounds(from: absoluteStartPoint)
+    try addAnimation(
+      for: .startPoint,
+      keyframes: combinedKeyframes.keyframes,
+      value: \.startPoint,
+      context: context)
 
-    let radius = absoluteStartPoint.distanceTo(absoluteEndPoint)
-    endPoint = percentBasedPointInBounds(
-      from: CGPoint(
-        x: absoluteStartPoint.x + radius,
-        y: absoluteStartPoint.y + radius))
+    try addAnimation(
+      for: .endPoint,
+      keyframes: combinedKeyframes.keyframes,
+      value: \.endPoint,
+      context: context)
   }
 }
 

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

@@ -28,7 +28,7 @@ struct LayerProperty<ValueRepresentation: Equatable> {
 // MARK: - CustomizableProperty
 
 /// A description of how a `CALayer` property can be customized dynamically
-/// at runtime using `AnimationView.setValueProvider(_:keypath:)`
+/// at runtime using `LottieAnimationView.setValueProvider(_:keypath:)`
 struct CustomizableProperty<ValueRepresentation> {
   /// The name that `AnimationKeypath`s can use to refer to this property
   ///  - When building an animation for this property that will be applied
@@ -219,7 +219,7 @@ extension CustomizableProperty {
     .init(
       name: [.color],
       conversion: { typeErasedValue in
-        guard let color = typeErasedValue as? Color else {
+        guard let color = typeErasedValue as? LottieColor else {
           return nil
         }
 

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

@@ -7,7 +7,7 @@ import QuartzCore
 
 protocol OpacityAnimationModel {
   /// The opacity animation to apply to a `CALayer`
-  var opacity: KeyframeGroup<Vector1D> { get }
+  var opacity: KeyframeGroup<LottieVector1D> { get }
 }
 
 // MARK: - Transform + OpacityAnimationModel

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

@@ -9,12 +9,13 @@ extension CAShapeLayer {
   func addAnimations(
     for rectangle: Rectangle,
     context: LayerAnimationContext,
-    pathMultiplier: PathMultiplier)
+    pathMultiplier: PathMultiplier,
+    roundedCorners: RoundedCorners?)
     throws
   {
     try addAnimation(
       for: .path,
-      keyframes: try rectangle.combinedKeyframes(context: context).keyframes,
+      keyframes: try rectangle.combinedKeyframes(roundedCorners: roundedCorners).keyframes,
       value: { keyframe in
         BezierPath.rectangle(
           position: keyframe.position.pointValue,
@@ -31,28 +32,16 @@ extension CAShapeLayer {
 extension Rectangle {
   /// Data that represents how to render a rectangle at a specific point in time
   struct Keyframe {
-    let size: Vector3D
-    let position: Vector3D
-    let cornerRadius: Vector1D
+    let size: LottieVector3D
+    let position: LottieVector3D
+    let cornerRadius: LottieVector1D
   }
 
   /// Creates a single array of animatable keyframes from the separate arrays of keyframes in this Rectangle
-  func combinedKeyframes(context: LayerAnimationContext) throws-> KeyframeGroup<Rectangle.Keyframe> {
-    let combinedKeyframes = Keyframes.combinedIfPossible(
+  func combinedKeyframes(roundedCorners: RoundedCorners?) throws -> KeyframeGroup<Rectangle.Keyframe> {
+    let cornerRadius = roundedCorners?.radius ?? cornerRadius
+    return Keyframes.combined(
       size, position, cornerRadius,
       makeCombinedResult: Rectangle.Keyframe.init)
-
-    if let combinedKeyframes = combinedKeyframes {
-      return combinedKeyframes
-    } else {
-      // If we weren't able to combine all of the keyframes, we have to take the timing values
-      // from one property and use a fixed value for the other properties.
-      return try size.map { sizeValue in
-        Keyframe(
-          size: sizeValue,
-          position: try position.exactlyOneKeyframe(context: context, description: "rectangle position"),
-          cornerRadius: try cornerRadius.exactlyOneKeyframe(context: context, description: "rectangle cornerRadius"))
-      }
-    }
   }
 }

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

@@ -9,23 +9,38 @@ extension CAShapeLayer {
   func addAnimations(
     for shape: ShapeItem,
     context: LayerAnimationContext,
-    pathMultiplier: PathMultiplier) throws
+    pathMultiplier: PathMultiplier,
+    roundedCorners: RoundedCorners?) throws
   {
     switch shape {
     case let customShape as Shape:
-      try addAnimations(for: customShape.path, context: context, pathMultiplier: pathMultiplier)
+      try addAnimations(
+        for: customShape.path,
+        context: context,
+        pathMultiplier: pathMultiplier,
+        roundedCorners: roundedCorners)
 
     case let combinedShape as CombinedShapeItem:
       try addAnimations(for: combinedShape, context: context, pathMultiplier: pathMultiplier)
+      try context.compatibilityAssert(roundedCorners == nil, """
+        Rounded corners support is not currently implemented for combined shape items
+        """)
 
     case let ellipse as Ellipse:
       try addAnimations(for: ellipse, context: context, pathMultiplier: pathMultiplier)
 
     case let rectangle as Rectangle:
-      try addAnimations(for: rectangle, context: context, pathMultiplier: pathMultiplier)
+      try addAnimations(
+        for: rectangle,
+        context: context,
+        pathMultiplier: pathMultiplier,
+        roundedCorners: roundedCorners)
 
     case let star as Star:
       try addAnimations(for: star, context: context, pathMultiplier: pathMultiplier)
+      try context.compatibilityAssert(roundedCorners == nil, """
+        Rounded corners support is currently not implemented for polygon items
+        """)
 
     default:
       // None of the other `ShapeItem` subclasses draw a `path`
@@ -51,7 +66,7 @@ extension CAShapeLayer {
   /// Adds animations for `strokeStart` and `strokeEnd` from the given `Trim` object
   @nonobjc
   func addAnimations(for trim: Trim, context: LayerAnimationContext) throws -> PathMultiplier {
-    let (strokeStartKeyframes, strokeEndKeyframes, pathMultiplier) = try trim.caShapeLayerKeyframes(context: context)
+    let (strokeStartKeyframes, strokeEndKeyframes, pathMultiplier) = try trim.caShapeLayerKeyframes()
 
     try addAnimation(
       for: .strokeStart,
@@ -87,11 +102,12 @@ extension Trim {
   /// The `strokeStart` and `strokeEnd` keyframes to apply to a `CAShapeLayer`,
   /// plus a `pathMultiplier` that should be applied to the layer's `path` so that
   /// trim values larger than 100% can be displayed properly.
-  fileprivate func caShapeLayerKeyframes(context: LayerAnimationContext) throws
-    -> (strokeStart: KeyframeGroup<Vector1D>, strokeEnd: KeyframeGroup<Vector1D>, pathMultiplier: PathMultiplier)
+  fileprivate func caShapeLayerKeyframes()
+    throws
+    -> (strokeStart: KeyframeGroup<LottieVector1D>, strokeEnd: KeyframeGroup<LottieVector1D>, pathMultiplier: PathMultiplier)
   {
-    let strokeStart: KeyframeGroup<Vector1D>
-    let strokeEnd: KeyframeGroup<Vector1D>
+    let strokeStart: KeyframeGroup<LottieVector1D>
+    let strokeEnd: KeyframeGroup<LottieVector1D>
 
     // CAShapeLayer requires strokeStart to be less than strokeEnd. This
     // isn't required by the Lottie schema, so some animations may have
@@ -123,14 +139,12 @@ extension Trim {
     var adjustedStrokeStart = KeyframeGroup(
       keyframes: try adjustKeyframesForTrimOffsets(
         strokeKeyframes: interpolatedStrokeStart,
-        offsetKeyframes: interpolatedStrokeOffset,
-        context: context))
+        offsetKeyframes: interpolatedStrokeOffset))
 
     var adjustedStrokeEnd = KeyframeGroup(
       keyframes: try adjustKeyframesForTrimOffsets(
         strokeKeyframes: interpolatedStrokeEnd,
-        offsetKeyframes: interpolatedStrokeOffset,
-        context: context))
+        offsetKeyframes: interpolatedStrokeOffset))
 
     // If maximum stroke value is larger than 100%, then we have to create copies of the path
     // so the total path length includes the maximum stroke
@@ -142,8 +156,8 @@ extension Trim {
     if minimumStrokeMultiplier < 0 {
       // Core Animation doesn't support negative stroke offsets, so we have to
       // shift all of the offset values up by the minimum
-      adjustedStrokeStart = adjustedStrokeStart.map { Vector1D($0.value + (abs(minimumStrokeMultiplier) * 100.0)) }
-      adjustedStrokeEnd = adjustedStrokeEnd.map { Vector1D($0.value + (abs(minimumStrokeMultiplier) * 100.0)) }
+      adjustedStrokeStart = adjustedStrokeStart.map { LottieVector1D($0.value + (abs(minimumStrokeMultiplier) * 100.0)) }
+      adjustedStrokeEnd = adjustedStrokeEnd.map { LottieVector1D($0.value + (abs(minimumStrokeMultiplier) * 100.0)) }
     }
 
     return (
@@ -164,8 +178,8 @@ extension Trim {
 
     for keyframeTime in keyframeTimes {
       guard
-        let startAtTime = startInterpolator.value(frame: keyframeTime) as? Vector1D,
-        let endAtTime = endInterpolator.value(frame: keyframeTime) as? Vector1D
+        let startAtTime = startInterpolator.value(frame: keyframeTime) as? LottieVector1D,
+        let endAtTime = endInterpolator.value(frame: keyframeTime) as? LottieVector1D
       else { continue }
 
       if startAtTime.cgFloatValue < endAtTime.cgFloatValue {
@@ -184,9 +198,9 @@ extension Trim {
   ///
   /// - Precondition: The keyframes must be interpolated using `KeyframeGroup.manuallyInterpolateKeyframes()`
   private func adjustKeyframesForTrimOffsets(
-    strokeKeyframes: ContiguousArray<Keyframe<Vector1D>>,
-    offsetKeyframes: ContiguousArray<Keyframe<Vector1D>>,
-    context _: LayerAnimationContext) throws -> ContiguousArray<Keyframe<Vector1D>>
+    strokeKeyframes: ContiguousArray<Keyframe<LottieVector1D>>,
+    offsetKeyframes: ContiguousArray<Keyframe<LottieVector1D>>)
+    throws -> ContiguousArray<Keyframe<LottieVector1D>>
   {
     guard
       !strokeKeyframes.isEmpty,
@@ -196,7 +210,7 @@ extension Trim {
     }
 
     // Map each time to its corresponding stroke/offset keyframe
-    var timeMap = [AnimationFrameTime: [Keyframe<Vector1D>?]]()
+    var timeMap = [AnimationFrameTime: [Keyframe<LottieVector1D>?]]()
     for stroke in strokeKeyframes {
       timeMap[stroke.time] = [stroke, nil]
     }
@@ -210,9 +224,9 @@ extension Trim {
     }
 
     // Each time will be mapped to a new, adjusted keyframe
-    var output = ContiguousArray<Keyframe<Vector1D>>()
-    var lastKeyframe: Keyframe<Vector1D>?
-    var lastOffset: Keyframe<Vector1D>?
+    var output = ContiguousArray<Keyframe<LottieVector1D>>()
+    var lastKeyframe: Keyframe<LottieVector1D>?
+    var lastOffset: Keyframe<LottieVector1D>?
 
     for (time, values) in timeMap.sorted(by: { $0.0 < $1.0 }) {
       // Extract keyframe/offset associated with this timestamp
@@ -240,8 +254,8 @@ extension Trim {
       let adjustedValue = strokeValue + (offsetValue / 360 * 100)
 
       // The tangent values are all `nil` as the keyframes should have been manually interpolated
-      let adjustedKeyframe = Keyframe<Vector1D>(
-        value: Vector1D(adjustedValue),
+      let adjustedKeyframe = Keyframe<LottieVector1D>(
+        value: LottieVector1D(adjustedValue),
         time: time,
         isHold: currentKeyframe.isHold,
         inTangent: nil,

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

@@ -36,7 +36,7 @@ extension CAShapeLayer {
   {
     try addAnimation(
       for: .path,
-      keyframes: try star.combinedKeyframes(context: context).keyframes,
+      keyframes: try star.combinedKeyframes().keyframes,
       value: { keyframe in
         BezierPath.star(
           position: keyframe.position.pointValue,
@@ -62,7 +62,7 @@ extension CAShapeLayer {
   {
     try addAnimation(
       for: .path,
-      keyframes: try star.combinedKeyframes(context: context).keyframes,
+      keyframes: try star.combinedKeyframes().keyframes,
       value: { keyframe in
         BezierPath.polygon(
           position: keyframe.position.pointValue,
@@ -81,44 +81,25 @@ extension CAShapeLayer {
 extension Star {
   /// Data that represents how to render a star at a specific point in time
   struct Keyframe {
-    let position: Vector3D
-    let outerRadius: Vector1D
-    let innerRadius: Vector1D
-    let outerRoundness: Vector1D
-    let innerRoundness: Vector1D
-    let points: Vector1D
-    let rotation: Vector1D
+    let position: LottieVector3D
+    let outerRadius: LottieVector1D
+    let innerRadius: LottieVector1D
+    let outerRoundness: LottieVector1D
+    let innerRoundness: LottieVector1D
+    let points: LottieVector1D
+    let rotation: LottieVector1D
   }
 
   /// Creates a single array of animatable keyframes from the separate arrays of keyframes in this star/polygon
-  func combinedKeyframes(context: LayerAnimationContext) throws -> KeyframeGroup<Keyframe> {
-    let combinedKeyframes = Keyframes.combinedIfPossible(
+  func combinedKeyframes() throws -> KeyframeGroup<Keyframe> {
+    Keyframes.combined(
       position,
       outerRadius,
-      innerRadius ?? KeyframeGroup(Vector1D(0)),
+      innerRadius ?? KeyframeGroup(LottieVector1D(0)),
       outerRoundness,
-      innerRoundness ?? KeyframeGroup(Vector1D(0)),
+      innerRoundness ?? KeyframeGroup(LottieVector1D(0)),
       points,
       rotation,
       makeCombinedResult: Star.Keyframe.init)
-
-    if let combinedKeyframes = combinedKeyframes {
-      return combinedKeyframes
-    } else {
-      // If we weren't able to combine all of the keyframes, we have to take the timing values
-      // from one property and use a fixed value for the other properties.
-      return try position.map { positionValue in
-        Keyframe(
-          position: positionValue,
-          outerRadius: try outerRadius.exactlyOneKeyframe(context: context, description: "star outerRadius"),
-          innerRadius: try innerRadius?.exactlyOneKeyframe(context: context, description: "star innerRadius")
-            ?? Vector1D(0),
-          outerRoundness: try outerRoundness.exactlyOneKeyframe(context: context, description: "star outerRoundness"),
-          innerRoundness: try innerRoundness?.exactlyOneKeyframe(context: context, description: "star innerRoundness")
-            ?? Vector1D(0),
-          points: try points.exactlyOneKeyframe(context: context, description: "star points"),
-          rotation: try rotation.exactlyOneKeyframe(context: context, description: "star rotation"))
-      }
-    }
   }
 }