lottie-ios 4.2.0 → 4.3.0

package/Sources/Private/MainThread/LayerContainers/CompLayers/PreCompositionLayer.swift

@@ -16,10 +16,12 @@ final class PreCompositionLayer: CompositionLayer {
     precomp: PreCompLayerModel,
     asset: PrecompAsset,
     layerImageProvider: LayerImageProvider,
-    textProvider: AnimationTextProvider,
+    layerTextProvider: LayerTextProvider,
+    textProvider: AnimationKeypathTextProvider,
     fontProvider: AnimationFontProvider,
     assetLibrary: AssetLibrary?,
-    frameRate: CGFloat)
+    frameRate: CGFloat,
+    rootAnimationLayer: MainThreadAnimationLayer?)
   {
     animationLayers = []
     if let keyframes = precomp.timeRemapping?.keyframes {
@@ -36,11 +38,14 @@ final class PreCompositionLayer: CompositionLayer {
     let layers = asset.layers.initializeCompositionLayers(
       assetLibrary: assetLibrary,
       layerImageProvider: layerImageProvider,
+      layerTextProvider: layerTextProvider,
       textProvider: textProvider,
       fontProvider: fontProvider,
-      frameRate: frameRate)
+      frameRate: frameRate,
+      rootAnimationLayer: rootAnimationLayer)
 
     var imageLayers = [ImageCompositionLayer]()
+    var textLayers = [TextCompositionLayer]()
 
     var mattedLayer: CompositionLayer? = nil
 
@@ -50,6 +55,9 @@ final class PreCompositionLayer: CompositionLayer {
       if let imageLayer = layer as? ImageCompositionLayer {
         imageLayers.append(imageLayer)
       }
+      if let textLayer = layer as? TextCompositionLayer {
+        textLayers.append(textLayer)
+      }
       if let matte = mattedLayer {
         /// The previous layer requires this layer to be its matte
         matte.matteLayer = layer
@@ -69,6 +77,7 @@ final class PreCompositionLayer: CompositionLayer {
     childKeypaths.append(contentsOf: layers)
 
     layerImageProvider.addImageLayers(imageLayers)
+    layerTextProvider.addTextLayers(textLayers)
   }
 
   override init(layer: Any) {
@@ -107,12 +116,16 @@ final class PreCompositionLayer: CompositionLayer {
     } else {
       localFrame = (frame - startFrame) / timeStretch
     }
-    animationLayers.forEach { $0.displayWithFrame(frame: localFrame, forceUpdates: forceUpdates) }
+    for animationLayer in animationLayers {
+      animationLayer.displayWithFrame(frame: localFrame, forceUpdates: forceUpdates)
+    }
   }
 
   override func updateRenderScale() {
     super.updateRenderScale()
-    animationLayers.forEach { $0.renderScale = renderScale }
+    for animationLayer in animationLayers {
+      animationLayer.renderScale = renderScale
+    }
   }
 
   // MARK: Fileprivate

package/Sources/Private/MainThread/LayerContainers/CompLayers/TextCompositionLayer.swift

@@ -47,7 +47,12 @@ final class TextCompositionLayer: CompositionLayer {
 
   // MARK: Lifecycle
 
-  init(textLayer: TextLayerModel, textProvider: AnimationTextProvider, fontProvider: AnimationFontProvider) {
+  init(
+    textLayer: TextLayerModel,
+    textProvider: AnimationKeypathTextProvider,
+    fontProvider: AnimationFontProvider,
+    rootAnimationLayer: MainThreadAnimationLayer?)
+  {
     var rootNode: TextAnimatorNode?
     for animator in textLayer.animators {
       rootNode = TextAnimatorNode(parentNode: rootNode, textAnimator: animator)
@@ -57,6 +62,7 @@ final class TextCompositionLayer: CompositionLayer {
 
     self.textProvider = textProvider
     self.fontProvider = fontProvider
+    self.rootAnimationLayer = rootAnimationLayer
 
     super.init(layer: textLayer, size: .zero)
     contentsLayer.addSublayer(self.textLayer)
@@ -92,8 +98,18 @@ final class TextCompositionLayer: CompositionLayer {
   let textDocument: KeyframeInterpolator<TextDocument>?
 
   let textLayer = CoreTextRenderLayer()
-  var textProvider: AnimationTextProvider
+  var textProvider: AnimationKeypathTextProvider
   var fontProvider: AnimationFontProvider
+  weak var rootAnimationLayer: MainThreadAnimationLayer?
+
+  lazy var fullAnimationKeypath: AnimationKeypath = {
+    // Individual layers don't know their full keypaths, so we have to delegate
+    // to the `MainThreadAnimationLayer` to search the layer hierarchy and find
+    // the full keypath (which includes this layer's parent layers)
+    rootAnimationLayer?.keypath(for: self)
+      // If that failed for some reason, just use the last path component (which we do have here)
+      ?? AnimationKeypath(keypath: keypathName)
+  }()
 
   override func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
     guard let textDocument = textDocument else { return }
@@ -108,11 +124,23 @@ final class TextCompositionLayer: CompositionLayer {
 
     // Get Text Attributes
     let text = textDocument.value(frame: frame) as! TextDocument
+
+    // Prior to Lottie 4.3.0 the Main Thread rendering engine always just used `LegacyAnimationTextProvider`
+    // and called it with the `keypathName` (only the last path component of the full keypath).
+    // Starting in Lottie 4.3.0 we use `AnimationKeypathTextProvider` instead if implemented.
+    let textString: String
+    if let keypathTextValue = textProvider.text(for: fullAnimationKeypath, sourceText: text.text) {
+      textString = keypathTextValue
+    } else if let legacyTextProvider = textProvider as? LegacyAnimationTextProvider {
+      textString = legacyTextProvider.textFor(keypathName: keypathName, sourceText: text.text)
+    } else {
+      textString = text.text
+    }
+
     let strokeColor = rootNode?.textOutputNode.strokeColor ?? text.strokeColorData?.cgColorValue
     let strokeWidth = rootNode?.textOutputNode.strokeWidth ?? CGFloat(text.strokeWidth ?? 0)
     let tracking = (CGFloat(text.fontSize) * (rootNode?.textOutputNode.tracking ?? CGFloat(text.tracking))) / 1000.0
     let matrix = rootNode?.textOutputNode.xform ?? CATransform3DIdentity
-    let textString = textProvider.textFor(keypathName: keypathName, sourceText: text.text)
     let ctFont = fontProvider.fontFor(family: text.fontFamily, size: CGFloat(text.fontSize))
 
     // Set all of the text layer options

package/Sources/Private/MainThread/LayerContainers/MainThreadAnimationLayer.swift

@@ -21,7 +21,7 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
   init(
     animation: LottieAnimation,
     imageProvider: AnimationImageProvider,
-    textProvider: AnimationTextProvider,
+    textProvider: AnimationKeypathTextProvider,
     fontProvider: AnimationFontProvider,
     maskAnimationToBounds: Bool,
     logger: LottieLogger)
@@ -37,9 +37,11 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
     let layers = animation.layers.initializeCompositionLayers(
       assetLibrary: animation.assetLibrary,
       layerImageProvider: layerImageProvider,
+      layerTextProvider: layerTextProvider,
       textProvider: textProvider,
       fontProvider: fontProvider,
-      frameRate: CGFloat(animation.framerate))
+      frameRate: CGFloat(animation.framerate),
+      rootAnimationLayer: self)
 
     var imageLayers = [ImageCompositionLayer]()
     var textLayers = [TextCompositionLayer]()
@@ -139,7 +141,9 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
     if respectAnimationFrameRate {
       newFrame = floor(newFrame)
     }
-    animationLayers.forEach { $0.displayWithFrame(frame: newFrame, forceUpdates: false) }
+    for animationLayer in animationLayers {
+      animationLayer.displayWithFrame(frame: newFrame, forceUpdates: forceDisplayUpdateOnEachFrame)
+    }
   }
 
   // MARK: Internal
@@ -147,8 +151,16 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
   /// The animatable Current Frame Property
   @NSManaged var currentFrame: CGFloat
 
-  /// The parent `LottieAnimationView` that manages this layer
-  weak var animationView: LottieAnimationView?
+  /// The parent `LottieAnimationLayer` that manages this layer
+  weak var lottieAnimationLayer: LottieAnimationLayer?
+
+  /// Whether or not to use `forceDisplayUpdate()` when rendering each individual frame.
+  ///  - The main thread rendering engine implements optimizations to decrease the amount
+  ///    of properties that have to be re-rendered on each frame. There are some cases
+  ///    where this can result in bugs / incorrect behavior, so we allow it to be disabled.
+  ///  - Forcing a full render on every frame will decrease performance, and is not recommended
+  ///    except as a workaround to a bug in the main thread rendering engine.
+  var forceDisplayUpdateOnEachFrame = false
 
   var animationLayers: ContiguousArray<CompositionLayer>
 
@@ -175,11 +187,13 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
 
   var renderScale: CGFloat = 1 {
     didSet {
-      animationLayers.forEach { $0.renderScale = renderScale }
+      for animationLayer in animationLayers {
+        animationLayer.renderScale = renderScale
+      }
     }
   }
 
-  var textProvider: AnimationTextProvider {
+  var textProvider: AnimationKeypathTextProvider {
     get { layerTextProvider.textProvider }
     set { layerTextProvider.textProvider = newValue }
   }
@@ -199,7 +213,9 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
 
   /// Forces the view to update its drawing.
   func forceDisplayUpdate() {
-    animationLayers.forEach { $0.displayWithFrame(frame: currentFrame, forceUpdates: true) }
+    for animationLayer in animationLayers {
+      animationLayer.displayWithFrame(frame: currentFrame, forceUpdates: true)
+    }
   }
 
   func logHierarchyKeypaths() {
@@ -258,6 +274,15 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
     return nil
   }
 
+  func keypath(for layerToFind: CALayer) -> AnimationKeypath? {
+    for layer in animationLayers {
+      if let foundKeypath = layer.keypath(for: layerToFind) {
+        return foundKeypath
+      }
+    }
+    return nil
+  }
+
   func animatorNodes(for keypath: AnimationKeypath) -> [AnimatorNode]? {
     var results = [AnimatorNode]()
     for layer in animationLayers {

package/Sources/Private/MainThread/LayerContainers/Utility/CachedImageProvider.swift

@@ -3,6 +3,7 @@
 
 import CoreGraphics
 import Foundation
+import QuartzCore
 
 // MARK: - CachedImageProvider
 
@@ -35,6 +36,11 @@ private final class CachedImageProvider: AnimationImageProvider {
 
   let imageCache: NSCache<NSString, CGImage> = .init()
   let imageProvider: AnimationImageProvider
+
+  func contentsGravity(for asset: ImageAsset) -> CALayerContentsGravity {
+    imageProvider.contentsGravity(for: asset)
+  }
+
 }
 
 extension AnimationImageProvider {
@@ -42,6 +48,7 @@ extension AnimationImageProvider {
   /// It wraps the current provider as image loader, and uses `NSCache` to cache the images for resue.
   /// The cache will be reset when the `animation` is reset.
   var cachedImageProvider: AnimationImageProvider {
-    CachedImageProvider(imageProvider: self)
+    guard cacheEligible else { return self }
+    return CachedImageProvider(imageProvider: self)
   }
 }

package/Sources/Private/MainThread/LayerContainers/Utility/CompositionLayersInitializer.swift

@@ -13,9 +13,12 @@ extension Array where Element == LayerModel {
   func initializeCompositionLayers(
     assetLibrary: AssetLibrary?,
     layerImageProvider: LayerImageProvider,
-    textProvider: AnimationTextProvider,
+    layerTextProvider: LayerTextProvider,
+    textProvider: AnimationKeypathTextProvider,
     fontProvider: AnimationFontProvider,
-    frameRate: CGFloat) -> [CompositionLayer]
+    frameRate: CGFloat,
+    rootAnimationLayer: MainThreadAnimationLayer?)
+    -> [CompositionLayer]
   {
     var compositionLayers = [CompositionLayer]()
     var layerMap = [Int : CompositionLayer]()
@@ -45,10 +48,12 @@ extension Array where Element == LayerModel {
           precomp: precompLayer,
           asset: precompAsset,
           layerImageProvider: layerImageProvider,
+          layerTextProvider: layerTextProvider,
           textProvider: textProvider,
           fontProvider: fontProvider,
           assetLibrary: assetLibrary,
-          frameRate: frameRate)
+          frameRate: frameRate,
+          rootAnimationLayer: rootAnimationLayer)
         compositionLayers.append(precompContainer)
         layerMap[layer.index] = precompContainer
       } else if
@@ -62,7 +67,11 @@ extension Array where Element == LayerModel {
         compositionLayers.append(imageContainer)
         layerMap[layer.index] = imageContainer
       } else if let textLayer = layer as? TextLayerModel {
-        let textContainer = TextCompositionLayer(textLayer: textLayer, textProvider: textProvider, fontProvider: fontProvider)
+        let textContainer = TextCompositionLayer(
+          textLayer: textLayer,
+          textProvider: textProvider,
+          fontProvider: fontProvider,
+          rootAnimationLayer: rootAnimationLayer)
         compositionLayers.append(textContainer)
         layerMap[layer.index] = textContainer
       } else {

package/Sources/Private/MainThread/LayerContainers/Utility/LayerFontProvider.swift

@@ -34,8 +34,8 @@ final class LayerFontProvider {
   }
 
   func reloadTexts() {
-    textLayers.forEach {
-      $0.fontProvider = fontProvider
+    for textLayer in textLayers {
+      textLayer.fontProvider = fontProvider
     }
   }
 }

package/Sources/Private/MainThread/LayerContainers/Utility/LayerImageProvider.swift

@@ -47,6 +47,7 @@ final class LayerImageProvider {
     for imageLayer in imageLayers {
       if let asset = imageAssets[imageLayer.imageReferenceID] {
         imageLayer.image = imageProvider.imageForAsset(asset: asset)
+        imageLayer.imageContentsGravity = imageProvider.contentsGravity(for: asset)
       }
     }
   }

package/Sources/Private/MainThread/LayerContainers/Utility/LayerTextProvider.swift

@@ -12,7 +12,7 @@ final class LayerTextProvider {
 
   // MARK: Lifecycle
 
-  init(textProvider: AnimationTextProvider) {
+  init(textProvider: AnimationKeypathTextProvider) {
     self.textProvider = textProvider
     textLayers = []
     reloadTexts()
@@ -22,7 +22,7 @@ final class LayerTextProvider {
 
   private(set) var textLayers: [TextCompositionLayer]
 
-  var textProvider: AnimationTextProvider {
+  var textProvider: AnimationKeypathTextProvider {
     didSet {
       reloadTexts()
     }
@@ -33,8 +33,8 @@ final class LayerTextProvider {
   }
 
   func reloadTexts() {
-    textLayers.forEach {
-      $0.textProvider = textProvider
+    for textLayer in textLayers {
+      textLayer.textProvider = textProvider
     }
   }
 }

package/Sources/Private/MainThread/NodeRenderSystem/NodeProperties/Protocols/NodePropertyMap.swift

@@ -36,7 +36,7 @@ extension NodePropertyMap {
 
   /// Rebuilds only the local nodes that have an update for the frame
   func updateNodeProperties(frame: CGFloat) {
-    properties.forEach { property in
+    for property in properties {
       property.update(frame: frame)
     }
   }

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/ModifierNodes/TrimPathNode.swift

@@ -133,7 +133,9 @@ final class TrimPathNode: AnimatorNode {
 
     /// First get the total length of all paths.
     var totalLength: CGFloat = 0
-    upstreamPaths.forEach { totalLength = totalLength + $0.totalLength }
+    for upstreamPath in upstreamPaths {
+      totalLength = totalLength + upstreamPath.totalLength
+    }
 
     /// Now determine the start and end cut lengths
     let startLength = startPosition * totalLength

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientFillRenderer.swift

@@ -82,7 +82,8 @@ private final class GradientFillLayer: CALayer {
           bitsPerComponent: 8,
           bytesPerRow: ctx.width,
           space: maskColorSpace,
-          bitmapInfo: 0) else { return }
+          bitmapInfo: 0)
+      else { return }
       let flipVertical = CGAffineTransform(a: 1, b: 0, c: 0, d: -1, tx: 0, ty: CGFloat(maskContext.height))
       maskContext.concatenate(flipVertical)
       maskContext.concatenate(ctx.ctm)

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/LegacyGradientFillRenderer.swift

@@ -104,7 +104,8 @@ final class LegacyGradientFillRenderer: PassThroughOutputNode, Renderable {
           bitsPerComponent: 8,
           bytesPerRow: inContext.width,
           space: maskColorSpace,
-          bitmapInfo: 0) else { return }
+          bitmapInfo: 0)
+      else { return }
       let flipVertical = CGAffineTransform(a: 1, b: 0, c: 0, d: -1, tx: 0, ty: CGFloat(maskContext.height))
       maskContext.concatenate(flipVertical)
       maskContext.concatenate(inContext.ctm)

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/GradientFillNode.swift

@@ -27,7 +27,7 @@ final class GradientFillProperties: NodePropertyMap, KeypathSearchable {
       PropertyName.opacity.rawValue : opacity,
       "Start Point" : startPoint,
       "End Point" : endPoint,
-      "Colors" : colors,
+      PropertyName.gradientColors.rawValue : colors,
     ]
     properties = Array(keypathProperties.values)
   }

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/GradientStrokeNode.swift

@@ -47,8 +47,8 @@ final class GradientStrokeProperties: NodePropertyMap, KeypathSearchable {
       PropertyName.opacity.rawValue : opacity,
       "Start Point" : startPoint,
       "End Point" : endPoint,
-      "Colors" : colors,
-      "Stroke Width" : width,
+      PropertyName.gradientColors.rawValue : colors,
+      PropertyName.strokeWidth.rawValue : width,
       "Dashes" : dashPattern,
       "Dash Phase" : dashPhase,
     ]

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/StrokeNode.swift

@@ -38,7 +38,7 @@ final class StrokeNodeProperties: NodePropertyMap, KeypathSearchable {
     keypathProperties = [
       PropertyName.opacity.rawValue : opacity,
       PropertyName.color.rawValue : color,
-      "Stroke Width" : width,
+      PropertyName.strokeWidth.rawValue : width,
       "Dashes" : dashPattern,
       "Dash Phase" : dashPhase,
     ]

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/Text/TextAnimatorNode.swift

@@ -99,7 +99,7 @@ final class TextAnimatorNodeProperties: NodePropertyMap, KeypathSearchable {
 
     if let keyframeGroup = textAnimator.strokeWidth {
       strokeWidth = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframeGroup.keyframes))
-      properties["Stroke Width"] = strokeWidth
+      properties[PropertyName.strokeWidth.rawValue] = strokeWidth
     } else {
       strokeWidth = nil
     }

package/Sources/Private/MainThread/NodeRenderSystem/RenderLayers/ShapeContainerLayer.swift

@@ -56,7 +56,9 @@ class ShapeContainerLayer: CALayer {
       rebuildContents(forFrame: forFrame)
     }
     guard isHidden == false else { return }
-    renderLayers.forEach { $0.markRenderUpdates(forFrame: forFrame) }
+    for renderLayer in renderLayers {
+      renderLayer.markRenderUpdates(forFrame: forFrame)
+    }
   }
 
   func hasRenderUpdate(forFrame _: CGFloat) -> Bool {
@@ -69,7 +71,9 @@ class ShapeContainerLayer: CALayer {
 
   func updateRenderScale() {
     contentsScale = renderScale
-    renderLayers.forEach { $0.renderScale = renderScale }
+    for renderLayer in renderLayers {
+      renderLayer.renderScale = renderScale
+    }
   }
 
 }

package/Sources/Private/Model/Assets/Asset.swift

@@ -7,6 +7,8 @@
 
 import Foundation
 
+// MARK: - Asset
+
 public class Asset: Codable, DictionaryInitializable {
 
   // MARK: Lifecycle
@@ -41,3 +43,9 @@ public class Asset: Codable, DictionaryInitializable {
     case id
   }
 }
+
+// MARK: Sendable
+
+/// Since `Asset` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `Asset` subclasses are immutable `Sendable` values.
+extension Asset: @unchecked Sendable { }

package/Sources/Private/Model/Assets/AssetLibrary.swift

@@ -7,7 +7,7 @@
 
 import Foundation
 
-final class AssetLibrary: Codable, AnyInitializable {
+final class AssetLibrary: Codable, AnyInitializable, Sendable {
 
   // MARK: Lifecycle
 
@@ -44,7 +44,7 @@ final class AssetLibrary: Codable, AnyInitializable {
     var decodedAssets = [String : Asset]()
     var imageAssets = [String : ImageAsset]()
     var precompAssets = [String : PrecompAsset]()
-    try dictionaries.forEach { dictionary in
+    for dictionary in dictionaries {
       if dictionary[PrecompAsset.CodingKeys.layers.rawValue] != nil {
         let asset = try PrecompAsset(dictionary: dictionary)
         decodedAssets[asset.id] = asset

package/Sources/Private/Model/Assets/ImageAsset.swift

@@ -70,7 +70,7 @@ extension Data {
   ///
   /// Returns nil when the input is not recognized as valid Data URL.
   /// - parameter imageAsset: The image asset that contains Data URL.
-  internal init?(imageAsset: ImageAsset) {
+  init?(imageAsset: ImageAsset) {
     self.init(dataString: imageAsset.name)
   }
 
@@ -79,7 +79,7 @@ extension Data {
   /// 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 `[]`.
-  internal init?(dataString: String, options: DataURLReadOptions = []) {
+  init?(dataString: String, options: DataURLReadOptions = []) {
     let trimmedDataString = dataString.trimmingCharacters(in: .whitespacesAndNewlines)
     guard
       dataString.hasPrefix("data:"),
@@ -103,7 +103,7 @@ extension Data {
 
   // MARK: Internal
 
-  internal struct DataURLReadOptions: OptionSet {
+  struct DataURLReadOptions: OptionSet {
     let rawValue: Int
 
     /// Will read Data URL using Data(contentsOf:)

package/Sources/Private/Model/DotLottie/DotLottieAnimation.swift

@@ -7,6 +7,8 @@
 
 import Foundation
 
+// MARK: - DotLottieAnimation
+
 struct DotLottieAnimation: Codable {
   /// Id of Animation
   var id: String
@@ -21,11 +23,16 @@ struct DotLottieAnimation: Codable {
   var direction: Int? = 1
 
   /// mode - "bounce" | "normal"
-  var mode: String? = "normal"
+  var mode: DotLottieAnimationMode? = .normal
 
   /// Loop mode for animation
   var loopMode: LottieLoopMode {
-    mode == "bounce" ? .autoReverse : ((loop ?? false) ? .loop : .playOnce)
+    switch mode {
+    case .bounce:
+      return .autoReverse
+    case .normal, nil:
+      return (loop ?? false) ? .loop : .playOnce
+    }
   }
 
   /// Animation speed
@@ -41,3 +48,10 @@ struct DotLottieAnimation: Codable {
     return try LottieAnimation.from(data: data)
   }
 }
+
+// MARK: - DotLottieAnimationMode
+
+enum DotLottieAnimationMode: String, Codable {
+  case normal
+  case bounce
+}

package/Sources/Private/Model/DotLottie/DotLottieImageProvider.swift

@@ -6,9 +6,9 @@
 //
 
 import Foundation
-#if os(iOS) || os(tvOS) || os(watchOS) || targetEnvironment(macCatalyst)
+#if canImport(UIKit)
 import UIKit
-#elseif os(macOS)
+#elseif canImport(AppKit)
 import AppKit
 #endif
 
@@ -51,23 +51,36 @@ class DotLottieImageProvider: AnimationImageProvider {
   private var images = [String: CGImage]()
 
   private func loadImages() {
-    filepath.urls.forEach {
+    for url in filepath.urls {
       #if os(iOS) || os(tvOS) || os(watchOS) || targetEnvironment(macCatalyst)
       if
-        let data = try? Data(contentsOf: $0),
+        let data = try? Data(contentsOf: url),
         let image = UIImage(data: data)?.cgImage
       {
-        images[$0.lastPathComponent] = image
+        images[url.lastPathComponent] = image
       }
       #elseif os(macOS)
       if
-        let data = try? Data(contentsOf: $0),
+        let data = try? Data(contentsOf: url),
         let image = NSImage(data: data)?.lottie_CGImage
       {
-        images[$0.lastPathComponent] = image
+        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/Sources/Private/Model/Extensions/KeyedDecodingContainerExtensions.swift

@@ -41,4 +41,30 @@ extension KeyedDecodingContainer {
     }
     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.decode(U.self, forKey: U.discriminator)
+      if let type = family.getType() as? T.Type {
+        list.append(try tmpContainer.decode(type))
+      }
+    }
+    return list
+  }
 }