lottie-ios 3.4.3 → 3.5.0

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

@@ -88,10 +88,10 @@ extension Trim {
   /// plus a `pathMultiplier` that should be applied to the layer's `path` so that
   /// trim values larger than 100% can be displayed properly.
   fileprivate func caShapeLayerKeyframes(context: LayerAnimationContext) throws
-    -> (strokeStart: KeyframeGroup<Vector1D>, strokeEnd: KeyframeGroup<Vector1D>, pathMultiplier: PathMultiplier)
+    -> (strokeStart: KeyframeGroup<LottieVector1D>, strokeEnd: KeyframeGroup<LottieVector1D>, pathMultiplier: PathMultiplier)
   {
-    let strokeStart: KeyframeGroup<Vector1D>
-    let strokeEnd: KeyframeGroup<Vector1D>
+    let strokeStart: KeyframeGroup<LottieVector1D>
+    let strokeEnd: KeyframeGroup<LottieVector1D>
 
     // CAShapeLayer requires strokeStart to be less than strokeEnd. This
     // isn't required by the Lottie schema, so some animations may have
@@ -142,8 +142,8 @@ extension Trim {
     if minimumStrokeMultiplier < 0 {
       // Core Animation doesn't support negative stroke offsets, so we have to
       // shift all of the offset values up by the minimum
-      adjustedStrokeStart = adjustedStrokeStart.map { Vector1D($0.value + (abs(minimumStrokeMultiplier) * 100.0)) }
-      adjustedStrokeEnd = adjustedStrokeEnd.map { Vector1D($0.value + (abs(minimumStrokeMultiplier) * 100.0)) }
+      adjustedStrokeStart = adjustedStrokeStart.map { LottieVector1D($0.value + (abs(minimumStrokeMultiplier) * 100.0)) }
+      adjustedStrokeEnd = adjustedStrokeEnd.map { LottieVector1D($0.value + (abs(minimumStrokeMultiplier) * 100.0)) }
     }
 
     return (
@@ -164,8 +164,8 @@ extension Trim {
 
     for keyframeTime in keyframeTimes {
       guard
-        let startAtTime = startInterpolator.value(frame: keyframeTime) as? Vector1D,
-        let endAtTime = endInterpolator.value(frame: keyframeTime) as? Vector1D
+        let startAtTime = startInterpolator.value(frame: keyframeTime) as? LottieVector1D,
+        let endAtTime = endInterpolator.value(frame: keyframeTime) as? LottieVector1D
       else { continue }
 
       if startAtTime.cgFloatValue < endAtTime.cgFloatValue {
@@ -184,9 +184,9 @@ extension Trim {
   ///
   /// - Precondition: The keyframes must be interpolated using `KeyframeGroup.manuallyInterpolateKeyframes()`
   private func adjustKeyframesForTrimOffsets(
-    strokeKeyframes: ContiguousArray<Keyframe<Vector1D>>,
-    offsetKeyframes: ContiguousArray<Keyframe<Vector1D>>,
-    context _: LayerAnimationContext) throws -> ContiguousArray<Keyframe<Vector1D>>
+    strokeKeyframes: ContiguousArray<Keyframe<LottieVector1D>>,
+    offsetKeyframes: ContiguousArray<Keyframe<LottieVector1D>>,
+    context _: LayerAnimationContext) throws -> ContiguousArray<Keyframe<LottieVector1D>>
   {
     guard
       !strokeKeyframes.isEmpty,
@@ -196,7 +196,7 @@ extension Trim {
     }
 
     // Map each time to its corresponding stroke/offset keyframe
-    var timeMap = [AnimationFrameTime: [Keyframe<Vector1D>?]]()
+    var timeMap = [AnimationFrameTime: [Keyframe<LottieVector1D>?]]()
     for stroke in strokeKeyframes {
       timeMap[stroke.time] = [stroke, nil]
     }
@@ -210,9 +210,9 @@ extension Trim {
     }
 
     // Each time will be mapped to a new, adjusted keyframe
-    var output = ContiguousArray<Keyframe<Vector1D>>()
-    var lastKeyframe: Keyframe<Vector1D>?
-    var lastOffset: Keyframe<Vector1D>?
+    var output = ContiguousArray<Keyframe<LottieVector1D>>()
+    var lastKeyframe: Keyframe<LottieVector1D>?
+    var lastOffset: Keyframe<LottieVector1D>?
 
     for (time, values) in timeMap.sorted(by: { $0.0 < $1.0 }) {
       // Extract keyframe/offset associated with this timestamp
@@ -240,8 +240,8 @@ extension Trim {
       let adjustedValue = strokeValue + (offsetValue / 360 * 100)
 
       // The tangent values are all `nil` as the keyframes should have been manually interpolated
-      let adjustedKeyframe = Keyframe<Vector1D>(
-        value: Vector1D(adjustedValue),
+      let adjustedKeyframe = Keyframe<LottieVector1D>(
+        value: LottieVector1D(adjustedValue),
         time: time,
         isHold: currentKeyframe.isHold,
         inTangent: nil,

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/Layers/ShapeLayer.swift

@@ -157,7 +157,7 @@ final class GroupLayer: BaseAnimationLayer {
         // interpolate the path for each shape at each frame ahead of time so we can combine them
         // into a single set of bezier path keyframes.
         else {
-          combinedShape = .manuallyInterpolating(shapes: allPathKeyframes, name: group.name, context: context)
+          combinedShape = .manuallyInterpolating(shapes: allPathKeyframes, name: group.name)
         }
 
         let sublayer = try ShapeItemLayer(

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/Extensions/ItemsExtension.swift

@@ -80,7 +80,7 @@ extension Array where Element == ShapeItem {
         nodeTree.paths.append(contentsOf: tree.paths)
         nodeTree.renderContainers.append(node.container)
       } else if item is Repeater {
-        LottieLogger.shared.assertionFailure("""
+        LottieLogger.shared.warn("""
           The Main Thread rendering engine doesn't currently support repeaters.
           To play an animation with repeaters, you can use the Core Animation rendering engine instead.
           """)

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