lottie-ios 3.4.4 → 4.0.0

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

@@ -144,21 +144,9 @@ final class GroupLayer: BaseAnimationLayer {
         !shapeRenderGroup.otherItems.contains(where: { $0.item is Trim })
       {
         let allPathKeyframes = shapeRenderGroup.pathItems.compactMap { ($0.item as? Shape)?.path }
-        let combinedShape: CombinedShapeItem
-
-        // If all of the path-drawing `ShapeItem`s have keyframes with the same timing information,
-        // we can combine the `[KeyframeGroup<BezierPath>]` (which have to animate in separate layers)
-        // into a single `KeyframeGroup<[BezierPath]>`, which can be combined into a single CGPath animation.
-        if let combinedShapeKeyframes = Keyframes.combinedIfPossible(allPathKeyframes) {
-          combinedShape = CombinedShapeItem(shapes: combinedShapeKeyframes, name: group.name)
-        }
-
-        // Otherwise, in order for the path fills to be rendered correctly, we have to manually
-        // 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)
-        }
+        let combinedShape = CombinedShapeItem(
+          shapes: Keyframes.combined(allPathKeyframes),
+          name: group.name)
 
         let sublayer = try ShapeItemLayer(
           shape: ShapeItemLayer.Item(item: combinedShape, groupPath: shapeRenderGroup.pathItems[0].groupPath),
@@ -194,7 +182,8 @@ extension CALayer {
     from items: [ShapeItem],
     parentGroup: Group?,
     parentGroupPath: [String],
-    context: LayerContext) throws
+    context: LayerContext)
+    throws
   {
     let groupLayers = try makeGroupLayers(
       from: items,
@@ -214,8 +203,8 @@ extension CALayer {
     from items: [ShapeItem],
     parentGroup: Group?,
     parentGroupPath: [String],
-    context: LayerContext) throws
-    -> [GroupLayer]
+    context: LayerContext)
+    throws -> [GroupLayer]
   {
     var (groupItems, otherItems) = items
       .filter { !$0.hidden }

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
@@ -40,8 +40,7 @@ final class ValueProviderStore {
     of customizableProperty: CustomizableProperty<Value>,
     for keypath: AnimationKeypath,
     context: LayerAnimationContext)
-    throws
-    -> KeyframeGroup<Value>?
+    throws -> KeyframeGroup<Value>?
   {
     if context.logHierarchyKeypaths {
       context.logger.info(keypath.fullPath)

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

@@ -73,7 +73,7 @@ final class MaskContainerLayer: CALayer {
   // MARK: Internal
 
   func updateWithFrame(frame: CGFloat, forceUpdates: Bool) {
-    maskLayers.forEach({ $0.updateWithFrame(frame: frame, forceUpdates: forceUpdates) })
+    maskLayers.forEach { $0.updateWithFrame(frame: frame, forceUpdates: forceUpdates) }
   }
 
   // MARK: Fileprivate
@@ -103,8 +103,8 @@ private class MaskLayer: CALayer {
     addSublayer(maskLayer)
     anchorPoint = .zero
     maskLayer.fillColor = mask.mode == .add
-      ? CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [1, 0, 0, 1])
-      : CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [0, 1, 0, 1])
+      ? .rgb(1, 0, 0)
+      : .rgb(0, 1, 0)
     maskLayer.fillRule = CAShapeLayerFillRule.evenOdd
     actions = [
       "opacity" : NSNull(),
@@ -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 {
@@ -107,12 +107,12 @@ final class PreCompositionLayer: CompositionLayer {
     } else {
       localFrame = (frame - startFrame) / timeStretch
     }
-    animationLayers.forEach({ $0.displayWithFrame(frame: localFrame, forceUpdates: forceUpdates) })
+    animationLayers.forEach { $0.displayWithFrame(frame: localFrame, forceUpdates: forceUpdates) }
   }
 
   override func updateRenderScale() {
     super.updateRenderScale()
-    animationLayers.forEach({ $0.renderScale = renderScale })
+    animationLayers.forEach { $0.renderScale = renderScale }
   }
 
   // MARK: Fileprivate

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,
@@ -31,6 +31,7 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
     animationLayers = []
     self.logger = logger
     super.init()
+    masksToBounds = true
     bounds = animation.bounds
     let layers = animation.layers.initializeCompositionLayers(
       assetLibrary: animation.assetLibrary,
@@ -152,7 +153,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] {
@@ -170,7 +171,7 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
 
   var renderScale: CGFloat = 1 {
     didSet {
-      animationLayers.forEach({ $0.renderScale = renderScale })
+      animationLayers.forEach { $0.renderScale = renderScale }
     }
   }
 
@@ -189,17 +190,17 @@ 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.
   func forceDisplayUpdate() {
-    animationLayers.forEach({ $0.displayWithFrame(frame: currentFrame, forceUpdates: true) })
+    animationLayers.forEach { $0.displayWithFrame(frame: currentFrame, forceUpdates: true) }
   }
 
   func logHierarchyKeypaths() {
     logger.info("Lottie: Logging Animation Keypaths")
-    animationLayers.forEach({ $0.logKeypaths(for: nil, logger: self.logger) })
+    animationLayers.forEach { $0.logKeypaths(for: nil, logger: self.logger) }
   }
 
   func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath) {

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

@@ -48,9 +48,7 @@ final class InvertedMatteLayer: CALayer, CompositionLayerDelegate {
 
   override func draw(in ctx: CGContext) {
     guard let inputMatte = inputMatte else { return }
-    guard let fillColor = CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [0, 0, 0, 1])
-    else { return }
-    ctx.setFillColor(fillColor)
+    ctx.setFillColor(.rgb(0, 0, 0))
     ctx.fill(bounds)
     ctx.setBlendMode(.destinationOut)
     inputMatte.render(in: ctx)

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

@@ -68,6 +68,13 @@ extension Array where Element == ShapeItem {
         let node = TrimPathNode(parentNode: nodeTree.rootNode, trim: trim, upstreamPaths: nodeTree.paths)
         nodeTree.rootNode = node
         nodeTree.childrenNodes.append(node)
+      } else if let roundedCorners = item as? RoundedCorners {
+        let node = RoundedCornersNode(
+          parentNode: nodeTree.rootNode,
+          roundedCorners: roundedCorners,
+          upstreamPaths: nodeTree.paths)
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
       } else if let xform = item as? ShapeTransform {
         nodeTree.transform = xform
         continue

package/Sources/Private/MainThread/NodeRenderSystem/NodeProperties/ValueProviders/GroupInterpolator.swift

@@ -15,7 +15,7 @@ final class GroupInterpolator<ValueType>: ValueProvider where ValueType: Interpo
 
   /// Initialize with an array of array of keyframes.
   init(keyframeGroups: ContiguousArray<ContiguousArray<Keyframe<ValueType>>>) {
-    keyframeInterpolators = ContiguousArray(keyframeGroups.map({ KeyframeInterpolator(keyframes: $0) }))
+    keyframeInterpolators = ContiguousArray(keyframeGroups.map { KeyframeInterpolator(keyframes: $0) })
   }
 
   // MARK: Internal
@@ -28,7 +28,7 @@ final class GroupInterpolator<ValueType>: ValueProvider where ValueType: Interpo
 
   var storage: ValueProviderStorage<[ValueType]> {
     .closure { frame in
-      self.keyframeInterpolators.map({ $0.value(frame: frame) as! ValueType })
+      self.keyframeInterpolators.map { $0.value(frame: frame) as! ValueType }
     }
   }
 

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

@@ -0,0 +1,85 @@
+//
+//  RoundedCornersNode.swift
+//  Lottie
+//
+//  Created by Duolingo on 10/31/22.
+//
+
+import Foundation
+import QuartzCore
+
+// MARK: - RoundedCornersProperties
+
+final class RoundedCornersProperties: NodePropertyMap, KeypathSearchable {
+
+  // MARK: Lifecycle
+
+  init(roundedCorners: RoundedCorners) {
+    keypathName = roundedCorners.name
+    radius = NodeProperty(provider: KeyframeInterpolator(keyframes: roundedCorners.radius.keyframes))
+    keypathProperties = ["Radius" : radius]
+    properties = Array(keypathProperties.values)
+  }
+
+  // MARK: Internal
+
+  let keypathProperties: [String: AnyNodeProperty]
+  let properties: [AnyNodeProperty]
+  let keypathName: String
+
+  let radius: NodeProperty<LottieVector1D>
+}
+
+// MARK: - RoundedCornersNode
+
+final class RoundedCornersNode: AnimatorNode {
+
+  // MARK: Lifecycle
+
+  init(parentNode: AnimatorNode?, roundedCorners: RoundedCorners, upstreamPaths: [PathOutputNode]) {
+    outputNode = PassThroughOutputNode(parent: parentNode?.outputNode)
+    self.parentNode = parentNode
+    properties = RoundedCornersProperties(roundedCorners: roundedCorners)
+    self.upstreamPaths = upstreamPaths
+  }
+
+  // MARK: Internal
+
+  let properties: RoundedCornersProperties
+
+  let parentNode: AnimatorNode?
+  let outputNode: NodeOutput
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+  var isEnabled = true
+
+  // MARK: Animator Node
+  var propertyMap: NodePropertyMap & KeypathSearchable {
+    properties
+  }
+
+  func forceUpstreamOutputUpdates() -> Bool {
+    hasLocalUpdates || hasUpstreamUpdates
+  }
+
+  func rebuildOutputs(frame: CGFloat) {
+    for pathContainer in upstreamPaths {
+      let pathObjects = pathContainer.removePaths(updateFrame: frame)
+      for path in pathObjects {
+        let cornerRadius = properties.radius.value.cgFloatValue
+        if cornerRadius != 0 {
+          pathContainer.appendPath(
+            path.roundCorners(radius: cornerRadius),
+            updateFrame: frame)
+        } else {
+          pathContainer.appendPath(path, updateFrame: frame)
+        }
+      }
+    }
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate let upstreamPaths: [PathOutputNode]
+}

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
 }
 
@@ -133,7 +133,7 @@ final class TrimPathNode: AnimatorNode {
 
     /// First get the total length of all paths.
     var totalLength: CGFloat = 0
-    upstreamPaths.forEach({ totalLength = totalLength + $0.totalLength })
+    upstreamPaths.forEach { totalLength = totalLength + $0.totalLength }
 
     /// Now determine the start and end cut lengths
     let startLength = startPosition * totalLength

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientFillRenderer.swift

@@ -48,15 +48,11 @@ private final class GradientFillLayer: CALayer {
 
     var gradientColors = [CGColor]()
     var colorLocations = [CGFloat]()
-    let colorSpace = CGColorSpaceCreateDeviceRGB()
     let maskColorSpace = CGColorSpaceCreateDeviceGray()
     for i in 0..<numberOfColors {
       let ix = i * 4
-      if
-        colors.count > ix, let color = CGColor(
-          colorSpace: colorSpace,
-          components: [colors[ix + 1], colors[ix + 2], colors[ix + 3], 1])
-      {
+      if colors.count > ix {
+        let color = CGColor.rgb(colors[ix + 1], colors[ix + 2], colors[ix + 3])
         gradientColors.append(color)
         colorLocations.append(colors[ix])
       }
@@ -68,10 +64,8 @@ private final class GradientFillLayer: CALayer {
       if alpha < 1 {
         drawMask = true
       }
-      if let color = CGColor(colorSpace: maskColorSpace, components: [alpha, 1]) {
-        alphaLocations.append(colors[i])
-        alphaColors.append(color)
-      }
+      alphaLocations.append(colors[i])
+      alphaColors.append(.gray(alpha))
     }
 
     /// First draw a mask is necessary.
@@ -114,8 +108,13 @@ private final class GradientFillLayer: CALayer {
     }
 
     /// Now draw the gradient
-    guard let gradient = CGGradient(colorsSpace: colorSpace, colors: gradientColors as CFArray, locations: colorLocations)
+    guard
+      let gradient = CGGradient(
+        colorsSpace: CGColorSpaceCreateDeviceRGB(),
+        colors: gradientColors as CFArray,
+        locations: colorLocations)
     else { return }
+
     if type == .linear {
       ctx.drawLinearGradient(gradient, start: start, end: end, options: [.drawsAfterEndLocation, .drawsBeforeStartLocation])
     } else {
@@ -141,7 +140,7 @@ final class GradientFillRenderer: PassThroughOutputNode, Renderable {
   override init(parent: NodeOutput?) {
     super.init(parent: parent)
 
-    maskLayer.fillColor = CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [1, 1, 1, 1])
+    maskLayer.fillColor = .rgb(1, 1, 1)
     gradientLayer.mask = maskLayer
 
     maskLayer.actions = [

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientStrokeRenderer.swift

@@ -17,7 +17,7 @@ final class GradientStrokeRenderer: PassThroughOutputNode, Renderable {
   override init(parent: NodeOutput?) {
     strokeRender = StrokeRenderer(parent: nil)
     gradientRender = LegacyGradientFillRenderer(parent: nil)
-    strokeRender.color = CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [1, 1, 1, 1])
+    strokeRender.color = .rgb(1, 1, 1)
     super.init(parent: parent)
   }
 

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/LegacyGradientFillRenderer.swift

@@ -67,15 +67,11 @@ final class LegacyGradientFillRenderer: PassThroughOutputNode, Renderable {
 
     var gradientColors = [CGColor]()
     var colorLocations = [CGFloat]()
-    let colorSpace = CGColorSpaceCreateDeviceRGB()
     let maskColorSpace = CGColorSpaceCreateDeviceGray()
     for i in 0..<numberOfColors {
       let ix = i * 4
-      if
-        colors.count > ix, let color = CGColor(
-          colorSpace: colorSpace,
-          components: [colors[ix + 1], colors[ix + 2], colors[ix + 3], 1])
-      {
+      if colors.count > ix {
+        let color = CGColor.rgb(colors[ix + 1], colors[ix + 2], colors[ix + 3])
         gradientColors.append(color)
         colorLocations.append(colors[ix])
       }
@@ -87,10 +83,8 @@ final class LegacyGradientFillRenderer: PassThroughOutputNode, Renderable {
       if alpha < 1 {
         drawMask = true
       }
-      if let color = CGColor(colorSpace: maskColorSpace, components: [alpha, 1]) {
-        alphaLocations.append(colors[i])
-        alphaColors.append(color)
-      }
+      alphaLocations.append(colors[i])
+      alphaColors.append(.gray(alpha))
     }
 
     inContext.setAlpha(opacity)
@@ -136,8 +130,13 @@ final class LegacyGradientFillRenderer: PassThroughOutputNode, Renderable {
     }
 
     /// Now draw the gradient
-    guard let gradient = CGGradient(colorsSpace: colorSpace, colors: gradientColors as CFArray, locations: colorLocations)
+    guard
+      let gradient = CGGradient(
+        colorsSpace: CGColorSpaceCreateDeviceRGB(),
+        colors: gradientColors as CFArray,
+        locations: colorLocations)
     else { return }
+
     if type == .linear {
       inContext.drawLinearGradient(gradient, start: start, end: end, options: [.drawsAfterEndLocation, .drawsBeforeStartLocation])
     } else {

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/StrokeRenderer.swift

@@ -160,7 +160,7 @@ final class StrokeRenderer: PassThroughOutputNode, Renderable {
     layer.lineDashPhase = dashPhase ?? 0
     layer.fillColor = nil
     if let dashPattern = dashLengths {
-      layer.lineDashPattern = dashPattern.map({ NSNumber(value: Double($0)) })
+      layer.lineDashPattern = dashPattern.map { NSNumber(value: Double($0)) }
     }
   }
 }

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]