lottie-ios 3.4.0 → 3.4.3

package/Sources/Private/CoreAnimation/CoreAnimationLayer.swift

@@ -17,6 +17,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   init(
     animation: Animation,
     imageProvider: AnimationImageProvider,
+    textProvider: AnimationTextProvider,
     fontProvider: AnimationFontProvider,
     compatibilityTrackerMode: CompatibilityTracker.Mode,
     logger: LottieLogger)
@@ -24,6 +25,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   {
     self.animation = animation
     self.imageProvider = imageProvider
+    self.textProvider = textProvider
     self.fontProvider = fontProvider
     self.logger = logger
     compatibilityTracker = CompatibilityTracker(mode: compatibilityTrackerMode, logger: logger)
@@ -44,6 +46,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     animation = typedLayer.animation
     currentAnimationConfiguration = typedLayer.currentAnimationConfiguration
     imageProvider = typedLayer.imageProvider
+    textProvider = typedLayer.textProvider
     fontProvider = typedLayer.fontProvider
     didSetUpAnimation = typedLayer.didSetUpAnimation
     compatibilityTracker = typedLayer.compatibilityTracker
@@ -92,6 +95,16 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     didSet { reloadImages() }
   }
 
+  /// The `AnimationTextProvider` that `TextLayer`'s use to retrieve texts,
+  /// that they should use to render their text context
+  var textProvider: AnimationTextProvider {
+    didSet {
+      // We need to rebuild the current animation after updating the text provider,
+      // since this is used in `TextLayer.setupAnimations(context:)`
+      rebuildCurrentAnimation()
+    }
+  }
+
   /// The `FontProvider` that `TextLayer`s use to retrieve the `CTFont`
   /// that they should use to render their text content
   var fontProvider: AnimationFontProvider {
@@ -203,6 +216,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     LayerContext(
       animation: animation,
       imageProvider: imageProvider,
+      textProvider: textProvider,
       fontProvider: fontProvider,
       compatibilityTracker: compatibilityTracker,
       layerName: "root layer")
@@ -234,6 +248,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
       compatibilityTracker: compatibilityTracker,
       logger: logger,
       currentKeypath: AnimationKeypath(keys: []),
+      textProvider: textProvider,
       logHierarchyKeypaths: configuration.logHierarchyKeypaths)
 
     // Perform a layout pass if necessary so all of the sublayers
@@ -264,6 +279,11 @@ final class CoreAnimationLayer: BaseAnimationLayer {
 
     let timedProgressAnimation = animationProgressTracker.timed(with: context, for: self)
     timedProgressAnimation.delegate = currentAnimationConfiguration?.animationContext.closure
+
+    // Remove the progress animation once complete so we know when the animation
+    // has finished playing (if it doesn't loop infinitely)
+    timedProgressAnimation.isRemovedOnCompletion = true
+
     add(timedProgressAnimation, forKey: #keyPath(animationProgress))
   }
 
@@ -309,11 +329,18 @@ extension CoreAnimationLayer: RootAnimationLayer {
   }
 
   var isAnimationPlaying: Bool? {
-    switch playbackState {
+    switch pendingAnimationConfiguration?.playbackState {
     case .playing:
       return true
-    case nil, .paused:
+    case .paused:
       return false
+    case nil:
+      switch playbackState {
+      case .playing:
+        return animation(forKey: #keyPath(animationProgress)) != nil
+      case nil, .paused:
+        return false
+      }
     }
   }
 
@@ -378,15 +405,6 @@ extension CoreAnimationLayer: RootAnimationLayer {
     (sublayers ?? []).filter { $0 is AnimationLayer }
   }
 
-  var textProvider: AnimationTextProvider {
-    get { DictionaryTextProvider([:]) }
-    set {
-      logger.assertionFailure("""
-        The Core Animation rendering engine currently doesn't support `textProvider`s")
-        """)
-    }
-  }
-
   func reloadImages() {
     // When the image provider changes, we have to update all `ImageLayer`s
     // so they can query the most up-to-date image from the new image provider.

package/Sources/Private/CoreAnimation/Extensions/KeyframeGroup+exactlyOneKeyframe.swift

@@ -23,7 +23,7 @@ extension KeyframeGroup {
     fileID _: StaticString = #fileID,
     line _: UInt = #line)
     throws
-    -> Keyframe<T>
+    -> T
   {
     try context.compatibilityAssert(
       keyframes.count == 1,
@@ -32,6 +32,6 @@ extension KeyframeGroup {
       for \(description) values (due to limitations of Core Animation `CAKeyframeAnimation`s).
       """)
 
-    return keyframes[0]
+    return keyframes[0].value
   }
 }

package/Sources/Private/CoreAnimation/Extensions/Keyframes+combinedIfPossible.swift

@@ -4,34 +4,113 @@
 // MARK: - Keyframes
 
 enum Keyframes {
-  /// Combines the given `[KeyframeGroup]` of `Keyframe<T>`s
-  /// into a single `KeyframeGroup` of `Keyframe<[T]>`s
-  /// if all of the `KeyframeGroup`s have the exact same animation timing
-  static func combinedIfPossible<T>(_ groups: [KeyframeGroup<T>]) -> KeyframeGroup<[T]>? {
+
+  // MARK: Internal
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of
+  /// of `Keyframe<[T]>`s if all of the `KeyframeGroup`s have the exact same animation timing
+  static func combinedIfPossible<T>(_ allGroups: [KeyframeGroup<T>]) -> KeyframeGroup<[T]>? {
+    combinedIfPossible(allGroups, makeCombinedResult: { index in
+      allGroups.map { $0.valueForCombinedKeyframes(at: index) }
+    })
+  }
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of
+  /// of `Keyframe<[T]>`s if all of the `KeyframeGroup`s have the exact same animation timing
+  static func combinedIfPossible<T1, T2, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    makeCombinedResult: (T1, T2) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>?
+  {
+    combinedIfPossible(
+      [k1, k2],
+      makeCombinedResult: { index in
+        makeCombinedResult(
+          k1.valueForCombinedKeyframes(at: index),
+          k2.valueForCombinedKeyframes(at: index))
+      })
+  }
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of
+  /// of `Keyframe<[T]>`s if all of the `KeyframeGroup`s have the exact same animation timing
+  static func combinedIfPossible<T1, T2, T3, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    makeCombinedResult: (T1, T2, T3) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>?
+  {
+    combinedIfPossible(
+      [k1, k2, k3],
+      makeCombinedResult: { index in
+        makeCombinedResult(
+          k1.valueForCombinedKeyframes(at: index),
+          k2.valueForCombinedKeyframes(at: index),
+          k3.valueForCombinedKeyframes(at: index))
+      })
+  }
+
+  /// Combines the given keyframe groups of `Keyframe<T>`s into a single keyframe group of
+  /// of `Keyframe<[T]>`s if all of the `KeyframeGroup`s have the exact same animation timing
+  static func combinedIfPossible<T1, T2, T3, T4, T5, T6, T7, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    _ k4: KeyframeGroup<T4>,
+    _ k5: KeyframeGroup<T5>,
+    _ k6: KeyframeGroup<T6>,
+    _ k7: KeyframeGroup<T7>,
+    makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>?
+  {
+    combinedIfPossible(
+      [k1, k2, k3, k4, k5, k6, k7],
+      makeCombinedResult: { index in
+        makeCombinedResult(
+          k1.valueForCombinedKeyframes(at: index),
+          k2.valueForCombinedKeyframes(at: index),
+          k3.valueForCombinedKeyframes(at: index),
+          k4.valueForCombinedKeyframes(at: index),
+          k5.valueForCombinedKeyframes(at: index),
+          k6.valueForCombinedKeyframes(at: index),
+          k7.valueForCombinedKeyframes(at: index))
+      })
+  }
+
+  // MARK: Private
+
+  /// Combines the given `[KeyframeGroup]` of `Keyframe<T>`s into a single `KeyframeGroup`
+  /// of `Keyframe<CombinedResult>`s if all of the `KeyframeGroup`s have the exact same animation timing
+  private static func combinedIfPossible<CombinedResult>(
+    _ allGroups: [AnyKeyframeGroup],
+    makeCombinedResult: (_ index: Int) -> CombinedResult)
+    -> KeyframeGroup<CombinedResult>?
+  {
+    let untypedGroups = allGroups.map { $0.untyped }
+
+    // Animations with no timing information (e.g. with just a single keyframe)
+    // can be trivially combined with any other set of keyframes, so we don't need
+    // to check those.
+    let animatingKeyframes = untypedGroups.filter { $0.keyframes.count > 1 }
+
     guard
-      !groups.isEmpty,
-      groups.allSatisfy({ $0.hasSameTimingParameters(as: groups[0]) })
+      !allGroups.isEmpty,
+      animatingKeyframes.allSatisfy({ $0.hasSameTimingParameters(as: animatingKeyframes[0]) })
     else { return nil }
 
-    var combinedKeyframes = ContiguousArray<Keyframe<[T]>>()
+    var combinedKeyframes = ContiguousArray<Keyframe<CombinedResult>>()
+    let baseKeyframes = (animatingKeyframes.first ?? untypedGroups[0]).keyframes
 
-    for index in groups[0].keyframes.indices {
-      let baseKeyframe = groups[0].keyframes[index]
-      let combinedValues = groups.map { $0.keyframes[index].value }
-      combinedKeyframes.append(baseKeyframe.withValue(combinedValues))
+    for index in baseKeyframes.indices {
+      let baseKeyframe = baseKeyframes[index]
+      let combinedValue = makeCombinedResult(index)
+      combinedKeyframes.append(baseKeyframe.withValue(combinedValue))
     }
 
     return KeyframeGroup(keyframes: combinedKeyframes)
   }
 
-  /// Combines the given `[KeyframeGroup?]` of `Keyframe<T>`s
-  /// into a single `KeyframeGroup` of `Keyframe<[T]>`s
-  /// if all of the `KeyframeGroup`s have the exact same animation timing
-  static func combinedIfPossible<T>(_ groups: [KeyframeGroup<T>?]) -> KeyframeGroup<[T]>? {
-    let nonOptionalGroups = groups.compactMap { $0 }
-    guard nonOptionalGroups.count == groups.count else { return nil }
-    return combinedIfPossible(nonOptionalGroups)
-  }
 }
 
 extension KeyframeGroup {
@@ -49,13 +128,27 @@ extension KeyframeGroup {
 }
 
 extension Keyframe {
-  /// Whether or not this keyframe has the same timing parameters as the given keyframe
-  func hasSameTimingParameters<T>(as other: Keyframe<T>) -> Bool {
+  /// Whether or not this keyframe has the same timing parameters as the given keyframe,
+  /// excluding `spatialInTangent` and `spatialOutTangent`.
+  fileprivate func hasSameTimingParameters<T>(as other: Keyframe<T>) -> Bool {
     time == other.time
       && isHold == other.isHold
       && inTangent == other.inTangent
       && outTangent == other.outTangent
-      && spatialInTangent == other.spatialInTangent
-      && spatialOutTangent == other.spatialOutTangent
+    // We intentionally don't compare spatial in/out tangents,
+    // since those values are only used in very specific cases
+    // (animating the x/y position of a layer), which aren't ever
+    // combined in this way.
+  }
+}
+
+extension KeyframeGroup {
+  /// The value to use for a combined set of keyframes, for the given index
+  fileprivate func valueForCombinedKeyframes(at index: Int) -> T {
+    if keyframes.count == 1 {
+      return keyframes[0].value
+    } else {
+      return keyframes[index].value
+    }
   }
 }

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

@@ -41,6 +41,9 @@ struct LayerAnimationContext {
   /// The AnimationKeypath represented by the current layer
   var currentKeypath: AnimationKeypath
 
+  /// The `AnimationTextProvider`
+  var textProvider: AnimationTextProvider
+
   /// Whether or not to log `AnimationKeypath`s for all of the animation's layers
   ///  - Used for `CoreAnimationLayer.logHierarchyKeypaths()`
   var logHierarchyKeypaths: Bool
@@ -63,6 +66,12 @@ struct LayerAnimationContext {
     animation.progressTime(forFrame: timeRemapping(frame), clamped: false)
   }
 
+  /// The real-time `TimeInterval` for the given `AnimationFrameTime` within this layer,
+  /// accounting for the `timeRemapping` applied to this layer
+  func time(for frame: AnimationFrameTime) -> TimeInterval {
+    animation.time(forFrame: timeRemapping(frame))
+  }
+
   /// Chains an additional `timeRemapping` closure onto this layer context
   func withTimeRemapping(
     _ additionalTimeRemapping: @escaping (AnimationFrameTime) -> AnimationFrameTime)

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

@@ -78,7 +78,8 @@ class BaseCompositionLayer: BaseAnimationLayer {
   private func setupSublayers() {
     if
       renderLayerContents,
-      let masks = baseLayerModel.masks
+      let masks = baseLayerModel.masks?.filter({ $0.mode != .none }),
+      !masks.isEmpty
     {
       mask = MaskCompositionLayer(masks: masks)
     }

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

@@ -4,6 +4,9 @@
 import QuartzCore
 
 extension CALayer {
+
+  // MARK: Internal
+
   /// Sets up an `AnimationLayer` / `CALayer` hierarchy in this layer,
   /// using the given list of layers.
   @nonobjc
@@ -48,7 +51,7 @@ extension CALayer {
     }
 
     // Create an `AnimationLayer` for each `LayerModel`
-    for (layerModel, maskLayerModel) in try layersInZAxisOrder.pairedLayersAndMasks(context: context) {
+    for (layerModel, mask) in try layersInZAxisOrder.pairedLayersAndMasks(context: context) {
       guard let layer = try layerModel.makeAnimationLayer(context: context) else {
         continue
       }
@@ -64,14 +67,14 @@ extension CALayer {
 
       // Create the `mask` layer for this layer, if it has a `MatteType`
       if
-        let maskLayerModel = maskLayerModel,
-        let maskLayer = try maskLayerModel.makeAnimationLayer(context: context)
+        let mask = mask,
+        let maskLayer = try maskLayer(for: mask.model, type: mask.matteType, context: context)
       {
         let maskParentTransformLayer = makeParentTransformLayer(
-          childLayerModel: maskLayerModel,
+          childLayerModel: mask.model,
           childLayer: maskLayer,
           name: { parentLayerModel in
-            "\(maskLayerModel.name) (mask of \(layerModel.name)) (parent, \(parentLayerModel.name))"
+            "\(mask.model.name) (mask of \(layerModel.name)) (parent, \(parentLayerModel.name))"
           })
 
         // Set up a parent container to host both the layer
@@ -96,6 +99,41 @@ extension CALayer {
     }
   }
 
+  // MARK: Fileprivate
+
+  /// Creates a mask `CALayer` from the given matte layer model, using the `MatteType`
+  /// from the layer that is being masked.
+  fileprivate func maskLayer(
+    for matteLayerModel: LayerModel,
+    type: MatteType,
+    context: LayerContext) throws
+    -> CALayer?
+  {
+    switch type {
+    case .add:
+      return try matteLayerModel.makeAnimationLayer(context: context)
+
+    case .invert:
+      guard let maskLayer = try matteLayerModel.makeAnimationLayer(context: context) else {
+        return nil
+      }
+
+      // We can invert the mask layer by having a large solid black layer with the
+      // given mask layer subtracted out using the `xor` blend mode. When applied to the
+      // layer being masked, this creates an inverted mask where only areas _outside_
+      // of the mask layer are visible.
+      // https://developer.apple.com/documentation/coregraphics/cgblendmode/xor
+      let base = BaseAnimationLayer()
+      base.backgroundColor = .rgb(0, 0, 0)
+      base.addSublayer(maskLayer)
+      maskLayer.compositingFilter = "xor"
+      return base
+
+    case .none, .unknown:
+      return nil
+    }
+  }
+
 }
 
 extension Collection where Element == LayerModel {
@@ -103,8 +141,10 @@ extension Collection where Element == LayerModel {
   /// a `LayerModel` to use as its mask, if applicable
   /// based on the layer's `MatteType` configuration.
   ///  - Assumes the layers are sorted in z-axis order.
-  fileprivate func pairedLayersAndMasks(context: LayerContext) throws -> [(layer: LayerModel, mask: LayerModel?)] {
-    var layersAndMasks = [(layer: LayerModel, mask: LayerModel?)]()
+  fileprivate func pairedLayersAndMasks(context _: LayerContext) throws
+    -> [(layer: LayerModel, mask: (model: LayerModel, matteType: MatteType)?)]
+  {
+    var layersAndMasks = [(layer: LayerModel, mask: (model: LayerModel, matteType: MatteType)?)]()
     var unprocessedLayers = reversed()
 
     while let layer = unprocessedLayers.popLast() {
@@ -114,11 +154,7 @@ extension Collection where Element == LayerModel {
         matteType != .none,
         let maskLayer = unprocessedLayers.popLast()
       {
-        try context.compatibilityAssert(
-          matteType == .add,
-          "The Core Animation rendering engine currently only supports `MatteMode.add`.")
-
-        layersAndMasks.append((layer: layer, mask: maskLayer))
+        layersAndMasks.append((layer: layer, mask: (model: maskLayer, matteType: matteType)))
       }
 
       else {

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

@@ -59,7 +59,7 @@ final class GradientRenderLayer: CAGradientLayer {
   ///  - This specific value is arbitrary and can be increased if necessary.
   ///    Theoretically this should be "infinite", to match the behavior of
   ///    `CGContext.drawLinearGradient` with `[.drawsAfterEndLocation, .drawsBeforeStartLocation]`.
-  private let gradientPadding: CGFloat = 2_000
+  private let gradientPadding: CGFloat = 10_000
 
   private func updateLayout() {
     anchorPoint = .zero
@@ -70,9 +70,12 @@ final class GradientRenderLayer: CAGradientLayer {
       width: gradientPadding + gradientReferenceBounds.width + gradientPadding,
       height: gradientPadding + gradientReferenceBounds.height + gradientPadding)
 
+    // Align the center of this layer to be at the center point of its parent layer
+    let superlayerSize = superlayer?.frame.size ?? gradientReferenceBounds.size
+
     transform = CATransform3DMakeTranslation(
-      -gradientPadding,
-      -gradientPadding,
+      (superlayerSize.width - bounds.width) / 2,
+      (superlayerSize.height - bounds.height) / 2,
       0)
   }
 
@@ -83,5 +86,9 @@ final class GradientRenderLayer: CAGradientLayer {
 extension GradientRenderLayer: CustomLayoutLayer {
   func layout(superlayerBounds: CGRect) {
     gradientReferenceBounds = superlayerBounds
+
+    if let gradientMask = mask as? GradientRenderLayer {
+      gradientMask.layout(superlayerBounds: superlayerBounds)
+    }
   }
 }

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

@@ -9,6 +9,7 @@ import QuartzCore
 struct LayerContext {
   let animation: Animation
   let imageProvider: AnimationImageProvider
+  let textProvider: AnimationTextProvider
   let fontProvider: AnimationFontProvider
   let compatibilityTracker: CompatibilityTracker
   var layerName: String
@@ -27,6 +28,10 @@ extension LayerModel {
   func makeAnimationLayer(context: LayerContext) throws -> BaseCompositionLayer? {
     let context = context.forLayer(self)
 
+    if hidden {
+      return TransformLayer(layerModel: self)
+    }
+
     switch (type, self) {
     case (.precomp, let preCompLayerModel as PreCompLayerModel):
       let preCompLayer = PreCompLayer(preCompLayer: preCompLayerModel)

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

@@ -74,7 +74,7 @@ extension MaskCompositionLayer: AnimationLayer {
   }
 }
 
-// MARK: - MaskLayer
+// MARK: MaskCompositionLayer.MaskLayer
 
 extension MaskCompositionLayer {
   final class MaskLayer: CAShapeLayer {

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

@@ -68,12 +68,12 @@ final class PreCompLayer: BaseCompositionLayer {
     try setupLayerAnimations(context: context)
 
     // Precomp layers can adjust the local time of their child layers (relative to the
-    // animation's global time) via `timeRemapping` or a custom `startTime`
+    // animation's global time) via `timeRemapping` or a custom `startTime` / `timeStretch`
     let contextForChildren = context.withTimeRemapping { [preCompLayer, timeRemappingInterpolator] layerLocalFrame in
       if let timeRemappingInterpolator = timeRemappingInterpolator {
         return timeRemappingInterpolator.value(frame: layerLocalFrame) as? AnimationFrameTime ?? layerLocalFrame
       } else {
-        return layerLocalFrame + AnimationFrameTime(preCompLayer.startTime)
+        return (layerLocalFrame * AnimationFrameTime(preCompLayer.timeStretch)) + AnimationFrameTime(preCompLayer.startTime)
       }
     }
 

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

@@ -0,0 +1,85 @@
+// Created by Cal Stephens on 8/1/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - RepeaterLayer
+
+/// A layer that renders a child layer at some offset using a `Repeater`
+final class RepeaterLayer: BaseAnimationLayer {
+
+  // MARK: Lifecycle
+
+  init(repeater: Repeater, childLayer: CALayer, index: Int) {
+    repeaterTransform = RepeaterTransform(repeater: repeater, index: index)
+    super.init()
+    addSublayer(childLayer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  /// Called by CoreAnimation to create a shadow copy of this layer
+  /// More details: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+  override init(layer: Any) {
+    guard let typedLayer = layer as? Self else {
+      fatalError("\(Self.self).init(layer:) incorrectly called with \(type(of: layer))")
+    }
+
+    repeaterTransform = typedLayer.repeaterTransform
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Internal
+
+  override func setupAnimations(context: LayerAnimationContext) throws {
+    try super.setupAnimations(context: context)
+    try addTransformAnimations(for: repeaterTransform, context: context)
+  }
+
+  // MARK: Private
+
+  private let repeaterTransform: RepeaterTransform
+
+}
+
+// MARK: - RepeaterTransform
+
+/// A transform model created from a `Repeater`
+private struct RepeaterTransform {
+
+  // MARK: Lifecycle
+
+  init(repeater: Repeater, index: Int) {
+    anchorPoint = repeater.anchorPoint
+    scale = repeater.scale
+
+    rotation = repeater.rotation.map { rotation in
+      Vector1D(rotation.value * Double(index))
+    }
+
+    position = repeater.position.map { position in
+      Vector3D(
+        x: position.x * Double(index),
+        y: position.y * Double(index),
+        z: position.z * Double(index))
+    }
+  }
+
+  // MARK: Internal
+
+  let anchorPoint: KeyframeGroup<Vector3D>
+  let position: KeyframeGroup<Vector3D>
+  let rotation: KeyframeGroup<Vector1D>
+  let scale: KeyframeGroup<Vector3D>
+
+}
+
+// MARK: TransformModel
+
+extension RepeaterTransform: TransformModel {
+  var _position: KeyframeGroup<Vector3D>? { position }
+  var _positionX: KeyframeGroup<Vector1D>? { nil }
+  var _positionY: KeyframeGroup<Vector1D>? { nil }
+}