lottie-ios 3.2.2 → 3.4.1

package/{lottie-swift/src → Sources}/Private/Utility/Extensions/AnimationKeypathExtension.swift

@@ -9,69 +9,77 @@ import Foundation
 import QuartzCore
 
 extension KeypathSearchable {
-  
+
   func animatorNodes(for keyPath: AnimationKeypath) -> [AnimatorNode]? {
     // Make sure there is a current key path.
     guard let currentKey = keyPath.currentKey else { return nil }
-    
+
     // Now try popping the keypath for wildcard / child search
     guard let nextKeypath = keyPath.popKey(keypathName) else {
       // We may be on the final keypath. Check for match.
-      if let node = self as? AnimatorNode,
-        currentKey.equalsKeypath(keypathName) {
+      if
+        let node = self as? AnimatorNode,
+        currentKey.equalsKeypath(keypathName)
+      {
         // This is the final keypath and matches self. Return.s
         return [node]
       }
       /// Nope. Stop Search
       return nil
     }
-    
+
     var results: [AnimatorNode] = []
-    
-    if let node = self as? AnimatorNode,
-      nextKeypath.currentKey == nil {
+
+    if
+      let node = self as? AnimatorNode,
+      nextKeypath.currentKey == nil
+    {
       // Keypath matched self and was the final keypath.
       results.append(node)
     }
-    
+
     for childNode in childKeypaths {
       // Check if the child has any nodes matching the next keypath.
       if let foundNodes = childNode.animatorNodes(for: nextKeypath) {
         results.append(contentsOf: foundNodes)
       }
-      
+
       // In this case the current key is fuzzy, and both child and self match the next keyname. Keep digging!
-      if currentKey.keyPathType == .fuzzyWildcard,
+      if
+        currentKey.keyPathType == .fuzzyWildcard,
         let nextKeypath = keyPath.nextKeypath,
         nextKeypath.equalsKeypath(childNode.keypathName),
-        let foundNodes = childNode.animatorNodes(for: keyPath) {
+        let foundNodes = childNode.animatorNodes(for: keyPath)
+      {
         results.append(contentsOf: foundNodes)
       }
     }
-    
+
     guard results.count > 0 else {
       return nil
     }
-    
+
     return results
   }
-  
+
   func nodeProperties(for keyPath: AnimationKeypath) -> [AnyNodeProperty]? {
     guard let nextKeypath = keyPath.popKey(keypathName) else {
       /// Nope. Stop Search
       return nil
     }
-    
+
     /// Keypath matches in some way. Continue the search.
     var results: [AnyNodeProperty] = []
-    
+
     /// Check if we have a property keypath yet
-    if let propertyKey = nextKeypath.propertyKey,
-      let property = keypathProperties[propertyKey] {
+    if
+      let propertyKey = nextKeypath.propertyKey,
+      let property = keypathProperties[propertyKey]
+    {
       /// We found a property!
       results.append(property)
     }
-    
+
     if nextKeypath.nextKeypath != nil {
       /// Now check child keypaths.
       for child in childKeypaths {
@@ -80,16 +88,16 @@ extension KeypathSearchable {
         }
       }
     }
-    
+
     guard results.count > 0 else {
       return nil
     }
-    
+
     return results
   }
-  
+
   func layer(for keyPath: AnimationKeypath) -> CALayer? {
-    if keyPath.nextKeypath == nil, let layerKey = keyPath.currentKey,  layerKey.equalsKeypath(keypathName) {
+    if keyPath.nextKeypath == nil, let layerKey = keyPath.currentKey, layerKey.equalsKeypath(keypathName) {
       /// We found our layer!
       return keypathLayer
     }
@@ -97,47 +105,45 @@ extension KeypathSearchable {
       /// Nope. Stop Search
       return nil
     }
-    
-    if nextKeypath.nextKeypath != nil {
-      /// Now check child keypaths.
-      for child in childKeypaths {
-        if let layer = child.layer(for: keyPath) {
-          return layer
-        }
+
+    /// Now check child keypaths.
+    for child in childKeypaths {
+      if let layer = child.layer(for: nextKeypath) {
+        return layer
       }
     }
     return nil
   }
-  
-  func logKeypaths(for keyPath: AnimationKeypath?) {
+
+  func logKeypaths(for keyPath: AnimationKeypath?, logger: LottieLogger) {
     let newKeypath: AnimationKeypath
     if let previousKeypath = keyPath {
       newKeypath = previousKeypath.appendingKey(keypathName)
     } else {
       newKeypath = AnimationKeypath(keys: [keypathName])
     }
-    print(newKeypath.fullPath)
+    logger.info(newKeypath.fullPath)
     for key in keypathProperties.keys {
-      print(newKeypath.appendingKey(key).fullPath)
+      logger.info(newKeypath.appendingKey(key).fullPath)
     }
     for child in childKeypaths {
-      child.logKeypaths(for: newKeypath)
+      child.logKeypaths(for: newKeypath, logger: logger)
     }
   }
 }
 
 extension AnimationKeypath {
   var currentKey: String? {
-    return keys.first
+    keys.first
   }
-  
+
   var nextKeypath: String? {
     guard keys.count > 1 else {
       return nil
     }
     return keys[1]
   }
-  
+
   var propertyKey: String? {
     if nextKeypath == nil {
       /// There are no more keypaths. This is a property key.
@@ -149,23 +155,31 @@ extension AnimationKeypath {
     }
     return nil
   }
-  
+
+  var fullPath: String {
+    keys.joined(separator: ".")
+  }
+
   // Pops the top keypath from the stack if the keyname matches.
   func popKey(_ keyname: String) -> AnimationKeypath? {
-    guard let currentKey = currentKey,
+    guard
+      let currentKey = currentKey,
       currentKey.equalsKeypath(keyname),
-      keys.count > 1 else {
-        // Current key either doesnt match or we are on the last key.
-        return nil
+      keys.count > 1 else
+    {
+      // Current key either doesnt match or we are on the last key.
+      return nil
     }
-    
+
     // Pop the keypath from the stack and return the new stack.
     let newKeys: [String]
-    
+
     if currentKey.keyPathType == .fuzzyWildcard {
       /// Dont remove if current key is a fuzzy wildcard, and if the next keypath doesnt equal keypathname
-      if let nextKeypath = nextKeypath,
-        nextKeypath.equalsKeypath(keyname) {
+      if
+        let nextKeypath = nextKeypath,
+        nextKeypath.equalsKeypath(keyname)
+      {
         /// Remove next two keypaths. This keypath breaks the wildcard.
         var oldKeys = keys
         oldKeys.remove(at: 0)
@@ -179,14 +193,10 @@ extension AnimationKeypath {
       oldKeys.remove(at: 0)
       newKeys = oldKeys
     }
-    
+
     return AnimationKeypath(keys: newKeys)
   }
-  
-  var fullPath: String {
-    return keys.joined(separator: ".")
-  }
-  
+
   func appendingKey(_ key: String) -> AnimationKeypath {
     var newKeys = keys
     newKeys.append(key)
@@ -194,8 +204,6 @@ extension AnimationKeypath {
   }
 }
 
-
-
 extension String {
   var keyPathType: KeyType {
     switch self {
@@ -207,7 +215,7 @@ extension String {
       return .specific
     }
   }
-  
+
   func equalsKeypath(_ keyname: String) -> Bool {
     if keyPathType == .wildcard || keyPathType == .fuzzyWildcard {
       return true
@@ -215,11 +223,11 @@ extension String {
     if self == keyname {
       return true
     }
-    if let index = self.firstIndex(of: "*") {
+    if let index = firstIndex(of: "*") {
       // Wildcard search.
       let prefix = String(self.prefix(upTo: index))
       let suffix = String(self.suffix(from: self.index(after: index)))
-      
+
       if prefix.count > 0 {
         // Match prefix.
         if keyname.count < prefix.count {
@@ -249,6 +257,8 @@ extension String {
   }
 }
 
+// MARK: - KeyType
+
 enum KeyType {
   case specific
   case wildcard

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

@@ -0,0 +1,31 @@
+//
+//  File.swift
+//
+//
+//  Created by Denis Koryttsev on 10.05.2022.
+//
+
+extension BlendMode {
+  /// The Core Image filter name for this `BlendMode`, that can be applied to a `CALayer`'s `compositingFilter`.
+  /// 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"
+    }
+  }
+}

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

@@ -0,0 +1,22 @@
+// Created by Cal Stephens on 1/7/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+extension CGColor {
+  /// Initializes a `CGColor` using the given `RGB` values
+  static func rgb(_ red: CGFloat, _ green: CGFloat, _ blue: CGFloat) -> CGColor {
+    if #available(iOS 13.0, tvOS 13.0, macOS 10.5, *) {
+      return CGColor(red: red, green: green, blue: blue, alpha: 1)
+    } else {
+      return CGColor(
+        colorSpace: CGColorSpaceCreateDeviceRGB(),
+        components: [red, green, blue])!
+    }
+  }
+
+  /// Initializes a `CGColor` using the given `RGBA` values
+  static func rgba(_ red: CGFloat, _ green: CGFloat, _ blue: CGFloat, _ alpha: CGFloat) -> CGColor {
+    CGColor.rgb(red, green, blue).copy(alpha: alpha)!
+  }
+}

package/{lottie-swift/src → Sources}/Private/Utility/Extensions/CGFloatExtensions.swift

@@ -9,46 +9,87 @@ import Foundation
 import QuartzCore
 
 extension CGFloat {
-  
-  func isInRangeOrEqual(_ from: CGFloat, _ to: CGFloat) -> Bool {
-    return (from <= self && self <= to)
-  }
-  
-  func isInRange(_ from: CGFloat, _ to: CGFloat) -> Bool {
-    return (from < self && self < to)
-  }
-  
+
+  // MARK: Internal
+
   var squared: CGFloat {
-    return self * self
+    self * self
   }
-  
+
   var cubed: CGFloat {
-    return self * self * self
+    self * self * self
   }
-  
+
   var cubicRoot: CGFloat {
-    return CGFloat(pow(Double(self), 1.0 / 3.0))
+    CGFloat(pow(Double(self), 1.0 / 3.0))
+  }
+
+  func isInRangeOrEqual(_ from: CGFloat, _ to: CGFloat) -> Bool {
+    from <= self && self <= to
+  }
+
+  func isInRange(_ from: CGFloat, _ to: CGFloat) -> Bool {
+    from < self && self < to
+  }
+
+  func cubicBezierInterpolate(_ P0: CGPoint, _ P1: CGPoint, _ P2: CGPoint, _ P3: CGPoint) -> CGFloat {
+    var t: CGFloat
+    if self == P0.x {
+      // Handle corner cases explicitly to prevent rounding errors
+      t = 0
+    } else if self == P3.x {
+      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);
+      if tTemp == -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;
+  }
+
+  func cubicBezier(_ t: CGFloat, _ c1: CGFloat, _ c2: CGFloat, _ end: CGFloat) -> CGFloat {
+    let t_ = (1.0 - t)
+    let tt_ = t_ * t_
+    let ttt_ = t_ * t_ * t_
+    let tt = t * t
+    let ttt = t * t * t
+
+    return self * ttt_
+      + 3.0 * c1 * tt_ * t
+      + 3.0 * c2 * t_ * tt
+      + 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);
     guard !result.isInRangeOrEqual(0, 1) else {
       return result
     }
-    
+
     result = (-b - sqrt(b.squared - 4 * a * c)) / (2 * a);
     guard !result.isInRangeOrEqual(0, 1) else {
       return result
     }
-    
+
     return -1;
   }
-  
+
   fileprivate static func SolveCubic(_ a: CGFloat, _ b: CGFloat, _ c: CGFloat, _ d: CGFloat) -> CGFloat {
-    if (a == 0) {
+    if a == 0 {
       return SolveQuadratic(b, c, d)
     }
-    if (d == 0) {
+    if d == 0 {
       return 0
     }
     let a = a
@@ -62,36 +103,36 @@ extension CGFloat {
     let r = (-27.0 * d + b * (9.0 * c - 2.0 * b.squared)) / 54.0
     let disc = q.cubed + r.squared
     let term1 = b / 3.0
-    
-    if (disc > 0) {
+
+    if disc > 0 {
       var s = r + sqrt(disc)
       s = (s < 0) ? -((-s).cubicRoot) : s.cubicRoot
       var t = r - sqrt(disc)
       t = (t < 0) ? -((-t).cubicRoot) : t.cubicRoot
-      
+
       let result = -term1 + s + t;
       if result.isInRangeOrEqual(0, 1) {
         return result
       }
-    } else if (disc == 0) {
+    } else if disc == 0 {
       let r13 = (r < 0) ? -((-r).cubicRoot) : r.cubicRoot;
-      
+
       var result = -term1 + 2.0 * r13;
       if result.isInRangeOrEqual(0, 1) {
         return result
       }
-      
+
       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);
-      
+
       var result = -term1 + r13 * cos(dum1 / 3.0);
       if result.isInRangeOrEqual(0, 1) {
         return result
@@ -105,45 +146,7 @@ extension CGFloat {
         return result
       }
     }
-    
+
     return -1;
   }
-  
-  func cubicBezierInterpolate(_ P0: CGPoint, _ P1: CGPoint, _ P2: CGPoint, _ P3: CGPoint) -> CGFloat {
-    var t: CGFloat
-    if (self == P0.x) {
-      // Handle corner cases explicitly to prevent rounding errors
-      t = 0
-    } else if (self == P3.x) {
-      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);
-      if (tTemp == -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;
-  }
-  
-  func cubicBezier(_ t: CGFloat, _ c1: CGFloat, _ c2: CGFloat, _ end: CGFloat) -> CGFloat {
-    let t_ = (1.0 - t)
-    let tt_ = t_ * t_
-    let ttt_ = t_ * t_ * t_
-    let tt = t * t
-    let ttt = t * t * t
-    
-    return self * ttt_
-      + 3.0 *  c1 * tt_ * t
-      + 3.0 *  c2 * t_ * tt
-      + end * ttt;
-  }
-  
 }

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

@@ -0,0 +1,27 @@
+//
+//  DataExtension.swift
+//  Lottie
+//
+//  Created by René Fouquet on 03.05.21.
+//
+
+import Foundation
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+
+extension Data {
+
+  static func jsonData(from assetName: String, in bundle: Bundle) -> Data? {
+    #if canImport(UIKit)
+    return NSDataAsset(name: assetName, bundle: bundle)?.data
+    #else
+    if #available(macOS 10.11, *) {
+      return NSDataAsset(name: assetName, bundle: bundle)?.data
+    }
+    return nil
+    #endif
+  }
+}