@octane-xplat/lottie 0.9.0 → 0.11.0

package/platforms/macos/src/vendor/Lottie/Private/Model/Text/TextAnimator.swift

@@ -0,0 +1,240 @@
+//
+//  TextAnimator.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+// MARK: - TextRangeUnit
+
+enum TextRangeUnit: Int, RawRepresentable, Codable {
+  case percentage = 1
+  case index = 2
+}
+
+// MARK: - TextAnimator
+
+final class TextAnimator: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: TextAnimator.CodingKeys.self)
+    name = try container.decodeIfPresent(String.self, forKey: .name) ?? ""
+
+    let animatorContainer = try container.nestedContainer(keyedBy: TextAnimatorKeys.self, forKey: .textAnimator)
+    fillColor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieColor>.self, forKey: .fillColor)
+    strokeColor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieColor>.self, forKey: .strokeColor)
+    strokeWidth = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .strokeWidth)
+    tracking = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .tracking)
+    anchor = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .anchor)
+    position = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .position)
+    scale = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector3D>.self, forKey: .scale)
+    skew = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skew)
+    skewAxis = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .skewAxis)
+    rotationX = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationX)
+    rotationY = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationY)
+    if let rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotation) {
+      rotationZ = rotation
+    } else if let rotation = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .rotationZ) {
+      rotationZ = rotation
+    } else {
+      rotationZ = nil
+    }
+    opacity = try animatorContainer.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
+
+    let selectorContainer = try? container.nestedContainer(keyedBy: TextSelectorKeys.self, forKey: .textSelector)
+    start = try? selectorContainer?.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .start)
+    end = try? selectorContainer?.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .end)
+    textRangeUnit = try? selectorContainer?.decodeIfPresent(TextRangeUnit.self, forKey: .textRangeUnits)
+  }
+
+  init(dictionary: [String: Any]) throws {
+    name = (try? dictionary.value(for: CodingKeys.name)) ?? ""
+
+    let animatorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.textAnimator)
+    if let fillColorDictionary = animatorDictionary[TextAnimatorKeys.fillColor.rawValue] as? [String: Any] {
+      fillColor = try? KeyframeGroup<LottieColor>(dictionary: fillColorDictionary)
+    } else {
+      fillColor = nil
+    }
+    if let strokeColorDictionary = animatorDictionary[TextAnimatorKeys.strokeColor.rawValue] as? [String: Any] {
+      strokeColor = try? KeyframeGroup<LottieColor>(dictionary: strokeColorDictionary)
+    } else {
+      strokeColor = nil
+    }
+    if let strokeWidthDictionary = animatorDictionary[TextAnimatorKeys.strokeWidth.rawValue] as? [String: Any] {
+      strokeWidth = try? KeyframeGroup<LottieVector1D>(dictionary: strokeWidthDictionary)
+    } else {
+      strokeWidth = nil
+    }
+    if let trackingDictionary = animatorDictionary[TextAnimatorKeys.tracking.rawValue] as? [String: Any] {
+      tracking = try? KeyframeGroup<LottieVector1D>(dictionary: trackingDictionary)
+    } else {
+      tracking = nil
+    }
+    if let anchorDictionary = animatorDictionary[TextAnimatorKeys.anchor.rawValue] as? [String: Any] {
+      anchor = try? KeyframeGroup<LottieVector3D>(dictionary: anchorDictionary)
+    } else {
+      anchor = nil
+    }
+    if let positionDictionary = animatorDictionary[TextAnimatorKeys.position.rawValue] as? [String: Any] {
+      position = try? KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
+    } else {
+      position = nil
+    }
+    if let scaleDictionary = animatorDictionary[TextAnimatorKeys.scale.rawValue] as? [String: Any] {
+      scale = try? KeyframeGroup<LottieVector3D>(dictionary: scaleDictionary)
+    } else {
+      scale = nil
+    }
+    if let skewDictionary = animatorDictionary[TextAnimatorKeys.skew.rawValue] as? [String: Any] {
+      skew = try? KeyframeGroup<LottieVector1D>(dictionary: skewDictionary)
+    } else {
+      skew = nil
+    }
+    if let skewAxisDictionary = animatorDictionary[TextAnimatorKeys.skewAxis.rawValue] as? [String: Any] {
+      skewAxis = try? KeyframeGroup<LottieVector1D>(dictionary: skewAxisDictionary)
+    } else {
+      skewAxis = nil
+    }
+    if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotationX.rawValue] as? [String: Any] {
+      rotationX = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else {
+      rotationX = nil
+    }
+
+    if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotationY.rawValue] as? [String: Any] {
+      rotationY = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else {
+      rotationY = nil
+    }
+
+    if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotation.rawValue] as? [String: Any] {
+      rotationZ = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else if let rotationDictionary = animatorDictionary[TextAnimatorKeys.rotationZ.rawValue] as? [String: Any] {
+      rotationZ = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    } else {
+      rotationZ = nil
+    }
+
+    if let opacityDictionary = animatorDictionary[TextAnimatorKeys.opacity.rawValue] as? [String: Any] {
+      opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
+    } else {
+      opacity = nil
+    }
+
+    let selectorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.textSelector)
+
+    if let startDictionary = selectorDictionary[TextSelectorKeys.start.rawValue] as? [String: Any] {
+      start = try KeyframeGroup<LottieVector1D>(dictionary: startDictionary)
+    } else {
+      start = nil
+    }
+
+    if let endDictionary = selectorDictionary[TextSelectorKeys.end.rawValue] as? [String: Any] {
+      end = try KeyframeGroup<LottieVector1D>(dictionary: endDictionary)
+    } else {
+      end = nil
+    }
+
+    if let textRangeUnitValue = selectorDictionary[TextSelectorKeys.textRangeUnits.rawValue] as? Int {
+      textRangeUnit = TextRangeUnit(rawValue: textRangeUnitValue)
+    } else {
+      textRangeUnit = nil
+    }
+  }
+
+  // MARK: Internal
+
+  let name: String
+
+  /// Anchor
+  let anchor: KeyframeGroup<LottieVector3D>?
+
+  /// Position
+  let position: KeyframeGroup<LottieVector3D>?
+
+  /// Scale
+  let scale: KeyframeGroup<LottieVector3D>?
+
+  /// Skew
+  let skew: KeyframeGroup<LottieVector1D>?
+
+  /// Skew Axis
+  let skewAxis: KeyframeGroup<LottieVector1D>?
+
+  /// Rotation on X axis
+  let rotationX: KeyframeGroup<LottieVector1D>?
+
+  /// Rotation on Y axis
+  let rotationY: KeyframeGroup<LottieVector1D>?
+
+  /// Rotation on Z axis
+  let rotationZ: KeyframeGroup<LottieVector1D>?
+
+  /// Opacity
+  let opacity: KeyframeGroup<LottieVector1D>?
+
+  /// Stroke Color
+  let strokeColor: KeyframeGroup<LottieColor>?
+
+  /// Fill Color
+  let fillColor: KeyframeGroup<LottieColor>?
+
+  /// Stroke Width
+  let strokeWidth: KeyframeGroup<LottieVector1D>?
+
+  /// Tracking
+  let tracking: KeyframeGroup<LottieVector1D>?
+
+  /// Start
+  let start: KeyframeGroup<LottieVector1D>?
+
+  /// End
+  let end: KeyframeGroup<LottieVector1D>?
+
+  /// The type of unit used by the start/end ranges
+  let textRangeUnit: TextRangeUnit?
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    var animatorContainer = container.nestedContainer(keyedBy: TextAnimatorKeys.self, forKey: .textAnimator)
+    try animatorContainer.encodeIfPresent(fillColor, forKey: .fillColor)
+    try animatorContainer.encodeIfPresent(strokeColor, forKey: .strokeColor)
+    try animatorContainer.encodeIfPresent(strokeWidth, forKey: .strokeWidth)
+    try animatorContainer.encodeIfPresent(tracking, forKey: .tracking)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case textSelector = "s"
+    case textAnimator = "a"
+    case name = "nm"
+  }
+
+  private enum TextSelectorKeys: String, CodingKey {
+    case start = "s"
+    case end = "e"
+    case offset = "o"
+    case textRangeUnits = "r"
+  }
+
+  private enum TextAnimatorKeys: String, CodingKey {
+    case fillColor = "fc"
+    case strokeColor = "sc"
+    case strokeWidth = "sw"
+    case tracking = "t"
+    case anchor = "a"
+    case position = "p"
+    case scale = "s"
+    case skew = "sk"
+    case skewAxis = "sa"
+    case rotation = "r"
+    case rotationX = "rx"
+    case rotationY = "ry"
+    case rotationZ = "rz"
+    case opacity = "o"
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/Text/TextDocument.swift

@@ -0,0 +1,142 @@
+//
+//  TextDocument.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+// MARK: - TextJustification
+
+enum TextJustification: Int, Codable {
+  case left
+  case right
+  case center
+  case justifyLastLineLeft
+  case justifyLastLineRight
+  case justifyLastLineCenter
+  case justifyLastLineFull
+}
+
+// MARK: - TextDocument
+
+final class TextDocument: Codable, DictionaryInitializable, AnyInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    text = try container.decode(String.self, forKey: .text)
+    fontSize = try container.decode(Double.self, forKey: .fontSize)
+    fontFamily = try container.decode(String.self, forKey: .fontFamily)
+    justification = try container.decode(TextJustification.self, forKey: .justification)
+    tracking = try container.decode(Int.self, forKey: .tracking)
+    lineHeight = try container.decodeIfPresent(Double.self, forKey: .lineHeight) ?? 0
+    baseline = try container.decodeIfPresent(Double.self, forKey: .baseline)
+    fillColorData = try container.decodeIfPresent(LottieColor.self, forKey: .fillColorData)
+    strokeColorData = try container.decodeIfPresent(LottieColor.self, forKey: .strokeColorData)
+    strokeWidth = try container.decodeIfPresent(Double.self, forKey: .strokeWidth)
+    strokeOverFill = try container.decodeIfPresent(Bool.self, forKey: .strokeOverFill)
+    textFramePosition = try container.decodeIfPresent(LottieVector3D.self, forKey: .textFramePosition)
+    textFrameSize = try container.decodeIfPresent(LottieVector3D.self, forKey: .textFrameSize)
+  }
+
+  init(dictionary: [String: Any]) throws {
+    text = try dictionary.value(for: CodingKeys.text)
+    fontSize = try dictionary.value(for: CodingKeys.fontSize)
+    fontFamily = try dictionary.value(for: CodingKeys.fontFamily)
+    let justificationValue: Int = try dictionary.value(for: CodingKeys.justification)
+    guard let justification = TextJustification(rawValue: justificationValue) else {
+      throw InitializableError.invalidInput()
+    }
+    self.justification = justification
+    tracking = try dictionary.value(for: CodingKeys.tracking)
+    lineHeight = (try? dictionary.value(for: CodingKeys.lineHeight)) ?? 0
+    baseline = try dictionary.value(for: CodingKeys.baseline)
+    if let fillColorRawValue = dictionary[CodingKeys.fillColorData.rawValue] {
+      fillColorData = try? LottieColor(value: fillColorRawValue)
+    } else {
+      fillColorData = nil
+    }
+    if let strokeColorRawValue = dictionary[CodingKeys.strokeColorData.rawValue] {
+      strokeColorData = try? LottieColor(value: strokeColorRawValue)
+    } else {
+      strokeColorData = nil
+    }
+    strokeWidth = try? dictionary.value(for: CodingKeys.strokeWidth)
+    strokeOverFill = try? dictionary.value(for: CodingKeys.strokeOverFill)
+    if let textFramePositionRawValue = dictionary[CodingKeys.textFramePosition.rawValue] {
+      textFramePosition = try? LottieVector3D(value: textFramePositionRawValue)
+    } else {
+      textFramePosition = nil
+    }
+    if let textFrameSizeRawValue = dictionary[CodingKeys.textFrameSize.rawValue] {
+      textFrameSize = try? LottieVector3D(value: textFrameSizeRawValue)
+    } else {
+      textFrameSize = nil
+    }
+  }
+
+  convenience init(value: Any) throws {
+    guard let dictionary = value as? [String: Any] else {
+      throw InitializableError.invalidInput()
+    }
+    try self.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The Text
+  let text: String
+
+  /// The Font size
+  let fontSize: Double
+
+  /// The Font Family
+  let fontFamily: String
+
+  /// Justification
+  let justification: TextJustification
+
+  /// Tracking
+  let tracking: Int
+
+  /// Line Height
+  let lineHeight: Double
+
+  /// Baseline
+  let baseline: Double?
+
+  /// Fill Color data
+  let fillColorData: LottieColor?
+
+  /// Scroke Color data
+  let strokeColorData: LottieColor?
+
+  /// Stroke Width
+  let strokeWidth: Double?
+
+  /// Stroke Over Fill
+  let strokeOverFill: Bool?
+
+  let textFramePosition: LottieVector3D?
+
+  let textFrameSize: LottieVector3D?
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case text = "t"
+    case fontSize = "s"
+    case fontFamily = "f"
+    case justification = "j"
+    case tracking = "tr"
+    case lineHeight = "lh"
+    case baseline = "ls"
+    case fillColorData = "fc"
+    case strokeColorData = "sc"
+    case strokeWidth = "sw"
+    case strokeOverFill = "of"
+    case textFramePosition = "ps"
+    case textFrameSize = "sz"
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/RootAnimationLayer.swift

@@ -0,0 +1,54 @@
+// Created by Cal Stephens on 12/13/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - RootAnimationLayer
+
+/// A root `CALayer` responsible for playing a Lottie animation
+protocol RootAnimationLayer: CALayer {
+  var lottieAnimationLayer: LottieAnimationLayer? { get set }
+
+  var currentFrame: AnimationFrameTime { get set }
+  var renderScale: CGFloat { get set }
+  var respectAnimationFrameRate: Bool { get set }
+
+  var _animationLayers: [CALayer] { get }
+  var imageProvider: AnimationImageProvider { get set }
+  var textProvider: AnimationKeypathTextProvider { get set }
+  var fontProvider: AnimationFontProvider { get set }
+
+  /// The `CAAnimation` key corresponding to the primary animation.
+  ///  - `LottieAnimationView` uses this key to check if the animation is still active
+  var primaryAnimationKey: AnimationKey { get }
+
+  /// Whether or not this layer is currently playing an animation
+  ///  - If the layer returns `nil`, `LottieAnimationView` determines if an animation
+  ///    is playing by checking if there is an active animation for `primaryAnimationKey`
+  var isAnimationPlaying: Bool? { get }
+
+  /// Instructs this layer to remove all `CAAnimation`s,
+  /// other than the `CAAnimation` managed by `LottieAnimationView` (if applicable)
+  func removeAnimations()
+
+  func reloadImages()
+  func forceDisplayUpdate()
+  func logHierarchyKeypaths()
+  func allHierarchyKeypaths() -> [String]
+  func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath)
+  func removeValueProvider(for keypath: AnimationKeypath)
+  func getValue(for keypath: AnimationKeypath, atFrame: AnimationFrameTime?) -> Any?
+  func getOriginalValue(for keypath: AnimationKeypath, atFrame: AnimationFrameTime?) -> Any?
+
+  func layer(for keypath: AnimationKeypath) -> CALayer?
+  func animatorNodes(for keypath: AnimationKeypath) -> [AnimatorNode]?
+}
+
+// MARK: - AnimationKey
+
+enum AnimationKey {
+  /// The primary animation and its key should be managed by `LottieAnimationView`
+  case managed
+  /// The primary animation always uses the given key
+  case specific(String)
+}

package/platforms/macos/src/vendor/Lottie/Private/Utility/Debugging/AnimatorNodeDebugging.swift

@@ -0,0 +1,23 @@
+//
+//  AnimatorNodeDebugging.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/18/19.
+//
+
+extension AnimatorNode {
+
+  func printNodeTree() {
+    parentNode?.printNodeTree()
+    LottieLogger.shared.info(String(describing: type(of: self)))
+
+    if let group = self as? GroupNode {
+      LottieLogger.shared.info("* |Children")
+      group.rootNode?.printNodeTree()
+      LottieLogger.shared.info("*")
+    } else {
+      LottieLogger.shared.info("|")
+    }
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/Utility/Debugging/LayerDebugging.swift

@@ -0,0 +1,231 @@
+//
+//  LayerDebugging.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/24/19.
+//
+
+#if DEBUG
+
+import QuartzCore
+
+// MARK: - LayerDebugStyle
+
+struct LayerDebugStyle {
+  let anchorColor: CGColor
+  let boundsColor: CGColor
+  let anchorWidth: CGFloat
+  let boundsWidth: CGFloat
+}
+
+// MARK: - LayerDebugging
+
+protocol LayerDebugging {
+  var debugStyle: LayerDebugStyle { get }
+}
+
+// MARK: - CustomLayerDebugging
+
+protocol CustomLayerDebugging {
+  func layerForDebugging() -> CALayer
+}
+
+// MARK: - DebugLayer
+
+final class DebugLayer: CALayer {
+  init(style: LayerDebugStyle) {
+    super.init()
+    zPosition = 1000
+    bounds = CGRect(x: 0, y: 0, width: style.anchorWidth, height: style.anchorWidth)
+    backgroundColor = style.anchorColor
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+}
+
+extension CALayer {
+
+  @nonobjc
+  public func logLayerTree(withIndent: Int = 0) {
+    var string = ""
+    for _ in 0...withIndent {
+      string = string + "  "
+    }
+    string = string + "|_" + String(describing: self)
+    LottieLogger.shared.info(string)
+    if let sublayers {
+      for sublayer in sublayers {
+        sublayer.logLayerTree(withIndent: withIndent + 1)
+      }
+    }
+  }
+
+}
+
+// MARK: - CompositionLayer + CustomLayerDebugging
+
+extension CompositionLayer: CustomLayerDebugging {
+  func layerForDebugging() -> CALayer {
+    contentsLayer
+  }
+}
+
+extension CALayer {
+
+  @nonobjc
+  func setDebuggingState(visible: Bool) {
+    var sublayers = sublayers
+    if let cust = self as? CustomLayerDebugging {
+      sublayers = cust.layerForDebugging().sublayers
+    }
+
+    if let sublayers {
+      for i in 0..<sublayers.count {
+        if let debugLayer = sublayers[i] as? DebugLayer {
+          debugLayer.removeFromSuperlayer()
+          break
+        }
+      }
+    }
+
+    if let sublayers {
+      for sublayer in sublayers {
+        sublayer.setDebuggingState(visible: visible)
+      }
+    }
+
+    if visible {
+      let style: LayerDebugStyle =
+        if let layerDebugging = self as? LayerDebugging {
+          layerDebugging.debugStyle
+        } else {
+          LayerDebugStyle.defaultStyle()
+        }
+      let debugLayer = DebugLayer(style: style)
+      var container = self
+      if let cust = self as? CustomLayerDebugging {
+        container = cust.layerForDebugging()
+      }
+      container.addSublayer(debugLayer)
+      debugLayer.position = .zero
+      borderWidth = style.boundsWidth
+      borderColor = style.boundsColor
+    } else {
+      borderWidth = 0
+      borderColor = nil
+    }
+  }
+}
+
+// MARK: - MainThreadAnimationLayer + LayerDebugging
+
+extension MainThreadAnimationLayer: LayerDebugging {
+  var debugStyle: LayerDebugStyle {
+    LayerDebugStyle.topLayerStyle()
+  }
+}
+
+// MARK: - NullCompositionLayer + LayerDebugging
+
+extension NullCompositionLayer: LayerDebugging {
+  var debugStyle: LayerDebugStyle {
+    LayerDebugStyle.nullLayerStyle()
+  }
+}
+
+// MARK: - ShapeCompositionLayer + LayerDebugging
+
+extension ShapeCompositionLayer: LayerDebugging {
+  var debugStyle: LayerDebugStyle {
+    LayerDebugStyle.shapeLayerStyle()
+  }
+}
+
+// MARK: - ShapeRenderLayer + LayerDebugging
+
+extension ShapeRenderLayer: LayerDebugging {
+  var debugStyle: LayerDebugStyle {
+    LayerDebugStyle.shapeRenderLayerStyle()
+  }
+}
+
+extension LayerDebugStyle {
+  static func defaultStyle() -> LayerDebugStyle {
+    let anchorColor = CGColor.rgb(1, 0, 0)
+    let boundsColor = CGColor.rgb(1, 1, 0)
+    return LayerDebugStyle(
+      anchorColor: anchorColor,
+      boundsColor: boundsColor,
+      anchorWidth: 10,
+      boundsWidth: 2
+    )
+  }
+
+  static func topLayerStyle() -> LayerDebugStyle {
+    let anchorColor = CGColor.rgba(1, 0.5, 0, 0)
+    let boundsColor = CGColor.rgb(0, 1, 0)
+
+    return LayerDebugStyle(
+      anchorColor: anchorColor,
+      boundsColor: boundsColor,
+      anchorWidth: 10,
+      boundsWidth: 2
+    )
+  }
+
+  static func nullLayerStyle() -> LayerDebugStyle {
+    let anchorColor = CGColor.rgba(0, 0, 1, 0)
+    let boundsColor = CGColor.rgb(0, 1, 0)
+
+    return LayerDebugStyle(
+      anchorColor: anchorColor,
+      boundsColor: boundsColor,
+      anchorWidth: 10,
+      boundsWidth: 2
+    )
+  }
+
+  static func shapeLayerStyle() -> LayerDebugStyle {
+    let anchorColor = CGColor.rgba(0, 1, 0, 0)
+    let boundsColor = CGColor.rgb(0, 1, 0)
+
+    return LayerDebugStyle(
+      anchorColor: anchorColor,
+      boundsColor: boundsColor,
+      anchorWidth: 10,
+      boundsWidth: 2
+    )
+  }
+
+  static func shapeRenderLayerStyle() -> LayerDebugStyle {
+    let anchorColor = CGColor.rgba(0, 1, 1, 0)
+    let boundsColor = CGColor.rgb(0, 1, 0)
+
+    return LayerDebugStyle(
+      anchorColor: anchorColor,
+      boundsColor: boundsColor,
+      anchorWidth: 10,
+      boundsWidth: 2
+    )
+  }
+}
+
+extension [LayerModel] {
+
+  var parents: [Int] {
+    var array = [Int]()
+    for layer in self {
+      if let parent = layer.parent {
+        array.append(parent)
+      } else {
+        array.append(-1)
+      }
+    }
+    return array
+  }
+
+}
+
+#endif

package/platforms/macos/src/vendor/Lottie/Private/Utility/Debugging/TestHelpers.swift

@@ -0,0 +1,10 @@
+// Created by Cal Stephens on 1/28/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+enum TestHelpers {
+  /// Whether or not snapshot tests are currently running in a test target
+  static var snapshotTestsAreRunning = false
+
+  /// Whether or not performance tests are currently running in a test target
+  static var performanceTestsAreRunning = false
+}