lottie-ios 3.2.3 → 3.4.0

package/{lottie-swift/src → Sources}/Private/Model/ShapeItems/Merge.swift

@@ -7,6 +7,8 @@
 
 import Foundation
 
+// MARK: - MergeMode
+
 enum MergeMode: Int, Codable {
   case none
   case merge
@@ -16,26 +18,42 @@ enum MergeMode: Int, Codable {
   case exclude
 }
 
+// MARK: - Merge
+
 /// An item that define an ellipse shape
 final class Merge: ShapeItem {
-  
-  /// The mode of the merge path
-  let mode: MergeMode
-  
-  private enum CodingKeys : String, CodingKey {
-    case mode = "mm"
-  }
-  
+
+  // MARK: Lifecycle
+
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: Merge.CodingKeys.self)
-    self.mode = try container.decode(MergeMode.self, forKey: .mode)
+    mode = try container.decode(MergeMode.self, forKey: .mode)
     try super.init(from: decoder)
   }
-  
+
+  required init(dictionary: [String: Any]) throws {
+    let modeRawType: Int = try dictionary.value(for: CodingKeys.mode)
+    guard let mode = MergeMode(rawValue: modeRawType) else {
+      throw InitializableError.invalidInput
+    }
+    self.mode = mode
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The mode of the merge path
+  let mode: MergeMode
+
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)
     var container = encoder.container(keyedBy: CodingKeys.self)
     try container.encode(mode, forKey: .mode)
   }
-  
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case mode = "mm"
+  }
 }

package/Sources/Private/Model/ShapeItems/Rectangle.swift

@@ -0,0 +1,73 @@
+//
+//  Rectangle.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+/// An item that define an ellipse shape
+final class Rectangle: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Rectangle.CodingKeys.self)
+    direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction) ?? .clockwise
+    position = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .position)
+    size = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .size)
+    cornerRadius = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .cornerRadius)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if
+      let directionRawType = dictionary[CodingKeys.direction.rawValue] as? Int,
+      let direction = PathDirection(rawValue: directionRawType)
+    {
+      self.direction = direction
+    } else {
+      direction = .clockwise
+    }
+    let positionDictionary: [String: Any] = try dictionary.value(for: CodingKeys.position)
+    position = try KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+    let sizeDictionary: [String: Any] = try dictionary.value(for: CodingKeys.size)
+    size = try KeyframeGroup<Vector3D>(dictionary: sizeDictionary)
+    let cornerRadiusDictionary: [String: Any] = try dictionary.value(for: CodingKeys.cornerRadius)
+    cornerRadius = try KeyframeGroup<Vector1D>(dictionary: cornerRadiusDictionary)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The direction of the rect.
+  let direction: PathDirection
+
+  /// The position
+  let position: KeyframeGroup<Vector3D>
+
+  /// The size
+  let size: KeyframeGroup<Vector3D>
+
+  /// The Corner radius of the rectangle
+  let cornerRadius: KeyframeGroup<Vector1D>
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(direction, forKey: .direction)
+    try container.encode(position, forKey: .position)
+    try container.encode(size, forKey: .size)
+    try container.encode(cornerRadius, forKey: .cornerRadius)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case direction = "d"
+    case position = "p"
+    case size = "s"
+    case cornerRadius = "r"
+  }
+}

package/Sources/Private/Model/ShapeItems/Repeater.swift

@@ -0,0 +1,136 @@
+//
+//  Repeater.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+/// An item that define an ellipse shape
+final class Repeater: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Repeater.CodingKeys.self)
+    copies = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .copies) ?? KeyframeGroup(Vector1D(0))
+    offset = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .offset) ?? KeyframeGroup(Vector1D(0))
+    let transformContainer = try container.nestedContainer(keyedBy: TransformKeys.self, forKey: .transform)
+    startOpacity = try transformContainer
+      .decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .startOpacity) ?? KeyframeGroup(Vector1D(100))
+    endOpacity = try transformContainer
+      .decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .endOpacity) ?? KeyframeGroup(Vector1D(100))
+    rotation = try transformContainer
+      .decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation) ?? KeyframeGroup(Vector1D(0))
+    position = try transformContainer
+      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .position) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+    anchorPoint = try transformContainer
+      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchorPoint) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+    scale = try transformContainer
+      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale) ?? KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if let copiesDictionary = dictionary[CodingKeys.copies.rawValue] as? [String: Any] {
+      copies = try KeyframeGroup<Vector1D>(dictionary: copiesDictionary)
+    } else {
+      copies = KeyframeGroup(Vector1D(0))
+    }
+    if let offsetDictionary = dictionary[CodingKeys.offset.rawValue] as? [String: Any] {
+      offset = try KeyframeGroup<Vector1D>(dictionary: offsetDictionary)
+    } else {
+      offset = KeyframeGroup(Vector1D(0))
+    }
+    let transformDictionary: [String: Any] = try dictionary.value(for: CodingKeys.transform)
+    if let startOpacityDictionary = transformDictionary[TransformKeys.startOpacity.rawValue] as? [String: Any] {
+      startOpacity = try KeyframeGroup<Vector1D>(dictionary: startOpacityDictionary)
+    } else {
+      startOpacity = KeyframeGroup(Vector1D(100))
+    }
+    if let endOpacityDictionary = transformDictionary[TransformKeys.endOpacity.rawValue] as? [String: Any] {
+      endOpacity = try KeyframeGroup<Vector1D>(dictionary: endOpacityDictionary)
+    } else {
+      endOpacity = KeyframeGroup(Vector1D(100))
+    }
+    if let rotationDictionary = transformDictionary[TransformKeys.rotation.rawValue] as? [String: Any] {
+      rotation = try KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+    } else {
+      rotation = KeyframeGroup(Vector1D(0))
+    }
+    if let positionDictionary = transformDictionary[TransformKeys.position.rawValue] as? [String: Any] {
+      position = try KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+    } else {
+      position = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+    }
+    if let anchorPointDictionary = transformDictionary[TransformKeys.anchorPoint.rawValue] as? [String: Any] {
+      anchorPoint = try KeyframeGroup<Vector3D>(dictionary: anchorPointDictionary)
+    } else {
+      anchorPoint = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+    }
+    if let scaleDictionary = transformDictionary[TransformKeys.scale.rawValue] as? [String: Any] {
+      scale = try KeyframeGroup<Vector3D>(dictionary: scaleDictionary)
+    } else {
+      scale = KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
+    }
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The number of copies to repeat
+  let copies: KeyframeGroup<Vector1D>
+
+  /// The offset of each copy
+  let offset: KeyframeGroup<Vector1D>
+
+  /// Start Opacity
+  let startOpacity: KeyframeGroup<Vector1D>
+
+  /// End opacity
+  let endOpacity: KeyframeGroup<Vector1D>
+
+  /// The rotation
+  let rotation: KeyframeGroup<Vector1D>
+
+  /// Anchor Point
+  let anchorPoint: KeyframeGroup<Vector3D>
+
+  /// Position
+  let position: KeyframeGroup<Vector3D>
+
+  /// Scale
+  let scale: KeyframeGroup<Vector3D>
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(copies, forKey: .copies)
+    try container.encode(offset, forKey: .offset)
+    var transformContainer = container.nestedContainer(keyedBy: TransformKeys.self, forKey: .transform)
+    try transformContainer.encode(startOpacity, forKey: .startOpacity)
+    try transformContainer.encode(endOpacity, forKey: .endOpacity)
+    try transformContainer.encode(rotation, forKey: .rotation)
+    try transformContainer.encode(position, forKey: .position)
+    try transformContainer.encode(anchorPoint, forKey: .anchorPoint)
+    try transformContainer.encode(scale, forKey: .scale)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case copies = "c"
+    case offset = "o"
+    case transform = "tr"
+  }
+
+  private enum TransformKeys: String, CodingKey {
+    case rotation = "r"
+    case startOpacity = "so"
+    case endOpacity = "eo"
+    case anchorPoint = "a"
+    case position = "p"
+    case scale = "s"
+  }
+}

package/Sources/Private/Model/ShapeItems/Shape.swift

@@ -0,0 +1,56 @@
+//
+//  VectorShape.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+/// An item that defines an custom shape
+final class Shape: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Shape.CodingKeys.self)
+    path = try container.decode(KeyframeGroup<BezierPath>.self, forKey: .path)
+    direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let pathDictionary: [String: Any] = try dictionary.value(for: CodingKeys.path)
+    path = try KeyframeGroup<BezierPath>(dictionary: pathDictionary)
+    if
+      let directionRawValue = dictionary[CodingKeys.direction.rawValue] as? Int,
+      let direction = PathDirection(rawValue: directionRawValue)
+    {
+      self.direction = direction
+    } else {
+      direction = nil
+    }
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The Path
+  let path: KeyframeGroup<BezierPath>
+
+  let direction: PathDirection?
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(path, forKey: .path)
+    try container.encodeIfPresent(direction, forKey: .direction)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case path = "ks"
+    case direction = "d"
+  }
+}

package/Sources/Private/Model/ShapeItems/ShapeItem.swift

@@ -0,0 +1,163 @@
+//
+//  ShapeItem.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+// MARK: - ShapeType + ClassFamily
+
+/// Used for mapping a heterogeneous list to classes for parsing.
+extension ShapeType: ClassFamily {
+
+  static var discriminator: Discriminator = .type
+
+  func getType() -> AnyObject.Type {
+    switch self {
+    case .ellipse:
+      return Ellipse.self
+    case .fill:
+      return Fill.self
+    case .gradientFill:
+      return GradientFill.self
+    case .group:
+      return Group.self
+    case .gradientStroke:
+      return GradientStroke.self
+    case .merge:
+      return Merge.self
+    case .rectangle:
+      return Rectangle.self
+    case .repeater:
+      return Repeater.self
+    case .shape:
+      return Shape.self
+    case .star:
+      return Star.self
+    case .stroke:
+      return Stroke.self
+    case .trim:
+      return Trim.self
+    case .transform:
+      return ShapeTransform.self
+    default:
+      return ShapeItem.self
+    }
+  }
+}
+
+// MARK: - ShapeType
+
+enum ShapeType: String, Codable {
+  case ellipse = "el"
+  case fill = "fl"
+  case gradientFill = "gf"
+  case group = "gr"
+  case gradientStroke = "gs"
+  case merge = "mm"
+  case rectangle = "rc"
+  case repeater = "rp"
+  case round = "rd"
+  case shape = "sh"
+  case star = "sr"
+  case stroke = "st"
+  case trim = "tm"
+  case transform = "tr"
+  case unknown
+
+  public init(from decoder: Decoder) throws {
+    self = try ShapeType(rawValue: decoder.singleValueContainer().decode(RawValue.self)) ?? .unknown
+  }
+}
+
+// MARK: - ShapeItem
+
+/// An item belonging to a Shape Layer
+class ShapeItem: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: ShapeItem.CodingKeys.self)
+    name = try container.decodeIfPresent(String.self, forKey: .name) ?? "Layer"
+    type = try container.decode(ShapeType.self, forKey: .type)
+    hidden = try container.decodeIfPresent(Bool.self, forKey: .hidden) ?? false
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    name = (try? dictionary.value(for: CodingKeys.name)) ?? "Layer"
+    type = ShapeType(rawValue: try dictionary.value(for: CodingKeys.type)) ?? .unknown
+    hidden = (try? dictionary.value(for: CodingKeys.hidden)) ?? false
+  }
+
+  init(
+    name: String,
+    type: ShapeType,
+    hidden: Bool)
+  {
+    self.name = name
+    self.type = type
+    self.hidden = hidden
+  }
+
+  // MARK: Internal
+
+  /// The name of the shape
+  let name: String
+
+  /// The type of shape
+  let type: ShapeType
+
+  let hidden: Bool
+
+  // MARK: Fileprivate
+
+  fileprivate enum CodingKeys: String, CodingKey {
+    case name = "nm"
+    case type = "ty"
+    case hidden = "hd"
+  }
+}
+
+extension Array where Element == ShapeItem {
+
+  static func fromDictionaries(_ dictionaries: [[String: Any]]) throws -> [ShapeItem] {
+    try dictionaries.compactMap { dictionary in
+      let shapeType = dictionary[ShapeItem.CodingKeys.type.rawValue] as? String
+      switch ShapeType(rawValue: shapeType ?? ShapeType.unknown.rawValue) {
+      case .ellipse:
+        return try Ellipse(dictionary: dictionary)
+      case .fill:
+        return try Fill(dictionary: dictionary)
+      case .gradientFill:
+        return try GradientFill(dictionary: dictionary)
+      case .group:
+        return try Group(dictionary: dictionary)
+      case .gradientStroke:
+        return try GradientStroke(dictionary: dictionary)
+      case .merge:
+        return try Merge(dictionary: dictionary)
+      case .rectangle:
+        return try Rectangle(dictionary: dictionary)
+      case .repeater:
+        return try Repeater(dictionary: dictionary)
+      case .shape:
+        return try Shape(dictionary: dictionary)
+      case .star:
+        return try Star(dictionary: dictionary)
+      case .stroke:
+        return try Stroke(dictionary: dictionary)
+      case .trim:
+        return try Trim(dictionary: dictionary)
+      case .transform:
+        return try ShapeTransform(dictionary: dictionary)
+      case .none:
+        return nil
+      default:
+        return try ShapeItem(dictionary: dictionary)
+      }
+    }
+  }
+}

package/Sources/Private/Model/ShapeItems/ShapeTransform.swift

@@ -0,0 +1,136 @@
+//
+//  TransformItem.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+/// An item that define an ellipse shape
+final class ShapeTransform: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: ShapeTransform.CodingKeys.self)
+    anchor = try container
+      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchor) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+    position = try container
+      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .position) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+    scale = try container
+      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale) ?? KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
+    rotation = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation) ?? KeyframeGroup(Vector1D(0))
+    opacity = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity) ?? KeyframeGroup(Vector1D(100))
+    skew = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skew) ?? KeyframeGroup(Vector1D(0))
+    skewAxis = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skewAxis) ?? KeyframeGroup(Vector1D(0))
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if
+      let anchorDictionary = dictionary[CodingKeys.anchor.rawValue] as? [String: Any],
+      let anchor = try? KeyframeGroup<Vector3D>(dictionary: anchorDictionary)
+    {
+      self.anchor = anchor
+    } else {
+      anchor = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+    }
+    if
+      let positionDictionary = dictionary[CodingKeys.position.rawValue] as? [String: Any],
+      let position = try? KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+    {
+      self.position = position
+    } else {
+      position = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+    }
+    if
+      let scaleDictionary = dictionary[CodingKeys.scale.rawValue] as? [String: Any],
+      let scale = try? KeyframeGroup<Vector3D>(dictionary: scaleDictionary)
+    {
+      self.scale = scale
+    } else {
+      scale = KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
+    }
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotation.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+    {
+      self.rotation = rotation
+    } else {
+      rotation = KeyframeGroup(Vector1D(0))
+    }
+    if
+      let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any],
+      let opacity = try? KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+    {
+      self.opacity = opacity
+    } else {
+      opacity = KeyframeGroup(Vector1D(100))
+    }
+    if
+      let skewDictionary = dictionary[CodingKeys.skew.rawValue] as? [String: Any],
+      let skew = try? KeyframeGroup<Vector1D>(dictionary: skewDictionary)
+    {
+      self.skew = skew
+    } else {
+      skew = KeyframeGroup(Vector1D(0))
+    }
+    if
+      let skewAxisDictionary = dictionary[CodingKeys.skewAxis.rawValue] as? [String: Any],
+      let skewAxis = try? KeyframeGroup<Vector1D>(dictionary: skewAxisDictionary)
+    {
+      self.skewAxis = skewAxis
+    } else {
+      skewAxis = KeyframeGroup(Vector1D(0))
+    }
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// Anchor Point
+  let anchor: KeyframeGroup<Vector3D>
+
+  /// Position
+  let position: KeyframeGroup<Vector3D>
+
+  /// Scale
+  let scale: KeyframeGroup<Vector3D>
+
+  /// Rotation
+  let rotation: KeyframeGroup<Vector1D>
+
+  /// opacity
+  let opacity: KeyframeGroup<Vector1D>
+
+  /// Skew
+  let skew: KeyframeGroup<Vector1D>
+
+  /// Skew Axis
+  let skewAxis: KeyframeGroup<Vector1D>
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(anchor, forKey: .anchor)
+    try container.encode(position, forKey: .position)
+    try container.encode(scale, forKey: .scale)
+    try container.encode(rotation, forKey: .rotation)
+    try container.encode(opacity, forKey: .opacity)
+    try container.encode(skew, forKey: .skew)
+    try container.encode(skewAxis, forKey: .skewAxis)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case anchor = "a"
+    case position = "p"
+    case scale = "s"
+    case rotation = "r"
+    case opacity = "o"
+    case skew = "sk"
+    case skewAxis = "sa"
+  }
+}