lottie-ios 3.2.3 → 3.4.0

package/lottie-swift/src/Private/Model/Animation.swift

@@ -1,107 +0,0 @@
-//
-//  Animation.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/7/19.
-//
-
-import Foundation
-
-public enum CoordinateSpace: Int, Codable {
-  case type2d
-  case type3d
-}
-
-/**
- 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 {
-  
-  /// The version of the JSON Schema.
-  let version: String
-  
-  /// The coordinate space of the composition.
-  let type: CoordinateSpace
-  
-  /// 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
-  
-  /// 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]?
-  
-  /// 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 }
-  }
-  
-  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 = "layers"
-    case glyphs = "chars"
-    case fonts = "fonts"
-    case assetLibrary = "assets"
-    case markers = "markers"
-  }
-  
-  required public init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Animation.CodingKeys.self)
-    self.version = try container.decode(String.self, forKey: .version)
-    self.type = try container.decodeIfPresent(CoordinateSpace.self, forKey: .type) ?? .type2d
-    self.startFrame = try container.decode(AnimationFrameTime.self, forKey: .startFrame)
-    self.endFrame = try container.decode(AnimationFrameTime.self, forKey: .endFrame)
-    self.framerate = try container.decode(Double.self, forKey: .framerate)
-    self.width = try container.decode(Int.self, forKey: .width)
-    self.height = try container.decode(Int.self, forKey: .height)
-    self.layers = try container.decode([LayerModel].self, ofFamily: LayerType.self, forKey: .layers)
-    self.glyphs = try container.decodeIfPresent([Glyph].self, forKey: .glyphs)
-    self.fonts = try container.decodeIfPresent(FontList.self, forKey: .fonts)
-    self.assetLibrary = try container.decodeIfPresent(AssetLibrary.self, forKey: .assetLibrary)
-    self.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 {
-      self.markerMap = nil
-    }
-  }
-
-}

package/lottie-swift/src/Private/Model/Assets/Asset.swift

@@ -1,27 +0,0 @@
-//
-//  Asset.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/9/19.
-//
-
-import Foundation
-
-public class Asset: Codable {
-  
-  /// The ID of the asset
-  public let id: String
-  
-  private enum CodingKeys : String, CodingKey {
-    case id = "id"
-  }
-  
-  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 {
-      self.id = String(try container.decode(Int.self, forKey: .id))
-    }
-  }
-}

package/lottie-swift/src/Private/Model/Assets/ImageAsset.swift

@@ -1,48 +0,0 @@
-//
-//  ImageAsset.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/9/19.
-//
-
-import Foundation
-
-public final class ImageAsset: Asset {
-  
-  /// Image name
-  public let name: String
-  
-  /// Image Directory
-  public let directory: String
-  
-  /// Image Size
-  public let width: Double
-  
-  public let height: Double
-  
-  enum CodingKeys : String, CodingKey {
-    case name = "p"
-    case directory = "u"
-    case width = "w"
-    case height = "h"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: ImageAsset.CodingKeys.self)
-    self.name = try container.decode(String.self, forKey: .name)
-    self.directory = try container.decode(String.self, forKey: .directory)
-    self.width = try container.decode(Double.self, forKey: .width)
-    self.height = try container.decode(Double.self, forKey: .height)
-    try super.init(from: decoder)
-  }
-  
-  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)
-  }
-
-}

package/lottie-swift/src/Private/Model/Keyframes/Keyframe.swift

@@ -1,128 +0,0 @@
-//
-//  Keyframe.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/7/19.
-//
-
-import Foundation
-import CoreGraphics
-
-/**
- Keyframe represents a point in time and is the container for datatypes.
- Note: This is a parent class and should not be used directly.
- */
-final class Keyframe<T: Interpolatable> {
-  
-  /// The value of the keyframe
-  let value: T
-  /// The time in frames of the keyframe.
-  let time: CGFloat
-  /// A hold keyframe freezes interpolation until the next keyframe that is not a hold.
-  let isHold: Bool
-  /// The in tangent for the time interpolation curve.
-  let inTangent: Vector2D?
-  /// The out tangent for the time interpolation curve.
-  let outTangent: Vector2D?
-  
-  /// The spacial in tangent of the vector.
-  let spatialInTangent: Vector3D?
-  /// The spacial out tangent of the vector.
-  let spatialOutTangent: Vector3D?
-  
-  /// Initialize a value-only keyframe with no time data.
-  init(_ value: T,
-       spatialInTangent: Vector3D? = nil,
-       spatialOutTangent: Vector3D? = nil) {
-    self.value = value
-    self.time = 0
-    self.isHold = true
-    self.inTangent = nil
-    self.outTangent = nil
-    self.spatialInTangent = spatialInTangent
-    self.spatialOutTangent = spatialOutTangent
-  }
-  
-  /// Initialize a keyframe
-  init(value: T,
-       time: Double,
-       isHold: Bool,
-       inTangent: Vector2D?,
-       outTangent: Vector2D?,
-       spatialInTangent: Vector3D? = nil,
-       spatialOutTangent: Vector3D? = nil) {
-    self.value = value
-    self.time = CGFloat(time)
-    self.isHold = isHold
-    self.outTangent = outTangent
-    self.inTangent = inTangent
-    self.spatialInTangent = spatialInTangent
-    self.spatialOutTangent = spatialOutTangent
-  }
-  
-}
-
-/**
- A generic class used to parse and remap keyframe json.
- 
- Keyframe json has a couple of different variations and formats depending on the
- type of keyframea and also the version of the JSON. By parsing the raw data
- we can reconfigure it into a constant format.
- */
-final class KeyframeData<T: Codable>: Codable {
-  
-  /// The start value of the keyframe
-  let startValue: T?
-  /// The End value of the keyframe. Note: Newer versions animation json do not have this field.
-  let endValue: T?
-  /// The time in frames of the keyframe.
-  let time: Double?
-  /// A hold keyframe freezes interpolation until the next keyframe that is not a hold.
-  let hold: Int?
-  
-  /// The in tangent for the time interpolation curve.
-  let inTangent: Vector2D?
-  /// The out tangent for the time interpolation curve.
-  let outTangent: Vector2D?
-  
-  /// The spacial in tangent of the vector.
-  let spatialInTangent: Vector3D?
-  /// The spacial out tangent of the vector.
-  let spatialOutTangent:Vector3D?
-  
-  init(startValue: T?,
-       endValue: T?,
-       time: Double?,
-       hold: Int?,
-       inTangent: Vector2D?,
-       outTangent: Vector2D?,
-       spatialInTangent: Vector3D?,
-       spatialOutTangent: Vector3D?) {
-    self.startValue = startValue
-    self.endValue = endValue
-    self.time = time
-    self.hold = hold
-    self.inTangent = inTangent
-    self.outTangent = outTangent
-    self.spatialInTangent = spatialInTangent
-    self.spatialOutTangent = spatialOutTangent
-  }
-  
-  enum CodingKeys : String, CodingKey {
-    case startValue = "s"
-    case endValue = "e"
-    case time = "t"
-    case hold = "h"
-    case inTangent = "i"
-    case outTangent = "o"
-    case spatialInTangent = "ti"
-    case spatialOutTangent = "to"
-  }
-  
-  var isHold: Bool {
-    if let hold = hold {
-      return hold > 0
-    }
-    return false
-  }
-}

package/lottie-swift/src/Private/Model/Keyframes/KeyframeGroup.swift

@@ -1,108 +0,0 @@
-//
-//  KeyframeGroup.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/14/19.
-//
-
-import Foundation
-
-/**
- Used for coding/decoding a group of Keyframes by type.
- 
- Keyframe data is wrapped in a dictionary { "k" : KeyframeData }.
- The keyframe data can either be an array of keyframes or, if no animation is present, the raw value.
- This helper object is needed to properly decode the json.
- */
-
-final class KeyframeGroup<T>: Codable where T: Codable, T: Interpolatable {
-  
-  let keyframes: ContiguousArray<Keyframe<T>>
-  
-  private enum KeyframeWrapperKey: String, CodingKey {
-    case keyframeData = "k"
-  }
-  
-  init(keyframes: ContiguousArray<Keyframe<T>>) {
-    self.keyframes = keyframes
-  }
-  
-  init(_ value: T) {
-    self.keyframes = [Keyframe(value)]
-  }
-
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: KeyframeWrapperKey.self)
-    
-    if let keyframeData: T = try? container.decode(T.self, forKey: .keyframeData) {
-      /// Try to decode raw value; No keyframe data.
-      self.keyframes = [Keyframe<T>(keyframeData)]
-    } else {
-      /**
-       Decode and array of keyframes.
-       
-       Body Movin and Lottie deal with keyframes in different ways.
-       
-       A keyframe object in Body movin defines a span of time with a START
-       and an END, from the current keyframe time to the next keyframe time.
-       
-       A keyframe object in Lottie defines a singular point in time/space.
-       This point has an in-tangent and an out-tangent.
-       
-       To properly decode this we must iterate through keyframes while holding
-       reference to the previous keyframe.
-       */
-      
-      var keyframesContainer = try container.nestedUnkeyedContainer(forKey: .keyframeData)
-      var keyframes = ContiguousArray<Keyframe<T>>()
-      var previousKeyframeData: KeyframeData<T>?
-      while(!keyframesContainer.isAtEnd) {
-        // Ensure that Time and Value are present.
-        
-        let keyframeData = try keyframesContainer.decode(KeyframeData<T>.self)
-        
-        guard let value: T = keyframeData.startValue ?? previousKeyframeData?.endValue,
-          let time = keyframeData.time else {
-            /// Missing keyframe data. JSON must be corrupt.
-            throw DecodingError.dataCorruptedError(forKey: KeyframeWrapperKey.keyframeData, in: container, debugDescription: "Missing keyframe data.")
-        }
-        
-        keyframes.append(Keyframe<T>(value: value,
-                                    time: time,
-                                    isHold: keyframeData.isHold,
-                                    inTangent: previousKeyframeData?.inTangent,
-                                    outTangent: keyframeData.outTangent,
-                                    spatialInTangent: previousKeyframeData?.spatialInTangent,
-                                    spatialOutTangent: keyframeData.spatialOutTangent))
-        previousKeyframeData = keyframeData
-      }
-      self.keyframes = keyframes
-    }
-  }
-  
-  func encode(to encoder: Encoder) throws {
-    var container = encoder.container(keyedBy: KeyframeWrapperKey.self)
-    
-    if keyframes.count == 1 {
-      let keyframe = keyframes[0]
-      try container.encode(keyframe.value, forKey: .keyframeData)
-    } else {
-      var keyframeContainer = container.nestedUnkeyedContainer(forKey: .keyframeData)
-      
-      for i in 1..<keyframes.endIndex {
-        let keyframe = keyframes[i-1]
-        let nextKeyframe = keyframes[i]
-        let keyframeData = KeyframeData<T>(startValue: keyframe.value,
-                                                  endValue: nextKeyframe.value,
-                                                  time: Double(keyframe.time),
-                                                  hold: keyframe.isHold ? 1 : nil,
-                                                  inTangent: nextKeyframe.inTangent,
-                                                  outTangent: keyframe.outTangent,
-                                                  spatialInTangent: nil,
-                                                  spatialOutTangent: nil)
-        try keyframeContainer.encode(keyframeData)
-      }
-    }
-  }
-  
-}

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))
-  }
-}