lottie-ios 3.4.0 → 3.4.1

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

@@ -7,17 +7,29 @@ enum Keyframes {
   /// Combines the given `[KeyframeGroup]` of `Keyframe<T>`s
   /// into a single `KeyframeGroup` of `Keyframe<[T]>`s
   /// if all of the `KeyframeGroup`s have the exact same animation timing
-  static func combinedIfPossible<T>(_ groups: [KeyframeGroup<T>]) -> KeyframeGroup<[T]>? {
+  static func combinedIfPossible<T>(_ allGroups: [KeyframeGroup<T>]) -> KeyframeGroup<[T]>? {
+    // Animations with no timing information (e.g. with just a single keyframe)
+    // can be trivially combined with any other set of keyframes, so we don't need
+    // to check those.
+    let animatingKeyframes = allGroups.filter { $0.keyframes.count > 1 }
+
     guard
-      !groups.isEmpty,
-      groups.allSatisfy({ $0.hasSameTimingParameters(as: groups[0]) })
+      !allGroups.isEmpty,
+      animatingKeyframes.allSatisfy({ $0.hasSameTimingParameters(as: animatingKeyframes[0]) })
     else { return nil }
 
     var combinedKeyframes = ContiguousArray<Keyframe<[T]>>()
+    let baseKeyframes = (animatingKeyframes.first ?? allGroups[0]).keyframes
 
-    for index in groups[0].keyframes.indices {
-      let baseKeyframe = groups[0].keyframes[index]
-      let combinedValues = groups.map { $0.keyframes[index].value }
+    for index in baseKeyframes.indices {
+      let baseKeyframe = baseKeyframes[index]
+      let combinedValues = allGroups.map { otherKeyframes -> T in
+        if otherKeyframes.keyframes.count == 1 {
+          return otherKeyframes.keyframes[0].value
+        } else {
+          return otherKeyframes.keyframes[index].value
+        }
+      }
       combinedKeyframes.append(baseKeyframe.withValue(combinedValues))
     }
 

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

@@ -63,6 +63,12 @@ struct LayerAnimationContext {
     animation.progressTime(forFrame: timeRemapping(frame), clamped: false)
   }
 
+  /// The real-time `TimeInterval` for the given `AnimationFrameTime` within this layer,
+  /// accounting for the `timeRemapping` applied to this layer
+  func time(for frame: AnimationFrameTime) -> TimeInterval {
+    animation.time(forFrame: timeRemapping(frame))
+  }
+
   /// Chains an additional `timeRemapping` closure onto this layer context
   func withTimeRemapping(
     _ additionalTimeRemapping: @escaping (AnimationFrameTime) -> AnimationFrameTime)

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

@@ -70,9 +70,12 @@ final class GradientRenderLayer: CAGradientLayer {
       width: gradientPadding + gradientReferenceBounds.width + gradientPadding,
       height: gradientPadding + gradientReferenceBounds.height + gradientPadding)
 
+    // Align the center of this layer to be at the center point of its parent layer
+    let superlayerSize = superlayer?.frame.size ?? gradientReferenceBounds.size
+
     transform = CATransform3DMakeTranslation(
-      -gradientPadding,
-      -gradientPadding,
+      (superlayerSize.width - bounds.width) / 2,
+      (superlayerSize.height - bounds.height) / 2,
       0)
   }
 
@@ -83,5 +86,9 @@ final class GradientRenderLayer: CAGradientLayer {
 extension GradientRenderLayer: CustomLayoutLayer {
   func layout(superlayerBounds: CGRect) {
     gradientReferenceBounds = superlayerBounds
+
+    if let gradientMask = mask as? GradientRenderLayer {
+      gradientMask.layout(superlayerBounds: superlayerBounds)
+    }
   }
 }

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

@@ -69,27 +69,24 @@ final class ShapeItemLayer: BaseAnimationLayer {
       try setupSolidFillAnimations(shapeLayer: shapeLayer, context: context)
 
     case .gradientFill(let gradientLayers):
-      try setupGradientFillAnimations(
-        gradientLayer: gradientLayers.gradientLayer,
-        maskLayer: gradientLayers.maskLayer,
-        context: context)
+      try setupGradientFillAnimations(layers: gradientLayers, context: context)
     }
 
     if let gradientStrokeConfiguration = sublayerConfiguration.gradientStroke {
-      try setupGradientStrokeAnimations(
-        gradientLayer: gradientStrokeConfiguration.gradientLayer,
-        maskLayer: gradientStrokeConfiguration.maskLayer,
-        context: context)
+      try setupGradientStrokeAnimations(layers: gradientStrokeConfiguration, context: context)
     }
   }
 
   // MARK: Private
 
   private struct GradientLayers {
-    /// The `CALayer` that renders the actual gradient
-    let gradientLayer: GradientRenderLayer
-    /// The `CAShapeLayer` that clips the gradient layer to the expected shape
-    let maskLayer: CAShapeLayer
+    /// The `CALayer` that renders the RGB components of the gradient
+    let gradientColorLayer: GradientRenderLayer
+    /// The `CALayer` that renders the alpha components of the gradient,
+    /// masking the `gradientColorLayer`
+    let gradientAlphaLayer: GradientRenderLayer?
+    /// The `CAShapeLayer` that clips the gradient layers to the expected shape
+    let shapeMaskLayer: CAShapeLayer
   }
 
   /// The configuration of this layer's `fill` sublayers
@@ -115,15 +112,15 @@ final class ShapeItemLayer: BaseAnimationLayer {
     // we're rendering a gradient (a `CAGradientLayer` masked by a `CAShapeLayer`)
     // or a solid shape (a simple `CAShapeLayer`).
     let fillLayerConfiguration: FillLayerConfiguration
-    if otherItems.contains(where: { $0.item is GradientFill }) {
-      fillLayerConfiguration = setupGradientFillLayerHierarchy()
+    if let gradientFill = otherItems.first(GradientFill.self) {
+      fillLayerConfiguration = setupGradientFillLayerHierarchy(for: gradientFill)
     } else {
       fillLayerConfiguration = setupSolidFillLayerHierarchy()
     }
 
     let gradientStrokeConfiguration: GradientLayers?
-    if otherItems.contains(where: { $0.item is GradientStroke }) {
-      gradientStrokeConfiguration = setupGradientStrokeLayerHierarchy()
+    if let gradientStroke = otherItems.first(GradientStroke.self) {
+      gradientStrokeConfiguration = setupGradientStrokeLayerHierarchy(for: gradientStroke)
     } else {
       gradientStrokeConfiguration = nil
     }
@@ -144,18 +141,35 @@ final class ShapeItemLayer: BaseAnimationLayer {
     return .solidFill(shapeLayer)
   }
 
-  private func setupGradientFillLayerHierarchy() -> FillLayerConfiguration {
+  private func setupGradientFillLayerHierarchy(
+    for gradientFill: GradientFill)
+    -> FillLayerConfiguration
+  {
     let pathMask = CAShapeLayer()
     pathMask.fillColor = .rgb(0, 0, 0)
     mask = pathMask
 
-    let gradientLayer = GradientRenderLayer()
-    addSublayer(gradientLayer)
+    let rgbGradientLayer = GradientRenderLayer()
+    addSublayer(rgbGradientLayer)
 
-    return .gradientFill(.init(gradientLayer: gradientLayer, maskLayer: pathMask))
+    let alphaGradientLayer: GradientRenderLayer?
+    if gradientFill.hasAlphaComponent {
+      alphaGradientLayer = GradientRenderLayer()
+      rgbGradientLayer.mask = alphaGradientLayer
+    } else {
+      alphaGradientLayer = nil
+    }
+
+    return .gradientFill(GradientLayers(
+      gradientColorLayer: rgbGradientLayer,
+      gradientAlphaLayer: alphaGradientLayer,
+      shapeMaskLayer: pathMask))
   }
 
-  private func setupGradientStrokeLayerHierarchy() -> GradientLayers {
+  private func setupGradientStrokeLayerHierarchy(
+    for gradientStroke: GradientStroke)
+    -> GradientLayers
+  {
     let container = BaseAnimationLayer()
 
     let pathMask = CAShapeLayer()
@@ -163,11 +177,22 @@ final class ShapeItemLayer: BaseAnimationLayer {
     pathMask.strokeColor = .rgb(0, 0, 0)
     container.mask = pathMask
 
-    let gradientLayer = GradientRenderLayer()
-    container.addSublayer(gradientLayer)
+    let rgbGradientLayer = GradientRenderLayer()
+    container.addSublayer(rgbGradientLayer)
     addSublayer(container)
 
-    return .init(gradientLayer: gradientLayer, maskLayer: pathMask)
+    let alphaGradientLayer: GradientRenderLayer?
+    if gradientStroke.hasAlphaComponent {
+      alphaGradientLayer = GradientRenderLayer()
+      rgbGradientLayer.mask = alphaGradientLayer
+    } else {
+      alphaGradientLayer = nil
+    }
+
+    return GradientLayers(
+      gradientColorLayer: rgbGradientLayer,
+      gradientAlphaLayer: alphaGradientLayer,
+      shapeMaskLayer: pathMask)
   }
 
   private func setupSolidFillAnimations(
@@ -192,34 +217,41 @@ final class ShapeItemLayer: BaseAnimationLayer {
   }
 
   private func setupGradientFillAnimations(
-    gradientLayer: GradientRenderLayer,
-    maskLayer: CAShapeLayer,
+    layers: GradientLayers,
     context: LayerAnimationContext)
     throws
   {
-    try maskLayer.addAnimations(for: shape.item, context: context.for(shape), pathMultiplier: 1)
+    try layers.shapeMaskLayer.addAnimations(
+      for: shape.item,
+      context: context.for(shape),
+      pathMultiplier: 1)
 
     if let (gradientFill, context) = otherItems.first(GradientFill.self, context: context) {
-      try gradientLayer.addGradientAnimations(for: gradientFill, context: context)
+      try layers.gradientColorLayer.addGradientAnimations(for: gradientFill, type: .rgb, context: context)
+      try layers.gradientAlphaLayer?.addGradientAnimations(for: gradientFill, type: .alpha, context: context)
     }
   }
 
   private func setupGradientStrokeAnimations(
-    gradientLayer: GradientRenderLayer,
-    maskLayer: CAShapeLayer,
+    layers: GradientLayers,
     context: LayerAnimationContext)
     throws
   {
     var trimPathMultiplier: PathMultiplier? = nil
     if let (trim, context) = otherItems.first(Trim.self, context: context) {
-      trimPathMultiplier = try maskLayer.addAnimations(for: trim, context: context)
+      trimPathMultiplier = try layers.shapeMaskLayer.addAnimations(for: trim, context: context)
     }
 
-    try maskLayer.addAnimations(for: shape.item, context: context.for(shape), pathMultiplier: trimPathMultiplier ?? 1)
+    try layers.shapeMaskLayer.addAnimations(
+      for: shape.item,
+      context: context.for(shape),
+      pathMultiplier: trimPathMultiplier ?? 1)
 
     if let (gradientStroke, context) = otherItems.first(GradientStroke.self, context: context) {
-      try gradientLayer.addGradientAnimations(for: gradientStroke, context: context)
-      try maskLayer.addStrokeAnimations(for: gradientStroke, context: context)
+      try layers.gradientColorLayer.addGradientAnimations(for: gradientStroke, type: .rgb, context: context)
+      try layers.gradientAlphaLayer?.addGradientAnimations(for: gradientStroke, type: .alpha, context: context)
+
+      try layers.shapeMaskLayer.addStrokeAnimations(for: gradientStroke, context: context)
     }
   }
 
@@ -241,6 +273,17 @@ extension Array where Element == ShapeItemLayer.Item {
 
     return nil
   }
+
+  /// The first `ShapeItem` in this array of the given type
+  func first<ItemType: ShapeItem>(_: ItemType.Type) -> ItemType? {
+    for item in self {
+      if let match = item.item as? ItemType {
+        return match
+      }
+    }
+
+    return nil
+  }
 }
 
 extension LayerAnimationContext {

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

@@ -108,6 +108,12 @@ final class GroupLayer: BaseAnimationLayer {
       // because combining multiple paths into a single `CGPath` (instead of rendering them in separate layers)
       // allows `CAShapeLayerFillRule.evenOdd` to be applied if the paths overlap. We just can't do this
       // in all cases, due to limitations of Core Animation.
+      //
+      // As a fall back when this is not possible, we render each shape in its own `CAShapeLayer`,
+      // which causes the `fillRule` to be applied incorrectly in cases where the paths overlap.
+      // We can't really detect when this happens, so this is a case where `RenderingEngineMode.automatic`
+      // can behave incorrectly. In the future we could fix this by precomputing the full combined CGPath for each
+      // individual frame in the animation (like we do for some trim animations as of #1612).
       if
         shapeRenderGroup.pathItems.count > 1,
         let combinedShapeKeyframes = Keyframes.combinedIfPossible(
@@ -150,7 +156,15 @@ extension CALayer {
   ///  - Each `Group` item becomes its own `GroupLayer` sublayer.
   ///  - Other `ShapeItem` are applied to all sublayers
   fileprivate func setupGroups(from items: [ShapeItem], parentGroup: Group?, context: LayerContext) throws {
-    let (groupItems, otherItems) = items.grouped(by: { $0 is Group })
+    var (groupItems, otherItems) = items.grouped(by: { $0 is Group })
+
+    // If this shape doesn't have any groups but just has top-level shape items,
+    // we can create a placeholder group with those items. (Otherwise the shape items
+    // would be silently ignored, since we expect all shape layers to have a top-level group).
+    if groupItems.isEmpty, parentGroup == nil {
+      groupItems = [Group(items: otherItems, name: "Group")]
+      otherItems = []
+    }
 
     // Groups are listed from front to back,
     // but `CALayer.sublayers` are listed from back to front.

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

@@ -109,7 +109,6 @@ private class MaskLayer: CALayer {
     actions = [
       "opacity" : NSNull(),
     ]
-
   }
 
   override init(layer: Any) {
@@ -152,7 +151,6 @@ private class MaskLayer: CALayer {
       }
       maskLayer.path = path
     }
-
   }
 }
 

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

@@ -107,12 +107,12 @@ final class PreCompositionLayer: CompositionLayer {
     } else {
       localFrame = (frame - startFrame) / timeStretch
     }
-    animationLayers.forEach( { $0.displayWithFrame(frame: localFrame, forceUpdates: forceUpdates) })
+    animationLayers.forEach({ $0.displayWithFrame(frame: localFrame, forceUpdates: forceUpdates) })
   }
 
   override func updateRenderScale() {
     super.updateRenderScale()
-    animationLayers.forEach( { $0.renderScale = renderScale } )
+    animationLayers.forEach({ $0.renderScale = renderScale })
   }
 
   // MARK: Fileprivate

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

@@ -93,7 +93,6 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
     super.init(layer: layer)
 
     currentFrame = typedLayer.currentFrame
-
   }
 
   required init?(coder _: NSCoder) {
@@ -195,7 +194,7 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
 
   /// Forces the view to update its drawing.
   func forceDisplayUpdate() {
-    animationLayers.forEach( { $0.displayWithFrame(frame: currentFrame, forceUpdates: true) })
+    animationLayers.forEach({ $0.displayWithFrame(frame: currentFrame, forceUpdates: true) })
   }
 
   func logHierarchyKeypaths() {

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

@@ -311,7 +311,7 @@ final class CoreTextRenderLayer: CALayer {
       x: textAnchor.x.remap(fromLow: 0, fromHigh: drawingRect.size.width, toLow: 0, toHigh: 1),
       y: textAnchor.y.remap(fromLow: 0, fromHigh: drawingRect.size.height, toLow: 0, toHigh: 1))
 
-    if fillFrameSetter != nil && strokeFrameSetter != nil {
+    if fillFrameSetter != nil, strokeFrameSetter != nil {
       drawingRect.size.width += strokeWidth
       drawingRect.size.height += strokeWidth
     }

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

@@ -16,7 +16,6 @@ final class LayerTransformProperties: NodePropertyMap, KeypathSearchable {
   // MARK: Lifecycle
 
   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))

package/Sources/Private/MainThread/NodeRenderSystem/Extensions/ItemsExtension.swift

@@ -19,7 +19,6 @@ final class NodeTree {
 
 extension Array where Element == ShapeItem {
   func initializeNodeTree() -> NodeTree {
-
     let nodeTree = NodeTree()
 
     for item in self {
@@ -73,7 +72,6 @@ extension Array where Element == ShapeItem {
         nodeTree.transform = xform
         continue
       } else if let group = item as? Group {
-
         let tree = group.items.initializeNodeTree()
         let node = GroupNode(name: group.name, parentNode: nodeTree.rootNode, tree: tree)
         nodeTree.rootNode = node

package/Sources/Private/MainThread/NodeRenderSystem/NodeProperties/ValueProviders/KeyframeInterpolator.swift

@@ -149,7 +149,7 @@ final class KeyframeInterpolator<ValueType>: ValueProvider where ValueType: AnyI
 
     /// Sets the initial keyframes. This is often only needed for the first check.
     if
-      leadingIndex == nil &&
+      leadingIndex == nil,
       trailingIndex == nil
     {
       if frame < keyframes[0].time {
@@ -170,7 +170,6 @@ final class KeyframeInterpolator<ValueType>: ValueProvider where ValueType: AnyI
       var newLeading = currentTrailing
       var keyframeFound = false
       while !keyframeFound {
-
         leadingIndex = newLeading
         trailingIndex = keyframes.validIndex(newLeading + 1)
 
@@ -192,13 +191,11 @@ final class KeyframeInterpolator<ValueType>: ValueProvider where ValueType: AnyI
       let currentLeading = leadingIndex,
       frame < keyframes[currentLeading].time
     {
-
       /// Time is before the current span. Iterate backwards
       var newTrailing = currentLeading
 
       var keyframeFound = false
       while !keyframeFound {
-
         leadingIndex = keyframes.validIndex(newTrailing - 1)
         trailingIndex = newTrailing
 

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/ModifierNodes/TrimPathNode.swift

@@ -142,7 +142,6 @@ final class TrimPathNode: AnimatorNode {
 
     /// Now loop through all path containers
     for pathContainer in upstreamPaths {
-
       let pathEnd = pathStart + pathContainer.totalLength
 
       if
@@ -214,11 +213,10 @@ final class TrimPathNode: AnimatorNode {
         let subpaths = pathContainer.removePaths(updateFrame: frame)
         var subpathStart: CGFloat = 0
         for path in subpaths {
-
           let subpathEnd = subpathStart + path.length
 
           if
-            !startCutLength.isInRange(subpathStart, subpathEnd) &&
+            !startCutLength.isInRange(subpathStart, subpathEnd),
             !endCutLength.isInRange(subpathStart, subpathEnd)
           {
             // The whole path is included. Add
@@ -226,7 +224,7 @@ final class TrimPathNode: AnimatorNode {
             pathContainer.appendPath(path, updateFrame: frame)
 
           } else if
-            startCutLength.isInRange(subpathStart, subpathEnd) &&
+            startCutLength.isInRange(subpathStart, subpathEnd),
             !endCutLength.isInRange(subpathStart, subpathEnd)
           {
             /// The start of the path needs to be trimmed
@@ -235,7 +233,7 @@ final class TrimPathNode: AnimatorNode {
             let newPath = path.trim(fromPosition: cutLength / path.length, toPosition: 1, offset: 0, trimSimultaneously: false)
             pathContainer.appendPath(newPath, updateFrame: frame)
           } else if
-            !startCutLength.isInRange(subpathStart, subpathEnd) &&
+            !startCutLength.isInRange(subpathStart, subpathEnd),
             endCutLength.isInRange(subpathStart, subpathEnd)
           {
             // S|=======E----------------------|
@@ -244,7 +242,7 @@ final class TrimPathNode: AnimatorNode {
             pathContainer.appendPath(newPath, updateFrame: frame)
             break
           } else if
-            startCutLength.isInRange(subpathStart, subpathEnd) &&
+            startCutLength.isInRange(subpathStart, subpathEnd),
             endCutLength.isInRange(subpathStart, subpathEnd)
           {
             //  |-------S============E---------|
@@ -272,7 +270,6 @@ final class TrimPathNode: AnimatorNode {
 
       pathStart = pathEnd
     }
-
   }
 
   // MARK: Fileprivate

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientStrokeRenderer.swift

@@ -42,7 +42,7 @@ final class GradientStrokeRenderer: PassThroughOutputNode, Renderable {
   }
 
   func render(_ inContext: CGContext) {
-    guard inContext.path != nil && inContext.path!.isEmpty == false else {
+    guard inContext.path != nil, inContext.path!.isEmpty == false else {
       return
     }
 
@@ -56,7 +56,6 @@ final class GradientStrokeRenderer: PassThroughOutputNode, Renderable {
 
     /// Now draw the gradient.
     gradientRender.render(inContext)
-
   }
 
   func renderBoundsFor(_ boundingBox: CGRect) -> CGRect {

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/LegacyGradientFillRenderer.swift

@@ -58,7 +58,7 @@ final class LegacyGradientFillRenderer: PassThroughOutputNode, Renderable {
   }
 
   func render(_ inContext: CGContext) {
-    guard inContext.path != nil && inContext.path!.isEmpty == false else {
+    guard inContext.path != nil, inContext.path!.isEmpty == false else {
       return
     }
     hasUpdate = false

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/StrokeRenderer.swift

@@ -140,7 +140,7 @@ final class StrokeRenderer: PassThroughOutputNode, Renderable {
   }
 
   func render(_ inContext: CGContext) {
-    guard inContext.path != nil && inContext.path!.isEmpty == false else {
+    guard inContext.path != nil, inContext.path!.isEmpty == false else {
       return
     }
     guard let color = color else { return }

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

@@ -171,7 +171,7 @@ extension BezierPath {
         CurveVertex(
           CGPoint(x: 0, y: radius), // In tangent
           CGPoint(x: 0, y: radius), // Point
-          CGPoint(x: -controlPoint, y: radius))// Out tangent
+          CGPoint(x: -controlPoint, y: radius)) // Out tangent
           .translated(CGPoint(x: radius, y: -radius))
           .translated(CGPoint(x: -size.width, y: size.height))
           .translated(position),

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

@@ -158,17 +158,17 @@ extension BezierPath {
     for i in 0..<numPoints {
       var radius = longSegment ? outerRadius : innerRadius
       var dTheta = halfAnglePerPoint
-      if partialPointRadius != 0 && i == numPoints - 2 {
+      if partialPointRadius != 0, i == numPoints - 2 {
         dTheta = anglePerPoint * partialPointAmount / 2
       }
-      if partialPointRadius != 0 && i == numPoints - 1 {
+      if partialPointRadius != 0, i == numPoints - 1 {
         radius = partialPointRadius
       }
       previousPoint = point
       point.x = (radius * cos(currentAngle))
       point.y = (radius * sin(currentAngle))
 
-      if innerRoundedness == 0 && outerRoundedness == 0 {
+      if innerRoundedness == 0, outerRoundedness == 0 {
         vertices.append(CurveVertex(point: point + position, inTangentRelative: .zero, outTangentRelative: .zero))
       } else {
         let cp1Theta = (atan2(previousPoint.y, previousPoint.x) - CGFloat.pi / 2)

package/Sources/Private/MainThread/NodeRenderSystem/RenderLayers/ShapeContainerLayer.swift

@@ -69,7 +69,7 @@ class ShapeContainerLayer: CALayer {
 
   func updateRenderScale() {
     contentsScale = renderScale
-    renderLayers.forEach( { $0.renderScale = renderScale } )
+    renderLayers.forEach({ $0.renderScale = renderScale })
   }
 
 }

package/Sources/Private/MainThread/NodeRenderSystem/RenderLayers/ShapeRenderLayer.swift

@@ -69,7 +69,6 @@ final class ShapeRenderLayer: ShapeContainerLayer {
   }
 
   override func rebuildContents(forFrame _: CGFloat) {
-
     if renderer.shouldRenderInContext {
       if let newPath = renderer.outputPath {
         bounds = renderer.renderBoundsFor(newPath.boundingBox)

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

@@ -7,7 +7,7 @@
 
 import Foundation
 
-/// An item that define an ellipse shape
+/// An item that define a a group of shape items
 final class Group: ShapeItem {
 
   // MARK: Lifecycle
@@ -24,6 +24,11 @@ final class Group: ShapeItem {
     try super.init(dictionary: dictionary)
   }
 
+  init(items: [ShapeItem], name: String) {
+    self.items = items
+    super.init(name: name, type: .group, hidden: false)
+  }
+
   // MARK: Internal
 
   /// A list of shape items.

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

@@ -26,7 +26,6 @@ final class TextAnimator: Codable, DictionaryInitializable {
     skewAxis = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skewAxis)
     rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation)
     opacity = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-
   }
 
   init(dictionary: [String: Any]) throws {

package/Sources/Private/Utility/Debugging/LayerDebugging.swift

@@ -53,7 +53,7 @@ extension CALayer {
       string = string + "  "
     }
     string = string + "|_" + String(describing: self)
-    print(string)
+    LottieLogger.shared.info(string)
     if let sublayers = sublayers {
       for sublayer in sublayers {
         sublayer.logLayerTree(withIndent: withIndent + 1)
@@ -75,7 +75,6 @@ extension CALayer {
 
   @nonobjc
   func setDebuggingState(visible: Bool) {
-
     var sublayers = self.sublayers
     if let cust = self as? CustomLayerDebugging {
       sublayers = cust.layerForDebugging().sublayers

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

@@ -344,7 +344,6 @@ extension CGPoint {
     var closestPoint = 0
 
     while previousAmount < 1 {
-
       previousAmount = previousAmount + step
 
       if previousAmount < amount {
@@ -429,7 +428,7 @@ extension CGPoint {
   func colinear(_ a: CGPoint, _ b: CGPoint) -> Bool {
     let area = x * (a.y - b.y) + a.x * (b.y - y) + b.x * (y - a.y);
     let accuracy: CGFloat = 0.05
-    if area < accuracy && area > -accuracy {
+    if area < accuracy, area > -accuracy {
       return true
     }
     return false

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

@@ -16,7 +16,6 @@ extension String {
   }
 
   func hexColorComponents() -> (red: CGFloat, green: CGFloat, blue: CGFloat) {
-
     var cString: String = trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
 
     if cString.hasPrefix("#") {

package/Sources/Private/Utility/Interpolatable/InterpolatableExtensions.swift

@@ -14,7 +14,6 @@ extension Color {
 
   /// Initialize a new color with Hue Saturation and Value
   init(h: Double, s: Double, v: Double, a: Double) {
-
     let i = floor(h * 6)
     let f = h * 6 - i
     let p = v * (1 - s);