lottie-ios 3.2.3 → 3.4.0

package/Sources/Private/Model/Objects/Transform.swift

@@ -0,0 +1,179 @@
+//
+//  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, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  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
+    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
+      positionX = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .positionX)
+      positionY = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .positionY)
+      position = nil
+    } else if let positionKeyframes = try? container.decode(KeyframeGroup<Vector3D>.self, forKey: .position) {
+      // Position dimensions are a single keyframe group.
+      position = positionKeyframes
+      positionX = nil
+      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
+      position = nil
+    } else {
+      /// Default value.
+      position = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      positionX = nil
+      positionY = nil
+    }
+
+    // Scale
+    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) {
+      rotation = rotationZ
+    } else {
+      rotation = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation) ?? KeyframeGroup(Vector1D(0))
+    }
+    rotationZ = nil
+
+    // Opacity
+    opacity = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity) ?? KeyframeGroup(Vector1D(100))
+  }
+
+  init(dictionary: [String: Any]) throws {
+    if
+      let anchorPointDictionary = dictionary[CodingKeys.anchorPoint.rawValue] as? [String: Any],
+      let anchorPoint = try? KeyframeGroup<Vector3D>(dictionary: anchorPointDictionary)
+    {
+      self.anchorPoint = anchorPoint
+    } else {
+      anchorPoint = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+    }
+
+    if
+      let xDictionary = dictionary[CodingKeys.positionX.rawValue] as? [String: Any],
+      let yDictionary = dictionary[CodingKeys.positionY.rawValue] as? [String: Any]
+    {
+      positionX = try KeyframeGroup<Vector1D>(dictionary: xDictionary)
+      positionY = try KeyframeGroup<Vector1D>(dictionary: yDictionary)
+      position = nil
+    } else if
+      let positionDictionary = dictionary[CodingKeys.position.rawValue] as? [String: Any],
+      positionDictionary[KeyframeGroup<Vector3D>.KeyframeWrapperKey.keyframeData.rawValue] != nil
+    {
+      position = try KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+      positionX = nil
+      positionY = nil
+    } else if
+      let positionDictionary = dictionary[CodingKeys.position.rawValue] as? [String: Any],
+      let xDictionary = positionDictionary[PositionCodingKeys.positionX.rawValue] as? [String: Any],
+      let yDictionary = positionDictionary[PositionCodingKeys.positionY.rawValue] as? [String: Any]
+    {
+      positionX = try KeyframeGroup<Vector1D>(dictionary: xDictionary)
+      positionY = try KeyframeGroup<Vector1D>(dictionary: yDictionary)
+      position = nil
+    } else {
+      position = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      positionX = nil
+      positionY = nil
+    }
+
+    if
+      let scaleDictionary = dictionary[CodingKeys.scale.rawValue] as? [String: Any],
+      let scale = try? KeyframeGroup<Vector3D>(dictionary: scaleDictionary)
+    {
+      self.scale = scale
+    } else {
+      scale = KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
+    }
+    if
+      let rotationDictionary = dictionary[CodingKeys.rotationZ.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+    {
+      self.rotation = rotation
+    } else if
+      let rotationDictionary = dictionary[CodingKeys.rotation.rawValue] as? [String: Any],
+      let rotation = try? KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+    {
+      self.rotation = rotation
+    } else {
+      rotation = KeyframeGroup(Vector1D(0))
+    }
+    rotationZ = nil
+    if
+      let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any],
+      let opacity = try? KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+    {
+      self.opacity = opacity
+    } else {
+      opacity = KeyframeGroup(Vector1D(100))
+    }
+  }
+
+  // MARK: Internal
+
+  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"
+  }
+
+  /// 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>?
+}

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

@@ -0,0 +1,75 @@
+//
+//  EllipseItem.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+// MARK: - PathDirection
+
+enum PathDirection: Int, Codable {
+  case clockwise = 1
+  case userSetClockwise = 2
+  case counterClockwise = 3
+}
+
+// MARK: - Ellipse
+
+/// An item that define an ellipse shape
+final class Ellipse: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Ellipse.CodingKeys.self)
+    direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction) ?? .clockwise
+    position = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .position)
+    size = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .size)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if
+      let directionRawType = dictionary[CodingKeys.direction.rawValue] as? Int,
+      let direction = PathDirection(rawValue: directionRawType)
+    {
+      self.direction = direction
+    } else {
+      direction = .clockwise
+    }
+    let positionDictionary: [String: Any] = try dictionary.value(for: CodingKeys.position)
+    position = try KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+    let sizeDictionary: [String: Any] = try dictionary.value(for: CodingKeys.size)
+    size = try KeyframeGroup<Vector3D>(dictionary: sizeDictionary)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// 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>
+
+  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)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case direction = "d"
+    case position = "p"
+    case size = "s"
+  }
+}

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

@@ -0,0 +1,74 @@
+//
+//  FillShape.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+// MARK: - FillRule
+
+enum FillRule: Int, Codable {
+  case none
+  case nonZeroWinding
+  case evenOdd
+}
+
+// MARK: - Fill
+
+/// An item that defines a fill render
+final class Fill: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Fill.CodingKeys.self)
+    opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
+    color = try container.decode(KeyframeGroup<Color>.self, forKey: .color)
+    fillRule = try container.decodeIfPresent(FillRule.self, forKey: .fillRule) ?? .nonZeroWinding
+    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)
+    if
+      let fillRuleRawValue = dictionary[CodingKeys.fillRule.rawValue] as? Int,
+      let fillRule = FillRule(rawValue: fillRuleRawValue)
+    {
+      self.fillRule = fillRule
+    } else {
+      fillRule = .nonZeroWinding
+    }
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The opacity of the fill
+  let opacity: KeyframeGroup<Vector1D>
+
+  /// The color keyframes for the fill
+  let color: KeyframeGroup<Color>
+
+  let fillRule: FillRule
+
+  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)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case opacity = "o"
+    case color = "c"
+    case fillRule = "r"
+  }
+}

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

@@ -0,0 +1,124 @@
+//
+//  GradientFill.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+// MARK: - GradientType
+
+enum GradientType: Int, Codable {
+  case none
+  case linear
+  case radial
+}
+
+// MARK: - GradientFill
+
+/// An item that define a gradient fill
+final class GradientFill: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: GradientFill.CodingKeys.self)
+    opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
+    startPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .startPoint)
+    endPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .endPoint)
+    gradientType = try container.decode(GradientType.self, forKey: .gradientType)
+    highlightLength = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightLength)
+    highlightAngle = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightAngle)
+    let colorsContainer = try container.nestedContainer(keyedBy: GradientDataKeys.self, forKey: .colors)
+    colors = try colorsContainer.decode(KeyframeGroup<[Double]>.self, forKey: .colors)
+    numberOfColors = try colorsContainer.decode(Int.self, forKey: .numberOfColors)
+    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 startPointDictionary: [String: Any] = try dictionary.value(for: CodingKeys.startPoint)
+    startPoint = try KeyframeGroup<Vector3D>(dictionary: startPointDictionary)
+    let endPointDictionary: [String: Any] = try dictionary.value(for: CodingKeys.endPoint)
+    endPoint = try KeyframeGroup<Vector3D>(dictionary: endPointDictionary)
+    let gradientRawType: Int = try dictionary.value(for: CodingKeys.gradientType)
+    guard let gradient = GradientType(rawValue: gradientRawType) else {
+      throw InitializableError.invalidInput
+    }
+    gradientType = gradient
+    if let highlightLengthDictionary = dictionary[CodingKeys.highlightLength.rawValue] as? [String: Any] {
+      highlightLength = try? KeyframeGroup<Vector1D>(dictionary: highlightLengthDictionary)
+    } else {
+      highlightLength = nil
+    }
+    if let highlightAngleDictionary = dictionary[CodingKeys.highlightAngle.rawValue] as? [String: Any] {
+      highlightAngle = try? KeyframeGroup<Vector1D>(dictionary: highlightAngleDictionary)
+    } else {
+      highlightAngle = nil
+    }
+    let colorsDictionary: [String: Any] = try dictionary.value(for: CodingKeys.colors)
+    let nestedColorsDictionary: [String: Any] = try colorsDictionary.value(for: GradientDataKeys.colors)
+    colors = try KeyframeGroup<[Double]>(dictionary: nestedColorsDictionary)
+    numberOfColors = try colorsDictionary.value(for: GradientDataKeys.numberOfColors)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// 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]>
+
+  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)
+  }
+
+  // MARK: Private
+
+  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"
+  }
+}

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

@@ -0,0 +1,186 @@
+//
+//  GradientStroke.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+import Foundation
+
+// MARK: - LineCap
+
+enum LineCap: Int, Codable {
+  case none
+  case butt
+  case round
+  case square
+}
+
+// MARK: - LineJoin
+
+enum LineJoin: Int, Codable {
+  case none
+  case miter
+  case round
+  case bevel
+}
+
+// MARK: - GradientStroke
+
+/// An item that define an ellipse shape
+final class GradientStroke: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: GradientStroke.CodingKeys.self)
+    opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
+    startPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .startPoint)
+    endPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .endPoint)
+    gradientType = try container.decode(GradientType.self, forKey: .gradientType)
+    highlightLength = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightLength)
+    highlightAngle = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightAngle)
+    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
+    // TODO Decode Color Objects instead of array.
+    let colorsContainer = try container.nestedContainer(keyedBy: GradientDataKeys.self, forKey: .colors)
+    colors = try colorsContainer.decode(KeyframeGroup<[Double]>.self, forKey: .colors)
+    numberOfColors = try colorsContainer.decode(Int.self, forKey: .numberOfColors)
+    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 startPointDictionary: [String: Any] = try dictionary.value(for: CodingKeys.startPoint)
+    startPoint = try KeyframeGroup<Vector3D>(dictionary: startPointDictionary)
+    let endPointDictionary: [String: Any] = try dictionary.value(for: CodingKeys.endPoint)
+    endPoint = try KeyframeGroup<Vector3D>(dictionary: endPointDictionary)
+    let gradientRawType: Int = try dictionary.value(for: CodingKeys.gradientType)
+    guard let gradient = GradientType(rawValue: gradientRawType) else {
+      throw InitializableError.invalidInput
+    }
+    gradientType = gradient
+    if let highlightLengthDictionary = dictionary[CodingKeys.highlightLength.rawValue] as? [String: Any] {
+      highlightLength = try? KeyframeGroup<Vector1D>(dictionary: highlightLengthDictionary)
+    } else {
+      highlightLength = nil
+    }
+    if let highlightAngleDictionary = dictionary[CodingKeys.highlightAngle.rawValue] as? [String: Any] {
+      highlightAngle = try? KeyframeGroup<Vector1D>(dictionary: highlightAngleDictionary)
+    } else {
+      highlightAngle = nil
+    }
+    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 colorsDictionary: [String: Any] = try dictionary.value(for: CodingKeys.colors)
+    let nestedColorsDictionary: [String: Any] = try colorsDictionary.value(for: GradientDataKeys.colors)
+    colors = try KeyframeGroup<[Double]>(dictionary: nestedColorsDictionary)
+    numberOfColors = try colorsDictionary.value(for: GradientDataKeys.numberOfColors)
+    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 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]?
+
+  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)
+  }
+
+  // MARK: Private
+
+  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"
+  }
+}

package/{lottie-swift/src → Sources}/Private/Model/ShapeItems/Group.swift

@@ -9,24 +9,35 @@ 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"
-  }
-  
+
+  // MARK: Lifecycle
+
   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)
+    items = try container.decode([ShapeItem].self, ofFamily: ShapeType.self, forKey: .items)
     try super.init(from: decoder)
   }
-  
+
+  required init(dictionary: [String: Any]) throws {
+    let itemDictionaries: [[String: Any]] = try dictionary.value(for: CodingKeys.items)
+    items = try [ShapeItem].fromDictionaries(itemDictionaries)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// A list of shape items.
+  let items: [ShapeItem]
+
   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)
   }
 
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case items = "it"
+  }
 }