@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Public/Animation/LottieAnimationViewInitializers.swift

@@ -0,0 +1,226 @@
+//
+//  AnimationViewInitializers.swift
+//  lottie-swift-iOS
+//
+//  Created by Brandon Withrow on 2/6/19.
+//
+
+import Foundation
+
+extension LottieAnimationView {
+
+  // MARK: Lifecycle
+
+  /// Loads a Lottie animation from a JSON file in the supplied bundle.
+  ///
+  /// - Parameter name: The string name of the lottie animation with no file extension provided.
+  /// - Parameter bundle: The bundle in which the animation is located. Defaults to the Main bundle.
+  /// - Parameter subdirectory: A subdirectory in the bundle in which the animation is located. Optional.
+  /// - Parameter imageProvider: An image provider for the animation's image data.
+  /// If none is supplied Lottie will search in the supplied bundle for images.
+  public convenience init(
+    name: String,
+    bundle: Bundle = Bundle.main,
+    subdirectory: String? = nil,
+    imageProvider: AnimationImageProvider? = nil,
+    animationCache: AnimationCacheProvider? = LottieAnimationCache.shared,
+    configuration: LottieConfiguration = .shared
+  ) {
+    let animation = LottieAnimation.named(name, bundle: bundle, subdirectory: subdirectory, animationCache: animationCache)
+    let provider = imageProvider ?? BundleImageProvider(bundle: bundle, searchPath: nil)
+    self.init(animation: animation, imageProvider: provider, configuration: configuration)
+  }
+
+  /// Loads a Lottie animation from a JSON file in a specific path on disk.
+  ///
+  /// - Parameter name: The absolute path of the Lottie Animation.
+  /// - Parameter imageProvider: An image provider for the animation's image data.
+  /// If none is supplied Lottie will search in the supplied filepath for images.
+  public convenience init(
+    filePath: String,
+    imageProvider: AnimationImageProvider? = nil,
+    animationCache: AnimationCacheProvider? = LottieAnimationCache.shared,
+    configuration: LottieConfiguration = .shared
+  ) {
+    let animation = LottieAnimation.filepath(filePath, animationCache: animationCache)
+    let provider = imageProvider ??
+      FilepathImageProvider(filepath: URL(fileURLWithPath: filePath).deletingLastPathComponent().path)
+    self.init(animation: animation, imageProvider: provider, configuration: configuration)
+  }
+
+  /// Loads a Lottie animation asynchronously from the URL
+  ///
+  /// - Parameter url: The url to load the animation from.
+  /// - Parameter imageProvider: An image provider for the animation's image data.
+  /// If none is supplied Lottie will search in the main bundle for images.
+  /// - Parameter session: The `LottieURLSession` used to load the animation. Defaults to `LottieConfiguration.defaultURLSession`.
+  /// - Parameter closure: A closure to be called when the animation has loaded.
+  public convenience init(
+    url: URL,
+    imageProvider: AnimationImageProvider? = nil,
+    session: LottieURLSession = LottieConfiguration.defaultURLSession,
+    closure: @escaping LottieAnimationView.DownloadClosure,
+    animationCache: AnimationCacheProvider? = LottieAnimationCache.shared,
+    configuration: LottieConfiguration = .shared
+  ) {
+    if let animationCache, let animation = animationCache.animation(forKey: url.absoluteString) {
+      self.init(animation: animation, imageProvider: imageProvider, configuration: configuration)
+      closure(nil)
+    } else {
+      self.init(animation: nil, imageProvider: imageProvider, configuration: configuration)
+
+      LottieAnimation.loadedFrom(url: url, session: session, closure: { animation in
+        if let animation {
+          self.animation = animation
+          closure(nil)
+        } else {
+          closure(LottieDownloadError.downloadFailed)
+        }
+      }, animationCache: animationCache)
+    }
+  }
+
+  /// Loads a Lottie animation from a JSON file located in the Asset catalog of the supplied bundle.
+  /// - Parameter name: The string name of the lottie animation in the asset catalog.
+  /// - Parameter bundle: The bundle in which the animation is located.
+  /// Defaults to the Main bundle.
+  /// - Parameter imageProvider: An image provider for the animation's image data.
+  /// If none is supplied Lottie will search in the supplied bundle for images.
+  public convenience init(
+    asset name: String,
+    bundle: Bundle = Bundle.main,
+    imageProvider: AnimationImageProvider? = nil,
+    animationCache: AnimationCacheProvider? = LottieAnimationCache.shared,
+    configuration: LottieConfiguration = .shared
+  ) {
+    let animation = LottieAnimation.asset(name, bundle: bundle, animationCache: animationCache)
+    let provider = imageProvider ?? BundleImageProvider(bundle: bundle, searchPath: nil)
+    self.init(animation: animation, imageProvider: provider, configuration: configuration)
+  }
+
+  /// Loads a Lottie animation from a .lottie file in the supplied bundle.
+  ///
+  /// - Parameter dotLottieName: The name of the lottie file without the lottie extension. EG "StarAnimation"
+  /// - Parameter bundle: The bundle in which the lottie is located. Defaults to `Bundle.main`
+  /// - Parameter subdirectory: A subdirectory in the bundle in which the lottie is located. Optional.
+  /// - Parameter animationId: Animation id to play. Optional
+  /// - Parameter completion: A closure that is called when the .lottie file is finished loading
+  /// Defaults to first animation in file
+  public convenience init(
+    dotLottieName name: String,
+    bundle: Bundle = Bundle.main,
+    subdirectory: String? = nil,
+    animationId: String? = nil,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    configuration: LottieConfiguration = .shared,
+    completion: ((LottieAnimationView, Error?) -> Void)? = nil
+  ) {
+    self.init(dotLottie: nil, animationId: animationId, configuration: configuration)
+    DotLottieFile.named(name, bundle: bundle, subdirectory: subdirectory, dotLottieCache: dotLottieCache) { result in
+      switch result {
+      case .success(let dotLottieFile):
+        self.loadAnimation(animationId, from: dotLottieFile)
+        completion?(self, nil)
+
+      case .failure(let error):
+        completion?(self, error)
+      }
+    }
+  }
+
+  /// Loads a Lottie from a .lottie file in a specific path on disk.
+  ///
+  /// - Parameter dotLottieFilePath: The absolute path of the Lottie file.
+  /// - Parameter animationId: Animation id to play. Optional
+  /// - Parameter completion: A closure that is called when the .lottie file is finished loading
+  /// Defaults to first animation in file
+  public convenience init(
+    dotLottieFilePath filePath: String,
+    animationId: String? = nil,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    configuration: LottieConfiguration = .shared,
+    completion: ((LottieAnimationView, Error?) -> Void)? = nil
+  ) {
+    self.init(dotLottie: nil, animationId: animationId, configuration: configuration)
+    DotLottieFile.loadedFrom(filepath: filePath, dotLottieCache: dotLottieCache) { result in
+      switch result {
+      case .success(let dotLottieFile):
+        self.loadAnimation(animationId, from: dotLottieFile)
+        completion?(self, nil)
+
+      case .failure(let error):
+        completion?(self, error)
+      }
+    }
+  }
+
+  /// Loads a Lottie file asynchronously from the URL
+  ///
+  /// - Parameter dotLottieUrl: The url to load the lottie file from.
+  /// - Parameter animationId: Animation id to play. Optional. Defaults to first animation in file.
+  /// - Parameter session: The `LottieURLSession` used to load the animation. Defaults to `LottieConfiguration.defaultURLSession`.
+  /// - Parameter completion: A closure to be called when the animation has loaded.
+  public convenience init(
+    dotLottieUrl url: URL,
+    animationId: String? = nil,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    configuration: LottieConfiguration = .shared,
+    session: LottieURLSession = LottieConfiguration.defaultURLSession,
+    completion: ((LottieAnimationView, Error?) -> Void)? = nil
+  ) {
+    if let dotLottieCache, let lottie = dotLottieCache.file(forKey: url.absoluteString) {
+      self.init(dotLottie: lottie, animationId: animationId, configuration: configuration)
+      completion?(self, nil)
+    } else {
+      self.init(dotLottie: nil, configuration: configuration)
+      DotLottieFile.loadedFrom(url: url, session: session, dotLottieCache: dotLottieCache) { result in
+        switch result {
+        case .success(let lottie):
+          self.loadAnimation(animationId, from: lottie)
+          completion?(self, nil)
+
+        case .failure(let error):
+          completion?(self, error)
+        }
+      }
+    }
+  }
+
+  /// Loads a Lottie from a .lottie file located in the Asset catalog of the supplied bundle.
+  /// - Parameter name: The string name of the lottie file in the asset catalog.
+  /// - Parameter bundle: The bundle in which the file is located. Defaults to the Main bundle.
+  /// - Parameter animationId: Animation id to play. Optional
+  /// - Parameter completion: A closure that is called when the .lottie file is finished loading
+  /// Defaults to first animation in file
+  public convenience init(
+    dotLottieAsset name: String,
+    bundle: Bundle = Bundle.main,
+    animationId: String? = nil,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    configuration: LottieConfiguration = .shared,
+    completion: ((LottieAnimationView, Error?) -> Void)? = nil
+  ) {
+    self.init(dotLottie: nil, animationId: animationId, configuration: configuration)
+    DotLottieFile.asset(named: name, bundle: bundle, dotLottieCache: dotLottieCache) { result in
+      switch result {
+      case .success(let dotLottieFile):
+        self.loadAnimation(animationId, from: dotLottieFile)
+        completion?(self, nil)
+
+      case .failure(let error):
+        completion?(self, error)
+      }
+    }
+  }
+
+  // MARK: Public
+
+  public typealias DownloadClosure = (Error?) -> Void
+
+}
+
+// MARK: - LottieDownloadError
+
+enum LottieDownloadError: Error {
+  case downloadFailed
+}

package/platforms/macos/src/vendor/Lottie/Public/Animation/LottiePlaybackMode.swift

@@ -0,0 +1,266 @@
+// Created by Cal Stephens on 8/3/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+import Foundation
+
+// MARK: - LottiePlaybackMode
+
+/// Configuration for how a Lottie animation should be played
+public enum LottiePlaybackMode: Hashable {
+
+  /// The animation is paused at the given state (e.g. paused at a specific frame)
+  case paused(at: PausedState)
+
+  /// The animation is playing using the given playback mode (e.g. looping from the start to the end)
+  case playing(_ mode: PlaybackMode)
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.paused(at:)", message: "Will be removed in a future major release.")
+  case progress(_ progress: AnimationProgressTime)
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.paused(at:)", message: "Will be removed in a future major release.")
+  case frame(_ frame: AnimationFrameTime)
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.paused(at:)", message: "Will be removed in a future major release.")
+  case time(_ time: TimeInterval)
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.paused(at:)", message: "Will be removed in a future major release.")
+  case pause
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.playing(_:)", message: "Will be removed in a future major release.")
+  case fromProgress(_ fromProgress: AnimationProgressTime?, toProgress: AnimationProgressTime, loopMode: LottieLoopMode)
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.playing(_:)", message: "Will be removed in a future major release.")
+  case fromFrame(_ fromFrame: AnimationFrameTime?, toFrame: AnimationFrameTime, loopMode: LottieLoopMode)
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.playing(_:)", message: "Will be removed in a future major release.")
+  case fromMarker(
+    _ fromMarker: String?,
+    toMarker: String,
+    playEndMarkerFrame: Bool = true,
+    loopMode: LottieLoopMode
+  )
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.playing(_:)", message: "Will be removed in a future major release.")
+  case marker(_ marker: String, loopMode: LottieLoopMode)
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.playing(_:)", message: "Will be removed in a future major release.")
+  case markers(_ markers: [String])
+
+  // MARK: Public
+
+  public enum PausedState: Hashable {
+    /// Any existing animation will be paused at the current frame.
+    case currentFrame
+
+    /// The animation is paused at the given progress value,
+    /// a value between 0.0 (0% progress) and 1.0 (100% progress).
+    case progress(_ progress: AnimationProgressTime)
+
+    /// The animation is paused at the given frame of the animation.
+    case frame(_ frame: AnimationFrameTime)
+
+    /// The animation is paused at the given time value from the start of the animation.
+    case time(_ time: TimeInterval)
+
+    /// Pauses the animation at a given marker and position
+    case marker(_ name: String, position: LottieMarkerPosition = .start)
+  }
+
+  public enum PlaybackMode: Hashable {
+    /// Plays the animation from a progress (0-1) to a progress (0-1).
+    /// - Parameter fromProgress: The start progress of the animation. If `nil` the animation will start at the current progress.
+    /// - Parameter toProgress: The end progress of the animation.
+    /// - Parameter loopMode: The loop behavior of the animation.
+    case fromProgress(
+      _ fromProgress: AnimationProgressTime?,
+      toProgress: AnimationProgressTime,
+      loopMode: LottieLoopMode
+    )
+
+    /// The animation plays from the given `fromFrame` to the given `toFrame`.
+    /// - Parameter fromFrame: The start frame of the animation. If `nil` the animation will start at the current frame.
+    /// - Parameter toFrame: The end frame of the animation.
+    /// - Parameter loopMode: The loop behavior of the animation.
+    case fromFrame(
+      _ fromFrame: AnimationFrameTime?,
+      toFrame: AnimationFrameTime,
+      loopMode: LottieLoopMode
+    )
+
+    /// Plays the animation from a named marker to another marker.
+    ///
+    /// Markers are point in time that are encoded into the Animation data and assigned a name.
+    ///
+    /// NOTE: If markers are not found the play command will exit.
+    ///
+    /// - Parameter fromMarker: The start marker for the animation playback. If `nil` the
+    /// animation will start at the current progress.
+    /// - Parameter toMarker: The end marker for the animation playback.
+    /// - Parameter playEndMarkerFrame: A flag to determine whether or not to play the frame of the end marker. If the
+    /// end marker represents the end of the section to play, it should be to true. If the provided end marker
+    /// represents the beginning of the next section, it should be false.
+    /// - Parameter loopMode: The loop behavior of the animation.
+    case fromMarker(
+      _ fromMarker: String?,
+      toMarker: String,
+      playEndMarkerFrame: Bool = true,
+      loopMode: LottieLoopMode
+    )
+
+    /// Plays the animation from a named marker to the end of the marker's duration.
+    ///
+    /// A marker is a point in time with an associated duration that is encoded into the
+    /// animation data and assigned a name.
+    ///
+    /// NOTE: If marker is not found the play command will exit.
+    ///
+    /// - Parameter marker: The start marker for the animation playback.
+    /// - Parameter loopMode: The loop behavior of the animation.
+    case marker(
+      _ marker: String,
+      loopMode: LottieLoopMode
+    )
+
+    /// Plays the given markers sequentially in order.
+    ///
+    /// A marker is a point in time with an associated duration that is encoded into the
+    /// animation data and assigned a name. Multiple markers can be played sequentially
+    /// to create programmable animations.
+    ///
+    /// If a marker is not found, it will be skipped.
+    ///
+    /// If a marker doesn't have a duration value, it will play with a duration of 0
+    /// (effectively being skipped).
+    ///
+    /// If another animation is played (by calling any `play` method) while this
+    /// marker sequence is playing, the marker sequence will be cancelled.
+    ///
+    /// - Parameter markers: The list of markers to play sequentially.
+    case markers(_ markers: [String])
+  }
+
+}
+
+extension LottiePlaybackMode {
+  public static var paused: Self {
+    .paused(at: .currentFrame)
+  }
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.playing(_:)", message: "Will be removed in a future major release.")
+  public static func toProgress(_ toProgress: AnimationProgressTime, loopMode: LottieLoopMode) -> LottiePlaybackMode {
+    .playing(.fromProgress(nil, toProgress: toProgress, loopMode: loopMode))
+  }
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.playing(_:)", message: "Will be removed in a future major release.")
+  public static func toFrame(_ toFrame: AnimationFrameTime, loopMode: LottieLoopMode) -> LottiePlaybackMode {
+    .playing(.fromFrame(nil, toFrame: toFrame, loopMode: loopMode))
+  }
+
+  @available(*, deprecated, renamed: "LottiePlaybackMode.playing(_:)", message: "Will be removed in a future major release.")
+  public static func toMarker(
+    _ toMarker: String,
+    playEndMarkerFrame: Bool = true,
+    loopMode: LottieLoopMode
+  ) -> LottiePlaybackMode {
+    .playing(.fromMarker(nil, toMarker: toMarker, playEndMarkerFrame: playEndMarkerFrame, loopMode: loopMode))
+  }
+}
+
+extension LottiePlaybackMode.PlaybackMode {
+  /// Plays the animation from the current progress to a progress value (0-1).
+  /// - Parameter toProgress: The end progress of the animation.
+  /// - Parameter loopMode: The loop behavior of the animation.
+  public static func toProgress(_ toProgress: AnimationProgressTime, loopMode: LottieLoopMode) -> Self {
+    .fromProgress(nil, toProgress: toProgress, loopMode: loopMode)
+  }
+
+  /// Plays the animation from the current frame to the given frame.
+  /// - Parameter toFrame: The end frame of the animation.
+  /// - Parameter loopMode: The loop behavior of the animation.
+  public static func toFrame(_ toFrame: AnimationFrameTime, loopMode: LottieLoopMode) -> Self {
+    .fromFrame(nil, toFrame: toFrame, loopMode: loopMode)
+  }
+
+  /// Plays the animation from the current frame to some marker.
+  ///
+  /// Markers are point in time that are encoded into the Animation data and assigned a name.
+  ///
+  /// NOTE: If the marker isn't found the play command will exit.
+  ///
+  /// - Parameter toMarker: The end marker for the animation playback.
+  /// - Parameter playEndMarkerFrame: A flag to determine whether or not to play the frame of the end marker. If the
+  /// end marker represents the end of the section to play, it should be to true. If the provided end marker
+  /// represents the beginning of the next section, it should be false.
+  /// - Parameter loopMode: The loop behavior of the animation.
+  public static func toMarker(
+    _ toMarker: String,
+    playEndMarkerFrame: Bool = true,
+    loopMode: LottieLoopMode
+  ) -> Self {
+    .fromMarker(nil, toMarker: toMarker, playEndMarkerFrame: playEndMarkerFrame, loopMode: loopMode)
+  }
+}
+
+// MARK: - LottieMarkerPosition
+
+/// The position within a marker.
+public enum LottieMarkerPosition: Hashable {
+  case start
+  case end
+}
+
+extension LottiePlaybackMode {
+  /// Returns a copy of this `PlaybackMode` with the `LottieLoopMode` updated to the given value
+  func loopMode(_ updatedLoopMode: LottieLoopMode) -> LottiePlaybackMode {
+    switch self {
+    case .playing(let playbackMode):
+      .playing(playbackMode.loopMode(updatedLoopMode))
+
+    case .fromProgress(let fromProgress, toProgress: let toProgress, _):
+      .playing(.fromProgress(
+        fromProgress,
+        toProgress: toProgress,
+        loopMode: updatedLoopMode
+      ))
+
+    case .fromFrame(let fromFrame, toFrame: let toFrame, _):
+      .playing(.fromFrame(
+        fromFrame,
+        toFrame: toFrame,
+        loopMode: updatedLoopMode
+      ))
+
+    case .fromMarker(let fromMarker, let toMarker, let playEndMarkerFrame, _):
+      .playing(.fromMarker(
+        fromMarker,
+        toMarker: toMarker,
+        playEndMarkerFrame: playEndMarkerFrame,
+        loopMode: updatedLoopMode
+      ))
+
+    case .marker(let marker, _):
+      .playing(.marker(marker, loopMode: updatedLoopMode))
+
+    case .pause, .paused, .progress(_), .time(_), .frame(_), .markers:
+      self
+    }
+  }
+}
+
+extension LottiePlaybackMode.PlaybackMode {
+  /// Returns a copy of this `PlaybackMode` with the `LottieLoopMode` updated to the given value
+  func loopMode(_ updatedLoopMode: LottieLoopMode) -> LottiePlaybackMode.PlaybackMode {
+    switch self {
+    case .fromProgress(let fromProgress, let toProgress, _):
+      .fromProgress(fromProgress, toProgress: toProgress, loopMode: updatedLoopMode)
+    case .fromFrame(let fromFrame, let toFrame, _):
+      .fromFrame(fromFrame, toFrame: toFrame, loopMode: updatedLoopMode)
+    case .fromMarker(let fromMarker, let toMarker, let playEndMarkerFrame, _):
+      .fromMarker(fromMarker, toMarker: toMarker, playEndMarkerFrame: playEndMarkerFrame, loopMode: updatedLoopMode)
+    case .marker(let marker, _):
+      .marker(marker, loopMode: updatedLoopMode)
+    case .markers:
+      self
+    }
+  }
+}