lottie-ios 3.2.3 → 3.4.0

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

@@ -0,0 +1,132 @@
+//
+//  Star.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+// MARK: - StarType
+
+enum StarType: Int, Codable {
+  case none
+  case star
+  case polygon
+}
+
+// MARK: - Star
+
+/// An item that define an ellipse shape
+final class Star: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Star.CodingKeys.self)
+    direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction) ?? .clockwise
+    position = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .position)
+    outerRadius = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .outerRadius)
+    outerRoundness = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .outerRoundness)
+    innerRadius = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .innerRadius)
+    innerRoundness = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .innerRoundness)
+    rotation = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .rotation)
+    points = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .points)
+    starType = try container.decode(StarType.self, forKey: .starType)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if
+      let directionRawValue = dictionary[CodingKeys.direction.rawValue] as? Int,
+      let direction = PathDirection(rawValue: directionRawValue)
+    {
+      self.direction = direction
+    } else {
+      direction = .clockwise
+    }
+    let positionDictionary: [String: Any] = try dictionary.value(for: CodingKeys.position)
+    position = try KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+    let outerRadiusDictionary: [String: Any] = try dictionary.value(for: CodingKeys.outerRadius)
+    outerRadius = try KeyframeGroup<Vector1D>(dictionary: outerRadiusDictionary)
+    let outerRoundnessDictionary: [String: Any] = try dictionary.value(for: CodingKeys.outerRoundness)
+    outerRoundness = try KeyframeGroup<Vector1D>(dictionary: outerRoundnessDictionary)
+    if let innerRadiusDictionary = dictionary[CodingKeys.innerRadius.rawValue] as? [String: Any] {
+      innerRadius = try KeyframeGroup<Vector1D>(dictionary: innerRadiusDictionary)
+    } else {
+      innerRadius = nil
+    }
+    if let innerRoundnessDictionary = dictionary[CodingKeys.innerRoundness.rawValue] as? [String: Any] {
+      innerRoundness = try KeyframeGroup<Vector1D>(dictionary: innerRoundnessDictionary)
+    } else {
+      innerRoundness = nil
+    }
+    let rotationDictionary: [String: Any] = try dictionary.value(for: CodingKeys.rotation)
+    rotation = try KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+    let pointsDictionary: [String: Any] = try dictionary.value(for: CodingKeys.points)
+    points = try KeyframeGroup<Vector1D>(dictionary: pointsDictionary)
+    let starTypeRawValue: Int = try dictionary.value(for: CodingKeys.starType)
+    guard let starType = StarType(rawValue: starTypeRawValue) else {
+      throw InitializableError.invalidInput
+    }
+    self.starType = starType
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// 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
+
+  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)
+  }
+
+  // MARK: Private
+
+  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"
+  }
+}

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

@@ -0,0 +1,102 @@
+//
+//  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 {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Stroke.CodingKeys.self)
+    opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
+    color = try container.decode(KeyframeGroup<Color>.self, forKey: .color)
+    width = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .width)
+    lineCap = try container.decodeIfPresent(LineCap.self, forKey: .lineCap) ?? .round
+    lineJoin = try container.decodeIfPresent(LineJoin.self, forKey: .lineJoin) ?? .round
+    miterLimit = try container.decodeIfPresent(Double.self, forKey: .miterLimit) ?? 4
+    dashPattern = try container.decodeIfPresent([DashElement].self, forKey: .dashPattern)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let opacityDictionary: [String: Any] = try dictionary.value(for: CodingKeys.opacity)
+    opacity = try KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+    let colorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.color)
+    color = try KeyframeGroup<Color>(dictionary: colorDictionary)
+    let widthDictionary: [String: Any] = try dictionary.value(for: CodingKeys.width)
+    width = try KeyframeGroup<Vector1D>(dictionary: widthDictionary)
+    if
+      let lineCapRawValue = dictionary[CodingKeys.lineCap.rawValue] as? Int,
+      let lineCap = LineCap(rawValue: lineCapRawValue)
+    {
+      self.lineCap = lineCap
+    } else {
+      lineCap = .round
+    }
+    if
+      let lineJoinRawValue = dictionary[CodingKeys.lineJoin.rawValue] as? Int,
+      let lineJoin = LineJoin(rawValue: lineJoinRawValue)
+    {
+      self.lineJoin = lineJoin
+    } else {
+      lineJoin = .round
+    }
+    miterLimit = (try? dictionary.value(for: CodingKeys.miterLimit)) ?? 4
+    let dashPatternDictionaries = dictionary[CodingKeys.dashPattern.rawValue] as? [[String: Any]]
+    dashPattern = try? dashPatternDictionaries?.map({ try DashElement(dictionary: $0) })
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// 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]?
+
+  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)
+  }
+
+  // MARK: Private
+
+  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"
+  }
+}

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

@@ -0,0 +1,78 @@
+//
+//  Trim.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+// MARK: - TrimType
+
+enum TrimType: Int, Codable {
+  case simultaneously = 1
+  case individually = 2
+}
+
+// MARK: - Trim
+
+/// An item that define an ellipse shape
+final class Trim: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Trim.CodingKeys.self)
+    start = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .start)
+    end = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .end)
+    offset = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .offset)
+    trimType = try container.decode(TrimType.self, forKey: .trimType)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let startDictionary: [String: Any] = try dictionary.value(for: CodingKeys.start)
+    start = try KeyframeGroup<Vector1D>(dictionary: startDictionary)
+    let endDictionary: [String: Any] = try dictionary.value(for: CodingKeys.end)
+    end = try KeyframeGroup<Vector1D>(dictionary: endDictionary)
+    let offsetDictionary: [String: Any] = try dictionary.value(for: CodingKeys.offset)
+    offset = try KeyframeGroup<Vector1D>(dictionary: offsetDictionary)
+    let trimTypeRawValue: Int = try dictionary.value(for: CodingKeys.trimType)
+    guard let trimType = TrimType(rawValue: trimTypeRawValue) else {
+      throw InitializableError.invalidInput
+    }
+    self.trimType = trimType
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// 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
+
+  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)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case start = "s"
+    case end = "e"
+    case offset = "o"
+    case trimType = "m"
+  }
+}

package/Sources/Private/Model/Text/Font.swift

@@ -0,0 +1,61 @@
+//
+//  Font.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+import Foundation
+
+// MARK: - Font
+
+final class Font: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  init(dictionary: [String: Any]) throws {
+    name = try dictionary.value(for: CodingKeys.name)
+    familyName = try dictionary.value(for: CodingKeys.familyName)
+    style = try dictionary.value(for: CodingKeys.style)
+    ascent = try dictionary.value(for: CodingKeys.ascent)
+  }
+
+  // MARK: Internal
+
+  let name: String
+  let familyName: String
+  let style: String
+  let ascent: Double
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case name = "fName"
+    case familyName = "fFamily"
+    case style = "fStyle"
+    case ascent
+  }
+
+}
+
+// MARK: - FontList
+
+/// A list of fonts
+final class FontList: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  init(dictionary: [String: Any]) throws {
+    let fontDictionaries: [[String: Any]] = try dictionary.value(for: CodingKeys.fonts)
+    fonts = try fontDictionaries.map({ try Font(dictionary: $0) })
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case fonts = "list"
+  }
+
+  let fonts: [Font]
+
+}

package/{lottie-swift/src → Sources}/Private/Model/Text/Glyph.swift

@@ -8,65 +8,89 @@
 import Foundation
 
 /// A model that holds a vector character
-final class Glyph: Codable {
-  
+final class Glyph: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Glyph.CodingKeys.self)
+    character = try container.decode(String.self, forKey: .character)
+    fontSize = try container.decode(Double.self, forKey: .fontSize)
+    fontFamily = try container.decode(String.self, forKey: .fontFamily)
+    fontStyle = try container.decode(String.self, forKey: .fontStyle)
+    width = try container.decode(Double.self, forKey: .width)
+    if
+      container.contains(.shapeWrapper),
+      let shapeContainer = try? container.nestedContainer(keyedBy: ShapeKey.self, forKey: .shapeWrapper),
+      shapeContainer.contains(.shapes)
+    {
+      shapes = try shapeContainer.decode([ShapeItem].self, ofFamily: ShapeType.self, forKey: .shapes)
+    } else {
+      shapes = []
+    }
+  }
+
+  init(dictionary: [String: Any]) throws {
+    character = try dictionary.value(for: CodingKeys.character)
+    fontSize = try dictionary.value(for: CodingKeys.fontSize)
+    fontFamily = try dictionary.value(for: CodingKeys.fontFamily)
+    fontStyle = try dictionary.value(for: CodingKeys.fontStyle)
+    width = try dictionary.value(for: CodingKeys.width)
+    if
+      let shapes = dictionary[CodingKeys.shapeWrapper.rawValue] as? [String: Any],
+      let shapeDictionaries = shapes[ShapeKey.shapes.rawValue] as? [[String: Any]]
+    {
+      self.shapes = try [ShapeItem].fromDictionaries(shapeDictionaries)
+    } else {
+      shapes = [ShapeItem]()
+    }
+  }
+
+  // MARK: Internal
+
   /// The character
   let character: String
-  
+
   /// The font size of the character
   let fontSize: Double
-  
+
   /// The font family of the character
   let fontFamily: String
-  
+
   /// The Style of the character
   let fontStyle: String
-  
+
   /// The Width of the character
   let width: Double
-  
+
   /// The Shape Data of the Character
   let shapes: [ShapeItem]
-  
-  private enum CodingKeys: String, CodingKey {
-    case character = "ch"
-    case fontSize = "size"
-    case fontFamily = "fFamily"
-    case fontStyle = "style"
-    case width = "w"
-    case shapeWrapper = "data"
-  }
-  
-  private enum ShapeKey: String, CodingKey {
-    case shapes = "shapes"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Glyph.CodingKeys.self)
-    self.character = try container.decode(String.self, forKey: .character)
-    self.fontSize = try container.decode(Double.self, forKey: .fontSize)
-    self.fontFamily = try container.decode(String.self, forKey: .fontFamily)
-    self.fontStyle = try container.decode(String.self, forKey: .fontStyle)
-    self.width = try container.decode(Double.self, forKey: .width)
-    if container.contains(.shapeWrapper),
-      let shapeContainer = try? container.nestedContainer(keyedBy: ShapeKey.self, forKey: .shapeWrapper),
-      shapeContainer.contains(.shapes) {
-      self.shapes = try shapeContainer.decode([ShapeItem].self, ofFamily: ShapeType.self, forKey: .shapes)
-    } else {
-      self.shapes = []
-    }
-  }
-  
+
   func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
-    
+
     try container.encode(character, forKey: .character)
     try container.encode(fontSize, forKey: .fontSize)
     try container.encode(fontFamily, forKey: .fontFamily)
     try container.encode(fontStyle, forKey: .fontStyle)
     try container.encode(width, forKey: .width)
-    
+
     var shapeContainer = container.nestedContainer(keyedBy: ShapeKey.self, forKey: .shapeWrapper)
     try shapeContainer.encode(shapes, forKey: .shapes)
   }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case character = "ch"
+    case fontSize = "size"
+    case fontFamily = "fFamily"
+    case fontStyle = "style"
+    case width = "w"
+    case shapeWrapper = "data"
+  }
+
+  private enum ShapeKey: String, CodingKey {
+    case shapes
+  }
 }

package/Sources/Private/Model/Text/TextAnimator.swift

@@ -0,0 +1,165 @@
+//
+//  TextAnimator.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+import Foundation
+
+final class TextAnimator: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: TextAnimator.CodingKeys.self)
+    name = try container.decodeIfPresent(String.self, forKey: .name) ?? ""
+    let animatorContainer = try container.nestedContainer(keyedBy: TextAnimatorKeys.self, forKey: .textAnimator)
+    fillColor = try animatorContainer.decodeIfPresent(KeyframeGroup<Color>.self, forKey: .fillColor)
+    strokeColor = try animatorContainer.decodeIfPresent(KeyframeGroup<Color>.self, forKey: .strokeColor)
+    strokeWidth = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .strokeWidth)
+    tracking = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .tracking)
+    anchor = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchor)
+    position = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .position)
+    scale = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale)
+    skew = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skew)
+    skewAxis = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skewAxis)
+    rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation)
+    opacity = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity)
+
+  }
+
+  init(dictionary: [String: Any]) throws {
+    name = (try? dictionary.value(for: CodingKeys.name)) ?? ""
+    let animatorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.textAnimator)
+    if let fillColorDictionary = animatorDictionary[TextAnimatorKeys.fillColor.rawValue] as? [String: Any] {
+      fillColor = try? KeyframeGroup<Color>(dictionary: fillColorDictionary)
+    } else {
+      fillColor = nil
+    }
+    if let strokeColorDictionary = animatorDictionary[TextAnimatorKeys.strokeColor.rawValue] as? [String: Any] {
+      strokeColor = try? KeyframeGroup<Color>(dictionary: strokeColorDictionary)
+    } else {
+      strokeColor = nil
+    }
+    if let strokeWidthDictionary = animatorDictionary[TextAnimatorKeys.strokeWidth.rawValue] as? [String: Any] {
+      strokeWidth = try? KeyframeGroup<Vector1D>(dictionary: strokeWidthDictionary)
+    } else {
+      strokeWidth = nil
+    }
+    if let trackingDictionary = animatorDictionary[TextAnimatorKeys.tracking.rawValue] as? [String: Any] {
+      tracking = try? KeyframeGroup<Vector1D>(dictionary: trackingDictionary)
+    } else {
+      tracking = nil
+    }
+    if let anchorDictionary = animatorDictionary[TextAnimatorKeys.anchor.rawValue] as? [String: Any] {
+      anchor = try? KeyframeGroup<Vector3D>(dictionary: anchorDictionary)
+    } else {
+      anchor = nil
+    }
+    if let positionDictionary = animatorDictionary[TextAnimatorKeys.position.rawValue] as? [String: Any] {
+      position = try? KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+    } else {
+      position = nil
+    }
+    if let scaleDictionary = animatorDictionary[TextAnimatorKeys.scale.rawValue] as? [String: Any] {
+      scale = try? KeyframeGroup<Vector3D>(dictionary: scaleDictionary)
+    } else {
+      scale = nil
+    }
+    if let skewDictionary = animatorDictionary[TextAnimatorKeys.skew.rawValue] as? [String: Any] {
+      skew = try? KeyframeGroup<Vector1D>(dictionary: skewDictionary)
+    } else {
+      skew = nil
+    }
+    if let skewAxisDictionary = animatorDictionary[TextAnimatorKeys.skewAxis.rawValue] as? [String: Any] {
+      skewAxis = try? KeyframeGroup<Vector1D>(dictionary: skewAxisDictionary)
+    } else {
+      skewAxis = nil
+    }
+    if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotation.rawValue] as? [String: Any] {
+      rotation = try? KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+    } else {
+      rotation = nil
+    }
+    if let opacityDictionary = animatorDictionary[TextAnimatorKeys.opacity.rawValue] as? [String: Any] {
+      opacity = try KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+    } else {
+      opacity = nil
+    }
+  }
+
+  // MARK: Internal
+
+  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>?
+
+  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)
+  }
+
+  // MARK: Private
+
+  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"
+  }
+}