lottie-ios 3.2.3 → 3.4.2

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/ModifierNodes/TrimPathNode.swift

@@ -8,75 +8,85 @@
 import Foundation
 import QuartzCore
 
+// MARK: - TrimPathProperties
+
 final class TrimPathProperties: NodePropertyMap, KeypathSearchable {
-  
+
+  // MARK: Lifecycle
+
   init(trim: Trim) {
-    self.keypathName = trim.name
-    self.start = NodeProperty(provider: KeyframeInterpolator(keyframes: trim.start.keyframes))
-    self.end = NodeProperty(provider: KeyframeInterpolator(keyframes: trim.end.keyframes))
-    self.offset = NodeProperty(provider: KeyframeInterpolator(keyframes: trim.offset.keyframes))
-    self.type = trim.trimType
-    self.keypathProperties = [
+    keypathName = trim.name
+    start = NodeProperty(provider: KeyframeInterpolator(keyframes: trim.start.keyframes))
+    end = NodeProperty(provider: KeyframeInterpolator(keyframes: trim.end.keyframes))
+    offset = NodeProperty(provider: KeyframeInterpolator(keyframes: trim.offset.keyframes))
+    type = trim.trimType
+    keypathProperties = [
       "Start" : start,
       "End" : end,
-      "Offset" : offset
+      "Offset" : offset,
     ]
-    self.properties = Array(keypathProperties.values)
+    properties = Array(keypathProperties.values)
   }
-  
-  let keypathProperties: [String : AnyNodeProperty]
+
+  // MARK: Internal
+
+  let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
   let keypathName: String
-  
+
   let start: NodeProperty<Vector1D>
   let end: NodeProperty<Vector1D>
   let offset: NodeProperty<Vector1D>
   let type: TrimType
 }
 
+// MARK: - TrimPathNode
+
 final class TrimPathNode: AnimatorNode {
-  
-  let properties: TrimPathProperties
-  
-  fileprivate let upstreamPaths: [PathOutputNode]
-  
+
+  // MARK: Lifecycle
+
   init(parentNode: AnimatorNode?, trim: Trim, upstreamPaths: [PathOutputNode]) {
-    self.outputNode = PassThroughOutputNode(parent: parentNode?.outputNode)
+    outputNode = PassThroughOutputNode(parent: parentNode?.outputNode)
     self.parentNode = parentNode
-    self.properties = TrimPathProperties(trim: trim)
+    properties = TrimPathProperties(trim: trim)
     self.upstreamPaths = upstreamPaths
   }
-  
-  // MARK: Animator Node
-  var propertyMap: NodePropertyMap & KeypathSearchable {
-    return properties
-  }
-  
+
+  // MARK: Internal
+
+  let properties: TrimPathProperties
+
   let parentNode: AnimatorNode?
   let outputNode: NodeOutput
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
   var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true
-  
+  var isEnabled = true
+
+  // MARK: Animator Node
+  var propertyMap: NodePropertyMap & KeypathSearchable {
+    properties
+  }
+
   func forceUpstreamOutputUpdates() -> Bool {
-    return hasLocalUpdates || hasUpstreamUpdates
+    hasLocalUpdates || hasUpstreamUpdates
   }
-  
+
   func rebuildOutputs(frame: CGFloat) {
     /// Make sure there is a trim.
-    let startValue = properties.start.value.cgFloatValue  * 0.01
+    let startValue = properties.start.value.cgFloatValue * 0.01
     let endValue = properties.end.value.cgFloatValue * 0.01
     let start = min(startValue, endValue)
     let end = max(startValue, endValue)
-    
+
     let offset = properties.offset.value.cgFloatValue.truncatingRemainder(dividingBy: 360) / 360
-    
+
     /// No need to trim, it's a full path
     if start == 0, end == 1 {
       return
     }
-    
+
     /// All paths are empty.
     if start == end {
       for pathContainer in upstreamPaths {
@@ -84,31 +94,33 @@ final class TrimPathNode: AnimatorNode {
       }
       return
     }
-    
+
     if properties.type == .simultaneously {
       /// Just trim each path
       for pathContainer in upstreamPaths {
         let pathObjects = pathContainer.removePaths(updateFrame: frame)
         for path in pathObjects {
           // We are treating each compount path as an individual path. Its subpaths are treated as a whole.
-          pathContainer.appendPath(path.trim(fromPosition: start, toPosition: end, offset: offset, trimSimultaneously: false), updateFrame: frame)
+          pathContainer.appendPath(
+            path.trim(fromPosition: start, toPosition: end, offset: offset, trimSimultaneously: false),
+            updateFrame: frame)
         }
       }
       return
     }
-    
+
     /// Individual path trimming.
-    
+
     /// Brace yourself for the below code.
-    
+
     /// Normalize lengths with offset.
-    var startPosition = (start+offset).truncatingRemainder(dividingBy: 1)
-    var endPosition =  (end+offset).truncatingRemainder(dividingBy: 1)
-    
+    var startPosition = (start + offset).truncatingRemainder(dividingBy: 1)
+    var endPosition = (end + offset).truncatingRemainder(dividingBy: 1)
+
     if startPosition < 0 {
       startPosition = 1 + startPosition
     }
-    
+
     if endPosition < 0 {
       endPosition = 1 + endPosition
     }
@@ -118,27 +130,27 @@ final class TrimPathNode: AnimatorNode {
     if endPosition == 0 {
       endPosition = 1
     }
-    
-    
+
     /// First get the total length of all paths.
     var totalLength: CGFloat = 0
     upstreamPaths.forEach({ totalLength = totalLength + $0.totalLength })
-    
+
     /// Now determine the start and end cut lengths
     let startLength = startPosition * totalLength
     let endLength = endPosition * totalLength
     var pathStart: CGFloat = 0
-    
+
     /// Now loop through all path containers
     for pathContainer in upstreamPaths {
-      
       let pathEnd = pathStart + pathContainer.totalLength
-      
-      if !startLength.isInRange(pathStart, pathEnd) &&
-        endLength.isInRange(pathStart, pathEnd) {
+
+      if
+        !startLength.isInRange(pathStart, pathEnd) &&
+        endLength.isInRange(pathStart, pathEnd)
+      {
         // pathStart|=======E----------------------|pathEnd
         // Cut path components, removing after end.
-        
+
         let pathCutLength = endLength - pathStart
         let subpaths = pathContainer.removePaths(updateFrame: frame)
         var subpathStart: CGFloat = 0
@@ -160,12 +172,14 @@ final class TrimPathNode: AnimatorNode {
           }
           subpathStart = subpathEnd
         }
-        
-      } else if !endLength.isInRange(pathStart, pathEnd) &&
-        startLength.isInRange(pathStart, pathEnd) {
+
+      } else if
+        !endLength.isInRange(pathStart, pathEnd) &&
+        startLength.isInRange(pathStart, pathEnd)
+      {
         // pathStart|-------S======================|pathEnd
         //
-        
+
         // Cut path components, removing before beginning.
         let pathCutLength = startLength - pathStart
         // Clear paths from container
@@ -173,7 +187,7 @@ final class TrimPathNode: AnimatorNode {
         var subpathStart: CGFloat = 0
         for path in subpaths {
           let subpathEnd = subpathStart + path.length
-          
+
           if subpathStart < pathCutLength, pathCutLength < subpathEnd {
             /// This is the subpath that needs to be cut.
             let cutLength = pathCutLength - subpathStart
@@ -184,12 +198,14 @@ final class TrimPathNode: AnimatorNode {
           }
           subpathStart = subpathEnd
         }
-      } else if endLength.isInRange(pathStart, pathEnd) &&
-        startLength.isInRange(pathStart, pathEnd) {
+      } else if
+        endLength.isInRange(pathStart, pathEnd) &&
+        startLength.isInRange(pathStart, pathEnd)
+      {
         // pathStart|-------S============E---------|endLength
         // pathStart|=====E----------------S=======|endLength
         // trim from path beginning to endLength.
-        
+
         // Cut path components, removing before beginnings.
         let startCutLength = startLength - pathStart
         let endCutLength = endLength - pathStart
@@ -197,51 +213,66 @@ final class TrimPathNode: AnimatorNode {
         let subpaths = pathContainer.removePaths(updateFrame: frame)
         var subpathStart: CGFloat = 0
         for path in subpaths {
-          
           let subpathEnd = subpathStart + path.length
-          
-          if !startCutLength.isInRange(subpathStart, subpathEnd) &&
-            !endCutLength.isInRange(subpathStart, subpathEnd) {
+
+          if
+            !startCutLength.isInRange(subpathStart, subpathEnd),
+            !endCutLength.isInRange(subpathStart, subpathEnd)
+          {
             // The whole path is included. Add
             // S|==============================|E
             pathContainer.appendPath(path, updateFrame: frame)
-            
-          } else if startCutLength.isInRange(subpathStart, subpathEnd) &&
-            !endCutLength.isInRange(subpathStart, subpathEnd) {
+
+          } else if
+            startCutLength.isInRange(subpathStart, subpathEnd),
+            !endCutLength.isInRange(subpathStart, subpathEnd)
+          {
             /// The start of the path needs to be trimmed
             //  |-------S======================|E
             let cutLength = startCutLength - subpathStart
             let newPath = path.trim(fromPosition: cutLength / path.length, toPosition: 1, offset: 0, trimSimultaneously: false)
             pathContainer.appendPath(newPath, updateFrame: frame)
-          } else if !startCutLength.isInRange(subpathStart, subpathEnd) &&
-            endCutLength.isInRange(subpathStart, subpathEnd) {
+          } else if
+            !startCutLength.isInRange(subpathStart, subpathEnd),
+            endCutLength.isInRange(subpathStart, subpathEnd)
+          {
             // S|=======E----------------------|
             let cutLength = endCutLength - subpathStart
             let newPath = path.trim(fromPosition: 0, toPosition: cutLength / path.length, offset: 0, trimSimultaneously: false)
             pathContainer.appendPath(newPath, updateFrame: frame)
             break
-          } else if startCutLength.isInRange(subpathStart, subpathEnd) &&
-            endCutLength.isInRange(subpathStart, subpathEnd) {
+          } else if
+            startCutLength.isInRange(subpathStart, subpathEnd),
+            endCutLength.isInRange(subpathStart, subpathEnd)
+          {
             //  |-------S============E---------|
             let cutFromLength = startCutLength - subpathStart
             let cutToLength = endCutLength - subpathStart
-            let newPath = path.trim(fromPosition: cutFromLength / path.length, toPosition: cutToLength / path.length, offset: 0, trimSimultaneously: false)
+            let newPath = path.trim(
+              fromPosition: cutFromLength / path.length,
+              toPosition: cutToLength / path.length,
+              offset: 0,
+              trimSimultaneously: false)
             pathContainer.appendPath(newPath, updateFrame: frame)
             break
           }
-          
+
           subpathStart = subpathEnd
         }
-      } else if (endLength <= pathStart && pathEnd <= startLength) ||
+      } else if
+        (endLength <= pathStart && pathEnd <= startLength) ||
         (startLength <= pathStart && endLength <= pathStart) ||
-        (pathEnd <= startLength && pathEnd <= endLength) {
+        (pathEnd <= startLength && pathEnd <= endLength)
+      {
         /// The Path needs to be cleared
         pathContainer.removePaths(updateFrame: frame)
       }
-      
+
       pathStart = pathEnd
     }
-    
   }
-  
+
+  // MARK: Fileprivate
+
+  fileprivate let upstreamPaths: [PathOutputNode]
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/OutputNodes/GroupOutputNode.swift

@@ -5,25 +5,29 @@
 //  Created by Brandon Withrow on 1/30/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 import QuartzCore
 
 class GroupOutputNode: NodeOutput {
-  
+
+  // MARK: Lifecycle
+
   init(parent: NodeOutput?, rootNode: NodeOutput?) {
     self.parent = parent
     self.rootNode = rootNode
   }
-  
+
+  // MARK: Internal
+
   let parent: NodeOutput?
   let rootNode: NodeOutput?
-  var isEnabled: Bool = true
-  
+  var isEnabled = true
+
   private(set) var outputPath: CGPath? = nil
   private(set) var transform: CATransform3D = CATransform3DIdentity
-  
-  func setTransform(_ xform: CATransform3D, forFrame: CGFloat) {
+
+  func setTransform(_ xform: CATransform3D, forFrame _: CGFloat) {
     transform = xform
     outputPath = nil
   }
@@ -34,7 +38,7 @@ class GroupOutputNode: NodeOutput {
       outputPath = parent?.outputPath
       return upstreamUpdates
     }
-    
+
     let upstreamUpdates = parent?.hasOutputUpdates(forFrame) ?? false
     if upstreamUpdates {
       outputPath = nil
@@ -43,28 +47,30 @@ class GroupOutputNode: NodeOutput {
     if rootUpdates {
       outputPath = nil
     }
-    
-    var localUpdates: Bool = false
+
+    var localUpdates = false
     if outputPath == nil {
       localUpdates = true
-      
+
       let newPath = CGMutablePath()
       if let parentNode = parent, let parentPath = parentNode.outputPath {
         /// First add parent path.
         newPath.addPath(parentPath)
       }
       var xform = CATransform3DGetAffineTransform(transform)
-      if let rootNode = rootNode,
+      if
+        let rootNode = rootNode,
         let rootPath = rootNode.outputPath,
-        let xformedPath = rootPath.copy(using: &xform) {
+        let xformedPath = rootPath.copy(using: &xform)
+      {
         /// Now add root path. Note root path is transformed.
         newPath.addPath(xformedPath)
       }
-      
+
       outputPath = newPath
     }
-    
+
     return upstreamUpdates || localUpdates
   }
-  
+
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/OutputNodes/PassThroughOutputNode.swift

@@ -5,20 +5,31 @@
 //  Created by Brandon Withrow on 1/30/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
 class PassThroughOutputNode: NodeOutput {
-  
+
+  // MARK: Lifecycle
+
   init(parent: NodeOutput?) {
     self.parent = parent
   }
-  
+
+  // MARK: Internal
+
   let parent: NodeOutput?
-  
-  var hasUpdate: Bool = false
-  var isEnabled: Bool = true
-  
+
+  var hasUpdate = false
+  var isEnabled = true
+
+  var outputPath: CGPath? {
+    if let parent = parent {
+      return parent.outputPath
+    }
+    return nil
+  }
+
   func hasOutputUpdates(_ forFrame: CGFloat) -> Bool {
     /// Changes to this node do not affect downstream nodes.
     let parentUpdate = parent?.hasOutputUpdates(forFrame) ?? false
@@ -26,14 +37,7 @@ class PassThroughOutputNode: NodeOutput {
     hasUpdate = hasUpdate || parentUpdate
     return parentUpdate
   }
-  
-  var outputPath: CGPath? {
-    if let parent = parent {
-      return parent.outputPath
-    }
-    return nil
-  }
-  
+
   func hasRenderUpdates(_ forFrame: CGFloat) -> Bool {
     /// Return true if there are upstream updates or if this node has updates
     let upstreamUpdates = parent?.hasOutputUpdates(forFrame) ?? false

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/OutputNodes/PathOutputNode.swift

@@ -5,34 +5,40 @@
 //  Created by Brandon Withrow on 1/30/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
 /// A node that has an output of a BezierPath
 class PathOutputNode: NodeOutput {
-  
+
+  // MARK: Lifecycle
+
   init(parent: NodeOutput?) {
     self.parent = parent
   }
-  
+
+  // MARK: Internal
+
   let parent: NodeOutput?
-  
+
   fileprivate(set) var outputPath: CGPath? = nil
-  
+
   var lastUpdateFrame: CGFloat? = nil
   var lastPathBuildFrame: CGFloat? = nil
-  var isEnabled: Bool = true
-  
+  var isEnabled = true
+  fileprivate(set) var totalLength: CGFloat = 0
+  fileprivate(set) var pathObjects: [CompoundBezierPath] = []
+
   func hasOutputUpdates(_ forFrame: CGFloat) -> Bool {
     guard isEnabled else {
       let upstreamUpdates = parent?.hasOutputUpdates(forFrame) ?? false
       outputPath = parent?.outputPath
       return upstreamUpdates
     }
-    
+
     /// Ask if parent was updated
     let upstreamUpdates = parent?.hasOutputUpdates(forFrame) ?? false
-    
+
     /// If parent was updated and the path hasn't been built for this frame, clear the path.
     if upstreamUpdates && lastPathBuildFrame != forFrame {
       outputPath = nil
@@ -52,17 +58,13 @@ class PathOutputNode: NodeOutput {
       }
       outputPath = newPath
     }
-    
+
     /// Return true if there were upstream updates or if this node was updated.
     return upstreamUpdates || (lastUpdateFrame == forFrame)
   }
-  
-  // MARK: Internal
-  
-  fileprivate(set) var totalLength: CGFloat = 0
-  fileprivate(set) var pathObjects: [CompoundBezierPath] = []
-  
-  @discardableResult func removePaths(updateFrame: CGFloat?) -> [CompoundBezierPath] {
+
+  @discardableResult
+  func removePaths(updateFrame: CGFloat?) -> [CompoundBezierPath] {
     lastUpdateFrame = updateFrame
     let returnPaths = pathObjects
     outputPath = nil
@@ -70,19 +72,19 @@ class PathOutputNode: NodeOutput {
     pathObjects = []
     return returnPaths
   }
-  
+
   func setPath(_ path: BezierPath, updateFrame: CGFloat) {
     lastUpdateFrame = updateFrame
     outputPath = nil
     totalLength = path.length
     pathObjects = [CompoundBezierPath(path: path)]
   }
-  
+
   func appendPath(_ path: CompoundBezierPath, updateFrame: CGFloat) {
     lastUpdateFrame = updateFrame
     outputPath = nil
     totalLength = totalLength + path.length
     pathObjects.append(path)
   }
-  
+
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/OutputNodes/Renderables/FillRenderer.swift

@@ -5,9 +5,9 @@
 //  Created by Brandon Withrow on 1/30/19.
 //
 
+import CoreGraphics
 import Foundation
 import QuartzCore
-import CoreGraphics
 
 extension FillRule {
   var cgFillRule: CGPathFillRule {
@@ -18,7 +18,7 @@ extension FillRule {
       return .winding
     }
   }
-  
+
   var caFillRule: CAShapeLayerFillRule {
     switch self {
     case .evenOdd:
@@ -29,44 +29,43 @@ extension FillRule {
   }
 }
 
+// MARK: - FillRenderer
+
 /// A rendered for a Path Fill
 final class FillRenderer: PassThroughOutputNode, Renderable {
-  
-  let shouldRenderInContext: Bool = false
-  
-  func updateShapeLayer(layer: CAShapeLayer) {
-    layer.fillColor = color
-    layer.opacity = Float(opacity)
-    layer.fillRule = fillRule.caFillRule
-    hasUpdate = false
-  }
-  
+  var shouldRenderInContext = false
+
   var color: CGColor? {
     didSet {
       hasUpdate = true
     }
   }
-  
+
   var opacity: CGFloat = 0 {
     didSet {
       hasUpdate = true
     }
   }
-  
+
   var fillRule: FillRule = .none {
     didSet {
       hasUpdate = true
     }
   }
-  
-  func render(_ inContext: CGContext) {
-    guard inContext.path != nil && inContext.path!.isEmpty == false else {
-      return
-    }
-    guard let color = color else { return }
+
+  func render(_: CGContext) {
+    // do nothing
+  }
+
+  func setupSublayers(layer _: CAShapeLayer) {
+    // do nothing
+  }
+
+  func updateShapeLayer(layer: CAShapeLayer) {
+    layer.fillColor = color
+    layer.opacity = Float(opacity)
+    layer.fillRule = fillRule.caFillRule
     hasUpdate = false
-    inContext.setAlpha(opacity * 0.01)
-    inContext.setFillColor(color)
-    inContext.fillPath(using: fillRule.cgFillRule)
   }
+
 }