lottie-ios 4.1.2 → 4.2.0

package/Sources/Private/Utility/Primitives/VectorsExtensions.swift

@@ -246,6 +246,10 @@ extension CGSize {
 
 extension CATransform3D {
 
+  enum Axis {
+    case x, y, z
+  }
+
   static func makeSkew(skew: CGFloat, skewAxis: CGFloat) -> CATransform3D {
     let mCos = cos(skewAxis.toRadians())
     let mSin = sin(skewAxis.toRadians())
@@ -311,20 +315,37 @@ extension CATransform3D {
     anchor: CGPoint,
     position: CGPoint,
     scale: CGSize,
-    rotation: CGFloat,
+    rotationX: CGFloat,
+    rotationY: CGFloat,
+    rotationZ: CGFloat,
     skew: CGFloat?,
     skewAxis: CGFloat?)
     -> CATransform3D
   {
     if let skew = skew, let skewAxis = skewAxis {
-      return CATransform3DMakeTranslation(position.x, position.y, 0).rotated(rotation).skewed(skew: -skew, skewAxis: skewAxis)
-        .scaled(scale * 0.01).translated(anchor * -1)
+      return CATransform3DMakeTranslation(position.x, position.y, 0)
+        .rotated(rotationX, axis: .x)
+        .rotated(rotationY, axis: .y)
+        .rotated(rotationZ, axis: .z)
+        .skewed(skew: -skew, skewAxis: skewAxis)
+        .scaled(scale * 0.01)
+        .translated(anchor * -1)
     }
-    return CATransform3DMakeTranslation(position.x, position.y, 0).rotated(rotation).scaled(scale * 0.01).translated(anchor * -1)
+    return CATransform3DMakeTranslation(position.x, position.y, 0)
+      .rotated(rotationX, axis: .x)
+      .rotated(rotationY, axis: .y)
+      .rotated(rotationZ, axis: .z)
+      .scaled(scale * 0.01)
+      .translated(anchor * -1)
   }
 
-  func rotated(_ degrees: CGFloat) -> CATransform3D {
-    CATransform3DRotate(self, degrees.toRadians(), 0, 0, 1)
+  func rotated(_ degrees: CGFloat, axis: Axis) -> CATransform3D {
+    CATransform3DRotate(
+      self,
+      degrees.toRadians(),
+      axis == .x ? 1 : 0,
+      axis == .y ? 1 : 0,
+      axis == .z ? 1 : 0)
   }
 
   func translated(_ translation: CGPoint) -> CATransform3D {
@@ -338,4 +359,5 @@ extension CATransform3D {
   func skewed(skew: CGFloat, skewAxis: CGFloat) -> CATransform3D {
     CATransform3DConcat(CATransform3D.makeSkew(skew: skew, skewAxis: skewAxis), self)
   }
+
 }

package/Sources/Public/Animation/LottieAnimationHelpers.swift

@@ -59,9 +59,7 @@ extension LottieAnimation {
 
     do {
       /// Decode animation.
-      guard let json = try bundle.getAnimationData(name, subdirectory: subdirectory) else {
-        return nil
-      }
+      let json = try bundle.getAnimationData(name, subdirectory: subdirectory)
       let animation = try LottieAnimation.from(data: json)
       animationCache?.setAnimation(animation, forKey: cacheKey)
       return animation
@@ -97,7 +95,10 @@ extension LottieAnimation {
       animationCache?.setAnimation(animation, forKey: filepath)
       return animation
     } catch {
-      /// Decoding Error.
+      LottieLogger.shared.warn("""
+        Failed to load animation from filepath \(filepath)
+        with underlying error: \(error.localizedDescription)
+        """)
       return nil
     }
   }
@@ -125,18 +126,19 @@ extension LottieAnimation {
       return animation
     }
 
-    /// Load jsonData from Asset
-    guard let json = Data.jsonData(from: name, in: bundle) else {
-      return nil
-    }
-
     do {
+      /// Load jsonData from Asset
+      let json = try Data(assetName: name, in: bundle)
       /// Decode animation.
       let animation = try LottieAnimation.from(data: json)
       animationCache?.setAnimation(animation, forKey: cacheKey)
       return animation
     } catch {
-      /// Decoding error.
+      LottieLogger.shared.warn("""
+        Failed to load animation with asset name \(name)
+        in \(bundle.bundlePath)
+        with underlying error: \(error.localizedDescription)
+        """)
       return nil
     }
   }

package/Sources/Public/Animation/LottieAnimationView.swift

@@ -88,7 +88,7 @@ extension LottieLoopMode: Equatable {
 // MARK: - LottieAnimationView
 
 @IBDesignable
-final public class LottieAnimationView: LottieAnimationViewBase {
+open class LottieAnimationView: LottieAnimationViewBase {
 
   // MARK: Lifecycle
 
@@ -178,6 +178,166 @@ final public class LottieAnimationView: LottieAnimationViewBase {
     commonInit()
   }
 
+  // MARK: Open
+
+  /// Plays the animation from its current state to the end.
+  ///
+  /// - Parameter completion: An optional completion closure to be called when the animation completes playing.
+  open func play(completion: LottieCompletionBlock? = nil) {
+    guard let animation = animation else {
+      return
+    }
+
+    /// Build a context for the animation.
+    let context = AnimationContext(
+      playFrom: CGFloat(animation.startFrame),
+      playTo: CGFloat(animation.endFrame),
+      closure: completion)
+    removeCurrentAnimationIfNecessary()
+    addNewAnimationForContext(context)
+  }
+
+  /// 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. If `nil` the view's `loopMode` property will be used.
+  /// - Parameter completion: An optional completion closure to be called when the animation stops.
+  open func play(
+    fromProgress: AnimationProgressTime? = nil,
+    toProgress: AnimationProgressTime,
+    loopMode: LottieLoopMode? = nil,
+    completion: LottieCompletionBlock? = nil)
+  {
+    guard let animation = animation else {
+      return
+    }
+
+    removeCurrentAnimationIfNecessary()
+    if let loopMode = loopMode {
+      /// Set the loop mode, if one was supplied
+      self.loopMode = loopMode
+    }
+    let context = AnimationContext(
+      playFrom: animation.frameTime(forProgress: fromProgress ?? currentProgress),
+      playTo: animation.frameTime(forProgress: toProgress),
+      closure: completion)
+    addNewAnimationForContext(context)
+  }
+
+  /// Plays the animation from a start frame to an end frame in the animation's framerate.
+  ///
+  /// - 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. If `nil` the view's `loopMode` property will be used.
+  /// - Parameter completion: An optional completion closure to be called when the animation stops.
+  open func play(
+    fromFrame: AnimationFrameTime? = nil,
+    toFrame: AnimationFrameTime,
+    loopMode: LottieLoopMode? = nil,
+    completion: LottieCompletionBlock? = nil)
+  {
+    removeCurrentAnimationIfNecessary()
+    if let loopMode = loopMode {
+      /// Set the loop mode, if one was supplied
+      self.loopMode = loopMode
+    }
+
+    let context = AnimationContext(
+      playFrom: fromFrame ?? currentFrame,
+      playTo: toFrame,
+      closure: completion)
+    addNewAnimationForContext(context)
+  }
+
+  /// 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. If `nil` the view's `loopMode` property will be used.
+  /// - Parameter completion: An optional completion closure to be called when the animation stops.
+  open func play(
+    fromMarker: String? = nil,
+    toMarker: String,
+    playEndMarkerFrame: Bool = true,
+    loopMode: LottieLoopMode? = nil,
+    completion: LottieCompletionBlock? = nil)
+  {
+    guard let animation = animation, let markers = animation.markerMap, let to = markers[toMarker] else {
+      return
+    }
+
+    removeCurrentAnimationIfNecessary()
+    if let loopMode = loopMode {
+      /// Set the loop mode, if one was supplied
+      self.loopMode = loopMode
+    }
+
+    let fromTime: CGFloat
+    if let fromName = fromMarker, let from = markers[fromName] {
+      fromTime = CGFloat(from.frameTime)
+    } else {
+      fromTime = currentFrame
+    }
+
+    let playTo = playEndMarkerFrame ? CGFloat(to.frameTime) : CGFloat(to.frameTime) - 1
+    let context = AnimationContext(
+      playFrom: fromTime,
+      playTo: playTo,
+      closure: completion)
+    addNewAnimationForContext(context)
+  }
+
+  /// 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. If `nil` the view's `loopMode` property will be used.
+  /// - Parameter completion: An optional completion closure to be called when the animation stops.
+  open func play(
+    marker: String,
+    loopMode: LottieLoopMode? = nil,
+    completion: LottieCompletionBlock? = nil)
+  {
+    guard let from = animation?.markerMap?[marker] else {
+      return
+    }
+
+    play(
+      fromFrame: from.frameTime,
+      toFrame: from.frameTime + from.durationFrameTime,
+      loopMode: loopMode,
+      completion: completion)
+  }
+
+  /// Stops the animation and resets the view to its start frame.
+  ///
+  /// The completion closure will be called with `false`
+  open func stop() {
+    removeCurrentAnimation()
+    currentFrame = 0
+  }
+
+  /// Pauses the animation in its current state.
+  ///
+  /// The completion closure will be called with `false`
+  open func pause() {
+    removeCurrentAnimation()
+  }
+
   // MARK: Public
 
   /// The configuration that this `LottieAnimationView` uses when playing its animation
@@ -294,6 +454,13 @@ final public class LottieAnimationView: LottieAnimationViewBase {
     }
   }
 
+  /// Whether or not the animation is masked to the bounds. Defaults to true.
+  public var maskAnimationToBounds = true {
+    didSet {
+      animationLayer?.masksToBounds = maskAnimationToBounds
+    }
+  }
+
   /// Returns `true` if the animation is currently playing.
   public var isAnimationPlaying: Bool {
     guard let animationLayer = animationLayer else {
@@ -492,164 +659,6 @@ final public class LottieAnimationView: LottieAnimationViewBase {
     animation = dotLottieAnimation.animation
   }
 
-  /// Plays the animation from its current state to the end.
-  ///
-  /// - Parameter completion: An optional completion closure to be called when the animation completes playing.
-  public func play(completion: LottieCompletionBlock? = nil) {
-    guard let animation = animation else {
-      return
-    }
-
-    /// Build a context for the animation.
-    let context = AnimationContext(
-      playFrom: CGFloat(animation.startFrame),
-      playTo: CGFloat(animation.endFrame),
-      closure: completion)
-    removeCurrentAnimationIfNecessary()
-    addNewAnimationForContext(context)
-  }
-
-  /// 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. If `nil` the view's `loopMode` property will be used.
-  /// - Parameter completion: An optional completion closure to be called when the animation stops.
-  public func play(
-    fromProgress: AnimationProgressTime? = nil,
-    toProgress: AnimationProgressTime,
-    loopMode: LottieLoopMode? = nil,
-    completion: LottieCompletionBlock? = nil)
-  {
-    guard let animation = animation else {
-      return
-    }
-
-    removeCurrentAnimationIfNecessary()
-    if let loopMode = loopMode {
-      /// Set the loop mode, if one was supplied
-      self.loopMode = loopMode
-    }
-    let context = AnimationContext(
-      playFrom: animation.frameTime(forProgress: fromProgress ?? currentProgress),
-      playTo: animation.frameTime(forProgress: toProgress),
-      closure: completion)
-    addNewAnimationForContext(context)
-  }
-
-  /// Plays the animation from a start frame to an end frame in the animation's framerate.
-  ///
-  /// - 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. If `nil` the view's `loopMode` property will be used.
-  /// - Parameter completion: An optional completion closure to be called when the animation stops.
-  public func play(
-    fromFrame: AnimationFrameTime? = nil,
-    toFrame: AnimationFrameTime,
-    loopMode: LottieLoopMode? = nil,
-    completion: LottieCompletionBlock? = nil)
-  {
-    removeCurrentAnimationIfNecessary()
-    if let loopMode = loopMode {
-      /// Set the loop mode, if one was supplied
-      self.loopMode = loopMode
-    }
-
-    let context = AnimationContext(
-      playFrom: fromFrame ?? currentFrame,
-      playTo: toFrame,
-      closure: completion)
-    addNewAnimationForContext(context)
-  }
-
-  /// 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. If `nil` the view's `loopMode` property will be used.
-  /// - Parameter completion: An optional completion closure to be called when the animation stops.
-  public func play(
-    fromMarker: String? = nil,
-    toMarker: String,
-    playEndMarkerFrame: Bool = true,
-    loopMode: LottieLoopMode? = nil,
-    completion: LottieCompletionBlock? = nil)
-  {
-    guard let animation = animation, let markers = animation.markerMap, let to = markers[toMarker] else {
-      return
-    }
-
-    removeCurrentAnimationIfNecessary()
-    if let loopMode = loopMode {
-      /// Set the loop mode, if one was supplied
-      self.loopMode = loopMode
-    }
-
-    let fromTime: CGFloat
-    if let fromName = fromMarker, let from = markers[fromName] {
-      fromTime = CGFloat(from.frameTime)
-    } else {
-      fromTime = currentFrame
-    }
-
-    let playTo = playEndMarkerFrame ? CGFloat(to.frameTime) : CGFloat(to.frameTime) - 1
-    let context = AnimationContext(
-      playFrom: fromTime,
-      playTo: playTo,
-      closure: completion)
-    addNewAnimationForContext(context)
-  }
-
-  /// 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. If `nil` the view's `loopMode` property will be used.
-  /// - Parameter completion: An optional completion closure to be called when the animation stops.
-  public func play(
-    marker: String,
-    loopMode: LottieLoopMode? = nil,
-    completion: LottieCompletionBlock? = nil)
-  {
-    guard let from = animation?.markerMap?[marker] else {
-      return
-    }
-
-    play(
-      fromFrame: from.frameTime,
-      toFrame: from.frameTime + from.durationFrameTime,
-      loopMode: loopMode,
-      completion: completion)
-  }
-
-  /// Stops the animation and resets the view to its start frame.
-  ///
-  /// The completion closure will be called with `false`
-  public func stop() {
-    removeCurrentAnimation()
-    currentFrame = 0
-  }
-
-  /// Pauses the animation in its current state.
-  ///
-  /// The completion closure will be called with `false`
-  public func pause() {
-    removeCurrentAnimation()
-  }
-
   /// Reloads the images supplied to the animation from the `imageProvider`
   public func reloadImages() {
     animationLayer?.reloadImages()
@@ -709,10 +718,17 @@ final public class LottieAnimationView: LottieAnimationViewBase {
   }
 
   /// Logs all child keypaths.
+  /// Logs the result of `allHierarchyKeypaths()` to the `LottieLogger`.
   public func logHierarchyKeypaths() {
     animationLayer?.logHierarchyKeypaths()
   }
 
+  /// Computes and returns a list of all child keypaths in the current animation.
+  /// The returned list is the same as the log output of `logHierarchyKeypaths()`
+  public func allHierarchyKeypaths() -> [String] {
+    animationLayer?.allHierarchyKeypaths() ?? []
+  }
+
   /// Searches for the nearest child layer to the first Keypath and adds the subview
   /// to that layer. The subview will move and animate with the child layer.
   /// Furthermore the subview will be in the child layers coordinate space.
@@ -1060,6 +1076,33 @@ final public class LottieAnimationView: LottieAnimationViewBase {
     }
   }
 
+  /// Updates an in flight animation.
+  func updateInFlightAnimation() {
+    guard let animationContext = animationContext else { return }
+
+    guard animationContext.closure.animationState != .complete else {
+      // Tried to re-add an already completed animation. Cancel.
+      self.animationContext = nil
+      return
+    }
+
+    /// Tell existing context to ignore its closure
+    animationContext.closure.ignoreDelegate = true
+
+    /// Make a new context, stealing the completion block from the previous.
+    let newContext = AnimationContext(
+      playFrom: animationContext.playFrom,
+      playTo: animationContext.playTo,
+      closure: animationContext.closure.completionBlock)
+
+    /// Remove current animation, and freeze the current frame.
+    let pauseFrame = realtimeAnimationFrame
+    animationLayer?.removeAnimation(forKey: activeAnimationName)
+    animationLayer?.currentFrame = pauseFrame
+
+    addNewAnimationForContext(newContext)
+  }
+
   // MARK: Fileprivate
 
   /// Context describing the animation that is currently playing in this `LottieAnimationView`
@@ -1087,6 +1130,7 @@ final public class LottieAnimationView: LottieAnimationViewBase {
 
     if let oldAnimation = animationLayer {
       oldAnimation.removeFromSuperlayer()
+      animationLayer = nil
     }
 
     invalidateIntrinsicContentSize()
@@ -1109,6 +1153,7 @@ final public class LottieAnimationView: LottieAnimationViewBase {
       return
     }
 
+    animationLayer.animationView = self
     animationLayer.renderScale = screenScale
 
     viewLayer?.addSublayer(animationLayer)
@@ -1125,6 +1170,7 @@ final public class LottieAnimationView: LottieAnimationViewBase {
       imageProvider: imageProvider.cachedImageProvider,
       textProvider: textProvider,
       fontProvider: fontProvider,
+      maskAnimationToBounds: maskAnimationToBounds,
       logger: logger)
   }
 
@@ -1135,6 +1181,7 @@ final public class LottieAnimationView: LottieAnimationViewBase {
         imageProvider: imageProvider.cachedImageProvider,
         textProvider: textProvider,
         fontProvider: fontProvider,
+        maskAnimationToBounds: maskAnimationToBounds,
         compatibilityTrackerMode: .track,
         logger: logger)
 
@@ -1170,6 +1217,7 @@ final public class LottieAnimationView: LottieAnimationViewBase {
         imageProvider: imageProvider.cachedImageProvider,
         textProvider: textProvider,
         fontProvider: fontProvider,
+        maskAnimationToBounds: maskAnimationToBounds,
         compatibilityTrackerMode: .abort,
         logger: logger)
 
@@ -1214,6 +1262,12 @@ final public class LottieAnimationView: LottieAnimationViewBase {
     let animationContext = animationContext
     let currentFrame = currentFrame
 
+    // Disable the completion handler delegate before tearing down the `CoreAnimationLayer`
+    // and building the `MainThreadAnimationLayer`. Otherwise deinitializing the
+    // `CoreAnimationLayer` would trigger the animation completion handler even though
+    // the animation hasn't even started playing yet.
+    animationContext?.closure.ignoreDelegate = true
+
     makeAnimationLayer(usingEngine: .mainThread)
 
     // Set up the Main Thread animation layer using the same configuration that
@@ -1295,33 +1349,6 @@ final public class LottieAnimationView: LottieAnimationViewBase {
     animationContext = nil
   }
 
-  /// Updates an in flight animation.
-  fileprivate func updateInFlightAnimation() {
-    guard let animationContext = animationContext else { return }
-
-    guard animationContext.closure.animationState != .complete else {
-      // Tried to re-add an already completed animation. Cancel.
-      self.animationContext = nil
-      return
-    }
-
-    /// Tell existing context to ignore its closure
-    animationContext.closure.ignoreDelegate = true
-
-    /// Make a new context, stealing the completion block from the previous.
-    let newContext = AnimationContext(
-      playFrom: animationContext.playFrom,
-      playTo: animationContext.playTo,
-      closure: animationContext.closure.completionBlock)
-
-    /// Remove current animation, and freeze the current frame.
-    let pauseFrame = realtimeAnimationFrame
-    animationLayer?.removeAnimation(forKey: activeAnimationName)
-    animationLayer?.currentFrame = pauseFrame
-
-    addNewAnimationForContext(newContext)
-  }
-
   /// Adds animation to animation layer and sets the delegate. If animation layer or animation are nil, exits.
   fileprivate func addNewAnimationForContext(_ animationContext: AnimationContext) {
     guard let animationlayer = animationLayer, let animation = animation else {

package/Sources/Public/DotLottie/DotLottieFile.swift

@@ -39,34 +39,17 @@ public final class DotLottieFile {
   /// Image provider for animations
   private(set) var imageProvider: AnimationImageProvider?
 
-  /// Manifest.json file loading
-  lazy var manifest: DotLottieManifest? = {
-    let path = fileUrl.appendingPathComponent(DotLottieFile.manifestFileName)
-    return try? DotLottieManifest.load(from: path)
-  }()
-
-  /// Animation url for main animation
-  lazy var animationUrl: URL? = {
-    guard let animationId = manifest?.animations.first?.id else { return nil }
-    let dotLottieJson = "\(DotLottieFile.animationsFolderName)/\(animationId).json"
-    return fileUrl.appendingPathComponent(dotLottieJson)
-  }()
-
   /// Animations folder url
   lazy var animationsUrl: URL = fileUrl.appendingPathComponent("\(DotLottieFile.animationsFolderName)")
 
   /// All files in animations folder
-  lazy var animationUrls: [URL] = {
-    FileManager.default.urls(for: animationsUrl) ?? []
-  }()
+  lazy var animationUrls: [URL] = FileManager.default.urls(for: animationsUrl) ?? []
 
   /// Images folder url
   lazy var imagesUrl: URL = fileUrl.appendingPathComponent("\(DotLottieFile.imagesFolderName)")
 
   /// All images in images folder
-  lazy var imageUrls: [URL] = {
-    FileManager.default.urls(for: imagesUrl) ?? []
-  }()
+  lazy var imageUrls: [URL] = FileManager.default.urls(for: imagesUrl) ?? []
 
   /// The `LottieAnimation` and `DotLottieConfiguration` for the given animation ID in this file
   func animation(for id: String? = nil) -> DotLottieFile.Animation? {
@@ -85,14 +68,6 @@ public final class DotLottieFile {
 
   private let fileUrl: URL
 
-  private var dotLottieAnimations: [DotLottieAnimation] {
-    manifest?.animations.map {
-      var animation = $0
-      animation.animationUrl = animationsUrl.appendingPathComponent("\($0.id).json")
-      return animation
-    } ?? []
-  }
-
   /// Decompresses .lottie file from `URL` and saves to local temp folder
   ///
   /// - Parameters:
@@ -102,7 +77,7 @@ public final class DotLottieFile {
     try? FileManager.default.removeItem(at: destinationURL)
     try FileManager.default.createDirectory(at: destinationURL, withIntermediateDirectories: true, attributes: nil)
     try FileManager.default.unzipItem(at: url, to: destinationURL)
-    loadContent()
+    try loadContent()
     try? FileManager.default.removeItem(at: destinationURL)
     try? FileManager.default.removeItem(at: url)
   }
@@ -120,14 +95,11 @@ public final class DotLottieFile {
   }
 
   /// Loads file content to memory
-  private func loadContent() {
+  private func loadContent() throws {
     imageProvider = DotLottieImageProvider(filepath: imagesUrl)
 
-    animations = dotLottieAnimations.compactMap { dotLottieAnimation -> DotLottieFile.Animation? in
-      guard let animation = try? dotLottieAnimation.animation() else {
-        return nil
-      }
-
+    animations = try loadManifest().animations.map { dotLottieAnimation in
+      let animation = try dotLottieAnimation.animation(url: animationsUrl)
       let configuration = DotLottieConfiguration(
         id: dotLottieAnimation.id,
         imageProvider: imageProvider,
@@ -139,6 +111,11 @@ public final class DotLottieFile {
         configuration: configuration)
     }
   }
+
+  private func loadManifest() throws -> DotLottieManifest {
+    let path = fileUrl.appendingPathComponent(DotLottieFile.manifestFileName)
+    return try DotLottieManifest.load(from: path)
+  }
 }
 
 extension String {