@octane-xplat/lottie 0.9.0 → 0.10.0

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

@@ -0,0 +1,386 @@
+//
+//  DotLottieFileHelpers.swift
+//  Lottie
+//
+//  Created by Evandro Hoffmann on 20/10/22.
+//
+
+import Foundation
+
+extension DotLottieFile {
+
+  public enum SynchronouslyBlockingCurrentThread {
+    /// Loads an DotLottie from a specific filepath synchronously. Returns a `Result<DotLottieFile, Error>`
+    /// Please use the asynchronous methods whenever possible. This operation will block the Thread it is running in.
+    ///
+    /// - Parameter filepath: The absolute filepath of the lottie to load. EG "/User/Me/starAnimation.lottie"
+    /// - Parameter dotLottieCache: A cache for holding loaded lotties. Defaults to `LRUDotLottieCache.sharedCache`. Optional.
+    public static func loadedFrom(
+      filepath: String,
+      dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache
+    ) -> Result<DotLottieFile, Error> {
+      LottieLogger.shared.assert(
+        !Thread.isMainThread,
+        "`DotLottieFile.SynchronouslyBlockingCurrentThread` methods shouldn't be called on the main thread."
+      )
+
+      /// Check cache for lottie
+      if
+        let dotLottieCache,
+        let lottie = dotLottieCache.file(forKey: filepath)
+      {
+        return .success(lottie)
+      }
+
+      do {
+        /// Decode the lottie.
+        let url = URL(fileURLWithPath: filepath)
+        let data = try Data(contentsOf: url)
+        let lottie = try DotLottieFile(data: data, filename: url.deletingPathExtension().lastPathComponent)
+        dotLottieCache?.setFile(lottie, forKey: filepath)
+        return .success(lottie)
+      } catch {
+        /// Decoding Error.
+        return .failure(error)
+      }
+    }
+
+    /// Loads a DotLottie model from a bundle by its name synchronously. Returns a `Result<DotLottieFile, Error>`
+    /// Please use the asynchronous methods whenever possible. This operation will block the Thread it is running in.
+    ///
+    /// - Parameter name: 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 dotLottieCache: A cache for holding loaded lotties. Defaults to `LRUDotLottieCache.sharedCache`. Optional.
+    public static func named(
+      _ name: String,
+      bundle: Bundle = Bundle.main,
+      subdirectory: String? = nil,
+      dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache
+    ) -> Result<DotLottieFile, Error> {
+      LottieLogger.shared.assert(
+        !Thread.isMainThread,
+        "`DotLottieFile.SynchronouslyBlockingCurrentThread` methods shouldn't be called on the main thread."
+      )
+
+      /// Create a cache key for the lottie.
+      let cacheKey = bundle.bundlePath + (subdirectory ?? "") + "/" + name
+
+      /// Check cache for lottie
+      if
+        let dotLottieCache,
+        let lottie = dotLottieCache.file(forKey: cacheKey)
+      {
+        return .success(lottie)
+      }
+
+      do {
+        /// Decode animation.
+        let data = try bundle.dotLottieData(name, subdirectory: subdirectory)
+        let lottie = try DotLottieFile(data: data, filename: name)
+        dotLottieCache?.setFile(lottie, forKey: cacheKey)
+        return .success(lottie)
+      } catch {
+        /// Decoding error.
+        LottieLogger.shared.warn("Error when decoding lottie \"\(name)\": \(error)")
+        return .failure(error)
+      }
+    }
+
+    /// Loads an DotLottie from a data synchronously. Returns a `Result<DotLottieFile, Error>`
+    ///
+    /// Please use the asynchronous methods whenever possible. This operation will block the Thread it is running in.
+    ///
+    /// - Parameters:
+    ///   - data: The data(`Foundation.Data`) object to load DotLottie from
+    ///   - filename: The name of the lottie file without the lottie extension. eg. "StarAnimation"
+    public static func loadedFrom(
+      data: Data,
+      filename: String
+    ) -> Result<DotLottieFile, Error> {
+      LottieLogger.shared.assert(
+        !Thread.isMainThread,
+        "`DotLottieFile.SynchronouslyBlockingCurrentThread` methods shouldn't be called on the main thread."
+      )
+
+      do {
+        let dotLottieFile = try DotLottieFile(data: data, filename: filename)
+        return .success(dotLottieFile)
+      } catch {
+        return .failure(error)
+      }
+    }
+  }
+
+  /// Loads a DotLottie model from a bundle by its name. Returns `nil` if a file is not found.
+  ///
+  /// - Parameter name: 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 dotLottieCache: A cache for holding loaded lotties. Defaults to `LRUDotLottieCache.sharedCache`. Optional.
+  public static func named(
+    _ name: String,
+    bundle: Bundle = Bundle.main,
+    subdirectory: String? = nil,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache
+  ) async throws -> DotLottieFile {
+    try await withCheckedThrowingContinuation { continuation in
+      DotLottieFile.named(name, bundle: bundle, subdirectory: subdirectory, dotLottieCache: dotLottieCache) { result in
+        continuation.resume(with: result)
+      }
+    }
+  }
+
+  /// Loads a DotLottie model from a bundle by its name. Returns `nil` if a file is not found.
+  ///
+  /// - Parameter name: 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 dotLottieCache: A cache for holding loaded lotties. Defaults to `LRUDotLottieCache.sharedCache`. Optional.
+  /// - Parameter dispatchQueue: A dispatch queue used to load animations. Defaults to `DispatchQueue.global()`. Optional.
+  /// - Parameter handleResult: A closure to be called when the file has loaded.
+  public static func named(
+    _ name: String,
+    bundle: Bundle = Bundle.main,
+    subdirectory: String? = nil,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    dispatchQueue: DispatchQueue = .dotLottie,
+    handleResult: @escaping (Result<DotLottieFile, Error>) -> Void
+  ) {
+    dispatchQueue.async {
+      let result = SynchronouslyBlockingCurrentThread.named(
+        name,
+        bundle: bundle,
+        subdirectory: subdirectory,
+        dotLottieCache: dotLottieCache
+      )
+
+      DispatchQueue.main.async {
+        handleResult(result)
+      }
+    }
+  }
+
+  /// Loads an DotLottie from a specific filepath.
+  /// - Parameter filepath: The absolute filepath of the lottie to load. EG "/User/Me/starAnimation.lottie"
+  /// - Parameter dotLottieCache: A cache for holding loaded lotties. Defaults to `LRUDotLottieCache.sharedCache`. Optional.
+  public static func loadedFrom(
+    filepath: String,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache
+  ) async throws -> DotLottieFile {
+    try await withCheckedThrowingContinuation { continuation in
+      DotLottieFile.loadedFrom(filepath: filepath, dotLottieCache: dotLottieCache) { result in
+        continuation.resume(with: result)
+      }
+    }
+  }
+
+  /// Loads an DotLottie from a specific filepath.
+  /// - Parameter filepath: The absolute filepath of the lottie to load. EG "/User/Me/starAnimation.lottie"
+  /// - Parameter dotLottieCache: A cache for holding loaded lotties. Defaults to `LRUDotLottieCache.sharedCache`. Optional.
+  /// - Parameter dispatchQueue: A dispatch queue used to load animations. Defaults to `DispatchQueue.global()`. Optional.
+  /// - Parameter handleResult: A closure to be called when the file has loaded.
+  public static func loadedFrom(
+    filepath: String,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    dispatchQueue: DispatchQueue = .dotLottie,
+    handleResult: @escaping (Result<DotLottieFile, Error>) -> Void
+  ) {
+    dispatchQueue.async {
+      let result = SynchronouslyBlockingCurrentThread.loadedFrom(
+        filepath: filepath,
+        dotLottieCache: dotLottieCache
+      )
+
+      DispatchQueue.main.async {
+        handleResult(result)
+      }
+    }
+  }
+
+  /// Loads a DotLottie model from the asset catalog by its name. Returns `nil` if a lottie is not found.
+  /// - Parameter name: The name of the lottie file in the asset catalog. EG "StarAnimation"
+  /// - Parameter bundle: The bundle in which the lottie is located. Defaults to `Bundle.main`
+  /// - Parameter dotLottieCache: A cache for holding loaded lottie files. Defaults to `LRUDotLottieCache.sharedCache` Optional.
+  public static func asset(
+    named name: String,
+    bundle: Bundle = Bundle.main,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache
+  ) async throws -> DotLottieFile {
+    try await withCheckedThrowingContinuation { continuation in
+      DotLottieFile.asset(named: name, bundle: bundle, dotLottieCache: dotLottieCache) { result in
+        continuation.resume(with: result)
+      }
+    }
+  }
+
+  ///    Loads a DotLottie model from the asset catalog by its name. Returns `nil` if a lottie is not found.
+  ///    - Parameter name: The name of the lottie file in the asset catalog. EG "StarAnimation"
+  ///    - Parameter bundle: The bundle in which the lottie is located. Defaults to `Bundle.main`
+  ///    - Parameter dotLottieCache: A cache for holding loaded lottie files. Defaults to `LRUDotLottieCache.sharedCache` Optional.
+  ///    - Parameter dispatchQueue: A dispatch queue used to load animations. Defaults to `DispatchQueue.global()`. Optional.
+  ///    - Parameter handleResult: A closure to be called when the file has loaded.
+  public static func asset(
+    named name: String,
+    bundle: Bundle = Bundle.main,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    dispatchQueue: DispatchQueue = .dotLottie,
+    handleResult: @escaping (Result<DotLottieFile, Error>) -> Void
+  ) {
+    dispatchQueue.async {
+      /// Create a cache key for the lottie.
+      let cacheKey = bundle.bundlePath + "/" + name
+
+      /// Check cache for lottie
+      if
+        let dotLottieCache,
+        let lottie = dotLottieCache.file(forKey: cacheKey)
+      {
+        /// If found, return the lottie.
+        DispatchQueue.main.async {
+          handleResult(.success(lottie))
+        }
+        return
+      }
+
+      do {
+        /// Load data from Asset
+        let data = try Data(assetName: name, in: bundle)
+
+        /// Decode lottie.
+        let lottie = try DotLottieFile(data: data, filename: name)
+        dotLottieCache?.setFile(lottie, forKey: cacheKey)
+        DispatchQueue.main.async {
+          handleResult(.success(lottie))
+        }
+      } catch {
+        /// Decoding error.
+        DispatchQueue.main.async {
+          handleResult(.failure(error))
+        }
+      }
+    }
+  }
+
+  /// Loads a DotLottie animation asynchronously from the URL.
+  ///
+  /// - Parameter url: The url to load the animation from.
+  /// - Parameter session: The `LottieURLSession` used to load the animation. Defaults to `LottieConfiguration.defaultURLSession`.
+  /// - Parameter dotLottieCache: A cache for holding loaded animations. Defaults to `DotLottieCache.sharedCache`. Optional.
+  ///
+  /// - Returns: Loaded DotLottie animation.
+  public static func loadedFrom(
+    url: URL,
+    session: LottieURLSession = LottieConfiguration.defaultURLSession,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache
+  ) async throws -> DotLottieFile {
+    var dataTask: URLSessionDataTask?
+    let cancelTask = { dataTask?.cancel() }
+    return try await withTaskCancellationHandler {
+      try await withCheckedThrowingContinuation { continuation in
+        dataTask = DotLottieFile.loadedFrom(url: url, session: session, dotLottieCache: dotLottieCache) { result in
+          continuation.resume(with: result)
+        }
+      }
+    } onCancel: {
+      cancelTask()
+    }
+  }
+
+  /// Loads a DotLottie animation asynchronously from the URL.
+  ///
+  /// - Parameter url: The url to load the animation from.
+  /// - Parameter session: The `LottieURLSession` used to load the animation. Defaults to `LottieConfiguration.defaultURLSession`.
+  /// - Parameter dotLottieCache: A cache for holding loaded animations. Defaults to `DotLottieCache.sharedCache`. Optional.
+  /// - Parameter handleResult: A closure to be called when the animation has loaded.
+  ///
+  /// - Returns: `URLSessionDataTask` that can be used to cancel the request, or `nil` if the animation was loaded from cache.
+  @discardableResult
+  public static func loadedFrom(
+    url: URL,
+    session: LottieURLSession = LottieConfiguration.defaultURLSession,
+    dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    handleResult: @escaping (Result<DotLottieFile, Error>) -> Void
+  ) -> URLSessionDataTask? {
+    if let dotLottieCache, let lottie = dotLottieCache.file(forKey: url.absoluteString) {
+      handleResult(.success(lottie))
+      return nil
+    } else {
+      let task = session.lottieDataTask(with: url) { data, _, error in
+        do {
+          if let error {
+            throw error
+          }
+          guard let data else {
+            throw DotLottieError.noDataLoaded
+          }
+          let lottie = try DotLottieFile(data: data, filename: url.deletingPathExtension().lastPathComponent)
+          DispatchQueue.main.async {
+            dotLottieCache?.setFile(lottie, forKey: url.absoluteString)
+            handleResult(.success(lottie))
+          }
+        } catch {
+          DispatchQueue.main.async {
+            handleResult(.failure(error))
+          }
+        }
+      }
+      task?.resume()
+      return task
+    }
+  }
+
+  /// Loads an DotLottie from a data asynchronously.
+  ///
+  /// - Parameters:
+  ///   - data: The data(`Foundation.Data`) object to load DotLottie from
+  ///   - filename: The name of the lottie file without the lottie extension. eg. "StarAnimation"
+  ///   - dispatchQueue: A dispatch queue used to load animations. Defaults to `DispatchQueue.global()`. Optional.
+  ///   - handleResult: A closure to be called when the file has loaded.
+  public static func loadedFrom(
+    data: Data,
+    filename: String,
+    dispatchQueue: DispatchQueue = .dotLottie,
+    handleResult: @escaping (Result<DotLottieFile, Error>) -> Void
+  ) {
+    dispatchQueue.async {
+      do {
+        let dotLottie = try DotLottieFile(data: data, filename: filename)
+        DispatchQueue.main.async {
+          handleResult(.success(dotLottie))
+        }
+      } catch {
+        DispatchQueue.main.async {
+          handleResult(.failure(error))
+        }
+      }
+    }
+  }
+
+  /// Loads an DotLottie from a data asynchronously.
+  ///
+  /// - Parameters:
+  ///   - data: The data(`Foundation.Data`) object to load DotLottie from
+  ///   - filename: The name of the lottie file without the lottie extension. eg. "StarAnimation"
+  ///   - dispatchQueue: A dispatch queue used to load animations. Defaults to `DispatchQueue.global()`. Optional.
+  public static func loadedFrom(
+    data: Data,
+    filename: String,
+    dispatchQueue: DispatchQueue = .dotLottie
+  ) async throws -> DotLottieFile {
+    try await withCheckedThrowingContinuation { continuation in
+      loadedFrom(data: data, filename: filename, dispatchQueue: dispatchQueue) { result in
+        continuation.resume(with: result)
+      }
+    }
+  }
+}
+
+extension DispatchQueue {
+  /// A serial dispatch queue ensures that IO related to loading dot Lottie files don't overlap,
+  /// which can trigger file loading errors due to concurrent unzipping on a single archive.
+  public static let dotLottie = DispatchQueue(
+    label: "com.airbnb.lottie.dot-lottie",
+    qos: .userInitiated
+  )
+}

package/platforms/macos/src/vendor/Lottie/Public/DynamicProperties/AnimationKeypath.swift

@@ -0,0 +1,57 @@
+//
+//  AnimationKeypath.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+/// `AnimationKeypath` is an object that describes a keypath search for nodes in the
+/// animation JSON. `AnimationKeypath` matches views and properties inside of `LottieAnimationView`
+/// to their backing `LottieAnimation` model by name.
+///
+/// A keypath can be used to set properties on an existing animation, or can be validated
+/// with an existing `LottieAnimation`.
+///
+/// `AnimationKeypath` can describe a specific object, or can use wildcards for fuzzy matching
+/// of objects. Acceptable wildcards are either "*" (star) or "**" (double star).
+/// Single star will search a single depth for the next object.
+/// Double star will search any depth.
+///
+/// Read More at https://airbnb.io/lottie/#/ios?id=dynamic-animation-properties
+///
+/// EG:
+/// @"Layer.Shape Group.Stroke 1.Color"
+/// Represents a specific color node on a specific stroke.
+///
+/// @"**.Stroke 1.Color"
+/// Represents the color node for every Stroke named "Stroke 1" in the animation.
+public struct AnimationKeypath: Hashable, ExpressibleByStringLiteral {
+
+  // MARK: Lifecycle
+
+  /// Creates a keypath from a dot-separated string. The string is separated by "."
+  public init(keypath: String) {
+    keys = keypath.components(separatedBy: ".")
+  }
+
+  /// Creates a keypath from a dot-separated string
+  public init(stringLiteral: String) {
+    self.init(keypath: stringLiteral)
+  }
+
+  /// Creates a keypath from a list of strings.
+  public init(keys: [String]) {
+    self.keys = keys
+  }
+
+  // MARK: Public
+
+  /// The dot-separated key values that represent this keypath.
+  public internal(set) var keys: [String]
+
+  /// The `String` representation of this keypath
+  public var string: String {
+    keys.joined(separator: ".")
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Public/DynamicProperties/AnyValueProvider.swift

@@ -0,0 +1,132 @@
+//
+//  AnyValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import Foundation
+
+// MARK: - AnyValueProvider
+
+/// `AnyValueProvider` is a protocol that return animation data for a property at a
+/// given time. Every frame a `LottieAnimationView` queries all of its properties and asks
+/// if their ValueProvider has an update. If it does the LottieAnimationView will read the
+/// property and update that portion of the animation.
+///
+/// Value Providers can be used to dynamically set animation properties at run time.
+public protocol AnyValueProvider {
+
+  /// The Type of the value provider
+  var valueType: Any.Type { get }
+
+  /// The type-erased storage for this Value Provider
+  var typeErasedStorage: AnyValueProviderStorage { get }
+
+  /// Asks the provider if it has an update for the given frame.
+  func hasUpdate(frame: AnimationFrameTime) -> Bool
+
+}
+
+extension AnyValueProvider {
+  /// Asks the provider to update the container with its value for the frame.
+  public func value(frame: AnimationFrameTime) -> Any {
+    typeErasedStorage.value(frame: frame)
+  }
+}
+
+// MARK: - ValueProvider
+
+/// A base protocol for strongly-typed Value Providers
+protocol ValueProvider: AnyValueProvider {
+  associatedtype Value: AnyInterpolatable
+
+  /// The strongly-typed storage for this Value Provider
+  var storage: ValueProviderStorage<Value> { get }
+}
+
+extension ValueProvider {
+  public var typeErasedStorage: AnyValueProviderStorage {
+    switch storage {
+    case .closure(let typedClosure):
+      .closure(typedClosure)
+
+    case .singleValue(let typedValue):
+      .singleValue(typedValue)
+
+    case .keyframes(let keyframes):
+      .keyframes(
+        keyframes.map { keyframe in
+          keyframe.withValue(keyframe.value as Any)
+        },
+        interpolate: storage.value(frame:)
+      )
+    }
+  }
+}
+
+// MARK: - ValueProviderStorage
+
+/// The underlying storage of a `ValueProvider`
+public enum ValueProviderStorage<T: AnyInterpolatable> {
+  /// The value provider stores a single value that is used on all frames
+  case singleValue(T)
+
+  /// The value provider stores a group of keyframes
+  ///  - The main-thread rendering engine interpolates values in these keyframes
+  ///    using `T`'s `Interpolatable` implementation.
+  ///  - The Core Animation rendering engine constructs a `CAKeyframeAnimation`
+  ///    using these keyframes. The Core Animation render server performs
+  ///    the interpolation, without calling `T`'s `Interpolatable` implementation.
+  case keyframes([Keyframe<T>])
+
+  /// The value provider stores a closure that is invoked on every frame
+  ///  - This is only supported by the main-thread rendering engine
+  case closure((AnimationFrameTime) -> T)
+
+  // MARK: Internal
+
+  func value(frame: AnimationFrameTime) -> T {
+    switch self {
+    case .singleValue(let value):
+      value
+
+    case .closure(let closure):
+      closure(frame)
+
+    case .keyframes(let keyframes):
+      KeyframeInterpolator(keyframes: ContiguousArray(keyframes)).storage.value(frame: frame)
+    }
+  }
+}
+
+// MARK: - AnyValueProviderStorage
+
+/// A type-erased representation of `ValueProviderStorage`
+public enum AnyValueProviderStorage {
+  /// The value provider stores a single value that is used on all frames
+  case singleValue(Any)
+
+  /// The value provider stores a group of keyframes
+  ///  - Since we can't interpolate a type-erased `KeyframeGroup`,
+  ///    the interpolation has to be performed in the `interpolate` closure.
+  case keyframes([Keyframe<Any>], interpolate: (AnimationFrameTime) -> Any)
+
+  /// The value provider stores a closure that is invoked on every frame
+  case closure((AnimationFrameTime) -> Any)
+
+  // MARK: Internal
+
+  func value(frame: AnimationFrameTime) -> Any {
+    switch self {
+    case .singleValue(let value):
+      value
+
+    case .closure(let closure):
+      closure(frame)
+
+    case .keyframes(_, let valueForFrame):
+      valueForFrame(frame)
+    }
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/DynamicProperties/ValueProviders/ColorValueProvider.swift

@@ -0,0 +1,96 @@
+//
+//  ColorValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - ColorValueProvider
+
+/// A `ValueProvider` that returns a CGColor Value
+public final class ColorValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes with a block provider
+  public init(block: @escaping ColorValueBlock) {
+    self.block = block
+    color = LottieColor(r: 0, g: 0, b: 0, a: 1)
+    keyframes = nil
+    identity = UUID()
+  }
+
+  /// Initializes with a single color.
+  public init(_ color: LottieColor) {
+    self.color = color
+    block = nil
+    keyframes = nil
+    hasUpdate = true
+    identity = color
+  }
+
+  /// Initializes with multiple colors, with timing information
+  public init(_ keyframes: [Keyframe<LottieColor>]) {
+    self.keyframes = keyframes
+    color = LottieColor(r: 0, g: 0, b: 0, a: 1)
+    block = nil
+    hasUpdate = true
+    identity = keyframes
+  }
+
+  // MARK: Public
+
+  /// Returns a LottieColor for a CGColor(Frame Time)
+  public typealias ColorValueBlock = (CGFloat) -> LottieColor
+
+  /// The color value of the provider.
+  public var color: LottieColor {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  public var valueType: Any.Type {
+    LottieColor.self
+  }
+
+  public var storage: ValueProviderStorage<LottieColor> {
+    if let block {
+      return .closure { frame in
+        self.hasUpdate = false
+        return block(frame)
+      }
+    } else if let keyframes {
+      return .keyframes(keyframes)
+    } else {
+      hasUpdate = false
+      return .singleValue(color)
+    }
+  }
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
+    if block != nil {
+      return true
+    }
+    return hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+
+  private var block: ColorValueBlock?
+  private var keyframes: [Keyframe<LottieColor>]?
+  private var identity: AnyHashable
+}
+
+// MARK: Equatable
+
+extension ColorValueProvider: Equatable {
+  public static func ==(_ lhs: ColorValueProvider, _ rhs: ColorValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
+}