lottie-ios 3.4.3 → 3.5.0

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

@@ -33,13 +33,13 @@ final class GradientStroke: ShapeItem {
 
   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)
+    opacity = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
+    startPoint = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .startPoint)
+    endPoint = try container.decode(KeyframeGroup<LottieVector3D>.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)
+    highlightLength = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .highlightLength)
+    highlightAngle = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .highlightAngle)
+    width = try container.decode(KeyframeGroup<LottieVector1D>.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
@@ -53,28 +53,28 @@ final class GradientStroke: ShapeItem {
 
   required init(dictionary: [String: Any]) throws {
     let opacityDictionary: [String: Any] = try dictionary.value(for: CodingKeys.opacity)
-    opacity = try KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+    opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
     let startPointDictionary: [String: Any] = try dictionary.value(for: CodingKeys.startPoint)
-    startPoint = try KeyframeGroup<Vector3D>(dictionary: startPointDictionary)
+    startPoint = try KeyframeGroup<LottieVector3D>(dictionary: startPointDictionary)
     let endPointDictionary: [String: Any] = try dictionary.value(for: CodingKeys.endPoint)
-    endPoint = try KeyframeGroup<Vector3D>(dictionary: endPointDictionary)
+    endPoint = try KeyframeGroup<LottieVector3D>(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)
+      highlightLength = try? KeyframeGroup<LottieVector1D>(dictionary: highlightLengthDictionary)
     } else {
       highlightLength = nil
     }
     if let highlightAngleDictionary = dictionary[CodingKeys.highlightAngle.rawValue] as? [String: Any] {
-      highlightAngle = try? KeyframeGroup<Vector1D>(dictionary: highlightAngleDictionary)
+      highlightAngle = try? KeyframeGroup<LottieVector1D>(dictionary: highlightAngleDictionary)
     } else {
       highlightAngle = nil
     }
     let widthDictionary: [String: Any] = try dictionary.value(for: CodingKeys.width)
-    width = try KeyframeGroup<Vector1D>(dictionary: widthDictionary)
+    width = try KeyframeGroup<LottieVector1D>(dictionary: widthDictionary)
     if
       let lineCapRawValue = dictionary[CodingKeys.lineCap.rawValue] as? Int,
       let lineCap = LineCap(rawValue: lineCapRawValue)
@@ -104,22 +104,22 @@ final class GradientStroke: ShapeItem {
   // MARK: Internal
 
   /// The opacity of the fill
-  let opacity: KeyframeGroup<Vector1D>
+  let opacity: KeyframeGroup<LottieVector1D>
 
   /// The start of the gradient
-  let startPoint: KeyframeGroup<Vector3D>
+  let startPoint: KeyframeGroup<LottieVector3D>
 
   /// The end of the gradient
-  let endPoint: KeyframeGroup<Vector3D>
+  let endPoint: KeyframeGroup<LottieVector3D>
 
   /// The type of gradient
   let gradientType: GradientType
 
   /// Gradient Highlight Length. Only if type is Radial
-  let highlightLength: KeyframeGroup<Vector1D>?
+  let highlightLength: KeyframeGroup<LottieVector1D>?
 
   /// Highlight Angle. Only if type is Radial
-  let highlightAngle: KeyframeGroup<Vector1D>?
+  let highlightAngle: KeyframeGroup<LottieVector1D>?
 
   /// The number of color points in the gradient
   let numberOfColors: Int
@@ -128,7 +128,7 @@ final class GradientStroke: ShapeItem {
   let colors: KeyframeGroup<[Double]>
 
   /// The width of the stroke
-  let width: KeyframeGroup<Vector1D>
+  let width: KeyframeGroup<LottieVector1D>
 
   /// Line Cap
   let lineCap: LineCap

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

@@ -14,9 +14,9 @@ final class Rectangle: ShapeItem {
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: Rectangle.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)
-    cornerRadius = try container.decode(KeyframeGroup<Vector1D>.self, forKey: .cornerRadius)
+    position = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .position)
+    size = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .size)
+    cornerRadius = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .cornerRadius)
     try super.init(from: decoder)
   }
 
@@ -30,11 +30,11 @@ final class Rectangle: ShapeItem {
       direction = .clockwise
     }
     let positionDictionary: [String: Any] = try dictionary.value(for: CodingKeys.position)
-    position = try KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+    position = try KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
     let sizeDictionary: [String: Any] = try dictionary.value(for: CodingKeys.size)
-    size = try KeyframeGroup<Vector3D>(dictionary: sizeDictionary)
+    size = try KeyframeGroup<LottieVector3D>(dictionary: sizeDictionary)
     let cornerRadiusDictionary: [String: Any] = try dictionary.value(for: CodingKeys.cornerRadius)
-    cornerRadius = try KeyframeGroup<Vector1D>(dictionary: cornerRadiusDictionary)
+    cornerRadius = try KeyframeGroup<LottieVector1D>(dictionary: cornerRadiusDictionary)
     try super.init(dictionary: dictionary)
   }
 
@@ -44,13 +44,13 @@ final class Rectangle: ShapeItem {
   let direction: PathDirection
 
   /// The position
-  let position: KeyframeGroup<Vector3D>
+  let position: KeyframeGroup<LottieVector3D>
 
   /// The size
-  let size: KeyframeGroup<Vector3D>
+  let size: KeyframeGroup<LottieVector3D>
 
   /// The Corner radius of the rectangle
-  let cornerRadius: KeyframeGroup<Vector1D>
+  let cornerRadius: KeyframeGroup<LottieVector1D>
 
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)

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

@@ -13,65 +13,70 @@ final class Repeater: ShapeItem {
 
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: Repeater.CodingKeys.self)
-    copies = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .copies) ?? KeyframeGroup(Vector1D(0))
-    offset = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .offset) ?? KeyframeGroup(Vector1D(0))
+    copies = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .copies) ?? KeyframeGroup(LottieVector1D(0))
+    offset = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .offset) ?? KeyframeGroup(LottieVector1D(0))
     let transformContainer = try container.nestedContainer(keyedBy: TransformKeys.self, forKey: .transform)
     startOpacity = try transformContainer
-      .decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .startOpacity) ?? KeyframeGroup(Vector1D(100))
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .startOpacity) ?? KeyframeGroup(LottieVector1D(100))
     endOpacity = try transformContainer
-      .decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .endOpacity) ?? KeyframeGroup(Vector1D(100))
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .endOpacity) ?? KeyframeGroup(LottieVector1D(100))
     rotation = try transformContainer
-      .decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation) ?? KeyframeGroup(Vector1D(0))
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) ?? KeyframeGroup(LottieVector1D(0))
     position = try transformContainer
-      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .position) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .position) ??
+      KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
     anchorPoint = try transformContainer
-      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchorPoint) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .anchorPoint) ??
+      KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
     scale = try transformContainer
-      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale) ?? KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale) ??
+      KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
     try super.init(from: decoder)
   }
 
   required init(dictionary: [String: Any]) throws {
     if let copiesDictionary = dictionary[CodingKeys.copies.rawValue] as? [String: Any] {
-      copies = try KeyframeGroup<Vector1D>(dictionary: copiesDictionary)
+      copies = try KeyframeGroup<LottieVector1D>(dictionary: copiesDictionary)
     } else {
-      copies = KeyframeGroup(Vector1D(0))
+      copies = KeyframeGroup(LottieVector1D(0))
     }
     if let offsetDictionary = dictionary[CodingKeys.offset.rawValue] as? [String: Any] {
-      offset = try KeyframeGroup<Vector1D>(dictionary: offsetDictionary)
+      offset = try KeyframeGroup<LottieVector1D>(dictionary: offsetDictionary)
     } else {
-      offset = KeyframeGroup(Vector1D(0))
+      offset = KeyframeGroup(LottieVector1D(0))
     }
     let transformDictionary: [String: Any] = try dictionary.value(for: CodingKeys.transform)
     if let startOpacityDictionary = transformDictionary[TransformKeys.startOpacity.rawValue] as? [String: Any] {
-      startOpacity = try KeyframeGroup<Vector1D>(dictionary: startOpacityDictionary)
+      startOpacity = try KeyframeGroup<LottieVector1D>(dictionary: startOpacityDictionary)
     } else {
-      startOpacity = KeyframeGroup(Vector1D(100))
+      startOpacity = KeyframeGroup(LottieVector1D(100))
     }
     if let endOpacityDictionary = transformDictionary[TransformKeys.endOpacity.rawValue] as? [String: Any] {
-      endOpacity = try KeyframeGroup<Vector1D>(dictionary: endOpacityDictionary)
+      endOpacity = try KeyframeGroup<LottieVector1D>(dictionary: endOpacityDictionary)
     } else {
-      endOpacity = KeyframeGroup(Vector1D(100))
+      endOpacity = KeyframeGroup(LottieVector1D(100))
     }
     if let rotationDictionary = transformDictionary[TransformKeys.rotation.rawValue] as? [String: Any] {
-      rotation = try KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+      rotation = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     } else {
-      rotation = KeyframeGroup(Vector1D(0))
+      rotation = KeyframeGroup(LottieVector1D(0))
     }
     if let positionDictionary = transformDictionary[TransformKeys.position.rawValue] as? [String: Any] {
-      position = try KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+      position = try KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
     } else {
-      position = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      position = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
     }
     if let anchorPointDictionary = transformDictionary[TransformKeys.anchorPoint.rawValue] as? [String: Any] {
-      anchorPoint = try KeyframeGroup<Vector3D>(dictionary: anchorPointDictionary)
+      anchorPoint = try KeyframeGroup<LottieVector3D>(dictionary: anchorPointDictionary)
     } else {
-      anchorPoint = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      anchorPoint = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
     }
     if let scaleDictionary = transformDictionary[TransformKeys.scale.rawValue] as? [String: Any] {
-      scale = try KeyframeGroup<Vector3D>(dictionary: scaleDictionary)
+      scale = try KeyframeGroup<LottieVector3D>(dictionary: scaleDictionary)
     } else {
-      scale = KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
+      scale = KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
     }
     try super.init(dictionary: dictionary)
   }
@@ -79,28 +84,28 @@ final class Repeater: ShapeItem {
   // MARK: Internal
 
   /// The number of copies to repeat
-  let copies: KeyframeGroup<Vector1D>
+  let copies: KeyframeGroup<LottieVector1D>
 
   /// The offset of each copy
-  let offset: KeyframeGroup<Vector1D>
+  let offset: KeyframeGroup<LottieVector1D>
 
   /// Start Opacity
-  let startOpacity: KeyframeGroup<Vector1D>
+  let startOpacity: KeyframeGroup<LottieVector1D>
 
   /// End opacity
-  let endOpacity: KeyframeGroup<Vector1D>
+  let endOpacity: KeyframeGroup<LottieVector1D>
 
   /// The rotation
-  let rotation: KeyframeGroup<Vector1D>
+  let rotation: KeyframeGroup<LottieVector1D>
 
   /// Anchor Point
-  let anchorPoint: KeyframeGroup<Vector3D>
+  let anchorPoint: KeyframeGroup<LottieVector3D>
 
   /// Position
-  let position: KeyframeGroup<Vector3D>
+  let position: KeyframeGroup<LottieVector3D>
 
   /// Scale
-  let scale: KeyframeGroup<Vector3D>
+  let scale: KeyframeGroup<LottieVector3D>
 
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)

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

@@ -14,74 +14,80 @@ final class ShapeTransform: ShapeItem {
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: ShapeTransform.CodingKeys.self)
     anchor = try container
-      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchor) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .anchor) ??
+      KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
     position = try container
-      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .position) ?? KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .position) ??
+      KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
     scale = try container
-      .decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale) ?? KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
-    rotation = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation) ?? KeyframeGroup(Vector1D(0))
-    opacity = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity) ?? KeyframeGroup(Vector1D(100))
-    skew = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skew) ?? KeyframeGroup(Vector1D(0))
-    skewAxis = try container.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skewAxis) ?? KeyframeGroup(Vector1D(0))
+      .decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale) ??
+      KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
+    rotation = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) ?? KeyframeGroup(LottieVector1D(0))
+    opacity = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity) ?? KeyframeGroup(LottieVector1D(100))
+    skew = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skew) ?? KeyframeGroup(LottieVector1D(0))
+    skewAxis = try container
+      .decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skewAxis) ?? KeyframeGroup(LottieVector1D(0))
     try super.init(from: decoder)
   }
 
   required init(dictionary: [String: Any]) throws {
     if
       let anchorDictionary = dictionary[CodingKeys.anchor.rawValue] as? [String: Any],
-      let anchor = try? KeyframeGroup<Vector3D>(dictionary: anchorDictionary)
+      let anchor = try? KeyframeGroup<LottieVector3D>(dictionary: anchorDictionary)
     {
       self.anchor = anchor
     } else {
-      anchor = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      anchor = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
     }
     if
       let positionDictionary = dictionary[CodingKeys.position.rawValue] as? [String: Any],
-      let position = try? KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+      let position = try? KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
     {
       self.position = position
     } else {
-      position = KeyframeGroup(Vector3D(x: Double(0), y: 0, z: 0))
+      position = KeyframeGroup(LottieVector3D(x: Double(0), y: 0, z: 0))
     }
     if
       let scaleDictionary = dictionary[CodingKeys.scale.rawValue] as? [String: Any],
-      let scale = try? KeyframeGroup<Vector3D>(dictionary: scaleDictionary)
+      let scale = try? KeyframeGroup<LottieVector3D>(dictionary: scaleDictionary)
     {
       self.scale = scale
     } else {
-      scale = KeyframeGroup(Vector3D(x: Double(100), y: 100, z: 100))
+      scale = KeyframeGroup(LottieVector3D(x: Double(100), y: 100, z: 100))
     }
     if
       let rotationDictionary = dictionary[CodingKeys.rotation.rawValue] as? [String: Any],
-      let rotation = try? KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+      let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     {
       self.rotation = rotation
     } else {
-      rotation = KeyframeGroup(Vector1D(0))
+      rotation = KeyframeGroup(LottieVector1D(0))
     }
     if
       let opacityDictionary = dictionary[CodingKeys.opacity.rawValue] as? [String: Any],
-      let opacity = try? KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+      let opacity = try? KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
     {
       self.opacity = opacity
     } else {
-      opacity = KeyframeGroup(Vector1D(100))
+      opacity = KeyframeGroup(LottieVector1D(100))
     }
     if
       let skewDictionary = dictionary[CodingKeys.skew.rawValue] as? [String: Any],
-      let skew = try? KeyframeGroup<Vector1D>(dictionary: skewDictionary)
+      let skew = try? KeyframeGroup<LottieVector1D>(dictionary: skewDictionary)
     {
       self.skew = skew
     } else {
-      skew = KeyframeGroup(Vector1D(0))
+      skew = KeyframeGroup(LottieVector1D(0))
     }
     if
       let skewAxisDictionary = dictionary[CodingKeys.skewAxis.rawValue] as? [String: Any],
-      let skewAxis = try? KeyframeGroup<Vector1D>(dictionary: skewAxisDictionary)
+      let skewAxis = try? KeyframeGroup<LottieVector1D>(dictionary: skewAxisDictionary)
     {
       self.skewAxis = skewAxis
     } else {
-      skewAxis = KeyframeGroup(Vector1D(0))
+      skewAxis = KeyframeGroup(LottieVector1D(0))
     }
     try super.init(dictionary: dictionary)
   }
@@ -89,25 +95,25 @@ final class ShapeTransform: ShapeItem {
   // MARK: Internal
 
   /// Anchor Point
-  let anchor: KeyframeGroup<Vector3D>
+  let anchor: KeyframeGroup<LottieVector3D>
 
   /// Position
-  let position: KeyframeGroup<Vector3D>
+  let position: KeyframeGroup<LottieVector3D>
 
   /// Scale
-  let scale: KeyframeGroup<Vector3D>
+  let scale: KeyframeGroup<LottieVector3D>
 
   /// Rotation
-  let rotation: KeyframeGroup<Vector1D>
+  let rotation: KeyframeGroup<LottieVector1D>
 
   /// opacity
-  let opacity: KeyframeGroup<Vector1D>
+  let opacity: KeyframeGroup<LottieVector1D>
 
   /// Skew
-  let skew: KeyframeGroup<Vector1D>
+  let skew: KeyframeGroup<LottieVector1D>
 
   /// Skew Axis
-  let skewAxis: KeyframeGroup<Vector1D>
+  let skewAxis: KeyframeGroup<LottieVector1D>
 
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)

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

@@ -24,13 +24,13 @@ final class Star: ShapeItem {
   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)
+    position = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .position)
+    outerRadius = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .outerRadius)
+    outerRoundness = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .outerRoundness)
+    innerRadius = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .innerRadius)
+    innerRoundness = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .innerRoundness)
+    rotation = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .rotation)
+    points = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .points)
     starType = try container.decode(StarType.self, forKey: .starType)
     try super.init(from: decoder)
   }
@@ -45,25 +45,25 @@ final class Star: ShapeItem {
       direction = .clockwise
     }
     let positionDictionary: [String: Any] = try dictionary.value(for: CodingKeys.position)
-    position = try KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+    position = try KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
     let outerRadiusDictionary: [String: Any] = try dictionary.value(for: CodingKeys.outerRadius)
-    outerRadius = try KeyframeGroup<Vector1D>(dictionary: outerRadiusDictionary)
+    outerRadius = try KeyframeGroup<LottieVector1D>(dictionary: outerRadiusDictionary)
     let outerRoundnessDictionary: [String: Any] = try dictionary.value(for: CodingKeys.outerRoundness)
-    outerRoundness = try KeyframeGroup<Vector1D>(dictionary: outerRoundnessDictionary)
+    outerRoundness = try KeyframeGroup<LottieVector1D>(dictionary: outerRoundnessDictionary)
     if let innerRadiusDictionary = dictionary[CodingKeys.innerRadius.rawValue] as? [String: Any] {
-      innerRadius = try KeyframeGroup<Vector1D>(dictionary: innerRadiusDictionary)
+      innerRadius = try KeyframeGroup<LottieVector1D>(dictionary: innerRadiusDictionary)
     } else {
       innerRadius = nil
     }
     if let innerRoundnessDictionary = dictionary[CodingKeys.innerRoundness.rawValue] as? [String: Any] {
-      innerRoundness = try KeyframeGroup<Vector1D>(dictionary: innerRoundnessDictionary)
+      innerRoundness = try KeyframeGroup<LottieVector1D>(dictionary: innerRoundnessDictionary)
     } else {
       innerRoundness = nil
     }
     let rotationDictionary: [String: Any] = try dictionary.value(for: CodingKeys.rotation)
-    rotation = try KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+    rotation = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     let pointsDictionary: [String: Any] = try dictionary.value(for: CodingKeys.points)
-    points = try KeyframeGroup<Vector1D>(dictionary: pointsDictionary)
+    points = try KeyframeGroup<LottieVector1D>(dictionary: pointsDictionary)
     let starTypeRawValue: Int = try dictionary.value(for: CodingKeys.starType)
     guard let starType = StarType(rawValue: starTypeRawValue) else {
       throw InitializableError.invalidInput
@@ -78,25 +78,25 @@ final class Star: ShapeItem {
   let direction: PathDirection
 
   /// The position of the star
-  let position: KeyframeGroup<Vector3D>
+  let position: KeyframeGroup<LottieVector3D>
 
   /// The outer radius of the star
-  let outerRadius: KeyframeGroup<Vector1D>
+  let outerRadius: KeyframeGroup<LottieVector1D>
 
   /// The outer roundness of the star
-  let outerRoundness: KeyframeGroup<Vector1D>
+  let outerRoundness: KeyframeGroup<LottieVector1D>
 
   /// The outer radius of the star
-  let innerRadius: KeyframeGroup<Vector1D>?
+  let innerRadius: KeyframeGroup<LottieVector1D>?
 
   /// The outer roundness of the star
-  let innerRoundness: KeyframeGroup<Vector1D>?
+  let innerRoundness: KeyframeGroup<LottieVector1D>?
 
   /// The rotation of the star
-  let rotation: KeyframeGroup<Vector1D>
+  let rotation: KeyframeGroup<LottieVector1D>
 
   /// The number of points on the star
-  let points: KeyframeGroup<Vector1D>
+  let points: KeyframeGroup<LottieVector1D>
 
   /// The type of star
   let starType: StarType

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

@@ -13,9 +13,9 @@ final class Stroke: ShapeItem {
 
   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)
+    opacity = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
+    color = try container.decode(KeyframeGroup<LottieColor>.self, forKey: .color)
+    width = try container.decode(KeyframeGroup<LottieVector1D>.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
@@ -25,11 +25,11 @@ final class Stroke: ShapeItem {
 
   required init(dictionary: [String: Any]) throws {
     let opacityDictionary: [String: Any] = try dictionary.value(for: CodingKeys.opacity)
-    opacity = try KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+    opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
     let colorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.color)
-    color = try KeyframeGroup<Color>(dictionary: colorDictionary)
+    color = try KeyframeGroup<LottieColor>(dictionary: colorDictionary)
     let widthDictionary: [String: Any] = try dictionary.value(for: CodingKeys.width)
-    width = try KeyframeGroup<Vector1D>(dictionary: widthDictionary)
+    width = try KeyframeGroup<LottieVector1D>(dictionary: widthDictionary)
     if
       let lineCapRawValue = dictionary[CodingKeys.lineCap.rawValue] as? Int,
       let lineCap = LineCap(rawValue: lineCapRawValue)
@@ -55,13 +55,13 @@ final class Stroke: ShapeItem {
   // MARK: Internal
 
   /// The opacity of the stroke
-  let opacity: KeyframeGroup<Vector1D>
+  let opacity: KeyframeGroup<LottieVector1D>
 
   /// The Color of the stroke
-  let color: KeyframeGroup<Color>
+  let color: KeyframeGroup<LottieColor>
 
   /// The width of the stroke
-  let width: KeyframeGroup<Vector1D>
+  let width: KeyframeGroup<LottieVector1D>
 
   /// Line Cap
   let lineCap: LineCap

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

@@ -22,20 +22,20 @@ final class Trim: ShapeItem {
 
   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)
+    start = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .start)
+    end = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .end)
+    offset = try container.decode(KeyframeGroup<LottieVector1D>.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)
+    start = try KeyframeGroup<LottieVector1D>(dictionary: startDictionary)
     let endDictionary: [String: Any] = try dictionary.value(for: CodingKeys.end)
-    end = try KeyframeGroup<Vector1D>(dictionary: endDictionary)
+    end = try KeyframeGroup<LottieVector1D>(dictionary: endDictionary)
     let offsetDictionary: [String: Any] = try dictionary.value(for: CodingKeys.offset)
-    offset = try KeyframeGroup<Vector1D>(dictionary: offsetDictionary)
+    offset = try KeyframeGroup<LottieVector1D>(dictionary: offsetDictionary)
     let trimTypeRawValue: Int = try dictionary.value(for: CodingKeys.trimType)
     guard let trimType = TrimType(rawValue: trimTypeRawValue) else {
       throw InitializableError.invalidInput
@@ -47,13 +47,13 @@ final class Trim: ShapeItem {
   // MARK: Internal
 
   /// The start of the trim
-  let start: KeyframeGroup<Vector1D>
+  let start: KeyframeGroup<LottieVector1D>
 
   /// The end of the trim
-  let end: KeyframeGroup<Vector1D>
+  let end: KeyframeGroup<LottieVector1D>
 
   /// The offset of the trim
-  let offset: KeyframeGroup<Vector1D>
+  let offset: KeyframeGroup<LottieVector1D>
 
   let trimType: TrimType