lottie-ios 3.4.0 → 3.4.1

package/Sources/Private/CoreAnimation/Animations/CALayer+addAnimation.swift

@@ -28,7 +28,8 @@ extension CALayer {
         value: keyframeValueMapping,
         context: context)
     {
-      add(defaultAnimation, timedWith: context)
+      let timedAnimation = defaultAnimation.timed(with: context, for: self)
+      add(timedAnimation, forKey: property.caLayerKeypath)
     }
   }
 
@@ -44,7 +45,7 @@ extension CALayer {
     value keyframeValueMapping: (KeyframeValue) throws -> ValueRepresentation,
     context: LayerAnimationContext)
     throws
-    -> CAPropertyAnimation?
+    -> CAAnimation?
   {
     guard !keyframes.isEmpty else { return nil }
 
@@ -52,39 +53,31 @@ extension CALayer {
     // by applying that value directly to the layer instead of creating
     // a relatively expensive `CAKeyframeAnimation`.
     if keyframes.count == 1 {
-      let keyframeValue = try keyframeValueMapping(keyframes[0].value)
-
-      // If the keyframe value is the same as the layer's default value for this property,
-      // then we can just ignore this set of keyframes.
-      if keyframeValue == property.defaultValue {
-        return nil
-      }
+      return singleKeyframeAnimation(
+        for: property,
+        keyframeValue: try keyframeValueMapping(keyframes[0].value),
+        writeDirectlyToPropertyIfPossible: true)
+    }
 
-      // If the property on the CALayer being animated hasn't been modified from the default yet,
-      // then we can apply the keyframe value directly to the layer using KVC instead
-      // of creating a `CAAnimation`.
-      if
-        let defaultValue = property.defaultValue,
-        defaultValue == value(forKey: property.caLayerKeypath) as? ValueRepresentation
-      {
-        setValue(keyframeValue, forKeyPath: property.caLayerKeypath)
-        return nil
-      }
+    // Split the keyframes into segments with the same `CAAnimationCalculationMode` value
+    //  - Each of these segments will become their own `CAKeyframeAnimation`
+    let animationSegments = keyframes.segmentsSplitByCalculationMode()
 
-      // Otherwise, we still need to create a `CAAnimation`, but we can
-      // create a simple `CABasicAnimation` that is still less expensive
-      // than computing a `CAKeyframeAnimation`.
-      let animation = CABasicAnimation(keyPath: property.caLayerKeypath)
-      animation.fromValue = keyframeValue
-      animation.toValue = keyframeValue
-      return animation
+    // If we only have a single segment, we can just create a single `CAKeyframeAnimation`
+    // instead of wrapping it in a `CAAnimationGroup` -- this reduces allocation overhead a bit.
+    if animationSegments.count == 1 {
+      return try keyframeAnimation(
+        for: property,
+        keyframes: animationSegments[0],
+        value: keyframeValueMapping,
+        context: context)
+    } else {
+      return try animationGroup(
+        for: property,
+        animationSegments: animationSegments,
+        value: keyframeValueMapping,
+        context: context)
     }
-
-    return try keyframeAnimation(
-      for: property,
-      keyframes: keyframes,
-      value: keyframeValueMapping,
-      context: context)
   }
 
   /// A `CAAnimation` that applies the custom value from the `AnyValueProvider`
@@ -106,32 +99,142 @@ extension CALayer {
     else { return nil }
 
     // Since custom animations are overriding an existing animation,
-    // we always have to create a CAKeyframeAnimation for these instead of
-    // letting `defaultAnimation(...)` try to apply the value using KVC.
+    // we always have to create a CAAnimation and can't write directly
+    // to the layer property
+    if
+      customKeyframes.keyframes.count == 1,
+      let singleKeyframeAnimation = singleKeyframeAnimation(
+        for: property,
+        keyframeValue: customKeyframes.keyframes[0].value,
+        writeDirectlyToPropertyIfPossible: false)
+    {
+      return singleKeyframeAnimation
+    }
+
     return try keyframeAnimation(
       for: property,
-      keyframes: customKeyframes.keyframes,
+      keyframes: Array(customKeyframes.keyframes),
       value: { $0 },
       context: context)
   }
 
-  /// Creates a `CAKeyframeAnimation` for the given keyframes
+  /// Creates an animation that applies a single keyframe to this layer property
+  ///  - In many cases this animation can be omitted entirely, and the underlying
+  ///    property can be set directly. In that case, no animation will be created.
+  private func singleKeyframeAnimation<ValueRepresentation>(
+    for property: LayerProperty<ValueRepresentation>,
+    keyframeValue: ValueRepresentation,
+    writeDirectlyToPropertyIfPossible: Bool)
+    -> CABasicAnimation?
+  {
+    if writeDirectlyToPropertyIfPossible {
+      // If the keyframe value is the same as the layer's default value for this property,
+      // then we can just ignore this set of keyframes.
+      if keyframeValue == property.defaultValue {
+        return nil
+      }
+
+      // If the property on the CALayer being animated hasn't been modified from the default yet,
+      // then we can apply the keyframe value directly to the layer using KVC instead
+      // of creating a `CAAnimation`.
+      if
+        let defaultValue = property.defaultValue,
+        defaultValue == value(forKey: property.caLayerKeypath) as? ValueRepresentation
+      {
+        setValue(keyframeValue, forKeyPath: property.caLayerKeypath)
+        return nil
+      }
+    }
+
+    // Otherwise, we still need to create a `CAAnimation`, but we can
+    // create a simple `CABasicAnimation` that is still less expensive
+    // than computing a `CAKeyframeAnimation`.
+    let animation = CABasicAnimation(keyPath: property.caLayerKeypath)
+    animation.fromValue = keyframeValue
+    animation.toValue = keyframeValue
+    return animation
+  }
+
+  /// Creates a `CAAnimationGroup` that wraps a `CAKeyframeAnimation` for each
+  /// of the given `animationSegments`
+  private func animationGroup<KeyframeValue, ValueRepresentation>(
+    for property: LayerProperty<ValueRepresentation>,
+    animationSegments: [[Keyframe<KeyframeValue>]],
+    value keyframeValueMapping: (KeyframeValue) throws -> ValueRepresentation,
+    context: LayerAnimationContext)
+    throws
+    -> CAAnimationGroup
+  {
+    // Build the `CAKeyframeAnimation` for each segment of keyframes
+    // with the same `CAAnimationCalculationMode`.
+    //  - Here we have a non-zero number of animation segments,
+    //    all of which have a non-zero number of keyframes.
+    let segmentAnimations: [CAKeyframeAnimation] = try animationSegments.indices.map { index in
+      let animationSegment = animationSegments[index]
+      var segmentStartTime = context.time(for: animationSegment.first!.time)
+      var segmentEndTime = context.time(for: animationSegment.last!.time)
+
+      // Every portion of the animation timeline has to be covered by a `CAKeyframeAnimation`,
+      // so if this is the first or last segment then the start/end time should be exactly
+      // the start/end time of the animation itself.
+      let isFirstSegment = (index == animationSegments.indices.first!)
+      let isLastSegment = (index == animationSegments.indices.last!)
+
+      if isFirstSegment {
+        segmentStartTime = context.time(for: context.animation.startFrame)
+      }
+
+      if isLastSegment {
+        segmentEndTime = context.time(for: context.animation.endFrame)
+      }
+
+      let segmentDuration = segmentEndTime - segmentStartTime
+
+      // We're building `CAKeyframeAnimation`s, so the `keyTimes` are expressed
+      // relative to 0 (`segmentStartTime`) and 1 (`segmentEndTime`). This is different
+      // from the default behavior of the `keyframeAnimation` method, where times
+      // are expressed relative to the entire animation duration.
+      let customKeyTimes = animationSegment.map { keyframeModel -> NSNumber in
+        let keyframeTime = context.time(for: keyframeModel.time)
+        let segmentProgressTime = ((keyframeTime - segmentStartTime) / segmentDuration)
+        return segmentProgressTime as NSNumber
+      }
+
+      let animation = try keyframeAnimation(
+        for: property,
+        keyframes: animationSegment,
+        value: keyframeValueMapping,
+        customKeyTimes: customKeyTimes,
+        context: context)
+
+      animation.duration = segmentDuration
+      animation.beginTime = segmentStartTime
+      return animation
+    }
+
+    let fullAnimation = CAAnimationGroup()
+    fullAnimation.animations = segmentAnimations
+    return fullAnimation
+  }
+
+  /// Creates and validates a `CAKeyframeAnimation` for the given keyframes
   private func keyframeAnimation<KeyframeValue, ValueRepresentation>(
     for property: LayerProperty<ValueRepresentation>,
-    keyframes: ContiguousArray<Keyframe<KeyframeValue>>,
+    keyframes: [Keyframe<KeyframeValue>],
     value keyframeValueMapping: (KeyframeValue) throws -> ValueRepresentation,
+    customKeyTimes: [NSNumber]? = nil,
     context: LayerAnimationContext)
     throws
     -> CAKeyframeAnimation
   {
     // Convert the list of `Keyframe<T>` into
     // the representation used by `CAKeyframeAnimation`
-    var keyTimes = keyframes.map { keyframeModel -> NSNumber in
+    var keyTimes = customKeyTimes ?? keyframes.map { keyframeModel -> NSNumber in
       NSNumber(value: Float(context.progressTime(for: keyframeModel.time)))
     }
 
     var timingFunctions = self.timingFunctions(for: keyframes)
-    let calculationMode = try self.calculationMode(for: keyframes, context: context)
+    let calculationMode = self.calculationMode(for: keyframes)
 
     let animation = CAKeyframeAnimation(keyPath: property.caLayerKeypath)
 
@@ -173,37 +276,22 @@ extension CALayer {
   /// The `CAAnimationCalculationMode` that should be used for a `CAKeyframeAnimation`
   /// animating the given keyframes
   private func calculationMode<KeyframeValue>(
-    for keyframes: ContiguousArray<Keyframe<KeyframeValue>>,
-    context: LayerAnimationContext)
-    throws
+    for keyframes: [Keyframe<KeyframeValue>])
     -> CAAnimationCalculationMode
   {
-    // Animations using `isHold` should use `CAAnimationCalculationMode.discrete`
-    //
-    //  - Since we currently only create a single `CAKeyframeAnimation`,
-    //    we can currently only correctly support animations where
-    //    `isHold` is either always `true` or always `false`
-    //    (this requirement doesn't apply to the first/last keyframes).
-    //
-    //  - We should be able to support this in the future by creating multiple
-    //    `CAKeyframeAnimation`s with different `calculationMode`s and
-    //    playing them sequentially.
-    //
-    let intermediateKeyframes = keyframes.dropFirst().dropLast()
-    if intermediateKeyframes.contains(where: \.isHold) {
-      if intermediateKeyframes.allSatisfy(\.isHold) {
-        return .discrete
-      } else {
-        try context.logCompatibilityIssue("Mixed `isHold` / `!isHold` keyframes are currently unsupported")
-      }
+    // At this point we expect all of the animations to have been split in
+    // to segments based on the `CAAnimationCalculationMode`, so we can just
+    // check the first keyframe.
+    if keyframes[0].isHold {
+      return .discrete
+    } else {
+      return .linear
     }
-
-    return .linear
   }
 
   /// `timingFunctions` to apply to a `CAKeyframeAnimation` animating the given keyframes
   private func timingFunctions<KeyframeValue>(
-    for keyframes: ContiguousArray<Keyframe<KeyframeValue>>)
+    for keyframes: [Keyframe<KeyframeValue>])
     -> [CAMediaTimingFunction]
   {
     // Compute the timing function between each keyframe and the subsequent keyframe
@@ -231,9 +319,10 @@ extension CALayer {
   /// Creates a `CGPath` for the given `position` keyframes,
   /// which accounts for `spatialInTangent`s and `spatialOutTangents`
   private func path<KeyframeValue>(
-    keyframes positionKeyframes: ContiguousArray<Keyframe<KeyframeValue>>,
+    keyframes positionKeyframes: [Keyframe<KeyframeValue>],
     value keyframeValueMapping: (KeyframeValue) throws -> CGPoint) rethrows
-    -> CGPath {
+    -> CGPath
+  {
     let path = CGMutablePath()
 
     for (index, keyframe) in positionKeyframes.enumerated() {
@@ -320,3 +409,40 @@ extension CALayer {
   }
 
 }
+
+extension RandomAccessCollection {
+  /// Splits this array of `Keyframe`s into segments with the same `CAAnimationCalculationMode`
+  ///  - Keyframes with `isHold=true` become `discrete`, and keyframes with `isHold=false`
+  ///    become linear. Each `CAKeyframeAnimation` can only be one or the other, so each
+  ///    `calculationModeSegment` becomes its own `CAKeyframeAnimation`.
+  func segmentsSplitByCalculationMode<KeyframeValue>() -> [[Element]]
+    where Element == Keyframe<KeyframeValue>, Index == Int
+  {
+    var segments: [[Element]] = []
+    var currentSegment: [Element] = []
+
+    for keyframe in self {
+      guard let mostRecentKeyframe = currentSegment.last else {
+        currentSegment.append(keyframe)
+        continue
+      }
+
+      // When `isHold` changes between any two given keyframes, we have to create a new segment
+      if keyframe.isHold != mostRecentKeyframe.isHold {
+        // Add this keyframe to both the existing segment that is ending,
+        // so we know how long that segment is, and the new segment,
+        // so we know when that segment starts.
+        currentSegment.append(keyframe)
+        segments.append(currentSegment)
+        currentSegment = [keyframe]
+      }
+
+      else {
+        currentSegment.append(keyframe)
+      }
+    }
+
+    segments.append(currentSegment)
+    return segments
+  }
+}

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

@@ -29,7 +29,13 @@ extension GradientRenderLayer {
   // MARK: Internal
 
   /// Adds gradient-related animations to this layer, from the given `GradientFill`
-  func addGradientAnimations(for gradient: GradientShapeItem, context: LayerAnimationContext) throws {
+  ///  - The RGB components and alpha components can have different color stops / locations,
+  ///    so have to be rendered in separate `CAGradientLayer`s.
+  func addGradientAnimations(
+    for gradient: GradientShapeItem,
+    type: GradientContentType,
+    context: LayerAnimationContext) throws
+  {
     // We have to set `colors` to a non-nil value with some valid number of colors
     // for the color animation below to have any effect
     colors = .init(
@@ -40,7 +46,7 @@ extension GradientRenderLayer {
       for: .colors,
       keyframes: gradient.colors.keyframes,
       value: { colorComponents in
-        try gradient.colorConfiguration(from: colorComponents, context: context).map { $0.color }
+        gradient.colorConfiguration(from: colorComponents, type: type).map { $0.color }
       },
       context: context)
 
@@ -48,7 +54,7 @@ extension GradientRenderLayer {
       for: .locations,
       keyframes: gradient.colors.keyframes,
       value: { colorComponents in
-        try gradient.colorConfiguration(from: colorComponents, context: context).map { $0.location }
+        gradient.colorConfiguration(from: colorComponents, type: type).map { $0.location }
       },
       context: context)
 
@@ -113,55 +119,92 @@ extension GradientRenderLayer {
   }
 }
 
+// MARK: - GradientContentType
+
+/// Each type of gradient that can be constructed from a `GradientShapeItem`
+enum GradientContentType {
+  case rgb
+  case alpha
+}
+
+/// `colors` and `locations` configuration for a `CAGradientLayer`
+typealias GradientColorConfiguration = [(color: CGColor, location: CGFloat)]
+
 extension GradientShapeItem {
+
+  // MARK: Internal
+
+  /// Whether or not this `GradientShapeItem` includes an alpha component
+  /// that has to be rendered as a separate `CAGradientLayer` from the
+  /// layer that renders the rgb color components
+  var hasAlphaComponent: Bool {
+    for colorComponentsKeyframe in colors.keyframes {
+      let colorComponents = colorComponentsKeyframe.value
+      let alphaConfiguration = colorConfiguration(from: colorComponents, type: .alpha)
+
+      let notFullyOpaque = alphaConfiguration.contains(where: { color, _ in
+        color.alpha < 0.999
+      })
+
+      if notFullyOpaque {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  // MARK: Fileprivate
+
   /// Converts the compact `[Double]` color components representation
   /// into an array of `CGColor`s and the location of those colors within the gradient.
   ///  - The color components array is a repeating list of `[location, red, green, blue]` values
   ///    for each color in the gradient, followed by an optional repeating list of
   ///    `[location, alpha]` values that control the colors' alpha values.
+  ///  - The RGB and alpha values can have different color stops / locations,
+  ///    so each has to be rendered in a separate `CAGradientLayer`.
   fileprivate func colorConfiguration(
     from colorComponents: [Double],
-    context: LayerAnimationContext) throws
-    -> [(color: CGColor, location: CGFloat)]
+    type: GradientContentType)
+    -> GradientColorConfiguration
   {
-    precondition(
-      colorComponents.count >= numberOfColors * 4,
-      "Each color must have RGB components and a location component")
+    switch type {
+    case .rgb:
+      precondition(
+        colorComponents.count >= numberOfColors * 4,
+        "Each color must have RGB components and a location component")
 
-    var cgColors = [(color: CGColor, location: CGFloat)]()
+      // Each group of four `Double` values represents a single `CGColor`,
+      // and its relative location within the gradient.
+      var colors = GradientColorConfiguration()
 
-    // Each group of four `Double` values represents a single `CGColor`,
-    // and its relative location within the gradient.
-    for colorIndex in 0..<numberOfColors {
-      let colorStartIndex = colorIndex * 4
+      for colorIndex in 0..<numberOfColors {
+        let colorStartIndex = colorIndex * 4
 
-      let colorLocation = CGFloat(colorComponents[colorStartIndex])
+        let colorLocation = CGFloat(colorComponents[colorStartIndex])
 
-      // Alpha values aren't stored contiguously with the RGB color components,
-      // but are instead optionally listed at the end of the array
-      var alpha = 1.0
-      let alphaIndex = (numberOfColors * 4) + (colorIndex * 2)
-      if alphaIndex < colorComponents.count {
-        let alphaLocation = CGFloat(colorComponents[alphaIndex])
-        if alphaLocation == colorLocation {
-          alpha = colorComponents[alphaIndex + 1]
-        } else {
-          try context.logCompatibilityIssue("""
-            The Core Animation rendering engine currently expects gradient colors and alpha values
-            to be in the same order, with the same color stops / locations.
-            """)
-        }
+        let color = CGColor.rgb(
+          CGFloat(colorComponents[colorStartIndex + 1]),
+          CGFloat(colorComponents[colorStartIndex + 2]),
+          CGFloat(colorComponents[colorStartIndex + 3]))
+
+        colors.append((color: color, location: colorLocation))
       }
 
-      let color = CGColor.rgba(
-        CGFloat(colorComponents[colorStartIndex + 1]),
-        CGFloat(colorComponents[colorStartIndex + 2]),
-        CGFloat(colorComponents[colorStartIndex + 3]),
-        CGFloat(alpha))
+      return colors
 
-      cgColors.append((color, colorLocation))
-    }
+    case .alpha:
+      // After the rgb color components, there can be arbitrary number of repeating
+      // `[alphaLocation, alphaValue]` pairs that define a separate alpha gradient.
+      var alphaValues = GradientColorConfiguration()
+
+      for alphaIndex in stride(from: numberOfColors * 4, to: colorComponents.endIndex, by: 2) {
+        let alphaLocation = CGFloat(colorComponents[alphaIndex])
+        let alphaValue = CGFloat(colorComponents[alphaIndex + 1])
+        alphaValues.append((color: .rgba(0, 0, 0, alphaValue), location: alphaLocation))
+      }
 
-    return cgColors
+      return alphaValues
+    }
   }
 }

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

@@ -58,56 +58,56 @@ extension LayerProperty {
     .init(
       caLayerKeypath: "transform.translation",
       defaultValue: CGPoint(x: 0, y: 0),
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var positionX: LayerProperty<CGFloat> {
     .init(
       caLayerKeypath: "transform.translation.x",
       defaultValue: 0,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var positionY: LayerProperty<CGFloat> {
     .init(
       caLayerKeypath: "transform.translation.y",
       defaultValue: 0,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var scale: LayerProperty<CGFloat> {
     .init(
       caLayerKeypath: "transform.scale",
       defaultValue: 1,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var scaleX: LayerProperty<CGFloat> {
     .init(
       caLayerKeypath: "transform.scale.x",
       defaultValue: 1,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var scaleY: LayerProperty<CGFloat> {
     .init(
       caLayerKeypath: "transform.scale.y",
       defaultValue: 1,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var rotation: LayerProperty<CGFloat> {
     .init(
       caLayerKeypath: "transform.rotation",
       defaultValue: 0,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var rotationY: LayerProperty<CGFloat> {
     .init(
       caLayerKeypath: "transform.rotation.y",
       defaultValue: 0,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var anchorPoint: LayerProperty<CGPoint> {
@@ -116,14 +116,14 @@ extension LayerProperty {
       // This is intentionally not `GGPoint(x: 0.5, y: 0.5)` (the actual default)
       // to opt `anchorPoint` out of the KVC `setValue` flow, which causes issues.
       defaultValue: nil,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var opacity: LayerProperty<CGFloat> {
     .init(
       caLayerKeypath: #keyPath(CALayer.opacity),
       defaultValue: 1,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 }
 
@@ -134,7 +134,7 @@ extension LayerProperty {
     .init(
       caLayerKeypath: #keyPath(CAShapeLayer.path),
       defaultValue: nil,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var fillColor: LayerProperty<CGColor> {
@@ -148,14 +148,14 @@ extension LayerProperty {
     .init(
       caLayerKeypath: #keyPath(CAShapeLayer.lineWidth),
       defaultValue: 1,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var lineDashPhase: LayerProperty<CGFloat> {
     .init(
       caLayerKeypath: #keyPath(CAShapeLayer.lineDashPhase),
       defaultValue: 0,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var strokeColor: LayerProperty<CGColor> {
@@ -169,14 +169,14 @@ extension LayerProperty {
     .init(
       caLayerKeypath: #keyPath(CAShapeLayer.strokeStart),
       defaultValue: 0,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var strokeEnd: LayerProperty<CGFloat> {
     .init(
       caLayerKeypath: #keyPath(CAShapeLayer.strokeEnd),
       defaultValue: 1,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 }
 
@@ -187,28 +187,28 @@ extension LayerProperty {
     .init(
       caLayerKeypath: #keyPath(CAGradientLayer.colors),
       defaultValue: nil,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var locations: LayerProperty<[CGFloat]> {
     .init(
       caLayerKeypath: #keyPath(CAGradientLayer.locations),
       defaultValue: nil,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var startPoint: LayerProperty<CGPoint> {
     .init(
       caLayerKeypath: #keyPath(CAGradientLayer.startPoint),
       defaultValue: nil,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 
   static var endPoint: LayerProperty<CGPoint> {
     .init(
       caLayerKeypath: #keyPath(CAGradientLayer.endPoint),
       defaultValue: nil,
-      customizableProperty: nil /* currently unsupported */)
+      customizableProperty: nil /* currently unsupported */ )
   }
 }