lottie-ios 3.2.0 → 3.4.0

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/Text/TextAnimatorNode.swift

@@ -5,100 +5,106 @@
 //  Created by Brandon Withrow on 2/19/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 import QuartzCore
 
+// MARK: - TextAnimatorNodeProperties
+
 final class TextAnimatorNodeProperties: NodePropertyMap, KeypathSearchable {
-  
-  let keypathName: String
-  
+
+  // MARK: Lifecycle
+
   init(textAnimator: TextAnimator) {
-    self.keypathName = textAnimator.name
+    keypathName = textAnimator.name
     var properties = [String : AnyNodeProperty]()
-    
+
     if let keyframeGroup = textAnimator.anchor {
-      self.anchor = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Anchor"] = self.anchor
+      anchor = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Anchor"] = anchor
     } else {
-      self.anchor = nil
+      anchor = nil
     }
-    
+
     if let keyframeGroup = textAnimator.position {
-      self.position = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Position"] = self.position
+      position = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Position"] = position
     } else {
-      self.position = nil
+      position = nil
     }
-    
+
     if let keyframeGroup = textAnimator.scale {
-      self.scale = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Scale"] = self.scale
+      scale = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Scale"] = scale
     } else {
-      self.scale = nil
+      scale = nil
     }
-    
+
     if let keyframeGroup = textAnimator.skew {
-      self.skew = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Skew"] = self.skew
+      skew = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Skew"] = skew
     } else {
-      self.skew = nil
+      skew = nil
     }
-    
+
     if let keyframeGroup = textAnimator.skewAxis {
-      self.skewAxis = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Skew Axis"] = self.skewAxis
+      skewAxis = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Skew Axis"] = skewAxis
     } else {
-      self.skewAxis = nil
+      skewAxis = nil
     }
-    
+
     if let keyframeGroup = textAnimator.rotation {
-      self.rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Rotation"] = self.rotation
+      rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Rotation"] = rotation
     } else {
-      self.rotation = nil
+      rotation = nil
     }
-    
+
     if let keyframeGroup = textAnimator.opacity {
-      self.opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Opacity"] = self.opacity
+      opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Opacity"] = opacity
     } else {
-      self.opacity = nil
+      opacity = nil
     }
-    
+
     if let keyframeGroup = textAnimator.strokeColor {
-      self.strokeColor = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Stroke Color"] = self.strokeColor
+      strokeColor = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Stroke Color"] = strokeColor
     } else {
-      self.strokeColor = nil
+      strokeColor = nil
     }
-    
+
     if let keyframeGroup = textAnimator.fillColor {
-      self.fillColor = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Fill Color"] = self.fillColor
+      fillColor = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Fill Color"] = fillColor
     } else {
-      self.fillColor = nil
+      fillColor = nil
     }
-    
+
     if let keyframeGroup = textAnimator.strokeWidth {
-      self.strokeWidth = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Stroke Width"] = self.strokeWidth
+      strokeWidth = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Stroke Width"] = strokeWidth
     } else {
-      self.strokeWidth = nil
+      strokeWidth = nil
     }
-    
+
     if let keyframeGroup = textAnimator.tracking {
-      self.tracking = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Tracking"] = self.tracking
+      tracking = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
+      properties["Tracking"] = tracking
     } else {
-      self.tracking = nil
+      tracking = nil
     }
-    
-    self.keypathProperties = properties
-    
+
+    keypathProperties = properties
+
     self.properties = Array(keypathProperties.values)
   }
-  
+
+  // MARK: Internal
+
+  let keypathName: String
+
   let anchor: NodeProperty<Vector3D>?
   let position: NodeProperty<Vector3D>?
   let scale: NodeProperty<Vector3D>?
@@ -110,137 +116,150 @@ final class TextAnimatorNodeProperties: NodePropertyMap, KeypathSearchable {
   let fillColor: NodeProperty<Color>?
   let strokeWidth: NodeProperty<Vector1D>?
   let tracking: NodeProperty<Vector1D>?
-  
-  let keypathProperties: [String : AnyNodeProperty]
+
+  let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
-  
+
   var caTransform: CATransform3D {
-    return CATransform3D.makeTransform(anchor: anchor?.value.pointValue ?? .zero,
-                                       position: position?.value.pointValue ?? .zero,
-                                       scale: scale?.value.sizeValue ?? CGSize(width: 100, height: 100),
-                                       rotation: rotation?.value.cgFloatValue ?? 0,
-                                       skew: skew?.value.cgFloatValue,
-                                       skewAxis: skewAxis?.value.cgFloatValue)
+    CATransform3D.makeTransform(
+      anchor: anchor?.value.pointValue ?? .zero,
+      position: position?.value.pointValue ?? .zero,
+      scale: scale?.value.sizeValue ?? CGSize(width: 100, height: 100),
+      rotation: rotation?.value.cgFloatValue ?? 0,
+      skew: skew?.value.cgFloatValue,
+      skewAxis: skewAxis?.value.cgFloatValue)
   }
 }
 
+// MARK: - TextOutputNode
+
 final class TextOutputNode: NodeOutput {
-  
-  var parent: NodeOutput? {
-    return parentTextNode
+
+  // MARK: Lifecycle
+
+  init(parent: TextOutputNode?) {
+    parentTextNode = parent
   }
-  
+
+  // MARK: Internal
+
   var parentTextNode: TextOutputNode?
-  var isEnabled: Bool = true
-  
-  init(parent: TextOutputNode?) {
-    self.parentTextNode = parent
+  var isEnabled = true
+
+  var outputPath: CGPath?
+
+  var parent: NodeOutput? {
+    parentTextNode
   }
 
-  fileprivate var _xform: CATransform3D?
-  fileprivate var _opacity: CGFloat?
-  fileprivate var _strokeColor: CGColor?
-  fileprivate var _fillColor: CGColor?
-  fileprivate var _tracking: CGFloat?
-  fileprivate var _strokeWidth: CGFloat?
-  
   var xform: CATransform3D {
     get {
-      return _xform ?? parentTextNode?.xform ?? CATransform3DIdentity
+      _xform ?? parentTextNode?.xform ?? CATransform3DIdentity
     }
     set {
       _xform = newValue
     }
   }
-  
+
   var opacity: CGFloat {
     get {
-      return _opacity ?? parentTextNode?.opacity ?? 1
+      _opacity ?? parentTextNode?.opacity ?? 1
     }
     set {
       _opacity = newValue
     }
   }
-  
+
   var strokeColor: CGColor? {
     get {
-      return _strokeColor ?? parentTextNode?.strokeColor
+      _strokeColor ?? parentTextNode?.strokeColor
     }
     set {
       _strokeColor = newValue
     }
   }
-  
+
   var fillColor: CGColor? {
     get {
-      return _fillColor ?? parentTextNode?.fillColor
+      _fillColor ?? parentTextNode?.fillColor
     }
     set {
       _fillColor = newValue
     }
   }
-  
+
   var tracking: CGFloat {
     get {
-      return _tracking ?? parentTextNode?.tracking ?? 0
+      _tracking ?? parentTextNode?.tracking ?? 0
     }
     set {
       _tracking = newValue
     }
   }
-  
+
   var strokeWidth: CGFloat {
     get {
-      return _strokeWidth ?? parentTextNode?.strokeWidth ?? 0
+      _strokeWidth ?? parentTextNode?.strokeWidth ?? 0
     }
     set {
       _strokeWidth = newValue
     }
   }
-  
-  
-  func hasOutputUpdates(_ forFrame: CGFloat) -> Bool {
+
+  func hasOutputUpdates(_: CGFloat) -> Bool {
     // TODO Fix This
-    return true
+    true
   }
-  
-  var outputPath: CGPath?
-  
+
+  // MARK: Fileprivate
+
+  fileprivate var _xform: CATransform3D?
+  fileprivate var _opacity: CGFloat?
+  fileprivate var _strokeColor: CGColor?
+  fileprivate var _fillColor: CGColor?
+  fileprivate var _tracking: CGFloat?
+  fileprivate var _strokeWidth: CGFloat?
 }
 
+// MARK: - TextAnimatorNode
+
 class TextAnimatorNode: AnimatorNode {
-  
-  let textOutputNode: TextOutputNode
-  
-  var outputNode: NodeOutput {
-    return textOutputNode
-  }
-  
-  let textAnimatorProperties: TextAnimatorNodeProperties
-  
+
+  // MARK: Lifecycle
+
   init(parentNode: TextAnimatorNode?, textAnimator: TextAnimator) {
-    self.textOutputNode = TextOutputNode(parent: parentNode?.textOutputNode)
-    self.textAnimatorProperties = TextAnimatorNodeProperties(textAnimator: textAnimator)
+    textOutputNode = TextOutputNode(parent: parentNode?.textOutputNode)
+    textAnimatorProperties = TextAnimatorNodeProperties(textAnimator: textAnimator)
     self.parentNode = parentNode
   }
-  
+
+  // MARK: Internal
+
+  let textOutputNode: TextOutputNode
+
+  let textAnimatorProperties: TextAnimatorNodeProperties
+
+  let parentNode: AnimatorNode?
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+  var isEnabled = true
+
+  var outputNode: NodeOutput {
+    textOutputNode
+  }
+
   // MARK: Animator Node Protocol
-  
+
   var propertyMap: NodePropertyMap & KeypathSearchable {
-    return textAnimatorProperties
+    textAnimatorProperties
   }
-  
-  let parentNode: AnimatorNode?
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
-  var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true
-  
+
   func localUpdatesPermeateDownstream() -> Bool {
-    return true
+    true
   }
-  
-  func rebuildOutputs(frame: CGFloat) {
+
+  func rebuildOutputs(frame _: CGFloat) {
     textOutputNode.xform = textAnimatorProperties.caTransform
     textOutputNode.opacity = (textAnimatorProperties.opacity?.value.cgFloatValue ?? 100) * 0.01
     textOutputNode.strokeColor = textAnimatorProperties.strokeColor?.value.cgColorValue

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Protocols/AnimatorNode.swift

@@ -8,125 +8,126 @@
 import Foundation
 import QuartzCore
 
-/**
- Defines the basic outputs of an animator node.
- 
- */
+// MARK: - NodeOutput
+
+/// Defines the basic outputs of an animator node.
+///
 protocol NodeOutput {
-  
+
   /// The parent node.
   var parent: NodeOutput? { get }
-  
+
   /// Returns true if there are any updates upstream. OutputPath must be built before returning.
   func hasOutputUpdates(_ forFrame: CGFloat) -> Bool
-  
+
   var outputPath: CGPath? { get }
-  
+
   var isEnabled: Bool { get set }
 }
 
-/**
- The Animator Node is the base node in the render system tree.
- 
- It defines a single node that has an output path and option input node.
- At animation time the root animation node is asked to update its contents for
- the current frame.
- The node reaches up its chain of nodes until the first node that does not need
- updating is found. Then each node updates its contents down the render pipeline.
- Each node adds its local path to its input path and passes it forward.
- 
- An animator node holds a group of interpolators. These interpolators determine
- if the node needs an update for the current frame.
- 
- */
-protocol AnimatorNode: class, KeypathSearchable {
-  
-  /**
-   The available properties of the Node.
-   
-   These properties are automatically updated each frame.
-   These properties are also settable and gettable through the dynamic
-   property system.
-   
-   */
+// MARK: - AnimatorNode
+
+/// The Animator Node is the base node in the render system tree.
+///
+/// It defines a single node that has an output path and option input node.
+/// At animation time the root animation node is asked to update its contents for
+/// the current frame.
+/// The node reaches up its chain of nodes until the first node that does not need
+/// updating is found. Then each node updates its contents down the render pipeline.
+/// Each node adds its local path to its input path and passes it forward.
+///
+/// An animator node holds a group of interpolators. These interpolators determine
+/// if the node needs an update for the current frame.
+///
+protocol AnimatorNode: AnyObject, KeypathSearchable {
+
+  /// The available properties of the Node.
+  ///
+  /// These properties are automatically updated each frame.
+  /// These properties are also settable and gettable through the dynamic
+  /// property system.
+  ///
   var propertyMap: NodePropertyMap & KeypathSearchable { get }
-  
+
   /// The upstream input node
   var parentNode: AnimatorNode? { get }
-  
+
   /// The output of the node.
   var outputNode: NodeOutput { get }
-  
+
   /// Update the outputs of the node. Called if local contents were update or if outputsNeedUpdate returns true.
   func rebuildOutputs(frame: CGFloat)
-  
+
   /// Setters for marking current node state.
   var isEnabled: Bool { get set }
   var hasLocalUpdates: Bool { get set }
   var hasUpstreamUpdates: Bool { get set }
   var lastUpdateFrame: CGFloat? { get set }
-  
+
   // MARK: Optional
-  
+
   /// Marks if updates to this node affect nodes downstream.
   func localUpdatesPermeateDownstream() -> Bool
   func forceUpstreamOutputUpdates() -> Bool
-  
+
   /// Called at the end of this nodes update cycle. Always called. Optional.
   func performAdditionalLocalUpdates(frame: CGFloat, forceLocalUpdate: Bool) -> Bool
   func performAdditionalOutputUpdates(_ frame: CGFloat, forceOutputUpdate: Bool)
-  
+
   /// The default simply returns `hasLocalUpdates`
   func shouldRebuildOutputs(frame: CGFloat) -> Bool
 }
 
 /// Basic Node Logic
 extension AnimatorNode {
-  
-  func shouldRebuildOutputs(frame: CGFloat) -> Bool {
-    return hasLocalUpdates
+
+  func shouldRebuildOutputs(frame _: CGFloat) -> Bool {
+    hasLocalUpdates
   }
-  
+
   func localUpdatesPermeateDownstream() -> Bool {
     /// Optional override
-    return true
+    true
   }
-  
+
   func forceUpstreamOutputUpdates() -> Bool {
     /// Optional
-    return false
+    false
   }
-  
-  func performAdditionalLocalUpdates(frame: CGFloat, forceLocalUpdate: Bool) -> Bool {
+
+  func performAdditionalLocalUpdates(frame _: CGFloat, forceLocalUpdate: Bool) -> Bool {
     /// Optional
-    return forceLocalUpdate
+    forceLocalUpdate
   }
-  
-  func performAdditionalOutputUpdates(_ frame: CGFloat, forceOutputUpdate: Bool) {
+
+  func performAdditionalOutputUpdates(_: CGFloat, forceOutputUpdate _: Bool) {
     /// Optional
   }
 
-  @discardableResult func updateOutputs(_ frame: CGFloat, forceOutputUpdate: Bool) -> Bool {
+  @discardableResult
+  func updateOutputs(_ frame: CGFloat, forceOutputUpdate: Bool) -> Bool {
     guard isEnabled else {
       // Disabled node, pass through.
       lastUpdateFrame = frame
       return parentNode?.updateOutputs(frame, forceOutputUpdate: forceOutputUpdate) ?? false
     }
-    
+
     if forceOutputUpdate == false && lastUpdateFrame != nil && lastUpdateFrame! == frame {
       /// This node has already updated for this frame. Go ahead and return the results.
       return hasUpstreamUpdates || hasLocalUpdates
     }
 
     /// Ask if this node should force output updates upstream.
-    let forceUpstreamUpdates =  forceOutputUpdate || forceUpstreamOutputUpdates()
-    
+    let forceUpstreamUpdates = forceOutputUpdate || forceUpstreamOutputUpdates()
+
     /// Perform upstream output updates. Optionally mark upstream updates if any.
-    hasUpstreamUpdates = (parentNode?.updateOutputs(frame, forceOutputUpdate: forceUpstreamUpdates) ?? false || hasUpstreamUpdates)
-    
+    hasUpstreamUpdates = (
+      parentNode?
+        .updateOutputs(frame, forceOutputUpdate: forceUpstreamUpdates) ?? false || hasUpstreamUpdates)
+
     /// Perform additional local output updates
     performAdditionalOutputUpdates(frame, forceOutputUpdate: forceUpstreamUpdates)
-    
+
     /// If there are local updates, or if updates have been force, rebuild outputs
     if forceUpstreamUpdates || shouldRebuildOutputs(frame: frame) {
       lastUpdateFrame = frame
@@ -134,64 +135,64 @@ extension AnimatorNode {
     }
     return hasUpstreamUpdates || hasLocalUpdates
   }
-  
-  
+
   /// Rebuilds the content of this node, and upstream nodes if necessary.
-  @discardableResult func updateContents(_ frame: CGFloat, forceLocalUpdate: Bool) -> Bool {
+  @discardableResult
+  func updateContents(_ frame: CGFloat, forceLocalUpdate: Bool) -> Bool {
     guard isEnabled else {
       // Disabled node, pass through.
       return parentNode?.updateContents(frame, forceLocalUpdate: forceLocalUpdate) ?? false
     }
-    
+
     if forceLocalUpdate == false && lastUpdateFrame != nil && lastUpdateFrame! == frame {
       /// This node has already updated for this frame. Go ahead and return the results.
       return localUpdatesPermeateDownstream() ? hasUpstreamUpdates || hasLocalUpdates : hasUpstreamUpdates
     }
-    
+
     /// Are there local updates? If so mark the node.
     hasLocalUpdates = forceLocalUpdate ? forceLocalUpdate : propertyMap.needsLocalUpdate(frame: frame)
-    
+
     /// Were there upstream updates? If so mark the node
     hasUpstreamUpdates = parentNode?.updateContents(frame, forceLocalUpdate: forceLocalUpdate) ?? false
-    
+
     /// Perform property updates if necessary.
     if hasLocalUpdates {
       /// Rebuild local properties
       propertyMap.updateNodeProperties(frame: frame)
     }
-    
+
     /// Ask the node to perform any other updates it might have.
     hasUpstreamUpdates = performAdditionalLocalUpdates(frame: frame, forceLocalUpdate: forceLocalUpdate) || hasUpstreamUpdates
-    
+
     /// If the node can update nodes downstream, notify them, otherwise pass on any upstream updates downstream.
     return localUpdatesPermeateDownstream() ? hasUpstreamUpdates || hasLocalUpdates : hasUpstreamUpdates
   }
-  
+
   func updateTree(_ frame: CGFloat, forceUpdates: Bool = false) {
     updateContents(frame, forceLocalUpdate: forceUpdates)
     updateOutputs(frame, forceOutputUpdate: forceUpdates)
   }
-  
+
 }
 
 extension AnimatorNode {
   /// Default implementation for Keypath searchable.
   /// Forward all calls to the propertyMap.
-  
+
   var keypathName: String {
-    return propertyMap.keypathName
+    propertyMap.keypathName
   }
-  
-  var keypathProperties: [String : AnyNodeProperty] {
-    return propertyMap.keypathProperties
+
+  var keypathProperties: [String: AnyNodeProperty] {
+    propertyMap.keypathProperties
   }
-  
+
   var childKeypaths: [KeypathSearchable] {
-    return propertyMap.childKeypaths
+    propertyMap.childKeypaths
   }
-  
+
   var keypathLayer: CALayer? {
-    return nil
+    nil
   }
-  
+
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Protocols/PathNode.swift

@@ -7,14 +7,16 @@
 
 import Foundation
 
+// MARK: - PathNode
+
 protocol PathNode {
   var pathOutput: PathOutputNode { get }
 }
 
 extension PathNode where Self: AnimatorNode {
-  
+
   var outputNode: NodeOutput {
-    return pathOutput
+    pathOutput
   }
-  
+
 }