lottie-ios 4.1.3 → 4.2.0

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

@@ -57,7 +57,7 @@ extension CAShapeLayer {
 
     try addAnimation(
       for: .fillColor,
-      keyframes: fill.color.keyframes,
+      keyframes: fill.color,
       value: \.cgColorValue,
       context: context)
 
@@ -71,7 +71,7 @@ extension CAShapeLayer {
 
     try addAnimation(
       for: .strokeStart,
-      keyframes: strokeStartKeyframes.keyframes,
+      keyframes: strokeStartKeyframes,
       value: { strokeStart in
         // Lottie animation files express stoke trims as a numerical percentage value
         // (e.g. 25%, 50%, 100%) so we divide by 100 to get the decimal values
@@ -81,7 +81,7 @@ extension CAShapeLayer {
 
     try addAnimation(
       for: .strokeEnd,
-      keyframes: strokeEndKeyframes.keyframes,
+      keyframes: strokeEndKeyframes,
       value: { strokeEnd in
         // Lottie animation files express stoke trims as a numerical percentage value
         // (e.g. 25%, 50%, 100%) so we divide by 100 to get the decimal values
@@ -112,14 +112,24 @@ extension Trim {
 
     // CAShapeLayer requires strokeStart to be less than strokeEnd. This
     // isn't required by the Lottie schema, so some animations may have
-    // strokeStart and strokeEnd flipped. If we detect this is the case,
-    // then swap them.
-    if startValueIsAlwaysGreaterThanEndValue() {
+    // strokeStart and strokeEnd flipped.
+    if startValueIsAlwaysLessOrEqualToThanEndValue() {
+      // If the start value is always _less than_ or equal to the end value
+      // then we can use the given values without any modifications
+      strokeStart = start
+      strokeEnd = end
+    } else if startValueIsAlwaysGreaterThanOrEqualToEndValue() {
+      // If the start value is always _greater than_ or equal to the end value,
+      // then we can just swap the start / end keyframes. This lets us avoid
+      // manually interpolating the keyframes values at each frame, which
+      // would be more expensive.
       strokeStart = end
       strokeEnd = start
     } else {
-      strokeStart = start
-      strokeEnd = end
+      // Otherwise if the start / end values ever swap places we have to
+      // fix the order on a per-keyframe basis, which may require manually
+      // interpolating the keyframe values at each frame.
+      (strokeStart, strokeEnd) = interpolatedAtEachFrame()
     }
 
     // If there are no offsets, then the stroke values can be used as-is
@@ -130,22 +140,20 @@ extension Trim {
       return (strokeStart, strokeEnd, 1)
     }
 
-    // Otherwise, adjust the stroke values to account for the offsets
-    // 1. Interpolate the keyframes so they are all on a linear timing function
-    // 2. Merge by summing the stroke values with the offset values
-    let interpolatedStrokeStart = strokeStart.manuallyInterpolateKeyframes()
-    let interpolatedStrokeEnd = strokeEnd.manuallyInterpolateKeyframes()
-    let interpolatedStrokeOffset = offset.manuallyInterpolateKeyframes()
-
-    var adjustedStrokeStart = KeyframeGroup(
-      keyframes: try adjustKeyframesForTrimOffsets(
-        strokeKeyframes: interpolatedStrokeStart,
-        offsetKeyframes: interpolatedStrokeOffset))
-
-    var adjustedStrokeEnd = KeyframeGroup(
-      keyframes: try adjustKeyframesForTrimOffsets(
-        strokeKeyframes: interpolatedStrokeEnd,
-        offsetKeyframes: interpolatedStrokeOffset))
+    // Apply the offset to the start / end values at each frame
+    let offsetStrokeKeyframes = Keyframes.combined(
+      strokeStart,
+      strokeEnd,
+      offset,
+      makeCombinedResult: { start, end, offset -> (start: LottieVector1D, end: LottieVector1D) in
+        // Compute the adjusted value by converting the offset value to a stroke value
+        let offsetStart = start.cgFloatValue + (offset.cgFloatValue / 360 * 100)
+        let offsetEnd = end.cgFloatValue + (offset.cgFloatValue / 360 * 100)
+        return (start: LottieVector1D(offsetStart), end: LottieVector1D(offsetEnd))
+      })
+
+    var adjustedStrokeStart = offsetStrokeKeyframes.map { $0.start }
+    var adjustedStrokeEnd = offsetStrokeKeyframes.map { $0.end }
 
     // If maximum stroke value is larger than 100%, then we have to create copies of the path
     // so the total path length includes the maximum stroke
@@ -169,9 +177,23 @@ extension Trim {
 
   // MARK: Private
 
-  /// Checks whether or not the value for `trim.start` is greater
-  /// than the value for every `trim.end` at every keyframe.
-  private func startValueIsAlwaysGreaterThanEndValue() -> Bool {
+  /// Checks whether or not the value for `trim.start` is less than
+  /// or equal to the value for every `trim.end` at every frame.
+  private func startValueIsAlwaysLessOrEqualToThanEndValue() -> Bool {
+    startAndEndValuesAllSatisfy { startValue, endValue in
+      startValue <= endValue
+    }
+  }
+
+  /// Checks whether or not the value for `trim.start` is greater than
+  /// or equal to the value for every `trim.end` at every frame.
+  private func startValueIsAlwaysGreaterThanOrEqualToEndValue() -> Bool {
+    startAndEndValuesAllSatisfy { startValue, endValue in
+      startValue >= endValue
+    }
+  }
+
+  private func startAndEndValuesAllSatisfy(_ condition: (_ start: CGFloat, _ end: CGFloat) -> Bool) -> Bool {
     let keyframeTimes = Set(start.keyframes.map { $0.time } + end.keyframes.map { $0.time })
 
     let startInterpolator = KeyframeInterpolator(keyframes: start.keyframes)
@@ -183,7 +205,7 @@ extension Trim {
         let endAtTime = endInterpolator.value(frame: keyframeTime) as? LottieVector1D
       else { continue }
 
-      if startAtTime.cgFloatValue < endAtTime.cgFloatValue {
+      if !condition(startAtTime.cgFloatValue, endAtTime.cgFloatValue) {
         return false
       }
     }
@@ -191,82 +213,24 @@ extension Trim {
     return true
   }
 
-  /// Adjusted stroke keyframes to account for offset keyframes by merging them into a single keyframe collection
-  ///
-  /// Since stroke keyframes and offset keyframes can be defined on different animation curves, they must be
-  /// manually interpolated prior to invoking this method. Manually interpolating the keyframes will redefine both
-  /// keyframe groups such that they can be interpolated linearly.
-  ///
-  /// - Precondition: The keyframes must be interpolated using `KeyframeGroup.manuallyInterpolateKeyframes()`
-  private func adjustKeyframesForTrimOffsets(
-    strokeKeyframes: ContiguousArray<Keyframe<LottieVector1D>>,
-    offsetKeyframes: ContiguousArray<Keyframe<LottieVector1D>>)
-    throws -> ContiguousArray<Keyframe<LottieVector1D>>
+  /// Interpolates the start and end keyframes, at each frame if necessary,
+  /// so that the value of `strokeStart` is always less than `strokeEnd`.
+  private func interpolatedAtEachFrame()
+    -> (strokeStart: KeyframeGroup<LottieVector1D>, strokeEnd: KeyframeGroup<LottieVector1D>)
   {
-    guard
-      !strokeKeyframes.isEmpty,
-      !offsetKeyframes.isEmpty
-    else {
-      return strokeKeyframes
-    }
-
-    // Map each time to its corresponding stroke/offset keyframe
-    var timeMap = [AnimationFrameTime: [Keyframe<LottieVector1D>?]]()
-    for stroke in strokeKeyframes {
-      timeMap[stroke.time] = [stroke, nil]
-    }
-    for offset in offsetKeyframes {
-      if var existing = timeMap[offset.time] {
-        existing[1] = offset
-        timeMap[offset.time] = existing
-      } else {
-        timeMap[offset.time] = [nil, offset]
-      }
-    }
-
-    // Each time will be mapped to a new, adjusted keyframe
-    var output = ContiguousArray<Keyframe<LottieVector1D>>()
-    var lastKeyframe: Keyframe<LottieVector1D>?
-    var lastOffset: Keyframe<LottieVector1D>?
-
-    for (time, values) in timeMap.sorted(by: { $0.0 < $1.0 }) {
-      // Extract keyframe/offset associated with this timestamp
-      let keyframe = values[0]
-      let offset = values[1]
-      lastKeyframe = keyframe ?? lastKeyframe
-      lastOffset = offset ?? lastOffset
-
-      guard let currentKeyframe = lastKeyframe else {
-        // No keyframes are output until the first keyframe occurs
-        continue
-      }
-
-      guard let currentOffset = lastOffset else {
-        // Scalar isHold keyframes are not output as they offset the offset keyframes
-        if !(strokeKeyframes.count == 1 && currentKeyframe.isHold) {
-          output.append(currentKeyframe)
+    let combinedKeyframes = Keyframes.combined(
+      start,
+      end,
+      makeCombinedResult: { startValue, endValue -> (start: LottieVector1D, end: LottieVector1D) in
+        if startValue.cgFloatValue < endValue.cgFloatValue {
+          return (start: startValue, end: endValue)
+        } else {
+          return (start: endValue, end: startValue)
         }
-        continue
-      }
+      })
 
-      // Compute the adjusted value by converting the offset value to a stroke value
-      let strokeValue = currentKeyframe.value.value
-      let offsetValue = currentOffset.value.value
-      let adjustedValue = strokeValue + (offsetValue / 360 * 100)
-
-      // The tangent values are all `nil` as the keyframes should have been manually interpolated
-      let adjustedKeyframe = Keyframe<LottieVector1D>(
-        value: LottieVector1D(adjustedValue),
-        time: time,
-        isHold: currentKeyframe.isHold,
-        inTangent: nil,
-        outTangent: nil,
-        spatialInTangent: nil,
-        spatialOutTangent: nil)
-
-      output.append(adjustedKeyframe)
-    }
-
-    return output
+    return (
+      strokeStart: combinedKeyframes.map { $0.start },
+      strokeEnd: combinedKeyframes.map { $0.end })
   }
 }

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

@@ -36,7 +36,7 @@ extension CAShapeLayer {
   {
     try addAnimation(
       for: .path,
-      keyframes: try star.combinedKeyframes().keyframes,
+      keyframes: try star.combinedKeyframes(),
       value: { keyframe in
         BezierPath.star(
           position: keyframe.position.pointValue,
@@ -62,7 +62,7 @@ extension CAShapeLayer {
   {
     try addAnimation(
       for: .path,
-      keyframes: try star.combinedKeyframes().keyframes,
+      keyframes: try star.combinedKeyframes(),
       value: { keyframe in
         BezierPath.polygon(
           position: keyframe.position.pointValue,

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

@@ -54,14 +54,14 @@ extension CAShapeLayer {
     if let strokeColor = stroke.strokeColor {
       try addAnimation(
         for: .strokeColor,
-        keyframes: strokeColor.keyframes,
+        keyframes: strokeColor,
         value: \.cgColorValue,
         context: context)
     }
 
     try addAnimation(
       for: .lineWidth,
-      keyframes: stroke.width.keyframes,
+      keyframes: stroke.width,
       value: \.cgFloatValue,
       context: context)
 
@@ -79,7 +79,7 @@ extension CAShapeLayer {
 
       try addAnimation(
         for: .lineDashPhase,
-        keyframes: dashPhase,
+        keyframes: KeyframeGroup(keyframes: dashPhase),
         value: \.cgFloatValue,
         context: context)
     }

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

@@ -93,15 +93,15 @@ extension CALayer {
     context: LayerAnimationContext)
     throws
   {
-    if let positionKeyframes = transformModel._position?.keyframes {
+    if let positionKeyframes = transformModel._position {
       try addAnimation(
         for: .position,
         keyframes: positionKeyframes,
         value: \.pointValue,
         context: context)
     } else if
-      let xKeyframes = transformModel._positionX?.keyframes,
-      let yKeyframes = transformModel._positionY?.keyframes
+      let xKeyframes = transformModel._positionX,
+      let yKeyframes = transformModel._positionY
     {
       try addAnimation(
         for: .positionX,
@@ -129,7 +129,7 @@ extension CALayer {
   {
     try addAnimation(
       for: .anchorPoint,
-      keyframes: transformModel.anchorPoint.keyframes,
+      keyframes: transformModel.anchorPoint,
       value: { absoluteAnchorPoint in
         guard bounds.width > 0, bounds.height > 0 else {
           context.logger.assertionFailure("Size must be non-zero before an animation can be played")
@@ -154,7 +154,7 @@ extension CALayer {
   {
     try addAnimation(
       for: .scaleX,
-      keyframes: transformModel.scale.keyframes,
+      keyframes: transformModel.scale,
       value: { scale in
         // 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
@@ -207,7 +207,7 @@ extension CALayer {
 
       try addAnimation(
         for: .rotationY,
-        keyframes: transformModel.scale.keyframes,
+        keyframes: transformModel.scale,
         value: { scale in
           if scale.x < 0 {
             return .pi
@@ -220,7 +220,7 @@ extension CALayer {
 
     try addAnimation(
       for: .scaleY,
-      keyframes: transformModel.scale.keyframes,
+      keyframes: transformModel.scale,
       value: { scale in
         // 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
@@ -263,7 +263,7 @@ extension CALayer {
 
     try addAnimation(
       for: .rotationX,
-      keyframes: transformModel.rotationX.keyframes,
+      keyframes: transformModel.rotationX,
       value: { rotationDegrees in
         rotationDegrees.cgFloatValue * .pi / 180
       },
@@ -271,7 +271,7 @@ extension CALayer {
 
     try addAnimation(
       for: .rotationY,
-      keyframes: transformModel.rotationY.keyframes,
+      keyframes: transformModel.rotationY,
       value: { rotationDegrees in
         rotationDegrees.cgFloatValue * .pi / 180
       },
@@ -279,7 +279,7 @@ extension CALayer {
 
     try addAnimation(
       for: .rotationZ,
-      keyframes: transformModel.rotationZ.keyframes,
+      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
@@ -321,7 +321,7 @@ extension CALayer {
 
     try addAnimation(
       for: .transform,
-      keyframes: combinedTransformKeyframes.keyframes,
+      keyframes: combinedTransformKeyframes,
       value: { $0 },
       context: context)
   }

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/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

@@ -48,22 +48,20 @@ 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 contentsLayer.addTransformAnimations(for: baseLayerModel.transform, context: context)
+    try contentsLayer.addTransformAnimations(for: baseLayerModel.transform, context: transformContext)
 
     if renderLayerContents {
-      try contentsLayer.addOpacityAnimation(for: baseLayerModel.transform, context: context)
+      try contentsLayer.addOpacityAnimation(for: baseLayerModel.transform, context: transformContext)
 
       contentsLayer.addVisibilityAnimation(
         inFrame: CGFloat(baseLayerModel.inFrame),

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
   }