lottie-ios 3.2.3 → 3.4.0

package/lottie-swift/src/Private/Model/Objects/Transform.swift

@@ -1,105 +0,0 @@
-//
-//  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 {
-  
-  /// 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>?
-  
-  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"
-  }
-  
-  
-  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
-    self.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
-      self.positionX = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .positionX)
-      self.positionY = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .positionY)
-      self.position = nil
-    } else if let positionKeyframes = try? container.decode(KeyframeGroup<Vector3D>.self, forKey: .position) {
-      // Position dimensions are a single keyframe group.
-      self.position = positionKeyframes
-      self.positionX = nil
-      self.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
-      self.position = nil
-    } else {
-      /// Default value.
-      self.position = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
-      self.positionX = nil
-      self.positionY = nil
-    }
-    
-    
-    // Scale
-    self.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) {
-      self.rotation = rotationZ
-    } else {
-       self.rotation = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation) ?? KeyframeGroup(Vector1D(0))
-    }
-    self.rotationZ = nil
-    
-    // Opacity
-    self.opacity = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity) ?? KeyframeGroup(Vector1D(100))
-  }
-}

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

@@ -1,50 +0,0 @@
-//
-//  EllipseItem.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-enum PathDirection: Int, Codable {
-  case clockwise = 1
-  case userSetClockwise = 2
-  case counterClockwise = 3
-}
-
-/// An item that define an ellipse shape
-final class Ellipse: ShapeItem {
-  
-  /// 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>
-  
-  private enum CodingKeys : String, CodingKey {
-    case direction = "d"
-    case position = "p"
-    case size = "s"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Ellipse.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)
-    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)
-  }
-  
-}

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

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

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

@@ -1,86 +0,0 @@
-//
-//  GradientFill.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-enum GradientType: Int, Codable {
-  case none
-  case linear
-  case radial
-}
-
-/// An item that define a gradient fill
-final class GradientFill: ShapeItem {
-  
-  /// 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]>
-  
-  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"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: GradientFill.CodingKeys.self)
-    self.opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-    self.startPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .startPoint)
-    self.endPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .endPoint)
-    self.gradientType = try container.decode(GradientType.self, forKey: .gradientType)
-    self.highlightLength = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightLength)
-    self.highlightAngle = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightAngle)
-    let colorsContainer = try container.nestedContainer(keyedBy: GradientDataKeys.self, forKey: .colors)
-    self.colors = try colorsContainer.decode(KeyframeGroup<[Double]>.self, forKey: .colors)
-    self.numberOfColors = try colorsContainer.decode(Int.self, forKey: .numberOfColors)
-    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(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)
-  }
-  
-}

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

@@ -1,125 +0,0 @@
-//
-//  GradientStroke.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/8/19.
-//
-
-import Foundation
-
-enum LineCap: Int, Codable {
-  case none
-  case butt
-  case round
-  case square
-}
-
-enum LineJoin: Int, Codable {
-  case none
-  case miter
-  case round
-  case bevel
-}
-
-/// An item that define an ellipse shape
-final class GradientStroke: ShapeItem {
-  
-  /// 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]?
-  
-  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"
-  }
-  
-  required init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: GradientStroke.CodingKeys.self)
-    self.opacity = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .opacity)
-    self.startPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .startPoint)
-    self.endPoint = try container.decode(KeyframeGroup<Vector3D>.self, forKey: .endPoint)
-    self.gradientType = try container.decode(GradientType.self, forKey: .gradientType)
-    self.highlightLength = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightLength)
-    self.highlightAngle = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .highlightAngle)
-    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
-    // TODO Decode Color Objects instead of array.
-    let colorsContainer = try container.nestedContainer(keyedBy: GradientDataKeys.self, forKey: .colors)
-    self.colors = try colorsContainer.decode(KeyframeGroup<[Double]>.self, forKey: .colors)
-    self.numberOfColors = try colorsContainer.decode(Int.self, forKey: .numberOfColors)
-    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(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)
-  }
-  
-}

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