lottie-ios 3.2.3 → 3.4.2

package/Sources/Private/Model/Layers/LayerModel.swift

@@ -0,0 +1,228 @@
+//
+//  Layer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/7/19.
+//
+
+import Foundation
+
+// MARK: - LayerType + ClassFamily
+
+/// Used for mapping a heterogeneous list to classes for parsing.
+extension LayerType: ClassFamily {
+  static var discriminator: Discriminator = .type
+
+  func getType() -> AnyObject.Type {
+    switch self {
+    case .precomp:
+      return PreCompLayerModel.self
+    case .solid:
+      return SolidLayerModel.self
+    case .image:
+      return ImageLayerModel.self
+    case .null:
+      return LayerModel.self
+    case .shape:
+      return ShapeLayerModel.self
+    case .text:
+      return TextLayerModel.self
+    }
+  }
+}
+
+// MARK: - LayerType
+
+public enum LayerType: Int, Codable {
+  case precomp
+  case solid
+  case image
+  case null
+  case shape
+  case text
+
+  public init(from decoder: Decoder) throws {
+    self = try LayerType(rawValue: decoder.singleValueContainer().decode(RawValue.self)) ?? .null
+  }
+}
+
+// MARK: - MatteType
+
+public enum MatteType: Int, Codable {
+  case none
+  case add
+  case invert
+  case unknown
+}
+
+// MARK: - BlendMode
+
+public enum BlendMode: Int, Codable {
+  case normal
+  case multiply
+  case screen
+  case overlay
+  case darken
+  case lighten
+  case colorDodge
+  case colorBurn
+  case hardLight
+  case softLight
+  case difference
+  case exclusion
+  case hue
+  case saturation
+  case color
+  case luminosity
+}
+
+// MARK: - LayerModel
+
+/// A base top container for shapes, images, and other view objects.
+class LayerModel: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: LayerModel.CodingKeys.self)
+    name = try container.decodeIfPresent(String.self, forKey: .name) ?? "Layer"
+    index = try container.decodeIfPresent(Int.self, forKey: .index) ?? .random(in: Int.min...Int.max)
+    type = try container.decode(LayerType.self, forKey: .type)
+    coordinateSpace = try container.decodeIfPresent(CoordinateSpace.self, forKey: .coordinateSpace) ?? .type2d
+    inFrame = try container.decode(Double.self, forKey: .inFrame)
+    outFrame = try container.decode(Double.self, forKey: .outFrame)
+    startTime = try container.decode(Double.self, forKey: .startTime)
+    transform = try container.decode(Transform.self, forKey: .transform)
+    parent = try container.decodeIfPresent(Int.self, forKey: .parent)
+    blendMode = try container.decodeIfPresent(BlendMode.self, forKey: .blendMode) ?? .normal
+    masks = try container.decodeIfPresent([Mask].self, forKey: .masks)
+    timeStretch = try container.decodeIfPresent(Double.self, forKey: .timeStretch) ?? 1
+    matte = try container.decodeIfPresent(MatteType.self, forKey: .matte)
+    hidden = try container.decodeIfPresent(Bool.self, forKey: .hidden) ?? false
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    name = (try? dictionary.value(for: CodingKeys.name)) ?? "Layer"
+    index = try dictionary.value(for: CodingKeys.index) ?? .random(in: Int.min...Int.max)
+    type = LayerType(rawValue: try dictionary.value(for: CodingKeys.type)) ?? .null
+    if
+      let coordinateSpaceRawValue = dictionary[CodingKeys.coordinateSpace.rawValue] as? Int,
+      let coordinateSpace = CoordinateSpace(rawValue: coordinateSpaceRawValue)
+    {
+      self.coordinateSpace = coordinateSpace
+    } else {
+      coordinateSpace = .type2d
+    }
+    inFrame = try dictionary.value(for: CodingKeys.inFrame)
+    outFrame = try dictionary.value(for: CodingKeys.outFrame)
+    startTime = try dictionary.value(for: CodingKeys.startTime)
+    transform = try Transform(dictionary: try dictionary.value(for: CodingKeys.transform))
+    parent = try? dictionary.value(for: CodingKeys.parent)
+    if
+      let blendModeRawValue = dictionary[CodingKeys.blendMode.rawValue] as? Int,
+      let blendMode = BlendMode(rawValue: blendModeRawValue)
+    {
+      self.blendMode = blendMode
+    } else {
+      blendMode = .normal
+    }
+    if let maskDictionaries = dictionary[CodingKeys.masks.rawValue] as? [[String: Any]] {
+      masks = try maskDictionaries.map({ try Mask(dictionary: $0) })
+    } else {
+      masks = nil
+    }
+    timeStretch = (try? dictionary.value(for: CodingKeys.timeStretch)) ?? 1
+    if let matteRawValue = dictionary[CodingKeys.matte.rawValue] as? Int {
+      matte = MatteType(rawValue: matteRawValue)
+    } else {
+      matte = nil
+    }
+    hidden = (try? dictionary.value(for: CodingKeys.hidden)) ?? false
+  }
+
+  // MARK: Internal
+
+  /// The readable name of the layer
+  let name: String
+
+  /// The index of the layer
+  let index: Int
+
+  /// The type of the layer.
+  let type: LayerType
+
+  /// The coordinate space
+  let coordinateSpace: CoordinateSpace
+
+  /// The in time of the layer in frames.
+  let inFrame: Double
+  /// The out time of the layer in frames.
+  let outFrame: Double
+
+  /// The start time of the layer in frames.
+  let startTime: Double
+
+  /// The transform of the layer
+  let transform: Transform
+
+  /// The index of the parent layer, if applicable.
+  let parent: Int?
+
+  /// The blending mode for the layer
+  let blendMode: BlendMode
+
+  /// An array of masks for the layer.
+  let masks: [Mask]?
+
+  /// A number that stretches time by a multiplier
+  let timeStretch: Double
+
+  /// The type of matte if any.
+  let matte: MatteType?
+
+  let hidden: Bool
+
+  // MARK: Fileprivate
+
+  fileprivate enum CodingKeys: String, CodingKey {
+    case name = "nm"
+    case index = "ind"
+    case type = "ty"
+    case coordinateSpace = "ddd"
+    case inFrame = "ip"
+    case outFrame = "op"
+    case startTime = "st"
+    case transform = "ks"
+    case parent
+    case blendMode = "bm"
+    case masks = "masksProperties"
+    case timeStretch = "sr"
+    case matte = "tt"
+    case hidden = "hd"
+  }
+}
+
+extension Array where Element == LayerModel {
+
+  static func fromDictionaries(_ dictionaries: [[String: Any]]) throws -> [LayerModel] {
+    try dictionaries.compactMap { dictionary in
+      let layerType = dictionary[LayerModel.CodingKeys.type.rawValue] as? Int
+      switch LayerType(rawValue: layerType ?? LayerType.null.rawValue) {
+      case .precomp:
+        return try PreCompLayerModel(dictionary: dictionary)
+      case .solid:
+        return try SolidLayerModel(dictionary: dictionary)
+      case .image:
+        return try ImageLayerModel(dictionary: dictionary)
+      case .null:
+        return try LayerModel(dictionary: dictionary)
+      case .shape:
+        return try ShapeLayerModel(dictionary: dictionary)
+      case .text:
+        return try TextLayerModel(dictionary: dictionary)
+      case .none:
+        return nil
+      }
+    }
+  }
+}

package/{lottie-swift/src → Sources}/Private/Model/Layers/PreCompLayerModel.swift

@@ -9,35 +9,44 @@ import Foundation
 
 /// A layer that holds another animation composition.
 final class PreCompLayerModel: LayerModel {
-  
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: PreCompLayerModel.CodingKeys.self)
+    referenceID = try container.decode(String.self, forKey: .referenceID)
+    timeRemapping = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .timeRemapping)
+    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 {
+    referenceID = try dictionary.value(for: CodingKeys.referenceID)
+    if let timeRemappingDictionary = dictionary[CodingKeys.timeRemapping.rawValue] as? [String: Any] {
+      timeRemapping = try KeyframeGroup<Vector1D>(dictionary: timeRemappingDictionary)
+    } else {
+      timeRemapping = nil
+    }
+    width = try dictionary.value(for: CodingKeys.width)
+    height = try dictionary.value(for: CodingKeys.height)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
   /// The reference ID of the precomp.
   let referenceID: String
-  
+
   /// A value that remaps time over time.
   let timeRemapping: KeyframeGroup<Vector1D>?
-  
+
   /// Precomp Width
   let width: Double
-  
+
   /// Precomp Height
   let height: Double
-  
-  private enum CodingKeys : String, CodingKey {
-    case referenceID = "refId"
-    case timeRemapping = "tm"
-    case width = "w"
-    case height = "h"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: PreCompLayerModel.CodingKeys.self)
-    self.referenceID = try container.decode(String.self, forKey: .referenceID)
-    self.timeRemapping = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .timeRemapping)
-    self.width = try container.decode(Double.self, forKey: .width)
-    self.height = try container.decode(Double.self, forKey: .height)
-    try super.init(from: decoder)
-  }
-  
+
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)
     var container = encoder.container(keyedBy: CodingKeys.self)
@@ -46,5 +55,13 @@ final class PreCompLayerModel: LayerModel {
     try container.encode(width, forKey: .width)
     try container.encode(height, forKey: .height)
   }
-  
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case referenceID = "refId"
+    case timeRemapping = "tm"
+    case width = "w"
+    case height = "h"
+  }
 }

package/{lottie-swift/src → Sources}/Private/Model/Layers/ShapeLayerModel.swift

@@ -9,24 +9,35 @@ import Foundation
 
 /// A layer that holds vector shape objects.
 final class ShapeLayerModel: LayerModel {
-  
-  /// A list of shape items.
-  let items: [ShapeItem]
-  
-  private enum CodingKeys : String, CodingKey {
-    case items = "shapes"
-  }
-  
+
+  // MARK: Lifecycle
+
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: ShapeLayerModel.CodingKeys.self)
-    self.items = try container.decode([ShapeItem].self, ofFamily: ShapeType.self, forKey: .items)
+    items = try container.decode([ShapeItem].self, ofFamily: ShapeType.self, forKey: .items)
     try super.init(from: decoder)
   }
-  
+
+  required init(dictionary: [String: Any]) throws {
+    let itemDictionaries: [[String: Any]] = try dictionary.value(for: CodingKeys.items)
+    items = try [ShapeItem].fromDictionaries(itemDictionaries)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// A list of shape items.
+  let items: [ShapeItem]
+
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)
     var container = encoder.container(keyedBy: CodingKeys.self)
-    try container.encode(self.items, forKey: .items)
+    try container.encode(items, forKey: .items)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case items = "shapes"
   }
-  
 }

package/{lottie-swift/src → Sources}/Private/Model/Layers/SolidLayerModel.swift

@@ -9,30 +9,35 @@ import Foundation
 
 /// A layer that holds a solid color.
 final class SolidLayerModel: LayerModel {
-  
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: SolidLayerModel.CodingKeys.self)
+    colorHex = try container.decode(String.self, forKey: .colorHex)
+    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 {
+    colorHex = try dictionary.value(for: CodingKeys.colorHex)
+    width = try dictionary.value(for: CodingKeys.width)
+    height = try dictionary.value(for: CodingKeys.height)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
   /// The color of the solid in Hex // Change to value provider.
   let colorHex: String
-  
+
   /// The Width of the color layer
   let width: Double
-  
+
   /// The height of the color layer
   let height: Double
-  
-  private enum CodingKeys : String, CodingKey {
-    case colorHex = "sc"
-    case width = "sw"
-    case height = "sh"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: SolidLayerModel.CodingKeys.self)
-    self.colorHex = try container.decode(String.self, forKey: .colorHex)
-    self.width = try container.decode(Double.self, forKey: .width)
-    self.height = try container.decode(Double.self, forKey: .height)
-    try super.init(from: decoder)
-  }
-  
+
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)
     var container = encoder.container(keyedBy: CodingKeys.self)
@@ -40,5 +45,12 @@ final class SolidLayerModel: LayerModel {
     try container.encode(width, forKey: .width)
     try container.encode(height, forKey: .height)
   }
-  
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case colorHex = "sc"
+    case width = "sw"
+    case height = "sh"
+  }
 }

package/{lottie-swift/src → Sources}/Private/Model/Layers/TextLayerModel.swift

@@ -10,29 +10,33 @@ import Foundation
 /// A layer that holds text.
 final class TextLayerModel: LayerModel {
 
-  /// The text for the layer
-  let text: KeyframeGroup<TextDocument>
-  
-  /// Text animators
-  let animators: [TextAnimator]
-  
-  private enum CodingKeys : String, CodingKey {
-    case textGroup = "t"
-  }
-  
-  private enum TextCodingKeys : String, CodingKey {
-    case text = "d"
-    case animators = "a"
-  }
-  
+  // MARK: Lifecycle
+
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: TextLayerModel.CodingKeys.self)
     let textContainer = try container.nestedContainer(keyedBy: TextCodingKeys.self, forKey: .textGroup)
-    self.text = try textContainer.decode(KeyframeGroup<TextDocument>.self, forKey: .text)
-    self.animators = try textContainer.decode([TextAnimator].self, forKey: .animators)
+    text = try textContainer.decode(KeyframeGroup<TextDocument>.self, forKey: .text)
+    animators = try textContainer.decode([TextAnimator].self, forKey: .animators)
     try super.init(from: decoder)
   }
-  
+
+  required init(dictionary: [String: Any]) throws {
+    let containerDictionary: [String: Any] = try dictionary.value(for: CodingKeys.textGroup)
+    let textDictionary: [String: Any] = try containerDictionary.value(for: TextCodingKeys.text)
+    text = try KeyframeGroup<TextDocument>(dictionary: textDictionary)
+    let animatorDictionaries: [[String: Any]] = try containerDictionary.value(for: TextCodingKeys.animators)
+    animators = try animatorDictionaries.map({ try TextAnimator(dictionary: $0) })
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The text for the layer
+  let text: KeyframeGroup<TextDocument>
+
+  /// Text animators
+  let animators: [TextAnimator]
+
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)
     var container = encoder.container(keyedBy: CodingKeys.self)
@@ -40,5 +44,15 @@ final class TextLayerModel: LayerModel {
     try textContainer.encode(text, forKey: .text)
     try textContainer.encode(animators, forKey: .animators)
   }
-  
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case textGroup = "t"
+  }
+
+  private enum TextCodingKeys: String, CodingKey {
+    case text = "d"
+    case animators = "a"
+  }
 }

package/Sources/Private/Model/Objects/DashPattern.swift

@@ -0,0 +1,44 @@
+//
+//  DashPattern.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/22/19.
+//
+
+import Foundation
+
+// MARK: - DashElementType
+
+enum DashElementType: String, Codable {
+  case offset = "o"
+  case dash = "d"
+  case gap = "g"
+}
+
+// MARK: - DashElement
+
+final class DashElement: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  init(dictionary: [String: Any]) throws {
+    let typeRawValue: String = try dictionary.value(for: CodingKeys.type)
+    guard let type = DashElementType(rawValue: typeRawValue) else {
+      throw InitializableError.invalidInput
+    }
+    self.type = type
+    let valueDictionary: [String: Any] = try dictionary.value(for: CodingKeys.value)
+    value = try KeyframeGroup<Vector1D>(dictionary: valueDictionary)
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case type = "n"
+    case value = "v"
+  }
+
+  let type: DashElementType
+  let value: KeyframeGroup<Vector1D>
+
+}

package/Sources/Private/Model/Objects/Marker.swift

@@ -0,0 +1,33 @@
+//
+//  Marker.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+import Foundation
+
+/// A time marker
+final class Marker: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  init(dictionary: [String: Any]) throws {
+    name = try dictionary.value(for: CodingKeys.name)
+    frameTime = try dictionary.value(for: CodingKeys.frameTime)
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case name = "cm"
+    case frameTime = "tm"
+  }
+
+  /// The Marker Name
+  let name: String
+
+  /// The Frame time of the marker
+  let frameTime: AnimationFrameTime
+
+}

package/Sources/Private/Model/Objects/Mask.swift

@@ -0,0 +1,80 @@
+//
+//  Mask.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+// MARK: - MaskMode
+
+enum MaskMode: String, Codable {
+  case add = "a"
+  case subtract = "s"
+  case intersect = "i"
+  case lighten = "l"
+  case darken = "d"
+  case difference = "f"
+  case none = "n"
+}
+
+// MARK: - Mask
+
+final class Mask: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Mask.CodingKeys.self)
+    mode = try container.decodeIfPresent(MaskMode.self, forKey: .mode) ?? .add
+    opacity = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity) ?? KeyframeGroup(Vector1D(100))
+    shape = try container.decode(KeyframeGroup<BezierPath>.self, forKey: .shape)
+    inverted = try container.decodeIfPresent(Bool.self, forKey: .inverted) ?? false
+    expansion = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .expansion) ?? KeyframeGroup(Vector1D(0))
+  }
+
+  init(dictionary: [String: Any]) throws {
+    if
+      let modeRawType = dictionary[CodingKeys.mode.rawValue] as? String,
+      let mode = MaskMode(rawValue: modeRawType)
+    {
+      self.mode = mode
+    } else {
+      mode = .add
+    }
+    if let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any] {
+      opacity = try KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+    } else {
+      opacity = KeyframeGroup(Vector1D(100))
+    }
+    let shapeDictionary: [String: Any] = try dictionary.value(for: CodingKeys.shape)
+    shape = try KeyframeGroup<BezierPath>(dictionary: shapeDictionary)
+    inverted = (try? dictionary.value(for: CodingKeys.inverted)) ?? false
+    if let expansionDictionary = dictionary[CodingKeys.expansion.rawValue] as? [String: Any] {
+      expansion = try KeyframeGroup<Vector1D>(dictionary: expansionDictionary)
+    } else {
+      expansion = KeyframeGroup(Vector1D(0))
+    }
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case mode
+    case opacity = "o"
+    case inverted = "inv"
+    case shape = "pt"
+    case expansion = "x"
+  }
+
+  let mode: MaskMode
+
+  let opacity: KeyframeGroup<Vector1D>
+
+  let shape: KeyframeGroup<BezierPath>
+
+  let inverted: Bool
+
+  let expansion: KeyframeGroup<Vector1D>
+}