lottie-ios 3.4.0 → 3.4.3

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

@@ -55,8 +55,13 @@ final class ShapeItemLayer: BaseAnimationLayer {
     /// A `ShapeItem` that should be rendered by this layer
     let item: ShapeItem
 
-    /// The group that contains this `ShapeItem`, if applicable
-    let parentGroup: Group?
+    /// The set of groups that this item descends from
+    ///  - Due to the way `GroupLayer`s are setup, the original `ShapeItem`
+    ///    hierarchy from the `ShapeLayer` data model may no longer exactly
+    ///    match the hierarchy of `GroupLayer` / `ShapeItemLayer`s constructed
+    ///    at runtime. Since animation keypaths need to match the original
+    ///    structure of the `ShapeLayer` data model, we track that info here.
+    let groupPath: [String]
   }
 
   override func setupAnimations(context: LayerAnimationContext) throws {
@@ -69,27 +74,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 +117,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 +146,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 +182,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(
@@ -178,6 +208,13 @@ final class ShapeItemLayer: BaseAnimationLayer {
     var trimPathMultiplier: PathMultiplier? = nil
     if let (trim, context) = otherItems.first(Trim.self, context: context) {
       trimPathMultiplier = try shapeLayer.addAnimations(for: trim, context: context)
+
+      try context.compatibilityAssert(
+        otherItems.first(Fill.self) == nil,
+        """
+        The Core Animation rendering engine doesn't currently support applying
+        trims to filled shapes (only stroked shapes).
+        """)
     }
 
     try shapeLayer.addAnimations(for: shape.item, context: context.for(shape), pathMultiplier: trimPathMultiplier ?? 1)
@@ -192,34 +229,42 @@ 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)
+      layers.shapeMaskLayer.fillRule = gradientFill.fillRule.caFillRule
+      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 +286,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 {
@@ -249,8 +305,8 @@ extension LayerAnimationContext {
   func `for`(_ item: ShapeItemLayer.Item) -> LayerAnimationContext {
     var context = self
 
-    if let group = item.parentGroup {
-      context.currentKeypath.keys.append(group.name)
+    for parentGroupName in item.groupPath {
+      context.currentKeypath.keys.append(parentGroupName)
     }
 
     context.currentKeypath.keys.append(item.item.name)

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

@@ -13,7 +13,7 @@ final class ShapeLayer: BaseCompositionLayer {
   init(shapeLayer: ShapeLayerModel, context: LayerContext) throws {
     self.shapeLayer = shapeLayer
     super.init(layerModel: shapeLayer)
-    try setupGroups(from: shapeLayer.items, parentGroup: nil, context: context)
+    try setUpGroups(context: context)
   }
 
   required init?(coder _: NSCoder) {
@@ -35,6 +35,28 @@ final class ShapeLayer: BaseCompositionLayer {
 
   private let shapeLayer: ShapeLayerModel
 
+  private func setUpGroups(context: LayerContext) throws {
+    // If the layer has a `Repeater`, the `Group`s are duplicated and offset
+    // based on the copy count of the repeater.
+    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)
+    }
+  }
+
+  private func setUpRepeater(_ repeater: Repeater, context: LayerContext) throws {
+    let items = shapeLayer.items.filter { !($0 is Repeater) }
+    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 repeatedLayer = RepeaterLayer(repeater: repeater, childLayer: groupLayer, index: index)
+        addSublayer(repeatedLayer)
+      }
+    }
+  }
+
 }
 
 // MARK: - GroupLayer
@@ -44,9 +66,10 @@ final class GroupLayer: BaseAnimationLayer {
 
   // MARK: Lifecycle
 
-  init(group: Group, inheritedItems: [ShapeItemLayer.Item], context: LayerContext) throws {
+  init(group: Group, items: [ShapeItemLayer.Item], groupPath: [String], context: LayerContext) throws {
     self.group = group
-    self.inheritedItems = inheritedItems
+    self.items = items
+    self.groupPath = groupPath
     super.init()
     try setupLayerHierarchy(context: context)
   }
@@ -63,7 +86,8 @@ final class GroupLayer: BaseAnimationLayer {
     }
 
     group = typedLayer.group
-    inheritedItems = typedLayer.inheritedItems
+    items = typedLayer.items
+    groupPath = typedLayer.groupPath
     super.init(layer: typedLayer)
   }
 
@@ -82,46 +106,62 @@ final class GroupLayer: BaseAnimationLayer {
 
   private let group: Group
 
-  /// `ShapeItem`s that were listed in the parent's `items: [ShapeItem]` array
-  ///   - This layer's parent is either the root `ShapeLayerModel` or some other `Group`
-  private let inheritedItems: [ShapeItemLayer.Item]
+  /// `ShapeItemLayer.Item`s rendered by this `Group`
+  ///  - In the original `ShapeLayer` data model, these items could have originated from a different group
+  private let items: [ShapeItemLayer.Item]
+
+  /// The keypath that represents this group, with respect to the parent `ShapeLayer`
+  ///  - Due to the way `GroupLayer`s are setup, the original `ShapeItem`
+  ///    hierarchy from the `ShapeLayer` data model may no longer exactly
+  ///    match the hierarchy of `GroupLayer` / `ShapeItemLayer`s constructed
+  ///    at runtime. Since animation keypaths need to match the original
+  ///    structure of the `ShapeLayer` data model, we track that info here.
+  private let groupPath: [String]
 
-  /// `ShapeItem`s (other than nested `Group`s) that are included in this group
-  private lazy var nonGroupItems = group.items
-    .filter { !($0 is Group) }
-    .map { ShapeItemLayer.Item(item: $0, parentGroup: group) }
-    + inheritedItems
+  /// `ShapeItem`s (other than nested `Group`s) that are rendered by this layer
+  private lazy var nonGroupItems = items.filter { !($0.item is Group) }
 
   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, context: context)
+    try setupGroups(from: group.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
     for shapeRenderGroup in nonGroupItems.shapeRenderGroups.reversed() {
-      // If all of the path-drawing `ShapeItem`s have keyframes with the same timing information,
-      // we can combine the `[KeyframeGroup<BezierPath>]` (which have to animate in separate layers)
-      // into a single `KeyframeGroup<[BezierPath]>`, which can be combined into a single CGPath animation.
-      //
-      // This is how Groups with multiple path-drawing items are supposed to be rendered,
-      // 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.
+      // When there are multiple path-drawing items, they're supposed to be rendered
+      // in a single `CAShapeLayer` (instead of rendering them in separate layers) so
+      // `CAShapeLayerFillRule.evenOdd` can be applied correctly if the paths overlap.
+      // Since a `CAShapeLayer` only supports animating a single `CGPath` from a single `KeyframeGroup<BezierPath>`,
+      // this requires combining all of the path-drawing items into a single set of keyframes.
       if
         shapeRenderGroup.pathItems.count > 1,
-        let combinedShapeKeyframes = Keyframes.combinedIfPossible(
-          shapeRenderGroup.pathItems.map { ($0.item as? Shape)?.path }),
+        // We currently only support this codepath for `Shape` items that directly contain bezier path keyframes.
+        // We could also support this for other path types like rectangles, ellipses, and polygons with more work.
+        shapeRenderGroup.pathItems.allSatisfy({ $0.item is Shape }),
         // `Trim`s are currently only applied correctly using individual `ShapeItemLayer`s,
         // because each path has to be trimmed separately.
         !shapeRenderGroup.otherItems.contains(where: { $0.item is Trim })
       {
-        let combinedShape = CombinedShapeItem(
-          shapes: combinedShapeKeyframes,
-          name: group.name)
+        let allPathKeyframes = shapeRenderGroup.pathItems.compactMap { ($0.item as? Shape)?.path }
+        let combinedShape: CombinedShapeItem
+
+        // If all of the path-drawing `ShapeItem`s have keyframes with the same timing information,
+        // we can combine the `[KeyframeGroup<BezierPath>]` (which have to animate in separate layers)
+        // into a single `KeyframeGroup<[BezierPath]>`, which can be combined into a single CGPath animation.
+        if let combinedShapeKeyframes = Keyframes.combinedIfPossible(allPathKeyframes) {
+          combinedShape = CombinedShapeItem(shapes: combinedShapeKeyframes, name: group.name)
+        }
+
+        // Otherwise, in order for the path fills to be rendered correctly, we have to manually
+        // interpolate the path for each shape at each frame ahead of time so we can combine them
+        // into a single set of bezier path keyframes.
+        else {
+          combinedShape = .manuallyInterpolating(shapes: allPathKeyframes, name: group.name, context: context)
+        }
 
         let sublayer = try ShapeItemLayer(
-          shape: ShapeItemLayer.Item(item: combinedShape, parentGroup: group),
+          shape: ShapeItemLayer.Item(item: combinedShape, groupPath: shapeRenderGroup.pathItems[0].groupPath),
           otherItems: shapeRenderGroup.otherItems,
           context: context)
 
@@ -129,7 +169,8 @@ final class GroupLayer: BaseAnimationLayer {
       }
 
       // Otherwise, if each `ShapeItem` that draws a `GGPath` animates independently,
-      // we have to create a separate `ShapeItemLayer` for each one.
+      // we have to create a separate `ShapeItemLayer` for each one. This may render
+      // incorrectly if there are multiple paths that overlap with each other.
       else {
         for pathDrawingItem in shapeRenderGroup.pathItems {
           let sublayer = try ShapeItemLayer(
@@ -149,34 +190,78 @@ extension CALayer {
   /// Sets up `GroupLayer`s for each `Group` in the given list of `ShapeItem`s
   ///  - 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 })
+  fileprivate func setupGroups(
+    from items: [ShapeItem],
+    parentGroup: Group?,
+    parentGroupPath: [String],
+    context: LayerContext) throws
+  {
+    let groupLayers = try makeGroupLayers(
+      from: items,
+      parentGroup: parentGroup,
+      parentGroupPath: parentGroupPath,
+      context: context)
+
+    for groupLayer in groupLayers {
+      addSublayer(groupLayer)
+    }
+  }
+
+  /// Creates a `GroupLayer` for each `Group` in the given list of `ShapeItem`s
+  ///  - Each `Group` item becomes its own `GroupLayer` sublayer.
+  ///  - Other `ShapeItem` are applied to all sublayers
+  fileprivate func makeGroupLayers(
+    from items: [ShapeItem],
+    parentGroup: Group?,
+    parentGroupPath: [String],
+    context: LayerContext) throws
+    -> [GroupLayer]
+  {
+    var (groupItems, otherItems) = items
+      .filter { !$0.hidden }
+      .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: "")]
+      otherItems = []
+    }
+
+    // `ShapeItem`s either draw a path, or modify how a path is rendered.
+    //  - If this group doesn't have any items that draw a path, then its
+    //    items are applied to all of this group's children.
+    let inheritedItemsForChildGroups: [ShapeItemLayer.Item]
+    if !otherItems.contains(where: { $0.drawsCGPath }) {
+      inheritedItemsForChildGroups = otherItems.map {
+        ShapeItemLayer.Item(item: $0, groupPath: parentGroupPath)
+      }
+    } else {
+      inheritedItemsForChildGroups = []
+    }
 
     // Groups are listed from front to back,
     // but `CALayer.sublayers` are listed from back to front.
     let groupsInZAxisOrder = groupItems.reversed()
 
-    for group in groupsInZAxisOrder {
-      guard let group = group as? Group else { continue }
+    return try groupsInZAxisOrder.compactMap { group in
+      guard let group = group as? Group else { return nil }
 
-      // `ShapeItem`s either draw a path, or modify how a path is rendered.
-      //  - If this group doesn't have any items that draw a path, then its
-      //    items are applied to all of this groups children.
-      let inheritedItems: [ShapeItemLayer.Item]
-      if !otherItems.contains(where: { $0.drawsCGPath }) {
-        inheritedItems = otherItems.map {
-          ShapeItemLayer.Item(item: $0, parentGroup: parentGroup)
-        }
-      } else {
-        inheritedItems = []
+      var pathForChildren = parentGroupPath
+      if !group.name.isEmpty {
+        pathForChildren.append(group.name)
       }
 
-      let groupLayer = try GroupLayer(
+      let childItems = group.items
+        .filter { !$0.hidden }
+        .map { ShapeItemLayer.Item(item: $0, groupPath: pathForChildren) }
+
+      return try GroupLayer(
         group: group,
-        inheritedItems: inheritedItems,
+        items: childItems + inheritedItemsForChildGroups,
+        groupPath: pathForChildren,
         context: context)
-
-      addSublayer(groupLayer)
     }
   }
 }

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

@@ -36,12 +36,27 @@ final class TextLayer: BaseCompositionLayer {
 
   // MARK: Internal
 
+  override func setupAnimations(context: LayerAnimationContext) throws {
+    try super.setupAnimations(context: context)
+    let textAnimationContext = context.addingKeypathComponent(textLayerModel.name)
+
+    let sourceText = try textLayerModel.text.exactlyOneKeyframe(
+      context: textAnimationContext,
+      description: "text layer text")
+
+    renderLayer.text = context.textProvider.textFor(
+      keypathName: textAnimationContext.currentKeypath.fullPath,
+      sourceText: sourceText.text)
+
+    renderLayer.sizeToFit()
+  }
+
   func configureRenderLayer(with context: LayerContext) throws {
     // We can't use `CATextLayer`, because it doesn't support enough features we use.
     // Instead, we use the same `CoreTextRenderLayer` (with a custom `draw` implementation)
     // used by the Main Thread rendering engine. This means the Core Animation engine can't
     // _animate_ text properties, but it can display static text without any issues.
-    let text = try textLayerModel.text.exactlyOneKeyframe(context: context, description: "text layer text").value
+    let text = try textLayerModel.text.exactlyOneKeyframe(context: context, description: "text layer text")
 
     // The Core Animation engine doesn't currently support `TextAnimator`s.
     //  - We could add support for animating the transform-related properties without much trouble.
@@ -54,7 +69,6 @@ final class TextLayer: BaseCompositionLayer {
         """)
     }
 
-    renderLayer.text = text.text
     renderLayer.font = context.fontProvider.fontFor(family: text.fontFamily, size: CGFloat(text.fontSize))
 
     renderLayer.alignment = text.justification.textAlignment

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

@@ -17,7 +17,7 @@ class CompositionLayer: CALayer, KeypathSearchable {
 
   init(layer: LayerModel, size: CGSize) {
     transformNode = LayerTransformNode(transform: layer.transform)
-    if let masks = layer.masks {
+    if let masks = layer.masks?.filter({ $0.mode != .none }), !masks.isEmpty {
       maskLayer = MaskContainerLayer(masks: masks)
     } else {
       maskLayer = nil

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

@@ -151,6 +151,16 @@ final class CoreTextRenderLayer: CALayer {
       strokeFrame = nil
     }
 
+    // This fixes a vertical padding issue that arises when drawing some fonts.
+    // For some reason some fonts, such as Helvetica draw with and ascender that is greater than the one reported by CTFontGetAscender.
+    // I suspect this is actually an issue with the Attributed string, but cannot reproduce.
+
+    if let fillFrame = fillFrame {
+      ctx.adjustWithLineOrigins(in: fillFrame, with: font)
+    } else if let strokeFrame = strokeFrame {
+      ctx.adjustWithLineOrigins(in: strokeFrame, with: font)
+    }
+
     if !strokeOnTop, let strokeFrame = strokeFrame {
       CTFrameDraw(strokeFrame, ctx)
     }
@@ -311,10 +321,29 @@ 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
     }
   }
 
 }
+
+extension CGContext {
+
+  fileprivate func adjustWithLineOrigins(in frame: CTFrame, with font: CTFont?) {
+    guard let font = font else { return }
+
+    let count = CFArrayGetCount(CTFrameGetLines(frame))
+
+    guard count > 0 else { return }
+
+    var o = [CGPoint](repeating: .zero, count: 1)
+    CTFrameGetLineOrigins(frame, CFRange(location: count - 1, length: 1), &o)
+
+    let diff = CTFontGetDescent(font) - o[0].y
+    if diff > 0 {
+      translateBy(x: 0, y: diff)
+    }
+  }
+}

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

@@ -42,6 +42,7 @@ final class InvertedMatteLayer: CALayer, CompositionLayerDelegate {
   let wrapperLayer = CALayer()
 
   func frameUpdated(frame _: CGFloat) {
+    setNeedsDisplay()
     displayIfNeeded()
   }
 

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