@octane-xplat/lottie 0.9.0 → 0.11.0

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/LayoutUtilities/SwiftUIMeasurementContainer.swift

@@ -0,0 +1,468 @@
+// Created by Bryn Bodayle on 1/24/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import SwiftUI
+
+// MARK: - SwiftUIMeasurementContainer
+
+/// A view that has an `intrinsicContentSize` of the `uiView`'s `systemLayoutSizeFitting(…)` and
+/// supports double layout pass sizing and content size category changes.
+///
+/// This container view uses an injected proposed width to measure the view and return its ideal
+/// height through the `SwiftUISizingContext` binding.
+///
+/// - SeeAlso: ``MeasuringViewRepresentable``
+final class SwiftUIMeasurementContainer<Content: ViewType>: ViewType {
+
+  // MARK: Lifecycle
+
+  init(content: Content, strategy: SwiftUIMeasurementContainerStrategy) {
+    self.content = content
+    self.strategy = strategy
+
+    // On iOS 15 and below, passing zero can result in a constraint failure the first time a view
+    // is displayed, but the system gracefully recovers afterwards. On iOS 16, it's fine to pass
+    // zero.
+    let initialSize: CGSize =
+      if #available(iOS 16, tvOS 16, macOS 13, *) {
+        .zero
+      } else {
+        .init(width: 375, height: 150)
+      }
+    super.init(frame: .init(origin: .zero, size: initialSize))
+
+    addSubview(content)
+    setUpConstraints()
+  }
+
+  @available(*, unavailable)
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  /// The  most recently measured fitting size of the `uiView` that fits within the current
+  /// `proposedSize`.
+  ///
+  /// Contains `proposedSize`/`bounds.size` fallbacks for dimensions with no intrinsic size, as
+  /// compared to `intrinsicContentSize` which has `UIView.noIntrinsicMetric` fields in the case of
+  /// no intrinsic size.
+  var measuredFittingSize: CGSize {
+    _measuredFittingSize ?? measureView()
+  }
+
+  /// The `UIView` content that's being measured by this container.
+  var content: Content {
+    didSet {
+      guard content !== oldValue else { return }
+      oldValue.removeFromSuperview()
+      addSubview(content)
+      // Invalidate the strategy since it's derived from this view.
+      _resolvedStrategy = nil
+      // Re-configure the constraints since they depend on the resolved strategy.
+      setUpConstraints()
+      // Finally, we need to re-measure the view.
+      _measuredFittingSize = nil
+    }
+  }
+
+  /// The proposed size at the time of the latest measurement.
+  ///
+  /// Has a side-effect of updating the `measuredIntrinsicContentSize` if it's changed.
+  var proposedSize = CGSize.noIntrinsicMetric {
+    didSet {
+      guard oldValue != proposedSize else { return }
+      // The proposed size is only used by the measurement, so just re-measure.
+      _measuredFittingSize = nil
+    }
+  }
+
+  /// The measurement strategy of this container.
+  ///
+  /// Has a side-effect of updating the `measuredIntrinsicContentSize` if it's changed.
+  var strategy: SwiftUIMeasurementContainerStrategy {
+    didSet {
+      guard oldValue != strategy else { return }
+      // Invalidate the resolved strategy since it's derived from this strategy.
+      _resolvedStrategy = nil
+      // Then, re-measure the view.
+      _measuredFittingSize = nil
+    }
+  }
+
+  override var intrinsicContentSize: CGSize {
+    _intrinsicContentSize
+  }
+
+  #if os(macOS)
+  override func layout() {
+    super.layout()
+
+    // We need to re-measure the view whenever the size of the bounds changes, as the previous size
+    // may now be incorrect.
+    if latestMeasurementBoundsSize != nil, bounds.size != latestMeasurementBoundsSize {
+      // This will trigger SwiftUI to re-measure the view.
+      super.invalidateIntrinsicContentSize()
+    }
+  }
+  #else
+  override func layoutSubviews() {
+    super.layoutSubviews()
+
+    // We need to re-measure the view whenever the size of the bounds changes, as the previous size
+    // may now be incorrect.
+    if latestMeasurementBoundsSize != nil, bounds.size != latestMeasurementBoundsSize {
+      // This will trigger SwiftUI to re-measure the view.
+      super.invalidateIntrinsicContentSize()
+    }
+  }
+  #endif
+
+  override func invalidateIntrinsicContentSize() {
+    super.invalidateIntrinsicContentSize()
+
+    // Invalidate the resolved strategy in case it changes with the re-measurement as it relies on
+    // the intrinsic size.
+    _resolvedStrategy = nil
+    _measuredFittingSize = nil
+  }
+
+  // MARK: Private
+
+  /// The most recently measured intrinsic content size of the `uiView`, else `noIntrinsicMetric` if
+  /// it has not yet been measured.
+  ///
+  /// Contains `UIView.noIntrinsicMetric` fallbacks for dimensions with no intrinsic size,
+  /// as compared to `measuredFittingSize` which has `proposedSize`/`bounds.size` fallbacks.
+  private var _intrinsicContentSize = CGSize.noIntrinsicMetric
+
+  /// The bounds size at the time of the latest measurement.
+  private var latestMeasurementBoundsSize: CGSize?
+
+  /// The most recently updated set of constraints constraining `uiView` to `self`.
+  private var uiViewConstraints = [NSLayoutConstraint.Attribute: NSLayoutConstraint]()
+
+  /// The cached `resolvedStrategy` to prevent unnecessary re-measurements.
+  private var _resolvedStrategy: ResolvedSwiftUIMeasurementContainerStrategy?
+
+  /// The cached `measuredFittingSize` to prevent unnecessary re-measurements.
+  private var _measuredFittingSize: CGSize?
+
+  /// The resolved measurement strategy.
+  private var resolvedStrategy: ResolvedSwiftUIMeasurementContainerStrategy {
+    if let resolvedStrategy = _resolvedStrategy {
+      return resolvedStrategy
+    }
+
+    let resolved: ResolvedSwiftUIMeasurementContainerStrategy
+    switch strategy {
+    case .automatic:
+      // Perform an intrinsic size measurement pass, which gives us valid values for
+      // `UILabel.preferredMaxLayoutWidth`.
+      let intrinsicSize = content.systemLayoutFittingIntrinsicSize()
+
+      // If the view has a intrinsic width and contains a double layout pass subview, give it the
+      // proposed width to allow the label content to gracefully wrap to multiple lines.
+      if intrinsicSize.width > 0, content.containsDoubleLayoutPassSubviews() {
+        resolved = .intrinsicHeightProposedWidth
+      } else {
+        let zero = CGFloat(0)
+        switch (width: intrinsicSize.width, height: intrinsicSize.height) {
+        case (width: ...zero, height: ...zero):
+          resolved = .proposed
+        case (width: ...zero, height: zero.nextUp...):
+          resolved = .intrinsicHeightProposedWidth
+        case (width: zero.nextUp..., height: ...zero):
+          resolved = .intrinsicWidthProposedHeight
+        default:
+          resolved = .intrinsic(intrinsicSize)
+        }
+      }
+
+    case .proposed:
+      resolved = .proposed
+
+    case .intrinsicHeightProposedWidth:
+      resolved = .intrinsicHeightProposedWidth
+
+    case .intrinsicWidthProposedHeight:
+      resolved = .intrinsicWidthProposedHeight
+
+    case .intrinsic:
+      resolved = .intrinsic(content.systemLayoutFittingIntrinsicSize())
+    }
+    _resolvedStrategy = resolved
+    return resolved
+  }
+
+  private func setUpConstraints() {
+    content.translatesAutoresizingMaskIntoConstraints = false
+
+    let leading = content.leadingAnchor.constraint(equalTo: leadingAnchor)
+    let top = content.topAnchor.constraint(equalTo: topAnchor)
+    let trailing = content.trailingAnchor.constraint(equalTo: trailingAnchor)
+    let bottom = content.bottomAnchor.constraint(equalTo: bottomAnchor)
+    let newConstraints: [NSLayoutConstraint.Attribute: NSLayoutConstraint] = [
+      .leading: leading,
+      .top: top,
+      .trailing: trailing,
+      .bottom: bottom,
+    ]
+    // Start with the lowest priority constraints so we aren't measuring the view too early, the
+    // priorities will be updated later on.
+    prioritizeConstraints(newConstraints, strategy: .intrinsic(.zero))
+
+    NSLayoutConstraint.deactivate(Array(uiViewConstraints.values))
+    uiViewConstraints = newConstraints
+    NSLayoutConstraint.activate(Array(uiViewConstraints.values))
+  }
+
+  /// Prioritizes the given constraints based on the provided resolved strategy.
+  private func prioritizeConstraints(
+    _ constraints: [NSLayoutConstraint.Attribute: NSLayoutConstraint],
+    strategy: ResolvedSwiftUIMeasurementContainerStrategy
+  ) {
+    // Give a required constraint in the dimensions that are fixed to the bounds, otherwise almost
+    // required.
+    switch strategy {
+    case .proposed:
+      constraints[.trailing]?.priority = .required
+      constraints[.bottom]?.priority = .required
+
+    case .intrinsicHeightProposedWidth:
+      constraints[.trailing]?.priority = .required
+      constraints[.bottom]?.priority = .almostRequired
+
+    case .intrinsicWidthProposedHeight:
+      constraints[.trailing]?.priority = .almostRequired
+      constraints[.bottom]?.priority = .required
+
+    case .intrinsic:
+      constraints[.trailing]?.priority = .almostRequired
+      constraints[.bottom]?.priority = .almostRequired
+    }
+
+    #if os(macOS)
+    // On macOS, views default to having required constraints setting their height / width
+    // equal to their intrinsic content size. These have to be disabled in favor of the constraints
+    // we create here.
+    content.isVerticalContentSizeConstraintActive = false
+    content.isHorizontalContentSizeConstraintActive = false
+    #endif
+  }
+
+  /// Measures the `uiView`, storing the resulting size in `measuredIntrinsicContentSize`.
+  private func measureView() -> CGSize {
+    latestMeasurementBoundsSize = bounds.size
+    prioritizeConstraints(uiViewConstraints, strategy: resolvedStrategy)
+
+    var measuredSize: CGSize
+    let proposedSizeElseBounds = proposedSize.replacingNoIntrinsicMetric(with: bounds.size)
+
+    switch resolvedStrategy {
+    case .proposed:
+      measuredSize = .noIntrinsicMetric
+
+    case .intrinsicHeightProposedWidth:
+      measuredSize = content.systemLayoutFittingIntrinsicHeightFixedWidth(proposedSizeElseBounds.width)
+      measuredSize.width = ViewType.noIntrinsicMetric
+
+    case .intrinsicWidthProposedHeight:
+      measuredSize = content.systemLayoutFittingIntrinsicWidthFixedHeight(proposedSizeElseBounds.height)
+      measuredSize.height = ViewType.noIntrinsicMetric
+
+    case .intrinsic(let size):
+      measuredSize = size
+
+      // If the measured size exceeds an available width or height, set the measured size to
+      // `noIntrinsicMetric` to ensure that the component can be compressed, otherwise it will
+      // overflow beyond the proposed size.
+      // - If the previous intrinsic content size is the same as the new proposed size, we don't
+      //   do this as SwiftUI sometimes "proposes" the same intrinsic size back to the component and
+      //   we don't want that scenario to prevent size changes when there is actually more space
+      //   available.
+      if
+        proposedSize.width != ViewType.noIntrinsicMetric,
+        measuredSize.width > proposedSizeElseBounds.width,
+        _intrinsicContentSize.width != proposedSize.width
+      {
+        measuredSize.width = ViewType.noIntrinsicMetric
+      }
+      if
+        proposedSize.height != ViewType.noIntrinsicMetric,
+        measuredSize.height > proposedSizeElseBounds.height,
+        _intrinsicContentSize.height != proposedSize.height
+      {
+        measuredSize.height = ViewType.noIntrinsicMetric
+      }
+    }
+
+    _intrinsicContentSize = measuredSize
+
+    let measuredFittingSize = measuredSize.replacingNoIntrinsicMetric(with: proposedSizeElseBounds)
+    _measuredFittingSize = measuredFittingSize
+    return measuredFittingSize
+  }
+}
+
+// MARK: - SwiftUIMeasurementContainerStrategy
+
+/// The measurement strategy of a `SwiftUIMeasurementContainer`.
+enum SwiftUIMeasurementContainerStrategy {
+  /// The container makes a best effort to correctly choose the measurement strategy of the view.
+  ///
+  /// The best effort is based on a number of heuristics:
+  /// - The `uiView` will be given its intrinsic width and/or height when measurement in that
+  ///   dimension produces a positive value, while zero/negative values will result in that
+  ///   dimension receiving the available space proposed by the parent.
+  /// - If the view contains `UILabel` subviews that require a double layout pass as determined by
+  ///   a `preferredMaxLayoutWidth` that's greater than zero after a layout, then the view will
+  ///   default to `intrinsicHeightProposedWidth` to allow the labels to wrap.
+  ///
+  /// If you would like to opt out of automatic sizing for performance or to override the default
+  /// behavior, choose another strategy.
+  case automatic
+
+  /// The `uiView` is sized to fill the area proposed by its parent.
+  ///
+  /// Typically used for views that should expand greedily in both axes, e.g. a background view.
+  case proposed
+
+  /// The `uiView` is sized with its intrinsic height and expands horizontally to fill the width
+  /// proposed by its parent.
+  ///
+  /// Typically used for views that have a height that's a function of their width, e.g. a row with
+  /// text that can wrap to multiple lines.
+  case intrinsicHeightProposedWidth
+
+  /// The `uiView` is sized with its intrinsic width and expands vertically to fill the height
+  /// proposed by its parent.
+  ///
+  /// Typically used for views that are free to grow vertically but have a fixed width, e.g. a view
+  /// in a horizontal carousel.
+  case intrinsicWidthProposedHeight
+
+  /// The `uiView` is sized to its intrinsic width and height.
+  ///
+  /// Typically used for components with a specific intrinsic size in both axes, e.g. controls or
+  /// inputs.
+  case intrinsic
+}
+
+// MARK: - ResolvedSwiftUIMeasurementContainerStrategy
+
+/// The resolved measurement strategy of a `SwiftUIMeasurementContainer`, matching the cases of the
+/// `SwiftUIMeasurementContainerStrategy` without the automatic case.
+private enum ResolvedSwiftUIMeasurementContainerStrategy {
+  case proposed
+  case intrinsicHeightProposedWidth
+  case intrinsicWidthProposedHeight
+  case intrinsic(CGSize)
+}
+
+// MARK: - UILayoutPriority
+
+extension LayoutPriorityType {
+  /// An "almost required" constraint, useful for creating near-required constraints that don't
+  /// error when unable to be satisfied.
+  @nonobjc
+  fileprivate static var almostRequired: LayoutPriorityType {
+    .init(rawValue: required.rawValue - 1)
+  }
+}
+
+// MARK: - UIView
+
+extension ViewType {
+  /// The `systemLayoutSizeFitting(…)` of this view with a compressed size and fitting priorities.
+  @nonobjc
+  fileprivate func systemLayoutFittingIntrinsicSize() -> CGSize {
+    #if os(macOS)
+    intrinsicContentSize
+    #else
+    systemLayoutSizeFitting(
+      UIView.layoutFittingCompressedSize,
+      withHorizontalFittingPriority: .fittingSizeLevel,
+      verticalFittingPriority: .fittingSizeLevel
+    )
+    #endif
+  }
+
+  /// The `systemLayoutSizeFitting(…)` of this view with a compressed height with a fitting size
+  /// priority and with the given fixed width and fitting priority.
+  @nonobjc
+  fileprivate func systemLayoutFittingIntrinsicHeightFixedWidth(
+    _ width: CGFloat,
+    priority: LayoutPriorityType = .almostRequired
+  ) -> CGSize {
+    #if os(macOS)
+    return CGSize(width: width, height: intrinsicContentSize.height)
+    #else
+    let targetSize = CGSize(width: width, height: UIView.layoutFittingCompressedSize.height)
+
+    return systemLayoutSizeFitting(
+      targetSize,
+      withHorizontalFittingPriority: priority,
+      verticalFittingPriority: .fittingSizeLevel
+    )
+    #endif
+  }
+
+  /// The `systemLayoutSizeFitting(…)` of this view with a compressed width with a fitting size
+  /// priority and with the given fixed height and fitting priority.
+  @nonobjc
+  fileprivate func systemLayoutFittingIntrinsicWidthFixedHeight(
+    _ height: CGFloat,
+    priority: LayoutPriorityType = .almostRequired
+  ) -> CGSize {
+    #if os(macOS)
+    return CGSize(width: intrinsicContentSize.width, height: height)
+    #else
+    let targetSize = CGSize(width: UIView.layoutFittingCompressedSize.width, height: height)
+
+    return systemLayoutSizeFitting(
+      targetSize,
+      withHorizontalFittingPriority: .fittingSizeLevel,
+      verticalFittingPriority: priority
+    )
+    #endif
+  }
+
+  /// Whether this view or any of its subviews has a subview that has a double layout pass `UILabel`
+  /// as determined by a non-zero `preferredMaxLayoutWidth`, which implies that it should get a
+  /// `intrinsicHeightProposedWidth` sizing strategy to allow the label to wrap and grow.
+  @nonobjc
+  fileprivate func containsDoubleLayoutPassSubviews() -> Bool {
+    #if os(macOS)
+    return false
+    #else
+    var contains = false
+    if let label = self as? UILabel, label.preferredMaxLayoutWidth > 0 {
+      contains = true
+    }
+    for subview in subviews {
+      contains = contains || subview.containsDoubleLayoutPassSubviews()
+    }
+    return contains
+    #endif
+  }
+}
+
+// MARK: - CGSize
+
+extension CGSize {
+  /// A `CGSize` with `noIntrinsicMetric` for both its width and height.
+  fileprivate static var noIntrinsicMetric: CGSize {
+    .init(width: ViewType.noIntrinsicMetric, height: ViewType.noIntrinsicMetric)
+  }
+
+  /// Returns a `CGSize` with its width and/or height replaced with the corresponding field of the
+  /// provided `fallback` size if they are `UIView.noIntrinsicMetric`.
+  fileprivate func replacingNoIntrinsicMetric(with fallback: CGSize) -> CGSize {
+    .init(
+      width: width == ViewType.noIntrinsicMetric ? fallback.width : width,
+      height: height == ViewType.noIntrinsicMetric ? fallback.height : height
+    )
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/SwiftUIView.swift

@@ -0,0 +1,146 @@
+// Created by eric_horacek on 9/8/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import SwiftUI
+
+// MARK: - SwiftUIView
+
+/// A `UIViewRepresentable` SwiftUI `View` that wraps its `Content` `UIView` within a
+/// `SwiftUIMeasurementContainer`, used to size a UIKit view correctly within a SwiftUI view
+/// hierarchy.
+///
+/// Includes an optional generic `Storage` value, which can be used to compare old and new values
+/// across state changes to prevent redundant view updates.
+struct SwiftUIView<Content: ViewType, Storage>: MeasuringViewRepresentable,
+  UIViewConfiguringSwiftUIView
+{
+
+  // MARK: Lifecycle
+
+  /// Creates a SwiftUI representation of the content view with the given storage and the provided
+  /// `makeContent` closure to construct the content whenever `makeUIView(…)` is invoked.
+  init(storage: Storage, makeContent: @escaping () -> Content) {
+    self.storage = storage
+    self.makeContent = makeContent
+  }
+
+  /// Creates a SwiftUI representation of the content view with the provided `makeContent` closure
+  /// to construct it whenever `makeUIView(…)` is invoked.
+  init(makeContent: @escaping () -> Content) where Storage == Void {
+    storage = ()
+    self.makeContent = makeContent
+  }
+
+  // MARK: Internal
+
+  var configurations = [Configuration]()
+
+  var sizing = SwiftUIMeasurementContainerStrategy.automatic
+
+  // MARK: Private
+
+  /// The current stored value, with the previous value provided to the configuration closure as
+  /// the `oldStorage`.
+  private var storage: Storage
+
+  /// A closure that's invoked to construct the represented content view.
+  private var makeContent: () -> Content
+}
+
+// MARK: UIViewRepresentable
+
+extension SwiftUIView {
+  func makeCoordinator() -> Coordinator {
+    Coordinator(storage: storage)
+  }
+
+  #if os(macOS)
+  func makeNSView(context _: Context) -> SwiftUIMeasurementContainer<Content> {
+    SwiftUIMeasurementContainer(content: makeContent(), strategy: sizing)
+  }
+
+  func updateNSView(_ uiView: SwiftUIMeasurementContainer<Content>, context: Context) {
+    let oldStorage = context.coordinator.storage
+    context.coordinator.storage = storage
+
+    let configurationContext = ConfigurationContext(
+      oldStorage: oldStorage,
+      viewRepresentableContext: context,
+      container: uiView
+    )
+
+    for configuration in configurations {
+      configuration(configurationContext)
+    }
+  }
+  #else
+  func makeUIView(context _: Context) -> SwiftUIMeasurementContainer<Content> {
+    SwiftUIMeasurementContainer(content: makeContent(), strategy: sizing)
+  }
+
+  func updateUIView(_ uiView: SwiftUIMeasurementContainer<Content>, context: Context) {
+    let oldStorage = context.coordinator.storage
+    context.coordinator.storage = storage
+
+    let configurationContext = ConfigurationContext(
+      oldStorage: oldStorage,
+      viewRepresentableContext: context,
+      container: uiView
+    )
+
+    for configuration in configurations {
+      configuration(configurationContext)
+    }
+  }
+  #endif
+}
+
+// MARK: SwiftUIView.ConfigurationContext
+
+extension SwiftUIView {
+  /// The configuration context that's available to configure the `Content` view whenever the
+  /// `updateUIView()` method is invoked via a configuration closure.
+  struct ConfigurationContext: ViewProviding {
+    /// The previous value for the `Storage` of this `SwiftUIView`, which can be used to store
+    /// values across state changes to prevent redundant view updates.
+    var oldStorage: Storage
+
+    /// The `UIViewRepresentable.Context`, with information about the transaction and environment.
+    var viewRepresentableContext: Context
+
+    /// The backing measurement container that contains the `Content`.
+    var container: SwiftUIMeasurementContainer<Content>
+
+    /// The `UIView` content that's being configured.
+    ///
+    /// Setting this to a new value updates the backing measurement container's `content`.
+    var view: Content {
+      get { container.content }
+      nonmutating set { container.content = newValue }
+    }
+
+    /// A convenience accessor indicating whether this content update should be animated.
+    var animated: Bool {
+      viewRepresentableContext.transaction.animation != nil
+    }
+  }
+}
+
+// MARK: SwiftUIView.Coordinator
+
+extension SwiftUIView {
+  /// A coordinator that stores the `storage` associated with this view, enabling the old storage
+  /// value to be accessed during the `updateUIView(…)`.
+  final class Coordinator {
+
+    // MARK: Lifecycle
+
+    fileprivate init(storage: Storage) {
+      self.storage = storage
+    }
+
+    // MARK: Internal
+
+    fileprivate(set) var storage: Storage
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/UIView+SwiftUIView.swift

@@ -0,0 +1,39 @@
+// Created by eric_horacek on 3/3/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import SwiftUI
+
+// MARK: - ViewTypeProtocol + swiftUIView
+
+extension ViewTypeProtocol {
+  /// Returns a SwiftUI `View` representing this `UIView`, constructed with the given `makeView`
+  /// closure and sized with the given sizing configuration.
+  ///
+  /// To perform additional configuration of the `UIView` instance, call `configure` on the
+  /// returned SwiftUI `View`:
+  /// ```
+  /// MyUIView.swiftUIView(…)
+  ///   .configure { context in
+  ///     context.view.doSomething()
+  ///   }
+  /// ```
+  ///
+  /// To configure the sizing behavior of the `UIView` instance, call `sizing` on the returned
+  /// SwiftUI `View`:
+  /// ```
+  /// MyView.swiftUIView(…).sizing(.intrinsicSize)
+  /// ```
+  /// The sizing defaults to `.automatic`.
+  static func swiftUIView(makeView: @escaping () -> Self) -> SwiftUIView<Self, Void> {
+    SwiftUIView(makeContent: makeView)
+  }
+}
+
+// MARK: - ViewTypeProtocol
+
+/// A protocol that all `UIView`s conform to, enabling extensions that have a `Self` reference.
+protocol ViewTypeProtocol: ViewType { }
+
+// MARK: - ViewType + ViewTypeProtocol
+
+extension ViewType: ViewTypeProtocol { }

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/EpoxyCore/SwiftUI/UIViewConfiguringSwiftUIView.swift

@@ -0,0 +1,41 @@
+// Created by eric_horacek on 3/4/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import SwiftUI
+
+// MARK: - UIViewConfiguringSwiftUIView
+
+/// A protocol describing a SwiftUI `View` that can configure its `UIView` content via an array of
+/// `configuration` closures.
+protocol UIViewConfiguringSwiftUIView: View {
+  /// The context available to this configuration, which provides the `UIView` instance at a minimum
+  /// but can include additional context as needed.
+  associatedtype ConfigurationContext: ViewProviding
+
+  /// A closure that is invoked to configure the represented content view.
+  typealias Configuration = (ConfigurationContext) -> Void
+
+  /// A mutable array of configuration closures that should each be invoked with the
+  /// `ConfigurationContext` whenever `updateUIView` is called in a `UIViewRepresentable`.
+  var configurations: [Configuration] { get set }
+}
+
+// MARK: Extensions
+
+extension UIViewConfiguringSwiftUIView {
+  /// Returns a copy of this view updated to have the given closure applied to its represented view
+  /// whenever it is updated via the `updateUIView(…)` method.
+  func configure(_ configure: @escaping Configuration) -> Self {
+    var copy = self
+    copy.configurations.append(configure)
+    return copy
+  }
+
+  /// Returns a copy of this view updated to have the given closures applied to its represented view
+  /// whenever it is updated via the `updateUIView(…)` method.
+  func configurations(_ configurations: [Configuration]) -> Self {
+    var copy = self
+    copy.configurations.append(contentsOf: configurations)
+    return copy
+  }
+}