@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Public/Controls/AnimatedControl.swift

@@ -0,0 +1,248 @@
+//
+//  AnimatedControl.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+
+// MARK: - AnimatedControl
+
+/// Lottie comes prepacked with a two Animated Controls, `AnimatedSwitch` and
+/// `AnimatedButton`. Both of these controls are built on top of `AnimatedControl`
+///
+/// `AnimatedControl` is a subclass of `UIControl` that provides an interactive
+/// mechanism for controlling the visual state of an animation in response to
+/// user actions.
+///
+/// The `AnimatedControl` will show and hide layers depending on the current
+/// `UIControl.State` of the control.
+///
+/// Users of `AnimationControl` can set a Layer Name for each `UIControl.State`.
+/// When the state is change the `AnimationControl` will change the visibility
+/// of its layers.
+///
+/// NOTE: Do not initialize directly. This is intended to be subclassed.
+open class AnimatedControl: LottieControlType {
+
+  // MARK: Lifecycle
+
+  public init(
+    animation: LottieAnimation?,
+    configuration: LottieConfiguration = .shared
+  ) {
+    animationView = LottieAnimationView(
+      animation: animation,
+      configuration: configuration
+    )
+
+    super.init(frame: animation?.bounds ?? .zero)
+    commonInit()
+  }
+
+  public init() {
+    animationView = LottieAnimationView()
+    super.init(frame: .zero)
+    commonInit()
+  }
+
+  required public init?(coder aDecoder: NSCoder) {
+    animationView = LottieAnimationView()
+    super.init(coder: aDecoder)
+    commonInit()
+  }
+
+  // MARK: Open
+
+  open override var isEnabled: Bool {
+    didSet {
+      updateForState()
+    }
+  }
+
+  #if canImport(UIKit)
+  open override var isSelected: Bool {
+    didSet {
+      updateForState()
+    }
+  }
+  #endif
+
+  open override var isHighlighted: Bool {
+    didSet {
+      updateForState()
+    }
+  }
+
+  open override var intrinsicContentSize: CGSize {
+    animationView.intrinsicContentSize
+  }
+
+  #if canImport(UIKit)
+  open override func beginTracking(_ touch: UITouch, with event: UIEvent?) -> Bool {
+    updateForState()
+    return super.beginTracking(touch, with: event)
+  }
+
+  open override func continueTracking(_ touch: UITouch, with event: UIEvent?) -> Bool {
+    updateForState()
+    return super.continueTracking(touch, with: event)
+  }
+
+  open override func endTracking(_ touch: UITouch?, with event: UIEvent?) {
+    updateForState()
+    return super.endTracking(touch, with: event)
+  }
+
+  open override func cancelTracking(with event: UIEvent?) {
+    updateForState()
+    super.cancelTracking(with: event)
+  }
+
+  #elseif canImport(AppKit)
+  open override func mouseDown(with mouseDownEvent: NSEvent) {
+    guard let window else { return }
+
+    currentState = .highlighted
+    updateForState()
+    handle(LottieControlEvent(mouseDownEvent.type, inside: eventIsInside(mouseDownEvent)))
+
+    // AppKit mouse-tracking loop from:
+    // https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/EventOverview/HandlingMouseEvents/HandlingMouseEvents.html#//apple_ref/doc/uid/10000060i-CH6-SW4
+    var keepOn = true
+    while
+      keepOn,
+      let event = window.nextEvent(
+        matching: .any,
+        until: .distantFuture,
+        inMode: .eventTracking,
+        dequeue: true
+      )
+    {
+      if event.type == .leftMouseUp {
+        keepOn = false
+      }
+
+      let isInside = eventIsInside(event)
+      handle(LottieControlEvent(event.type, inside: isInside))
+
+      let expectedState = (isInside && keepOn) ? LottieNSControlState.highlighted : .normal
+      if currentState != expectedState {
+        currentState = expectedState
+        updateForState()
+      }
+    }
+  }
+
+  func handle(_: LottieNSControlEvent) {
+    // To be overridden in subclasses
+  }
+
+  private func eventIsInside(_ event: NSEvent) -> Bool {
+    let mouseLocation = convert(event.locationInWindow, from: nil)
+    return isMousePoint(mouseLocation, in: bounds)
+  }
+  #endif
+
+  open func animationDidSet() { }
+
+  // MARK: Public
+
+  /// The animation view in which the animation is rendered.
+  public let animationView: LottieAnimationView
+
+  /// The animation backing the animated control.
+  public var animation: LottieAnimation? {
+    didSet {
+      animationView.animation = animation
+      animationView.bounds = animation?.bounds ?? .zero
+      #if canImport(UIKit)
+      setNeedsLayout()
+      #elseif canImport(AppKit)
+      needsLayout = true
+      #endif
+      updateForState()
+      animationDidSet()
+    }
+  }
+
+  /// The speed of the animation playback. Defaults to 1
+  public var animationSpeed: CGFloat {
+    set { animationView.animationSpeed = newValue }
+    get { animationView.animationSpeed }
+  }
+
+  /// Sets which Animation Layer should be visible for the given state.
+  public func setLayer(named: String, forState: LottieControlState) {
+    stateMap[forState.rawValue] = named
+    updateForState()
+  }
+
+  /// Sets a ValueProvider for the specified keypath
+  public func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath) {
+    animationView.setValueProvider(valueProvider, keypath: keypath)
+  }
+
+  /// Removes a ValueProvider for the specified keypath
+  public func removeValueProvider(for keypath: AnimationKeypath) {
+    animationView.removeValueProvider(for: keypath)
+  }
+
+  // MARK: Internal
+
+  var stateMap = [UInt: String]()
+
+  #if canImport(UIKit)
+  var currentState: LottieControlState {
+    state
+  }
+
+  #elseif canImport(AppKit)
+  var currentState = LottieControlState.normal
+  #endif
+
+  func updateForState() {
+    guard let animationLayer = animationView.animationLayer else { return }
+    if
+      let layerName = stateMap[currentState.rawValue],
+      let stateLayer = animationLayer.layer(for: AnimationKeypath(keypath: layerName))
+    {
+      for layer in animationLayer._animationLayers {
+        layer.isHidden = true
+      }
+      stateLayer.isHidden = false
+    } else {
+      for layer in animationLayer._animationLayers {
+        layer.isHidden = false
+      }
+    }
+  }
+
+  // MARK: Private
+
+  private func commonInit() {
+    #if canImport(UIKit)
+    animationView.clipsToBounds = false
+    clipsToBounds = true
+    #endif
+
+    animationView.translatesAutoresizingMaskIntoConstraints = false
+    animationView.backgroundBehavior = .forceFinish
+    addSubview(animationView)
+    animationView.contentMode = .scaleAspectFit
+
+    #if canImport(UIKit)
+    animationView.isUserInteractionEnabled = false
+    #endif
+
+    animationView.leadingAnchor.constraint(equalTo: leadingAnchor).isActive = true
+    animationView.trailingAnchor.constraint(equalTo: trailingAnchor).isActive = true
+    animationView.topAnchor.constraint(equalTo: topAnchor).isActive = true
+    animationView.bottomAnchor.constraint(equalTo: bottomAnchor).isActive = true
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/Controls/AnimatedSwitch.swift

@@ -0,0 +1,271 @@
+//
+//  AnimatedSwitch.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+
+// MARK: - AnimatedSwitch
+
+/// An interactive switch with an 'On' and 'Off' state. When the user taps on the
+/// switch the state is toggled and the appropriate animation is played.
+///
+/// Both the 'On' and 'Off' have an animation play range associated with their state.
+///
+/// Also available as a SwiftUI view (`LottieSwitch`).
+open class AnimatedSwitch: AnimatedControl {
+
+  // MARK: Lifecycle
+
+  public override init(
+    animation: LottieAnimation?,
+    configuration: LottieConfiguration = .shared
+  ) {
+    /// Generate a haptic generator if available.
+    #if os(iOS)
+    hapticGenerator = HapticGenerator()
+    #else
+    hapticGenerator = NullHapticGenerator()
+    #endif
+    super.init(animation: animation, configuration: configuration)
+
+    #if canImport(UIKit)
+    isAccessibilityElement = true
+    #elseif canImport(AppKit)
+    setAccessibilityElement(true)
+    #endif
+
+    updateOnState(isOn: _isOn, animated: false, shouldFireHaptics: false)
+  }
+
+  public override init() {
+    /// Generate a haptic generator if available.
+    #if os(iOS)
+    hapticGenerator = HapticGenerator()
+    #else
+    hapticGenerator = NullHapticGenerator()
+    #endif
+
+    super.init()
+
+    #if canImport(UIKit)
+    isAccessibilityElement = true
+    #elseif canImport(AppKit)
+    setAccessibilityElement(true)
+    #endif
+
+    updateOnState(isOn: _isOn, animated: false, shouldFireHaptics: false)
+  }
+
+  required public init?(coder aDecoder: NSCoder) {
+    /// Generate a haptic generator if available.
+    #if os(iOS)
+    hapticGenerator = HapticGenerator()
+    #else
+    hapticGenerator = NullHapticGenerator()
+    #endif
+    super.init(coder: aDecoder)
+
+    #if canImport(UIKit)
+    isAccessibilityElement = true
+    #elseif canImport(AppKit)
+    setAccessibilityElement(true)
+    #endif
+  }
+
+  // MARK: Open
+
+  open override func animationDidSet() {
+    updateOnState(isOn: _isOn, animated: animateUpdateWhenChangingAnimation, shouldFireHaptics: false)
+  }
+
+  #if canImport(UIKit)
+  open override func endTracking(_ touch: UITouch?, with event: UIEvent?) {
+    super.endTracking(touch, with: event)
+    updateOnState(isOn: !_isOn, animated: true, shouldFireHaptics: true)
+    sendActions(for: .valueChanged)
+  }
+
+  #elseif canImport(AppKit)
+  open override func handle(_ event: LottieNSControlEvent) {
+    super.handle(event)
+
+    if event == .touchUpInside {
+      updateOnState(isOn: !_isOn, animated: true, shouldFireHaptics: true)
+    }
+  }
+  #endif
+
+  // MARK: Public
+
+  /// Defines what happens when the user taps the switch while an
+  /// animation is still in flight
+  public enum CancelBehavior {
+    case reverse // default - plays the current animation in reverse
+    case none // does not update the animation when canceled
+  }
+
+  /// The cancel behavior for the switch. See CancelBehavior for options
+  public var cancelBehavior = CancelBehavior.reverse
+
+  /// If `false` the switch will not play the animation when changing between animations.
+  public var animateUpdateWhenChangingAnimation = true
+
+  /// A closure that is called when the `isOn` state is updated
+  public var stateUpdated: ((_ isOn: Bool) -> Void)?
+
+  #if canImport(UIKit)
+  public override var accessibilityTraits: UIAccessibilityTraits {
+    set { super.accessibilityTraits = newValue }
+    get { super.accessibilityTraits.union(.button) }
+  }
+  #endif
+
+  /// The current state of the switch.
+  public var isOn: Bool {
+    set {
+      /// This is forwarded to a private variable because the animation needs to be updated without animation when set externally and with animation when set internally.
+      guard _isOn != newValue else { return }
+      updateOnState(isOn: newValue, animated: false, shouldFireHaptics: false)
+    }
+    get {
+      _isOn
+    }
+  }
+
+  /// Set the state of the switch and specify animation and haptics
+  public func setIsOn(_ isOn: Bool, animated: Bool, shouldFireHaptics: Bool = true) {
+    guard isOn != _isOn else { return }
+    updateOnState(isOn: isOn, animated: animated, shouldFireHaptics: shouldFireHaptics)
+  }
+
+  /// Sets the play range for the given state. When the switch is toggled, the animation range is played.
+  public func setProgressForState(
+    fromProgress: AnimationProgressTime,
+    toProgress: AnimationProgressTime,
+    forOnState: Bool
+  ) {
+    if forOnState {
+      onStartProgress = fromProgress
+      onEndProgress = toProgress
+    } else {
+      offStartProgress = fromProgress
+      offEndProgress = toProgress
+    }
+
+    updateOnState(isOn: _isOn, animated: false, shouldFireHaptics: false)
+  }
+
+  // MARK: Internal
+
+  private(set) var onStartProgress: CGFloat = 0
+  private(set) var onEndProgress: CGFloat = 1
+  private(set) var offStartProgress: CGFloat = 1
+  private(set) var offEndProgress: CGFloat = 0
+
+  func updateOnState(isOn: Bool, animated: Bool, shouldFireHaptics: Bool) {
+    _isOn = isOn
+    var startProgress = isOn ? onStartProgress : offStartProgress
+    var endProgress = isOn ? onEndProgress : offEndProgress
+    let finalProgress = endProgress
+
+    if cancelBehavior == .reverse {
+      let realtimeProgress = animationView.realtimeAnimationProgress
+
+      let previousStateStart = isOn ? offStartProgress : onStartProgress
+      let previousStateEnd = isOn ? offEndProgress : onEndProgress
+      if
+        realtimeProgress.isInRange(
+          min(previousStateStart, previousStateEnd),
+          max(previousStateStart, previousStateEnd)
+        )
+      {
+        /// Animation is currently in the previous time range. Reverse the previous play.
+        startProgress = previousStateEnd
+        endProgress = previousStateStart
+      }
+    }
+
+    updateAccessibilityLabel()
+
+    guard animated == true else {
+      animationView.currentProgress = finalProgress
+      return
+    }
+
+    if shouldFireHaptics {
+      hapticGenerator.generateImpact()
+    }
+
+    animationView.play(
+      fromProgress: startProgress,
+      toProgress: endProgress,
+      loopMode: LottieLoopMode.playOnce,
+      completion: { [weak self] finished in
+        guard let self else { return }
+
+        // For the Main Thread rendering engine, we freeze the animation at the expected final progress
+        // once the animation is complete. This isn't necessary on the Core Animation engine.
+        if finished, !(animationView.animationLayer is CoreAnimationLayer) {
+          animationView.currentProgress = finalProgress
+        }
+      }
+    )
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate var hapticGenerator: ImpactGenerator
+
+  fileprivate var _isOn = false {
+    didSet {
+      stateUpdated?(_isOn)
+    }
+  }
+
+  // MARK: Private
+
+  private func updateAccessibilityLabel() {
+    let value = _isOn ? NSLocalizedString("On", comment: "On") : NSLocalizedString("Off", comment: "Off")
+
+    #if canImport(UIKit)
+    accessibilityValue = value
+    #elseif canImport(AppKit)
+    setAccessibilityValue(value)
+    #endif
+  }
+
+}
+
+// MARK: - ImpactGenerator
+
+protocol ImpactGenerator {
+  func generateImpact()
+}
+
+#if os(iOS)
+final class HapticGenerator: ImpactGenerator {
+
+  // MARK: Internal
+
+  func generateImpact() {
+    impact.impactOccurred()
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate let impact = UIImpactFeedbackGenerator(style: .light)
+}
+#else
+// MARK: - NullHapticGenerator
+
+final class NullHapticGenerator: ImpactGenerator {
+  func generateImpact() { }
+}
+#endif

package/platforms/macos/src/vendor/Lottie/Public/Controls/LottieButton.swift

@@ -0,0 +1,119 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+#if canImport(SwiftUI)
+import SwiftUI
+
+/// A wrapper which exposes Lottie's `AnimatedButton` to SwiftUI
+public struct LottieButton: UIViewConfiguringSwiftUIView {
+
+  // MARK: Lifecycle
+
+  public init(animation: LottieAnimation?, action: @escaping () -> Void) {
+    self.animation = animation
+    self.action = action
+  }
+
+  // MARK: Public
+
+  public var body: some View {
+    AnimatedButton.swiftUIView {
+      let button = AnimatedButton(animation: animation, configuration: configuration)
+      button.performAction = action
+      return button
+    }
+    .configure { context in
+      // We check referential equality of the animation before updating as updating the
+      // animation has a side-effect of rebuilding the animation layer, and it would be
+      // prohibitive to do so on every state update.
+      if animation !== context.view.animationView.animation {
+        context.view.animationView.animation = animation
+      }
+
+      #if os(macOS)
+      // Disable the intrinsic content size constraint on the inner animation view,
+      // or the Epoxy `SwiftUIMeasurementContainer` won't size this view correctly.
+      context.view.animationView.isVerticalContentSizeConstraintActive = false
+      context.view.animationView.isHorizontalContentSizeConstraintActive = false
+      #endif
+    }
+    .configurations(configurations)
+  }
+
+  /// Returns a copy of this `LottieView` updated to have the given closure applied to its
+  /// represented `LottieAnimationView` whenever it is updated via the `updateUIView(…)`
+  /// or `updateNSView(…)` method.
+  public func configure(_ configure: @escaping (AnimatedButton) -> Void) -> Self {
+    var copy = self
+    copy.configurations.append { context in
+      configure(context.view)
+    }
+    return copy
+  }
+
+  /// Returns a copy of this view with its `LottieConfiguration` updated to the given value.
+  public func configuration(_ configuration: LottieConfiguration) -> Self {
+    var copy = self
+    copy.configuration = configuration
+
+    copy = copy.configure { view in
+      if view.animationView.configuration != configuration {
+        view.animationView.configuration = configuration
+      }
+    }
+
+    return copy
+  }
+
+  /// Returns a copy of this view configured to animate between the
+  /// given progress values when the given event is triggered
+  public func animate(
+    fromProgress: AnimationProgressTime,
+    toProgress: AnimationProgressTime,
+    on event: LottieControlEvent
+  ) -> Self {
+    configure { view in
+      // `setPlayRange` just modifies a dictionary,
+      // so we can just call it on every state update without diffing
+      view.setPlayRange(fromProgress: fromProgress, toProgress: toProgress, event: event)
+    }
+  }
+
+  /// Returns a copy of this view configured to animate between the
+  /// given markers when the given event is triggered
+  public func animate(
+    fromMarker: String,
+    toMarker: String,
+    on event: LottieControlEvent
+  ) -> Self {
+    configure { view in
+      // `setPlayRange` just modifies a dictionary,
+      // so we can just call it on every state update without diffing
+      view.setPlayRange(fromMarker: fromMarker, toMarker: toMarker, event: event)
+    }
+  }
+
+  /// Returns a copy of this view using the given value provider for the given keypath.
+  /// The value provider must be `Equatable` to avoid unnecessary state updates / re-renders.
+  public func valueProvider<ValueProvider: AnyValueProvider & Equatable>(
+    _ valueProvider: ValueProvider,
+    for keypath: AnimationKeypath
+  ) -> Self {
+    configure { view in
+      if (view.animationView.valueProviders[keypath] as? ValueProvider) != valueProvider {
+        view.animationView.setValueProvider(valueProvider, keypath: keypath)
+      }
+    }
+  }
+
+  // MARK: Internal
+
+  var configurations = [SwiftUIView<AnimatedButton, Void>.Configuration]()
+
+  // MARK: Private
+
+  private let animation: LottieAnimation?
+  private let action: () -> Void
+  private var configuration = LottieConfiguration.shared
+}
+#endif