lottie-ios 3.2.3 → 3.4.0

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

@@ -5,53 +5,58 @@
 //  Created by Brandon Withrow on 1/17/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 import QuartzCore
 
+// MARK: - RenderNode
+
 /// A protocol that defines a node that holds render instructions
 protocol RenderNode {
   var renderer: Renderable & NodeOutput { get }
 }
 
+// MARK: - Renderable
+
 /// A protocol that defines anything with render instructions
 protocol Renderable {
-  
+
   /// The last frame in which this node was updated.
   var hasUpdate: Bool { get }
-  
+
   func hasRenderUpdates(_ forFrame: CGFloat) -> Bool
-  
-  /**
-   Determines if the renderer requires a custom context for drawing.
-   If yes the shape layer will perform a custom drawing pass.
-   If no the shape layer will be a standard CAShapeLayer
-   */
+
+  /// Determines if the renderer requires a custom context for drawing.
+  /// If yes the shape layer will perform a custom drawing pass.
+  /// If no the shape layer will be a standard CAShapeLayer
   var shouldRenderInContext: Bool { get }
-  
+
   /// Passes in the CAShapeLayer to update
   func updateShapeLayer(layer: CAShapeLayer)
-  
+
   /// Asks the renderer what the renderable bounds is for the given box.
   func renderBoundsFor(_ boundingBox: CGRect) -> CGRect
-  
+
+  /// Opportunity for renderers to inject sublayers
+  func setupSublayers(layer: CAShapeLayer)
+
   /// Renders the shape in a custom context
   func render(_ inContext: CGContext)
 }
 
 extension RenderNode where Self: AnimatorNode {
-  
+
   var outputNode: NodeOutput {
-    return renderer
+    renderer
   }
-  
+
 }
 
 extension Renderable {
 
   func renderBoundsFor(_ boundingBox: CGRect) -> CGRect {
     /// Optional
-    return boundingBox
+    boundingBox
   }
-  
+
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/RenderLayers/ShapeContainerLayer.swift

@@ -8,16 +8,14 @@
 import Foundation
 import QuartzCore
 
-/**
- The base layer that holds Shapes and Shape Renderers
- */
+/// The base layer that holds Shapes and Shape Renderers
 class ShapeContainerLayer: CALayer {
-  
-  private(set) var renderLayers: [ShapeContainerLayer] = []
-  
+
+  // MARK: Lifecycle
+
   override init() {
     super.init()
-    self.actions = [
+    actions = [
       "position" : NSNull(),
       "bounds" : NSNull(),
       "anchorPoint" : NSNull(),
@@ -26,47 +24,52 @@ class ShapeContainerLayer: CALayer {
       "hidden" : NSNull(),
     ]
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
   override init(layer: Any) {
     guard let layer = layer as? ShapeContainerLayer else {
       fatalError("init(layer:) wrong class.")
     }
     super.init(layer: layer)
   }
-  
+
+  // MARK: Internal
+
+  private(set) var renderLayers: [ShapeContainerLayer] = []
+
   var renderScale: CGFloat = 1 {
     didSet {
       updateRenderScale()
     }
   }
-  
+
   func insertRenderLayer(_ layer: ShapeContainerLayer) {
     renderLayers.append(layer)
     insertSublayer(layer, at: 0)
   }
-  
+
   func markRenderUpdates(forFrame: CGFloat) {
-    if self.hasRenderUpdate(forFrame: forFrame) {
-      self.rebuildContents(forFrame: forFrame)
+    if hasRenderUpdate(forFrame: forFrame) {
+      rebuildContents(forFrame: forFrame)
     }
-    guard self.isHidden == false else { return }
+    guard isHidden == false else { return }
     renderLayers.forEach { $0.markRenderUpdates(forFrame: forFrame) }
   }
-  
-  func hasRenderUpdate(forFrame: CGFloat) -> Bool {
-    return false
+
+  func hasRenderUpdate(forFrame _: CGFloat) -> Bool {
+    false
   }
-  
-  func rebuildContents(forFrame: CGFloat) {
+
+  func rebuildContents(forFrame _: CGFloat) {
     /// Override
   }
-  
+
   func updateRenderScale() {
+    contentsScale = renderScale
     renderLayers.forEach( { $0.renderScale = renderScale } )
   }
-  
+
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/RenderLayers/ShapeRenderLayer.swift

@@ -8,20 +8,16 @@
 import Foundation
 import QuartzCore
 
-/**
- The layer responsible for rendering shape objects
- */
+/// The layer responsible for rendering shape objects
 final class ShapeRenderLayer: ShapeContainerLayer {
-  
-  fileprivate(set) var renderer: Renderable & NodeOutput
-  
-  let shapeLayer: CAShapeLayer = CAShapeLayer()
-  
+
+  // MARK: Lifecycle
+
   init(renderer: Renderable & NodeOutput) {
     self.renderer = renderer
     super.init()
-    self.anchorPoint = .zero
-    self.actions = [
+    anchorPoint = .zero
+    actions = [
       "position" : NSNull(),
       "bounds" : NSNull(),
       "anchorPoint" : NSNull(),
@@ -40,45 +36,54 @@ final class ShapeRenderLayer: ShapeContainerLayer {
       "lineWidth" : NSNull(),
       "miterLimit" : NSNull(),
       "lineDashPhase" : NSNull(),
+      "opacity": NSNull(),
       "hidden" : NSNull(),
     ]
     addSublayer(shapeLayer)
+
+    renderer.setupSublayers(layer: shapeLayer)
   }
-  
+
   override init(layer: Any) {
     guard let layer = layer as? ShapeRenderLayer else {
       fatalError("init(layer:) wrong class.")
     }
-    self.renderer = layer.renderer
+    renderer = layer.renderer
     super.init(layer: layer)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Internal
+
+  fileprivate(set) var renderer: Renderable & NodeOutput
+
+  let shapeLayer = CAShapeLayer()
+
   override func hasRenderUpdate(forFrame: CGFloat) -> Bool {
-    self.isHidden = !renderer.isEnabled
-    guard self.isHidden == false else { return false }
+    isHidden = !renderer.isEnabled
+    guard isHidden == false else { return false }
     return renderer.hasRenderUpdates(forFrame)
   }
-  
-  override func rebuildContents(forFrame: CGFloat) {
-    
+
+  override func rebuildContents(forFrame _: CGFloat) {
+
     if renderer.shouldRenderInContext {
       if let newPath = renderer.outputPath {
-        self.bounds = renderer.renderBoundsFor(newPath.boundingBox)
+        bounds = renderer.renderBoundsFor(newPath.boundingBox)
       } else {
-        self.bounds = .zero
+        bounds = .zero
       }
-      self.position = bounds.origin
-      self.setNeedsDisplay()
+      position = bounds.origin
+      setNeedsDisplay()
     } else {
       shapeLayer.path = renderer.outputPath
       renderer.updateShapeLayer(layer: shapeLayer)
     }
   }
-  
+
   override func draw(in ctx: CGContext) {
     if let path = renderer.outputPath {
       if !path.isEmpty {
@@ -87,4 +92,9 @@ final class ShapeRenderLayer: ShapeContainerLayer {
     }
     renderer.render(ctx)
   }
+
+  override func updateRenderScale() {
+    super.updateRenderScale()
+    shapeLayer.contentsScale = renderScale
+  }
 }

package/Sources/Private/Model/Animation.swift

@@ -0,0 +1,160 @@
+//
+//  Animation.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/7/19.
+//
+
+import Foundation
+
+// MARK: - CoordinateSpace
+
+public enum CoordinateSpace: Int, Codable {
+  case type2d
+  case type3d
+}
+
+// MARK: - Animation
+
+/// The `Animation` model is the top level model object in Lottie.
+///
+/// An `Animation` holds all of the animation data backing a Lottie Animation.
+/// Codable, see JSON schema [here](https://github.com/airbnb/lottie-web/tree/master/docs/json).
+public final class Animation: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Animation.CodingKeys.self)
+    version = try container.decode(String.self, forKey: .version)
+    type = try container.decodeIfPresent(CoordinateSpace.self, forKey: .type) ?? .type2d
+    startFrame = try container.decode(AnimationFrameTime.self, forKey: .startFrame)
+    endFrame = try container.decode(AnimationFrameTime.self, forKey: .endFrame)
+    framerate = try container.decode(Double.self, forKey: .framerate)
+    width = try container.decode(Int.self, forKey: .width)
+    height = try container.decode(Int.self, forKey: .height)
+    layers = try container.decode([LayerModel].self, ofFamily: LayerType.self, forKey: .layers)
+    glyphs = try container.decodeIfPresent([Glyph].self, forKey: .glyphs)
+    fonts = try container.decodeIfPresent(FontList.self, forKey: .fonts)
+    assetLibrary = try container.decodeIfPresent(AssetLibrary.self, forKey: .assetLibrary)
+    markers = try container.decodeIfPresent([Marker].self, forKey: .markers)
+
+    if let markers = markers {
+      var markerMap: [String: Marker] = [:]
+      for marker in markers {
+        markerMap[marker.name] = marker
+      }
+      self.markerMap = markerMap
+    } else {
+      markerMap = nil
+    }
+  }
+
+  public init(dictionary: [String: Any]) throws {
+    version = try dictionary.value(for: CodingKeys.version)
+    if
+      let typeRawValue = dictionary[CodingKeys.type.rawValue] as? Int,
+      let type = CoordinateSpace(rawValue: typeRawValue)
+    {
+      self.type = type
+    } else {
+      type = .type2d
+    }
+    startFrame = try dictionary.value(for: CodingKeys.startFrame)
+    endFrame = try dictionary.value(for: CodingKeys.endFrame)
+    framerate = try dictionary.value(for: CodingKeys.framerate)
+    width = try dictionary.value(for: CodingKeys.width)
+    height = try dictionary.value(for: CodingKeys.height)
+    let layerDictionaries: [[String: Any]] = try dictionary.value(for: CodingKeys.layers)
+    layers = try [LayerModel].fromDictionaries(layerDictionaries)
+    if let glyphDictionaries = dictionary[CodingKeys.glyphs.rawValue] as? [[String: Any]] {
+      glyphs = try glyphDictionaries.map({ try Glyph(dictionary: $0) })
+    } else {
+      glyphs = nil
+    }
+    if let fontsDictionary = dictionary[CodingKeys.fonts.rawValue] as? [String: Any] {
+      fonts = try FontList(dictionary: fontsDictionary)
+    } else {
+      fonts = nil
+    }
+    if let assetLibraryDictionaries = dictionary[CodingKeys.assetLibrary.rawValue] as? [[String: Any]] {
+      assetLibrary = try AssetLibrary(value: assetLibraryDictionaries)
+    } else {
+      assetLibrary = nil
+    }
+    if let markerDictionaries = dictionary[CodingKeys.markers.rawValue] as? [[String: Any]] {
+      let markers = try markerDictionaries.map({ try Marker(dictionary: $0) })
+      var markerMap: [String: Marker] = [:]
+      for marker in markers {
+        markerMap[marker.name] = marker
+      }
+      self.markers = markers
+      self.markerMap = markerMap
+    } else {
+      markers = nil
+      markerMap = nil
+    }
+  }
+
+  // MARK: Public
+
+  /// The start time of the composition in frameTime.
+  public let startFrame: AnimationFrameTime
+
+  /// The end time of the composition in frameTime.
+  public let endFrame: AnimationFrameTime
+
+  /// The frame rate of the composition.
+  public let framerate: Double
+
+  /// Return all marker names, in order, or an empty list if none are specified
+  public var markerNames: [String] {
+    guard let markers = markers else { return [] }
+    return markers.map { $0.name }
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case version = "v"
+    case type = "ddd"
+    case startFrame = "ip"
+    case endFrame = "op"
+    case framerate = "fr"
+    case width = "w"
+    case height = "h"
+    case layers
+    case glyphs = "chars"
+    case fonts
+    case assetLibrary = "assets"
+    case markers
+  }
+
+  /// The version of the JSON Schema.
+  let version: String
+
+  /// The coordinate space of the composition.
+  let type: CoordinateSpace
+
+  /// The height of the composition in points.
+  let width: Int
+
+  /// The width of the composition in points.
+  let height: Int
+
+  /// The list of animation layers
+  let layers: [LayerModel]
+
+  /// The list of glyphs used for text rendering
+  let glyphs: [Glyph]?
+
+  /// The list of fonts used for text rendering
+  let fonts: FontList?
+
+  /// Asset Library
+  let assetLibrary: AssetLibrary?
+
+  /// Markers
+  let markers: [Marker]?
+  let markerMap: [String: Marker]?
+}

package/Sources/Private/Model/Assets/Asset.swift

@@ -0,0 +1,43 @@
+//
+//  Asset.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+import Foundation
+
+public class Asset: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Asset.CodingKeys.self)
+    if let id = try? container.decode(String.self, forKey: .id) {
+      self.id = id
+    } else {
+      id = String(try container.decode(Int.self, forKey: .id))
+    }
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if let id = dictionary[CodingKeys.id.rawValue] as? String {
+      self.id = id
+    } else if let id = dictionary[CodingKeys.id.rawValue] as? Int {
+      self.id = String(id)
+    } else {
+      throw InitializableError.invalidInput
+    }
+  }
+
+  // MARK: Public
+
+  /// The ID of the asset
+  public let id: String
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case id
+  }
+}

package/{lottie-swift/src → Sources}/Private/Model/Assets/AssetLibrary.swift

@@ -7,23 +7,19 @@
 
 import Foundation
 
-final class AssetLibrary: Codable {
-  
-  /// The Assets
-  let assets: [String : Asset]
-  
-  let imageAssets: [String : ImageAsset]
-  let precompAssets: [String : PrecompAsset]
-  
+final class AssetLibrary: Codable, AnyInitializable {
+
+  // MARK: Lifecycle
+
   required init(from decoder: Decoder) throws {
     var container = try decoder.unkeyedContainer()
     var containerForKeys = container
-    
+
     var decodedAssets = [String : Asset]()
-    
+
     var imageAssets = [String : ImageAsset]()
     var precompAssets = [String : PrecompAsset]()
-    
+
     while !container.isAtEnd {
       let keyContainer = try containerForKeys.nestedContainer(keyedBy: PrecompAsset.CodingKeys.self)
       if keyContainer.contains(.layers) {
@@ -36,11 +32,42 @@ final class AssetLibrary: Codable {
         imageAssets[imageAsset.id] = imageAsset
       }
     }
-    self.assets = decodedAssets
+    assets = decodedAssets
+    self.precompAssets = precompAssets
+    self.imageAssets = imageAssets
+  }
+
+  init(value: Any) throws {
+    guard let dictionaries = value as? [[String: Any]] else {
+      throw InitializableError.invalidInput
+    }
+    var decodedAssets = [String : Asset]()
+    var imageAssets = [String : ImageAsset]()
+    var precompAssets = [String : PrecompAsset]()
+    try dictionaries.forEach { dictionary in
+      if dictionary[PrecompAsset.CodingKeys.layers.rawValue] != nil {
+        let asset = try PrecompAsset(dictionary: dictionary)
+        decodedAssets[asset.id] = asset
+        precompAssets[asset.id] = asset
+      } else {
+        let asset = try ImageAsset(dictionary: dictionary)
+        decodedAssets[asset.id] = asset
+        imageAssets[asset.id] = asset
+      }
+    }
+    assets = decodedAssets
     self.precompAssets = precompAssets
     self.imageAssets = imageAssets
   }
-  
+
+  // MARK: Internal
+
+  /// The Assets
+  let assets: [String: Asset]
+
+  let imageAssets: [String: ImageAsset]
+  let precompAssets: [String: PrecompAsset]
+
   func encode(to encoder: Encoder) throws {
     var container = encoder.unkeyedContainer()
     try container.encode(contentsOf: Array(assets.values))

package/Sources/Private/Model/Assets/ImageAsset.swift

@@ -0,0 +1,112 @@
+//
+//  ImageAsset.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+import Foundation
+
+// MARK: - ImageAsset
+
+public final class ImageAsset: Asset {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: ImageAsset.CodingKeys.self)
+    name = try container.decode(String.self, forKey: .name)
+    directory = try container.decode(String.self, forKey: .directory)
+    width = try container.decode(Double.self, forKey: .width)
+    height = try container.decode(Double.self, forKey: .height)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    name = try dictionary.value(for: CodingKeys.name)
+    directory = try dictionary.value(for: CodingKeys.directory)
+    width = try dictionary.value(for: CodingKeys.width)
+    height = try dictionary.value(for: CodingKeys.height)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Public
+
+  /// Image name
+  public let name: String
+
+  /// Image Directory
+  public let directory: String
+
+  /// Image Size
+  public let width: Double
+
+  public let height: Double
+
+  override public func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(name, forKey: .name)
+    try container.encode(directory, forKey: .directory)
+    try container.encode(width, forKey: .width)
+    try container.encode(height, forKey: .height)
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case name = "p"
+    case directory = "u"
+    case width = "w"
+    case height = "h"
+  }
+}
+
+extension Data {
+
+  // MARK: Lifecycle
+
+  /// Initializes `Data` from an `ImageAsset`.
+  ///
+  /// Returns nil when the input is not recognized as valid Data URL.
+  /// - parameter imageAsset: The image asset that contains Data URL.
+  internal init?(imageAsset: ImageAsset) {
+    self.init(dataString: imageAsset.name)
+  }
+
+  /// Initializes `Data` from a [Data URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs) String.
+  ///
+  /// Returns nil when the input is not recognized as valid Data URL.
+  /// - parameter dataString: The data string to parse.
+  /// - parameter options: Options for the string parsing. Default value is `[]`.
+  internal init?(dataString: String, options: DataURLReadOptions = []) {
+    guard
+      dataString.hasPrefix("data:"),
+      let url = URL(string: dataString)
+    else {
+      return nil
+    }
+    // The code below is needed because Data(contentsOf:) floods logs
+    // with messages since url doesn't have a host. This only fixes flooding logs
+    // when data inside Data URL is base64 encoded.
+    if
+      let base64Range = dataString.range(of: ";base64,"),
+      !options.contains(DataURLReadOptions.legacy)
+    {
+      let encodedString = String(dataString[base64Range.upperBound...])
+      self.init(base64Encoded: encodedString)
+    } else {
+      try? self.init(contentsOf: url)
+    }
+  }
+
+  // MARK: Internal
+
+  internal struct DataURLReadOptions: OptionSet {
+    let rawValue: Int
+
+    /// Will read Data URL using Data(contentsOf:)
+    static let legacy = DataURLReadOptions(rawValue: 1 << 0)
+  }
+
+}