@octane-xplat/lottie 0.9.0 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/Utility/Extensions/AnimationKeypathExtension.swift

@@ -0,0 +1,303 @@
+//
+//  KeypathSearchableExtension.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+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)
+      {
+        // 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
+    {
+      // 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,
+        let nextKeypath = keyPath.nextKeypath,
+        nextKeypath.equalsKeypath(childNode.keypathName),
+        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]
+    {
+      /// We found a property!
+      results.append(property)
+    }
+
+    if nextKeypath.nextKeypath != nil {
+      /// Now check child keypaths.
+      for child in childKeypaths {
+        if let childProperties = child.nodeProperties(for: nextKeypath) {
+          results.append(contentsOf: childProperties)
+        }
+      }
+    }
+
+    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) {
+      /// We found our layer!
+      return keypathLayer
+    }
+    guard let nextKeypath = keyPath.popKey(keypathName) else {
+      /// Nope. Stop Search
+      return nil
+    }
+
+    /// Now check child keypaths.
+    for child in childKeypaths {
+      if let layer = child.layer(for: nextKeypath) {
+        return layer
+      }
+    }
+    return nil
+  }
+
+  /// Searches this layer's keypaths to find the keypath for the given layer
+  func keypath(for layer: CALayer) -> AnimationKeypath? {
+    let allKeypaths = layerKeypaths()
+    return allKeypaths[layer]
+  }
+
+  /// Computes the list of animation keypaths that descend from this layer
+  func allKeypaths(for keyPath: AnimationKeypath? = nil) -> [String] {
+    var allKeypaths = [String]()
+
+    let newKeypath: AnimationKeypath =
+      if let previousKeypath = keyPath {
+        previousKeypath.appendingKey(keypathName)
+      } else {
+        AnimationKeypath(keys: [keypathName])
+      }
+
+    allKeypaths.append(newKeypath.fullPath)
+
+    for key in keypathProperties.keys {
+      allKeypaths.append(newKeypath.appendingKey(key).fullPath)
+    }
+
+    for child in childKeypaths {
+      allKeypaths.append(contentsOf: child.allKeypaths(for: newKeypath))
+    }
+
+    return allKeypaths
+  }
+
+  /// Computes the list of animation keypaths that descend from this layer
+  func layerKeypaths(for keyPath: AnimationKeypath? = nil) -> [CALayer: AnimationKeypath] {
+    var allKeypaths = [CALayer: AnimationKeypath]()
+
+    let newKeypath: AnimationKeypath =
+      if let previousKeypath = keyPath {
+        previousKeypath.appendingKey(keypathName)
+      } else {
+        AnimationKeypath(keys: [keypathName])
+      }
+
+    if let layer = self as? CALayer {
+      allKeypaths[layer] = newKeypath
+    }
+
+    for child in childKeypaths {
+      for (layer, keypath) in child.layerKeypaths(for: newKeypath) {
+        allKeypaths[layer] = keypath
+      }
+    }
+
+    return allKeypaths
+  }
+}
+
+extension AnimationKeypath {
+  var currentKey: String? {
+    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.
+      return currentKey
+    }
+    if keys.count == 2, currentKey?.keyPathType == .fuzzyWildcard {
+      /// The next keypath is the last and the current is a fuzzy key.
+      return nextKeypath
+    }
+    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.equalsKeypath(keyname),
+      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.equalsKeypath(keyname)
+      {
+        /// Remove next two keypaths. This keypath breaks the wildcard.
+        var oldKeys = keys
+        oldKeys.remove(at: 0)
+        oldKeys.remove(at: 0)
+        newKeys = oldKeys
+      } else {
+        newKeys = keys
+      }
+    } else {
+      var oldKeys = keys
+      oldKeys.remove(at: 0)
+      newKeys = oldKeys
+    }
+
+    return AnimationKeypath(keys: newKeys)
+  }
+
+  func appendingKey(_ key: String) -> AnimationKeypath {
+    var newKeys = keys
+    newKeys.append(key)
+    return AnimationKeypath(keys: newKeys)
+  }
+}
+
+extension String {
+  var keyPathType: KeyType {
+    switch self {
+    case "*":
+      .wildcard
+    case "**":
+      .fuzzyWildcard
+    default:
+      .specific
+    }
+  }
+
+  func equalsKeypath(_ keyname: String) -> Bool {
+    if keyPathType == .wildcard || keyPathType == .fuzzyWildcard {
+      return true
+    }
+    if self == keyname {
+      return true
+    }
+    if let index = firstIndex(of: "*") {
+      // Wildcard search.
+      let prefix = String(prefix(upTo: index))
+      let suffix = String(suffix(from: self.index(after: index)))
+
+      if prefix.count > 0 {
+        // Match prefix.
+        if keyname.count < prefix.count {
+          return false
+        }
+        let testPrefix = String(keyname.prefix(upTo: keyname.index(keyname.startIndex, offsetBy: prefix.count)))
+        if testPrefix != prefix {
+          // Prefix doesnt match
+          return false
+        }
+      }
+      if suffix.count > 0 {
+        // Match suffix.
+        if keyname.count < suffix.count {
+          // Suffix doesnt match
+          return false
+        }
+        let index = keyname.index(keyname.endIndex, offsetBy: -suffix.count)
+        let testSuffix = String(keyname.suffix(from: index))
+        if testSuffix != suffix {
+          return false
+        }
+      }
+      return true
+    }
+    return false
+  }
+}
+
+// MARK: - KeyType
+
+enum KeyType {
+  case specific
+  case wildcard
+  case fuzzyWildcard
+}

package/platforms/macos/src/vendor/Lottie/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: 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/platforms/macos/src/vendor/Lottie/Private/Utility/Extensions/CGColor+RGB.swift

@@ -0,0 +1,45 @@
+// Created by Cal Stephens on 1/7/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+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)
+  }
+
+  /// Initializes a `CGColor` using the given grayscale value
+  static func gray(_ gray: CGFloat) -> CGColor {
+    CGColor(
+      colorSpace: CGColorSpaceCreateDeviceGray(),
+      components: [gray, 1.0]
+    )!
+  }
+
+  /// Initializes a `CGColor` using the given `RGBA` values
+  static func rgba(_ red: CGFloat, _ green: CGFloat, _ blue: CGFloat, _ alpha: CGFloat) -> CGColor {
+    CGColor(
+      colorSpace: LottieConfiguration.shared.colorSpace,
+      components: [red, green, blue, alpha]
+    )!
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/Utility/Extensions/CGFloatExtensions.swift

@@ -0,0 +1,152 @@
+//
+//  CGFloatExtensions.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/14/19.
+//
+
+import Foundation
+import QuartzCore
+
+extension CGFloat {
+
+  // MARK: Internal
+
+  var squared: CGFloat {
+    self * self
+  }
+
+  var cubed: CGFloat {
+    self * self * self
+  }
+
+  var cubicRoot: CGFloat {
+    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 {
+      return SolveQuadratic(b, c, d)
+    }
+    if d == 0 {
+      return 0
+    }
+    let a = a
+    var b = b
+    var c = c
+    var d = d
+    b /= a
+    c /= a
+    d /= a
+    var q = (3.0 * c - b.squared) / 9.0
+    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 {
+      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 {
+      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
+      }
+      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)
+      if result.isInRangeOrEqual(0, 1) {
+        return result
+      }
+    }
+
+    return -1
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/Utility/Extensions/DataExtension.swift

@@ -0,0 +1,33 @@
+//
+//  DataExtension.swift
+//  Lottie
+//
+//  Created by René Fouquet on 03.05.21.
+//
+
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+
+extension Data {
+
+  init(assetName: String, in bundle: Bundle) throws {
+    #if canImport(UIKit)
+    if let asset = NSDataAsset(name: assetName, bundle: bundle) {
+      self = asset.data
+      return
+    } else {
+      throw DotLottieError.assetNotFound(name: assetName, bundle: bundle)
+    }
+    #else
+    if let asset = NSDataAsset(name: assetName, bundle: bundle) {
+      self = asset.data
+      return
+    } else {
+      throw DotLottieError.assetNotFound(name: assetName, bundle: bundle)
+    }
+    #endif
+  }
+}