lottie-ios 3.2.2 → 3.4.1

package/lottie-swift/src/Private/Model/Layers/LayerModel.swift

@@ -1,150 +0,0 @@
-//
-//  Layer.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/7/19.
-//
-
-import Foundation
-
-/// 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
-    }
-  }
-}
-
-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
-  }
-}
-
-public enum MatteType: Int, Codable {
-  case none
-  case add
-  case invert
-  case unknown
-}
-
-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
-}
-
-/**
- A base top container for shapes, images, and other view objects.
- */
-class LayerModel: Codable {
-  
-  /// 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
-  
-  private 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 = "parent"
-    case blendMode = "bm"
-    case masks = "masksProperties"
-    case timeStretch = "sr"
-    case matte = "tt"
-    case hidden = "hd"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: LayerModel.CodingKeys.self)
-    self.name = try container.decodeIfPresent(String.self, forKey: .name) ?? "Layer"
-    self.index = try container.decode(Int.self, forKey: .index)
-    self.type = try container.decode(LayerType.self, forKey: .type)
-    self.coordinateSpace = try container.decodeIfPresent(CoordinateSpace.self, forKey: .coordinateSpace) ?? .type2d
-    self.inFrame = try container.decode(Double.self, forKey: .inFrame)
-    self.outFrame = try container.decode(Double.self, forKey: .outFrame)
-    self.startTime = try container.decode(Double.self, forKey: .startTime)
-    self.transform = try container.decode(Transform.self, forKey: .transform)
-    self.parent = try container.decodeIfPresent(Int.self, forKey: .parent)
-    self.blendMode = try container.decodeIfPresent(BlendMode.self, forKey: .blendMode) ?? .normal
-    self.masks = try container.decodeIfPresent([Mask].self, forKey: .masks)
-    self.timeStretch = try container.decodeIfPresent(Double.self, forKey: .timeStretch) ?? 1
-    self.matte = try container.decodeIfPresent(MatteType.self, forKey: .matte)
-    self.hidden = try container.decodeIfPresent(Bool.self, forKey: .hidden) ?? false
-  }
-}

package/lottie-swift/src/Private/Model/Objects/DashPattern.swift

@@ -1,24 +0,0 @@
-//
-//  DashPattern.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/22/19.
-//
-
-import Foundation
-
-enum DashElementType: String, Codable {
-  case offset = "o"
-  case dash = "d"
-  case gap = "g"
-}
-
-final class DashElement: Codable {
-  let type: DashElementType
-  let value: KeyframeGroup<Vector1D>
-  
-  enum CodingKeys : String, CodingKey {
-    case type = "n"
-    case value = "v"
-  }
-}

package/lottie-swift/src/Private/Model/Objects/Marker.swift

@@ -1,23 +0,0 @@
-//
-//  Marker.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/9/19.
-//
-
-import Foundation
-
-/// A time marker
-final class Marker: Codable {
-  
-  /// The Marker Name
-  let name: String
-  
-  /// The Frame time of the marker
-  let frameTime: AnimationFrameTime
-  
-  enum CodingKeys : String, CodingKey {
-    case name = "cm"
-    case frameTime = "tm"
-  }
-}

package/lottie-swift/src/Private/Model/Objects/Mask.swift

@@ -1,48 +0,0 @@
-//
-//  Mask.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-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"
-}
-
-final class Mask: Codable {
-  
-  let mode: MaskMode
-  
-  let opacity: KeyframeGroup<Vector1D>
-  
-  let shape: KeyframeGroup<BezierPath>
-  
-  let inverted: Bool
-  
-  let expansion: KeyframeGroup<Vector1D>
-  
-  enum CodingKeys : String, CodingKey {
-    case mode = "mode"
-    case opacity = "o"
-    case inverted = "inv"
-    case shape = "pt"
-    case expansion = "x"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Mask.CodingKeys.self)
-    self.mode = try container.decodeIfPresent(MaskMode.self, forKey: .mode) ?? .add
-    self.opacity = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity) ?? KeyframeGroup(Vector1D(100))
-    self.shape = try container.decode(KeyframeGroup<BezierPath>.self, forKey: .shape)
-    self.inverted = try container.decodeIfPresent(Bool.self, forKey: .inverted) ?? false
-    self.expansion = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .expansion) ?? KeyframeGroup(Vector1D(0))
-  }
-}

package/lottie-swift/src/Private/Model/Objects/Transform.swift

@@ -1,105 +0,0 @@
-//
-//  Transform.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/7/19.
-//
-
-import Foundation
-
-/// The animatable transform for a layer. Controls position, rotation, scale, and opacity.
-final class Transform: Codable {
-  
-  /// The anchor point of the transform.
-  let anchorPoint: KeyframeGroup<Vector3D>
-  
-  /// The position of the transform. This is nil if the position data was split.
-  let position: KeyframeGroup<Vector3D>?
-  
-  /// The positionX of the transform. This is nil if the position property is set.
-  let positionX: KeyframeGroup<Vector1D>?
-  
-  /// The positionY of the transform. This is nil if the position property is set.
-  let positionY: KeyframeGroup<Vector1D>?
-  
-  /// The scale of the transform
-  let scale: KeyframeGroup<Vector3D>
-  
-  /// The rotation of the transform. Note: This is single dimensional rotation.
-  let rotation: KeyframeGroup<Vector1D>
-  
-  /// The opacity of the transform.
-  let opacity: KeyframeGroup<Vector1D>
-  
-  /// Should always be nil.
-  let rotationZ: KeyframeGroup<Vector1D>?
-  
-  enum CodingKeys : String, CodingKey {
-    case anchorPoint = "a"
-    case position = "p"
-    case positionX = "px"
-    case positionY = "py"
-    case scale = "s"
-    case rotation = "r"
-    case rotationZ = "rz"
-    case opacity = "o"
-  }
-
-  enum PositionCodingKeys : String, CodingKey {
-    case split = "s"
-    case positionX = "x"
-    case positionY = "y"
-  }
-  
-  
-  required init(from decoder: Decoder) throws {
-    /**
-     This manual override of decode is required because we want to throw an error
-     in the case that there is not position data.
-     */
-    let container = try decoder.container(keyedBy: Transform.CodingKeys.self)
-    
-    // AnchorPoint
-    self.anchorPoint = try container.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchorPoint) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
-    
-    // Position
-    if container.contains(.positionX), container.contains(.positionY) {
-      // Position dimensions are split into two keyframe groups
-      self.positionX = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .positionX)
-      self.positionY = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .positionY)
-      self.position = nil
-    } else if let positionKeyframes = try? container.decode(KeyframeGroup<Vector3D>.self, forKey: .position) {
-      // Position dimensions are a single keyframe group.
-      self.position = positionKeyframes
-      self.positionX = nil
-      self.positionY = nil
-    } else if let positionContainer = try? container.nestedContainer(keyedBy: PositionCodingKeys.self, forKey: .position),
-      let positionX = try? positionContainer.decode(KeyframeGroup<Vector1D>.self, forKey: .positionX),
-      let positionY = try? positionContainer.decode(KeyframeGroup<Vector1D>.self, forKey: .positionY) {
-      /// Position keyframes are split and nested.
-      self.positionX = positionX
-      self.positionY = positionY
-      self.position = nil
-    } else {
-      /// Default value.
-      self.position = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
-      self.positionX = nil
-      self.positionY = nil
-    }
-    
-    
-    // Scale
-    self.scale = try container.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale) ?? KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
-    
-    // Rotation
-    if let rotationZ = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotationZ) {
-      self.rotation = rotationZ
-    } else {
-       self.rotation = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation) ?? KeyframeGroup(Vector1D(0))
-    }
-    self.rotationZ = nil
-    
-    // Opacity
-    self.opacity = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity) ?? KeyframeGroup(Vector1D(100))
-  }
-}

package/lottie-swift/src/Private/Model/ShapeItems/Ellipse.swift

@@ -1,50 +0,0 @@
-//
-//  EllipseItem.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-enum PathDirection: Int, Codable {
-  case clockwise = 1
-  case userSetClockwise = 2
-  case counterClockwise = 3
-}
-
-/// An item that define an ellipse shape
-final class Ellipse: ShapeItem {
-  
-  /// The direction of the ellipse.
-  let direction: PathDirection
-  
-  /// The position of the ellipse
-  let position: KeyframeGroup<Vector3D>
-  
-  /// The size of the ellipse
-  let size: KeyframeGroup<Vector3D>
-  
-  private enum CodingKeys : String, CodingKey {
-    case direction = "d"
-    case position = "p"
-    case size = "s"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Ellipse.CodingKeys.self)
-    self.direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction) ?? .clockwise
-    self.position = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .position)
-    self.size = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .size)
-    try super.init(from: decoder)
-  }
-  
-  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)
-  }
-  
-}

package/lottie-swift/src/Private/Model/ShapeItems/FillI.swift

@@ -1,49 +0,0 @@
-//
-//  FillShape.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-enum FillRule: Int, Codable {
-  case none
-  case nonZeroWinding
-  case evenOdd
-}
-
-/// An item that defines a fill render
-final class Fill: ShapeItem {
-  
-  /// The opacity of the fill
-  let opacity: KeyframeGroup<Vector1D>
-  
-  /// The color keyframes for the fill
-  let color: KeyframeGroup<Color>
-  
-  let fillRule: FillRule
-  
-  private enum CodingKeys : String, CodingKey {
-    case opacity = "o"
-    case color = "c"
-    case fillRule = "r"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Fill.CodingKeys.self)
-    self.opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-    self.color = try container.decode(KeyframeGroup<Color>.self, forKey: .color)
-    self.fillRule = try container.decodeIfPresent(FillRule.self, forKey: .fillRule) ?? .nonZeroWinding
-    try super.init(from: decoder)
-  }
-  
-  override func encode(to encoder: Encoder) throws {
-    try super.encode(to: encoder)
-    var container = encoder.container(keyedBy: CodingKeys.self)
-    try container.encode(opacity, forKey: .opacity)
-    try container.encode(color, forKey: .color)
-    try container.encode(fillRule, forKey: .fillRule)
-  }
-  
-}

package/lottie-swift/src/Private/Model/ShapeItems/GradientFill.swift

@@ -1,86 +0,0 @@
-//
-//  GradientFill.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-enum GradientType: Int, Codable {
-  case none
-  case linear
-  case radial
-}
-
-/// An item that define a gradient fill
-final class GradientFill: ShapeItem {
-  
-  /// The opacity of the fill
-  let opacity: KeyframeGroup<Vector1D>
-  
-  /// The start of the gradient
-  let startPoint: KeyframeGroup<Vector3D>
-  
-  /// The end of the gradient
-  let endPoint: KeyframeGroup<Vector3D>
-  
-  /// The type of gradient
-  let gradientType: GradientType
-  
-  /// Gradient Highlight Length. Only if type is Radial
-  let highlightLength: KeyframeGroup<Vector1D>?
-  
-  /// Highlight Angle. Only if type is Radial
-  let highlightAngle: KeyframeGroup<Vector1D>?
-  
-  /// The number of color points in the gradient
-  let numberOfColors: Int
-  
-  /// The Colors of the gradient.
-  let colors: KeyframeGroup<[Double]>
-  
-  private enum CodingKeys : String, CodingKey {
-    case opacity = "o"
-    case startPoint = "s"
-    case endPoint = "e"
-    case gradientType = "t"
-    case highlightLength = "h"
-    case highlightAngle = "a"
-    case colors = "g"
-  }
-  
-  private enum GradientDataKeys : String, CodingKey {
-    case numberOfColors = "p"
-    case colors = "k"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: GradientFill.CodingKeys.self)
-    self.opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-    self.startPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .startPoint)
-    self.endPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .endPoint)
-    self.gradientType = try container.decode(GradientType.self, forKey: .gradientType)
-    self.highlightLength = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightLength)
-    self.highlightAngle = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightAngle)
-    let colorsContainer = try container.nestedContainer(keyedBy: GradientDataKeys.self, forKey: .colors)
-    self.colors = try colorsContainer.decode(KeyframeGroup<[Double]>.self, forKey: .colors)
-    self.numberOfColors = try colorsContainer.decode(Int.self, forKey: .numberOfColors)
-    try super.init(from: decoder)
-  }
-  
-  override func encode(to encoder: Encoder) throws {
-    try super.encode(to: encoder)
-    var container = encoder.container(keyedBy: CodingKeys.self)
-    try container.encode(opacity, forKey: .opacity)
-    try container.encode(startPoint, forKey: .startPoint)
-    try container.encode(endPoint, forKey: .endPoint)
-    try container.encode(gradientType, forKey: .gradientType)
-    try container.encodeIfPresent(highlightLength, forKey: .highlightLength)
-    try container.encodeIfPresent(highlightAngle, forKey: .highlightAngle)
-    var colorsContainer = container.nestedContainer(keyedBy: GradientDataKeys.self, forKey: .colors)
-    try colorsContainer.encode(numberOfColors, forKey: .numberOfColors)
-    try colorsContainer.encode(colors, forKey: .colors)
-  }
-  
-}

package/lottie-swift/src/Private/Model/ShapeItems/GradientStroke.swift

@@ -1,125 +0,0 @@
-//
-//  GradientStroke.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-enum LineCap: Int, Codable {
-  case none
-  case butt
-  case round
-  case square
-}
-
-enum LineJoin: Int, Codable {
-  case none
-  case miter
-  case round
-  case bevel
-}
-
-/// An item that define an ellipse shape
-final class GradientStroke: ShapeItem {
-  
-  /// The opacity of the fill
-  let opacity: KeyframeGroup<Vector1D>
-  
-  /// The start of the gradient
-  let startPoint: KeyframeGroup<Vector3D>
-  
-  /// The end of the gradient
-  let endPoint: KeyframeGroup<Vector3D>
-  
-  /// The type of gradient
-  let gradientType: GradientType
-  
-  /// Gradient Highlight Length. Only if type is Radial
-  let highlightLength: KeyframeGroup<Vector1D>?
-  
-  /// Highlight Angle. Only if type is Radial
-  let highlightAngle: KeyframeGroup<Vector1D>?
-  
-  /// The number of color points in the gradient
-  let numberOfColors: Int
-  
-  /// The Colors of the gradient.
-  let colors: KeyframeGroup<[Double]>
-  
-  /// The width of the stroke
-  let width: KeyframeGroup<Vector1D>
-  
-  /// Line Cap
-  let lineCap: LineCap
-  
-  /// Line Join
-  let lineJoin: LineJoin
-  
-  /// Miter Limit
-  let miterLimit: Double
-  
-  /// The dash pattern of the stroke
-  let dashPattern: [DashElement]?
-  
-  private enum CodingKeys : String, CodingKey {
-    case opacity = "o"
-    case startPoint = "s"
-    case endPoint = "e"
-    case gradientType = "t"
-    case highlightLength = "h"
-    case highlightAngle = "a"
-    case colors = "g"
-    case width = "w"
-    case lineCap = "lc"
-    case lineJoin = "lj"
-    case miterLimit = "ml"
-    case dashPattern = "d"
-  }
-  
-  private enum GradientDataKeys : String, CodingKey {
-    case numberOfColors = "p"
-    case colors = "k"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: GradientStroke.CodingKeys.self)
-    self.opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-    self.startPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .startPoint)
-    self.endPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .endPoint)
-    self.gradientType = try container.decode(GradientType.self, forKey: .gradientType)
-    self.highlightLength = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightLength)
-    self.highlightAngle = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightAngle)
-    self.width = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .width)
-    self.lineCap = try container.decodeIfPresent(LineCap.self, forKey: .lineCap) ?? .round
-    self.lineJoin = try container.decodeIfPresent(LineJoin.self, forKey: .lineJoin) ?? .round
-    self.miterLimit = try container.decodeIfPresent(Double.self, forKey: .miterLimit) ?? 4
-    // TODO Decode Color Objects instead of array.
-    let colorsContainer = try container.nestedContainer(keyedBy: GradientDataKeys.self, forKey: .colors)
-    self.colors = try colorsContainer.decode(KeyframeGroup<[Double]>.self, forKey: .colors)
-    self.numberOfColors = try colorsContainer.decode(Int.self, forKey: .numberOfColors)
-    self.dashPattern = try container.decodeIfPresent([DashElement].self, forKey: .dashPattern)
-    try super.init(from: decoder)
-  }
-  
-  override func encode(to encoder: Encoder) throws {
-    try super.encode(to: encoder)
-    var container = encoder.container(keyedBy: CodingKeys.self)
-    try container.encode(opacity, forKey: .opacity)
-    try container.encode(startPoint, forKey: .startPoint)
-    try container.encode(endPoint, forKey: .endPoint)
-    try container.encode(gradientType, forKey: .gradientType)
-    try container.encodeIfPresent(highlightLength, forKey: .highlightLength)
-    try container.encodeIfPresent(highlightAngle, forKey: .highlightAngle)
-    try container.encode(width, forKey: .width)
-    try container.encode(lineCap, forKey: .lineCap)
-    try container.encode(lineJoin, forKey: .lineJoin)
-    try container.encode(miterLimit, forKey: .miterLimit)
-    var colorsContainer = container.nestedContainer(keyedBy: GradientDataKeys.self, forKey: .colors)
-    try colorsContainer.encode(numberOfColors, forKey: .numberOfColors)
-    try colorsContainer.encode(colors, forKey: .colors)
-    try container.encodeIfPresent(dashPattern, forKey: .dashPattern)
-  }
-  
-}

package/lottie-swift/src/Private/Model/ShapeItems/Group.swift

@@ -1,32 +0,0 @@
-//
-//  GroupItem.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-/// An item that define an ellipse shape
-final class Group: ShapeItem {
-  
-  /// A list of shape items.
-  let items: [ShapeItem]
-  
-  private enum CodingKeys : String, CodingKey {
-    case items = "it"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Group.CodingKeys.self)
-    self.items = try container.decode([ShapeItem].self, ofFamily: ShapeType.self, forKey: .items)
-    try super.init(from: decoder)
-  }
-  
-  override func encode(to encoder: Encoder) throws {
-    try super.encode(to: encoder)
-    var container = encoder.container(keyedBy: CodingKeys.self)
-    try container.encode(items, forKey: .items)
-  }
-
-}