lottie-ios 3.4.4 → 3.5.0

package/Sources/Private/CoreAnimation/Animations/StarAnimation.swift

@@ -81,13 +81,13 @@ extension CAShapeLayer {
 extension Star {
   /// Data that represents how to render a star at a specific point in time
   struct Keyframe {
-    let position: Vector3D
-    let outerRadius: Vector1D
-    let innerRadius: Vector1D
-    let outerRoundness: Vector1D
-    let innerRoundness: Vector1D
-    let points: Vector1D
-    let rotation: Vector1D
+    let position: LottieVector3D
+    let outerRadius: LottieVector1D
+    let innerRadius: LottieVector1D
+    let outerRoundness: LottieVector1D
+    let innerRoundness: LottieVector1D
+    let points: LottieVector1D
+    let rotation: LottieVector1D
   }
 
   /// Creates a single array of animatable keyframes from the separate arrays of keyframes in this star/polygon
@@ -95,9 +95,9 @@ extension Star {
     let combinedKeyframes = Keyframes.combinedIfPossible(
       position,
       outerRadius,
-      innerRadius ?? KeyframeGroup(Vector1D(0)),
+      innerRadius ?? KeyframeGroup(LottieVector1D(0)),
       outerRoundness,
-      innerRoundness ?? KeyframeGroup(Vector1D(0)),
+      innerRoundness ?? KeyframeGroup(LottieVector1D(0)),
       points,
       rotation,
       makeCombinedResult: Star.Keyframe.init)
@@ -112,10 +112,10 @@ extension Star {
           position: positionValue,
           outerRadius: try outerRadius.exactlyOneKeyframe(context: context, description: "star outerRadius"),
           innerRadius: try innerRadius?.exactlyOneKeyframe(context: context, description: "star innerRadius")
-            ?? Vector1D(0),
+            ?? LottieVector1D(0),
           outerRoundness: try outerRoundness.exactlyOneKeyframe(context: context, description: "star outerRoundness"),
           innerRoundness: try innerRoundness?.exactlyOneKeyframe(context: context, description: "star innerRoundness")
-            ?? Vector1D(0),
+            ?? LottieVector1D(0),
           points: try points.exactlyOneKeyframe(context: context, description: "star points"),
           rotation: try rotation.exactlyOneKeyframe(context: context, description: "star rotation"))
       }

package/Sources/Private/CoreAnimation/Animations/StrokeAnimation.swift

@@ -8,8 +8,8 @@ import QuartzCore
 
 /// A `ShapeItem` that represents a stroke
 protocol StrokeShapeItem: OpacityAnimationModel {
-  var strokeColor: KeyframeGroup<Color>? { get }
-  var width: KeyframeGroup<Vector1D> { get }
+  var strokeColor: KeyframeGroup<LottieColor>? { get }
+  var width: KeyframeGroup<LottieVector1D> { get }
   var lineCap: LineCap { get }
   var lineJoin: LineJoin { get }
   var miterLimit: Double { get }
@@ -19,13 +19,13 @@ protocol StrokeShapeItem: OpacityAnimationModel {
 // MARK: - Stroke + StrokeShapeItem
 
 extension Stroke: StrokeShapeItem {
-  var strokeColor: KeyframeGroup<Color>? { color }
+  var strokeColor: KeyframeGroup<LottieColor>? { color }
 }
 
 // MARK: - GradientStroke + StrokeShapeItem
 
 extension GradientStroke: StrokeShapeItem {
-  var strokeColor: KeyframeGroup<Color>? { nil }
+  var strokeColor: KeyframeGroup<LottieColor>? { nil }
 }
 
 // MARK: - CAShapeLayer + StrokeShapeItem

package/Sources/Private/CoreAnimation/Animations/TransformAnimations.swift

@@ -10,39 +10,39 @@ import QuartzCore
 /// both transform types to share the same animation implementation.
 protocol TransformModel {
   /// The anchor point of the transform.
-  var anchorPoint: KeyframeGroup<Vector3D> { get }
+  var anchorPoint: KeyframeGroup<LottieVector3D> { get }
 
   /// The position of the transform. This is nil if the position data was split.
-  var _position: KeyframeGroup<Vector3D>? { get }
+  var _position: KeyframeGroup<LottieVector3D>? { get }
 
   /// The positionX of the transform. This is nil if the position property is set.
-  var _positionX: KeyframeGroup<Vector1D>? { get }
+  var _positionX: KeyframeGroup<LottieVector1D>? { get }
 
   /// The positionY of the transform. This is nil if the position property is set.
-  var _positionY: KeyframeGroup<Vector1D>? { get }
+  var _positionY: KeyframeGroup<LottieVector1D>? { get }
 
   /// The scale of the transform
-  var scale: KeyframeGroup<Vector3D> { get }
+  var scale: KeyframeGroup<LottieVector3D> { get }
 
   /// The rotation of the transform. Note: This is single dimensional rotation.
-  var rotation: KeyframeGroup<Vector1D> { get }
+  var rotation: KeyframeGroup<LottieVector1D> { get }
 }
 
 // MARK: - Transform + TransformModel
 
 extension Transform: TransformModel {
-  var _position: KeyframeGroup<Vector3D>? { position }
-  var _positionX: KeyframeGroup<Vector1D>? { positionX }
-  var _positionY: KeyframeGroup<Vector1D>? { positionY }
+  var _position: KeyframeGroup<LottieVector3D>? { position }
+  var _positionX: KeyframeGroup<LottieVector1D>? { positionX }
+  var _positionY: KeyframeGroup<LottieVector1D>? { positionY }
 }
 
 // MARK: - ShapeTransform + TransformModel
 
 extension ShapeTransform: TransformModel {
-  var anchorPoint: KeyframeGroup<Vector3D> { anchor }
-  var _position: KeyframeGroup<Vector3D>? { position }
-  var _positionX: KeyframeGroup<Vector1D>? { nil }
-  var _positionY: KeyframeGroup<Vector1D>? { nil }
+  var anchorPoint: KeyframeGroup<LottieVector3D> { anchor }
+  var _position: KeyframeGroup<LottieVector3D>? { position }
+  var _positionX: KeyframeGroup<LottieVector1D>? { nil }
+  var _positionY: KeyframeGroup<LottieVector1D>? { nil }
 }
 
 // MARK: - CALayer + TransformModel

package/Sources/Private/CoreAnimation/CoreAnimationLayer.swift

@@ -15,7 +15,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   ///  - This initializer is throwing, but will only throw when using
   ///    `CompatibilityTracker.Mode.abort`.
   init(
-    animation: Animation,
+    animation: LottieAnimation,
     imageProvider: AnimationImageProvider,
     textProvider: AnimationTextProvider,
     fontProvider: AnimationFontProvider,
@@ -156,7 +156,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
       } catch {
         if case CompatibilityTracker.Error.encounteredCompatibilityIssue(let compatibilityIssue) = error {
           // Even though the animation setup failed, we still update the layer's playback state
-          // so it can be read by the parent `AnimationView` when handling this error
+          // so it can be read by the parent `LottieAnimationView` when handling this error
           currentPlaybackState = pendingAnimationConfiguration.playbackState
 
           didSetUpAnimation?([compatibilityIssue])
@@ -187,7 +187,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   /// which is also the realtime animation progress of this layer's animation
   @objc private var animationProgress: CGFloat = 0
 
-  private let animation: Animation
+  private let animation: LottieAnimation
   private let valueProviderStore: ValueProviderStore
   private let compatibilityTracker: CompatibilityTracker
   private let logger: LottieLogger

package/Sources/Private/CoreAnimation/Layers/AnimationLayer.swift

@@ -18,7 +18,7 @@ protocol AnimationLayer: CALayer {
 // Context describing the timing parameters of the current animation
 struct LayerAnimationContext {
   /// The animation being played
-  let animation: Animation
+  let animation: LottieAnimation
 
   /// The timing configuration that should be applied to `CAAnimation`s
   let timingConfiguration: CoreAnimationLayer.CAMediaTimingConfiguration

package/Sources/Private/CoreAnimation/Layers/CALayer+setupLayerHierarchy.swift

@@ -15,7 +15,7 @@ extension CALayer {
     context: LayerContext)
     throws
   {
-    // An `Animation`'s `LayerModel`s are listed from front to back,
+    // A `LottieAnimation`'s `LayerModel`s are listed from front to back,
     // but `CALayer.sublayers` are listed from back to front.
     // We reverse the layer ordering to match what Core Animation expects.
     // The final view hierarchy must display the layers in this exact order.

package/Sources/Private/CoreAnimation/Layers/LayerModel+makeAnimationLayer.swift

@@ -7,7 +7,7 @@ import QuartzCore
 
 /// Context available when constructing an `AnimationLayer`
 struct LayerContext {
-  let animation: Animation
+  let animation: LottieAnimation
   let imageProvider: AnimationImageProvider
   let textProvider: AnimationTextProvider
   let fontProvider: AnimationFontProvider

package/Sources/Private/CoreAnimation/Layers/PreCompLayer.swift

@@ -108,7 +108,7 @@ extension PreCompLayer: CustomLayoutLayer {
 extension KeyframeInterpolator where ValueType == AnimationFrameTime {
   /// A `KeyframeInterpolator` for the given `timeRemapping` keyframes
   static func timeRemapping(
-    keyframes timeRemappingKeyframes: KeyframeGroup<Vector1D>,
+    keyframes timeRemappingKeyframes: KeyframeGroup<LottieVector1D>,
     context: LayerContext)
     throws
     -> KeyframeInterpolator<AnimationFrameTime>

package/Sources/Private/CoreAnimation/Layers/RepeaterLayer.swift

@@ -56,11 +56,11 @@ private struct RepeaterTransform {
     scale = repeater.scale
 
     rotation = repeater.rotation.map { rotation in
-      Vector1D(rotation.value * Double(index))
+      LottieVector1D(rotation.value * Double(index))
     }
 
     position = repeater.position.map { position in
-      Vector3D(
+      LottieVector3D(
         x: position.x * Double(index),
         y: position.y * Double(index),
         z: position.z * Double(index))
@@ -69,17 +69,17 @@ private struct RepeaterTransform {
 
   // MARK: Internal
 
-  let anchorPoint: KeyframeGroup<Vector3D>
-  let position: KeyframeGroup<Vector3D>
-  let rotation: KeyframeGroup<Vector1D>
-  let scale: KeyframeGroup<Vector3D>
+  let anchorPoint: KeyframeGroup<LottieVector3D>
+  let position: KeyframeGroup<LottieVector3D>
+  let rotation: KeyframeGroup<LottieVector1D>
+  let scale: KeyframeGroup<LottieVector3D>
 
 }
 
 // MARK: TransformModel
 
 extension RepeaterTransform: TransformModel {
-  var _position: KeyframeGroup<Vector3D>? { position }
-  var _positionX: KeyframeGroup<Vector1D>? { nil }
-  var _positionY: KeyframeGroup<Vector1D>? { nil }
+  var _position: KeyframeGroup<LottieVector3D>? { position }
+  var _positionX: KeyframeGroup<LottieVector1D>? { nil }
+  var _positionY: KeyframeGroup<LottieVector1D>? { nil }
 }

package/Sources/Private/CoreAnimation/ValueProviderStore.swift

@@ -6,7 +6,7 @@ import QuartzCore
 // MARK: - ValueProviderStore
 
 /// Registration and storage for `AnyValueProvider`s that can dynamically
-/// provide custom values for `AnimationKeypath`s within an `Animation`.
+/// provide custom values for `AnimationKeypath`s within a `LottieAnimation`.
 final class ValueProviderStore {
 
   // MARK: Lifecycle

package/Sources/Private/MainThread/LayerContainers/CompLayers/MaskContainerLayer.swift

@@ -183,7 +183,7 @@ private class MaskNodeProperties: NodePropertyMap {
   let mode: MaskMode
   let inverted: Bool
 
-  let opacity: NodeProperty<Vector1D>
+  let opacity: NodeProperty<LottieVector1D>
   let shape: NodeProperty<BezierPath>
-  let expansion: NodeProperty<Vector1D>
+  let expansion: NodeProperty<LottieVector1D>
 }

package/Sources/Private/MainThread/LayerContainers/CompLayers/PreCompositionLayer.swift

@@ -90,7 +90,7 @@ final class PreCompositionLayer: CompositionLayer {
   // MARK: Internal
 
   let frameRate: CGFloat
-  let remappingNode: NodeProperty<Vector1D>?
+  let remappingNode: NodeProperty<LottieVector1D>?
 
   override var keypathProperties: [String: AnyNodeProperty] {
     guard let remappingNode = remappingNode else {

package/Sources/Private/MainThread/LayerContainers/CompLayers/SolidCompositionLayer.swift

@@ -15,7 +15,7 @@ final class SolidCompositionLayer: CompositionLayer {
   init(solid: SolidLayerModel) {
     let components = solid.colorHex.hexColorComponents()
     colorProperty =
-      NodeProperty(provider: SingleValueProvider(Color(
+      NodeProperty(provider: SingleValueProvider(LottieColor(
         r: Double(components.red),
         g: Double(components.green),
         b: Double(components.blue),
@@ -41,7 +41,7 @@ final class SolidCompositionLayer: CompositionLayer {
 
   // MARK: Internal
 
-  let colorProperty: NodeProperty<Color>?
+  let colorProperty: NodeProperty<LottieColor>?
   let solidShape = CAShapeLayer()
 
   override var keypathProperties: [String: AnyNodeProperty] {

package/Sources/Private/MainThread/LayerContainers/MainThreadAnimationLayer.swift

@@ -19,7 +19,7 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
   // MARK: Lifecycle
 
   init(
-    animation: Animation,
+    animation: LottieAnimation,
     imageProvider: AnimationImageProvider,
     textProvider: AnimationTextProvider,
     fontProvider: AnimationFontProvider,
@@ -152,7 +152,7 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
   }
 
   var isAnimationPlaying: Bool? {
-    nil // this state is managed by `AnimationView`
+    nil // this state is managed by `LottieAnimationView`
   }
 
   var _animationLayers: [CALayer] {
@@ -189,7 +189,7 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
   }
 
   func removeAnimations() {
-    // no-op, since the primary animation is managed by the `AnimationView`.
+    // no-op, since the primary animation is managed by the `LottieAnimationView`.
   }
 
   /// Forces the view to update its drawing.

package/Sources/Private/MainThread/LayerContainers/Utility/LayerTransformNode.swift

@@ -32,15 +32,15 @@ final class LayerTransformProperties: NodePropertyMap, KeypathSearchable {
       let positionKeyframesX = transform.positionX?.keyframes,
       let positionKeyframesY = transform.positionY?.keyframes
     {
-      let xPosition: NodeProperty<Vector1D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframesX))
-      let yPosition: NodeProperty<Vector1D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframesY))
+      let xPosition: NodeProperty<LottieVector1D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframesX))
+      let yPosition: NodeProperty<LottieVector1D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframesY))
       propertyMap["X Position"] = xPosition
       propertyMap["Y Position"] = yPosition
       positionX = xPosition
       positionY = yPosition
       position = nil
     } else if let positionKeyframes = transform.position?.keyframes {
-      let position: NodeProperty<Vector3D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframes))
+      let position: NodeProperty<LottieVector3D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframes))
       propertyMap["Position"] = position
       self.position = position
       positionX = nil
@@ -62,13 +62,13 @@ final class LayerTransformProperties: NodePropertyMap, KeypathSearchable {
 
   let properties: [AnyNodeProperty]
 
-  let anchor: NodeProperty<Vector3D>
-  let scale: NodeProperty<Vector3D>
-  let rotation: NodeProperty<Vector1D>
-  let position: NodeProperty<Vector3D>?
-  let positionX: NodeProperty<Vector1D>?
-  let positionY: NodeProperty<Vector1D>?
-  let opacity: NodeProperty<Vector1D>
+  let anchor: NodeProperty<LottieVector3D>
+  let scale: NodeProperty<LottieVector3D>
+  let rotation: NodeProperty<LottieVector1D>
+  let position: NodeProperty<LottieVector3D>?
+  let positionX: NodeProperty<LottieVector1D>?
+  let positionY: NodeProperty<LottieVector1D>?
+  let opacity: NodeProperty<LottieVector1D>
 
   var childKeypaths: [KeypathSearchable] {
     []

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/ModifierNodes/TrimPathNode.swift

@@ -34,9 +34,9 @@ final class TrimPathProperties: NodePropertyMap, KeypathSearchable {
   let properties: [AnyNodeProperty]
   let keypathName: String
 
-  let start: NodeProperty<Vector1D>
-  let end: NodeProperty<Vector1D>
-  let offset: NodeProperty<Vector1D>
+  let start: NodeProperty<LottieVector1D>
+  let end: NodeProperty<LottieVector1D>
+  let offset: NodeProperty<LottieVector1D>
   let type: TrimType
 }
 

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/EllipseNode.swift

@@ -31,8 +31,8 @@ final class EllipseNodeProperties: NodePropertyMap, KeypathSearchable {
   var keypathName: String
 
   let direction: PathDirection
-  let position: NodeProperty<Vector3D>
-  let size: NodeProperty<Vector3D>
+  let position: NodeProperty<LottieVector3D>
+  let size: NodeProperty<LottieVector3D>
 
   let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/PolygonNode.swift

@@ -42,11 +42,11 @@ final class PolygonNodeProperties: NodePropertyMap, KeypathSearchable {
   let properties: [AnyNodeProperty]
 
   let direction: PathDirection
-  let position: NodeProperty<Vector3D>
-  let outerRadius: NodeProperty<Vector1D>
-  let outerRoundedness: NodeProperty<Vector1D>
-  let rotation: NodeProperty<Vector1D>
-  let points: NodeProperty<Vector1D>
+  let position: NodeProperty<LottieVector3D>
+  let outerRadius: NodeProperty<LottieVector1D>
+  let outerRoundedness: NodeProperty<LottieVector1D>
+  let rotation: NodeProperty<LottieVector1D>
+  let points: NodeProperty<LottieVector1D>
 }
 
 // MARK: - PolygonNode

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/RectNode.swift

@@ -38,9 +38,9 @@ final class RectNodeProperties: NodePropertyMap, KeypathSearchable {
   let properties: [AnyNodeProperty]
 
   let direction: PathDirection
-  let position: NodeProperty<Vector3D>
-  let size: NodeProperty<Vector3D>
-  let cornerRadius: NodeProperty<Vector1D>
+  let position: NodeProperty<LottieVector3D>
+  let size: NodeProperty<LottieVector3D>
+  let cornerRadius: NodeProperty<LottieVector1D>
 
 }
 

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/StarNode.swift

@@ -23,12 +23,12 @@ final class StarNodeProperties: NodePropertyMap, KeypathSearchable {
     if let innerRadiusKeyframes = star.innerRadius?.keyframes {
       innerRadius = NodeProperty(provider: KeyframeInterpolator(keyframes: innerRadiusKeyframes))
     } else {
-      innerRadius = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      innerRadius = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
     }
     if let innderRoundedness = star.innerRoundness?.keyframes {
       innerRoundedness = NodeProperty(provider: KeyframeInterpolator(keyframes: innderRoundedness))
     } else {
-      innerRoundedness = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      innerRoundedness = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
     }
     rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: star.rotation.keyframes))
     points = NodeProperty(provider: KeyframeInterpolator(keyframes: star.points.keyframes))
@@ -52,13 +52,13 @@ final class StarNodeProperties: NodePropertyMap, KeypathSearchable {
   let properties: [AnyNodeProperty]
 
   let direction: PathDirection
-  let position: NodeProperty<Vector3D>
-  let outerRadius: NodeProperty<Vector1D>
-  let outerRoundedness: NodeProperty<Vector1D>
-  let innerRadius: NodeProperty<Vector1D>
-  let innerRoundedness: NodeProperty<Vector1D>
-  let rotation: NodeProperty<Vector1D>
-  let points: NodeProperty<Vector1D>
+  let position: NodeProperty<LottieVector3D>
+  let outerRadius: NodeProperty<LottieVector1D>
+  let outerRoundedness: NodeProperty<LottieVector1D>
+  let innerRadius: NodeProperty<LottieVector1D>
+  let innerRoundedness: NodeProperty<LottieVector1D>
+  let rotation: NodeProperty<LottieVector1D>
+  let points: NodeProperty<LottieVector1D>
 }
 
 // MARK: - StarNode

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderContainers/GroupNode.swift

@@ -26,13 +26,13 @@ final class GroupNodeProperties: NodePropertyMap, KeypathSearchable {
       skewAxis = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.skewAxis.keyframes))
     } else {
       /// Transform node missing. Default to empty transform.
-      anchor = NodeProperty(provider: SingleValueProvider(Vector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
-      position = NodeProperty(provider: SingleValueProvider(Vector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
-      scale = NodeProperty(provider: SingleValueProvider(Vector3D(x: CGFloat(100), y: CGFloat(100), z: CGFloat(100))))
-      rotation = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
-      opacity = NodeProperty(provider: SingleValueProvider(Vector1D(100)))
-      skew = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
-      skewAxis = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      anchor = NodeProperty(provider: SingleValueProvider(LottieVector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
+      position = NodeProperty(provider: SingleValueProvider(LottieVector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
+      scale = NodeProperty(provider: SingleValueProvider(LottieVector3D(x: CGFloat(100), y: CGFloat(100), z: CGFloat(100))))
+      rotation = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+      opacity = NodeProperty(provider: SingleValueProvider(LottieVector1D(100)))
+      skew = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+      skewAxis = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
     }
     keypathProperties = [
       "Anchor Point" : anchor,
@@ -55,13 +55,13 @@ final class GroupNodeProperties: NodePropertyMap, KeypathSearchable {
   let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
 
-  let anchor: NodeProperty<Vector3D>
-  let position: NodeProperty<Vector3D>
-  let scale: NodeProperty<Vector3D>
-  let rotation: NodeProperty<Vector1D>
-  let opacity: NodeProperty<Vector1D>
-  let skew: NodeProperty<Vector1D>
-  let skewAxis: NodeProperty<Vector1D>
+  let anchor: NodeProperty<LottieVector3D>
+  let position: NodeProperty<LottieVector3D>
+  let scale: NodeProperty<LottieVector3D>
+  let rotation: NodeProperty<LottieVector1D>
+  let opacity: NodeProperty<LottieVector1D>
+  let skew: NodeProperty<LottieVector1D>
+  let skewAxis: NodeProperty<LottieVector1D>
 
   var caTransform: CATransform3D {
     CATransform3D.makeTransform(

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/FillNode.swift

@@ -30,8 +30,8 @@ final class FillNodeProperties: NodePropertyMap, KeypathSearchable {
 
   var keypathName: String
 
-  let opacity: NodeProperty<Vector1D>
-  let color: NodeProperty<Color>
+  let opacity: NodeProperty<LottieVector1D>
+  let color: NodeProperty<LottieColor>
   let type: FillRule
 
   let keypathProperties: [String: AnyNodeProperty]

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/GradientFillNode.swift

@@ -36,9 +36,9 @@ final class GradientFillProperties: NodePropertyMap, KeypathSearchable {
 
   var keypathName: String
 
-  let opacity: NodeProperty<Vector1D>
-  let startPoint: NodeProperty<Vector3D>
-  let endPoint: NodeProperty<Vector3D>
+  let opacity: NodeProperty<LottieVector1D>
+  let startPoint: NodeProperty<LottieVector3D>
+  let endPoint: NodeProperty<LottieVector3D>
   let colors: NodeProperty<[Double]>
 
   let gradientType: GradientType

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/GradientStrokeNode.swift

@@ -28,8 +28,8 @@ final class GradientStrokeProperties: NodePropertyMap, KeypathSearchable {
     lineJoin = gradientStroke.lineJoin
 
     if let dashes = gradientStroke.dashPattern {
-      var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>()
-      var dashPhase = ContiguousArray<Keyframe<Vector1D>>()
+      var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<LottieVector1D>>>()
+      var dashPhase = ContiguousArray<Keyframe<LottieVector1D>>()
       for dash in dashes {
         if dash.type == .offset {
           dashPhase = dash.value.keyframes
@@ -40,8 +40,8 @@ final class GradientStrokeProperties: NodePropertyMap, KeypathSearchable {
       dashPattern = NodeProperty(provider: GroupInterpolator(keyframeGroups: dashPatterns))
       self.dashPhase = NodeProperty(provider: KeyframeInterpolator(keyframes: dashPhase))
     } else {
-      dashPattern = NodeProperty(provider: SingleValueProvider([Vector1D]()))
-      dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      dashPattern = NodeProperty(provider: SingleValueProvider([LottieVector1D]()))
+      dashPhase = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
     }
     keypathProperties = [
       "Opacity" : opacity,
@@ -59,14 +59,14 @@ final class GradientStrokeProperties: NodePropertyMap, KeypathSearchable {
 
   var keypathName: String
 
-  let opacity: NodeProperty<Vector1D>
-  let startPoint: NodeProperty<Vector3D>
-  let endPoint: NodeProperty<Vector3D>
+  let opacity: NodeProperty<LottieVector1D>
+  let startPoint: NodeProperty<LottieVector3D>
+  let endPoint: NodeProperty<LottieVector3D>
   let colors: NodeProperty<[Double]>
-  let width: NodeProperty<Vector1D>
+  let width: NodeProperty<LottieVector1D>
 
-  let dashPattern: NodeProperty<[Vector1D]>
-  let dashPhase: NodeProperty<Vector1D>
+  let dashPattern: NodeProperty<[LottieVector1D]>
+  let dashPhase: NodeProperty<LottieVector1D>
 
   let lineCap: LineCap
   let lineJoin: LineJoin

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/StrokeNode.swift

@@ -27,13 +27,13 @@ final class StrokeNodeProperties: NodePropertyMap, KeypathSearchable {
       let (dashPatterns, dashPhase) = dashes.shapeLayerConfiguration
       dashPattern = NodeProperty(provider: GroupInterpolator(keyframeGroups: dashPatterns))
       if dashPhase.count == 0 {
-        self.dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+        self.dashPhase = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
       } else {
         self.dashPhase = NodeProperty(provider: KeyframeInterpolator(keyframes: dashPhase))
       }
     } else {
-      dashPattern = NodeProperty(provider: SingleValueProvider([Vector1D]()))
-      dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      dashPattern = NodeProperty(provider: SingleValueProvider([LottieVector1D]()))
+      dashPhase = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
     }
     keypathProperties = [
       "Opacity" : opacity,
@@ -51,12 +51,12 @@ final class StrokeNodeProperties: NodePropertyMap, KeypathSearchable {
   let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
 
-  let opacity: NodeProperty<Vector1D>
-  let color: NodeProperty<Color>
-  let width: NodeProperty<Vector1D>
+  let opacity: NodeProperty<LottieVector1D>
+  let color: NodeProperty<LottieColor>
+  let width: NodeProperty<LottieVector1D>
 
-  let dashPattern: NodeProperty<[Vector1D]>
-  let dashPhase: NodeProperty<Vector1D>
+  let dashPattern: NodeProperty<[LottieVector1D]>
+  let dashPhase: NodeProperty<LottieVector1D>
 
   let lineCap: LineCap
   let lineJoin: LineJoin
@@ -133,14 +133,14 @@ final class StrokeNode: AnimatorNode, RenderNode {
 
 extension Array where Element == DashElement {
   typealias ShapeLayerConfiguration = (
-    dashPatterns: ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>,
-    dashPhase: ContiguousArray<Keyframe<Vector1D>>)
+    dashPatterns: ContiguousArray<ContiguousArray<Keyframe<LottieVector1D>>>,
+    dashPhase: ContiguousArray<Keyframe<LottieVector1D>>)
 
   /// Converts the `[DashElement]` data model into `lineDashPattern` and `lineDashPhase`
   /// representations usable in a `CAShapeLayer`
   var shapeLayerConfiguration: ShapeLayerConfiguration {
-    var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>()
-    var dashPhase = ContiguousArray<Keyframe<Vector1D>>()
+    var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<LottieVector1D>>>()
+    var dashPhase = ContiguousArray<Keyframe<LottieVector1D>>()
     for dash in self {
       if dash.type == .offset {
         dashPhase = dash.value.keyframes
@@ -150,14 +150,14 @@ extension Array where Element == DashElement {
     }
 
     dashPatterns = ContiguousArray(dashPatterns.map { pattern in
-      ContiguousArray(pattern.map { keyframe -> Keyframe<Vector1D> in
+      ContiguousArray(pattern.map { keyframe -> Keyframe<LottieVector1D> in
         // The recommended way to create a stroke of round dots, in theory,
         // is to use a value of 0 followed by the stroke width, but for
         // some reason Core Animation incorrectly (?) renders these as pills
         // instead of circles. As a workaround, for parity with Lottie on other
         // platforms, we can change `0`s to `0.01`: https://stackoverflow.com/a/38036486
         if keyframe.value.cgFloatValue == 0 {
-          return keyframe.withValue(Vector1D(0.01))
+          return keyframe.withValue(LottieVector1D(0.01))
         } else {
           return keyframe
         }