lottie-ios 4.1.2 → 4.2.0

package/Sources/Private/CoreAnimation/CoreAnimationLayer.swift

@@ -19,6 +19,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     imageProvider: AnimationImageProvider,
     textProvider: AnimationTextProvider,
     fontProvider: AnimationFontProvider,
+    maskAnimationToBounds: Bool,
     compatibilityTrackerMode: CompatibilityTracker.Mode,
     logger: LottieLogger)
     throws
@@ -31,7 +32,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     compatibilityTracker = CompatibilityTracker(mode: compatibilityTrackerMode, logger: logger)
     valueProviderStore = ValueProviderStore(logger: logger)
     super.init()
-    masksToBounds = true
+    masksToBounds = maskAnimationToBounds
     setup()
     try setupChildLayers()
   }
@@ -71,7 +72,10 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   }
 
   enum PlaybackState: Equatable {
-    /// The animation is playing in real-time
+    /// The animation is has started playing, and may still be playing.
+    ///  - When animating with a finite duration (e.g. `playOnce`), playback
+    ///    state will still be `playing` when the animation completes.
+    ///    To check if the animation is currently playing, prefer `isAnimationPlaying`.
     case playing
     /// The animation is statically displaying a specific frame
     case paused(frame: AnimationFrameTime)
@@ -81,9 +85,18 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   struct AnimationConfiguration: Equatable {
     var animationContext: AnimationContext
     var timingConfiguration: CAMediaTimingConfiguration
-    var logHierarchyKeypaths = false
+    var recordHierarchyKeypath: ((String) -> Void)?
+
+    static func ==(_ lhs: AnimationConfiguration, _ rhs: AnimationConfiguration) -> Bool {
+      lhs.animationContext == rhs.animationContext
+        && lhs.timingConfiguration == rhs.timingConfiguration
+        && ((lhs.recordHierarchyKeypath == nil) == (rhs.recordHierarchyKeypath == nil))
+    }
   }
 
+  /// The parent `LottieAnimationView` that manages this layer
+  weak var animationView: LottieAnimationView?
+
   /// A closure that is called after this layer sets up its animation.
   /// If the animation setup was unsuccessful and encountered compatibility issues,
   /// those issues are included in this call.
@@ -148,7 +161,9 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     //    allocate a very large amount of memory (400mb+).
     //  - Alternatively this layer could subclass `CATransformLayer`,
     //    but this causes Core Animation to emit unnecessary logs.
-    if let pendingAnimationConfiguration = pendingAnimationConfiguration {
+    if var pendingAnimationConfiguration = pendingAnimationConfiguration {
+      pendingAnimationConfigurationModification?(&pendingAnimationConfiguration.animationConfiguration)
+      pendingAnimationConfigurationModification = nil
       self.pendingAnimationConfiguration = nil
 
       do {
@@ -180,6 +195,9 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     animationConfiguration: AnimationConfiguration,
     playbackState: PlaybackState)?
 
+  /// A modification that should be applied to the next animation configuration
+  private var pendingAnimationConfigurationModification: ((inout AnimationConfiguration) -> Void)?
+
   /// Configuration for the animation that is currently setup in this layer
   private var currentAnimationConfiguration: AnimationConfiguration?
 
@@ -249,7 +267,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
       logger: logger,
       currentKeypath: AnimationKeypath(keys: []),
       textProvider: textProvider,
-      logHierarchyKeypaths: configuration.logHierarchyKeypaths)
+      recordHierarchyKeypath: configuration.recordHierarchyKeypath)
 
     // Perform a layout pass if necessary so all of the sublayers
     // have the most up-to-date sizing information
@@ -289,32 +307,20 @@ final class CoreAnimationLayer: BaseAnimationLayer {
 
   // Removes the current `CAAnimation`s, and rebuilds new animations
   // using the same configuration as the previous animations.
-  private func rebuildCurrentAnimation(with newConfiguration: AnimationConfiguration? = nil) {
+  private func rebuildCurrentAnimation() {
     guard
-      let currentConfiguration = currentAnimationConfiguration,
-      let playbackState = playbackState,
       // Don't replace any pending animations that are queued to begin
       // on the next run loop cycle, since an existing pending animation
       // will cause the animation to be rebuilt anyway.
       pendingAnimationConfiguration == nil
-    else {
-      // If we already have a pending animation setup pass, but a new configuration was provided,
-      // replace the pending configuration with the new configuration
-      if let newConfiguration = newConfiguration {
-        pendingAnimationConfiguration?.animationConfiguration = newConfiguration
-      }
-
-      return
-    }
-
-    removeAnimations()
-
-    switch playbackState {
-    case .paused(let frame):
-      currentFrame = frame
-
-    case .playing:
-      playAnimation(configuration: newConfiguration ?? currentConfiguration)
+    else { return }
+
+    if isAnimationPlaying == true {
+      animationView?.updateInFlightAnimation()
+    } else {
+      let currentFrame = currentFrame
+      removeAnimations()
+      self.currentFrame = currentFrame
     }
   }
 
@@ -328,6 +334,9 @@ extension CoreAnimationLayer: RootAnimationLayer {
     .specific(#keyPath(animationProgress))
   }
 
+  /// Whether or not the animation is currently playing.
+  ///  - Handles case where CAAnimations with a finite duration animation (e.g. `playOnce`)
+  ///    have finished playing but still present on this layer.
   var isAnimationPlaying: Bool? {
     switch pendingAnimationConfiguration?.playbackState {
     case .playing:
@@ -344,6 +353,8 @@ extension CoreAnimationLayer: RootAnimationLayer {
     }
   }
 
+  /// The current frame of the animation being displayed,
+  /// accounting for the realtime progress of any active CAAnimations.
   var currentFrame: AnimationFrameTime {
     get {
       switch playbackState {
@@ -442,18 +453,30 @@ extension CoreAnimationLayer: RootAnimationLayer {
   }
 
   func logHierarchyKeypaths() {
-    guard var configuration = pendingAnimationConfiguration?.animationConfiguration ?? currentAnimationConfiguration else {
+    for keypath in allHierarchyKeypaths() {
+      logger.info(keypath)
+    }
+  }
+
+  func allHierarchyKeypaths() -> [String] {
+    guard pendingAnimationConfiguration?.animationConfiguration ?? currentAnimationConfiguration != nil else {
       logger.info("Cannot log hierarchy keypaths until animation has been set up at least once")
-      return
+      return []
     }
 
     logger.info("Lottie: Rebuilding animation with hierarchy keypath logging enabled")
 
-    // Rebuild the animation with `logHierarchyKeypaths = true` so the `ValueProviderStore` will log any keypath lookups that occur.
-    // This allows the consumer to know what keypaths can be customized in their animation.
-    configuration.logHierarchyKeypaths = true
-    rebuildCurrentAnimation(with: configuration)
+    var allAnimationKeypaths = [String]()
+    pendingAnimationConfigurationModification = { configuration in
+      configuration.recordHierarchyKeypath = { keypath in
+        allAnimationKeypaths.append(keypath)
+      }
+    }
+
+    rebuildCurrentAnimation()
     displayIfNeeded()
+
+    return allAnimationKeypaths
   }
 
   func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath) {

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

@@ -68,20 +68,21 @@ enum Keyframes {
   /// 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, CombinedResult>(
+  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>,
-    makeCombinedResult: (T1, T2, T3, T4, T5, T6) -> CombinedResult)
+    _ 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
+    T5: AnyInterpolatable, T6: AnyInterpolatable, T7: AnyInterpolatable
   {
     Keyframes.combined(
-      [k1, k2, k3, k4, k5, k6],
+      [k1, k2, k3, k4, k5, k6, k7],
       makeCombinedResult: { untypedValues in
         guard
           let t1 = untypedValues[0] as? T1,
@@ -89,17 +90,18 @@ enum Keyframes {
           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 t6 = untypedValues[5] as? T6,
+          let t7 = untypedValues[6] as? T7
         else { return nil }
 
-        return makeCombinedResult(t1, t2, t3, t4, t5, t6)
+        return makeCombinedResult(t1, t2, t3, t4, t5, t6, t7)
       })
   }
 
   /// 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>(
+  static func combined<T1, T2, T3, T4, T5, T6, T7, T8, CombinedResult>(
     _ k1: KeyframeGroup<T1>,
     _ k2: KeyframeGroup<T2>,
     _ k3: KeyframeGroup<T3>,
@@ -107,13 +109,14 @@ enum Keyframes {
     _ k5: KeyframeGroup<T5>,
     _ k6: KeyframeGroup<T6>,
     _ k7: KeyframeGroup<T7>,
-    makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7) -> CombinedResult)
+    _ k8: KeyframeGroup<T8>,
+    makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7, T8) -> CombinedResult)
     -> KeyframeGroup<CombinedResult>
     where T1: AnyInterpolatable, T2: AnyInterpolatable, T3: AnyInterpolatable, T4: AnyInterpolatable,
-    T5: AnyInterpolatable, T6: AnyInterpolatable, T7: AnyInterpolatable
+    T5: AnyInterpolatable, T6: AnyInterpolatable, T7: AnyInterpolatable, T8: AnyInterpolatable
   {
     Keyframes.combined(
-      [k1, k2, k3, k4, k5, k6, k7],
+      [k1, k2, k3, k4, k5, k6, k7, k8],
       makeCombinedResult: { untypedValues in
         guard
           let t1 = untypedValues[0] as? T1,
@@ -122,10 +125,11 @@ enum Keyframes {
           let t4 = untypedValues[3] as? T4,
           let t5 = untypedValues[4] as? T5,
           let t6 = untypedValues[5] as? T6,
-          let t7 = untypedValues[6] as? T7
+          let t7 = untypedValues[6] as? T7,
+          let t8 = untypedValues[7] as? T8
         else { return nil }
 
-        return makeCombinedResult(t1, t2, t3, t4, t5, t6, t7)
+        return makeCombinedResult(t1, t2, t3, t4, t5, t6, t7, t8)
       })
   }
 

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

@@ -44,9 +44,9 @@ struct LayerAnimationContext {
   /// The `AnimationTextProvider`
   var textProvider: AnimationTextProvider
 
-  /// Whether or not to log `AnimationKeypath`s for all of the animation's layers
-  ///  - Used for `CoreAnimationLayer.logHierarchyKeypaths()`
-  var logHierarchyKeypaths: Bool
+  /// Records the given animation keypath so it can be logged or collected into a list
+  ///  - Used for `CoreAnimationLayer.logHierarchyKeypaths()` and `allHierarchyKeypaths()`
+  var recordHierarchyKeypath: ((String) -> Void)?
 
   /// A closure that remaps the given frame in the child layer's local time to a frame
   /// in the animation's overall global time

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

@@ -17,6 +17,7 @@ class BaseCompositionLayer: BaseAnimationLayer {
     setupSublayers()
     compositingFilter = layerModel.blendMode.filterName
     name = layerModel.name
+    contentsLayer.name = "\(layerModel.name) (Content)"
   }
 
   required init?(coder _: NSCoder) {
@@ -36,6 +37,10 @@ class BaseCompositionLayer: BaseAnimationLayer {
 
   // MARK: Internal
 
+  /// The layer that content / sublayers should be rendered in.
+  /// This is the layer that transform animations are applied to.
+  let contentsLayer = BaseAnimationLayer()
+
   /// Whether or not this layer render should render any visible content
   var renderLayerContents: Bool { true }
 
@@ -43,24 +48,22 @@ class BaseCompositionLayer: BaseAnimationLayer {
   /// and all child `AnimationLayer`s.
   ///  - Can be overridden by subclasses, which much call `super`.
   override func setupAnimations(context: LayerAnimationContext) throws {
-    var context = context
-    if renderLayerContents {
-      context = context.addingKeypathComponent(baseLayerModel.name)
-    }
+    let layerContext = context.addingKeypathComponent(baseLayerModel.name)
+    let childContext = renderLayerContents ? layerContext : context
 
-    try setupLayerAnimations(context: context)
-    try setupChildAnimations(context: context)
+    try setupLayerAnimations(context: layerContext)
+    try setupChildAnimations(context: childContext)
   }
 
   func setupLayerAnimations(context: LayerAnimationContext) throws {
-    let context = context.addingKeypathComponent(baseLayerModel.name)
+    let transformContext = context.addingKeypathComponent("Transform")
 
-    try addTransformAnimations(for: baseLayerModel.transform, context: context)
+    try contentsLayer.addTransformAnimations(for: baseLayerModel.transform, context: transformContext)
 
     if renderLayerContents {
-      try addOpacityAnimation(for: baseLayerModel.transform, context: context)
+      try contentsLayer.addOpacityAnimation(for: baseLayerModel.transform, context: transformContext)
 
-      addVisibilityAnimation(
+      contentsLayer.addVisibilityAnimation(
         inFrame: CGFloat(baseLayerModel.inFrame),
         outFrame: CGFloat(baseLayerModel.outFrame),
         context: context)
@@ -71,17 +74,27 @@ class BaseCompositionLayer: BaseAnimationLayer {
     try super.setupAnimations(context: context)
   }
 
+  override func addSublayer(_ layer: CALayer) {
+    if layer === contentsLayer {
+      super.addSublayer(contentsLayer)
+    } else {
+      contentsLayer.addSublayer(layer)
+    }
+  }
+
   // MARK: Private
 
   private let baseLayerModel: LayerModel
 
   private func setupSublayers() {
+    addSublayer(contentsLayer)
+
     if
       renderLayerContents,
       let masks = baseLayerModel.masks?.filter({ $0.mode != .none }),
       !masks.isEmpty
     {
-      mask = MaskCompositionLayer(masks: masks)
+      contentsLayer.mask = MaskCompositionLayer(masks: masks)
     }
   }
 

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

@@ -42,12 +42,12 @@ final class ImageLayer: BaseCompositionLayer {
       let image = context.imageProvider.imageForAsset(asset: imageAsset)
     else {
       self.imageAsset = nil
-      contents = nil
+      contentsLayer.contents = nil
       return
     }
 
     self.imageAsset = imageAsset
-    contents = image
+    contentsLayer.contents = image
     setNeedsLayout()
   }
 

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

@@ -101,7 +101,7 @@ extension PreCompLayer: CustomLayoutLayer {
       width: CGFloat(preCompLayer.width),
       height: CGFloat(preCompLayer.height))
 
-    masksToBounds = true
+    contentsLayer.masksToBounds = true
   }
 }
 

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

@@ -55,7 +55,15 @@ private struct RepeaterTransform {
     anchorPoint = repeater.anchorPoint
     scale = repeater.scale
 
-    rotation = repeater.rotation.map { rotation in
+    rotationX = repeater.rotationX.map { rotation in
+      LottieVector1D(rotation.value * Double(index))
+    }
+
+    rotationY = repeater.rotationY.map { rotation in
+      LottieVector1D(rotation.value * Double(index))
+    }
+
+    rotationZ = repeater.rotationZ.map { rotation in
       LottieVector1D(rotation.value * Double(index))
     }
 
@@ -71,7 +79,10 @@ private struct RepeaterTransform {
 
   let anchorPoint: KeyframeGroup<LottieVector3D>
   let position: KeyframeGroup<LottieVector3D>
-  let rotation: KeyframeGroup<LottieVector1D>
+  let rotationX: KeyframeGroup<LottieVector1D>
+  let rotationY: KeyframeGroup<LottieVector1D>
+  let rotationZ: KeyframeGroup<LottieVector1D>
+
   let scale: KeyframeGroup<LottieVector3D>
 
 }

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

@@ -373,9 +373,17 @@ extension Array where Element == ShapeItemLayer.Item {
 
     for item in self {
       // `renderGroups` is non-empty, so is guaranteed to have a valid end index
-      let lastIndex = renderGroups.indices.last!
+      var lastIndex: Int {
+        renderGroups.indices.last!
+      }
 
       if item.item.drawsCGPath {
+        // Trims should only affect paths that precede them in the group,
+        // so if the existing group already has a trim we create a new group for this path item.
+        if renderGroups[lastIndex].otherItems.contains(where: { $0.item is Trim }) {
+          renderGroups.append(ShapeRenderGroup())
+        }
+
         renderGroups[lastIndex].pathItems.append(item)
       }
 

package/Sources/Private/CoreAnimation/ValueProviderStore.swift

@@ -26,10 +26,15 @@ final class ValueProviderStore {
       because that would require calling the closure on the main thread once per frame.
       """)
 
-    // TODO: Support more value types
+    let supportedProperties = PropertyName.allCases.map { $0.rawValue }
+    let propertyBeingCustomized = keypath.keys.last ?? ""
+
     logger.assert(
-      keypath.keys.last == PropertyName.color.rawValue,
-      "The Core Animation rendering engine currently only supports customizing color values")
+      supportedProperties.contains(propertyBeingCustomized),
+      """
+      The Core Animation rendering engine currently doesn't support customizing "\(propertyBeingCustomized)" \
+      properties. Supported properties are: \(supportedProperties.joined(separator: ", ")).
+      """)
 
     valueProviders.append((keypath: keypath, valueProvider: valueProvider))
   }
@@ -42,9 +47,7 @@ final class ValueProviderStore {
     context: LayerAnimationContext)
     throws -> KeyframeGroup<Value>?
   {
-    if context.logHierarchyKeypaths {
-      context.logger.info(keypath.fullPath)
-    }
+    context.recordHierarchyKeypath?(keypath.fullPath)
 
     guard let anyValueProvider = valueProvider(for: keypath) else {
       return nil
@@ -125,13 +128,21 @@ extension AnimationKeypath {
       + keypath.keys.joined(separator: "\\.") // match this keypath, escaping "." characters
       + "$" // match the end of the string
 
-    // ** wildcards match anything
-    //  - "**.Color" matches both "Layer 1.Color" and "Layer 1.Layer 2.Color"
-    regex = regex.replacingOccurrences(of: "**", with: ".+")
+    // Replace the ** and * wildcards with markers that are guaranteed to be unique
+    // and won't conflict with regex syntax (e.g. `.*`).
+    let doubleWildcardMarker = UUID().uuidString
+    let singleWildcardMarker = UUID().uuidString
+    regex = regex.replacingOccurrences(of: "**", with: doubleWildcardMarker)
+    regex = regex.replacingOccurrences(of: "*", with: singleWildcardMarker)
+
+    // "**" wildcards match zero or more path segments separated by "\\."
+    //  - "**.Color" matches any of "Color", "Layer 1.Color", and "Layer 1.Layer 2.Color"
+    regex = regex.replacingOccurrences(of: "\(doubleWildcardMarker)\\.", with: ".*")
+    regex = regex.replacingOccurrences(of: doubleWildcardMarker, with: ".*")
 
-    // * wildcards match any individual path component
+    // "*" wildcards match exactly one path component
     //  - "*.Color" matches "Layer 1.Color" but not "Layer 1.Layer 2.Color"
-    regex = regex.replacingOccurrences(of: "*", with: "[^.]+")
+    regex = regex.replacingOccurrences(of: singleWildcardMarker, with: "[^.]+")
 
     return fullPath.range(of: regex, options: .regularExpression) != nil
   }

package/Sources/Private/MainThread/LayerContainers/CompLayers/MaskContainerLayer.swift

@@ -167,7 +167,7 @@ private class MaskNodeProperties: NodePropertyMap {
     shape = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.shape.keyframes))
     expansion = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.expansion.keyframes))
     propertyMap = [
-      "Opacity" : opacity,
+      PropertyName.opacity.rawValue : opacity,
       "Shape" : shape,
       "Expansion" : expansion,
     ]

package/Sources/Private/MainThread/LayerContainers/MainThreadAnimationLayer.swift

@@ -23,6 +23,7 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
     imageProvider: AnimationImageProvider,
     textProvider: AnimationTextProvider,
     fontProvider: AnimationFontProvider,
+    maskAnimationToBounds: Bool,
     logger: LottieLogger)
   {
     layerImageProvider = LayerImageProvider(imageProvider: imageProvider, assets: animation.assetLibrary?.imageAssets)
@@ -31,7 +32,7 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
     animationLayers = []
     self.logger = logger
     super.init()
-    masksToBounds = true
+    masksToBounds = maskAnimationToBounds
     bounds = animation.bounds
     let layers = animation.layers.initializeCompositionLayers(
       assetLibrary: animation.assetLibrary,
@@ -146,6 +147,9 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
   /// The animatable Current Frame Property
   @NSManaged var currentFrame: CGFloat
 
+  /// The parent `LottieAnimationView` that manages this layer
+  weak var animationView: LottieAnimationView?
+
   var animationLayers: ContiguousArray<CompositionLayer>
 
   var primaryAnimationKey: AnimationKey {
@@ -200,7 +204,14 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
 
   func logHierarchyKeypaths() {
     logger.info("Lottie: Logging Animation Keypaths")
-    animationLayers.forEach { $0.logKeypaths(for: nil, logger: self.logger) }
+
+    for keypath in allHierarchyKeypaths() {
+      logger.info(keypath)
+    }
+  }
+
+  func allHierarchyKeypaths() -> [String] {
+    animationLayers.flatMap { $0.allKeypaths() }
   }
 
   func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath) {

package/Sources/Private/MainThread/LayerContainers/Utility/LayerTransformNode.swift

@@ -18,14 +18,19 @@ final class LayerTransformProperties: NodePropertyMap, KeypathSearchable {
   init(transform: Transform) {
     anchor = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.anchorPoint.keyframes))
     scale = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.scale.keyframes))
-    rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotation.keyframes))
+    rotationX = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotationX.keyframes))
+    rotationY = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotationY.keyframes))
+    rotationZ = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotationZ.keyframes))
     opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.opacity.keyframes))
 
     var propertyMap: [String: AnyNodeProperty] = [
       "Anchor Point" : anchor,
-      "Scale" : scale,
-      "Rotation" : rotation,
-      "Opacity" : opacity,
+      PropertyName.scale.rawValue : scale,
+      PropertyName.rotation.rawValue: rotationZ,
+      "Rotation X" : rotationX,
+      "Rotation Y" : rotationY,
+      "Rotation Z" : rotationZ,
+      PropertyName.opacity.rawValue : opacity,
     ]
 
     if
@@ -41,7 +46,7 @@ final class LayerTransformProperties: NodePropertyMap, KeypathSearchable {
       position = nil
     } else if let positionKeyframes = transform.position?.keyframes {
       let position: NodeProperty<LottieVector3D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframes))
-      propertyMap["Position"] = position
+      propertyMap[PropertyName.position.rawValue] = position
       self.position = position
       positionX = nil
       positionY = nil
@@ -64,7 +69,9 @@ final class LayerTransformProperties: NodePropertyMap, KeypathSearchable {
 
   let anchor: NodeProperty<LottieVector3D>
   let scale: NodeProperty<LottieVector3D>
-  let rotation: NodeProperty<LottieVector1D>
+  let rotationX: NodeProperty<LottieVector1D>
+  let rotationY: NodeProperty<LottieVector1D>
+  let rotationZ: NodeProperty<LottieVector1D>
   let position: NodeProperty<LottieVector3D>?
   let positionX: NodeProperty<LottieVector1D>?
   let positionY: NodeProperty<LottieVector1D>?
@@ -130,7 +137,9 @@ class LayerTransformNode: AnimatorNode {
       anchor: transformProperties.anchor.value.pointValue,
       position: position,
       scale: transformProperties.scale.value.sizeValue,
-      rotation: transformProperties.rotation.value.cgFloatValue,
+      rotationX: transformProperties.rotationX.value.cgFloatValue,
+      rotationY: transformProperties.rotationY.value.cgFloatValue,
+      rotationZ: transformProperties.rotationZ.value.cgFloatValue,
       skew: nil,
       skewAxis: nil)
 

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/EllipseNode.swift

@@ -20,7 +20,7 @@ final class EllipseNodeProperties: NodePropertyMap, KeypathSearchable {
     position = NodeProperty(provider: KeyframeInterpolator(keyframes: ellipse.position.keyframes))
     size = NodeProperty(provider: KeyframeInterpolator(keyframes: ellipse.size.keyframes))
     keypathProperties = [
-      "Position" : position,
+      PropertyName.position.rawValue : position,
       "Size" : size,
     ]
     properties = Array(keypathProperties.values)

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/PolygonNode.swift

@@ -23,10 +23,10 @@ final class PolygonNodeProperties: NodePropertyMap, KeypathSearchable {
     rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: star.rotation.keyframes))
     points = NodeProperty(provider: KeyframeInterpolator(keyframes: star.points.keyframes))
     keypathProperties = [
-      "Position" : position,
+      PropertyName.position.rawValue : position,
       "Outer Radius" : outerRadius,
       "Outer Roundedness" : outerRoundedness,
-      "Rotation" : rotation,
+      PropertyName.rotation.rawValue : rotation,
       "Points" : points,
     ]
     properties = Array(keypathProperties.values)

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/RectNode.swift

@@ -22,7 +22,7 @@ final class RectNodeProperties: NodePropertyMap, KeypathSearchable {
     cornerRadius = NodeProperty(provider: KeyframeInterpolator(keyframes: rectangle.cornerRadius.keyframes))
 
     keypathProperties = [
-      "Position" : position,
+      PropertyName.position.rawValue : position,
       "Size" : size,
       "Roundness" : cornerRadius,
     ]

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/StarNode.swift

@@ -33,12 +33,12 @@ final class StarNodeProperties: NodePropertyMap, KeypathSearchable {
     rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: star.rotation.keyframes))
     points = NodeProperty(provider: KeyframeInterpolator(keyframes: star.points.keyframes))
     keypathProperties = [
-      "Position" : position,
+      PropertyName.position.rawValue : position,
       "Outer Radius" : outerRadius,
       "Outer Roundedness" : outerRoundedness,
       "Inner Radius" : innerRadius,
       "Inner Roundedness" : innerRoundedness,
-      "Rotation" : rotation,
+      PropertyName.rotation.rawValue : rotation,
       "Points" : points,
     ]
     properties = Array(keypathProperties.values)