lottie-ios 3.2.3 → 3.4.2

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

@@ -29,13 +29,17 @@ extension MaskMode {
   }
 }
 
+// MARK: - MaskContainerLayer
+
 final class MaskContainerLayer: CALayer {
-  
+
+  // MARK: Lifecycle
+
   init(masks: [Mask]) {
     super.init()
     anchorPoint = .zero
     var containerLayer = CALayer()
-    var firstObject: Bool = true
+    var firstObject = true
     for mask in masks {
       let maskLayer = MaskLayer(mask: mask)
       maskLayers.append(maskLayer)
@@ -53,7 +57,7 @@ final class MaskContainerLayer: CALayer {
     }
     addSublayer(containerLayer)
   }
-  
+
   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? MaskContainerLayer else {
@@ -61,71 +65,84 @@ final class MaskContainerLayer: CALayer {
     }
     super.init(layer: layer)
   }
-  
-  fileprivate var maskLayers: [MaskLayer] = []
-  
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
   func updateWithFrame(frame: CGFloat, forceUpdates: Bool) {
     maskLayers.forEach({ $0.updateWithFrame(frame: frame, forceUpdates: forceUpdates) })
   }
-  
-  required init?(coder aDecoder: NSCoder) {
-    fatalError("init(coder:) has not been implemented")
-  }
+
+  // MARK: Fileprivate
+
+  fileprivate var maskLayers: [MaskLayer] = []
 }
 
 extension CGRect {
   static var veryLargeRect: CGRect {
-    return CGRect(x: -100_000_000,
-                  y: -100_000_000,
-                  width: 200_000_000,
-                  height: 200_000_000)
+    CGRect(
+      x: -100_000_000,
+      y: -100_000_000,
+      width: 200_000_000,
+      height: 200_000_000)
   }
 }
 
-fileprivate class MaskLayer: CALayer {
-  
-  let properties: MaskNodeProperties?
-  
-  let maskLayer = CAShapeLayer()
-  
+// MARK: - MaskLayer
+
+private class MaskLayer: CALayer {
+
+  // MARK: Lifecycle
+
   init(mask: Mask) {
-    self.properties = MaskNodeProperties(mask: mask)
+    properties = MaskNodeProperties(mask: mask)
     super.init()
     addSublayer(maskLayer)
     anchorPoint = .zero
-    maskLayer.fillColor = mask.mode == .add ? CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [1, 0, 0, 1]) :
-      CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [0, 1, 0, 1])
+    maskLayer.fillColor = mask.mode == .add
+      ? CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [1, 0, 0, 1])
+      : CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [0, 1, 0, 1])
     maskLayer.fillRule = CAShapeLayerFillRule.evenOdd
-    self.actions = [
-      "opacity" : NSNull()
+    actions = [
+      "opacity" : NSNull(),
     ]
-    
   }
-  
+
   override init(layer: Any) {
-    self.properties = nil
+    properties = nil
     super.init(layer: layer)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Internal
+
+  let properties: MaskNodeProperties?
+
+  let maskLayer = CAShapeLayer()
+
   func updateWithFrame(frame: CGFloat, forceUpdates: Bool) {
     guard let properties = properties else { return }
     if properties.opacity.needsUpdate(frame: frame) || forceUpdates {
       properties.opacity.update(frame: frame)
-      self.opacity = Float(properties.opacity.value.cgFloatValue)
+      opacity = Float(properties.opacity.value.cgFloatValue)
     }
-    
+
     if properties.shape.needsUpdate(frame: frame) || forceUpdates {
       properties.shape.update(frame: frame)
       properties.expansion.update(frame: frame)
-      
+
       let shapePath = properties.shape.value.cgPath()
       var path = shapePath
-      if properties.mode.usableMode == .subtract && !properties.inverted ||
-        (properties.mode.usableMode == .add && properties.inverted) {
+      if
+        properties.mode.usableMode == .subtract && !properties.inverted ||
+        (properties.mode.usableMode == .add && properties.inverted)
+      {
         /// Add a bounds rect to invert the mask
         let newPath = CGMutablePath()
         newPath.addRect(CGRect.veryLargeRect)
@@ -134,35 +151,39 @@ fileprivate class MaskLayer: CALayer {
       }
       maskLayer.path = path
     }
-    
   }
 }
 
-fileprivate class MaskNodeProperties: NodePropertyMap {
-  
-  var propertyMap: [String : AnyNodeProperty]
-  
-  var properties: [AnyNodeProperty]
-  
+// MARK: - MaskNodeProperties
+
+private class MaskNodeProperties: NodePropertyMap {
+
+  // MARK: Lifecycle
+
   init(mask: Mask) {
-    self.mode = mask.mode
-    self.inverted = mask.inverted
-    self.opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.opacity.keyframes))
-    self.shape = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.shape.keyframes))
-    self.expansion = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.expansion.keyframes))
-    self.propertyMap = [
+    mode = mask.mode
+    inverted = mask.inverted
+    opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.opacity.keyframes))
+    shape = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.shape.keyframes))
+    expansion = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.expansion.keyframes))
+    propertyMap = [
       "Opacity" : opacity,
       "Shape" : shape,
-      "Expansion" : expansion
+      "Expansion" : expansion,
     ]
-    self.properties = Array(self.propertyMap.values)
+    properties = Array(propertyMap.values)
   }
-  
+
+  // MARK: Internal
+
+  var propertyMap: [String: AnyNodeProperty]
+
+  var properties: [AnyNodeProperty]
+
   let mode: MaskMode
   let inverted: Bool
-  
+
   let opacity: NodeProperty<Vector1D>
   let shape: NodeProperty<BezierPath>
   let expansion: NodeProperty<Vector1D>
 }
-

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

@@ -8,15 +8,15 @@
 import Foundation
 
 final class NullCompositionLayer: CompositionLayer {
-  
+
   init(layer: LayerModel) {
     super.init(layer: layer, size: .zero)
   }
-  
-  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? NullCompositionLayer else {
@@ -24,5 +24,5 @@ final class NullCompositionLayer: CompositionLayer {
     }
     super.init(layer: layer)
   }
-  
+
 }

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

@@ -9,36 +9,41 @@ import Foundation
 import QuartzCore
 
 final class PreCompositionLayer: CompositionLayer {
-  
-  let frameRate: CGFloat
-  let remappingNode: NodeProperty<Vector1D>?
-  fileprivate var animationLayers: [CompositionLayer]
-  
-  init(precomp: PreCompLayerModel,
-       asset: PrecompAsset,
-       layerImageProvider: LayerImageProvider,
-       textProvider: AnimationTextProvider,
-       fontProvider: AnimationFontProvider,
-       assetLibrary: AssetLibrary?,
-       frameRate: CGFloat) {
-    self.animationLayers = []
+
+  // MARK: Lifecycle
+
+  init(
+    precomp: PreCompLayerModel,
+    asset: PrecompAsset,
+    layerImageProvider: LayerImageProvider,
+    textProvider: AnimationTextProvider,
+    fontProvider: AnimationFontProvider,
+    assetLibrary: AssetLibrary?,
+    frameRate: CGFloat)
+  {
+    animationLayers = []
     if let keyframes = precomp.timeRemapping?.keyframes {
-      self.remappingNode = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframes))
+      remappingNode = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframes))
     } else {
-      self.remappingNode = nil
+      remappingNode = nil
     }
     self.frameRate = frameRate
     super.init(layer: precomp, size: CGSize(width: precomp.width, height: precomp.height))
     bounds = CGRect(origin: .zero, size: CGSize(width: precomp.width, height: precomp.height))
     contentsLayer.masksToBounds = true
     contentsLayer.bounds = bounds
-    
-    let layers = asset.layers.initializeCompositionLayers(assetLibrary: assetLibrary, layerImageProvider: layerImageProvider, textProvider: textProvider,  fontProvider: fontProvider, frameRate: frameRate)
-    
+
+    let layers = asset.layers.initializeCompositionLayers(
+      assetLibrary: assetLibrary,
+      layerImageProvider: layerImageProvider,
+      textProvider: textProvider,
+      fontProvider: fontProvider,
+      frameRate: frameRate)
+
     var imageLayers = [ImageCompositionLayer]()
-    
+
     var mattedLayer: CompositionLayer? = nil
-    
+
     for layer in layers.reversed() {
       layer.bounds = bounds
       animationLayers.append(layer)
@@ -51,35 +56,49 @@ final class PreCompositionLayer: CompositionLayer {
         mattedLayer = nil
         continue
       }
-      if let matte = layer.matteType,
-        (matte == .add || matte == .invert) {
+      if
+        let matte = layer.matteType,
+        matte == .add || matte == .invert
+      {
         /// We have a layer that requires a matte.
         mattedLayer = layer
       }
       contentsLayer.addSublayer(layer)
     }
-    
-    self.childKeypaths.append(contentsOf: layers)
-    
+
+    childKeypaths.append(contentsOf: layers)
+
     layerImageProvider.addImageLayers(imageLayers)
   }
-  
+
   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? PreCompositionLayer else {
       fatalError("init(layer:) Wrong Layer Class")
     }
-    self.frameRate = layer.frameRate
-    self.remappingNode = nil
-    self.animationLayers = []
-    
+    frameRate = layer.frameRate
+    remappingNode = nil
+    animationLayers = []
+
     super.init(layer: layer)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Internal
+
+  let frameRate: CGFloat
+  let remappingNode: NodeProperty<Vector1D>?
+
+  override var keypathProperties: [String: AnyNodeProperty] {
+    guard let remappingNode = remappingNode else {
+      return super.keypathProperties
+    }
+    return ["Time Remap" : remappingNode]
+  }
+
   override func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
     let localFrame: CGFloat
     if let remappingNode = remappingNode {
@@ -88,18 +107,15 @@ final class PreCompositionLayer: CompositionLayer {
     } else {
       localFrame = (frame - startFrame) / timeStretch
     }
-    animationLayers.forEach( { $0.displayWithFrame(frame: localFrame, forceUpdates: forceUpdates) })
+    animationLayers.forEach({ $0.displayWithFrame(frame: localFrame, forceUpdates: forceUpdates) })
   }
-  
-  override var keypathProperties: [String : AnyNodeProperty] {
-    guard let remappingNode = remappingNode else {
-      return super.keypathProperties
-    }
-    return ["Time Remap" : remappingNode]
-  }
-  
+
   override func updateRenderScale() {
     super.updateRenderScale()
-    animationLayers.forEach( { $0.renderScale = renderScale } )
+    animationLayers.forEach({ $0.renderScale = renderScale })
   }
+
+  // MARK: Fileprivate
+
+  fileprivate var animationLayers: [CompositionLayer]
 }

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
   }
 }