lottie-ios 4.2.0 → 4.3.0

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

@@ -6,7 +6,7 @@ import QuartzCore
 // MARK: - TransformModel
 
 /// This protocol mirrors the interface of `Transform`,
-/// but it also implemented by `ShapeTransform` to allow
+/// but is also implemented by `ShapeTransform` to allow
 /// both transform types to share the same animation implementation.
 protocol TransformModel {
   /// The anchor point of the transform.
@@ -32,6 +32,12 @@ protocol TransformModel {
 
   /// The rotation of the transform on Z axis.
   var rotationZ: KeyframeGroup<LottieVector1D> { get }
+
+  /// The skew of the transform (only present on `ShapeTransform`s)
+  var _skew: KeyframeGroup<LottieVector1D>? { get }
+
+  /// The skew axis of the transform (only present on `ShapeTransform`s)
+  var _skewAxis: KeyframeGroup<LottieVector1D>? { get }
 }
 
 // MARK: - Transform + TransformModel
@@ -40,6 +46,8 @@ extension Transform: TransformModel {
   var _position: KeyframeGroup<LottieVector3D>? { position }
   var _positionX: KeyframeGroup<LottieVector1D>? { positionX }
   var _positionY: KeyframeGroup<LottieVector1D>? { positionY }
+  var _skew: KeyframeGroup<LottieVector1D>? { nil }
+  var _skewAxis: KeyframeGroup<LottieVector1D>? { nil }
 }
 
 // MARK: - ShapeTransform + TransformModel
@@ -49,6 +57,8 @@ extension ShapeTransform: TransformModel {
   var _position: KeyframeGroup<LottieVector3D>? { position }
   var _positionX: KeyframeGroup<LottieVector1D>? { nil }
   var _positionY: KeyframeGroup<LottieVector1D>? { nil }
+  var _skew: KeyframeGroup<LottieVector1D>? { skew }
+  var _skewAxis: KeyframeGroup<LottieVector1D>? { skewAxis }
 }
 
 // MARK: - CALayer + TransformModel
@@ -66,15 +76,18 @@ extension CALayer {
     context: LayerAnimationContext)
     throws
   {
-    // CALayers don't support animating skew with its own set of keyframes.
-    // If the transform includes a skew, we have to combine all of the transform
-    // components into a single set of keyframes.
-    // Only `ShapeTransform` supports skews.
     if
-      let shapeTransform = transformModel as? ShapeTransform,
-      shapeTransform.hasSkew
+      // CALayers don't support animating skew with its own set of keyframes.
+      // If the transform includes a skew, we have to combine all of the transform
+      // components into a single set of keyframes.
+      transformModel.hasSkew
+      // Negative `scale.x` values aren't applied correctly by Core Animation when animating
+      // `transform.scale.x` and `transform.scale.y` using separate `CAKeyframeAnimation`s
+      // (https://openradar.appspot.com/FB9862872). If the transform includes negative `scale.x`
+      // values, we have to combine all of the transform components into a single set of keyframes.
+      || transformModel.hasNegativeXScaleValues
     {
-      try addCombinedTransformAnimation(for: shapeTransform, context: context)
+      try addCombinedTransformAnimation(for: transformModel, context: context)
     }
 
     else {
@@ -159,65 +172,10 @@ extension CALayer {
         // Lottie animation files express scale as a numerical percentage value
         // (e.g. 50%, 100%, 200%) so we divide by 100 to get the decimal values
         // expected by Core Animation (e.g. 0.5, 1.0, 2.0).
-        //  - Negative `scale.x` values aren't applied correctly by Core Animation.
-        //    This appears to be because we animate `transform.scale.x` and `transform.scale.y`
-        //    as separate `CAKeyframeAnimation`s instead of using a single animation of `transform` itself.
-        //    https://openradar.appspot.com/FB9862872
-        //  - To work around this, we set up a `rotationY` animation below
-        //    to flip the view horizontally, which gives us the desired effect.
-        abs(CGFloat(scale.x) / 100)
+        CGFloat(scale.x) / 100
       },
       context: context)
 
-    /// iOS 14 and earlier doesn't properly support rendering transforms with
-    /// negative `scale.x` values: https://github.com/airbnb/lottie-ios/issues/1882
-    let osSupportsNegativeScaleValues: Bool = {
-      #if os(iOS) || os(tvOS)
-      if #available(iOS 15.0, tvOS 15.0, *) {
-        return true
-      } else {
-        return false
-      }
-      #else
-      // We'll assume this works correctly on macOS until told otherwise
-      return true
-      #endif
-    }()
-
-    lazy var hasNegativeXScaleValues = transformModel.scale.keyframes.contains(where: { $0.value.x < 0 })
-
-    // When `scale.x` is negative, we have to rotate the view
-    // half way around the y axis to flip it horizontally.
-    //  - We don't do this in snapshot tests because it breaks the tests
-    //    in surprising ways that don't happen at runtime. Definitely not ideal.
-    //  - This isn't supported on iOS 14 and earlier either, so we have to
-    //    log a compatibility error on devices running older OSs.
-    if TestHelpers.snapshotTestsAreRunning {
-      if hasNegativeXScaleValues {
-        context.logger.warn("""
-          Negative `scale.x` values are not displayed correctly in snapshot tests
-          """)
-      }
-    } else {
-      if !osSupportsNegativeScaleValues, hasNegativeXScaleValues {
-        try context.logCompatibilityIssue("""
-          iOS 14 and earlier does not support rendering negative `scale.x` values
-          """)
-      }
-
-      try addAnimation(
-        for: .rotationY,
-        keyframes: transformModel.scale,
-        value: { scale in
-          if scale.x < 0 {
-            return .pi
-          } else {
-            return 0
-          }
-        },
-        context: context)
-    }
-
     try addAnimation(
       for: .scaleY,
       keyframes: transformModel.scale,
@@ -225,9 +183,6 @@ extension CALayer {
         // Lottie animation files express scale as a numerical percentage value
         // (e.g. 50%, 100%, 200%) so we divide by 100 to get the decimal values
         // expected by Core Animation (e.g. 0.5, 1.0, 2.0).
-        //  - Negative `scaleY` values are correctly applied (they flip the view
-        //    vertically), so we don't have to apply an additional rotation animation
-        //    like we do for `scaleX`.
         CGFloat(scale.y) / 100
       },
       context: context)
@@ -258,7 +213,7 @@ extension CALayer {
     }
 
     // Lottie animation files express rotation in degrees
-    // (e.g. 90º, 180º, 360º) so we covert to radians to get the
+    // (e.g. 90º, 180º, 360º) so we convert to radians to get the
     // values expected by Core Animation (e.g. π/2, π, 2π)
 
     try addAnimation(
@@ -282,7 +237,7 @@ extension CALayer {
       keyframes: transformModel.rotationZ,
       value: { rotationDegrees in
         // Lottie animation files express rotation in degrees
-        // (e.g. 90º, 180º, 360º) so we covert to radians to get the
+        // (e.g. 90º, 180º, 360º) so we convert to radians to get the
         // values expected by Core Animation (e.g. π/2, π, 2π)
         rotationDegrees.cgFloatValue * .pi / 180
       },
@@ -291,26 +246,44 @@ extension CALayer {
 
   /// Adds an animation for the entire `transform` key by combining all of the
   /// position / size / rotation / skew animations into a single set of keyframes.
-  /// This is necessary when there's a skew animation, since skew can only
-  /// be applied via a transform.
+  /// This is more expensive that animating each component separately, since
+  /// it may require manually interpolating the keyframes at each frame.
   private func addCombinedTransformAnimation(
-    for transformModel: ShapeTransform,
+    for transformModel: TransformModel,
     context: LayerAnimationContext)
     throws
   {
+    // Core Animation doesn't animate skew changes properly. If the skew value
+    // changes over the course of the animation then we have to manually
+    // compute the `CATransform3D` for each frame individually.
+    let requiresManualInterpolation = transformModel.hasSkewAnimation
+
     let combinedTransformKeyframes = Keyframes.combined(
-      transformModel.anchor,
-      transformModel.position,
+      transformModel.anchorPoint,
+      transformModel._position ?? KeyframeGroup(LottieVector3D(x: 0.0, y: 0.0, z: 0.0)),
+      transformModel._positionX ?? KeyframeGroup(LottieVector1D(0)),
+      transformModel._positionY ?? KeyframeGroup(LottieVector1D(0)),
       transformModel.scale,
       transformModel.rotationX,
       transformModel.rotationY,
       transformModel.rotationZ,
-      transformModel.skew,
-      transformModel.skewAxis,
-      makeCombinedResult: { anchor, position, scale, rotationX, rotationY, rotationZ, skew, skewAxis in
-        CATransform3D.makeTransform(
+      transformModel._skew ?? KeyframeGroup(LottieVector1D(0)),
+      transformModel._skewAxis ?? KeyframeGroup(LottieVector1D(0)),
+      requiresManualInterpolation: requiresManualInterpolation,
+      makeCombinedResult: {
+        anchor, position, positionX, positionY, scale, rotationX, rotationY, rotationZ, skew, skewAxis
+          -> CATransform3D in
+
+        let transformPosition: CGPoint
+        if transformModel._positionX != nil, transformModel._positionY != nil {
+          transformPosition = CGPoint(x: positionX.cgFloatValue, y: positionY.cgFloatValue)
+        } else {
+          transformPosition = position.pointValue
+        }
+
+        return CATransform3D.makeTransform(
           anchor: anchor.pointValue,
-          position: position.pointValue,
+          position: transformPosition,
           scale: scale.sizeValue,
           rotationX: rotationX.cgFloatValue,
           rotationY: rotationY.cgFloatValue,
@@ -327,3 +300,36 @@ extension CALayer {
   }
 
 }
+
+extension TransformModel {
+  /// Whether or not this transform has a non-zero skew value
+  var hasSkew: Bool {
+    guard
+      let _skew = _skew,
+      let _skewAxis = _skewAxis,
+      !_skew.keyframes.isEmpty,
+      !_skewAxis.keyframes.isEmpty
+    else {
+      return false
+    }
+
+    return _skew.keyframes.contains(where: { $0.value.cgFloatValue != 0 })
+  }
+
+  /// Whether or not this transform has a non-zero skew value which animates
+  var hasSkewAnimation: Bool {
+    guard
+      hasSkew,
+      let _skew = _skew,
+      let _skewAxis = _skewAxis
+    else { return false }
+
+    return _skew.keyframes.count > 1
+      || _skewAxis.keyframes.count > 1
+  }
+
+  /// Whether or not this `TransformModel` has any negative X scale values
+  var hasNegativeXScaleValues: Bool {
+    scale.keyframes.contains(where: { $0.value.x < 0 })
+  }
+}

package/Sources/Private/CoreAnimation/CoreAnimationLayer.swift

@@ -17,7 +17,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   init(
     animation: LottieAnimation,
     imageProvider: AnimationImageProvider,
-    textProvider: AnimationTextProvider,
+    textProvider: AnimationKeypathTextProvider,
     fontProvider: AnimationFontProvider,
     maskAnimationToBounds: Bool,
     compatibilityTrackerMode: CompatibilityTracker.Mode,
@@ -94,8 +94,8 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     }
   }
 
-  /// The parent `LottieAnimationView` that manages this layer
-  weak var animationView: LottieAnimationView?
+  /// The parent `LottieAnimationLayer` that manages this layer
+  weak var lottieAnimationLayer: LottieAnimationLayer?
 
   /// A closure that is called after this layer sets up its animation.
   /// If the animation setup was unsuccessful and encountered compatibility issues,
@@ -108,9 +108,9 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     didSet { reloadImages() }
   }
 
-  /// The `AnimationTextProvider` that `TextLayer`'s use to retrieve texts,
+  /// The `AnimationKeypathTextProvider` that `TextLayer`'s use to retrieve texts,
   /// that they should use to render their text context
-  var textProvider: AnimationTextProvider {
+  var textProvider: AnimationKeypathTextProvider {
     didSet {
       // We need to rebuild the current animation after updating the text provider,
       // since this is used in `TextLayer.setupAnimations(context:)`
@@ -316,7 +316,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     else { return }
 
     if isAnimationPlaying == true {
-      animationView?.updateInFlightAnimation()
+      lottieAnimationLayer?.updateInFlightAnimation()
     } else {
       let currentFrame = currentFrame
       removeAnimations()
@@ -449,7 +449,7 @@ extension CoreAnimationLayer: RootAnimationLayer {
   }
 
   func forceDisplayUpdate() {
-    // Unimplemented / unused
+    display()
   }
 
   func logHierarchyKeypaths() {

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

@@ -10,12 +10,18 @@ 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<T>(_ allGroups: [KeyframeGroup<T>]) -> KeyframeGroup<[T]>
+  static func combined<T>(
+    _ allGroups: [KeyframeGroup<T>],
+    requiresManualInterpolation: Bool = false)
+    -> KeyframeGroup<[T]>
     where T: AnyInterpolatable
   {
-    Keyframes.combined(allGroups, makeCombinedResult: { untypedValues in
-      untypedValues.compactMap { $0 as? T }
-    })
+    Keyframes.combined(
+      allGroups,
+      requiresManualInterpolation: requiresManualInterpolation,
+      makeCombinedResult: { untypedValues in
+        untypedValues.compactMap { $0 as? T }
+      })
   }
 
   /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of of `Keyframe<[T]>`s
@@ -24,6 +30,7 @@ enum Keyframes {
   static func combined<T1, T2, CombinedResult>(
     _ k1: KeyframeGroup<T1>,
     _ k2: KeyframeGroup<T2>,
+    requiresManualInterpolation: Bool = false,
     makeCombinedResult: (T1, T2) throws -> CombinedResult)
     rethrows
     -> KeyframeGroup<CombinedResult>
@@ -31,6 +38,7 @@ enum Keyframes {
   {
     try Keyframes.combined(
       [k1, k2],
+      requiresManualInterpolation: requiresManualInterpolation,
       makeCombinedResult: { untypedValues in
         guard
           let t1 = untypedValues[0] as? T1,
@@ -48,12 +56,14 @@ enum Keyframes {
     _ k1: KeyframeGroup<T1>,
     _ k2: KeyframeGroup<T2>,
     _ k3: KeyframeGroup<T3>,
+    requiresManualInterpolation: Bool = false,
     makeCombinedResult: (T1, T2, T3) -> CombinedResult)
     -> KeyframeGroup<CombinedResult>
     where T1: AnyInterpolatable, T2: AnyInterpolatable, T3: AnyInterpolatable
   {
     Keyframes.combined(
       [k1, k2, k3],
+      requiresManualInterpolation: requiresManualInterpolation,
       makeCombinedResult: { untypedValues in
         guard
           let t1 = untypedValues[0] as? T1,
@@ -76,6 +86,7 @@ enum Keyframes {
     _ k5: KeyframeGroup<T5>,
     _ k6: KeyframeGroup<T6>,
     _ k7: KeyframeGroup<T7>,
+    requiresManualInterpolation: Bool = false,
     makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7) -> CombinedResult)
     -> KeyframeGroup<CombinedResult>
     where T1: AnyInterpolatable, T2: AnyInterpolatable, T3: AnyInterpolatable, T4: AnyInterpolatable,
@@ -83,6 +94,7 @@ enum Keyframes {
   {
     Keyframes.combined(
       [k1, k2, k3, k4, k5, k6, k7],
+      requiresManualInterpolation: requiresManualInterpolation,
       makeCombinedResult: { untypedValues in
         guard
           let t1 = untypedValues[0] as? T1,
@@ -110,6 +122,7 @@ enum Keyframes {
     _ k6: KeyframeGroup<T6>,
     _ k7: KeyframeGroup<T7>,
     _ k8: KeyframeGroup<T8>,
+    requiresManualInterpolation: Bool = false,
     makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7, T8) -> CombinedResult)
     -> KeyframeGroup<CombinedResult>
     where T1: AnyInterpolatable, T2: AnyInterpolatable, T3: AnyInterpolatable, T4: AnyInterpolatable,
@@ -117,6 +130,7 @@ enum Keyframes {
   {
     Keyframes.combined(
       [k1, k2, k3, k4, k5, k6, k7, k8],
+      requiresManualInterpolation: requiresManualInterpolation,
       makeCombinedResult: { untypedValues in
         guard
           let t1 = untypedValues[0] as? T1,
@@ -133,6 +147,48 @@ 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, T7, T8, T9, T10, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    _ k4: KeyframeGroup<T4>,
+    _ k5: KeyframeGroup<T5>,
+    _ k6: KeyframeGroup<T6>,
+    _ k7: KeyframeGroup<T7>,
+    _ k8: KeyframeGroup<T8>,
+    _ k9: KeyframeGroup<T9>,
+    _ k10: KeyframeGroup<T10>,
+    requiresManualInterpolation: Bool = false,
+    makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>
+    where T1: AnyInterpolatable, T2: AnyInterpolatable, T3: AnyInterpolatable, T4: AnyInterpolatable,
+    T5: AnyInterpolatable, T6: AnyInterpolatable, T7: AnyInterpolatable, T8: AnyInterpolatable,
+    T9: AnyInterpolatable, T10: AnyInterpolatable
+  {
+    Keyframes.combined(
+      [k1, k2, k3, k4, k5, k6, k7, k8, k9, k10],
+      requiresManualInterpolation: requiresManualInterpolation,
+      makeCombinedResult: { untypedValues in
+        guard
+          let t1 = untypedValues[0] as? T1,
+          let t2 = untypedValues[1] as? T2,
+          let t3 = untypedValues[2] as? T3,
+          let t4 = untypedValues[3] as? T4,
+          let t5 = untypedValues[4] as? T5,
+          let t6 = untypedValues[5] as? T6,
+          let t7 = untypedValues[6] as? T7,
+          let t8 = untypedValues[7] as? T8,
+          let t9 = untypedValues[8] as? T9,
+          let t10 = untypedValues[9] as? T10
+        else { return nil }
+
+        return makeCombinedResult(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+      })
+  }
+
   // MARK: Private
 
   /// Combines the given `[KeyframeGroup]` of `Keyframe<T>`s into a single `KeyframeGroup` of `Keyframe<CombinedResult>`s
@@ -141,8 +197,12 @@ enum Keyframes {
   ///
   /// `makeCombinedResult` is a closure that takes an array of keyframe values (with the exact same length as `AnyKeyframeGroup`),
   /// casts them to the expected type, and combined them into the final resulting keyframe.
+  ///
+  /// `requiresManualInterpolation` determines whether the keyframes must be computed using `Keyframes.manuallyInterpolated`,
+  /// which interpolates the value at each frame, or if the keyframes can simply be combined.
   private static func combined<CombinedResult>(
     _ allGroups: [AnyKeyframeGroup],
+    requiresManualInterpolation: Bool,
     makeCombinedResult: ([Any]) throws -> CombinedResult?)
     rethrows
     -> KeyframeGroup<CombinedResult>
@@ -155,6 +215,7 @@ enum Keyframes {
     let animatingKeyframes = untypedGroups.filter { $0.keyframes.count > 1 }
 
     guard
+      !requiresManualInterpolation,
       !allGroups.isEmpty,
       animatingKeyframes.allSatisfy({ $0.hasSameTimingParameters(as: animatingKeyframes[0]) })
     else {
@@ -222,7 +283,7 @@ enum Keyframes {
 extension KeyframeGroup {
   /// Whether or not all of the keyframes in this `KeyframeGroup` have the same
   /// timing parameters as the corresponding keyframe in the other given `KeyframeGroup`
-  func hasSameTimingParameters<T>(as other: KeyframeGroup<T>) -> Bool {
+  func hasSameTimingParameters<U>(as other: KeyframeGroup<U>) -> Bool {
     guard keyframes.count == other.keyframes.count else {
       return false
     }
@@ -236,7 +297,7 @@ extension KeyframeGroup {
 extension Keyframe {
   /// Whether or not this keyframe has the same timing parameters as the given keyframe,
   /// excluding `spatialInTangent` and `spatialOutTangent`.
-  fileprivate func hasSameTimingParameters<T>(as other: Keyframe<T>) -> Bool {
+  fileprivate func hasSameTimingParameters<U>(as other: Keyframe<U>) -> Bool {
     time == other.time
       && isHold == other.isHold
       && inTangent == other.inTangent

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

@@ -41,8 +41,8 @@ struct LayerAnimationContext {
   /// The AnimationKeypath represented by the current layer
   var currentKeypath: AnimationKeypath
 
-  /// The `AnimationTextProvider`
-  var textProvider: AnimationTextProvider
+  /// The `AnimationKeypathTextProvider`
+  var textProvider: AnimationKeypathTextProvider
 
   /// Records the given animation keypath so it can be logged or collected into a list
   ///  - Used for `CoreAnimationLayer.logHierarchyKeypaths()` and `allHierarchyKeypaths()`

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

@@ -67,6 +67,15 @@ class BaseCompositionLayer: BaseAnimationLayer {
         inFrame: CGFloat(baseLayerModel.inFrame),
         outFrame: CGFloat(baseLayerModel.outFrame),
         context: context)
+
+      // There are two different drop shadow schemas, either using `DropShadowEffect` or `DropShadowStyle`.
+      // If both happen to be present, prefer the `DropShadowEffect` (which is the drop shadow schema
+      // supported on other platforms).
+      let dropShadowEffect = baseLayerModel.effects.first(where: { $0 is DropShadowEffect }) as? DropShadowModel
+      let dropShadowStyle = baseLayerModel.styles.first(where: { $0 is DropShadowStyle }) as? DropShadowModel
+      if let dropShadowModel = dropShadowEffect ?? dropShadowStyle {
+        try contentsLayer.addDropShadowAnimations(for: dropShadowModel, context: context)
+      }
     }
   }
 

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

@@ -48,6 +48,7 @@ final class ImageLayer: BaseCompositionLayer {
 
     self.imageAsset = imageAsset
     contentsLayer.contents = image
+    contentsLayer.contentsGravity = context.imageProvider.contentsGravity(for: imageAsset)
     setNeedsLayout()
   }
 

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

@@ -9,7 +9,7 @@ import QuartzCore
 struct LayerContext {
   let animation: LottieAnimation
   let imageProvider: AnimationImageProvider
-  let textProvider: AnimationTextProvider
+  let textProvider: AnimationKeypathTextProvider
   let fontProvider: AnimationFontProvider
   let compatibilityTracker: CompatibilityTracker
   var layerName: String

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

@@ -93,4 +93,6 @@ extension RepeaterTransform: TransformModel {
   var _position: KeyframeGroup<LottieVector3D>? { position }
   var _positionX: KeyframeGroup<LottieVector1D>? { nil }
   var _positionY: KeyframeGroup<LottieVector1D>? { nil }
+  var _skew: KeyframeGroup<LottieVector1D>? { nil }
+  var _skewAxis: KeyframeGroup<LottieVector1D>? { nil }
 }

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

@@ -41,7 +41,8 @@ final class ShapeLayer: BaseCompositionLayer {
     if let repeater = shapeLayer.items.first(where: { $0 is Repeater }) as? Repeater {
       try setUpRepeater(repeater, context: context)
     } else {
-      try setupGroups(from: shapeLayer.items, parentGroup: nil, parentGroupPath: [], context: context)
+      let shapeItems = shapeLayer.items.map { ShapeItemLayer.Item(item: $0, groupPath: []) }
+      try setupGroups(from: shapeItems, parentGroup: nil, parentGroupPath: [], context: context)
     }
   }
 
@@ -50,7 +51,8 @@ final class ShapeLayer: BaseCompositionLayer {
     let copyCount = Int(try repeater.copies.exactlyOneKeyframe(context: context, description: "repeater copies").value)
 
     for index in 0..<copyCount {
-      for groupLayer in try makeGroupLayers(from: items, parentGroup: nil, parentGroupPath: [], context: context) {
+      let shapeItems = items.map { ShapeItemLayer.Item(item: $0, groupPath: []) }
+      for groupLayer in try makeGroupLayers(from: shapeItems, parentGroup: nil, parentGroupPath: [], context: context) {
         let repeatedLayer = RepeaterLayer(repeater: repeater, childLayer: groupLayer, index: index)
         addSublayer(repeatedLayer)
       }
@@ -127,7 +129,7 @@ final class GroupLayer: BaseAnimationLayer {
   private func setupLayerHierarchy(context: LayerContext) throws {
     // Groups can contain other groups, so we may have to continue
     // recursively creating more `GroupLayer`s
-    try setupGroups(from: group.items, parentGroup: group, parentGroupPath: groupPath, context: context)
+    try setupGroups(from: items, parentGroup: group, parentGroupPath: groupPath, context: context)
 
     // Create `ShapeItemLayer`s for each subgroup of shapes that should be rendered as a single unit
     //  - These groups are listed from front-to-back, so we have to add the sublayers in reverse order
@@ -183,7 +185,7 @@ extension CALayer {
   ///  - Each `Group` item becomes its own `GroupLayer` sublayer.
   ///  - Other `ShapeItem` are applied to all sublayers
   fileprivate func setupGroups(
-    from items: [ShapeItem],
+    from items: [ShapeItemLayer.Item],
     parentGroup: Group?,
     parentGroupPath: [String],
     context: LayerContext)
@@ -204,29 +206,27 @@ extension CALayer {
   ///  - Each `Group` item becomes its own `GroupLayer` sublayer.
   ///  - Other `ShapeItem` are applied to all sublayers
   fileprivate func makeGroupLayers(
-    from items: [ShapeItem],
+    from items: [ShapeItemLayer.Item],
     parentGroup: Group?,
     parentGroupPath: [String],
     context: LayerContext)
     throws -> [GroupLayer]
   {
-    var (groupItems, otherItems) = items
-      .filter { !$0.hidden }
-      .grouped(by: { $0 is Group })
+    var groupItems = items.compactMap { $0.item as? Group }.filter { !$0.hidden }
+    var otherItems = items.filter { !($0.item is Group) && !$0.item.hidden }
 
     // Handle the top-level `shapeLayer.items` array. This is typically just a single `Group`,
     // but in practice can be any combination of items. The implementation expects all path-drawing
     // shape items to be managed by a `GroupLayer`, so if there's a top-level path item we
     // have to create a placeholder group.
-    if parentGroup == nil, otherItems.contains(where: { $0.drawsCGPath }) {
-      groupItems = [Group(items: items, name: "")]
+    if parentGroup == nil, otherItems.contains(where: { $0.item.drawsCGPath }) {
+      groupItems = [Group(items: items.map { $0.item }, name: "")]
       otherItems = []
     }
 
     // Any child items that wouldn't be included in a valid shape render group
     // need to be applied to child groups (otherwise they'd be silently ignored).
     let inheritedItemsForChildGroups = otherItems
-      .map { ShapeItemLayer.Item(item: $0, groupPath: parentGroupPath) }
       .shapeRenderGroups(groupHasChildGroupsToInheritUnusedItems: !groupItems.isEmpty)
       .unusedItems
 
@@ -235,8 +235,6 @@ extension CALayer {
     let groupsInZAxisOrder = groupItems.reversed()
 
     return try groupsInZAxisOrder.compactMap { group in
-      guard let group = group as? Group else { return nil }
-
       var pathForChildren = parentGroupPath
       if !group.name.isEmpty {
         pathForChildren.append(group.name)

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

@@ -30,16 +30,31 @@ final class SolidLayer: BaseCompositionLayer {
     super.init(layer: typedLayer)
   }
 
+  // MARK: Internal
+
+  override func setupAnimations(context: LayerAnimationContext) throws {
+    try super.setupAnimations(context: context)
+
+    // Even though the Lottie json schema provides a fixed `solidLayer.colorHex` value,
+    // we still need to create a set of keyframes and go through the standard `CAAnimation`
+    // codepath so that this value can be customized using the custom `ValueProvider`s API.
+    try shapeLayer.addAnimation(
+      for: .fillColor,
+      keyframes: KeyframeGroup(solidLayer.colorHex.cgColor),
+      value: { $0 },
+      context: context)
+  }
+
   // MARK: Private
 
   private let solidLayer: SolidLayerModel
 
+  /// Render the fill color in a child `CAShapeLayer`
+  ///  - Using a `CAShapeLayer` specifically, instead of a `CALayer` with a `backgroundColor`,
+  ///    allows the size of the fill shape to be different from `contentsLayer.size`.
+  private let shapeLayer = CAShapeLayer()
+
   private func setupContentLayer() {
-    // Render the fill color in a child `CAShapeLayer`
-    //  - Using a `CAShapeLayer` specifically, instead of a `CALayer` with a `backgroundColor`,
-    //    allows the size of the fill shape to be different from `contentsLayer.size`.
-    let shapeLayer = CAShapeLayer()
-    shapeLayer.fillColor = solidLayer.colorHex.cgColor
     shapeLayer.path = CGPath(rect: .init(x: 0, y: 0, width: solidLayer.width, height: solidLayer.height), transform: nil)
     addSublayer(shapeLayer)
   }

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

@@ -44,9 +44,19 @@ final class TextLayer: BaseCompositionLayer {
       context: textAnimationContext,
       description: "text layer text")
 
-    renderLayer.text = context.textProvider.textFor(
-      keypathName: textAnimationContext.currentKeypath.fullPath,
-      sourceText: sourceText.text)
+    // Prior to Lottie 4.3.0 the Core Animation rendering engine always just used `LegacyAnimationTextProvider`
+    // but incorrectly called it with the full keypath string, unlike the Main Thread rendering engine
+    // which only used the last component of the keypath. Starting in Lottie 4.3.0 we use `AnimationKeypathTextProvider`
+    // instead if implemented.
+    if let keypathTextValue = context.textProvider.text(for: textAnimationContext.currentKeypath, sourceText: sourceText.text) {
+      renderLayer.text = keypathTextValue
+    } else if let legacyTextProvider = context.textProvider as? LegacyAnimationTextProvider {
+      renderLayer.text = legacyTextProvider.textFor(
+        keypathName: textAnimationContext.currentKeypath.fullPath,
+        sourceText: sourceText.text)
+    } else {
+      renderLayer.text = sourceText.text
+    }
 
     renderLayer.sizeToFit()
   }