lottie-ios 3.2.3 → 3.4.0

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

@@ -1,68 +0,0 @@
-//
-//  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 {
-  
-  /// 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>
-  
-  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"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: ShapeTransform.CodingKeys.self)
-    self.anchor = try container.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchor) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
-    self.position = try container.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .position) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
-    self.scale = try container.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale) ?? KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
-    self.rotation = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation) ?? KeyframeGroup(Vector1D(0))
-    self.opacity = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity) ?? KeyframeGroup(Vector1D(100))
-    self.skew = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skew) ?? KeyframeGroup(Vector1D(0))
-    self.skewAxis =  try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skewAxis) ?? KeyframeGroup(Vector1D(0))
-    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(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)
-  }
-  
-}

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

@@ -1,86 +0,0 @@
-//
-//  Star.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-enum StarType: Int, Codable {
-  case none
-  case star
-  case polygon
-}
-
-/// An item that define an ellipse shape
-final class Star: ShapeItem {
-  
-  /// The direction of the star.
-  let direction: PathDirection
-  
-  /// The position of the star
-  let position: KeyframeGroup<Vector3D>
-  
-  /// The outer radius of the star
-  let outerRadius: KeyframeGroup<Vector1D>
-  
-  /// The outer roundness of the star
-  let outerRoundness: KeyframeGroup<Vector1D>
-  
-  /// The outer radius of the star
-  let innerRadius: KeyframeGroup<Vector1D>?
-  
-  /// The outer roundness of the star
-  let innerRoundness: KeyframeGroup<Vector1D>?
-  
-  /// The rotation of the star
-  let rotation: KeyframeGroup<Vector1D>
-  
-  /// The number of points on the star
-  let points: KeyframeGroup<Vector1D>
-  
-  /// The type of star
-  let starType: StarType
-  
-  private enum CodingKeys : String, CodingKey {
-    case direction = "d"
-    case position = "p"
-    case outerRadius = "or"
-    case outerRoundness = "os"
-    case innerRadius = "ir"
-    case innerRoundness = "is"
-    case rotation = "r"
-    case points = "pt"
-    case starType = "sy"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Star.CodingKeys.self)
-    self.direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction) ?? .clockwise
-    self.position = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .position)
-    self.outerRadius = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .outerRadius)
-    self.outerRoundness = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .outerRoundness)
-    self.innerRadius = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .innerRadius)
-    self.innerRoundness = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .innerRoundness)
-    self.rotation = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .rotation)
-    self.points = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .points)
-    self.starType = try container.decode(StarType.self, forKey: .starType)
-    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(outerRadius, forKey: .outerRadius)
-    try container.encode(outerRoundness, forKey: .outerRoundness)
-    try container.encode(innerRadius, forKey: .innerRadius)
-    try container.encode(innerRoundness, forKey: .innerRoundness)
-    try container.encode(rotation, forKey: .rotation)
-    try container.encode(points, forKey: .points)
-    try container.encode(starType, forKey: .starType)
-  }
-  
-}

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

@@ -1,67 +0,0 @@
-//
-//  Stroke.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-/// An item that define an ellipse shape
-final class Stroke: ShapeItem {
-  
-  /// The opacity of the stroke
-  let opacity: KeyframeGroup<Vector1D>
-  
-  /// The Color of the stroke
-  let color: KeyframeGroup<Color>
-  
-  /// 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 color = "c"
-    case width = "w"
-    case lineCap = "lc"
-    case lineJoin = "lj"
-    case miterLimit = "ml"
-    case dashPattern = "d"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Stroke.CodingKeys.self)
-    self.opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-    self.color = try container.decode(KeyframeGroup<Color>.self, forKey: .color)
-    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
-    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(color, forKey: .color)
-    try container.encode(width, forKey: .width)
-    try container.encode(lineCap, forKey: .lineCap)
-    try container.encode(lineJoin, forKey: .lineJoin)
-    try container.encode(miterLimit, forKey: .miterLimit)
-    try container.encodeIfPresent(dashPattern, forKey: .dashPattern)
-  }
-}

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

@@ -1,53 +0,0 @@
-//
-//  Trim.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-enum TrimType: Int, Codable {
-  case simultaneously = 1
-  case individually = 2
-}
-/// An item that define an ellipse shape
-final class Trim: ShapeItem {
-  
-  /// The start of the trim
-  let start: KeyframeGroup<Vector1D>
-  
-  /// The end of the trim
-  let end: KeyframeGroup<Vector1D>
-  
-  /// The offset of the trim
-  let offset: KeyframeGroup<Vector1D>
-  
-  let trimType: TrimType
-  
-  private enum CodingKeys : String, CodingKey {
-    case start = "s"
-    case end = "e"
-    case offset = "o"
-    case trimType = "m"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Trim.CodingKeys.self)
-    self.start = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .start)
-    self.end = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .end)
-    self.offset = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .offset)
-    self.trimType = try container.decode(TrimType.self, forKey: .trimType)
-    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(start, forKey: .start)
-    try container.encode(end, forKey: .end)
-    try container.encode(offset, forKey: .offset)
-    try container.encode(trimType, forKey: .trimType)
-  }
-  
-}

package/lottie-swift/src/Private/Model/Text/Font.swift

@@ -1,35 +0,0 @@
-//
-//  Font.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/9/19.
-//
-
-import Foundation
-
-final class Font: Codable {
-  
-  let name: String
-  let familyName: String
-  let style: String
-  let ascent: Double
-  
-  private enum CodingKeys: String, CodingKey {
-    case name = "fName"
-    case familyName = "fFamily"
-    case style = "fStyle"
-    case ascent = "ascent"
-  }
-  
-}
-
-/// A list of fonts
-final class FontList: Codable {
-  
-  let fonts: [Font]
-  
-  enum CodingKeys : String, CodingKey {
-    case fonts = "list"
-  }
-  
-}

package/lottie-swift/src/Private/Model/Text/TextAnimator.swift

@@ -1,99 +0,0 @@
-//
-//  TextAnimator.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/9/19.
-//
-
-import Foundation
-
-final class TextAnimator: Codable {
-  
-  let name: String
-  
-  /// Anchor
-  let anchor: KeyframeGroup<Vector3D>?
-  
-  /// Position
-  let position: KeyframeGroup<Vector3D>?
-  
-  /// Scale
-  let scale: KeyframeGroup<Vector3D>?
-  
-  /// Skew
-  let skew: KeyframeGroup<Vector1D>?
-  
-  /// Skew Axis
-  let skewAxis: KeyframeGroup<Vector1D>?
-  
-  /// Rotation
-  let rotation: KeyframeGroup<Vector1D>?
-  
-  /// Opacity
-  let opacity: KeyframeGroup<Vector1D>?
-  
-  /// Stroke Color
-  let strokeColor: KeyframeGroup<Color>?
-  
-  /// Fill Color
-  let fillColor: KeyframeGroup<Color>?
-  
-  /// Stroke Width
-  let strokeWidth: KeyframeGroup<Vector1D>?
-  
-  /// Tracking
-  let tracking: KeyframeGroup<Vector1D>?
-  
-  private enum CodingKeys: String, CodingKey {
-//    case textSelector = "s" TODO
-    case textAnimator = "a"
-    case name = "nm"
-  }
-  
-  private enum TextSelectorKeys: String, CodingKey {
-    case start = "s"
-    case end = "e"
-    case offset = "o"
-  }
-  
-  private enum TextAnimatorKeys: String, CodingKey {
-    case fillColor = "fc"
-    case strokeColor = "sc"
-    case strokeWidth = "sw"
-    case tracking = "t"
-    case anchor = "a"
-    case position = "p"
-    case scale = "s"
-    case skew = "sk"
-    case skewAxis = "sa"
-    case rotation = "r"
-    case opacity = "o"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: TextAnimator.CodingKeys.self)
-    self.name = try container.decodeIfPresent(String.self, forKey: .name) ?? ""
-    let animatorContainer = try container.nestedContainer(keyedBy: TextAnimatorKeys.self, forKey: .textAnimator)
-    self.fillColor = try animatorContainer.decodeIfPresent(KeyframeGroup<Color>.self, forKey: .fillColor)
-    self.strokeColor = try animatorContainer.decodeIfPresent(KeyframeGroup<Color>.self, forKey: .strokeColor)
-    self.strokeWidth = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .strokeWidth)
-    self.tracking = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .tracking)
-    self.anchor = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchor)
-    self.position = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .position)
-    self.scale = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale)
-    self.skew = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skew)
-    self.skewAxis = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skewAxis)
-    self.rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation)
-    self.opacity = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-    
-  }
-  
-  func encode(to encoder: Encoder) throws {
-    var container = encoder.container(keyedBy: CodingKeys.self)
-    var animatorContainer = container.nestedContainer(keyedBy: TextAnimatorKeys.self, forKey: .textAnimator)
-    try animatorContainer.encodeIfPresent(fillColor, forKey: .fillColor)
-    try animatorContainer.encodeIfPresent(strokeColor, forKey: .strokeColor)
-    try animatorContainer.encodeIfPresent(strokeWidth, forKey: .strokeWidth)
-    try animatorContainer.encodeIfPresent(tracking, forKey: .tracking)
-  }
-}

package/lottie-swift/src/Private/Model/Text/TextDocument.swift

@@ -1,70 +0,0 @@
-//
-//  TextDocument.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/9/19.
-//
-
-import Foundation
-
-enum TextJustification: Int, Codable {
-  case left
-  case right
-  case center
-}
-
-final class TextDocument: Codable {
-  
-  /// The Text
-  let text: String
-  
-  /// The Font size
-  let fontSize: Double
-  
-  /// The Font Family
-  let fontFamily: String
-  
-  /// Justification
-  let justification: TextJustification
-  
-  /// Tracking
-  let tracking: Int
-  
-  /// Line Height
-  let lineHeight: Double
-  
-  /// Baseline
-  let baseline: Double?
-  
-  /// Fill Color data
-  let fillColorData: Color?
-  
-  /// Scroke Color data
-  let strokeColorData: Color?
-  
-  /// Stroke Width
-  let strokeWidth: Double?
-  
-  /// Stroke Over Fill
-  let strokeOverFill: Bool?
-  
-  let textFramePosition: Vector3D?
-  
-  let textFrameSize: Vector3D?
-  
-  private enum CodingKeys : String, CodingKey {
-    case text = "t"
-    case fontSize = "s"
-    case fontFamily = "f"
-    case justification = "j"
-    case tracking = "tr"
-    case lineHeight = "lh"
-    case baseline = "ls"
-    case fillColorData = "fc"
-    case strokeColorData = "sc"
-    case strokeWidth = "sw"
-    case strokeOverFill = "of"
-    case textFramePosition = "ps"
-    case textFrameSize = "sz"
-  }
-}

package/lottie-swift/src/Private/NodeRenderSystem/Nodes/PathNodes/EllipseNode.swift

@@ -1,109 +0,0 @@
-//
-//  EllipseNode.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/17/19.
-//
-
-import Foundation
-import QuartzCore
-
-final class EllipseNodeProperties: NodePropertyMap, KeypathSearchable {
-  
-  var keypathName: String
-  
-  init(ellipse: Ellipse) {
-    self.keypathName = ellipse.name
-    self.direction = ellipse.direction
-    self.position = NodeProperty(provider: KeyframeInterpolator(keyframes: ellipse.position.keyframes))
-    self.size = NodeProperty(provider: KeyframeInterpolator(keyframes: ellipse.size.keyframes))
-    self.keypathProperties = [
-      "Position" : position,
-      "Size" : size
-    ]
-    self.properties = Array(keypathProperties.values)
-  }
-  
-  let direction: PathDirection
-  let position: NodeProperty<Vector3D>
-  let size: NodeProperty<Vector3D>
-  
-  let keypathProperties: [String : AnyNodeProperty]
-  let properties: [AnyNodeProperty]
-}
-
-final class EllipseNode: AnimatorNode, PathNode {
-  
-  let pathOutput: PathOutputNode
-  
-  let properties: EllipseNodeProperties
-
-  init(parentNode: AnimatorNode?, ellipse: Ellipse) {
-    self.pathOutput = PathOutputNode(parent: parentNode?.outputNode)
-    self.properties = EllipseNodeProperties(ellipse: ellipse)
-    self.parentNode = parentNode
-  }
-  
-  // MARK: Animator Node
-  
-  var propertyMap: NodePropertyMap & KeypathSearchable {
-    return properties
-  }
-  
-  let parentNode: AnimatorNode?
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
-  var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true {
-    didSet{
-      self.pathOutput.isEnabled = self.isEnabled
-    }
-  }
-  
-  func rebuildOutputs(frame: CGFloat) {
-    let ellipseSize = properties.size.value.sizeValue
-    let center = properties.position.value.pointValue
-    
-    // Unfortunately we HAVE to manually build out the ellipse.
-    // Every Apple method constructs an ellipse from the 3 o-clock position
-    // After effects constructs from the Noon position.
-    // After effects does clockwise, but also has a flag for reversed.
-    
-    var half = ellipseSize * 0.5
-    if properties.direction == .counterClockwise {
-      half.width = half.width * -1
-    }
-    
-    
-    let q1 = CGPoint(x: center.x, y: center.y - half.height)
-    let q2 = CGPoint(x: center.x + half.width, y: center.y)
-    let q3 = CGPoint(x: center.x, y: center.y + half.height)
-    let q4 = CGPoint(x: center.x - half.width, y: center.y)
-    
-    let cp = half * EllipseNode.ControlPointConstant
-    
-    var path = BezierPath(startPoint: CurveVertex(point: q1,
-                                                  inTangentRelative: CGPoint(x: -cp.width, y: 0),
-                                                  outTangentRelative: CGPoint(x: cp.width, y: 0)))
-    path.addVertex(CurveVertex(point: q2,
-                               inTangentRelative: CGPoint(x: 0, y: -cp.height),
-                               outTangentRelative: CGPoint(x: 0, y: cp.height)))
-    
-    path.addVertex(CurveVertex(point: q3,
-                               inTangentRelative: CGPoint(x: cp.width, y: 0),
-                               outTangentRelative: CGPoint(x: -cp.width, y: 0)))
-    
-    path.addVertex(CurveVertex(point: q4,
-                               inTangentRelative: CGPoint(x: 0, y: cp.height),
-                               outTangentRelative: CGPoint(x: 0, y: -cp.height)))
-    
-    path.addVertex(CurveVertex(point: q1,
-                               inTangentRelative: CGPoint(x: -cp.width, y: 0),
-                               outTangentRelative: CGPoint(x: cp.width, y: 0)))
-    path.close()
-    pathOutput.setPath(path, updateFrame: frame)
-  }
-
-  static let ControlPointConstant: CGFloat = 0.55228
-  
-}