lottie-ios 4.4.2 → 4.5.0

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/LayerEffectNodes/DropShadowNode.swift

@@ -0,0 +1,102 @@
+// Created by Lan Xu on 2024/6/7.
+// Copyright © 2024 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - DropShadowNode
+
+final class DropShadowNode: LayerEffectNode {
+
+  // MARK: Lifecycle
+
+  init(model: DropShadowModel) {
+    properties = DropShadowNodeProperties(model: model)
+  }
+
+  // MARK: Internal
+
+  var properties: DropShadowNodeProperties
+
+  var propertyMap: any NodePropertyMap {
+    properties
+  }
+
+  func applyEffect(to layer: CALayer) {
+    if let opacity = properties.opacity?.value.cgFloatValue {
+      // Lottie animation files express opacity as a numerical percentage value
+      // (e.g. 0%, 50%, 100%) so we divide by 100 to get the decimal values
+      // expected by Core Animation (e.g. 0.0, 0.5, 1.0).
+      layer.shadowOpacity = Float(opacity / 100)
+    }
+    if
+      let angleDegrees = properties.angle?.value.cgFloatValue,
+      let distance = properties.distance?.value.cgFloatValue
+    {
+      // Lottie animation files express rotation in degrees
+      // (e.g. 90º, 180º, 360º) so we convert to radians to get the
+      // values expected by Core Animation (e.g. π/2, π, 2π)
+      let angleRadians = (angleDegrees * .pi) / 180
+
+      // Lottie animation files express the `shadowOffset` as (angle, distance) pair,
+      // which we convert to the expected x / y offset values:
+      let offsetX = distance * cos(angleRadians)
+      let offsetY = distance * sin(angleRadians)
+      layer.shadowOffset = .init(width: offsetX, height: offsetY)
+    }
+    layer.shadowColor = properties.color?.value.cgColorValue
+    layer.shadowRadius = properties.radius?.value.cgFloatValue ?? 0
+  }
+
+}
+
+// MARK: - DropShadowNodeProperties
+
+final class DropShadowNodeProperties: NodePropertyMap {
+
+  // MARK: Lifecycle
+
+  init(model: DropShadowModel) {
+    if let opacityKeyframes = model._opacity?.keyframes {
+      opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: opacityKeyframes))
+      propertyMap[PropertyName.opacity.rawValue] = opacity
+    } else {
+      opacity = nil
+    }
+    if let radiusKeyframes = model._radius?.keyframes {
+      radius = NodeProperty(provider: KeyframeInterpolator(keyframes: radiusKeyframes))
+      propertyMap["Radius"] = radius
+    } else {
+      radius = nil
+    }
+    if let colorKeyFrames = model._color?.keyframes {
+      color = NodeProperty(provider: KeyframeInterpolator(keyframes: colorKeyFrames))
+      propertyMap[PropertyName.color.rawValue] = color
+    } else {
+      color = nil
+    }
+    if let angleKeyFrames = model._angle?.keyframes {
+      angle = NodeProperty(provider: KeyframeInterpolator(keyframes: angleKeyFrames))
+      propertyMap["Angle"] = angle
+    } else {
+      angle = nil
+    }
+    if let distanceKeyFrame = model._distance?.keyframes {
+      distance = NodeProperty(provider: KeyframeInterpolator(keyframes: distanceKeyFrame))
+      propertyMap["Distance"] = distance
+    } else {
+      distance = nil
+    }
+    properties = Array(propertyMap.values)
+  }
+
+  // MARK: Internal
+
+  var propertyMap: [String: AnyNodeProperty] = [:]
+  var properties: [AnyNodeProperty]
+
+  let opacity: NodeProperty<LottieVector1D>?
+  let radius: NodeProperty<LottieVector1D>?
+  let color: NodeProperty<LottieColor>?
+  let angle: NodeProperty<LottieVector1D>?
+  let distance: NodeProperty<LottieVector1D>?
+}

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/LayerEffectNodes/LayerEffectNode.swift

@@ -0,0 +1,24 @@
+// Created by Lan Xu on 2024/6/8.
+// Copyright © 2024 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - LayerEffectNode
+
+protocol LayerEffectNode {
+  func applyEffect(to layer: CALayer)
+  var propertyMap: NodePropertyMap { get }
+}
+
+extension LayerEffectNode {
+
+  func updateWithFrame(layer: CALayer, frame: CGFloat) {
+    for property in propertyMap.properties {
+      if property.needsUpdate(frame: frame) {
+        property.update(frame: frame)
+      }
+    }
+    applyEffect(to: layer)
+  }
+
+}

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

@@ -11,18 +11,18 @@ extension FillRule {
   var cgFillRule: CGPathFillRule {
     switch self {
     case .evenOdd:
-      return .evenOdd
+      .evenOdd
     default:
-      return .winding
+      .winding
     }
   }
 
   var caFillRule: CAShapeLayerFillRule {
     switch self {
     case .evenOdd:
-      return CAShapeLayerFillRule.evenOdd
+      CAShapeLayerFillRule.evenOdd
     default:
-      return CAShapeLayerFillRule.nonZero
+      CAShapeLayerFillRule.nonZero
     }
   }
 }

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

@@ -11,26 +11,26 @@ extension LineJoin {
   var cgLineJoin: CGLineJoin {
     switch self {
     case .bevel:
-      return .bevel
+      .bevel
     case .none:
-      return .miter
+      .miter
     case .miter:
-      return .miter
+      .miter
     case .round:
-      return .round
+      .round
     }
   }
 
   var caLineJoin: CAShapeLayerLineJoin {
     switch self {
     case .none:
-      return CAShapeLayerLineJoin.miter
+      CAShapeLayerLineJoin.miter
     case .miter:
-      return CAShapeLayerLineJoin.miter
+      CAShapeLayerLineJoin.miter
     case .round:
-      return CAShapeLayerLineJoin.round
+      CAShapeLayerLineJoin.round
     case .bevel:
-      return CAShapeLayerLineJoin.bevel
+      CAShapeLayerLineJoin.bevel
     }
   }
 }
@@ -39,26 +39,26 @@ extension LineCap {
   var cgLineCap: CGLineCap {
     switch self {
     case .none:
-      return .butt
+      .butt
     case .butt:
-      return .butt
+      .butt
     case .round:
-      return .round
+      .round
     case .square:
-      return .square
+      .square
     }
   }
 
   var caLineCap: CAShapeLayerLineCap {
     switch self {
     case .none:
-      return CAShapeLayerLineCap.butt
+      CAShapeLayerLineCap.butt
     case .butt:
-      return CAShapeLayerLineCap.butt
+      CAShapeLayerLineCap.butt
     case .round:
-      return CAShapeLayerLineCap.round
+      CAShapeLayerLineCap.round
     case .square:
-      return CAShapeLayerLineCap.square
+      CAShapeLayerLineCap.square
     }
   }
 }

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

@@ -122,7 +122,7 @@ extension BezierPath {
     var vertices = [CurveVertex(point: point + position, inTangentRelative: .zero, outTangentRelative: .zero)]
 
     var previousPoint = point
-    currentAngle += anglePerPoint;
+    currentAngle += anglePerPoint
     for _ in 0..<Int(ceil(numberOfPoints)) {
       previousPoint = point
       point = CGPoint(
@@ -131,8 +131,8 @@ extension BezierPath {
 
       if outerRoundedness != 0 {
         let cp1Theta = (atan2(previousPoint.y, previousPoint.x) - CGFloat.pi / 2)
-        let cp1Dx = cos(cp1Theta);
-        let cp1Dy = sin(cp1Theta);
+        let cp1Dx = cos(cp1Theta)
+        let cp1Dy = sin(cp1Theta)
 
         let cp2Theta = (atan2(point.y, point.x) - CGFloat.pi / 2)
         let cp2Dx = cos(cp2Theta)
@@ -154,7 +154,7 @@ extension BezierPath {
       } else {
         vertices.append(CurveVertex(point: point + position, inTangentRelative: .zero, outTangentRelative: .zero))
       }
-      currentAngle += anglePerPoint;
+      currentAngle += anglePerPoint
     }
     let reverse = direction == .counterClockwise
     if reverse {

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/StrokeNode.swift

@@ -169,11 +169,11 @@ extension [DashElement] {
 }
 
 extension [CGFloat] {
-  // If all of the items in the dash pattern are zeros, then we shouldn't attempt to render it.
-  // This causes Core Animation to have extremely poor performance for some reason, even though
-  // it doesn't affect the appearance of the animation.
-  //  - We check for `== 0.01` instead of `== 0` because `dashPattern.shapeLayerConfiguration`
-  //    converts all `0` values to `0.01` to work around a different Core Animation rendering issue.
+  /// If all of the items in the dash pattern are zeros, then we shouldn't attempt to render it.
+  /// This causes Core Animation to have extremely poor performance for some reason, even though
+  /// it doesn't affect the appearance of the animation.
+  ///  - We check for `== 0.01` instead of `== 0` because `dashPattern.shapeLayerConfiguration`
+  ///    converts all `0` values to `0.01` to work around a different Core Animation rendering issue.
   var isSupportedLayerDashPattern: Bool {
     !allSatisfy { $0 == 0.01 }
   }

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/Text/TextAnimatorNode.swift

@@ -15,6 +15,7 @@ final class TextAnimatorNodeProperties: NodePropertyMap, KeypathSearchable {
 
   init(textAnimator: TextAnimator) {
     keypathName = textAnimator.name
+    textRangeUnit = textAnimator.textRangeUnit
     var properties = [String : AnyNodeProperty]()
 
     if let keyframeGroup = textAnimator.anchor {
@@ -109,6 +110,27 @@ final class TextAnimatorNodeProperties: NodePropertyMap, KeypathSearchable {
       tracking = nil
     }
 
+    if let startKeyframes = textAnimator.start {
+      start = NodeProperty(provider: KeyframeInterpolator(keyframes: startKeyframes.keyframes))
+      properties["Start"] = start
+    } else {
+      start = nil
+    }
+
+    if let endKeyframes = textAnimator.end {
+      end = NodeProperty(provider: KeyframeInterpolator(keyframes: endKeyframes.keyframes))
+      properties["End"] = end
+    } else {
+      end = nil
+    }
+
+    if let selectedRangeOpacityKeyframes = textAnimator.opacity {
+      selectedRangeOpacity = NodeProperty(provider: KeyframeInterpolator(keyframes: selectedRangeOpacityKeyframes.keyframes))
+      properties["SelectedRangeOpacity"] = selectedRangeOpacity
+    } else {
+      selectedRangeOpacity = nil
+    }
+
     keypathProperties = properties
 
     self.properties = Array(keypathProperties.values)
@@ -131,6 +153,10 @@ final class TextAnimatorNodeProperties: NodePropertyMap, KeypathSearchable {
   let fillColor: NodeProperty<LottieColor>?
   let strokeWidth: NodeProperty<LottieVector1D>?
   let tracking: NodeProperty<LottieVector1D>?
+  let start: NodeProperty<LottieVector1D>?
+  let end: NodeProperty<LottieVector1D>?
+  let selectedRangeOpacity: NodeProperty<LottieVector1D>?
+  let textRangeUnit: TextRangeUnit?
 
   let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
@@ -223,6 +249,33 @@ final class TextOutputNode: NodeOutput {
     }
   }
 
+  var start: CGFloat? {
+    get {
+      _start
+    }
+    set {
+      _start = newValue
+    }
+  }
+
+  var end: CGFloat? {
+    get {
+      _end
+    }
+    set {
+      _end = newValue
+    }
+  }
+
+  var selectedRangeOpacity: CGFloat? {
+    get {
+      _selectedRangeOpacity
+    }
+    set {
+      _selectedRangeOpacity = newValue
+    }
+  }
+
   func hasOutputUpdates(_: CGFloat) -> Bool {
     // TODO Fix This
     true
@@ -236,6 +289,9 @@ final class TextOutputNode: NodeOutput {
   fileprivate var _fillColor: CGColor?
   fileprivate var _tracking: CGFloat?
   fileprivate var _strokeWidth: CGFloat?
+  fileprivate var _start: CGFloat?
+  fileprivate var _end: CGFloat?
+  fileprivate var _selectedRangeOpacity: CGFloat?
 }
 
 // MARK: - TextAnimatorNode
@@ -278,10 +334,13 @@ class TextAnimatorNode: AnimatorNode {
 
   func rebuildOutputs(frame _: CGFloat) {
     textOutputNode.xform = textAnimatorProperties.caTransform
-    textOutputNode.opacity = (textAnimatorProperties.opacity?.value.cgFloatValue ?? 100) * 0.01
+    textOutputNode.opacity = 1.0
     textOutputNode.strokeColor = textAnimatorProperties.strokeColor?.value.cgColorValue
     textOutputNode.fillColor = textAnimatorProperties.fillColor?.value.cgColorValue
     textOutputNode.tracking = textAnimatorProperties.tracking?.value.cgFloatValue ?? 1
     textOutputNode.strokeWidth = textAnimatorProperties.strokeWidth?.value.cgFloatValue ?? 0
+    textOutputNode.start = textAnimatorProperties.start?.value.cgFloatValue
+    textOutputNode.end = textAnimatorProperties.end?.value.cgFloatValue
+    textOutputNode.selectedRangeOpacity = (textAnimatorProperties.opacity?.value.cgFloatValue).flatMap { $0 * 0.01 }
   }
 }

package/Sources/Private/Model/DotLottie/DotLottieAnimation.swift

@@ -29,9 +29,9 @@ struct DotLottieAnimation: Codable {
   var loopMode: LottieLoopMode {
     switch mode {
     case .bounce:
-      return .autoReverse
+      .autoReverse
     case .normal, nil:
-      return (loop ?? false) ? .loop : .playOnce
+      (loop ?? false) ? .loop : .playOnce
     }
   }
 

package/Sources/Private/Model/Keyframes/KeyframeGroup.swift

@@ -151,12 +151,15 @@ extension KeyframeGroup: DictionaryInitializable where T: AnyInitializable {
     {
       keyframes = [Keyframe<T>(value)]
     } else {
-      var frameDictionaries: [[String: Any]]
-      if let singleFrameDictionary = dictionary[KeyframeWrapperKey.keyframeData.rawValue] as? [String: Any] {
-        frameDictionaries = [singleFrameDictionary]
-      } else {
-        frameDictionaries = try dictionary.value(for: KeyframeWrapperKey.keyframeData)
-      }
+      let frameDictionaries: [[String: Any]] =
+        if
+          let singleFrameDictionary =
+          dictionary[KeyframeWrapperKey.keyframeData.rawValue] as? [String: Any]
+        {
+          [singleFrameDictionary]
+        } else {
+          try dictionary.value(for: KeyframeWrapperKey.keyframeData)
+        }
       var previousKeyframeData: KeyframeData<T>?
       for frameDictionary in frameDictionaries {
         let data = try KeyframeData<T>(dictionary: frameDictionary)

package/Sources/Private/Model/LayerEffects/EffectValues/EffectValue.swift

@@ -23,14 +23,14 @@ extension EffectValueType: ClassFamily {
   func getType() -> AnyObject.Type {
     switch self {
     case .slider:
-      return Vector1DEffectValue.self
+      Vector1DEffectValue.self
     case .angle:
-      return Vector1DEffectValue.self
+      Vector1DEffectValue.self
     case .color:
-      return ColorEffectValue.self
+      ColorEffectValue.self
     case .unknown:
       // Unsupported
-      return LayerEffect.self
+      LayerEffect.self
     }
   }
 }

package/Sources/Private/Model/LayerEffects/LayerEffect.swift

@@ -21,10 +21,10 @@ extension LayerEffectType: ClassFamily {
   func getType() -> AnyObject.Type {
     switch self {
     case .dropShadow:
-      return DropShadowEffect.self
+      DropShadowEffect.self
     case .unknown:
       // Unsupported
-      return LayerEffect.self
+      LayerEffect.self
     }
   }
 }

package/Sources/Private/Model/LayerStyles/LayerStyle.swift

@@ -20,10 +20,10 @@ extension LayerStyleType: ClassFamily {
   func getType() -> AnyObject.Type {
     switch self {
     case .dropShadow:
-      return DropShadowStyle.self
+      DropShadowStyle.self
     case .unknown:
       // Unsupported
-      return LayerStyle.self
+      LayerStyle.self
     }
   }
 }

package/Sources/Private/Model/Layers/LayerModel.swift

@@ -14,19 +14,19 @@ extension LayerType: ClassFamily {
   func getType() -> AnyObject.Type {
     switch self {
     case .precomp:
-      return PreCompLayerModel.self
+      PreCompLayerModel.self
     case .solid:
-      return SolidLayerModel.self
+      SolidLayerModel.self
     case .image:
-      return ImageLayerModel.self
+      ImageLayerModel.self
     case .null:
-      return LayerModel.self
+      LayerModel.self
     case .shape:
-      return ShapeLayerModel.self
+      ShapeLayerModel.self
     case .text:
-      return TextLayerModel.self
+      TextLayerModel.self
     case .unknown:
-      return LayerModel.self
+      LayerModel.self
     }
   }
 }

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

@@ -38,35 +38,35 @@ extension ShapeType: ClassFamily {
   func getType() -> AnyObject.Type {
     switch self {
     case .ellipse:
-      return Ellipse.self
+      Ellipse.self
     case .fill:
-      return Fill.self
+      Fill.self
     case .gradientFill:
-      return GradientFill.self
+      GradientFill.self
     case .group:
-      return Group.self
+      Group.self
     case .gradientStroke:
-      return GradientStroke.self
+      GradientStroke.self
     case .merge:
-      return Merge.self
+      Merge.self
     case .rectangle:
-      return Rectangle.self
+      Rectangle.self
     case .repeater:
-      return Repeater.self
+      Repeater.self
     case .round:
-      return RoundedCorners.self
+      RoundedCorners.self
     case .shape:
-      return Shape.self
+      Shape.self
     case .star:
-      return Star.self
+      Star.self
     case .stroke:
-      return Stroke.self
+      Stroke.self
     case .trim:
-      return Trim.self
+      Trim.self
     case .transform:
-      return ShapeTransform.self
+      ShapeTransform.self
     default:
-      return ShapeItem.self
+      ShapeItem.self
     }
   }
 }

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

@@ -5,6 +5,15 @@
 //  Created by Brandon Withrow on 1/9/19.
 //
 
+// MARK: - TextRangeUnit
+
+enum TextRangeUnit: Int, RawRepresentable, Codable {
+  case percentage = 1
+  case index = 2
+}
+
+// MARK: - TextAnimator
+
 final class TextAnimator: Codable, DictionaryInitializable {
 
   // MARK: Lifecycle
@@ -12,6 +21,7 @@ final class TextAnimator: Codable, DictionaryInitializable {
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: TextAnimator.CodingKeys.self)
     name = try container.decodeIfPresent(String.self, forKey: .name) ?? ""
+
     let animatorContainer = try container.nestedContainer(keyedBy: TextAnimatorKeys.self, forKey: .textAnimator)
     fillColor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieColor>.self, forKey: .fillColor)
     strokeColor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieColor>.self, forKey: .strokeColor)
@@ -32,10 +42,16 @@ final class TextAnimator: Codable, DictionaryInitializable {
       rotationZ = nil
     }
     opacity = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
+
+    let selectorContainer = try? container.nestedContainer(keyedBy: TextSelectorKeys.self, forKey: .textSelector)
+    start = try? selectorContainer?.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .start)
+    end = try? selectorContainer?.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .end)
+    textRangeUnit = try? selectorContainer?.decodeIfPresent(TextRangeUnit.self, forKey: .textRangeUnits)
   }
 
   init(dictionary: [String: Any]) throws {
     name = (try? dictionary.value(for: CodingKeys.name)) ?? ""
+
     let animatorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.textAnimator)
     if let fillColorDictionary = animatorDictionary[TextAnimatorKeys.fillColor.rawValue] as? [String: Any] {
       fillColor = try? KeyframeGroup<LottieColor>(dictionary: fillColorDictionary)
@@ -107,6 +123,26 @@ final class TextAnimator: Codable, DictionaryInitializable {
     } else {
       opacity = nil
     }
+
+    let selectorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.textSelector)
+
+    if let startDictionary = selectorDictionary[TextSelectorKeys.start.rawValue] as? [String: Any] {
+      start = try KeyframeGroup<LottieVector1D>(dictionary: startDictionary)
+    } else {
+      start = nil
+    }
+
+    if let endDictionary = selectorDictionary[TextSelectorKeys.end.rawValue] as? [String: Any] {
+      end = try KeyframeGroup<LottieVector1D>(dictionary: endDictionary)
+    } else {
+      end = nil
+    }
+
+    if let textRangeUnitValue = selectorDictionary[TextSelectorKeys.textRangeUnits.rawValue] as? Int {
+      textRangeUnit = TextRangeUnit(rawValue: textRangeUnitValue)
+    } else {
+      textRangeUnit = nil
+    }
   }
 
   // MARK: Internal
@@ -152,6 +188,15 @@ final class TextAnimator: Codable, DictionaryInitializable {
   /// Tracking
   let tracking: KeyframeGroup<LottieVector1D>?
 
+  /// Start
+  let start: KeyframeGroup<LottieVector1D>?
+
+  /// End
+  let end: KeyframeGroup<LottieVector1D>?
+
+  /// The type of unit used by the start/end ranges
+  let textRangeUnit: TextRangeUnit?
+
   func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
     var animatorContainer = container.nestedContainer(keyedBy: TextAnimatorKeys.self, forKey: .textAnimator)
@@ -164,7 +209,7 @@ final class TextAnimator: Codable, DictionaryInitializable {
   // MARK: Private
 
   private enum CodingKeys: String, CodingKey {
-//    case textSelector = "s" TODO
+    case textSelector = "s"
     case textAnimator = "a"
     case name = "nm"
   }
@@ -173,6 +218,7 @@ final class TextAnimator: Codable, DictionaryInitializable {
     case start = "s"
     case end = "e"
     case offset = "o"
+    case textRangeUnits = "r"
   }
 
   private enum TextAnimatorKeys: String, CodingKey {

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

@@ -95,12 +95,12 @@ extension CALayer {
     }
 
     if visible {
-      let style: LayerDebugStyle
-      if let layerDebugging = self as? LayerDebugging {
-        style = layerDebugging.debugStyle
-      } else {
-        style = LayerDebugStyle.defaultStyle()
-      }
+      let style: LayerDebugStyle =
+        if let layerDebugging = self as? LayerDebugging {
+          layerDebugging.debugStyle
+        } else {
+          LayerDebugStyle.defaultStyle()
+        }
       let debugLayer = DebugLayer(style: style)
       var container = self
       if let cust = self as? CustomLayerDebugging {