lottie-ios 3.2.2 → 3.4.1

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/CompLayers/ShapeCompositionLayer.swift

@@ -5,52 +5,54 @@
 //  Created by Brandon Withrow on 1/22/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
-/**
- A CompositionLayer responsible for initializing and rendering shapes
- */
+/// A CompositionLayer responsible for initializing and rendering shapes
 final class ShapeCompositionLayer: CompositionLayer {
-  
-  let rootNode: AnimatorNode?
-  let renderContainer: ShapeContainerLayer?
-  
+
+  // MARK: Lifecycle
+
   init(shapeLayer: ShapeLayerModel) {
     let results = shapeLayer.items.initializeNodeTree()
     let renderContainer = ShapeContainerLayer()
     self.renderContainer = renderContainer
-    self.rootNode = results.rootNode
+    rootNode = results.rootNode
     super.init(layer: shapeLayer, size: .zero)
     contentsLayer.addSublayer(renderContainer)
     for container in results.renderContainers {
       renderContainer.insertRenderLayer(container)
     }
     rootNode?.updateTree(0, forceUpdates: true)
-    self.childKeypaths.append(contentsOf: results.childrenNodes)
+    childKeypaths.append(contentsOf: results.childrenNodes)
   }
-  
+
   override init(layer: Any) {
     guard let layer = layer as? ShapeCompositionLayer else {
       fatalError("init(layer:) wrong class.")
     }
-    self.rootNode = nil
-    self.renderContainer = nil
+    rootNode = nil
+    renderContainer = nil
     super.init(layer: layer)
   }
-  
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  let rootNode: AnimatorNode?
+  let renderContainer: ShapeContainerLayer?
+
   override func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
     rootNode?.updateTree(frame, forceUpdates: forceUpdates)
     renderContainer?.markRenderUpdates(forFrame: frame)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
-    fatalError("init(coder:) has not been implemented")
-  }
-  
+
   override func updateRenderScale() {
     super.updateRenderScale()
     renderContainer?.renderScale = renderScale
   }
-  
+
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/CompLayers/SolidCompositionLayer.swift

@@ -9,40 +9,49 @@ import Foundation
 import QuartzCore
 
 final class SolidCompositionLayer: CompositionLayer {
-  
-  let colorProperty: NodeProperty<Color>?
-  let solidShape: CAShapeLayer = CAShapeLayer()
-  
+
+  // MARK: Lifecycle
+
   init(solid: SolidLayerModel) {
     let components = solid.colorHex.hexColorComponents()
-    self.colorProperty = NodeProperty(provider: SingleValueProvider(Color(r: Double(components.red), g: Double(components.green), b: Double(components.blue), a: 1)))
-    
+    colorProperty =
+      NodeProperty(provider: SingleValueProvider(Color(
+        r: Double(components.red),
+        g: Double(components.green),
+        b: Double(components.blue),
+        a: 1)))
+
     super.init(layer: solid, size: .zero)
     solidShape.path = CGPath(rect: CGRect(x: 0, y: 0, width: solid.width, height: solid.height), transform: nil)
     contentsLayer.addSublayer(solidShape)
   }
-  
+
   override init(layer: Any) {
     /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
     guard let layer = layer as? SolidCompositionLayer else {
       fatalError("init(layer:) Wrong Layer Class")
     }
-    self.colorProperty = layer.colorProperty
+    colorProperty = layer.colorProperty
     super.init(layer: layer)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
-  override func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
+
+  // MARK: Internal
+
+  let colorProperty: NodeProperty<Color>?
+  let solidShape = CAShapeLayer()
+
+  override var keypathProperties: [String: AnyNodeProperty] {
+    guard let colorProperty = colorProperty else { return super.keypathProperties }
+    return [PropertyName.color.rawValue : colorProperty]
+  }
+
+  override func displayContentsWithFrame(frame: CGFloat, forceUpdates _: Bool) {
     guard let colorProperty = colorProperty else { return }
     colorProperty.update(frame: frame)
     solidShape.fillColor = colorProperty.value.cgColorValue
   }
-  
-  override var keypathProperties: [String : AnyNodeProperty] {
-    guard let colorProperty = colorProperty else { return super.keypathProperties }
-    return ["Color" : colorProperty]
-  }
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/CompLayers/TextCompositionLayer.swift

@@ -5,10 +5,10 @@
 //  Created by Brandon Withrow on 1/25/19.
 //
 
-import Foundation
 import CoreGraphics
-import QuartzCore
 import CoreText
+import Foundation
+import QuartzCore
 
 /// Needed for NSMutableParagraphStyle...
 #if os(OSX)
@@ -28,7 +28,7 @@ extension TextJustification {
       return .center
     }
   }
-  
+
   var caTextAlignement: CATextLayerAlignmentMode {
     switch self {
     case .left:
@@ -41,72 +41,78 @@ extension TextJustification {
   }
 }
 
+// MARK: - TextCompositionLayer
+
 final class TextCompositionLayer: CompositionLayer {
-  
-  let rootNode: TextAnimatorNode?
-  let textDocument: KeyframeInterpolator<TextDocument>?
-  
-  let textLayer: TextLayer = TextLayer()
-  var textProvider: AnimationTextProvider
-  var fontProvider: AnimationFontProvider
-  
+
+  // MARK: Lifecycle
+
   init(textLayer: TextLayerModel, textProvider: AnimationTextProvider, fontProvider: AnimationFontProvider) {
     var rootNode: TextAnimatorNode?
     for animator in textLayer.animators {
       rootNode = TextAnimatorNode(parentNode: rootNode, textAnimator: animator)
     }
     self.rootNode = rootNode
-    self.textDocument = KeyframeInterpolator(keyframes: textLayer.text.keyframes)
-    
+    textDocument = KeyframeInterpolator(keyframes: textLayer.text.keyframes)
+
     self.textProvider = textProvider
     self.fontProvider = fontProvider
-    
+
     super.init(layer: textLayer, size: .zero)
     contentsLayer.addSublayer(self.textLayer)
     self.textLayer.masksToBounds = false
     self.textLayer.isGeometryFlipped = true
 
     if let rootNode = rootNode {
-        childKeypaths.append(rootNode)
+      childKeypaths.append(rootNode)
     }
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
   override init(layer: Any) {
     /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
     guard let layer = layer as? TextCompositionLayer else {
       fatalError("init(layer:) Wrong Layer Class")
     }
-    self.rootNode = nil
-    self.textDocument = nil
-    
-    self.textProvider = DefaultTextProvider()
-    self.fontProvider = DefaultFontProvider()
-    
+    rootNode = nil
+    textDocument = nil
+
+    textProvider = DefaultTextProvider()
+    fontProvider = DefaultFontProvider()
+
     super.init(layer: layer)
   }
-  
+
+  // MARK: Internal
+
+  let rootNode: TextAnimatorNode?
+  let textDocument: KeyframeInterpolator<TextDocument>?
+
+  let textLayer = CoreTextRenderLayer()
+  var textProvider: AnimationTextProvider
+  var fontProvider: AnimationFontProvider
+
   override func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
     guard let textDocument = textDocument else { return }
-    
-    textLayer.contentsScale = self.renderScale
-    
+
+    textLayer.contentsScale = renderScale
+
     let documentUpdate = textDocument.hasUpdate(frame: frame)
     let animatorUpdate = rootNode?.updateContents(frame, forceLocalUpdate: forceUpdates) ?? false
     guard documentUpdate == true || animatorUpdate == true else { return }
-    
+
     rootNode?.rebuildOutputs(frame: frame)
-    
+
     // Get Text Attributes
     let text = textDocument.value(frame: frame) as! TextDocument
     let strokeColor = rootNode?.textOutputNode.strokeColor ?? text.strokeColorData?.cgColorValue
     let strokeWidth = rootNode?.textOutputNode.strokeWidth ?? CGFloat(text.strokeWidth ?? 0)
     let tracking = (CGFloat(text.fontSize) * (rootNode?.textOutputNode.tracking ?? CGFloat(text.tracking))) / 1000.0
     let matrix = rootNode?.textOutputNode.xform ?? CATransform3DIdentity
-    let textString = textProvider.textFor(keypathName: self.keypathName, sourceText: text.text)
+    let textString = textProvider.textFor(keypathName: keypathName, sourceText: text.text)
     let ctFont = fontProvider.fontFor(family: text.fontFamily, size: CGFloat(text.fontSize))
 
     // Set all of the text layer options
@@ -115,7 +121,7 @@ final class TextCompositionLayer: CompositionLayer {
     textLayer.alignment = text.justification.textAlignment
     textLayer.lineHeight = CGFloat(text.lineHeight)
     textLayer.tracking = tracking
-    
+
     if let fillColor = rootNode?.textOutputNode.fillColor {
       textLayer.fillColor = fillColor
     } else if let fillColor = text.fillColorData?.cgColorValue {
@@ -123,21 +129,21 @@ final class TextCompositionLayer: CompositionLayer {
     } else {
       textLayer.fillColor = nil
     }
-    
+
     textLayer.preferredSize = text.textFrameSize?.sizeValue
     textLayer.strokeOnTop = text.strokeOverFill ?? false
     textLayer.strokeWidth = strokeWidth
     textLayer.strokeColor = strokeColor
     textLayer.sizeToFit()
-    
+
     textLayer.opacity = Float(rootNode?.textOutputNode.opacity ?? 1)
     textLayer.transform = CATransform3DIdentity
     textLayer.position = text.textFramePosition?.pointValue ?? CGPoint.zero
     textLayer.transform = matrix
   }
-  
+
   override func updateRenderScale() {
     super.updateRenderScale()
-    textLayer.contentsScale = self.renderScale
+    textLayer.contentsScale = renderScale
   }
 }