lottie-ios 3.2.3 → 3.4.2

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/Utility/LayerTransformNode.swift

@@ -5,60 +5,63 @@
 //  Created by Brandon Withrow on 2/4/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 import QuartzCore
 
+// MARK: - LayerTransformProperties
+
 final class LayerTransformProperties: NodePropertyMap, KeypathSearchable {
-  
+
+  // MARK: Lifecycle
+
   init(transform: Transform) {
-    
-    self.anchor = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.anchorPoint.keyframes))
-    self.scale = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.scale.keyframes))
-    self.rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotation.keyframes))
-    self.opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.opacity.keyframes))
-    
+    anchor = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.anchorPoint.keyframes))
+    scale = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.scale.keyframes))
+    rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotation.keyframes))
+    opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.opacity.keyframes))
+
     var propertyMap: [String: AnyNodeProperty] = [
       "Anchor Point" : anchor,
       "Scale" : scale,
       "Rotation" : rotation,
-      "Opacity" : opacity
+      "Opacity" : opacity,
     ]
-    
-    if let positionKeyframesX = transform.positionX?.keyframes,
-      let positionKeyframesY = transform.positionY?.keyframes {
+
+    if
+      let positionKeyframesX = transform.positionX?.keyframes,
+      let positionKeyframesY = transform.positionY?.keyframes
+    {
       let xPosition: NodeProperty<Vector1D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframesX))
       let yPosition: NodeProperty<Vector1D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframesY))
       propertyMap["X Position"] = xPosition
       propertyMap["Y Position"] = yPosition
-      self.positionX = xPosition
-      self.positionY = yPosition
-      self.position = nil
+      positionX = xPosition
+      positionY = yPosition
+      position = nil
     } else if let positionKeyframes = transform.position?.keyframes {
       let position: NodeProperty<Vector3D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframes))
       propertyMap["Position"] = position
       self.position = position
-      self.positionX = nil
-      self.positionY = nil
+      positionX = nil
+      positionY = nil
     } else {
-      self.position = nil
-      self.positionY = nil
-      self.positionX = nil
+      position = nil
+      positionY = nil
+      positionX = nil
     }
-    
-    self.keypathProperties = propertyMap
-    self.properties = Array(propertyMap.values)
-  }
-  
-  let keypathProperties: [String : AnyNodeProperty]
-  var keypathName: String = "Transform"
-  
-  var childKeypaths: [KeypathSearchable] {
-    return []
+
+    keypathProperties = propertyMap
+    properties = Array(propertyMap.values)
   }
-  
+
+  // MARK: Internal
+
+  let keypathProperties: [String: AnyNodeProperty]
+  var keypathName = "Transform"
+
   let properties: [AnyNodeProperty]
-  
+
   let anchor: NodeProperty<Vector3D>
   let scale: NodeProperty<Vector3D>
   let rotation: NodeProperty<Vector1D>
@@ -66,63 +69,75 @@ final class LayerTransformProperties: NodePropertyMap, KeypathSearchable {
   let positionX: NodeProperty<Vector1D>?
   let positionY: NodeProperty<Vector1D>?
   let opacity: NodeProperty<Vector1D>
-  
+
+  var childKeypaths: [KeypathSearchable] {
+    []
+  }
 }
 
+// MARK: - LayerTransformNode
+
 class LayerTransformNode: AnimatorNode {
-  let outputNode: NodeOutput = PassThroughOutputNode(parent: nil)
-  
+
+  // MARK: Lifecycle
+
   init(transform: Transform) {
-    self.transformProperties = LayerTransformProperties(transform: transform)
+    transformProperties = LayerTransformProperties(transform: transform)
   }
-  
+
+  // MARK: Internal
+
+  let outputNode: NodeOutput = PassThroughOutputNode(parent: nil)
+
   let transformProperties: LayerTransformProperties
-  
+
+  var parentNode: AnimatorNode?
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+  var isEnabled = true
+
+  var opacity: Float = 1
+  var localTransform: CATransform3D = CATransform3DIdentity
+  var globalTransform: CATransform3D = CATransform3DIdentity
+
   // MARK: Animator Node Protocol
-  
+
   var propertyMap: NodePropertyMap & KeypathSearchable {
-    return transformProperties
+    transformProperties
   }
-  
-  var parentNode: AnimatorNode?
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
-  var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true
-  
-  func shouldRebuildOutputs(frame: CGFloat) -> Bool {
-    return hasLocalUpdates || hasUpstreamUpdates
+
+  func shouldRebuildOutputs(frame _: CGFloat) -> Bool {
+    hasLocalUpdates || hasUpstreamUpdates
   }
-  
-  func rebuildOutputs(frame: CGFloat) {
+
+  func rebuildOutputs(frame _: CGFloat) {
     opacity = Float(transformProperties.opacity.value.cgFloatValue) * 0.01
-    
+
     let position: CGPoint
     if let point = transformProperties.position?.value.pointValue {
       position = point
-    } else if let xPos = transformProperties.positionX?.value.cgFloatValue,
-      let yPos = transformProperties.positionY?.value.cgFloatValue {
+    } else if
+      let xPos = transformProperties.positionX?.value.cgFloatValue,
+      let yPos = transformProperties.positionY?.value.cgFloatValue
+    {
       position = CGPoint(x: xPos, y: yPos)
     } else {
       position = .zero
     }
-    
-    localTransform = CATransform3D.makeTransform(anchor: transformProperties.anchor.value.pointValue,
-                                                 position: position,
-                                                 scale: transformProperties.scale.value.sizeValue,
-                                                 rotation: transformProperties.rotation.value.cgFloatValue,
-                                                 skew: nil,
-                                                 skewAxis: nil)
-    
+
+    localTransform = CATransform3D.makeTransform(
+      anchor: transformProperties.anchor.value.pointValue,
+      position: position,
+      scale: transformProperties.scale.value.sizeValue,
+      rotation: transformProperties.rotation.value.cgFloatValue,
+      skew: nil,
+      skewAxis: nil)
+
     if let parentNode = parentNode as? LayerTransformNode {
       globalTransform = CATransform3DConcat(localTransform, parentNode.globalTransform)
     } else {
       globalTransform = localTransform
     }
   }
-  
-  var opacity: Float = 1
-  var localTransform: CATransform3D = CATransform3DIdentity
-  var globalTransform: CATransform3D = CATransform3DIdentity
-  
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Extensions/ItemsExtension.swift

@@ -7,6 +7,8 @@
 
 import Foundation
 
+// MARK: - NodeTree
+
 final class NodeTree {
   var rootNode: AnimatorNode? = nil
   var transform: ShapeTransform? = nil
@@ -17,7 +19,6 @@ final class NodeTree {
 
 extension Array where Element == ShapeItem {
   func initializeNodeTree() -> NodeTree {
-    
     let nodeTree = NodeTree()
 
     for item in self {
@@ -71,7 +72,6 @@ extension Array where Element == ShapeItem {
         nodeTree.transform = xform
         continue
       } else if let group = item as? Group {
-        
         let tree = group.items.initializeNodeTree()
         let node = GroupNode(name: group.name, parentNode: nodeTree.rootNode, tree: tree)
         nodeTree.rootNode = node
@@ -79,13 +79,18 @@ extension Array where Element == ShapeItem {
         /// Now add all child paths to current tree
         nodeTree.paths.append(contentsOf: tree.paths)
         nodeTree.renderContainers.append(node.container)
+      } else if item is Repeater {
+        LottieLogger.shared.assertionFailure("""
+          The Main Thread rendering engine doesn't currently support repeaters.
+          To play an animation with repeaters, you can use the Core Animation rendering engine instead.
+          """)
       }
-      
+
       if let pathNode = nodeTree.rootNode as? PathNode {
         //// Add path container to the node tree
         nodeTree.paths.append(pathNode.pathOutput)
       }
-      
+
       if let renderNode = nodeTree.rootNode as? RenderNode {
         nodeTree.renderContainers.append(ShapeRenderLayer(renderer: renderNode.renderer))
       }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/NodeProperties/NodeProperty.swift

@@ -5,43 +5,51 @@
 //  Created by Brandon Withrow on 1/30/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
 /// A node property that holds a reference to a T ValueProvider and a T ValueContainer.
 class NodeProperty<T>: AnyNodeProperty {
-  
-  var valueType: Any.Type { return T.self }
-  
+
+  // MARK: Lifecycle
+
+  init(provider: AnyValueProvider) {
+    valueProvider = provider
+    originalValueProvider = valueProvider
+    typedContainer = ValueContainer<T>(provider.value(frame: 0) as! T)
+    typedContainer.setNeedsUpdate()
+  }
+
+  // MARK: Internal
+
+  var valueProvider: AnyValueProvider
+  var originalValueProvider: AnyValueProvider
+
+  var valueType: Any.Type { T.self }
+
   var value: T {
-    return typedContainer.outputValue
+    typedContainer.outputValue
   }
-  
+
   var valueContainer: AnyValueContainer {
-    return typedContainer
-  }
-  
-  var valueProvider: AnyValueProvider
-  
-  init(provider: AnyValueProvider) {
-    self.valueProvider = provider
-    self.typedContainer = ValueContainer<T>(provider.value(frame: 0) as! T)
-    self.typedContainer.setNeedsUpdate()
+    typedContainer
   }
-  
+
   func needsUpdate(frame: CGFloat) -> Bool {
-    return valueContainer.needsUpdate || valueProvider.hasUpdate(frame: frame)
+    valueContainer.needsUpdate || valueProvider.hasUpdate(frame: frame)
   }
-  
+
   func setProvider(provider: AnyValueProvider) {
     guard provider.valueType == valueType else { return }
-    self.valueProvider = provider
+    valueProvider = provider
     valueContainer.setNeedsUpdate()
   }
-  
+
   func update(frame: CGFloat) {
     typedContainer.setValue(valueProvider.value(frame: frame), forFrame: frame)
   }
-  
+
+  // MARK: Fileprivate
+
   fileprivate var typedContainer: ValueContainer<T>
 }

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

@@ -5,26 +5,32 @@
 //  Created by Brandon Withrow on 1/30/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
+
+// MARK: - AnyNodeProperty
+
 /// A property of a node. The node property holds a provider and a container
 protocol AnyNodeProperty {
-  
+
   /// Returns true if the property needs to recompute its stored value
   func needsUpdate(frame: CGFloat) -> Bool
-  
+
   /// Updates the property for the frame
   func update(frame: CGFloat)
-  
+
   /// The stored value container for the property
   var valueContainer: AnyValueContainer { get }
-  
+
   /// The value provider for the property
   var valueProvider: AnyValueProvider { get }
-  
+
+  /// The original value provider for the property
+  var originalValueProvider: AnyValueProvider { get }
+
   /// The Type of the value provider
   var valueType: Any.Type { get }
-  
+
   /// Sets the value provider for the property.
   func setProvider(provider: AnyValueProvider)
 }
@@ -33,12 +39,12 @@ extension AnyNodeProperty {
 
   /// Returns the most recently computed value for the keypath, returns nil if property wasn't found
   func getValueOfType<T>() -> T? {
-    return valueContainer.value as? T
+    valueContainer.value as? T
   }
-  
+
   /// Returns the most recently computed value for the keypath, returns nil if property wasn't found
   func getValue() -> Any? {
-    return valueContainer.value
+    valueContainer.value
   }
 
 }

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

@@ -5,22 +5,22 @@
 //  Created by Brandon Withrow on 1/30/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
 /// The container for the value of a property.
 protocol AnyValueContainer: AnyObject {
-  
+
   /// The stored value of the container
   var value: Any { get }
-  
+
   /// Notifies the provider that it should update its container
   func setNeedsUpdate()
-  
+
   /// When true the container needs to have its value updated by its provider
   var needsUpdate: Bool { get }
-  
+
   /// The frame time of the last provided update
   var lastUpdateFrame: CGFloat { get }
-  
+
 }

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

@@ -10,15 +10,15 @@ import QuartzCore
 
 /// Protocol that provides keypath search functionality. Returns all node properties associated with a keypath.
 protocol KeypathSearchable {
-  
+
   /// The name of the Keypath
   var keypathName: String { get }
-  
+
   /// A list of properties belonging to the keypath.
-  var keypathProperties: [String : AnyNodeProperty] { get }
-  
+  var keypathProperties: [String: AnyNodeProperty] { get }
+
   /// Children Keypaths
   var childKeypaths: [KeypathSearchable] { get }
-  
+
   var keypathLayer: CALayer? { get }
 }

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

@@ -8,20 +8,22 @@
 import Foundation
 import QuartzCore
 
+// MARK: - NodePropertyMap
+
 protocol NodePropertyMap {
   var properties: [AnyNodeProperty] { get }
 }
 
 extension NodePropertyMap {
-  
+
   var childKeypaths: [KeypathSearchable] {
-    return []
+    []
   }
-  
+
   var keypathLayer: CALayer? {
-    return nil
+    nil
   }
-  
+
   /// Checks if the node's local contents need to be rebuilt.
   func needsLocalUpdate(frame: CGFloat) -> Bool {
     for property in properties {
@@ -31,12 +33,12 @@ extension NodePropertyMap {
     }
     return false
   }
-  
+
   /// Rebuilds only the local nodes that have an update for the frame
   func updateNodeProperties(frame: CGFloat) {
-    properties.forEach { (property) in
+    properties.forEach { property in
       property.update(frame: frame)
     }
   }
-  
+
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/NodeProperties/ValueContainer.swift

@@ -5,14 +5,34 @@
 //  Created by Brandon Withrow on 1/30/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
 /// A container for a node value that is Typed to T.
 class ValueContainer<T>: AnyValueContainer {
-  
-  private(set) var lastUpdateFrame: CGFloat = CGFloat.infinity
-  
+
+  // MARK: Lifecycle
+
+  init(_ value: T) {
+    outputValue = value
+  }
+
+  // MARK: Internal
+
+  private(set) var lastUpdateFrame = CGFloat.infinity
+
+  fileprivate(set) var needsUpdate = true
+
+  var value: Any {
+    outputValue as Any
+  }
+
+  var outputValue: T {
+    didSet {
+      needsUpdate = false
+    }
+  }
+
   func setValue(_ value: Any, forFrame: CGFloat) {
     if let typedValue = value as? T {
       needsUpdate = false
@@ -20,24 +40,8 @@ class ValueContainer<T>: AnyValueContainer {
       outputValue = typedValue
     }
   }
-  
+
   func setNeedsUpdate() {
     needsUpdate = true
   }
-  
-  var value: Any {
-    return outputValue as Any
-  }
-  
-  var outputValue: T {
-    didSet {
-      needsUpdate = false
-    }
-  }
-  
-  init(_ value: T) {
-    self.outputValue = value
-  }
-  
-  fileprivate(set) var needsUpdate: Bool = true
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/NodeProperties/ValueProviders/GroupInterpolator.swift

@@ -5,29 +5,35 @@
 //  Created by Brandon Withrow on 1/22/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
 /// A value provider that produces an array of values from an array of Keyframe Interpolators
-final class GroupInterpolator<ValueType>: AnyValueProvider where ValueType: Interpolatable {
+final class GroupInterpolator<ValueType>: ValueProvider where ValueType: Interpolatable {
+
+  // MARK: Lifecycle
+
+  /// Initialize with an array of array of keyframes.
+  init(keyframeGroups: ContiguousArray<ContiguousArray<Keyframe<ValueType>>>) {
+    keyframeInterpolators = ContiguousArray(keyframeGroups.map({ KeyframeInterpolator(keyframes: $0) }))
+  }
+
+  // MARK: Internal
+
+  let keyframeInterpolators: ContiguousArray<KeyframeInterpolator<ValueType>>
+
   var valueType: Any.Type {
-    return [ValueType].self
+    [ValueType].self
+  }
+
+  var storage: ValueProviderStorage<[ValueType]> {
+    .closure { frame in
+      self.keyframeInterpolators.map({ $0.value(frame: frame) as! ValueType })
+    }
   }
-  
+
   func hasUpdate(frame: CGFloat) -> Bool {
-    let updated = keyframeInterpolators.first(where: {$0.hasUpdate(frame: frame)})
+    let updated = keyframeInterpolators.first(where: { $0.hasUpdate(frame: frame) })
     return updated != nil
   }
-  
-  func value(frame: CGFloat) -> Any {
-    let output = keyframeInterpolators.map({$0.value(frame: frame) as! ValueType})
-    return output
-  }
-  
-  /// Initialize with an array of array of keyframes.
-  init(keyframeGroups: ContiguousArray<ContiguousArray<Keyframe<ValueType>>>) {
-    self.keyframeInterpolators = ContiguousArray(keyframeGroups.map({KeyframeInterpolator(keyframes: $0)}))
-  }
-  let keyframeInterpolators: ContiguousArray<KeyframeInterpolator<ValueType>>
-  
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/NodeProperties/ValueProviders/SingleValueProvider.swift

@@ -9,30 +9,35 @@ import Foundation
 import QuartzCore
 
 /// Returns a value for every frame.
-final class SingleValueProvider<ValueType>: AnyValueProvider {
-  
+final class SingleValueProvider<ValueType: AnyInterpolatable>: ValueProvider {
+
+  // MARK: Lifecycle
+
+  init(_ value: ValueType) {
+    self.value = value
+  }
+
+  // MARK: Internal
+
   var value: ValueType {
     didSet {
       hasUpdate = true
     }
   }
-  
-  init(_ value: ValueType) {
-    self.value = value
+
+  var storage: ValueProviderStorage<ValueType> {
+    .singleValue(value)
   }
-  
+
   var valueType: Any.Type {
-    return ValueType.self
-  }
-  
-  func hasUpdate(frame: CGFloat) -> Bool {
-    return hasUpdate
+    ValueType.self
   }
-  
-  func value(frame: CGFloat) -> Any {
-    hasUpdate = false
-    return value
+
+  func hasUpdate(frame _: CGFloat) -> Bool {
+    hasUpdate
   }
-  
-  private var hasUpdate: Bool = true
+
+  // MARK: Private
+
+  private var hasUpdate = true
 }