lottie-ios 3.2.3 → 3.4.2

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

@@ -0,0 +1,450 @@
+//
+//  MathKit.swift
+//  UIToolBox
+//
+//  Created by Brandon Withrow on 10/10/18.
+//
+// From https://github.com/buba447/UIToolBox
+
+import CoreGraphics
+import Foundation
+
+extension Int {
+  var cgFloat: CGFloat {
+    CGFloat(self)
+  }
+}
+
+extension Double {
+  var cgFloat: CGFloat {
+    CGFloat(self)
+  }
+}
+
+// MARK: - CGFloat + Interpolatable
+
+extension CGFloat {
+
+  func remap(fromLow: CGFloat, fromHigh: CGFloat, toLow: CGFloat, toHigh: CGFloat) -> CGFloat {
+    guard (fromHigh - fromLow) != 0 else {
+      // Would produce NAN
+      return 0
+    }
+    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 {
+    absolute ? abs(a - self) : a - self
+  }
+
+  func toRadians() -> CGFloat { self * .pi / 180 }
+  func toDegrees() -> CGFloat { self * 180 / .pi }
+
+}
+
+// MARK: - Double
+
+extension Double {
+
+  func remap(fromLow: Double, fromHigh: Double, toLow: Double, toHigh: Double) -> Double {
+    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: Double, _ b: Double) -> Double {
+    let minValue = a <= b ? a : b
+    let maxValue = a <= b ? b : a
+    return max(min(self, maxValue), minValue)
+  }
+
+}
+
+extension CGRect {
+
+  // MARK: Lifecycle
+
+  /// Initializes a new CGRect with a center point and size.
+  init(center: CGPoint, size: CGSize) {
+    self.init(
+      x: center.x - (size.width * 0.5),
+      y: center.y - (size.height * 0.5),
+      width: size.width,
+      height: size.height)
+  }
+
+  // MARK: Internal
+
+  /// Returns the total area of the rect.
+  var area: CGFloat {
+    width * height
+  }
+
+  /// The center point of the rect. Settable.
+  var center: CGPoint {
+    get {
+      CGPoint(x: midX, y: midY)
+    }
+    set {
+      origin = CGPoint(
+        x: newValue.x - (size.width * 0.5),
+        y: newValue.y - (size.height * 0.5))
+    }
+  }
+
+  /// The top left point of the rect. Settable.
+  var topLeft: CGPoint {
+    get {
+      CGPoint(x: minX, y: minY)
+    }
+    set {
+      origin = CGPoint(
+        x: newValue.x,
+        y: newValue.y)
+    }
+  }
+
+  /// The bottom left point of the rect. Settable.
+  var bottomLeft: CGPoint {
+    get {
+      CGPoint(x: minX, y: maxY)
+    }
+    set {
+      origin = CGPoint(
+        x: newValue.x,
+        y: newValue.y - size.height)
+    }
+  }
+
+  /// The top right point of the rect. Settable.
+  var topRight: CGPoint {
+    get {
+      CGPoint(x: maxX, y: minY)
+    }
+    set {
+      origin = CGPoint(
+        x: newValue.x - size.width,
+        y: newValue.y)
+    }
+  }
+
+  /// The bottom right point of the rect. Settable.
+  var bottomRight: CGPoint {
+    get {
+      CGPoint(x: maxX, y: maxY)
+    }
+    set {
+      origin = CGPoint(
+        x: newValue.x - size.width,
+        y: newValue.y - size.height)
+    }
+  }
+
+}
+
+extension CGSize {
+
+  /// Operator convenience to add sizes with +
+  static func +(left: CGSize, right: CGSize) -> CGSize {
+    left.add(right)
+  }
+
+  /// Operator convenience to subtract sizes with -
+  static func -(left: CGSize, right: CGSize) -> CGSize {
+    left.subtract(right)
+  }
+
+  /// Operator convenience to multiply sizes with *
+  static func *(left: CGSize, right: CGFloat) -> CGSize {
+    CGSize(width: left.width * right, height: left.height * right)
+  }
+
+  /// Returns the scale float that will fit the receive inside of the given size.
+  func scaleThatFits(_ size: CGSize) -> CGFloat {
+    CGFloat.minimum(width / size.width, height / size.height)
+  }
+
+  /// Adds receiver size to give size.
+  func add(_ size: CGSize) -> CGSize {
+    CGSize(width: width + size.width, height: height + size.height)
+  }
+
+  /// Subtracts given size from receiver size.
+  func subtract(_ size: CGSize) -> CGSize {
+    CGSize(width: width - size.width, height: height - size.height)
+  }
+
+  /// Multiplies receiver size by the given size.
+  func multiply(_ size: CGSize) -> CGSize {
+    CGSize(width: width * size.width, height: height * size.height)
+  }
+}
+
+// MARK: - CGLine
+
+/// A struct that defines a line segment with two CGPoints
+struct CGLine {
+
+  // MARK: Lifecycle
+
+  /// Initializes a line segment with start and end points
+  init(start: CGPoint, end: CGPoint) {
+    self.start = start
+    self.end = end
+  }
+
+  // MARK: Internal
+
+  /// The Start of the line segment.
+  var start: CGPoint
+  /// The End of the line segment.
+  var end: CGPoint
+
+  /// The length of the line segment.
+  var length: CGFloat {
+    end.distanceTo(start)
+  }
+
+  /// Returns a line segment that is normalized to a length of 1
+  func normalize() -> CGLine {
+    let len = length
+    guard len > 0 else {
+      return self
+    }
+    let relativeEnd = end - start
+    let relativeVector = CGPoint(x: relativeEnd.x / len, y: relativeEnd.y / len)
+    let absoluteVector = relativeVector + start
+    return CGLine(start: start, end: absoluteVector)
+  }
+
+  /// Trims a line segment to the given length
+  func trimmedToLength(_ toLength: CGFloat) -> CGLine {
+    let len = length
+    guard len > 0 else {
+      return self
+    }
+    let relativeEnd = end - start
+    let relativeVector = CGPoint(x: relativeEnd.x / len, y: relativeEnd.y / len)
+    let sizedVector = CGPoint(x: relativeVector.x * toLength, y: relativeVector.y * toLength)
+    let absoluteVector = sizedVector + start
+    return CGLine(start: start, end: absoluteVector)
+  }
+
+  /// Flips a line vertically and horizontally from the start point.
+  func flipped() -> CGLine {
+    let relativeEnd = end - start
+    let flippedEnd = CGPoint(x: relativeEnd.x * -1, y: relativeEnd.y * -1)
+    return CGLine(start: start, end: flippedEnd + start)
+  }
+
+  /// Move the line to the new start point.
+  func transpose(_ toPoint: CGPoint) -> CGLine {
+    let diff = toPoint - start
+    let newEnd = end + diff
+    return CGLine(start: toPoint, end: newEnd)
+  }
+
+}
+
+infix operator +|
+infix operator +-
+
+extension CGPoint {
+
+  /// Returns the length between the receiver and *CGPoint.zero*
+  var vectorLength: CGFloat {
+    distanceTo(.zero)
+  }
+
+  var isZero: Bool {
+    x == 0 && y == 0
+  }
+
+  /// Operator convenience to divide points with /
+  static func / (lhs: CGPoint, rhs: CGFloat) -> CGPoint {
+    CGPoint(x: lhs.x / CGFloat(rhs), y: lhs.y / CGFloat(rhs))
+  }
+
+  /// Operator convenience to multiply points with *
+  static func * (lhs: CGPoint, rhs: CGFloat) -> CGPoint {
+    CGPoint(x: lhs.x * CGFloat(rhs), y: lhs.y * CGFloat(rhs))
+  }
+
+  /// Operator convenience to add points with +
+  static func +(left: CGPoint, right: CGPoint) -> CGPoint {
+    left.add(right)
+  }
+
+  /// Operator convenience to subtract points with -
+  static func -(left: CGPoint, right: CGPoint) -> CGPoint {
+    left.subtract(right)
+  }
+
+  static func +|(left: CGPoint, right: CGFloat) -> CGPoint {
+    CGPoint(x: left.x, y: left.y + right)
+  }
+
+  static func +-(left: CGPoint, right: CGFloat) -> CGPoint {
+    CGPoint(x: left.x + right, y: left.y)
+  }
+
+  /// Returns the distance between the receiver and the given point.
+  func distanceTo(_ a: CGPoint) -> CGFloat {
+    let xDist = a.x - x
+    let yDist = a.y - y
+    return CGFloat(sqrt((xDist * xDist) + (yDist * yDist)))
+  }
+
+  func rounded(decimal: CGFloat) -> CGPoint {
+    CGPoint(x: round(decimal * x) / decimal, y: round(decimal * y) / decimal)
+  }
+
+  func interpolate(
+    _ to: CGPoint,
+    outTangent: CGPoint,
+    inTangent: CGPoint,
+    amount: CGFloat,
+    maxIterations: Int = 3,
+    samples: Int = 20,
+    accuracy: CGFloat = 1)
+    -> CGPoint
+  {
+    if amount == 0 {
+      return self
+    }
+    if amount == 1 {
+      return to
+    }
+
+    if
+      colinear(outTangent, inTangent) == true,
+      outTangent.colinear(inTangent, to) == true
+    {
+      return interpolate(to: to, amount: amount)
+    }
+
+    let step = 1 / CGFloat(samples)
+
+    var points: [(point: CGPoint, distance: CGFloat)] = [(point: self, distance: 0)]
+    var totalLength: CGFloat = 0
+
+    var previousPoint = self
+    var previousAmount = CGFloat(0)
+
+    var closestPoint = 0
+
+    while previousAmount < 1 {
+      previousAmount = previousAmount + step
+
+      if previousAmount < amount {
+        closestPoint = closestPoint + 1
+      }
+
+      let newPoint = pointOnPath(to, outTangent: outTangent, inTangent: inTangent, amount: previousAmount)
+      let distance = previousPoint.distanceTo(newPoint)
+      totalLength = totalLength + distance
+      points.append((point: newPoint, distance: totalLength))
+      previousPoint = newPoint
+    }
+
+    let accurateDistance = amount * totalLength
+    var point = points[closestPoint]
+
+    var foundPoint = false
+
+    var pointAmount = CGFloat(closestPoint) * step
+    var nextPointAmount: CGFloat = pointAmount + step
+
+    var refineIterations = 0
+    while foundPoint == false {
+      refineIterations = refineIterations + 1
+      /// First see if the next point is still less than the projected length.
+      let nextPoint = points[closestPoint + 1]
+      if nextPoint.distance < accurateDistance {
+        point = nextPoint
+        closestPoint = closestPoint + 1
+        pointAmount = CGFloat(closestPoint) * step
+        nextPointAmount = pointAmount + step
+        if closestPoint == points.count {
+          foundPoint = true
+        }
+        continue
+      }
+      if accurateDistance < point.distance {
+        closestPoint = closestPoint - 1
+        if closestPoint < 0 {
+          foundPoint = true
+          continue
+        }
+        point = points[closestPoint]
+        pointAmount = CGFloat(closestPoint) * step
+        nextPointAmount = pointAmount + step
+        continue
+      }
+
+      /// Now we are certain the point is the closest point under the distance
+      let pointDiff = nextPoint.distance - point.distance
+      let proposedPointAmount = ((accurateDistance - point.distance) / pointDiff)
+        .remap(fromLow: 0, fromHigh: 1, toLow: pointAmount, toHigh: nextPointAmount)
+
+      let newPoint = pointOnPath(to, outTangent: outTangent, inTangent: inTangent, amount: proposedPointAmount)
+      let newDistance = point.distance + point.point.distanceTo(newPoint)
+      pointAmount = proposedPointAmount
+      point = (point: newPoint, distance: newDistance)
+      if
+        accurateDistance - newDistance <= accuracy ||
+        newDistance - accurateDistance <= accuracy
+      {
+        foundPoint = true
+      }
+
+      if refineIterations == maxIterations {
+        foundPoint = true
+      }
+    }
+    return point.point
+  }
+
+  func pointOnPath(_ to: CGPoint, outTangent: CGPoint, inTangent: CGPoint, amount: CGFloat) -> CGPoint {
+    let a = interpolate(to: outTangent, amount: amount)
+    let b = outTangent.interpolate(to: inTangent, amount: amount)
+    let c = inTangent.interpolate(to: to, amount: amount)
+    let d = a.interpolate(to: b, amount: amount)
+    let e = b.interpolate(to: c, amount: amount)
+    let f = d.interpolate(to: e, amount: amount)
+    return f
+  }
+
+  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 accuracy: CGFloat = 0.05
+    if area < accuracy, area > -accuracy {
+      return true
+    }
+    return false
+  }
+
+  /// Subtracts the given point from the receiving point.
+  func subtract(_ point: CGPoint) -> CGPoint {
+    CGPoint(
+      x: x - point.x,
+      y: y - point.y)
+  }
+
+  /// Adds the given point from the receiving point.
+  func add(_ point: CGPoint) -> CGPoint {
+    CGPoint(
+      x: x + point.x,
+      y: y + point.y)
+  }
+}

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

@@ -0,0 +1,38 @@
+//
+//  StringExtensions.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+import CoreGraphics
+import Foundation
+
+extension String {
+
+  var cgColor: CGColor {
+    let (red, green, blue) = hexColorComponents()
+    return .rgb(red, green, blue)
+  }
+
+  func hexColorComponents() -> (red: CGFloat, green: CGFloat, blue: CGFloat) {
+    var cString: String = trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
+
+    if cString.hasPrefix("#") {
+      cString.remove(at: cString.startIndex)
+    }
+
+    if (cString.count) != 6 {
+      return (red: 0, green: 0, blue: 0)
+    }
+
+    var rgbValue: UInt64 = 0
+    Scanner(string: cString).scanHexInt64(&rgbValue)
+
+    return (
+      red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
+      green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
+      blue: CGFloat(rgbValue & 0x0000FF) / 255.0)
+  }
+
+}

package/{lottie-swift/src → Sources}/Private/Utility/Helpers/AnimationContext.swift

@@ -5,49 +5,67 @@
 //  Created by Brandon Withrow on 2/1/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 import QuartzCore
 
 /// A completion block for animations. `true` is passed in if the animation completed playing.
 public typealias LottieCompletionBlock = (Bool) -> Void
 
+// MARK: - AnimationContext
+
 struct AnimationContext {
 
-  init(playFrom: CGFloat,
-       playTo: CGFloat,
-       closure: LottieCompletionBlock?) {
+  init(
+    playFrom: AnimationFrameTime,
+    playTo: AnimationFrameTime,
+    closure: LottieCompletionBlock?)
+  {
     self.playTo = playTo
     self.playFrom = playFrom
     self.closure = AnimationCompletionDelegate(completionBlock: closure)
   }
 
-  var playFrom: CGFloat
-  var playTo: CGFloat
+  var playFrom: AnimationFrameTime
+  var playTo: AnimationFrameTime
   var closure: AnimationCompletionDelegate
 
 }
 
+// MARK: Equatable
+
+extension AnimationContext: Equatable {
+  /// Whether or not the two given `AnimationContext`s are functionally equivalent
+  ///  - This checks whether or not a completion handler was provided,
+  ///    but does not check whether or not the two completion handlers are equivalent.
+  static func == (_ lhs: AnimationContext, _ rhs: AnimationContext) -> Bool {
+    lhs.playTo == rhs.playTo
+      && lhs.playFrom == rhs.playFrom
+      && (lhs.closure.completionBlock == nil) == (rhs.closure.completionBlock == nil)
+  }
+}
+
+// MARK: - AnimationContextState
+
 enum AnimationContextState {
   case playing
   case cancelled
   case complete
 }
 
+// MARK: - AnimationCompletionDelegate
+
 class AnimationCompletionDelegate: NSObject, CAAnimationDelegate {
-  
+
+  // MARK: Lifecycle
+
   init(completionBlock: LottieCompletionBlock?) {
     self.completionBlock = completionBlock
     super.init()
   }
-  
-  var animationLayer: AnimationContainer?
-  var animationKey: String?
-  var ignoreDelegate: Bool = false
-  var animationState: AnimationContextState = .playing
-  
-  let completionBlock: LottieCompletionBlock?
-  
+
+  // MARK: Public
+
   public func animationDidStop(_ anim: CAAnimation, finished flag: Bool) {
     guard ignoreDelegate == false else { return }
     animationState = flag ? .complete : .cancelled
@@ -61,5 +79,13 @@ class AnimationCompletionDelegate: NSObject, CAAnimationDelegate {
       completionBlock(flag)
     }
   }
-  
+
+  // MARK: Internal
+
+  var animationLayer: RootAnimationLayer?
+  var animationKey: String?
+  var ignoreDelegate = false
+  var animationState: AnimationContextState = .playing
+
+  let completionBlock: LottieCompletionBlock?
 }

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

@@ -0,0 +1,134 @@
+//
+//  InterpolatableExtensions.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/14/19.
+//
+
+import CoreGraphics
+import Foundation
+
+extension Color {
+
+  // MARK: Lifecycle
+
+  /// Initialize a new color with Hue Saturation and Value
+  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 q = v * (1 - f * s)
+    let t = v * (1 - (1 - f) * s)
+
+    switch i.truncatingRemainder(dividingBy: 6) {
+    case 0:
+      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
+      b = 0
+    }
+    self.a = a
+  }
+
+  init(y: Double, u: Double, v: Double, a: Double) {
+    // From https://www.fourcc.org/fccyvrgb.php
+    r = y + 1.403 * v
+    g = y - 0.344 * u
+    b = y + 1.770 * u
+    self.a = a
+  }
+
+  // MARK: Internal
+
+  /// Hue Saturation Value of the color.
+  var hsva: (h: Double, s: Double, v: Double, a: Double) {
+    let maxValue = max(r, g, b)
+    let minValue = min(r, g, b)
+
+    var h: Double, s: Double, v: Double = maxValue
+
+    let d = maxValue - minValue
+    s = maxValue == 0 ? 0 : d / maxValue;
+
+    if maxValue == minValue {
+      h = 0; // achromatic
+    } else {
+      switch maxValue {
+      case r: h = (g - b) / d + (g < b ? 6 : 0)
+      case g: h = (b - r) / d + 2
+      case b: h = (r - g) / d + 4
+      default: h = maxValue
+      }
+      h = h / 6
+    }
+    return (h: h, s: s, v: v, a: a)
+  }
+
+  var yuv: (y: Double, u: Double, v: Double, a: Double) {
+    /// From https://www.fourcc.org/fccyvrgb.php
+    let y = 0.299 * r + 0.587 * g + 0.114 * b
+    let u = -0.14713 * r - 0.28886 * g + 0.436 * b
+    let v = 0.615 * r - 0.51499 * g - 0.10001 * b
+    return (y: y, u: u, v: v, a: a)
+  }
+
+}
+
+// MARK: - CurveVertex + Interpolatable
+
+extension CurveVertex: Interpolatable {
+  func interpolate(to: CurveVertex, amount: CGFloat) -> CurveVertex {
+    CurveVertex(
+      point: point.interpolate(to: to.point, amount: amount),
+      inTangent: inTangent.interpolate(to: to.inTangent, amount: amount),
+      outTangent: outTangent.interpolate(to: to.outTangent, amount: amount))
+  }
+}
+
+// MARK: - BezierPath + Interpolatable
+
+extension BezierPath: Interpolatable {
+  func interpolate(to: BezierPath, amount: CGFloat) -> BezierPath {
+    var newPath = BezierPath()
+    for i in 0..<min(elements.count, to.elements.count) {
+      let fromVertex = elements[i].vertex
+      let toVertex = to.elements[i].vertex
+      newPath.addVertex(fromVertex.interpolate(to: toVertex, amount: amount))
+    }
+    return newPath
+  }
+}
+
+// MARK: - TextDocument + Interpolatable
+
+extension TextDocument: Interpolatable {
+  func interpolate(to: TextDocument, amount: CGFloat) -> TextDocument {
+    if amount == 1 {
+      return to
+    }
+    return self
+  }
+}