@octane-xplat/lottie 0.9.0 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/Model/Assets/ImageAsset.swift

@@ -0,0 +1,141 @@
+//
+//  ImageAsset.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+import CoreGraphics
+import Foundation
+
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+
+// MARK: - ImageAsset
+
+public final class ImageAsset: Asset {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: ImageAsset.CodingKeys.self)
+    name = try container.decode(String.self, forKey: .name)
+    directory = try container.decode(String.self, forKey: .directory)
+    width = try container.decode(Double.self, forKey: .width)
+    height = try container.decode(Double.self, forKey: .height)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    name = try dictionary.value(for: CodingKeys.name)
+    directory = try dictionary.value(for: CodingKeys.directory)
+    width = try dictionary.value(for: CodingKeys.width)
+    height = try dictionary.value(for: CodingKeys.height)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Public
+
+  /// Image name
+  public let name: String
+
+  /// Image Directory
+  public let directory: String
+
+  /// Image Size
+  public let width: Double
+
+  public let height: Double
+
+  override public func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(name, forKey: .name)
+    try container.encode(directory, forKey: .directory)
+    try container.encode(width, forKey: .width)
+    try container.encode(height, forKey: .height)
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case name = "p"
+    case directory = "u"
+    case width = "w"
+    case height = "h"
+  }
+}
+
+extension Data {
+
+  // MARK: Lifecycle
+
+  /// Initializes `Data` from an `ImageAsset`.
+  ///
+  /// Returns nil when the input is not recognized as valid Data URL.
+  /// - parameter imageAsset: The image asset that contains Data URL.
+  init?(imageAsset: ImageAsset) {
+    self.init(dataString: imageAsset.name)
+  }
+
+  /// Initializes `Data` from a [Data URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs) String.
+  ///
+  /// Returns nil when the input is not recognized as valid Data URL.
+  /// - parameter dataString: The data string to parse.
+  /// - parameter options: Options for the string parsing. Default value is `[]`.
+  init?(dataString: String, options: DataURLReadOptions = []) {
+    let trimmedDataString = dataString.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard
+      dataString.hasPrefix("data:"),
+      let url = URL(string: trimmedDataString)
+    else {
+      return nil
+    }
+    // The code below is needed because Data(contentsOf:) floods logs
+    // with messages since url doesn't have a host. This only fixes flooding logs
+    // when data inside Data URL is base64 encoded.
+    if
+      let base64Range = trimmedDataString.range(of: ";base64,"),
+      !options.contains(DataURLReadOptions.legacy)
+    {
+      let encodedString = String(trimmedDataString[base64Range.upperBound...])
+      self.init(base64Encoded: encodedString)
+    } else {
+      try? self.init(contentsOf: url)
+    }
+  }
+
+  // MARK: Internal
+
+  struct DataURLReadOptions: OptionSet {
+    /// Will read Data URL using Data(contentsOf:)
+    static let legacy = DataURLReadOptions(rawValue: 1 << 0)
+
+    let rawValue: Int
+
+  }
+
+}
+
+extension ImageAsset {
+  /// A `CGImage` loaded from this asset if represented using a Base 64 encoding
+  var base64Image: CGImage? {
+    guard let data = Data(imageAsset: self) else { return nil }
+
+    #if canImport(UIKit)
+    return UIImage(data: data)?.cgImage
+    #elseif canImport(AppKit)
+    return NSImage(data: data)?.lottie_CGImage
+    #endif
+  }
+}
+
+// MARK: - ImageAsset + @unchecked Sendable
+
+/// `ImageAsset` inherits `@unchecked Sendable` from `Asset` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension ImageAsset: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/Assets/PrecompAsset.swift

@@ -0,0 +1,47 @@
+//
+//  PrecompAsset.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+// MARK: - PrecompAsset
+
+final class PrecompAsset: Asset {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: PrecompAsset.CodingKeys.self)
+    layers = try container.decode([LayerModel].self, ofFamily: LayerType.self, forKey: .layers)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let layerDictionaries: [[String: Any]] = try dictionary.value(for: CodingKeys.layers)
+    layers = try [LayerModel].fromDictionaries(layerDictionaries)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case layers
+  }
+
+  /// Layers of the precomp
+  let layers: [LayerModel]
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(layers, forKey: .layers)
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `PrecompAsset` inherits `@unchecked Sendable` from `Asset` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension PrecompAsset: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/DictionaryInitializable.swift

@@ -0,0 +1,73 @@
+//
+//  DictionaryInitializable.swift
+//  Lottie
+//
+//  Created by Marcelo Fabri on 5/5/22.
+//
+
+// MARK: - InitializableError
+
+enum InitializableError: Error {
+  case invalidInput(file: StaticString = #fileID, line: UInt = #line)
+}
+
+// MARK: - DictionaryInitializable
+
+protocol DictionaryInitializable {
+
+  init(dictionary: [String: Any]) throws
+
+}
+
+// MARK: - AnyInitializable
+
+protocol AnyInitializable {
+
+  init(value: Any) throws
+
+}
+
+extension Dictionary {
+
+  @_disfavoredOverload
+  func value<T, KeyType: RawRepresentable>(
+    for key: KeyType,
+    file: StaticString = #fileID,
+    line: UInt = #line
+  ) throws -> T where KeyType.RawValue == Key {
+    guard let value = self[key.rawValue] as? T else {
+      throw InitializableError.invalidInput(file: file, line: line)
+    }
+    return value
+  }
+
+  func value<T: AnyInitializable, KeyType: RawRepresentable>(
+    for key: KeyType,
+    file: StaticString = #fileID,
+    line: UInt = #line
+  ) throws -> T where KeyType.RawValue == Key {
+    if let value = self[key.rawValue] as? T {
+      return value
+    }
+
+    if let value = self[key.rawValue] {
+      return try T(value: value)
+    }
+
+    throw InitializableError.invalidInput(file: file, line: line)
+  }
+
+}
+
+// MARK: - [Double] + AnyInitializable
+
+extension [Double]: AnyInitializable {
+
+  init(value: Any) throws {
+    guard let array = value as? [Double] else {
+      throw InitializableError.invalidInput()
+    }
+    self = array
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/DotLottie/DotLottieAnimation.swift

@@ -0,0 +1,57 @@
+//
+// DotLottieAnimation.swift
+// Pods
+//
+// Created by Evandro Harrison Hoffmann on 28/06/2021.
+//
+
+import Foundation
+
+// MARK: - DotLottieAnimation
+
+struct DotLottieAnimation: Codable {
+  /// Id of Animation
+  var id: String
+
+  /// Loop enabled
+  var loop: Bool? = false
+
+  /// Animation Playback Speed
+  var speed: Double? = 1
+
+  /// 1 or -1
+  var direction: Int? = 1
+
+  /// mode - "bounce" | "normal"
+  var mode: DotLottieAnimationMode? = .normal
+
+  /// Loop mode for animation
+  var loopMode: LottieLoopMode {
+    switch mode {
+    case .bounce:
+      .autoReverse
+    case .normal, nil:
+      (loop ?? false) ? .loop : .playOnce
+    }
+  }
+
+  /// Animation speed
+  var animationSpeed: Double {
+    (speed ?? 1) * Double(direction ?? 1)
+  }
+
+  /// Loads `LottieAnimation` from `animationUrl`
+  /// - Returns: Deserialized `LottieAnimation`. Optional.
+  func animation(url: URL) throws -> LottieAnimation {
+    let animationUrl = url.appendingPathComponent("\(id).json")
+    let data = try Data(contentsOf: animationUrl)
+    return try LottieAnimation.from(data: data)
+  }
+}
+
+// MARK: - DotLottieAnimationMode
+
+enum DotLottieAnimationMode: String, Codable {
+  case normal
+  case bounce
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/DotLottie/DotLottieImageProvider.swift

@@ -0,0 +1,89 @@
+//
+//  DotLottieImageProvider.swift
+//  Lottie
+//
+//  Created by Evandro Hoffmann on 20/10/22.
+//
+
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+
+// MARK: - DotLottieImageProvider
+
+/// An image provider that loads the images from a DotLottieFile into memory
+final class DotLottieImageProvider: AnimationImageProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes an image provider with a specific filepath.
+  ///
+  /// - Parameter filepath: The absolute filepath containing the images.
+  ///
+  convenience init?(filepath: String) {
+    self.init(filepath: URL(fileURLWithPath: filepath))
+  }
+
+  init?(filepath: URL) {
+    guard filepath.urls.count > 0 else { return nil }
+    self.filepath = filepath
+    loadImages()
+  }
+
+  // MARK: Internal
+
+  let filepath: URL
+
+  func imageForAsset(asset: ImageAsset) -> CGImage? {
+    if let base64Image = asset.base64Image {
+      return base64Image
+    }
+
+    return images[asset.name]
+  }
+
+  // MARK: Private
+
+  /// This is intentionally a Dictionary instead of an NSCache. Files from a decompressed dotLottie zip archive
+  /// are only valid are deleted after being read into memory. If we used an NSCache then the OS could evict
+  /// the cache entries when under memory pressure, and we would have no way to reload them later.
+  ///  - Ideally we would have a way to remove image data when under memory pressure, but this would require
+  ///    re-decompressing the dotLottie file when requesting an image that has been loaded but then removed.
+  private var images = [String: CGImage]()
+
+  private func loadImages() {
+    for url in filepath.urls {
+      #if canImport(UIKit)
+      if
+        let data = try? Data(contentsOf: url),
+        let image = UIImage(data: data)?.cgImage
+      {
+        images[url.lastPathComponent] = image
+      }
+      #elseif canImport(AppKit)
+      if
+        let data = try? Data(contentsOf: url),
+        let image = NSImage(data: data)?.lottie_CGImage
+      {
+        images[url.lastPathComponent] = image
+      }
+      #endif
+    }
+  }
+
+}
+
+// MARK: Hashable
+
+extension DotLottieImageProvider: Hashable {
+  static func ==(_ lhs: DotLottieImageProvider, _ rhs: DotLottieImageProvider) -> Bool {
+    lhs.filepath == rhs.filepath
+  }
+
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(filepath)
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/DotLottie/DotLottieManifest.swift

@@ -0,0 +1,42 @@
+//
+// DotLottieManifest.swift
+// Lottie
+//
+// Created by Evandro Harrison Hoffmann on 27/06/2020.
+//
+
+import Foundation
+
+/// Manifest model for .lottie File
+struct DotLottieManifest: Codable {
+
+  var animations: [DotLottieAnimation]
+  var version: String?
+  var author: String?
+  var generator: String?
+
+  /// Decodes data to Manifest model
+  /// - Parameter data: Data to decode
+  /// - Throws: Error
+  /// - Returns: .lottie Manifest model
+  static func decode(from data: Data) throws -> DotLottieManifest {
+    try JSONDecoder().decode(DotLottieManifest.self, from: data)
+  }
+
+  /// Loads manifest from given URL
+  /// - Parameter path: URL path to Manifest
+  /// - Returns: Manifest Model
+  static func load(from url: URL) throws -> DotLottieManifest {
+    let data = try Data(contentsOf: url)
+    return try decode(from: data)
+  }
+
+  /// Encodes to data
+  /// - Parameter encoder: JSONEncoder
+  /// - Throws: Error
+  /// - Returns: encoded Data
+  func encode(with encoder: JSONEncoder = JSONEncoder()) throws -> Data {
+    try encoder.encode(self)
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/DotLottie/DotLottieUtils.swift

@@ -0,0 +1,71 @@
+//
+// DotLottieUtils.swift
+// Lottie
+//
+// Created by Evandro Harrison Hoffmann on 27/06/2020.
+//
+
+import Foundation
+
+// MARK: - DotLottieUtils
+
+enum DotLottieUtils {
+  static let dotLottieExtension = "lottie"
+  static let jsonExtension = "json"
+  /// IANA-approved short extension for the `video/lottie+json` media type.
+  /// See https://www.iana.org/assignments/media-types/video/lottie+json
+  /// Treated as an alias for `.json` everywhere a Lottie JSON animation is loaded.
+  static let lotExtension = "lot"
+
+  /// Temp folder to app directory
+  static var tempDirectoryURL: URL {
+    FileManager.default.temporaryDirectory
+  }
+}
+
+extension URL {
+  /// Checks if url is a lottie file
+  var isDotLottie: Bool {
+    pathExtension == DotLottieUtils.dotLottieExtension
+  }
+
+  /// Checks if url is a json file (`.json` or its IANA-registered alias `.lot`)
+  var isJsonFile: Bool {
+    pathExtension == DotLottieUtils.jsonExtension
+      || pathExtension == DotLottieUtils.lotExtension
+  }
+
+  var urls: [URL] {
+    FileManager.default.urls(for: self) ?? []
+  }
+}
+
+extension FileManager {
+  /// Lists urls for all files in a directory
+  /// - Parameters:
+  ///  - url: URL of directory to search
+  ///  - skipsHiddenFiles: If should or not show hidden files
+  /// - Returns: Returns urls of all files matching criteria in the directory
+  func urls(for url: URL, skipsHiddenFiles: Bool = true) -> [URL]? {
+    try? contentsOfDirectory(at: url, includingPropertiesForKeys: nil, options: skipsHiddenFiles ? .skipsHiddenFiles : [])
+  }
+}
+
+// MARK: - DotLottieError
+
+public enum DotLottieError: Error {
+  /// URL response has no data.
+  case noDataLoaded
+  /// Asset with this name was not found in the provided bundle.
+  case assetNotFound(name: String, bundle: Bundle?)
+  /// Animation loading from asset was not supported on macOS 10.10,
+  /// but this error is no longer used.
+  case loadingFromAssetNotSupported
+
+  @available(*, deprecated, message: "Unused")
+  case invalidFileFormat
+  @available(*, deprecated, message: "Unused")
+  case invalidData
+  @available(*, deprecated, message: "Unused")
+  case animationNotAvailable
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/Extensions/Bundle.swift

@@ -0,0 +1,58 @@
+import Foundation
+#if canImport(UIKit)
+import UIKit
+#endif
+
+extension Bundle {
+  func getAnimationData(_ name: String, subdirectory: String? = nil) throws -> Data {
+    // Check for files in the bundle at the given path
+    let name = name.removingJSONSuffix()
+    if let url = url(forResource: name, withExtension: "json", subdirectory: subdirectory) {
+      return try Data(contentsOf: url)
+    }
+    // `.lot` is the IANA-registered short extension for `video/lottie+json` and is
+    // treated as a synonym for `.json` when loading Lottie animations.
+    if let url = url(forResource: name, withExtension: "lot", subdirectory: subdirectory) {
+      return try Data(contentsOf: url)
+    }
+
+    // Check for data assets
+    let assetKey = subdirectory != nil ? "\(subdirectory ?? "")/\(name)" : name
+    return try Data(assetName: assetKey, in: self)
+  }
+
+  func dotLottieData(_ name: String, subdirectory: String? = nil) throws -> Data {
+    // Check for files in the bundle at the given path
+    let name = name.removingDotLottieSuffix()
+    if let url = url(forResource: name, withExtension: "lottie", subdirectory: subdirectory) {
+      return try Data(contentsOf: url)
+    }
+
+    let assetKey = subdirectory != nil ? "\(subdirectory ?? "")/\(name)" : name
+    return try Data(assetName: assetKey, in: self)
+  }
+}
+
+extension String {
+  fileprivate func removingJSONSuffix() -> String {
+    // Allow filenames to be passed with a ".json" extension (or its IANA-registered
+    // synonym ".lot") so the bundle lookup still works when the caller passes the
+    // extension as part of the name. Keeps the behavior from Lottie 2.x for .json
+    // and extends it to .lot per the `video/lottie+json` media type spec.
+    guard hasSuffix(".json") || hasSuffix(".lot") else {
+      return self
+    }
+
+    return (self as NSString).deletingPathExtension
+  }
+
+  fileprivate func removingDotLottieSuffix() -> String {
+    // Allow filenames to be passed with a ".lottie" extension (but not other extensions)
+    // to keep the behavior from Lottie 2.x - instead of failing to load the file
+    guard hasSuffix(".lottie") else {
+      return self
+    }
+
+    return (self as NSString).deletingPathExtension
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/Extensions/KeyedDecodingContainerExtensions.swift

@@ -0,0 +1,71 @@
+// From: https://medium.com/@kewindannerfjordremeczki/swift-4-0-decodable-heterogeneous-collections-ecc0e6b468cf
+
+// MARK: - ClassFamily
+
+/// To support a new class family, create an enum that conforms to this protocol and contains the different types.
+protocol ClassFamily: Decodable {
+  /// The discriminator key.
+  static var discriminator: Discriminator { get }
+
+  /// The "unknown" fallback case if the type discriminator could not be parsed successfully.
+  static var unknown: Self { get }
+
+  /// Returns the class type of the object corresponding to the value.
+  func getType() -> AnyObject.Type
+}
+
+// MARK: - Discriminator
+
+/// Discriminator key enum used to retrieve discriminator fields in JSON payloads.
+enum Discriminator: String, CodingKey {
+  case type = "ty"
+}
+
+extension KeyedDecodingContainer {
+
+  /// Decode a heterogeneous list of objects for a given family.
+  /// - Parameters:
+  ///     - heterogeneousType: The decodable type of the list.
+  ///     - family: The ClassFamily enum for the type family.
+  ///     - key: The CodingKey to look up the list in the current container.
+  /// - Returns: The resulting list of heterogeneousType elements.
+  func decode<T: Decodable, U: ClassFamily>(_: [T].Type, ofFamily family: U.Type, forKey key: K) throws -> [T] {
+    var container = try nestedUnkeyedContainer(forKey: key)
+    var list = [T]()
+    var tmpContainer = container
+    while !container.isAtEnd {
+      let typeContainer = try container.nestedContainer(keyedBy: Discriminator.self)
+      let family: U = (try? typeContainer.decodeIfPresent(U.self, forKey: U.discriminator)) ?? .unknown
+      if let type = family.getType() as? T.Type {
+        list.append(try tmpContainer.decode(type))
+      }
+    }
+    return list
+  }
+
+  /// Decode a heterogeneous list of objects for a given family if the given key is present.
+  /// - Parameters:
+  ///     - heterogeneousType: The decodable type of the list.
+  ///     - family: The ClassFamily enum for the type family.
+  ///     - key: The CodingKey to look up the list in the current container.
+  /// - Returns: The resulting list of heterogeneousType elements.
+  func decodeIfPresent<T: Decodable, U: ClassFamily>(_: [T].Type, ofFamily family: U.Type, forKey key: K) throws -> [T]? {
+    var container: UnkeyedDecodingContainer
+    do {
+      container = try nestedUnkeyedContainer(forKey: key)
+    } catch {
+      return nil
+    }
+
+    var list = [T]()
+    var tmpContainer = container
+    while !container.isAtEnd {
+      let typeContainer = try container.nestedContainer(keyedBy: Discriminator.self)
+      let family: U = (try? typeContainer.decodeIfPresent(U.self, forKey: U.discriminator)) ?? .unknown
+      if let type = family.getType() as? T.Type {
+        list.append(try tmpContainer.decode(type))
+      }
+    }
+    return list
+  }
+}