lottie-ios 4.4.2 → 4.5.0

package/Sources/Private/Utility/Extensions/AnimationKeypathExtension.swift

@@ -124,12 +124,12 @@ extension KeypathSearchable {
   func allKeypaths(for keyPath: AnimationKeypath? = nil) -> [String] {
     var allKeypaths: [String] = []
 
-    let newKeypath: AnimationKeypath
-    if let previousKeypath = keyPath {
-      newKeypath = previousKeypath.appendingKey(keypathName)
-    } else {
-      newKeypath = AnimationKeypath(keys: [keypathName])
-    }
+    let newKeypath: AnimationKeypath =
+      if let previousKeypath = keyPath {
+        previousKeypath.appendingKey(keypathName)
+      } else {
+        AnimationKeypath(keys: [keypathName])
+      }
 
     allKeypaths.append(newKeypath.fullPath)
 
@@ -148,12 +148,12 @@ extension KeypathSearchable {
   func layerKeypaths(for keyPath: AnimationKeypath? = nil) -> [CALayer: AnimationKeypath] {
     var allKeypaths: [CALayer: AnimationKeypath] = [:]
 
-    let newKeypath: AnimationKeypath
-    if let previousKeypath = keyPath {
-      newKeypath = previousKeypath.appendingKey(keypathName)
-    } else {
-      newKeypath = AnimationKeypath(keys: [keypathName])
-    }
+    let newKeypath: AnimationKeypath =
+      if let previousKeypath = keyPath {
+        previousKeypath.appendingKey(keypathName)
+      } else {
+        AnimationKeypath(keys: [keypathName])
+      }
 
     if let layer = self as? CALayer {
       allKeypaths[layer] = newKeypath
@@ -197,7 +197,7 @@ extension AnimationKeypath {
     keys.joined(separator: ".")
   }
 
-  // Pops the top keypath from the stack if the keyname matches.
+  /// Pops the top keypath from the stack if the keyname matches.
   func popKey(_ keyname: String) -> AnimationKeypath? {
     guard
       let currentKey,
@@ -245,11 +245,11 @@ extension String {
   var keyPathType: KeyType {
     switch self {
     case "*":
-      return .wildcard
+      .wildcard
     case "**":
-      return .fuzzyWildcard
+      .fuzzyWildcard
     default:
-      return .specific
+      .specific
     }
   }
 

package/Sources/Private/Utility/Extensions/BlendMode+Filter.swift

@@ -10,22 +10,22 @@ extension BlendMode {
   /// Supported compositing filters are defined here: https://developer.apple.com/library/archive/documentation/GraphicsImaging/Reference/CoreImageFilterReference/index.html#//apple_ref/doc/uid/TP30000136-SW71
   var filterName: String? {
     switch self {
-    case .normal: return nil
-    case .multiply: return "multiplyBlendMode"
-    case .screen: return "screenBlendMode"
-    case .overlay: return "overlayBlendMode"
-    case .darken: return "darkenBlendMode"
-    case .lighten: return "lightenBlendMode"
-    case .colorDodge: return "colorDodgeBlendMode"
-    case .colorBurn: return "colorBurnBlendMode"
-    case .hardLight: return "hardLightBlendMode"
-    case .softLight: return "softLightBlendMode"
-    case .difference: return "differenceBlendMode"
-    case .exclusion: return "exclusionBlendMode"
-    case .hue: return "hueBlendMode"
-    case .saturation: return "saturationBlendMode"
-    case .color: return "colorBlendMode"
-    case .luminosity: return "luminosityBlendMode"
+    case .normal: nil
+    case .multiply: "multiplyBlendMode"
+    case .screen: "screenBlendMode"
+    case .overlay: "overlayBlendMode"
+    case .darken: "darkenBlendMode"
+    case .lighten: "lightenBlendMode"
+    case .colorDodge: "colorDodgeBlendMode"
+    case .colorBurn: "colorBurnBlendMode"
+    case .hardLight: "hardLightBlendMode"
+    case .softLight: "softLightBlendMode"
+    case .difference: "differenceBlendMode"
+    case .exclusion: "exclusionBlendMode"
+    case .hue: "hueBlendMode"
+    case .saturation: "saturationBlendMode"
+    case .color: "colorBlendMode"
+    case .luminosity: "luminosityBlendMode"
     }
   }
 }

package/Sources/Private/Utility/Extensions/CGColor+RGB.swift

@@ -4,6 +4,23 @@
 import QuartzCore
 
 extension CGColor {
+  /// Retrieves the red, green, and blue color values from this `CGColor`
+  var rgb: (red: CGFloat, green: CGFloat, blue: CGFloat)? {
+    guard let components else { return nil }
+
+    switch numberOfComponents {
+    case 2:
+      return (red: components[0], green: components[0], blue: components[0])
+
+    case 3, 4:
+      return (red: components[0], green: components[1], blue: components[2])
+
+    default:
+      // Unsupported conversion
+      return nil
+    }
+  }
+
   /// Initializes a `CGColor` using the given `RGB` values
   static func rgb(_ red: CGFloat, _ green: CGFloat, _ blue: CGFloat) -> CGColor {
     rgba(red, green, blue, 1.0)
@@ -22,4 +39,5 @@ extension CGColor {
       colorSpace: LottieConfiguration.shared.colorSpace,
       components: [red, green, blue, alpha])!
   }
+
 }

package/Sources/Private/Utility/Extensions/CGFloatExtensions.swift

@@ -41,19 +41,19 @@ extension CGFloat {
       t = 1
     } else {
       // Calculate t
-      let a = -P0.x + 3 * P1.x - 3 * P2.x + P3.x;
-      let b = 3 * P0.x - 6 * P1.x + 3 * P2.x;
-      let c = -3 * P0.x + 3 * P1.x;
-      let d = P0.x - self;
-      let tTemp = CGFloat.SolveCubic(a, b, c, d);
+      let a = -P0.x + 3 * P1.x - 3 * P2.x + P3.x
+      let b = 3 * P0.x - 6 * P1.x + 3 * P2.x
+      let c = -3 * P0.x + 3 * P1.x
+      let d = P0.x - self
+      let tTemp = CGFloat.SolveCubic(a, b, c, d)
       if tTemp == -1 {
-        return -1;
+        return -1
       }
       t = tTemp
     }
 
     // Calculate y from t
-    return (1 - t).cubed * P0.y + 3 * t * (1 - t).squared * P1.y + 3 * t.squared * (1 - t) * P2.y + t.cubed * P3.y;
+    return (1 - t).cubed * P0.y + 3 * t * (1 - t).squared * P1.y + 3 * t.squared * (1 - t) * P2.y + t.cubed * P3.y
   }
 
   func cubicBezier(_ t: CGFloat, _ c1: CGFloat, _ c2: CGFloat, _ end: CGFloat) -> CGFloat {
@@ -66,23 +66,23 @@ extension CGFloat {
     return self * ttt_
       + 3.0 * c1 * tt_ * t
       + 3.0 * c2 * t_ * tt
-      + end * ttt;
+      + end * ttt
   }
 
   // MARK: Fileprivate
 
   fileprivate static func SolveQuadratic(_ a: CGFloat, _ b: CGFloat, _ c: CGFloat) -> CGFloat {
-    var result = (-b + sqrt(b.squared - 4 * a * c)) / (2 * a);
+    var result = (-b + sqrt(b.squared - 4 * a * c)) / (2 * a)
     guard !result.isInRangeOrEqual(0, 1) else {
       return result
     }
 
-    result = (-b - sqrt(b.squared - 4 * a * c)) / (2 * a);
+    result = (-b - sqrt(b.squared - 4 * a * c)) / (2 * a)
     guard !result.isInRangeOrEqual(0, 1) else {
       return result
     }
 
-    return -1;
+    return -1
   }
 
   fileprivate static func SolveCubic(_ a: CGFloat, _ b: CGFloat, _ c: CGFloat, _ d: CGFloat) -> CGFloat {
@@ -110,43 +110,43 @@ extension CGFloat {
       var t = r - sqrt(disc)
       t = (t < 0) ? -((-t).cubicRoot) : t.cubicRoot
 
-      let result = -term1 + s + t;
+      let result = -term1 + s + t
       if result.isInRangeOrEqual(0, 1) {
         return result
       }
     } else if disc == 0 {
-      let r13 = (r < 0) ? -((-r).cubicRoot) : r.cubicRoot;
+      let r13 = (r < 0) ? -((-r).cubicRoot) : r.cubicRoot
 
-      var result = -term1 + 2.0 * r13;
+      var result = -term1 + 2.0 * r13
       if result.isInRangeOrEqual(0, 1) {
         return result
       }
 
-      result = -(r13 + term1);
+      result = -(r13 + term1)
       if result.isInRangeOrEqual(0, 1) {
         return result
       }
 
     } else {
-      q = -q;
-      var dum1 = q * q * q;
-      dum1 = acos(r / sqrt(dum1));
-      let r13 = 2.0 * sqrt(q);
+      q = -q
+      var dum1 = q * q * q
+      dum1 = acos(r / sqrt(dum1))
+      let r13 = 2.0 * sqrt(q)
 
-      var result = -term1 + r13 * cos(dum1 / 3.0);
+      var result = -term1 + r13 * cos(dum1 / 3.0)
       if result.isInRangeOrEqual(0, 1) {
         return result
       }
-      result = -term1 + r13 * cos((dum1 + 2.0 * .pi) / 3.0);
+      result = -term1 + r13 * cos((dum1 + 2.0 * .pi) / 3.0)
       if result.isInRangeOrEqual(0, 1) {
         return result
       }
-      result = -term1 + r13 * cos((dum1 + 4.0 * .pi) / 3.0);
+      result = -term1 + r13 * cos((dum1 + 4.0 * .pi) / 3.0)
       if result.isInRangeOrEqual(0, 1) {
         return result
       }
     }
 
-    return -1;
+    return -1
   }
 }

package/Sources/Private/Utility/Extensions/MathKit.swift

@@ -33,13 +33,6 @@ extension CGFloat {
     return toLow + (self - fromLow) * (toHigh - toLow) / (fromHigh - fromLow)
   }
 
-  /// Returns a value that is clamped between the two numbers
-  ///
-  /// 1. The order of arguments does not matter.
-  func clamp(_ a: CGFloat, _ b: CGFloat) -> CGFloat {
-    CGFloat(Double(self).clamp(Double(a), Double(b)))
-  }
-
   /// Returns the difference between the receiver and the given number.
   /// - Parameter absolute: If *true* (Default) the returned value will always be positive.
   func diff(_ a: CGFloat, absolute: Bool = true) -> CGFloat {
@@ -54,20 +47,20 @@ extension CGFloat {
 // MARK: - Double
 
 extension Double {
-
   func remap(fromLow: Double, fromHigh: Double, toLow: Double, toHigh: Double) -> Double {
     toLow + (self - fromLow) * (toHigh - toLow) / (fromHigh - fromLow)
   }
+}
 
+extension Numeric where Self: Comparable {
   /// Returns a value that is clamped between the two numbers
   ///
   /// 1. The order of arguments does not matter.
-  func clamp(_ a: Double, _ b: Double) -> Double {
+  func clamp(_ a: Self, _ b: Self) -> Self {
     let minValue = a <= b ? a : b
     let maxValue = a <= b ? b : a
     return max(min(self, maxValue), minValue)
   }
-
 }
 
 extension CGRect {
@@ -426,7 +419,7 @@ extension CGPoint {
   }
 
   func colinear(_ a: CGPoint, _ b: CGPoint) -> Bool {
-    let area = x * (a.y - b.y) + a.x * (b.y - y) + b.x * (y - a.y);
+    let area = x * (a.y - b.y) + a.x * (b.y - y) + b.x * (y - a.y)
     let accuracy: CGFloat = 0.05
     if area < accuracy, area > -accuracy {
       return true

package/Sources/Private/Utility/Interpolatable/InterpolatableExtensions.swift

@@ -16,7 +16,7 @@ extension LottieColor {
   init(h: Double, s: Double, v: Double, a: Double) {
     let i = floor(h * 6)
     let f = h * 6 - i
-    let p = v * (1 - s);
+    let p = v * (1 - s)
     let q = v * (1 - f * s)
     let t = v * (1 - (1 - f) * s)
 
@@ -25,26 +25,32 @@ extension LottieColor {
       r = v
       g = t
       b = p
+
     case 1:
       r = q
       g = v
       b = p
+
     case 2:
       r = p
       g = v
       b = t
+
     case 3:
       r = p
       g = q
       b = v
+
     case 4:
       r = t
       g = p
       b = v
+
     case 5:
       r = v
       g = p
       b = q
+
     default:
       r = 0
       g = 0
@@ -71,10 +77,10 @@ extension LottieColor {
     var h: Double, s: Double, v: Double = maxValue
 
     let d = maxValue - minValue
-    s = maxValue == 0 ? 0 : d / maxValue;
+    s = maxValue == 0 ? 0 : d / maxValue
 
     if maxValue == minValue {
-      h = 0; // achromatic
+      h = 0 // achromatic
     } else {
       switch maxValue {
       case r: h = (g - b) / d + (g < b ? 6 : 0)

package/Sources/Private/Utility/LottieAnimationSource.swift

@@ -19,9 +19,9 @@ extension LottieAnimationSource {
   var animation: LottieAnimation? {
     switch self {
     case .lottieAnimation(let animation):
-      return animation
+      animation
     case .dotLottieFile:
-      return dotLottieAnimation?.animation
+      dotLottieAnimation?.animation
     }
   }
 
@@ -29,9 +29,9 @@ extension LottieAnimationSource {
   var dotLottieAnimation: DotLottieFile.Animation? {
     switch self {
     case .lottieAnimation:
-      return nil
+      nil
     case .dotLottieFile(let dotLottieFile):
-      return dotLottieFile.animation()
+      dotLottieFile.animation()
     }
   }
 }

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

@@ -343,7 +343,14 @@ extension BezierPath: Codable {
       totalLength = totalLength + pathElement.length
     }
     if closed {
-      let closeElement = previousElement.pathElementTo(firstVertex)
+      // Don't use an out tangent for the closing point, since the
+      // closing point is exactly equal to the starting point.
+      let closeVertex = CurveVertex(
+        point: firstVertex.point,
+        inTangentRelative: firstVertex.inTangentRelative,
+        outTangentRelative: .zero)
+
+      let closeElement = previousElement.pathElementTo(closeVertex)
       decodedElements.append(closeElement)
       totalLength = totalLength + closeElement.length
     }
@@ -448,7 +455,14 @@ extension BezierPath: AnyInitializable {
       totalLength = totalLength + pathElement.length
     }
     if closed {
-      let closeElement = previousElement.pathElementTo(firstVertex)
+      // Don't use an out tangent for the closing point, since the
+      // closing point is exactly equal to the starting point.
+      let closeVertex = CurveVertex(
+        point: firstVertex.point,
+        inTangentRelative: firstVertex.inTangentRelative,
+        outTangentRelative: .zero)
+
+      let closeElement = previousElement.pathElementTo(closeVertex)
       decodedElements.append(closeElement)
       totalLength = totalLength + closeElement.length
     }

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

@@ -30,7 +30,7 @@ import Foundation
 //    shape's vertex distances and the roundedness set in the animation.
 
 extension CompoundBezierPath {
-  // Round corners of a compound bezier
+  /// Round corners of a compound bezier
   func roundCorners(radius: CGFloat) -> CompoundBezierPath {
     var newPaths = [BezierPath]()
     for path in paths {
@@ -43,7 +43,7 @@ extension CompoundBezierPath {
 }
 
 extension BezierPath {
-  // Computes a new `BezierPath` with each corner rounded based on the given `radius`
+  /// Computes a new `BezierPath` with each corner rounded based on the given `radius`
   func roundCorners(radius: CGFloat) -> BezierPath {
     var newPath = BezierPath()
     var uniquePath = BezierPath()

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

@@ -16,26 +16,26 @@ extension LottieColor: Codable {
   public init(from decoder: Decoder) throws {
     var container = try decoder.unkeyedContainer()
 
-    var r1: Double
-    if !container.isAtEnd {
-      r1 = try container.decode(Double.self)
-    } else {
-      r1 = 0
-    }
-
-    var g1: Double
-    if !container.isAtEnd {
-      g1 = try container.decode(Double.self)
-    } else {
-      g1 = 0
-    }
-
-    var b1: Double
-    if !container.isAtEnd {
-      b1 = try container.decode(Double.self)
-    } else {
-      b1 = 0
-    }
+    var r1: Double =
+      if !container.isAtEnd {
+        try container.decode(Double.self)
+      } else {
+        0
+      }
+
+    var g1: Double =
+      if !container.isAtEnd {
+        try container.decode(Double.self)
+      } else {
+        0
+      }
+
+    var b1: Double =
+      if !container.isAtEnd {
+        try container.decode(Double.self)
+      } else {
+        0
+      }
 
     if r1 > 1, g1 > 1, b1 > 1 {
       r1 = r1 / 255

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

@@ -101,15 +101,15 @@ struct CompoundBezierPath {
       return self
     }
 
-    var positions: [(start: CGFloat, end: CGFloat)]
-    if endPosition < startPosition {
-      positions = [
-        (start: 0, end: endPosition * length),
-        (start: startPosition * length, end: length),
-      ]
-    } else {
-      positions = [(start: startPosition * length, end: endPosition * length)]
-    }
+    var positions: [(start: CGFloat, end: CGFloat)] =
+      if endPosition < startPosition {
+        [
+          (start: 0, end: endPosition * length),
+          (start: startPosition * length, end: length),
+        ]
+      } else {
+        [(start: startPosition * length, end: endPosition * length)]
+      }
 
     var compoundPath = CompoundBezierPath()
     var trim = positions.remove(at: 0)

package/Sources/Public/Animation/LottieAnimationLayer.swift

@@ -237,12 +237,12 @@ public class LottieAnimationLayer: CALayer {
       self.loopMode = loopMode
     }
 
-    let fromTime: CGFloat
-    if let fromName = fromMarker, let from = markers[fromName] {
-      fromTime = CGFloat(from.frameTime)
-    } else {
-      fromTime = currentFrame
-    }
+    let fromTime: CGFloat =
+      if let fromName = fromMarker, let from = markers[fromName] {
+        CGFloat(from.frameTime)
+      } else {
+        currentFrame
+      }
 
     let playTo = playEndMarkerFrame ? CGFloat(to.frameTime) : CGFloat(to.frameTime) - 1
     let context = AnimationContext(
@@ -339,7 +339,7 @@ public class LottieAnimationLayer: CALayer {
         // If we don't have any more markers to play, then the marker sequence has completed.
         completion?(completed)
       } else {
-        self.play(markers: followingMarkers, completion: completion)
+        play(markers: followingMarkers, completion: completion)
       }
     })
   }
@@ -370,6 +370,7 @@ public class LottieAnimationLayer: CALayer {
 
     case .frame(let animationFrameTime):
       currentFrame = animationFrameTime
+
     case .time(let timeInterval):
       currentTime = timeInterval
 
@@ -670,9 +671,9 @@ public class LottieAnimationLayer: CALayer {
     }
     get {
       if let animation {
-        return animation.progressTime(forFrame: currentFrame)
+        animation.progressTime(forFrame: currentFrame)
       } else {
-        return 0
+        0
       }
     }
   }
@@ -692,9 +693,9 @@ public class LottieAnimationLayer: CALayer {
     }
     get {
       if let animation {
-        return animation.time(forFrame: currentFrame)
+        animation.time(forFrame: currentFrame)
       } else {
-        return 0
+        0
       }
     }
   }
@@ -992,16 +993,20 @@ public class LottieAnimationLayer: CALayer {
       case .stop:
         removeCurrentAnimation()
         updateAnimationFrame(currentContext.playFrom)
+
       case .pause:
         removeCurrentAnimation()
+
       case .pauseAndRestore:
         currentContext.closure.ignoreDelegate = true
         removeCurrentAnimation()
         /// Keep the stale context around for when the app enters the foreground.
         animationContext = currentContext
+
       case .forceFinish:
         removeCurrentAnimation()
         updateAnimationFrame(currentContext.playTo)
+
       case .continuePlaying:
         break
       }
@@ -1117,9 +1122,9 @@ public class LottieAnimationLayer: CALayer {
   fileprivate var activeAnimationName: String {
     switch rootAnimationLayer?.primaryAnimationKey {
     case .specific(let animationKey):
-      return animationKey
+      animationKey
     case .managed, nil:
-      return _activeAnimationName
+      _activeAnimationName
     }
   }
 
@@ -1148,15 +1153,15 @@ public class LottieAnimationLayer: CALayer {
     guard let animation else {
       return
     }
-    let rootAnimationLayer: RootAnimationLayer?
-    switch renderingEngine {
-    case .automatic:
-      rootAnimationLayer = makeAutomaticEngineLayer(for: animation)
-    case .specific(.coreAnimation):
-      rootAnimationLayer = makeCoreAnimationLayer(for: animation)
-    case .specific(.mainThread):
-      rootAnimationLayer = makeMainThreadAnimationLayer(for: animation)
-    }
+    let rootAnimationLayer: RootAnimationLayer? =
+      switch renderingEngine {
+      case .automatic:
+        makeAutomaticEngineLayer(for: animation)
+      case .specific(.coreAnimation):
+        makeCoreAnimationLayer(for: animation)
+      case .specific(.mainThread):
+        makeMainThreadAnimationLayer(for: animation)
+      }
 
     guard let animationLayer = rootAnimationLayer else {
       return
@@ -1259,8 +1264,8 @@ public class LottieAnimationLayer: CALayer {
     }
   }
 
-  // Handles any compatibility issues with the Core Animation engine
-  // by falling back to the Main Thread engine
+  /// Handles any compatibility issues with the Core Animation engine
+  /// by falling back to the Main Thread engine
   fileprivate func automaticEngineLayerDidSetUpAnimation(_ compatibilityIssues: [CompatibilityIssue]) {
     // If there weren't any compatibility issues, then there's nothing else to do
     if compatibilityIssues.isEmpty {
@@ -1462,9 +1467,9 @@ public class LottieAnimationLayer: CALayer {
   private var reducedMotionMarker: Marker? {
     switch configuration.reducedMotionOption.currentReducedMotionMode {
     case .standardMotion:
-      return nil
+      nil
     case .reducedMotion:
-      return animation?.reducedMotionMarker
+      animation?.reducedMotionMarker
     }
   }
 
@@ -1503,15 +1508,15 @@ extension LottieLoopMode {
   var caAnimationConfiguration: (repeatCount: Float, autoreverses: Bool) {
     switch self {
     case .playOnce:
-      return (repeatCount: 1, autoreverses: false)
+      (repeatCount: 1, autoreverses: false)
     case .loop:
-      return (repeatCount: .greatestFiniteMagnitude, autoreverses: false)
+      (repeatCount: .greatestFiniteMagnitude, autoreverses: false)
     case .autoReverse:
-      return (repeatCount: .greatestFiniteMagnitude, autoreverses: true)
+      (repeatCount: .greatestFiniteMagnitude, autoreverses: true)
     case .repeat(let amount):
-      return (repeatCount: amount, autoreverses: false)
+      (repeatCount: amount, autoreverses: false)
     case .repeatBackwards(let amount):
-      return (repeatCount: amount, autoreverses: true)
+      (repeatCount: amount, autoreverses: true)
     }
   }
 }