@octane-xplat/lottie 0.9.0 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Public/AnimationCache/DefaultAnimationCache.swift

@@ -0,0 +1,67 @@
+//
+//  DefaultAnimationCache.swift
+//  Lottie
+//
+//  Created by Marcelo Fabri on 10/18/22.
+//
+
+import Foundation
+
+// MARK: - DefaultAnimationCache
+
+/// A thread-safe Animation Cache that will store animations up to `cacheSize`.
+///
+/// Once `cacheSize` is reached, animations can be ejected.
+/// The default size of the cache is 100.
+///
+/// This cache implementation also responds to memory pressure.
+public final class DefaultAnimationCache: AnimationCacheProvider {
+
+  // MARK: Lifecycle
+
+  public init() {
+    cache.countLimit = Self.defaultCacheCountLimit
+  }
+
+  // MARK: Public
+
+  /// The global shared Cache.
+  public static let sharedCache = DefaultAnimationCache()
+
+  /// The maximum number of animations that can be stored in the cache.
+  public var cacheSize: Int {
+    get { cache.countLimit }
+    set { cache.countLimit = newValue }
+  }
+
+  /// Clears the Cache.
+  public func clearCache() {
+    cache.removeAllValues()
+  }
+
+  public func animation(forKey key: String) -> LottieAnimation? {
+    cache.value(forKey: key)
+  }
+
+  public func setAnimation(_ animation: LottieAnimation, forKey key: String) {
+    cache.setValue(animation, forKey: key)
+  }
+
+  // MARK: Private
+
+  private static let defaultCacheCountLimit = 100
+
+  /// The underlying storage of this cache.
+  ///  - We use the `LRUCache` library instead of `NSCache`, because `NSCache`
+  ///    clears all cached values when the app is backgrounded instead of
+  ///    only when the app receives a memory warning notification.
+  private let cache = LRUCache<String, LottieAnimation>()
+}
+
+// MARK: @unchecked Sendable
+
+// LottieAnimationCache has a Sendable requirement, but we can't
+// redesign DefaultAnimationCache to be properly Sendable without
+// making breaking changes.
+// swiftlint:disable:next no_unchecked_sendable
+extension DefaultAnimationCache: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Public/AnimationCache/LRUAnimationCache.swift

@@ -0,0 +1,11 @@
+//
+//  LRUAnimationCache.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/5/19.
+//
+
+@available(*, deprecated, message: """
+  Use DefaultAnimationCache instead, which is thread-safe and automatically responds to memory pressure.
+  """)
+public typealias LRUAnimationCache = DefaultAnimationCache

package/platforms/macos/src/vendor/Lottie/Public/AnimationCache/LottieAnimationCache.swift

@@ -0,0 +1,15 @@
+//
+//  LottieAnimationCache.swift
+//  Lottie
+//
+//  Created by Marcelo Fabri on 10/17/22.
+//
+
+/// A customization point to configure which `AnimationCacheProvider` will be used.
+public enum LottieAnimationCache {
+
+  /// The animation cache that will be used when loading `LottieAnimation` models.
+  /// Using an Animation Cache can increase performance when loading an animation multiple times.
+  /// Defaults to DefaultAnimationCache.sharedCache.
+  public static var shared: AnimationCacheProvider? = DefaultAnimationCache.sharedCache
+}

package/platforms/macos/src/vendor/Lottie/Public/Configuration/DecodingStrategy.swift

@@ -0,0 +1,15 @@
+// Created by Cal Stephens on 7/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+/// How animation files should be decoded
+public enum DecodingStrategy: Hashable {
+  /// Use Codable. This is was the default strategy introduced on Lottie 3, but should be rarely
+  /// used as it's slower than `dictionaryBased`. Kept here for any possible compatibility issues
+  /// that may come up, but consider it soft-deprecated.
+  case legacyCodable
+
+  /// Manually deserialize a dictionary into an Animation.
+  /// This should be at least 2-3x faster than using Codable and due to that
+  /// it's the default as of Lottie 4.x.
+  case dictionaryBased
+}

package/platforms/macos/src/vendor/Lottie/Public/Configuration/LottieConfiguration.swift

@@ -0,0 +1,54 @@
+// Created by Cal Stephens on 12/13/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+import Foundation
+import QuartzCore
+
+/// Global configuration options for Lottie animations
+public struct LottieConfiguration: Hashable {
+
+  // MARK: Lifecycle
+
+  public init(
+    renderingEngine: RenderingEngineOption = .automatic,
+    decodingStrategy: DecodingStrategy = .dictionaryBased,
+    colorSpace: CGColorSpace = CGColorSpaceCreateDeviceRGB(),
+    reducedMotionOption: ReducedMotionOption = .systemReducedMotionToggle
+  ) {
+    self.renderingEngine = renderingEngine
+    self.decodingStrategy = decodingStrategy
+    self.colorSpace = colorSpace
+    self.reducedMotionOption = reducedMotionOption
+  }
+
+  // MARK: Public
+
+  /// The global configuration of Lottie,
+  /// which applies to all `LottieAnimationView`s by default.
+  public static var shared = LottieConfiguration()
+
+  /// The default URL session used to load remote Lottie animations.
+  ///  - Defaults to `URLSession.shared`
+  ///  - Set this to a custom `LottieURLSession` implementation to control network behavior,
+  ///    such as disabling network requests during screenshot tests.
+  public static var defaultURLSession: LottieURLSession = URLSession.shared
+
+  /// The rendering engine implementation to use when displaying an animation
+  ///  - Defaults to `RenderingEngineOption.automatic`, which uses the
+  ///    Core Animation rendering engine for supported animations, and
+  ///    falls back to using the Main Thread rendering engine for
+  ///    animations that use features not supported by the Core Animation engine.
+  public var renderingEngine: RenderingEngineOption
+
+  /// The decoding implementation to use when parsing an animation JSON file
+  public var decodingStrategy: DecodingStrategy
+
+  /// Options for controlling animation behavior in response to user / system "reduced motion" configuration.
+  ///  - Defaults to `ReducedMotionOption.systemReducedMotionToggle`, which returns `.reducedMotion`
+  ///    when the system `UIAccessibility.isReduceMotionEnabled` option is `true`.
+  public var reducedMotionOption: ReducedMotionOption
+
+  /// The color space to be used for rendering
+  ///  - Defaults to `CGColorSpaceCreateDeviceRGB()`
+  public var colorSpace: CGColorSpace
+}

package/platforms/macos/src/vendor/Lottie/Public/Configuration/LottieURLSession.swift

@@ -0,0 +1,31 @@
+// Created by Andy Bartholomew on 12/2/24.
+// Copyright © 2024 Airbnb Inc. All rights reserved.
+
+import Foundation
+
+// MARK: - LottieURLSession
+
+/// A protocol that abstracts URL session functionality for loading Lottie animations.
+public protocol LottieURLSession: Sendable {
+  /// Creates a data task that retrieves the contents of the specified URL.
+  ///
+  /// - Parameters:
+  ///   - url: The URL to retrieve.
+  ///   - completionHandler: The completion handler to call when the load request is complete.
+  /// - Returns: A `URLSessionDataTask` that can be resumed or cancelled, or `nil` for mock implementations.
+  func lottieDataTask(
+    with url: URL,
+    completionHandler: @escaping @Sendable (Data?, URLResponse?, (any Error)?) -> Void
+  ) -> URLSessionDataTask?
+}
+
+// MARK: - URLSession + LottieURLSession
+
+extension URLSession: LottieURLSession {
+  public func lottieDataTask(
+    with url: URL,
+    completionHandler: @escaping @Sendable (Data?, URLResponse?, (any Error)?) -> Void
+  ) -> URLSessionDataTask? {
+    dataTask(with: url, completionHandler: completionHandler)
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/Configuration/ReducedMotionOption.swift

@@ -0,0 +1,128 @@
+// Created by Cal Stephens on 7/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+
+// MARK: - ReducedMotionOption
+
+/// Options for controlling animation behavior in response to user / system "reduced motion" configuration
+public enum ReducedMotionOption {
+  /// Always use the specific given `ReducedMotionMode` value.
+  case specific(ReducedMotionMode)
+
+  /// Dynamically check the given `ReducedMotionOptionProvider` each time an animation begins.
+  ///  - Includes a Hashable `dataID` to support `ReducedMotionOption`'s `Hashable` requirement,
+  ///    which is required due to `LottieConfiguration`'s existing `Hashable` requirement.
+  case dynamic(ReducedMotionOptionProvider, dataID: AnyHashable)
+}
+
+extension ReducedMotionOption {
+  /// The standard behavior where Lottie animations play normally with no overrides.
+  /// By default this mode is used when the system "reduced motion" option is disabled.
+  public static var standardMotion: ReducedMotionOption {
+    .specific(.standardMotion)
+  }
+
+  /// Lottie animations with a "reduced motion" marker will play that marker instead of any other animations.
+  /// By default this mode is used when the system "reduced motion" option is enabled.
+  ///  - Valid marker names include "reduced motion", "reducedMotion", "reduced_motion" (case insensitive).
+  public static var reducedMotion: ReducedMotionOption {
+    .specific(.reducedMotion)
+  }
+
+  /// Animations are disabled and render statically at their first frame instead of playing.
+  /// This is useful for snapshot testing where animation non-determinism can cause flaky tests.
+  public static var disabledMotion: ReducedMotionOption {
+    .specific(.disabledMotion)
+  }
+
+  /// A `ReducedMotionOptionProvider` that returns `.reducedMotion` when
+  /// the system `UIAccessibility.isReduceMotionEnabled` option is `true`.
+  /// This is the default option of `LottieConfiguration`.
+  public static var systemReducedMotionToggle: ReducedMotionOption {
+    .dynamic(SystemReducedMotionOptionProvider(), dataID: ObjectIdentifier(SystemReducedMotionOptionProvider.self))
+  }
+}
+
+extension ReducedMotionOption {
+  /// The current `ReducedMotionMode` based on the currently selected option.
+  public var currentReducedMotionMode: ReducedMotionMode {
+    switch self {
+    case .specific(let specificMode):
+      specificMode
+    case .dynamic(let optionProvider, _):
+      optionProvider.currentReducedMotionMode
+    }
+  }
+}
+
+// MARK: Hashable
+
+extension ReducedMotionOption: Hashable {
+  public static func ==(_ lhs: ReducedMotionOption, _ rhs: ReducedMotionOption) -> Bool {
+    switch (lhs, rhs) {
+    case (.specific(let lhsMode), .specific(let rhsMode)):
+      lhsMode == rhsMode
+    case (.dynamic(_, let lhsDataID), .dynamic(_, dataID: let rhsDataID)):
+      lhsDataID == rhsDataID
+    case (.dynamic, .specific), (.specific, .dynamic):
+      false
+    }
+  }
+
+  public func hash(into hasher: inout Hasher) {
+    switch self {
+    case .specific(let mode):
+      hasher.combine(mode)
+    case .dynamic(_, let dataID):
+      hasher.combine(dataID)
+    }
+  }
+}
+
+// MARK: - ReducedMotionMode
+
+public enum ReducedMotionMode: Hashable {
+  /// The default behavior where Lottie animations play normally with no overrides
+  /// By default this mode is used when the system "reduced motion" option is disabled.
+  case standardMotion
+
+  /// Lottie animations with a "reduced motion" marker will play that marker instead of any other animations.
+  /// By default this mode is used when the system "reduced motion" option is enabled.
+  case reducedMotion
+
+  /// Animations are disabled and render statically at their first frame instead of playing.
+  /// This is useful for snapshot testing where animation non-determinism can cause flaky tests.
+  case disabledMotion
+}
+
+// MARK: - ReducedMotionOptionProvider
+
+/// A type that returns a dynamic `ReducedMotionMode` which is checked when playing a Lottie animation.
+public protocol ReducedMotionOptionProvider {
+  var currentReducedMotionMode: ReducedMotionMode { get }
+}
+
+// MARK: - SystemReducedMotionOptionProvider
+
+/// A `ReducedMotionOptionProvider` that returns `.reducedMotion` when
+/// the system `UIAccessibility.isReduceMotionEnabled` option is `true`.
+public struct SystemReducedMotionOptionProvider: ReducedMotionOptionProvider {
+  public init() { }
+
+  public var currentReducedMotionMode: ReducedMotionMode {
+    #if canImport(UIKit)
+    if UIAccessibility.isReduceMotionEnabled {
+      return .reducedMotion
+    } else {
+      return .standardMotion
+    }
+    #else
+    return .standardMotion
+    #endif
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/Configuration/RenderingEngineOption.swift

@@ -0,0 +1,117 @@
+// Created by Cal Stephens on 7/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+// MARK: - RenderingEngineOption
+
+public enum RenderingEngineOption: Hashable {
+  /// Uses the Core Animation engine for supported animations, and falls back to using
+  /// the Main Thread engine for animations that use features not supported by the
+  /// Core Animation engine.
+  case automatic
+
+  /// Uses the specified rendering engine
+  case specific(RenderingEngine)
+
+  // MARK: Public
+
+  /// The Main Thread rendering engine, which supports all Lottie features
+  /// but runs on the main thread, which comes with some CPU overhead and
+  /// can cause the animation to play at a low framerate when the CPU is busy.
+  public static var mainThread: RenderingEngineOption {
+    .specific(.mainThread)
+  }
+
+  /// The Core Animation rendering engine, that animates using Core Animation
+  /// and has better performance characteristics than the Main Thread engine,
+  /// but doesn't support all Lottie features.
+  ///  - In general, prefer using `RenderingEngineOption.automatic` over
+  ///    `RenderingEngineOption.coreAnimation`. The Core Animation rendering
+  ///    engine doesn't support all features supported by the Main Thread
+  ///    rendering engine. When using `RenderingEngineOption.automatic`,
+  ///    Lottie will automatically fall back to the Main Thread engine
+  ///    when necessary.
+  public static var coreAnimation: RenderingEngineOption {
+    .specific(.coreAnimation)
+  }
+}
+
+// MARK: - RenderingEngine
+
+/// The rendering engine implementation to use when displaying an animation
+public enum RenderingEngine: Hashable {
+  /// The Main Thread rendering engine, which supports all Lottie features
+  /// but runs on the main thread, which comes with some CPU overhead and
+  /// can cause the animation to play at a low framerate when the CPU is busy.
+  case mainThread
+
+  /// The Core Animation rendering engine, that animates using Core Animation
+  /// and has better performance characteristics than the Main Thread engine,
+  /// but doesn't support all Lottie features.
+  case coreAnimation
+}
+
+// MARK: - RenderingEngineOption + RawRepresentable, CustomStringConvertible
+
+extension RenderingEngineOption: RawRepresentable, CustomStringConvertible {
+
+  // MARK: Lifecycle
+
+  public init?(rawValue: String) {
+    if rawValue == "Automatic" {
+      self = .automatic
+    } else if let engine = RenderingEngine(rawValue: rawValue) {
+      self = .specific(engine)
+    } else {
+      return nil
+    }
+  }
+
+  // MARK: Public
+
+  public var rawValue: String {
+    switch self {
+    case .automatic:
+      "Automatic"
+    case .specific(let engine):
+      engine.rawValue
+    }
+  }
+
+  public var description: String {
+    rawValue
+  }
+
+}
+
+// MARK: - RenderingEngine + RawRepresentable, CustomStringConvertible
+
+extension RenderingEngine: RawRepresentable, CustomStringConvertible {
+
+  // MARK: Lifecycle
+
+  public init?(rawValue: String) {
+    switch rawValue {
+    case "Main Thread":
+      self = .mainThread
+    case "Core Animation":
+      self = .coreAnimation
+    default:
+      return nil
+    }
+  }
+
+  // MARK: Public
+
+  public var rawValue: String {
+    switch self {
+    case .mainThread:
+      "Main Thread"
+    case .coreAnimation:
+      "Core Animation"
+    }
+  }
+
+  public var description: String {
+    rawValue
+  }
+}

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

@@ -0,0 +1,128 @@
+//
+//  AnimatedButton.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+
+// MARK: - AnimatedButton
+
+/// An interactive button that plays an animation when pressed.
+open class AnimatedButton: AnimatedControl {
+
+  // MARK: Lifecycle
+
+  public override init(
+    animation: LottieAnimation?,
+    configuration: LottieConfiguration = .shared
+  ) {
+    super.init(animation: animation, configuration: configuration)
+
+    #if canImport(UIKit)
+    isAccessibilityElement = true
+    #elseif canImport(AppKit)
+    setAccessibilityElement(true)
+    #endif
+  }
+
+  public override init() {
+    super.init()
+
+    #if canImport(UIKit)
+    isAccessibilityElement = true
+    #elseif canImport(AppKit)
+    setAccessibilityElement(true)
+    #endif
+  }
+
+  required public init?(coder aDecoder: NSCoder) {
+    super.init(coder: aDecoder)
+
+    #if canImport(UIKit)
+    isAccessibilityElement = true
+    #elseif canImport(AppKit)
+    setAccessibilityElement(true)
+    #endif
+  }
+
+  // MARK: Open
+
+  #if canImport(UIKit)
+  open override func beginTracking(_ touch: UITouch, with event: UIEvent?) -> Bool {
+    let _ = super.beginTracking(touch, with: event)
+    let touchEvent = UIControl.Event.touchDown
+    if let playRange = rangesForEvents[touchEvent.id] {
+      animationView.play(fromProgress: playRange.from, toProgress: playRange.to, loopMode: .playOnce)
+    }
+    return true
+  }
+
+  open override func endTracking(_ touch: UITouch?, with event: UIEvent?) {
+    super.endTracking(touch, with: event)
+    let touchEvent: UIControl.Event
+    if let touch, bounds.contains(touch.location(in: self)) {
+      touchEvent = UIControl.Event.touchUpInside
+      performAction?()
+    } else {
+      touchEvent = UIControl.Event.touchUpOutside
+    }
+
+    if let playRange = rangesForEvents[touchEvent.id] {
+      animationView.play(fromProgress: playRange.from, toProgress: playRange.to, loopMode: .playOnce)
+    }
+  }
+
+  #elseif canImport(AppKit)
+  open override func handle(_ event: LottieNSControlEvent) {
+    super.handle(event)
+
+    if let playRange = rangesForEvents[event.id] {
+      animationView.play(fromProgress: playRange.from, toProgress: playRange.to, loopMode: .playOnce)
+    }
+
+    if event == .touchUpInside {
+      performAction?()
+    }
+  }
+  #endif
+
+  // MARK: Public
+
+  /// A closure that is called when the button is pressed / clicked
+  public var performAction: (() -> Void)?
+
+  #if canImport(UIKit)
+  public override var accessibilityTraits: UIAccessibilityTraits {
+    set { super.accessibilityTraits = newValue }
+    get { super.accessibilityTraits.union(.button) }
+  }
+  #endif
+
+  /// Sets the play range for the given UIControlEvent.
+  public func setPlayRange(fromProgress: AnimationProgressTime, toProgress: AnimationProgressTime, event: LottieControlEvent) {
+    rangesForEvents[event.id] = (from: fromProgress, to: toProgress)
+  }
+
+  /// Sets the play range for the given UIControlEvent.
+  public func setPlayRange(fromMarker fromName: String, toMarker toName: String, event: LottieControlEvent) {
+    if
+      let start = animationView.progressTime(forMarker: fromName),
+      let end = animationView.progressTime(forMarker: toName)
+    {
+      rangesForEvents[event.id] = (from: start, to: end)
+    }
+  }
+
+  // MARK: Private
+
+  private var rangesForEvents: [AnyHashable: (from: CGFloat, to: CGFloat)] = [LottieControlEvent.touchUpInside.id: (
+    from: 0,
+    to: 1
+  )]
+}