lottie-ios 3.4.4 → 3.5.0

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
 

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

@@ -15,74 +15,74 @@ final class TextAnimator: Codable, DictionaryInitializable {
     let container = try decoder.container(keyedBy: TextAnimator.CodingKeys.self)
     name = try container.decodeIfPresent(String.self, forKey: .name) ?? ""
     let animatorContainer = try container.nestedContainer(keyedBy: TextAnimatorKeys.self, forKey: .textAnimator)
-    fillColor = try animatorContainer.decodeIfPresent(KeyframeGroup<Color>.self, forKey: .fillColor)
-    strokeColor = try animatorContainer.decodeIfPresent(KeyframeGroup<Color>.self, forKey: .strokeColor)
-    strokeWidth = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .strokeWidth)
-    tracking = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .tracking)
-    anchor = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .anchor)
-    position = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .position)
-    scale = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector3D>.self, forKey: .scale)
-    skew = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skew)
-    skewAxis = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .skewAxis)
-    rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .rotation)
-    opacity = try animatorContainer.decodeIfPresent(KeyframeGroup<Vector1D>.self, forKey: .opacity)
+    fillColor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieColor>.self, forKey: .fillColor)
+    strokeColor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieColor>.self, forKey: .strokeColor)
+    strokeWidth = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .strokeWidth)
+    tracking = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .tracking)
+    anchor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .anchor)
+    position = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .position)
+    scale = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale)
+    skew = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skew)
+    skewAxis = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skewAxis)
+    rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation)
+    opacity = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
   }
 
   init(dictionary: [String: Any]) throws {
     name = (try? dictionary.value(for: CodingKeys.name)) ?? ""
     let animatorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.textAnimator)
     if let fillColorDictionary = animatorDictionary[TextAnimatorKeys.fillColor.rawValue] as? [String: Any] {
-      fillColor = try? KeyframeGroup<Color>(dictionary: fillColorDictionary)
+      fillColor = try? KeyframeGroup<LottieColor>(dictionary: fillColorDictionary)
     } else {
       fillColor = nil
     }
     if let strokeColorDictionary = animatorDictionary[TextAnimatorKeys.strokeColor.rawValue] as? [String: Any] {
-      strokeColor = try? KeyframeGroup<Color>(dictionary: strokeColorDictionary)
+      strokeColor = try? KeyframeGroup<LottieColor>(dictionary: strokeColorDictionary)
     } else {
       strokeColor = nil
     }
     if let strokeWidthDictionary = animatorDictionary[TextAnimatorKeys.strokeWidth.rawValue] as? [String: Any] {
-      strokeWidth = try? KeyframeGroup<Vector1D>(dictionary: strokeWidthDictionary)
+      strokeWidth = try? KeyframeGroup<LottieVector1D>(dictionary: strokeWidthDictionary)
     } else {
       strokeWidth = nil
     }
     if let trackingDictionary = animatorDictionary[TextAnimatorKeys.tracking.rawValue] as? [String: Any] {
-      tracking = try? KeyframeGroup<Vector1D>(dictionary: trackingDictionary)
+      tracking = try? KeyframeGroup<LottieVector1D>(dictionary: trackingDictionary)
     } else {
       tracking = nil
     }
     if let anchorDictionary = animatorDictionary[TextAnimatorKeys.anchor.rawValue] as? [String: Any] {
-      anchor = try? KeyframeGroup<Vector3D>(dictionary: anchorDictionary)
+      anchor = try? KeyframeGroup<LottieVector3D>(dictionary: anchorDictionary)
     } else {
       anchor = nil
     }
     if let positionDictionary = animatorDictionary[TextAnimatorKeys.position.rawValue] as? [String: Any] {
-      position = try? KeyframeGroup<Vector3D>(dictionary: positionDictionary)
+      position = try? KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
     } else {
       position = nil
     }
     if let scaleDictionary = animatorDictionary[TextAnimatorKeys.scale.rawValue] as? [String: Any] {
-      scale = try? KeyframeGroup<Vector3D>(dictionary: scaleDictionary)
+      scale = try? KeyframeGroup<LottieVector3D>(dictionary: scaleDictionary)
     } else {
       scale = nil
     }
     if let skewDictionary = animatorDictionary[TextAnimatorKeys.skew.rawValue] as? [String: Any] {
-      skew = try? KeyframeGroup<Vector1D>(dictionary: skewDictionary)
+      skew = try? KeyframeGroup<LottieVector1D>(dictionary: skewDictionary)
     } else {
       skew = nil
     }
     if let skewAxisDictionary = animatorDictionary[TextAnimatorKeys.skewAxis.rawValue] as? [String: Any] {
-      skewAxis = try? KeyframeGroup<Vector1D>(dictionary: skewAxisDictionary)
+      skewAxis = try? KeyframeGroup<LottieVector1D>(dictionary: skewAxisDictionary)
     } else {
       skewAxis = nil
     }
     if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotation.rawValue] as? [String: Any] {
-      rotation = try? KeyframeGroup<Vector1D>(dictionary: rotationDictionary)
+      rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     } else {
       rotation = nil
     }
     if let opacityDictionary = animatorDictionary[TextAnimatorKeys.opacity.rawValue] as? [String: Any] {
-      opacity = try KeyframeGroup<Vector1D>(dictionary: opacityDictionary)
+      opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
     } else {
       opacity = nil
     }
@@ -93,37 +93,37 @@ final class TextAnimator: Codable, DictionaryInitializable {
   let name: String
 
   /// Anchor
-  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>?
 
   /// Skew
-  let skew: KeyframeGroup<Vector1D>?
+  let skew: KeyframeGroup<LottieVector1D>?
 
   /// Skew Axis
-  let skewAxis: KeyframeGroup<Vector1D>?
+  let skewAxis: KeyframeGroup<LottieVector1D>?
 
   /// Rotation
-  let rotation: KeyframeGroup<Vector1D>?
+  let rotation: KeyframeGroup<LottieVector1D>?
 
   /// Opacity
-  let opacity: KeyframeGroup<Vector1D>?
+  let opacity: KeyframeGroup<LottieVector1D>?
 
   /// Stroke Color
-  let strokeColor: KeyframeGroup<Color>?
+  let strokeColor: KeyframeGroup<LottieColor>?
 
   /// Fill Color
-  let fillColor: KeyframeGroup<Color>?
+  let fillColor: KeyframeGroup<LottieColor>?
 
   /// Stroke Width
-  let strokeWidth: KeyframeGroup<Vector1D>?
+  let strokeWidth: KeyframeGroup<LottieVector1D>?
 
   /// Tracking
-  let tracking: KeyframeGroup<Vector1D>?
+  let tracking: KeyframeGroup<LottieVector1D>?
 
   func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)

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

@@ -34,24 +34,24 @@ final class TextDocument: Codable, DictionaryInitializable, AnyInitializable {
     lineHeight = try dictionary.value(for: CodingKeys.lineHeight)
     baseline = try dictionary.value(for: CodingKeys.baseline)
     if let fillColorRawValue = dictionary[CodingKeys.fillColorData.rawValue] {
-      fillColorData = try? Color(value: fillColorRawValue)
+      fillColorData = try? LottieColor(value: fillColorRawValue)
     } else {
       fillColorData = nil
     }
     if let strokeColorRawValue = dictionary[CodingKeys.strokeColorData.rawValue] {
-      strokeColorData = try? Color(value: strokeColorRawValue)
+      strokeColorData = try? LottieColor(value: strokeColorRawValue)
     } else {
       strokeColorData = nil
     }
     strokeWidth = try? dictionary.value(for: CodingKeys.strokeWidth)
     strokeOverFill = try? dictionary.value(for: CodingKeys.strokeOverFill)
     if let textFramePositionRawValue = dictionary[CodingKeys.textFramePosition.rawValue] {
-      textFramePosition = try? Vector3D(value: textFramePositionRawValue)
+      textFramePosition = try? LottieVector3D(value: textFramePositionRawValue)
     } else {
       textFramePosition = nil
     }
     if let textFrameSizeRawValue = dictionary[CodingKeys.textFrameSize.rawValue] {
-      textFrameSize = try? Vector3D(value: textFrameSizeRawValue)
+      textFrameSize = try? LottieVector3D(value: textFrameSizeRawValue)
     } else {
       textFrameSize = nil
     }
@@ -88,10 +88,10 @@ final class TextDocument: Codable, DictionaryInitializable, AnyInitializable {
   let baseline: Double?
 
   /// Fill Color data
-  let fillColorData: Color?
+  let fillColorData: LottieColor?
 
   /// Scroke Color data
-  let strokeColorData: Color?
+  let strokeColorData: LottieColor?
 
   /// Stroke Width
   let strokeWidth: Double?
@@ -99,9 +99,9 @@ final class TextDocument: Codable, DictionaryInitializable, AnyInitializable {
   /// Stroke Over Fill
   let strokeOverFill: Bool?
 
-  let textFramePosition: Vector3D?
+  let textFramePosition: LottieVector3D?
 
-  let textFrameSize: Vector3D?
+  let textFrameSize: LottieVector3D?
 
   // MARK: Private