@octane-xplat/lottie 0.9.0 → 0.11.0

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Extensions/KeyframeGroup+exactlyOneKeyframe.swift

@@ -0,0 +1,28 @@
+// Created by Cal Stephens on 1/11/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+// MARK: - KeyframeGroup + exactlyOneKeyframe
+
+extension KeyframeGroup {
+  /// Retrieves the first `Keyframe` from this group,
+  /// and asserts that there are not any extra keyframes that would be ignored
+  ///  - This should only be used in cases where it's fundamentally not possible to
+  ///    support animating a given property (e.g. if Core Animation itself doesn't
+  ///    support the property).
+  func exactlyOneKeyframe(
+    context: CompatibilityTrackerProviding,
+    description: String,
+    fileID _: StaticString = #fileID,
+    line _: UInt = #line
+  ) throws -> T {
+    try context.compatibilityAssert(
+      keyframes.count == 1,
+      """
+      The Core Animation rendering engine does not support animating multiple keyframes
+      for \(description) values, due to limitations of Core Animation.
+      """
+    )
+
+    return keyframes[0].value
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Extensions/Keyframes+combined.swift

@@ -0,0 +1,345 @@
+// Created by Cal Stephens on 1/28/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+// MARK: - Keyframes
+
+enum Keyframes {
+
+  // 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, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  static func combined<T: AnyInterpolatable>(
+    _ allGroups: [KeyframeGroup<T>],
+    requiresManualInterpolation: Bool = false
+  ) -> KeyframeGroup<[T]> {
+    Keyframes.combined(
+      allGroups,
+      requiresManualInterpolation: requiresManualInterpolation,
+      makeCombinedResult: { untypedValues in
+        untypedValues.compactMap { $0 as? T }
+      }
+    )
+  }
+
+  /// 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, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  static func combined<T1: AnyInterpolatable, T2: AnyInterpolatable, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    requiresManualInterpolation: Bool = false,
+    makeCombinedResult: (T1, T2) throws -> CombinedResult
+  ) rethrows -> KeyframeGroup<CombinedResult> {
+    try Keyframes.combined(
+      [k1, k2],
+      requiresManualInterpolation: requiresManualInterpolation,
+      makeCombinedResult: { untypedValues in
+        guard
+          let t1 = untypedValues[0] as? T1,
+          let t2 = untypedValues[1] as? T2
+        else { return nil }
+
+        return try makeCombinedResult(t1, t2)
+      }
+    )
+  }
+
+  /// 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, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  static func combined<T1: AnyInterpolatable, T2: AnyInterpolatable, T3: AnyInterpolatable, CombinedResult>(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    requiresManualInterpolation: Bool = false,
+    makeCombinedResult: (T1, T2, T3) -> CombinedResult
+  ) -> KeyframeGroup<CombinedResult> {
+    Keyframes.combined(
+      [k1, k2, k3],
+      requiresManualInterpolation: requiresManualInterpolation,
+      makeCombinedResult: { untypedValues in
+        guard
+          let t1 = untypedValues[0] as? T1,
+          let t2 = untypedValues[1] as? T2,
+          let t3 = untypedValues[2] as? T3
+        else { return nil }
+
+        return makeCombinedResult(t1, t2, t3)
+      }
+    )
+  }
+
+  /// 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, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  static func combined<
+    T1: AnyInterpolatable,
+    T2: AnyInterpolatable,
+    T3: AnyInterpolatable,
+    T4: AnyInterpolatable,
+    T5: AnyInterpolatable,
+    T6: AnyInterpolatable,
+    T7: AnyInterpolatable,
+    CombinedResult
+  >(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    _ k4: KeyframeGroup<T4>,
+    _ k5: KeyframeGroup<T5>,
+    _ k6: KeyframeGroup<T6>,
+    _ k7: KeyframeGroup<T7>,
+    requiresManualInterpolation: Bool = false,
+    makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7) -> CombinedResult
+  ) -> KeyframeGroup<CombinedResult> {
+    Keyframes.combined(
+      [k1, k2, k3, k4, k5, k6, k7],
+      requiresManualInterpolation: requiresManualInterpolation,
+      makeCombinedResult: { untypedValues in
+        guard
+          let t1 = untypedValues[0] as? T1,
+          let t2 = untypedValues[1] as? T2,
+          let t3 = untypedValues[2] as? T3,
+          let t4 = untypedValues[3] as? T4,
+          let t5 = untypedValues[4] as? T5,
+          let t6 = untypedValues[5] as? T6,
+          let t7 = untypedValues[6] as? T7
+        else { return nil }
+
+        return makeCombinedResult(t1, t2, t3, t4, t5, t6, t7)
+      }
+    )
+  }
+
+  /// 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, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  static func combined<
+    T1: AnyInterpolatable,
+    T2: AnyInterpolatable,
+    T3: AnyInterpolatable,
+    T4: AnyInterpolatable,
+    T5: AnyInterpolatable,
+    T6: AnyInterpolatable,
+    T7: AnyInterpolatable,
+    T8: AnyInterpolatable,
+    CombinedResult
+  >(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    _ k4: KeyframeGroup<T4>,
+    _ k5: KeyframeGroup<T5>,
+    _ k6: KeyframeGroup<T6>,
+    _ k7: KeyframeGroup<T7>,
+    _ k8: KeyframeGroup<T8>,
+    requiresManualInterpolation: Bool = false,
+    makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7, T8) -> CombinedResult
+  ) -> KeyframeGroup<CombinedResult> {
+    Keyframes.combined(
+      [k1, k2, k3, k4, k5, k6, k7, k8],
+      requiresManualInterpolation: requiresManualInterpolation,
+      makeCombinedResult: { untypedValues in
+        guard
+          let t1 = untypedValues[0] as? T1,
+          let t2 = untypedValues[1] as? T2,
+          let t3 = untypedValues[2] as? T3,
+          let t4 = untypedValues[3] as? T4,
+          let t5 = untypedValues[4] as? T5,
+          let t6 = untypedValues[5] as? T6,
+          let t7 = untypedValues[6] as? T7,
+          let t8 = untypedValues[7] as? T8
+        else { return nil }
+
+        return makeCombinedResult(t1, t2, t3, t4, t5, t6, t7, t8)
+      }
+    )
+  }
+
+  /// 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, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  static func combined<
+    T1: AnyInterpolatable,
+    T2: AnyInterpolatable,
+    T3: AnyInterpolatable,
+    T4: AnyInterpolatable,
+    T5: AnyInterpolatable,
+    T6: AnyInterpolatable,
+    T7: AnyInterpolatable,
+    T8: AnyInterpolatable,
+    T9: AnyInterpolatable,
+    T10: AnyInterpolatable,
+    CombinedResult
+  >(
+    _ k1: KeyframeGroup<T1>,
+    _ k2: KeyframeGroup<T2>,
+    _ k3: KeyframeGroup<T3>,
+    _ k4: KeyframeGroup<T4>,
+    _ k5: KeyframeGroup<T5>,
+    _ k6: KeyframeGroup<T6>,
+    _ k7: KeyframeGroup<T7>,
+    _ k8: KeyframeGroup<T8>,
+    _ k9: KeyframeGroup<T9>,
+    _ k10: KeyframeGroup<T10>,
+    requiresManualInterpolation: Bool = false,
+    makeCombinedResult: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> CombinedResult
+  ) -> KeyframeGroup<CombinedResult> {
+    Keyframes.combined(
+      [k1, k2, k3, k4, k5, k6, k7, k8, k9, k10],
+      requiresManualInterpolation: requiresManualInterpolation,
+      makeCombinedResult: { untypedValues in
+        guard
+          let t1 = untypedValues[0] as? T1,
+          let t2 = untypedValues[1] as? T2,
+          let t3 = untypedValues[2] as? T3,
+          let t4 = untypedValues[3] as? T4,
+          let t5 = untypedValues[4] as? T5,
+          let t6 = untypedValues[5] as? T6,
+          let t7 = untypedValues[6] as? T7,
+          let t8 = untypedValues[7] as? T8,
+          let t9 = untypedValues[8] as? T9,
+          let t10 = untypedValues[9] as? T10
+        else { return nil }
+
+        return makeCombinedResult(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
+      }
+    )
+  }
+
+  // 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, the keyframes are merged
+  ///  - Otherwise, the keyframes are manually interpolated at each frame in the animation
+  ///
+  /// `makeCombinedResult` is a closure that takes an array of keyframe values (with the exact same length as `AnyKeyframeGroup`),
+  /// casts them to the expected type, and combined them into the final resulting keyframe.
+  ///
+  /// `requiresManualInterpolation` determines whether the keyframes must be computed using `Keyframes.manuallyInterpolated`,
+  /// which interpolates the value at each frame, or if the keyframes can simply be combined.
+  private static func combined<CombinedResult>(
+    _ allGroups: [AnyKeyframeGroup],
+    requiresManualInterpolation: Bool,
+    makeCombinedResult: ([Any]) throws -> CombinedResult?
+  ) rethrows -> 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
+      !requiresManualInterpolation,
+      !allGroups.isEmpty,
+      animatingKeyframes.allSatisfy({ $0.hasSameTimingParameters(as: animatingKeyframes[0]) })
+    else {
+      // If the keyframes don't all share the same timing information,
+      // we have to interpolate the value at each individual frame
+      return try Keyframes.manuallyInterpolated(allGroups, makeCombinedResult: makeCombinedResult)
+    }
+
+    var combinedKeyframes = ContiguousArray<Keyframe<CombinedResult>>()
+    let baseKeyframes = (animatingKeyframes.first ?? untypedGroups[0]).keyframes
+
+    for index in baseKeyframes.indices {
+      let baseKeyframe = baseKeyframes[index]
+      let untypedValues = untypedGroups.map { $0.valueForCombinedKeyframes(at: index) }
+
+      if let combinedValue = try makeCombinedResult(untypedValues) {
+        combinedKeyframes.append(baseKeyframe.withValue(combinedValue))
+      } else {
+        LottieLogger.shared.assertionFailure("""
+          Failed to cast untyped keyframe values to expected type. This is an internal error.
+          """)
+      }
+    }
+
+    return KeyframeGroup(keyframes: combinedKeyframes)
+  }
+
+  private static func manuallyInterpolated<CombinedResult>(
+    _ allGroups: [AnyKeyframeGroup],
+    makeCombinedResult: ([Any]) throws -> CombinedResult?
+  ) rethrows -> KeyframeGroup<CombinedResult> {
+    let untypedGroups = allGroups.map { $0.untyped }
+    let untypedInterpolators = allGroups.map { $0.interpolator }
+
+    let times = untypedGroups.flatMap { $0.keyframes.map { $0.time } }
+
+    let minimumTime = times.min() ?? 0
+    let maximumTime = times.max() ?? 0
+
+    // We disable Core Animation interpolation when using manually interpolated keyframes,
+    // so we don't animate between these values. To prevent the animation from being choppy
+    // even at low playback speed, we have to interpolate at a very high fidelity.
+    let animationLocalTimeRange = stride(from: minimumTime, to: maximumTime, by: 0.1)
+
+    let interpolatedKeyframes = try animationLocalTimeRange.compactMap { localTime -> Keyframe<CombinedResult>? in
+      let interpolatedValues = untypedInterpolators.map { interpolator in
+        interpolator.value(frame: AnimationFrameTime(localTime))
+      }
+
+      guard let combinedResult = try makeCombinedResult(interpolatedValues) else {
+        LottieLogger.shared.assertionFailure("""
+          Failed to cast untyped keyframe values to expected type. This is an internal error.
+          """)
+        return nil
+      }
+
+      return Keyframe(
+        value: combinedResult,
+        time: AnimationFrameTime(localTime),
+        // Since we already manually interpolated the keyframes, have Core Animation display
+        // each value as a static keyframe rather than trying to interpolate between them.
+        isHold: true
+      )
+    }
+
+    return KeyframeGroup(keyframes: ContiguousArray(interpolatedKeyframes))
+  }
+
+}
+
+extension KeyframeGroup {
+  /// Whether or not all of the keyframes in this `KeyframeGroup` have the same
+  /// timing parameters as the corresponding keyframe in the other given `KeyframeGroup`
+  func hasSameTimingParameters<U>(as other: KeyframeGroup<U>) -> Bool {
+    guard keyframes.count == other.keyframes.count else {
+      return false
+    }
+
+    return zip(keyframes, other.keyframes).allSatisfy {
+      $0.hasSameTimingParameters(as: $1)
+    }
+  }
+}
+
+extension Keyframe {
+  /// Whether or not this keyframe has the same timing parameters as the given keyframe,
+  /// excluding `spatialInTangent` and `spatialOutTangent`.
+  fileprivate func hasSameTimingParameters<U>(as other: Keyframe<U>) -> Bool {
+    time == other.time
+      && isHold == other.isHold
+      && inTangent == other.inTangent
+      && outTangent == other.outTangent
+    // 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 {
+      keyframes[0].value
+    } else {
+      keyframes[index].value
+    }
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Extensions/Keyframes+timeRemapping.swift

@@ -0,0 +1,46 @@
+// Created by Cal Stephens on 1/8/24.
+// Copyright © 2024 Airbnb Inc. All rights reserved.
+
+extension Keyframes {
+  /// Manually interpolates the given keyframes, and applies `context.complexTimeRemapping`.
+  ///  - Since `complexTimeRemapping` is a mapping from "global time" to "local time",
+  ///    we have to manually interpolate the keyframes at every frame in the animation.
+  static func manuallyInterpolatedWithTimeRemapping<T: AnyInterpolatable>(
+    _ keyframes: KeyframeGroup<T>,
+    context: LayerAnimationContext
+  ) -> KeyframeGroup<T> {
+    let minimumTime = context.animation.startFrame
+    let maximumTime = context.animation.endFrame
+    let animationLocalTimeRange = stride(from: minimumTime, to: maximumTime, by: 1.0)
+
+    let interpolator = keyframes.interpolator
+
+    // Since potentially many global times can refer to the same local time,
+    // we can cache and reused these local-time values.
+    var localTimeCache = [AnimationFrameTime: T]()
+
+    let interpolatedRemappedKeyframes = animationLocalTimeRange.compactMap { globalTime -> Keyframe<T>? in
+      let remappedLocalTime = context.complexTimeRemapping(globalTime)
+
+      let valueAtRemappedTime: T
+      if let cachedValue = localTimeCache[remappedLocalTime] {
+        valueAtRemappedTime = cachedValue
+      } else if let interpolatedValue = interpolator.value(frame: remappedLocalTime) as? T {
+        valueAtRemappedTime = interpolatedValue
+        localTimeCache[remappedLocalTime] = interpolatedValue
+      } else {
+        LottieLogger.shared.assertionFailure("""
+          Failed to cast untyped keyframe values to expected type. This is an internal error.
+          """)
+        return nil
+      }
+
+      return Keyframe(
+        value: valueAtRemappedTime,
+        time: AnimationFrameTime(globalTime)
+      )
+    }
+
+    return KeyframeGroup(keyframes: ContiguousArray(interpolatedRemappedKeyframes))
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Layers/AnimationLayer.swift

@@ -0,0 +1,169 @@
+// Created by Cal Stephens on 12/14/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - AnimationLayer
+
+/// A type of `CALayer` that can be used in a Lottie animation
+///  - Layers backed by a `LayerModel` subclass should subclass `BaseCompositionLayer`
+protocol AnimationLayer: CALayer {
+  /// Instructs this layer to setup its `CAAnimation`s
+  /// using the given `LayerAnimationContext`
+  func setupAnimations(context: LayerAnimationContext) throws
+}
+
+// MARK: - LayerAnimationContext
+
+/// Context describing the timing parameters of the current animation
+struct LayerAnimationContext {
+  /// The animation being played
+  let animation: LottieAnimation
+
+  /// The timing configuration that should be applied to `CAAnimation`s
+  let timingConfiguration: CoreAnimationLayer.CAMediaTimingConfiguration
+
+  /// The absolute frame number that this animation begins at
+  let startFrame: AnimationFrameTime
+
+  /// The absolute frame number that this animation ends at
+  let endFrame: AnimationFrameTime
+
+  /// The set of custom Value Providers applied to this animation
+  let valueProviderStore: ValueProviderStore
+
+  /// Information about whether or not an animation is compatible with the Core Animation engine
+  let compatibilityTracker: CompatibilityTracker
+
+  /// The logger that should be used for assertions and warnings
+  let logger: LottieLogger
+
+  /// Mutable state related to log events, stored on the `CoreAnimationLayer`.
+  let loggingState: LoggingState
+
+  /// The AnimationKeypath represented by the current layer
+  var currentKeypath: AnimationKeypath
+
+  /// The `AnimationKeypathTextProvider`
+  var textProvider: AnimationKeypathTextProvider
+
+  /// Records the given animation keypath so it can be logged or collected into a list
+  ///  - Used for `CoreAnimationLayer.logHierarchyKeypaths()` and `allHierarchyKeypaths()`
+  var recordHierarchyKeypath: ((String) -> Void)?
+
+  /// A closure that remaps the given frame in the child layer's local time to a frame
+  /// in the animation's overall global time.
+  ///  - This time remapping is simple and only used `preCompLayer.timeStretch` and `preCompLayer.startTime`,
+  ///    so is a trivial function and is invertible. This allows us to invert the time remapping from
+  ///    "global time to local time" to instead be "local time to global time".
+  private(set) var simpleTimeRemapping: ((_ localTime: AnimationFrameTime) -> AnimationFrameTime) = { $0 }
+
+  /// A complex time remapping closure that remaps the given frame in the animation's overall global time
+  /// into the child layer's local time.
+  ///  - This time remapping is arbitrarily complex because it includes the full `preCompLayer.timeRemapping`.
+  ///  - Since it isn't possible to invert the time remapping function, this can only be applied by converting
+  ///    from global time to local time. This requires using `Keyframes.manuallyInterpolatedWithTimeRemapping`.
+  private(set) var complexTimeRemapping: ((_ globalTime: AnimationFrameTime) -> AnimationFrameTime) = { $0 }
+
+  /// Whether or not this layer is required to use the `complexTimeRemapping` via
+  /// the more expensive `Keyframes.manuallyInterpolatedWithTimeRemapping` codepath.
+  var mustUseComplexTimeRemapping = false
+
+  /// The duration of the animation
+  var animationDuration: AnimationFrameTime {
+    // Normal animation playback (like when looping) skips the last frame.
+    // However when the animation is paused, we need to be able to render the final frame.
+    // To allow this we have to extend the length of the animation by one frame.
+    let animationEndFrame: AnimationFrameTime =
+      if timingConfiguration.speed == 0 {
+        animation.endFrame + 1
+      } else {
+        animation.endFrame
+      }
+
+    return Double(animationEndFrame - animation.startFrame) / animation.framerate
+  }
+
+  /// Adds the given component string to the `AnimationKeypath` stored
+  /// that describes the current path being configured by this context value
+  func addingKeypathComponent(_ component: String) -> LayerAnimationContext {
+    var context = self
+    context.currentKeypath.keys.append(component)
+    return context
+  }
+
+  /// The `AnimationProgressTime` for the given `AnimationFrameTime` within this layer,
+  /// accounting for the `simpleTimeRemapping` applied to this layer.
+  func progressTime(for frame: AnimationFrameTime) throws -> AnimationProgressTime {
+    try compatibilityAssert(
+      !mustUseComplexTimeRemapping,
+      "LayerAnimationContext.time(forFrame:) does not support complex time remapping"
+    )
+
+    let animationFrameCount = animationDuration * animation.framerate
+    return (simpleTimeRemapping(frame) - animation.startFrame) / animationFrameCount
+  }
+
+  /// The real-time `TimeInterval` for the given `AnimationFrameTime` within this layer,
+  /// accounting for the `simpleTimeRemapping` applied to this layer.
+  func time(forFrame frame: AnimationFrameTime) throws -> TimeInterval {
+    try compatibilityAssert(
+      !mustUseComplexTimeRemapping,
+      "LayerAnimationContext.time(forFrame:) does not support complex time remapping"
+    )
+
+    return animation.time(forFrame: simpleTimeRemapping(frame))
+  }
+
+  /// Chains an additional time remapping closure onto the `simpleTimeRemapping` closure
+  func withSimpleTimeRemapping(
+    _ additionalSimpleTimeRemapping: @escaping (_ localTime: AnimationFrameTime) -> AnimationFrameTime
+  ) -> LayerAnimationContext {
+    var copy = self
+    copy.simpleTimeRemapping = { [existingSimpleTimeRemapping = simpleTimeRemapping] time in
+      existingSimpleTimeRemapping(additionalSimpleTimeRemapping(time))
+    }
+    return copy
+  }
+
+  /// Chains an additional time remapping closure onto the `complexTimeRemapping` closure.
+  ///  - If `required` is `true`, all subsequent child layers will be required to use the expensive
+  ///    `complexTimeRemapping` / `Keyframes.manuallyInterpolatedWithTimeRemapping` codepath.
+  ///  - `required: true` is necessary when this time remapping is not available via `simpleTimeRemapping`.
+  func withComplexTimeRemapping(
+    required: Bool,
+    _ additionalComplexTimeRemapping: @escaping (_ globalTime: AnimationFrameTime) -> AnimationFrameTime
+  ) -> LayerAnimationContext {
+    var copy = self
+    copy.mustUseComplexTimeRemapping = copy.mustUseComplexTimeRemapping || required
+    copy.complexTimeRemapping = { [existingComplexTimeRemapping = complexTimeRemapping] time in
+      additionalComplexTimeRemapping(existingComplexTimeRemapping(time))
+    }
+    return copy
+  }
+
+  /// Returns a copy of this context with time remapping removed
+  func withoutTimeRemapping() -> LayerAnimationContext {
+    var copy = self
+    copy.simpleTimeRemapping = { $0 }
+    copy.complexTimeRemapping = { $0 }
+    copy.mustUseComplexTimeRemapping = false
+    return copy
+  }
+}
+
+// MARK: - LoggingState
+
+/// Mutable state related to log events, stored on the `CoreAnimationLayer`.
+final class LoggingState {
+
+  // MARK: Lifecycle
+
+  init() { }
+
+  // MARK: Internal
+
+  /// Whether or not the warning about unsupported After Effects expressions
+  /// has been logged yet for this layer.
+  var hasLoggedAfterEffectsExpressionsWarning = false
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Layers/BaseAnimationLayer.swift

@@ -0,0 +1,46 @@
+// Created by Cal Stephens on 1/27/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+/// A base `CALayer` that manages the frame and animations
+/// of its `sublayers` and `mask`
+class BaseAnimationLayer: CALayer, AnimationLayer {
+
+  // MARK: Internal
+
+  override func layoutSublayers() {
+    super.layoutSublayers()
+
+    for sublayer in managedSublayers {
+      sublayer.fillBoundsOfSuperlayer()
+    }
+  }
+
+  func setupAnimations(context: LayerAnimationContext) throws {
+    // Only set up animations for sublayers here, not MaskCompositionLayer masks.
+    // MaskCompositionLayer animations must be set up separately with the parent's context
+    // (without precomp time remapping), since mask keyframes are defined
+    // in the parent's global timeline. See BaseCompositionLayer.setupLayerAnimations.
+    for childAnimationLayer in sublayers ?? [] {
+      try (childAnimationLayer as? AnimationLayer)?.setupAnimations(context: context)
+    }
+
+    // Set up animations for non-MaskCompositionLayer masks (e.g. alpha matte masks
+    // created in CALayer+setupLayerHierarchy.swift). These receive the same context
+    // as the layer they're masking. MaskCompositionLayer is excluded here because it
+    // is handled explicitly in BaseCompositionLayer.setupLayerAnimations with the
+    // parent's non-remapped context.
+    if let maskAnimationLayer = mask as? AnimationLayer, !(mask is MaskCompositionLayer) {
+      try maskAnimationLayer.setupAnimations(context: context)
+    }
+  }
+
+  // MARK: Private
+
+  /// All of the sublayers managed by this container
+  private var managedSublayers: [CALayer] {
+    (sublayers ?? []) + [mask].compactMap { $0 }
+  }
+
+}