lottie-ios 3.2.3 → 3.4.2

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

@@ -1,50 +0,0 @@
-//
-//  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 {
-  
-  /// 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>
-  
-  private enum CodingKeys : String, CodingKey {
-    case direction = "d"
-    case position = "p"
-    case size = "s"
-    case cornerRadius = "r"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Rectangle.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)
-    self.cornerRadius = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .cornerRadius)
-    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)
-    try container.encode(cornerRadius, forKey: .cornerRadius)
-  }
-  
-}

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

@@ -1,80 +0,0 @@
-//
-//  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 {
-  
-  /// 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>
-  
-  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"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Repeater.CodingKeys.self)
-    self.copies = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .copies) ?? KeyframeGroup(Vector1D(0))
-    self.offset = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .offset) ?? KeyframeGroup(Vector1D(0))
-    let transformContainer = try container.nestedContainer(keyedBy: TransformKeys.self, forKey: .transform)
-    self.startOpacity = try transformContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .startOpacity) ?? KeyframeGroup(Vector1D(100))
-    self.endOpacity = try transformContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .endOpacity) ?? KeyframeGroup(Vector1D(100))
-    self.rotation = try transformContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation) ?? KeyframeGroup(Vector1D(0))
-    self.position = try transformContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .position) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
-    self.anchorPoint = try transformContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchorPoint) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
-    self.scale = try transformContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale) ?? KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
-    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(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)
-  }
-  
-}

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

@@ -1,37 +0,0 @@
-//
-//  VectorShape.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-/// An item that define an ellipse shape
-final class Shape: ShapeItem {
-
-  /// The Path
-  let path: KeyframeGroup<BezierPath>
-  
-  let direction: PathDirection?
-  
-  private enum CodingKeys : String, CodingKey {
-    case path = "ks"
-    case direction = "d"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Shape.CodingKeys.self)
-    self.path = try container.decode(KeyframeGroup<BezierPath>.self, forKey: .path)
-    self.direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction)
-    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(path, forKey: .path)
-    try container.encodeIfPresent(direction, forKey: .direction)
-  }
-  
-}

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

@@ -1,95 +0,0 @@
-//
-//  ShapeItem.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-/// 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
-    }
-  }
-}
-
-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
-  }
-}
-
-/// An item belonging to a Shape Layer
-class ShapeItem: Codable {
-  
-  /// The name of the shape
-  let name: String
-  
-  /// The type of shape
-  let type: ShapeType
-  
-  let hidden: Bool
-  
-  private enum CodingKeys : String, CodingKey {
-    case name = "nm"
-    case type = "ty"
-    case hidden = "hd"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: ShapeItem.CodingKeys.self)
-    self.name = try container.decodeIfPresent(String.self, forKey: .name) ?? "Layer"
-    self.type = try container.decode(ShapeType.self, forKey: .type)
-    self.hidden = try container.decodeIfPresent(Bool.self, forKey: .hidden) ?? false
-  }
-
-}

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