lottie-ios 4.1.2 → 4.2.0

package/Sources/Private/Model/Keyframes/KeyframeGroup.swift

@@ -19,22 +19,35 @@ final class KeyframeGroup<T> {
 
   // MARK: Lifecycle
 
-  init(keyframes: ContiguousArray<Keyframe<T>>) {
+  init(
+    keyframes: ContiguousArray<Keyframe<T>>,
+    unsupportedAfterEffectsExpression: String? = nil)
+  {
     self.keyframes = keyframes
+    self.unsupportedAfterEffectsExpression = unsupportedAfterEffectsExpression
   }
 
-  init(_ value: T) {
+  init(
+    _ value: T,
+    unsupportedAfterEffectsExpression: String? = nil)
+  {
     keyframes = [Keyframe(value)]
+    self.unsupportedAfterEffectsExpression = unsupportedAfterEffectsExpression
   }
 
   // MARK: Internal
 
   enum KeyframeWrapperKey: String, CodingKey {
     case keyframeData = "k"
+    case unsupportedAfterEffectsExpression = "x"
   }
 
   let keyframes: ContiguousArray<Keyframe<T>>
 
+  /// lottie-ios doesn't support After Effects expressions, but we parse them so we can log diagnostics.
+  /// More info: https://helpx.adobe.com/after-effects/using/expression-basics.html
+  let unsupportedAfterEffectsExpression: String?
+
 }
 
 // MARK: Decodable
@@ -42,10 +55,13 @@ final class KeyframeGroup<T> {
 extension KeyframeGroup: Decodable where T: Decodable {
   convenience init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: KeyframeWrapperKey.self)
+    let unsupportedAfterEffectsExpression = try? container.decode(String.self, forKey: .unsupportedAfterEffectsExpression)
 
     if let keyframeData: T = try? container.decode(T.self, forKey: .keyframeData) {
       /// Try to decode raw value; No keyframe data.
-      self.init(keyframes: [Keyframe<T>(keyframeData)])
+      self.init(
+        keyframes: [Keyframe<T>(keyframeData)],
+        unsupportedAfterEffectsExpression: unsupportedAfterEffectsExpression)
     } else {
       // Decode and array of keyframes.
       //
@@ -89,7 +105,9 @@ extension KeyframeGroup: Decodable where T: Decodable {
           spatialOutTangent: keyframeData.spatialOutTangent))
         previousKeyframeData = keyframeData
       }
-      self.init(keyframes: keyframes)
+      self.init(
+        keyframes: keyframes,
+        unsupportedAfterEffectsExpression: unsupportedAfterEffectsExpression)
     }
   }
 }
@@ -129,6 +147,7 @@ extension KeyframeGroup: Encodable where T: Encodable {
 extension KeyframeGroup: DictionaryInitializable where T: AnyInitializable {
   convenience init(dictionary: [String: Any]) throws {
     var keyframes = ContiguousArray<Keyframe<T>>()
+    let unsupportedAfterEffectsExpression = dictionary[KeyframeWrapperKey.unsupportedAfterEffectsExpression.rawValue] as? String
     if
       let rawValue = dictionary[KeyframeWrapperKey.keyframeData.rawValue],
       let value = try? T(value: rawValue)
@@ -162,7 +181,9 @@ extension KeyframeGroup: DictionaryInitializable where T: AnyInitializable {
       }
     }
 
-    self.init(keyframes: keyframes)
+    self.init(
+      keyframes: keyframes,
+      unsupportedAfterEffectsExpression: unsupportedAfterEffectsExpression)
   }
 }
 
@@ -199,9 +220,11 @@ extension Keyframe {
 extension KeyframeGroup {
   /// Maps the values of each individual keyframe in this group
   func map<NewValue>(_ transformation: (T) throws -> NewValue) rethrows -> KeyframeGroup<NewValue> {
-    KeyframeGroup<NewValue>(keyframes: ContiguousArray(try keyframes.map { keyframe in
-      keyframe.withValue(try transformation(keyframe.value))
-    }))
+    KeyframeGroup<NewValue>(
+      keyframes: ContiguousArray(try keyframes.map { keyframe in
+        keyframe.withValue(try transformation(keyframe.value))
+      }),
+      unsupportedAfterEffectsExpression: unsupportedAfterEffectsExpression)
   }
 }
 

package/Sources/Private/Model/Objects/Transform.swift

@@ -55,14 +55,25 @@ final class Transform: Codable, DictionaryInitializable {
       KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
 
     // Rotation
-    if let rotationZ = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationZ) {
-      rotation = rotationZ
+    if let rotation = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationX) {
+      rotationX = rotation
     } else {
-      rotation = try container
-        .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) ?? KeyframeGroup(LottieVector1D(0))
+      rotationX = KeyframeGroup(LottieVector1D(0))
+    }
+
+    if let rotation = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationY) {
+      rotationY = rotation
+    } else {
+      rotationY = KeyframeGroup(LottieVector1D(0))
     }
-    rotationZ = nil
 
+    if let rotation = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationZ) {
+      rotationZ = rotation
+    } else {
+      rotationZ = try container
+        .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) ?? KeyframeGroup(LottieVector1D(0))
+    }
+    rotation = nil
     // Opacity
     opacity = try container
       .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity) ?? KeyframeGroup(LottieVector1D(100))
@@ -114,20 +125,40 @@ final class Transform: Codable, DictionaryInitializable {
     } else {
       scale = KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
     }
+
     if
-      let rotationDictionary = dictionary[CodingKeys.rotationZ.rawValue] as? [String: Any],
+      let rotationDictionary = dictionary[CodingKeys.rotationX.rawValue] as? [String: Any],
       let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     {
-      self.rotation = rotation
-    } else if
-      let rotationDictionary = dictionary[CodingKeys.rotation.rawValue] as? [String: Any],
+      rotationX = rotation
+    } else {
+      rotationX = KeyframeGroup(LottieVector1D(0))
+    }
+
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotationY.rawValue] as? [String: Any],
       let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     {
-      self.rotation = rotation
+      rotationY = rotation
     } else {
-      rotation = KeyframeGroup(LottieVector1D(0))
+      rotationY = KeyframeGroup(LottieVector1D(0))
     }
-    rotationZ = nil
+
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotation.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationZ = rotation
+    } else if
+      let rotationDictionary = dictionary[CodingKeys.rotationZ.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationZ = rotation
+    }
+    else {
+      rotationZ = KeyframeGroup(LottieVector1D(0))
+    }
+    rotation = nil
     if
       let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any],
       let opacity = try? KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
@@ -147,6 +178,8 @@ final class Transform: Codable, DictionaryInitializable {
     case positionY = "py"
     case scale = "s"
     case rotation = "r"
+    case rotationX = "rx"
+    case rotationY = "ry"
     case rotationZ = "rz"
     case opacity = "o"
   }
@@ -169,15 +202,23 @@ final class Transform: Codable, DictionaryInitializable {
   /// The positionY of the transform. This is nil if the position property is set.
   let positionY: KeyframeGroup<LottieVector1D>?
 
-  /// The scale of the transform
+  /// The scale of the transform.
   let scale: KeyframeGroup<LottieVector3D>
 
-  /// The rotation of the transform. Note: This is single dimensional rotation.
-  let rotation: KeyframeGroup<LottieVector1D>
+  /// The rotation of the transform on X axis.
+  let rotationX: KeyframeGroup<LottieVector1D>
+
+  /// The rotation of the transform on Y axis.
+  let rotationY: KeyframeGroup<LottieVector1D>
+
+  /// The rotation of the transform on Z axis.
+  let rotationZ: KeyframeGroup<LottieVector1D>
 
   /// The opacity of the transform.
   let opacity: KeyframeGroup<LottieVector1D>
 
-  /// Should always be nil.
-  let rotationZ: KeyframeGroup<LottieVector1D>?
+  // MARK: Private
+
+  /// Here for the CodingKeys.rotation = "r". `r` and `rz` are the same.
+  private let rotation: KeyframeGroup<LottieVector1D>?
 }

package/Sources/Private/Model/ShapeItems/Repeater.swift

@@ -22,8 +22,19 @@ final class Repeater: ShapeItem {
       .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .startOpacity) ?? KeyframeGroup(LottieVector1D(100))
     endOpacity = try transformContainer
       .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .endOpacity) ?? KeyframeGroup(LottieVector1D(100))
-    rotation = try transformContainer
-      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) ?? KeyframeGroup(LottieVector1D(0))
+    if let rotation = try transformContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) {
+      rotationZ = rotation
+    } else if let rotation = try transformContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationZ) {
+      rotationZ = rotation
+    } else {
+      rotationZ = KeyframeGroup(LottieVector1D(0))
+    }
+
+    rotationX = try transformContainer
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationX) ?? KeyframeGroup(LottieVector1D(0))
+    rotationY = try transformContainer
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationY) ?? KeyframeGroup(LottieVector1D(0))
+
     position = try transformContainer
       .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .position) ??
       KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
@@ -58,10 +69,22 @@ final class Repeater: ShapeItem {
     } else {
       endOpacity = KeyframeGroup(LottieVector1D(100))
     }
+    if let rotationDictionary = transformDictionary[TransformKeys.rotationX.rawValue] as? [String: Any] {
+      rotationX = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else {
+      rotationX = KeyframeGroup(LottieVector1D(0))
+    }
+    if let rotationDictionary = transformDictionary[TransformKeys.rotationY.rawValue] as? [String: Any] {
+      rotationY = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else {
+      rotationY = KeyframeGroup(LottieVector1D(0))
+    }
     if let rotationDictionary = transformDictionary[TransformKeys.rotation.rawValue] as? [String: Any] {
-      rotation = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+      rotationZ = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else if let rotationDictionary = transformDictionary[TransformKeys.rotationZ.rawValue] as? [String: Any] {
+      rotationZ = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     } else {
-      rotation = KeyframeGroup(LottieVector1D(0))
+      rotationZ = KeyframeGroup(LottieVector1D(0))
     }
     if let positionDictionary = transformDictionary[TransformKeys.position.rawValue] as? [String: Any] {
       position = try KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
@@ -95,8 +118,14 @@ final class Repeater: ShapeItem {
   /// End opacity
   let endOpacity: KeyframeGroup<LottieVector1D>
 
-  /// The rotation
-  let rotation: KeyframeGroup<LottieVector1D>
+  /// The rotation on X axis
+  let rotationX: KeyframeGroup<LottieVector1D>
+
+  /// The rotation on Y axis
+  let rotationY: KeyframeGroup<LottieVector1D>
+
+  /// The rotation on Z axis
+  let rotationZ: KeyframeGroup<LottieVector1D>
 
   /// Anchor Point
   let anchorPoint: KeyframeGroup<LottieVector3D>
@@ -115,7 +144,9 @@ final class Repeater: ShapeItem {
     var transformContainer = container.nestedContainer(keyedBy: TransformKeys.self, forKey: .transform)
     try transformContainer.encode(startOpacity, forKey: .startOpacity)
     try transformContainer.encode(endOpacity, forKey: .endOpacity)
-    try transformContainer.encode(rotation, forKey: .rotation)
+    try transformContainer.encode(rotationX, forKey: .rotationX)
+    try transformContainer.encode(rotationY, forKey: .rotationY)
+    try transformContainer.encode(rotationZ, forKey: .rotationZ)
     try transformContainer.encode(position, forKey: .position)
     try transformContainer.encode(anchorPoint, forKey: .anchorPoint)
     try transformContainer.encode(scale, forKey: .scale)
@@ -131,6 +162,9 @@ final class Repeater: ShapeItem {
 
   private enum TransformKeys: String, CodingKey {
     case rotation = "r"
+    case rotationX = "rx"
+    case rotationY = "ry"
+    case rotationZ = "rz"
     case startOpacity = "so"
     case endOpacity = "eo"
     case anchorPoint = "a"

package/Sources/Private/Model/ShapeItems/ShapeTransform.swift

@@ -22,8 +22,25 @@ final class ShapeTransform: ShapeItem {
     scale = try container
       .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale) ??
       KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
-    rotation = try container
-      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) ?? KeyframeGroup(LottieVector1D(0))
+
+    rotationX = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationX) ?? KeyframeGroup(LottieVector1D(0))
+    rotationY = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationY) ?? KeyframeGroup(LottieVector1D(0))
+    if
+      let rotation = try container
+        .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation)
+    {
+      rotationZ = rotation
+    } else if
+      let rotation = try container
+        .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationZ)
+    {
+      rotationZ = rotation
+    } else {
+      rotationZ = KeyframeGroup(LottieVector1D(0))
+    }
+
     opacity = try container
       .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity) ?? KeyframeGroup(LottieVector1D(100))
     skew = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skew) ?? KeyframeGroup(LottieVector1D(0))
@@ -57,14 +74,39 @@ final class ShapeTransform: ShapeItem {
     } else {
       scale = KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
     }
+
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotationX.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationX = rotation
+    } else {
+      rotationX = KeyframeGroup(LottieVector1D(0))
+    }
+
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotationY.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationY = rotation
+    } else {
+      rotationY = KeyframeGroup(LottieVector1D(0))
+    }
+
     if
       let rotationDictionary = dictionary[CodingKeys.rotation.rawValue] as? [String: Any],
       let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     {
-      self.rotation = rotation
+      rotationZ = rotation
+    } else if
+      let rotationDictionary = dictionary[CodingKeys.rotationZ.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    {
+      rotationZ = rotation
     } else {
-      rotation = KeyframeGroup(LottieVector1D(0))
+      rotationZ = KeyframeGroup(LottieVector1D(0))
     }
+
     if
       let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any],
       let opacity = try? KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
@@ -89,6 +131,7 @@ final class ShapeTransform: ShapeItem {
     } else {
       skewAxis = KeyframeGroup(LottieVector1D(0))
     }
+
     try super.init(dictionary: dictionary)
   }
 
@@ -103,8 +146,14 @@ final class ShapeTransform: ShapeItem {
   /// Scale
   let scale: KeyframeGroup<LottieVector3D>
 
-  /// Rotation
-  let rotation: KeyframeGroup<LottieVector1D>
+  /// Rotation on X axis
+  let rotationX: KeyframeGroup<LottieVector1D>
+
+  /// Rotation on Y axis
+  let rotationY: KeyframeGroup<LottieVector1D>
+
+  /// Rotation on Z axis
+  let rotationZ: KeyframeGroup<LottieVector1D>
 
   /// opacity
   let opacity: KeyframeGroup<LottieVector1D>
@@ -130,7 +179,9 @@ final class ShapeTransform: ShapeItem {
     try container.encode(anchor, forKey: .anchor)
     try container.encode(position, forKey: .position)
     try container.encode(scale, forKey: .scale)
-    try container.encode(rotation, forKey: .rotation)
+    try container.encode(rotationX, forKey: .rotationX)
+    try container.encode(rotationY, forKey: .rotationY)
+    try container.encode(rotationZ, forKey: .rotationZ)
     try container.encode(opacity, forKey: .opacity)
     try container.encode(skew, forKey: .skew)
     try container.encode(skewAxis, forKey: .skewAxis)
@@ -143,6 +194,9 @@ final class ShapeTransform: ShapeItem {
     case position = "p"
     case scale = "s"
     case rotation = "r"
+    case rotationX = "rx"
+    case rotationY = "ry"
+    case rotationZ = "rz"
     case opacity = "o"
     case skew = "sk"
     case skewAxis = "sa"

package/Sources/Private/Model/Text/TextAnimator.swift

@@ -24,7 +24,15 @@ final class TextAnimator: Codable, DictionaryInitializable {
     scale = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale)
     skew = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skew)
     skewAxis = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skewAxis)
-    rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation)
+    rotationX = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationX)
+    rotationY = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationY)
+    if let rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) {
+      rotationZ = rotation
+    } else if let rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationZ) {
+      rotationZ = rotation
+    } else {
+      rotationZ = nil
+    }
     opacity = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
   }
 
@@ -76,11 +84,26 @@ final class TextAnimator: Codable, DictionaryInitializable {
     } else {
       skewAxis = nil
     }
+    if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotationX.rawValue] as? [String: Any] {
+      rotationX = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else {
+      rotationX = nil
+    }
+
+    if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotationY.rawValue] as? [String: Any] {
+      rotationY = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else {
+      rotationY = nil
+    }
+
     if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotation.rawValue] as? [String: Any] {
-      rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+      rotationZ = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotationZ.rawValue] as? [String: Any] {
+      rotationZ = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     } else {
-      rotation = nil
+      rotationZ = nil
     }
+
     if let opacityDictionary = animatorDictionary[TextAnimatorKeys.opacity.rawValue] as? [String: Any] {
       opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
     } else {
@@ -107,8 +130,14 @@ final class TextAnimator: Codable, DictionaryInitializable {
   /// Skew Axis
   let skewAxis: KeyframeGroup<LottieVector1D>?
 
-  /// Rotation
-  let rotation: KeyframeGroup<LottieVector1D>?
+  /// Rotation on X axis
+  let rotationX: KeyframeGroup<LottieVector1D>?
+
+  /// Rotation on Y axis
+  let rotationY: KeyframeGroup<LottieVector1D>?
+
+  /// Rotation on Z axis
+  let rotationZ: KeyframeGroup<LottieVector1D>?
 
   /// Opacity
   let opacity: KeyframeGroup<LottieVector1D>?
@@ -159,6 +188,9 @@ final class TextAnimator: Codable, DictionaryInitializable {
     case skew = "sk"
     case skewAxis = "sa"
     case rotation = "r"
+    case rotationX = "rx"
+    case rotationY = "ry"
+    case rotationZ = "rz"
     case opacity = "o"
   }
 }

package/Sources/Private/RootAnimationLayer.swift

@@ -7,6 +7,8 @@ import QuartzCore
 
 /// A root `CALayer` responsible for playing a Lottie animation
 protocol RootAnimationLayer: CALayer {
+  var animationView: LottieAnimationView? { get set }
+
   var currentFrame: AnimationFrameTime { get set }
   var renderScale: CGFloat { get set }
   var respectAnimationFrameRate: Bool { get set }
@@ -32,7 +34,7 @@ protocol RootAnimationLayer: CALayer {
   func reloadImages()
   func forceDisplayUpdate()
   func logHierarchyKeypaths()
-
+  func allHierarchyKeypaths() -> [String]
   func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath)
   func getValue(for keypath: AnimationKeypath, atFrame: AnimationFrameTime?) -> Any?
   func getOriginalValue(for keypath: AnimationKeypath, atFrame: AnimationFrameTime?) -> Any?

package/Sources/Private/Utility/Extensions/AnimationKeypathExtension.swift

@@ -115,20 +115,28 @@ extension KeypathSearchable {
     return nil
   }
 
-  func logKeypaths(for keyPath: AnimationKeypath?, logger: LottieLogger) {
+  /// Computes the list of animation keypaths that descend from this layer
+  func allKeypaths(for keyPath: AnimationKeypath? = nil) -> [String] {
+    var allKeypaths: [String] = []
+
     let newKeypath: AnimationKeypath
     if let previousKeypath = keyPath {
       newKeypath = previousKeypath.appendingKey(keypathName)
     } else {
       newKeypath = AnimationKeypath(keys: [keypathName])
     }
-    logger.info(newKeypath.fullPath)
+
+    allKeypaths.append(newKeypath.fullPath)
+
     for key in keypathProperties.keys {
-      logger.info(newKeypath.appendingKey(key).fullPath)
+      allKeypaths.append(newKeypath.appendingKey(key).fullPath)
     }
+
     for child in childKeypaths {
-      child.logKeypaths(for: newKeypath, logger: logger)
+      allKeypaths.append(contentsOf: child.allKeypaths(for: newKeypath))
     }
+
+    return allKeypaths
   }
 }
 

package/Sources/Private/Utility/Extensions/DataExtension.swift

@@ -14,14 +14,24 @@ import AppKit
 
 extension Data {
 
-  static func jsonData(from assetName: String, in bundle: Bundle) -> Data? {
+  init(assetName: String, in bundle: Bundle) throws {
     #if canImport(UIKit)
-    return NSDataAsset(name: assetName, bundle: bundle)?.data
+    if let asset = NSDataAsset(name: assetName, bundle: bundle) {
+      self = asset.data
+      return
+    } else {
+      throw DotLottieError.assetNotFound(name: assetName, bundle: bundle)
+    }
     #else
     if #available(macOS 10.11, *) {
-      return NSDataAsset(name: assetName, bundle: bundle)?.data
+      if let asset = NSDataAsset(name: assetName, bundle: bundle) {
+        self = asset.data
+        return
+      } else {
+        throw DotLottieError.assetNotFound(name: assetName, bundle: bundle)
+      }
     }
-    return nil
+    throw DotLottieError.loadingFromAssetNotSupported
     #endif
   }
 }

package/Sources/Private/Utility/Primitives/BezierPathRoundExtension.swift

@@ -83,6 +83,8 @@ extension BezierPath {
       uniquePath.addVertex(elements[i].vertex)
     }
 
+    var pathHasRoundedCorner = false
+
     for elementIndex in 0..<uniquePath.elements.count {
       currentVertex = uniquePath.elements[elementIndex].vertex
 
@@ -96,6 +98,9 @@ extension BezierPath {
         continue
       }
 
+      // Track whether or not this path has at least one rounded corner
+      pathHasRoundedCorner = true
+
       // Do not round start and end if not closed
       if !newPath.closed, elementIndex == 0 || elementIndex == uniquePath.elements.count - 1 {
         newPath.addVertex(currentVertex)
@@ -142,6 +147,12 @@ extension BezierPath {
       }
     }
 
+    // If we didn't need to apply the corner radius to any of the corners,
+    // just use the original given path instead of modifying it.
+    if !pathHasRoundedCorner {
+      return self
+    }
+
     return newPath
   }
 }

package/Sources/Private/Utility/Primitives/ColorExtension.swift

@@ -38,22 +38,18 @@ extension LottieColor: Codable {
       b1 = 0
     }
 
-    var a1: Double
-    if !container.isAtEnd {
-      a1 = try container.decode(Double.self)
-    } else {
-      a1 = 1
-    }
-    if r1 > 1, g1 > 1, b1 > 1, a1 > 1 {
+    if r1 > 1, g1 > 1, b1 > 1 {
       r1 = r1 / 255
       g1 = g1 / 255
       b1 = b1 / 255
-      a1 = a1 / 255
     }
     r = r1
     g = g1
     b = b1
-    a = a1
+
+    // The Lottie JSON schema supports alpha values in theory, as the fourth value in this array.
+    // We intentionally do not support this, though, for consistency with Lottie on other platforms.
+    a = 1
   }
 
   // MARK: Public
@@ -79,17 +75,18 @@ extension LottieColor: AnyInitializable {
     var r: Double = array.count > 0 ? array.removeFirst() : 0
     var g: Double = array.count > 0 ? array.removeFirst() : 0
     var b: Double = array.count > 0 ? array.removeFirst() : 0
-    var a: Double = array.count > 0 ? array.removeFirst() : 1
-    if r > 1, g > 1, b > 1, a > 1 {
+    if r > 1, g > 1, b > 1 {
       r /= 255
       g /= 255
       b /= 255
-      a /= 255
     }
     self.r = r
     self.g = g
     self.b = b
-    self.a = a
+
+    // The Lottie JSON schema supports alpha values in theory, as the fourth value in this array.
+    // We intentionally do not support this, though, for consistency with Lottie on other platforms.
+    a = 1
   }
 
 }