lottie-ios 4.4.2 → 4.5.0

package/Sources/Public/Animation/LottieAnimationView.swift

@@ -43,9 +43,9 @@ public enum LottieBackgroundBehavior {
   public static func `default`(for renderingEngine: RenderingEngine) -> LottieBackgroundBehavior {
     switch renderingEngine {
     case .mainThread:
-      return .pauseAndRestore
+      .pauseAndRestore
     case .coreAnimation:
-      return .continuePlaying
+      .continuePlaying
     }
   }
 }
@@ -73,13 +73,13 @@ extension LottieLoopMode: Equatable {
     switch (lhs, rhs) {
     case (.repeat(let lhsAmount), .repeat(let rhsAmount)),
          (.repeatBackwards(let lhsAmount), .repeatBackwards(let rhsAmount)):
-      return lhsAmount == rhsAmount
+      lhsAmount == rhsAmount
     case (.playOnce, .playOnce),
          (.loop, .loop),
          (.autoReverse, .autoReverse):
-      return true
+      true
     default:
-      return false
+      false
     }
   }
 }
@@ -567,9 +567,9 @@ open class LottieAnimationView: LottieAnimationViewBase {
       // duration and curve are captured and added to the layer. This is used in the
       // layout block to animate the animationLayer's position and size.
       let rect = bounds
-      self.bounds = CGRect.zero
-      self.bounds = rect
-      self.setNeedsLayout()
+      bounds = CGRect.zero
+      bounds = rect
+      setNeedsLayout()
     }
   }
 
@@ -813,7 +813,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
 
   // MARK: Internal
 
-  // The backing CALayer for this animation view.
+  /// The backing CALayer for this animation view.
   let lottieAnimationLayer: LottieAnimationLayer
 
   var animationLayer: RootAnimationLayer? {
@@ -823,7 +823,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// Set animation name from Interface Builder
   @IBInspectable var animationName: String? {
     didSet {
-      self.lottieAnimationLayer.animation = animationName.flatMap { LottieAnimation.named($0, animationCache: nil)
+      lottieAnimationLayer.animation = animationName.flatMap { LottieAnimation.named($0, animationCache: nil)
       }
     }
   }
@@ -835,15 +835,15 @@ open class LottieAnimationView: LottieAnimationViewBase {
 
     lottieAnimationLayer.animationLoaded = { [weak self] _, animation in
       guard let self else { return }
-      self.animationLoaded?(self, animation)
-      self.invalidateIntrinsicContentSize()
-      self.setNeedsLayout()
+      animationLoaded?(self, animation)
+      invalidateIntrinsicContentSize()
+      setNeedsLayout()
     }
 
     lottieAnimationLayer.animationLayerDidLoad = { [weak self] _, _ in
       guard let self else { return }
-      self.invalidateIntrinsicContentSize()
-      self.setNeedsLayout()
+      invalidateIntrinsicContentSize()
+      setNeedsLayout()
     }
   }
 

package/Sources/Public/Animation/LottieAnimationViewInitializers.swift

@@ -122,6 +122,7 @@ extension LottieAnimationView {
       case .success(let dotLottieFile):
         self.loadAnimation(animationId, from: dotLottieFile)
         completion?(self, nil)
+
       case .failure(let error):
         completion?(self, error)
       }
@@ -147,6 +148,7 @@ extension LottieAnimationView {
       case .success(let dotLottieFile):
         self.loadAnimation(animationId, from: dotLottieFile)
         completion?(self, nil)
+
       case .failure(let error):
         completion?(self, error)
       }
@@ -176,6 +178,7 @@ extension LottieAnimationView {
         case .success(let lottie):
           self.loadAnimation(animationId, from: lottie)
           completion?(self, nil)
+
         case .failure(let error):
           completion?(self, error)
         }
@@ -203,6 +206,7 @@ extension LottieAnimationView {
       case .success(let dotLottieFile):
         self.loadAnimation(animationId, from: dotLottieFile)
         completion?(self, nil)
+
       case .failure(let error):
         completion?(self, error)
       }

package/Sources/Public/Animation/LottiePlaybackMode.swift

@@ -170,7 +170,7 @@ extension LottiePlaybackMode.PlaybackMode {
     .fromProgress(nil, toProgress: toProgress, loopMode: loopMode)
   }
 
-  // Plays the animation from the current frame to the given frame.
+  /// Plays the animation from the current frame to the given frame.
   /// - Parameter toFrame: The end frame of the animation.
   /// - Parameter loopMode: The loop behavior of the animation.
   public static func toFrame(_ toFrame: AnimationFrameTime, loopMode: LottieLoopMode) -> Self {
@@ -211,32 +211,32 @@ extension LottiePlaybackMode {
   func loopMode(_ updatedLoopMode: LottieLoopMode) -> LottiePlaybackMode {
     switch self {
     case .playing(let playbackMode):
-      return .playing(playbackMode.loopMode(updatedLoopMode))
+      .playing(playbackMode.loopMode(updatedLoopMode))
 
     case .fromProgress(let fromProgress, toProgress: let toProgress, _):
-      return .playing(.fromProgress(
+      .playing(.fromProgress(
         fromProgress,
         toProgress: toProgress,
         loopMode: updatedLoopMode))
 
     case .fromFrame(let fromFrame, toFrame: let toFrame, _):
-      return .playing(.fromFrame(
+      .playing(.fromFrame(
         fromFrame,
         toFrame: toFrame,
         loopMode: updatedLoopMode))
 
     case .fromMarker(let fromMarker, let toMarker, let playEndMarkerFrame, _):
-      return .playing(.fromMarker(
+      .playing(.fromMarker(
         fromMarker,
         toMarker: toMarker,
         playEndMarkerFrame: playEndMarkerFrame,
         loopMode: updatedLoopMode))
 
     case .marker(let marker, _):
-      return .playing(.marker(marker, loopMode: updatedLoopMode))
+      .playing(.marker(marker, loopMode: updatedLoopMode))
 
     case .pause, .paused, .progress(_), .time(_), .frame(_), .markers:
-      return self
+      self
     }
   }
 }
@@ -246,15 +246,15 @@ extension LottiePlaybackMode.PlaybackMode {
   func loopMode(_ updatedLoopMode: LottieLoopMode) -> LottiePlaybackMode.PlaybackMode {
     switch self {
     case .fromProgress(let fromProgress, let toProgress, _):
-      return .fromProgress(fromProgress, toProgress: toProgress, loopMode: updatedLoopMode)
+      .fromProgress(fromProgress, toProgress: toProgress, loopMode: updatedLoopMode)
     case .fromFrame(let fromFrame, let toFrame, _):
-      return .fromFrame(fromFrame, toFrame: toFrame, loopMode: updatedLoopMode)
+      .fromFrame(fromFrame, toFrame: toFrame, loopMode: updatedLoopMode)
     case .fromMarker(let fromMarker, let toMarker, let playEndMarkerFrame, _):
-      return .fromMarker(fromMarker, toMarker: toMarker, playEndMarkerFrame: playEndMarkerFrame, loopMode: updatedLoopMode)
+      .fromMarker(fromMarker, toMarker: toMarker, playEndMarkerFrame: playEndMarkerFrame, loopMode: updatedLoopMode)
     case .marker(let marker, _):
-      return .marker(marker, loopMode: updatedLoopMode)
+      .marker(marker, loopMode: updatedLoopMode)
     case .markers:
-      return self
+      self
     }
   }
 }

package/Sources/Public/Animation/LottieView.swift

@@ -125,7 +125,7 @@ public struct LottieView<Placeholder: View>: UIViewConfiguringSwiftUIView {
     }
     .sizing(sizing)
     .configure { context in
-      applyCurrentAnimationConfiguration(to: context.view)
+      applyCurrentAnimationConfiguration(to: context.view, in: context.container)
     }
     .configurations(configurations)
     .opacity(animationSource == nil ? 0 : 1)
@@ -141,9 +141,42 @@ public struct LottieView<Placeholder: View>: UIViewConfiguringSwiftUIView {
     }
   }
 
+  /// Returns a copy of this `LottieView` updated to have the specific configuration property
+  /// applied to its represented `LottieAnimationView` whenever it is updated via the `updateUIView(...)`
+  /// or `updateNSView(...)` methods.
+  ///
+  /// - note: This configuration will be applied on every SwiftUI render pass.
+  ///         Be wary of applying heavy side-effects as configuration values.
+  public func configure<Property>(
+    _ property: ReferenceWritableKeyPath<LottieAnimationView, Property>,
+    to value: Property)
+    -> Self
+  {
+    configure { $0[keyPath: property] = value }
+  }
+
+  /// Returns a copy of this `LottieView` updated to have the specific configuration property
+  /// applied to its represented `LottieAnimationView` whenever it is updated via the `updateUIView(...)`
+  /// or `updateNSView(...)` methods.
+  ///
+  /// - note: If the `value` is already the currently-applied configuration value, it won't be applied
+  public func configure<Property: Equatable>(
+    _ property: ReferenceWritableKeyPath<LottieAnimationView, Property>,
+    to value: Property)
+    -> Self
+  {
+    configure {
+      guard $0[keyPath: property] != value else { return }
+      $0[keyPath: property] = value
+    }
+  }
+
   /// Returns a copy of this `LottieView` updated to have the given closure applied to its
   /// represented `LottieAnimationView` whenever it is updated via the `updateUIView(…)`
   /// or `updateNSView(…)` method.
+  ///
+  /// - note: This configuration closure will be executed on every SwiftUI render pass.
+  ///         Be wary of applying heavy side-effects inside it.
   public func configure(_ configure: @escaping (LottieAnimationView) -> Void) -> Self {
     var copy = self
     copy.configurations.append { context in
@@ -152,14 +185,22 @@ public struct LottieView<Placeholder: View>: UIViewConfiguringSwiftUIView {
     return copy
   }
 
-  /// Returns a copy of this view that can be resized by scaling its animation to fit the size
-  /// offered by its parent.
+  /// Returns a copy of this view that can be resized by scaling its animation
+  /// to always fit the size offered by its parent.
   public func resizable() -> Self {
     var copy = self
     copy.sizing = .proposed
     return copy
   }
 
+  /// Returns a copy of this view that adopts the intrinsic size of the animation,
+  /// up to the proposed size.
+  public func intrinsicSize() -> Self {
+    var copy = self
+    copy.sizing = .intrinsic
+    return copy
+  }
+
   @available(*, deprecated, renamed: "playing()", message: "Will be removed in a future major release.")
   public func play() -> Self {
     playbackMode(.playing(.fromProgress(nil, toProgress: 1, loopMode: .playOnce)))
@@ -191,7 +232,7 @@ public struct LottieView<Placeholder: View>: UIViewConfiguringSwiftUIView {
     playbackMode(.playing(.fromProgress(nil, toProgress: 1, loopMode: loopMode)))
   }
 
-  // Returns a copy of this view playing once from the current frame to the end frame
+  /// Returns a copy of this view playing once from the current frame to the end frame
   public func playing() -> Self {
     playbackMode(.playing(.fromProgress(nil, toProgress: 1, loopMode: .playOnce)))
   }
@@ -501,7 +542,10 @@ public struct LottieView<Placeholder: View>: UIViewConfiguringSwiftUIView {
   }
 
   /// Applies playback configuration for the current animation to the `LottieAnimationView`
-  private func applyCurrentAnimationConfiguration(to view: LottieAnimationView) {
+  private func applyCurrentAnimationConfiguration(
+    to view: LottieAnimationView,
+    in container: SwiftUIMeasurementContainer<LottieAnimationView>)
+  {
     guard let animationSource else { return }
     var imageProviderConfiguration = imageProviderConfiguration
     var playbackMode = playbackMode
@@ -543,6 +587,10 @@ public struct LottieView<Placeholder: View>: UIViewConfiguringSwiftUIView {
     if animationSource.animation !== view.animation {
       view.loadAnimation(animationSource)
       animationDidLoad?(animationSource)
+
+      // Invalidate the intrinsic size of the SwiftUI measurement container,
+      // since any cached measurements will be out of date after updating the animation.
+      container.invalidateIntrinsicContentSize()
     }
 
     if 

package/Sources/Public/Configuration/ReducedMotionOption.swift

@@ -43,9 +43,9 @@ extension ReducedMotionOption {
   public var currentReducedMotionMode: ReducedMotionMode {
     switch self {
     case .specific(let specificMode):
-      return specificMode
+      specificMode
     case .dynamic(let optionProvider, _):
-      return optionProvider.currentReducedMotionMode
+      optionProvider.currentReducedMotionMode
     }
   }
 }
@@ -56,11 +56,11 @@ extension ReducedMotionOption: Hashable {
   public static func ==(_ lhs: ReducedMotionOption, _ rhs: ReducedMotionOption) -> Bool {
     switch (lhs, rhs) {
     case (.specific(let lhsMode), .specific(let rhsMode)):
-      return lhsMode == rhsMode
+      lhsMode == rhsMode
     case (.dynamic(_, let lhsDataID), .dynamic(_, dataID: let rhsDataID)):
-      return lhsDataID == rhsDataID
+      lhsDataID == rhsDataID
     case (.dynamic, .specific), (.specific, .dynamic):
-      return false
+      false
     }
   }
 

package/Sources/Public/Configuration/RenderingEngineOption.swift

@@ -67,9 +67,9 @@ extension RenderingEngineOption: RawRepresentable, CustomStringConvertible {
   public var rawValue: String {
     switch self {
     case .automatic:
-      return "Automatic"
+      "Automatic"
     case .specific(let engine):
-      return engine.rawValue
+      engine.rawValue
     }
   }
 
@@ -101,9 +101,9 @@ extension RenderingEngine: RawRepresentable, CustomStringConvertible {
   public var rawValue: String {
     switch self {
     case .mainThread:
-      return "Main Thread"
+      "Main Thread"
     case .coreAnimation:
-      return "Core Animation"
+      "Core Animation"
     }
   }
 

package/Sources/Public/Controls/AnimatedSwitch.swift

@@ -213,8 +213,8 @@ open class AnimatedSwitch: AnimatedControl {
 
         // For the Main Thread rendering engine, we freeze the animation at the expected final progress
         // once the animation is complete. This isn't necessary on the Core Animation engine.
-        if finished, !(self.animationView.animationLayer is CoreAnimationLayer) {
-          self.animationView.currentProgress = finalProgress
+        if finished, !(animationView.animationLayer is CoreAnimationLayer) {
+          animationView.currentProgress = finalProgress
         }
       })
   }

package/Sources/Public/DotLottie/DotLottieFile.swift

@@ -56,9 +56,9 @@ public final class DotLottieFile {
   /// The `LottieAnimation` and `DotLottieConfiguration` for the given animation ID in this file
   func animation(for id: String? = nil) -> DotLottieFile.Animation? {
     if let id {
-      return animations.first(where: { $0.configuration.id == id })
+      animations.first(where: { $0.configuration.id == id })
     } else {
-      return animations.first
+      animations.first
     }
   }
 

package/Sources/Public/DynamicProperties/AnyValueProvider.swift

@@ -49,13 +49,13 @@ extension ValueProvider {
   public var typeErasedStorage: AnyValueProviderStorage {
     switch storage {
     case .closure(let typedClosure):
-      return .closure(typedClosure)
+      .closure(typedClosure)
 
     case .singleValue(let typedValue):
-      return .singleValue(typedValue)
+      .singleValue(typedValue)
 
     case .keyframes(let keyframes):
-      return .keyframes(
+      .keyframes(
         keyframes.map { keyframe in
           keyframe.withValue(keyframe.value as Any)
         },
@@ -88,13 +88,13 @@ public enum ValueProviderStorage<T: AnyInterpolatable> {
   func value(frame: AnimationFrameTime) -> T {
     switch self {
     case .singleValue(let value):
-      return value
+      value
 
     case .closure(let closure):
-      return closure(frame)
+      closure(frame)
 
     case .keyframes(let keyframes):
-      return KeyframeInterpolator(keyframes: ContiguousArray(keyframes)).storage.value(frame: frame)
+      KeyframeInterpolator(keyframes: ContiguousArray(keyframes)).storage.value(frame: frame)
     }
   }
 }
@@ -119,13 +119,13 @@ public enum AnyValueProviderStorage {
   func value(frame: AnimationFrameTime) -> Any {
     switch self {
     case .singleValue(let value):
-      return value
+      value
 
     case .closure(let closure):
-      return closure(frame)
+      closure(frame)
 
     case .keyframes(_, let valueForFrame):
-      return valueForFrame(frame)
+      valueForFrame(frame)
     }
   }
 }

package/Sources/Public/DynamicProperties/ValueProviders/GradientValueProvider.swift

@@ -70,7 +70,7 @@ public final class GradientValueProvider: ValueProvider {
 
   public var storage: ValueProviderStorage<[Double]> {
     if let block {
-      return .closure { [self] frame in
+      .closure { [self] frame in
         hasUpdate = false
 
         let newColors = block(frame)
@@ -80,7 +80,7 @@ public final class GradientValueProvider: ValueProvider {
         return value
       }
     } else {
-      return .singleValue(value)
+      .singleValue(value)
     }
   }
 

package/Sources/Public/Keyframes/Interpolatable.swift

@@ -271,9 +271,9 @@ struct Hold<T>: Interpolatable {
 
   func interpolate(to: Hold<T>, amount: CGFloat) -> Hold<T> {
     if amount < 1 {
-      return self
+      self
     } else {
-      return to
+      to
     }
   }
 }

package/Sources/Public/Primitives/LottieColor.swift

@@ -15,11 +15,11 @@ public enum ColorFormatDenominator: Hashable {
   var value: Double {
     switch self {
     case .One:
-      return 1.0
+      1.0
     case .OneHundred:
-      return 100.0
+      100.0
     case .TwoFiftyFive:
-      return 255.0
+      255.0
     }
   }
 }

package/Sources/Public/TextProvider/AnimationTextProvider.swift

@@ -62,22 +62,22 @@ public final class DictionaryTextProvider: AnimationKeypathTextProvider, LegacyA
 
   public func text(for keypath: AnimationKeypath, sourceText: String) -> String? {
     if let valueForFullKeypath = values[keypath.fullPath] {
-      return valueForFullKeypath
+      valueForFullKeypath
     }
 
     else if
       let lastKeypathComponent = keypath.keys.last,
       let valueForLastComponent = values[lastKeypathComponent]
     {
-      return valueForLastComponent
+      valueForLastComponent
     }
 
     else {
-      return sourceText
+      sourceText
     }
   }
 
-  // Never called directly by Lottie, but we continue to implement this conformance for backwards compatibility.
+  /// Never called directly by Lottie, but we continue to implement this conformance for backwards compatibility.
   public func textFor(keypathName: String, sourceText: String) -> String {
     values[keypathName] ?? sourceText
   }

package/Sources/Public/iOS/Compatibility/CompatibleAnimationView.swift

@@ -77,15 +77,15 @@ public enum CompatibleRenderingEngineOption: Int {
   {
     switch configuration {
     case .shared:
-      return LottieConfiguration.shared
+      LottieConfiguration.shared
     case .defaultEngine:
-      return LottieConfiguration(renderingEngine: .coreAnimation)
+      LottieConfiguration(renderingEngine: .coreAnimation)
     case .automatic:
-      return LottieConfiguration(renderingEngine: .automatic)
+      LottieConfiguration(renderingEngine: .automatic)
     case .mainThread:
-      return LottieConfiguration(renderingEngine: .mainThread)
+      LottieConfiguration(renderingEngine: .mainThread)
     case .coreAnimation:
-      return LottieConfiguration(renderingEngine: .coreAnimation)
+      LottieConfiguration(renderingEngine: .coreAnimation)
     }
   }
 }
@@ -219,7 +219,8 @@ public final class CompatibleAnimationView: UIView {
     }
   }
 
-  @objc public override var contentMode: UIView.ContentMode {
+  @objc
+  public override var contentMode: UIView.ContentMode {
     set { animationView.contentMode = newValue }
     get { animationView.contentMode }
   }
@@ -285,15 +286,15 @@ public final class CompatibleAnimationView: UIView {
     get {
       switch animationView.backgroundBehavior {
       case .stop:
-        return .stop
+        .stop
       case .pause:
-        return .pause
+        .pause
       case .pauseAndRestore:
-        return .pauseAndRestore
+        .pauseAndRestore
       case .forceFinish:
-        return .forceFinish
+        .forceFinish
       case .continuePlaying:
-        return .continuePlaying
+        .continuePlaying
       }
     }
     set {
@@ -440,7 +441,7 @@ public final class CompatibleAnimationView: UIView {
   public func getColorValue(for keypath: CompatibleAnimationKeypath, atFrame: CGFloat) -> UIColor? {
     let value = animationView.getValue(for: keypath.animationKeypath, atFrame: atFrame)
     guard let colorValue = value as? LottieColor else {
-      return nil;
+      return nil
     }
 
     return UIColor(

package/Version.xcconfig

@@ -2,5 +2,5 @@
 // Copyright © 2024 Airbnb Inc. All rights reserved.
 
 // The version numbers used when building Lottie.xcframework
-MARKETING_VERSION = 4.4.2
-CURRENT_PROJECT_VERSION = 442 // a three-digit representation of the marketing version, without dots.
+MARKETING_VERSION = 4.5.0
+CURRENT_PROJECT_VERSION = 443 // a three-digit representation of the marketing version, without dots.

package/lottie-ios.podspec

@@ -8,7 +8,7 @@
 
 Pod::Spec.new do |s|
   s.name             = 'lottie-ios'
-  s.version          = '4.4.2'
+  s.version          = '4.5.0'
   s.summary          = 'A library to render native animations from bodymovin json'
 
   s.description = <<-DESC
@@ -22,7 +22,7 @@ Lottie enables designers to create and ship beautiful animations without an engi
   s.author           = { 'Brandon Withrow' => 'buba447@gmail.com', 'Cal Stephens' => 'cal.stephens@airbnb.com' }
   s.source           = { :git => 'https://github.com/airbnb/lottie-ios.git', :tag => s.version.to_s }
 
-  s.swift_version = '5.7'
+  s.swift_version = '5.9'
   s.ios.deployment_target = '13.0'
   s.osx.deployment_target = '10.15'
   s.tvos.deployment_target = '13.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lottie-ios",
-  "version": "4.4.2",
+  "version": "4.5.0",
   "description": "Lottie is a mobile library for Android and iOS that parses Adobe After Effects animations exported as json with bodymovin and renders the vector animations natively on mobile and through React Native!",
   "main": "index.js",
   "scripts": {