lottie-ios 4.1.1 → 4.1.3

package/README.md

@@ -8,7 +8,7 @@ Lottie is a cross-platform library for iOS, macOS, tvOS, [Android](https://githu
 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 them by hand.
-Since the animation is backed by JSON they are extremely small in size but can be large in complexity!
+Since the animations are 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!
 Animations can even be ***changed at runtime*** in various ways! Change the color, position, or any keyframable value!
@@ -41,10 +41,10 @@ To install Lottie using [Swift Package Manager](https://github.com/apple/swift-p
 or you can add the following dependency to your `Package.swift`:
 
 ```swift
-.package(url: "https://github.com/airbnb/lottie-spm.git", from: "4.1.1")
+.package(url: "https://github.com/airbnb/lottie-spm.git", from: "4.1.3")
 ```
 
-When using Swift Package Manager we recommend using the [lottie-spm](https://github.com/airbnb/lottie-spm) repo instead of the main lottie-ios repo.  The main git repository for [lottie-ios](https://github.com/airbnb/lottie-ios) is somewhat large (300+ MB), and Swift Package Manager always downloads the full repository with all git hsitory. The [lottie-spm](https://github.com/airbnb/lottie-spm) repo is much smaller (less than 500kb), so can be downloaded much more quickly. 
+When using Swift Package Manager we recommend using the [lottie-spm](https://github.com/airbnb/lottie-spm) repo instead of the main lottie-ios repo.  The main git repository for [lottie-ios](https://github.com/airbnb/lottie-ios) is somewhat large (300+ MB), and Swift Package Manager always downloads the full repository with all git history. The [lottie-spm](https://github.com/airbnb/lottie-spm) repo is much smaller (less than 500kb), so can be downloaded much more quickly. 
 
 Instead of downloading the full git history of Lottie and building it from source, the lottie-spm repo just contains a pointer to the precompiled XCFramework included in the [latest lottie-ios release](https://github.com/airbnb/lottie-ios/releases/latest) (typically ~8MB). If you prefer to include Lottie source directly your project, you can directly depend on the main lottie-ios repo by referencing `https://github.com/airbnb/lottie-ios.git` instead.
 
@@ -88,7 +88,7 @@ We always appreciate contributions from the community. To make changes to the pr
 
 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.
+  - To update existing snapshots after making changes, you can set `isRecording = true` in `SnapshotTests.swift` `setUp()` method and then re-run the snapshot tests.
 
 The project also includes several helpful commands defined in our [Rakefile](https://github.com/airbnb/lottie-ios/blob/master/Rakefile). To use these, you need to install [Bundler](https://bundler.io/):
 

package/Rakefile

@@ -49,6 +49,7 @@ namespace :build do
     sh 'rm -rf .build/archives'
     xcodebuild('archive -workspace Lottie.xcworkspace -scheme "Lottie (iOS)" -destination generic/platform=iOS -archivePath ".build/archives/Lottie_iOS" SKIP_INSTALL=NO BUILD_LIBRARY_FOR_DISTRIBUTION=YES')
     xcodebuild('archive -workspace Lottie.xcworkspace -scheme "Lottie (iOS)" -destination "generic/platform=iOS Simulator" -archivePath ".build/archives/Lottie_iOS_Simulator" SKIP_INSTALL=NO BUILD_LIBRARY_FOR_DISTRIBUTION=YES')
+    xcodebuild('archive -workspace Lottie.xcworkspace -scheme "Lottie (iOS)" -destination "generic/platform=macOS,variant=Mac Catalyst" -archivePath ".build/archives/Lottie_Mac_Catalyst" SKIP_INSTALL=NO BUILD_LIBRARY_FOR_DISTRIBUTION=YES')
     xcodebuild('archive -workspace Lottie.xcworkspace -scheme "Lottie (macOS)" -destination generic/platform=macOS -archivePath ".build/archives/Lottie_macOS" SKIP_INSTALL=NO BUILD_LIBRARY_FOR_DISTRIBUTION=YES')
     xcodebuild('archive -workspace Lottie.xcworkspace -scheme "Lottie (tvOS)" -destination generic/platform=tvOS -archivePath ".build/archives/Lottie_tvOS" SKIP_INSTALL=NO BUILD_LIBRARY_FOR_DISTRIBUTION=YES')
     xcodebuild('archive -workspace Lottie.xcworkspace -scheme "Lottie (tvOS)" -destination "generic/platform=tvOS Simulator" -archivePath ".build/archives/Lottie_tvOS_Simulator" SKIP_INSTALL=NO BUILD_LIBRARY_FOR_DISTRIBUTION=YES')
@@ -57,13 +58,16 @@ namespace :build do
         '-create-xcframework',
         '-framework .build/archives/Lottie_iOS.xcarchive/Products/Library/Frameworks/Lottie.framework',
         '-framework .build/archives/Lottie_iOS_Simulator.xcarchive/Products/Library/Frameworks/Lottie.framework',
+        '-framework .build/archives/Lottie_Mac_Catalyst.xcarchive/Products/Library/Frameworks/Lottie.framework',
         '-framework .build/archives/Lottie_macOS.xcarchive/Products/Library/Frameworks/Lottie.framework',
         '-framework .build/archives/Lottie_tvOS.xcarchive/Products/Library/Frameworks/Lottie.framework',
         '-framework .build/archives/Lottie_tvOS_Simulator.xcarchive/Products/Library/Frameworks/Lottie.framework',
         '-output .build/archives/Lottie.xcframework'
       ].join(" "))
     Dir.chdir('.build/archives') do
-      sh 'zip -r Lottie.xcframework.zip Lottie.xcframework'
+      # Use --symlinks to avoid "Multiple binaries share the same codesign path. This can happen if your build process copies frameworks by following symlinks." 
+      # error when validating macOS apps (#1948)
+      sh 'zip -r --symlinks Lottie.xcframework.zip Lottie.xcframework'
       sh 'rm -rf Lottie.xcframework'
     end
     sh 'swift package compute-checksum .build/archives/Lottie.xcframework.zip'

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

@@ -109,9 +109,9 @@ extension LayerProperty {
       customizableProperty: nil /* currently unsupported */ )
   }
 
-  static var rotation: LayerProperty<CGFloat> {
+  static var rotationX: LayerProperty<CGFloat> {
     .init(
-      caLayerKeypath: "transform.rotation",
+      caLayerKeypath: "transform.rotation.x",
       defaultValue: 0,
       customizableProperty: nil /* currently unsupported */ )
   }
@@ -123,6 +123,13 @@ extension LayerProperty {
       customizableProperty: nil /* currently unsupported */ )
   }
 
+  static var rotationZ: LayerProperty<CGFloat> {
+    .init(
+      caLayerKeypath: "transform.rotation.z",
+      defaultValue: 0,
+      customizableProperty: nil /* currently unsupported */ )
+  }
+
   static var anchorPoint: LayerProperty<CGPoint> {
     .init(
       caLayerKeypath: #keyPath(CALayer.anchorPoint),

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

@@ -24,8 +24,14 @@ protocol TransformModel {
   /// The scale of the transform
   var scale: KeyframeGroup<LottieVector3D> { get }
 
-  /// The rotation of the transform. Note: This is single dimensional rotation.
-  var rotation: KeyframeGroup<LottieVector1D> { get }
+  /// The rotation of the transform on X axis.
+  var rotationX: KeyframeGroup<LottieVector1D> { get }
+
+  /// The rotation of the transform on Y axis.
+  var rotationY: KeyframeGroup<LottieVector1D> { get }
+
+  /// The rotation of the transform on Z axis.
+  var rotationZ: KeyframeGroup<LottieVector1D> { get }
 }
 
 // MARK: - Transform + TransformModel
@@ -75,7 +81,7 @@ extension CALayer {
       try addPositionAnimations(from: transformModel, context: context)
       try addAnchorPointAnimation(from: transformModel, context: context)
       try addScaleAnimations(from: transformModel, context: context)
-      try addRotationAnimation(from: transformModel, context: context)
+      try addRotationAnimations(from: transformModel, context: context)
     }
   }
 
@@ -227,14 +233,53 @@ extension CALayer {
       context: context)
   }
 
-  private func addRotationAnimation(
+  private func addRotationAnimations(
     from transformModel: TransformModel,
     context: LayerAnimationContext)
     throws
   {
+    let containsXRotationValues = transformModel.rotationX.keyframes.contains(where: { $0.value.cgFloatValue != 0 })
+    let containsYRotationValues = transformModel.rotationY.keyframes.contains(where: { $0.value.cgFloatValue != 0 })
+
+    // When `rotation.x` or `rotation.y` is used, it doesn't render property in test snapshots
+    // but do renders correctly on the simulator / device
+    if TestHelpers.snapshotTestsAreRunning {
+      if containsXRotationValues {
+        context.logger.warn("""
+          `rotation.x` values are not displayed correctly in snapshot tests
+          """)
+      }
+
+      if containsYRotationValues {
+        context.logger.warn("""
+          `rotation.y` values are not displayed correctly in snapshot tests
+          """)
+      }
+    }
+
+    // Lottie animation files express rotation in degrees
+    // (e.g. 90º, 180º, 360º) so we covert to radians to get the
+    // values expected by Core Animation (e.g. π/2, π, 2π)
+
+    try addAnimation(
+      for: .rotationX,
+      keyframes: transformModel.rotationX.keyframes,
+      value: { rotationDegrees in
+        rotationDegrees.cgFloatValue * .pi / 180
+      },
+      context: context)
+
+    try addAnimation(
+      for: .rotationY,
+      keyframes: transformModel.rotationY.keyframes,
+      value: { rotationDegrees in
+        rotationDegrees.cgFloatValue * .pi / 180
+      },
+      context: context)
+
     try addAnimation(
-      for: .rotation,
-      keyframes: transformModel.rotation.keyframes,
+      for: .rotationZ,
+      keyframes: transformModel.rotationZ.keyframes,
       value: { rotationDegrees in
         // Lottie animation files express rotation in degrees
         // (e.g. 90º, 180º, 360º) so we covert to radians to get the
@@ -257,15 +302,19 @@ extension CALayer {
       transformModel.anchor,
       transformModel.position,
       transformModel.scale,
-      transformModel.rotation,
+      transformModel.rotationX,
+      transformModel.rotationY,
+      transformModel.rotationZ,
       transformModel.skew,
       transformModel.skewAxis,
-      makeCombinedResult: { anchor, position, scale, rotation, skew, skewAxis in
+      makeCombinedResult: { anchor, position, scale, rotationX, rotationY, rotationZ, skew, skewAxis in
         CATransform3D.makeTransform(
           anchor: anchor.pointValue,
           position: position.pointValue,
           scale: scale.sizeValue,
-          rotation: rotation.cgFloatValue,
+          rotationX: rotationX.cgFloatValue,
+          rotationY: rotationY.cgFloatValue,
+          rotationZ: rotationZ.cgFloatValue,
           skew: skew.cgFloatValue,
           skewAxis: skewAxis.cgFloatValue)
       })

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/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 }
 
@@ -55,12 +60,12 @@ class BaseCompositionLayer: BaseAnimationLayer {
   func setupLayerAnimations(context: LayerAnimationContext) throws {
     let context = context.addingKeypathComponent(baseLayerModel.name)
 
-    try addTransformAnimations(for: baseLayerModel.transform, context: context)
+    try contentsLayer.addTransformAnimations(for: baseLayerModel.transform, context: context)
 
     if renderLayerContents {
-      try addOpacityAnimation(for: baseLayerModel.transform, context: context)
+      try contentsLayer.addOpacityAnimation(for: baseLayerModel.transform, context: context)
 
-      addVisibilityAnimation(
+      contentsLayer.addVisibilityAnimation(
         inFrame: CGFloat(baseLayerModel.inFrame),
         outFrame: CGFloat(baseLayerModel.outFrame),
         context: context)
@@ -71,17 +76,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/MainThread/LayerContainers/Utility/LayerTransformNode.swift

@@ -18,13 +18,18 @@ 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,
+      "Rotation": rotationZ,
+      "Rotation X" : rotationX,
+      "Rotation Y" : rotationY,
+      "Rotation Z" : rotationZ,
       "Opacity" : opacity,
     ]
 
@@ -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/RenderContainers/GroupNode.swift

@@ -20,7 +20,9 @@ final class GroupNodeProperties: NodePropertyMap, KeypathSearchable {
       anchor = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.anchor.keyframes))
       position = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.position.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))
       skew = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.skew.keyframes))
       skewAxis = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.skewAxis.keyframes))
@@ -29,7 +31,9 @@ final class GroupNodeProperties: NodePropertyMap, KeypathSearchable {
       anchor = NodeProperty(provider: SingleValueProvider(LottieVector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
       position = NodeProperty(provider: SingleValueProvider(LottieVector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
       scale = NodeProperty(provider: SingleValueProvider(LottieVector3D(x: CGFloat(100), y: CGFloat(100), z: CGFloat(100))))
-      rotation = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+      rotationX = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+      rotationY = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+      rotationZ = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
       opacity = NodeProperty(provider: SingleValueProvider(LottieVector1D(100)))
       skew = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
       skewAxis = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
@@ -38,7 +42,10 @@ final class GroupNodeProperties: NodePropertyMap, KeypathSearchable {
       "Anchor Point" : anchor,
       "Position" : position,
       "Scale" : scale,
-      "Rotation" : rotation,
+      "Rotation" : rotationZ,
+      "Rotation X" : rotationX,
+      "Rotation Y" : rotationY,
+      "Rotation Z" : rotationZ,
       "Opacity" : opacity,
       "Skew" : skew,
       "Skew Axis" : skewAxis,
@@ -58,7 +65,10 @@ final class GroupNodeProperties: NodePropertyMap, KeypathSearchable {
   let anchor: NodeProperty<LottieVector3D>
   let position: NodeProperty<LottieVector3D>
   let scale: NodeProperty<LottieVector3D>
-  let rotation: NodeProperty<LottieVector1D>
+  let rotationX: NodeProperty<LottieVector1D>
+  let rotationY: NodeProperty<LottieVector1D>
+  let rotationZ: NodeProperty<LottieVector1D>
+
   let opacity: NodeProperty<LottieVector1D>
   let skew: NodeProperty<LottieVector1D>
   let skewAxis: NodeProperty<LottieVector1D>
@@ -68,7 +78,9 @@ final class GroupNodeProperties: NodePropertyMap, KeypathSearchable {
       anchor: anchor.value.pointValue,
       position: position.value.pointValue,
       scale: scale.value.sizeValue,
-      rotation: rotation.value.cgFloatValue,
+      rotationX: rotationX.value.cgFloatValue,
+      rotationY: rotationY.value.cgFloatValue,
+      rotationZ: rotationZ.value.cgFloatValue,
       skew: skew.value.cgFloatValue,
       skewAxis: skewAxis.value.cgFloatValue)
   }

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/Text/TextAnimatorNode.swift

@@ -54,11 +54,26 @@ final class TextAnimatorNodeProperties: NodePropertyMap, KeypathSearchable {
       skewAxis = nil
     }
 
-    if let keyframeGroup = textAnimator.rotation {
-      rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Rotation"] = rotation
+    if let keyframeGroup = textAnimator.rotationX {
+      rotationX = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Rotation X"] = rotationX
     } else {
-      rotation = nil
+      rotationX = nil
+    }
+
+    if let keyframeGroup = textAnimator.rotationY {
+      rotationY = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Rotation Y"] = rotationY
+    } else {
+      rotationY = nil
+    }
+
+    if let keyframeGroup = textAnimator.rotationZ {
+      rotationZ = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Rotation Z"] = rotationZ
+      properties["Rotation"] = rotationZ
+    } else {
+      rotationZ = nil
     }
 
     if let keyframeGroup = textAnimator.opacity {
@@ -110,7 +125,9 @@ final class TextAnimatorNodeProperties: NodePropertyMap, KeypathSearchable {
   let scale: NodeProperty<LottieVector3D>?
   let skew: NodeProperty<LottieVector1D>?
   let skewAxis: NodeProperty<LottieVector1D>?
-  let rotation: NodeProperty<LottieVector1D>?
+  let rotationX: NodeProperty<LottieVector1D>?
+  let rotationY: NodeProperty<LottieVector1D>?
+  let rotationZ: NodeProperty<LottieVector1D>?
   let opacity: NodeProperty<LottieVector1D>?
   let strokeColor: NodeProperty<LottieColor>?
   let fillColor: NodeProperty<LottieColor>?
@@ -125,7 +142,9 @@ final class TextAnimatorNodeProperties: NodePropertyMap, KeypathSearchable {
       anchor: anchor?.value.pointValue ?? .zero,
       position: position?.value.pointValue ?? .zero,
       scale: scale?.value.sizeValue ?? CGSize(width: 100, height: 100),
-      rotation: rotation?.value.cgFloatValue ?? 0,
+      rotationX: rotationX?.value.cgFloatValue ?? 0,
+      rotationY: rotationY?.value.cgFloatValue ?? 0,
+      rotationZ: rotationZ?.value.cgFloatValue ?? 0,
       skew: skew?.value.cgFloatValue,
       skewAxis: skewAxis?.value.cgFloatValue)
   }