@octane-xplat/lottie 0.9.0 → 0.10.0

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

@@ -0,0 +1,144 @@
+// Created by Cal Stephens on 8/11/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+#if canImport(SwiftUI)
+import SwiftUI
+
+/// A wrapper which exposes Lottie's `AnimatedSwitch` to SwiftUI
+public struct LottieSwitch: UIViewConfiguringSwiftUIView {
+
+  // MARK: Lifecycle
+
+  public init(animation: LottieAnimation?) {
+    self.animation = animation
+  }
+
+  // MARK: Public
+
+  public var body: some View {
+    AnimatedSwitch.swiftUIView {
+      let animatedSwitch = AnimatedSwitch(animation: animation, configuration: configuration)
+      animatedSwitch.isOn = isOn?.wrappedValue ?? false
+      return animatedSwitch
+    }
+    .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
+
+      if let isOn = isOn?.wrappedValue, isOn != context.view.isOn {
+        context.view.setIsOn(isOn, animated: true)
+      }
+    }
+    .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 (AnimatedSwitch) -> 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 with the given `Binding` reflecting the `isOn` state of the switch.
+  public func isOn(_ binding: Binding<Bool>) -> Self {
+    var copy = self
+    copy.isOn = binding
+    return copy.configure { view in
+      view.stateUpdated = { isOn in
+        DispatchQueue.main.async {
+          binding.wrappedValue = isOn
+        }
+      }
+    }
+  }
+
+  /// Returns a copy of this view with the "on" animation configured
+  /// to start and end at the given progress values.
+  /// Defaults to playing the entire animation forwards (0...1).
+  public func onAnimation(
+    fromProgress onStartProgress: AnimationProgressTime,
+    toProgress onEndProgress: AnimationProgressTime
+  ) -> Self {
+    configure { view in
+      if onStartProgress != view.onStartProgress || onEndProgress != view.onEndProgress {
+        view.setProgressForState(
+          fromProgress: onStartProgress,
+          toProgress: onEndProgress,
+          forOnState: true
+        )
+      }
+    }
+  }
+
+  /// Returns a copy of this view with the "on" animation configured
+  /// to start and end at the given progress values.
+  /// Defaults to playing the entire animation backwards (1...0).
+  public func offAnimation(
+    fromProgress offStartProgress: AnimationProgressTime,
+    toProgress offEndProgress: AnimationProgressTime
+  ) -> Self {
+    configure { view in
+      if offStartProgress != view.offStartProgress || offEndProgress != view.offEndProgress {
+        view.setProgressForState(
+          fromProgress: offStartProgress,
+          toProgress: offEndProgress,
+          forOnState: false
+        )
+      }
+    }
+  }
+
+  /// 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<AnimatedSwitch, Void>.Configuration]()
+
+  // MARK: Private
+
+  private let animation: LottieAnimation?
+  private var configuration = LottieConfiguration.shared
+  private var isOn: Binding<Bool>?
+
+}
+#endif

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

@@ -0,0 +1,79 @@
+// Created by Cal Stephens on 8/11/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+#if canImport(UIKit)
+import UIKit
+
+/// The control base type for this platform.
+///  - `UIControl` on iOS / tvOS and `NSControl` on macOS.
+public typealias LottieControlType = UIControl
+
+/// The `State` type of `LottieControlType`
+///  - `UIControl.State` on iOS / tvOS and `NSControl.StateValue` on macOS.
+public typealias LottieControlState = UIControl.State
+
+/// The event type handled by the `LottieControlType` component for this platform.
+///  - `UIControl.Event` on iOS / tvOS and `LottieNSControlEvent` on macOS.
+public typealias LottieControlEvent = UIControl.Event
+
+extension LottieControlEvent {
+  var id: AnyHashable {
+    rawValue
+  }
+}
+#else
+import AppKit
+
+/// The control base type for this platform.
+///  - `UIControl` on iOS / tvOS and `NSControl` on macOS.
+public typealias LottieControlType = NSControl
+
+/// The `State` type of `LottieControlType`
+///  - `UIControl.State` on iOS / tvOS and `NSControl.StateValue` on macOS.
+public typealias LottieControlState = LottieNSControlState
+
+/// AppKit equivalent of `UIControl.State` for `AnimatedControl`
+public enum LottieNSControlState: UInt, RawRepresentable {
+  /// The normal, or default, state of a control where the control is enabled but neither selected nor highlighted.
+  case normal
+  /// The highlighted state of a control.
+  case highlighted
+}
+
+/// The event type handled by the `LottieControlType` component for this platform.
+///  - `UIControl.Event` on iOS / tvOS and `LottieNSControlEvent` on macOS.
+public typealias LottieControlEvent = LottieNSControlEvent
+
+public struct LottieNSControlEvent: Equatable, Sendable {
+
+  // MARK: Lifecycle
+
+  public init(_ event: NSEvent.EventType, inside: Bool) {
+    self.event = event
+    self.inside = inside
+  }
+
+  // MARK: Public
+
+  /// macOS equivalent to `UIControl.Event.touchDown`
+  public static let touchDown = LottieNSControlEvent(.leftMouseDown, inside: true)
+
+  /// macOS equivalent to `UIControl.Event.touchUpInside`
+  public static let touchUpInside = LottieNSControlEvent(.leftMouseUp, inside: true)
+
+  /// macOS equivalent to `UIControl.Event.touchUpInside`
+  public static let touchUpOutside = LottieNSControlEvent(.leftMouseUp, inside: false)
+
+  /// The underlying `NSEvent.EventType` of this event, which is roughly equivalent to `UIControl.Event`
+  public var event: NSEvent.EventType
+
+  /// Whether or not the mouse must be inside the control.
+  public var inside: Bool
+
+  // MARK: Internal
+
+  var id: AnyHashable {
+    [AnyHashable(event.rawValue), AnyHashable(inside)]
+  }
+}
+#endif

package/platforms/macos/src/vendor/Lottie/Public/DotLottie/Cache/DotLottieCache.swift

@@ -0,0 +1,66 @@
+//
+//  LRUDotLottieCache.swift
+//  Lottie
+//
+//  Created by Evandro Hoffmann on 20/10/22.
+//
+
+import Foundation
+
+// MARK: - DotLottieCache
+
+/// A DotLottie Cache that will store lottie files up to `cacheSize`.
+///
+/// Once `cacheSize` is reached, the least recently used lottie will be ejected.
+/// The default size of the cache is 100.
+public final class DotLottieCache: DotLottieCacheProvider {
+
+  // MARK: Lifecycle
+
+  public init() {
+    cache.countLimit = Self.defaultCacheCountLimit
+  }
+
+  // MARK: Public
+
+  /// The global shared Cache.
+  public static let sharedCache = DotLottieCache()
+
+  /// The size of the cache.
+  public var cacheSize = defaultCacheCountLimit {
+    didSet {
+      cache.countLimit = cacheSize
+    }
+  }
+
+  /// Clears the Cache.
+  public func clearCache() {
+    cache.removeAllValues()
+  }
+
+  public func file(forKey key: String) -> DotLottieFile? {
+    cache.value(forKey: key)
+  }
+
+  public func setFile(_ lottie: DotLottieFile, forKey key: String) {
+    cache.setValue(lottie, 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 var cache = LRUCache<String, DotLottieFile>()
+
+}
+
+// MARK: @unchecked Sendable
+
+// DotLottieCacheProvider has a Sendable requirement, but we can't
+// redesign DotLottieCache to be properly Sendable without making breaking changes.
+// swiftlint:disable:next no_unchecked_sendable
+extension DotLottieCache: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Public/DotLottie/Cache/DotLottieCacheProvider.swift

@@ -0,0 +1,21 @@
+//
+//  DotLottieCacheProvider.swift
+//  Lottie
+//
+//  Created by Evandro Hoffmann on 20/10/22.
+//
+
+/// `DotLottieCacheProvider` is a protocol that describes a DotLottie Cache.
+/// DotLottie Cache is used when loading `DotLottie` models. Using a DotLottie Cache
+/// can increase performance when loading an animation multiple times.
+///
+/// Lottie comes with a prebuilt LRU DotLottie Cache.
+public protocol DotLottieCacheProvider: Sendable {
+
+  func file(forKey: String) -> DotLottieFile?
+
+  func setFile(_ lottie: DotLottieFile, forKey: String)
+
+  func clearCache()
+
+}

package/platforms/macos/src/vendor/Lottie/Public/DotLottie/DotLottieConfiguration.swift

@@ -0,0 +1,72 @@
+//
+// DotLottieConfiguration.swift
+// Lottie
+//
+// Created by Evandro Hoffmann on 19/10/22.
+//
+
+// MARK: - DotLottieConfiguration
+
+/// The `DotLottieConfiguration` model holds the presets extracted from DotLottieAnimation
+///  - The presets are used as input to setup `LottieAnimationView` before playing the animation.
+public struct DotLottieConfiguration {
+
+  // MARK: Public
+
+  /// id of the animation
+  public var id: String
+
+  /// Loop behavior of animation
+  public var loopMode: LottieLoopMode
+
+  /// Playback speed of animation
+  public var speed: Double
+
+  /// Animation Image Provider
+  public var imageProvider: AnimationImageProvider? {
+    dotLottieImageProvider
+  }
+
+  // MARK: Internal
+
+  /// The underlying `DotLottieImageProvider` used by this dotLottie animation
+  var dotLottieImageProvider: DotLottieImageProvider?
+}
+
+// MARK: - DotLottieConfigurationComponents
+
+/// Components of the `DotLottieConfiguration` to apply to the `LottieAnimationView`.
+///  - When using `LottieView`, if the component is selected to be applied it will
+///    override any value provided via other `LottieView` APIs.
+public struct DotLottieConfigurationComponents: OptionSet {
+
+  // MARK: Lifecycle
+
+  public init(rawValue: Int) {
+    self.rawValue = rawValue
+  }
+
+  // MARK: Public
+
+  /// `DotLottieConfiguration.imageProvider` will be applied to the `LottieAnimationView`
+  ///  - When using `LottieView`, the image provider from the dotLottie animation will override
+  ///    the image provider applied manually using `LottieView.imageProvider(...)`.
+  public static let imageProvider = DotLottieConfigurationComponents(rawValue: 1 << 0)
+
+  /// `DotLottieConfigurationMode.loopMode` will be applied to the `LottieAnimationView`.
+  ///  - When using `LottieView`, the loop mode from the dotLottie animation will override
+  ///    the loopMode applied by any playback method.
+  public static let loopMode = DotLottieConfigurationComponents(rawValue: 1 << 1)
+
+  /// `DotLottieConfigurationMode.speed` will be applied to the `LottieAnimationView`.
+  ///  - When using `LottieView`, the speed from the dotLottie animation will override
+  ///    the speed applied manually using `LottieView.animationSpeed(...)`.
+  public static let animationSpeed = DotLottieConfigurationComponents(rawValue: 1 << 2)
+
+  public static let all: DotLottieConfigurationComponents = [.imageProvider, .loopMode, .animationSpeed]
+
+  public static let none: DotLottieConfigurationComponents = []
+
+  public let rawValue: Int
+
+}

package/platforms/macos/src/vendor/Lottie/Public/DotLottie/DotLottieFile.swift

@@ -0,0 +1,186 @@
+//
+// DotLottie.swift
+// Lottie
+//
+// Created by Evandro Harrison Hoffmann on 27/06/2020.
+//
+
+import Foundation
+
+// MARK: - DotLottieFile
+
+/// Detailed .lottie file structure
+public final class DotLottieFile {
+
+  // MARK: Lifecycle
+
+  /// Loads `DotLottie` from `Data` object containing a compressed animation.
+  ///
+  /// - Parameters:
+  ///  - data: Data of .lottie file
+  ///  - filename: Name of .lottie file
+  ///  - Returns: Deserialized `DotLottie`. Optional.
+  init(data: Data, filename: String) throws {
+    fileUrl = DotLottieUtils.tempDirectoryURL.appendingPathComponent(filename.asFilename())
+    try decompress(data: data, to: fileUrl)
+  }
+
+  // MARK: Public
+
+  /// Definition for a single animation within a `DotLottieFile`
+  public struct Animation {
+    public let animation: LottieAnimation
+    public let configuration: DotLottieConfiguration
+  }
+
+  /// List of `LottieAnimation` in the file
+  public private(set) var animations = [Animation]()
+
+  // MARK: Internal
+
+  /// Image provider for animations
+  private(set) var imageProvider: DotLottieImageProvider?
+
+  /// Animations folder url
+  ///
+  /// - Parameters:
+  ///  - version: version of .lottie file
+  func animationsUrl(for version: String?) -> URL {
+    switch Int(version ?? "1") ?? 1 {
+    case 2...:
+      fileUrl.appendingPathComponent("a")
+    default:
+      fileUrl.appendingPathComponent("animations")
+    }
+  }
+
+  /// All files in animations folder
+  ///
+  /// - Parameters:
+  ///  - version: version of .lottie file
+  func animationUrls(for version: String?) -> [URL] {
+    FileManager.default.urls(for: animationsUrl(for: version)) ?? []
+  }
+
+  /// Images folder url
+  ///
+  /// - Parameters:
+  ///  - version: version of .lottie file
+  func imagesUrl(for version: String?) -> URL {
+    switch Int(version ?? "1") ?? 1 {
+    case 2...:
+      fileUrl.appendingPathComponent("i")
+    default:
+      fileUrl.appendingPathComponent("images")
+    }
+  }
+
+  /// All images in images folder
+  ///
+  /// - Parameters:
+  ///  - version: version of .lottie file
+  func imageUrls(for version: String?) -> [URL] {
+    FileManager.default.urls(for: imagesUrl(for: version)) ?? []
+  }
+
+  /// The `LottieAnimation` and `DotLottieConfiguration` for the given animation ID in this file
+  func animation(for id: String? = nil) -> DotLottieFile.Animation? {
+    if let id {
+      animations.first(where: { $0.configuration.id == id })
+    } else {
+      animations.first
+    }
+  }
+
+  /// The `LottieAnimation` and `DotLottieConfiguration` for the given animation index in this file
+  func animation(at index: Int) -> DotLottieFile.Animation? {
+    guard index < animations.count else { return nil }
+    return animations[index]
+  }
+
+  // MARK: Private
+
+  private static let manifestFileName = "manifest.json"
+
+  private let fileUrl: URL
+
+  /// Decompresses .lottie file from `URL` and saves to local temp folder
+  ///
+  /// - Parameters:
+  ///  - url: url to .lottie file
+  ///  - destinationURL: url to destination of decompression contents
+  private func decompress(from url: URL, to destinationURL: URL) throws {
+    try? FileManager.default.removeItem(at: destinationURL)
+    try FileManager.default.createDirectory(at: destinationURL, withIntermediateDirectories: true, attributes: nil)
+    try FileManager.default.unzipItem(at: url, to: destinationURL)
+    try loadContent()
+    try? FileManager.default.removeItem(at: destinationURL)
+    try? FileManager.default.removeItem(at: url)
+  }
+
+  /// Decompresses .lottie file from `Data` and saves to local temp folder
+  ///
+  /// - Parameters:
+  ///  - url: url to .lottie file
+  ///  - destinationURL: url to destination of decompression contents
+  private func decompress(data: Data, to destinationURL: URL) throws {
+    let url = destinationURL.appendingPathExtension("lottie")
+    try FileManager.default.createDirectory(at: destinationURL, withIntermediateDirectories: true, attributes: nil)
+    try data.write(to: url)
+    try decompress(from: url, to: destinationURL)
+  }
+
+  /// Loads file content to memory
+  private func loadContent() throws {
+    let manifest = try loadManifest()
+
+    imageProvider = DotLottieImageProvider(filepath: imagesUrl(for: manifest.version))
+
+    animations = try manifest.animations.map { dotLottieAnimation in
+      let animation = try dotLottieAnimation.animation(url: animationsUrl(for: manifest.version))
+      let configuration = DotLottieConfiguration(
+        id: dotLottieAnimation.id,
+        loopMode: dotLottieAnimation.loopMode,
+        speed: dotLottieAnimation.animationSpeed,
+        dotLottieImageProvider: imageProvider
+      )
+
+      return DotLottieFile.Animation(
+        animation: animation,
+        configuration: configuration
+      )
+    }
+  }
+
+  private func loadManifest() throws -> DotLottieManifest {
+    let path = fileUrl.appendingPathComponent(DotLottieFile.manifestFileName)
+    return try DotLottieManifest.load(from: path)
+  }
+}
+
+extension String {
+
+  // MARK: Fileprivate
+
+  fileprivate func asFilename() -> String {
+    lastPathComponent().removingPathExtension()
+  }
+
+  // MARK: Private
+
+  private func lastPathComponent() -> String {
+    (self as NSString).lastPathComponent
+  }
+
+  private func removingPathExtension() -> String {
+    (self as NSString).deletingPathExtension
+  }
+}
+
+// MARK: - DotLottieFile + @unchecked Sendable
+
+// Mark `DotLottieFile` as `@unchecked Sendable` to allow it to be used when strict concurrency is enabled.
+// In the future, it may be necessary to make changes to the internal implementation of `DotLottieFile`
+// to make it truly thread-safe.
+// swiftlint:disable:next no_unchecked_sendable
+extension DotLottieFile: @unchecked Sendable { }