@octane-xplat/lottie 0.9.0 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/Utility/Interpolatable/InterpolatableExtensions.swift

@@ -0,0 +1,143 @@
+//
+//  InterpolatableExtensions.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/14/19.
+//
+
+import CoreGraphics
+import Foundation
+
+extension LottieColor {
+
+  // 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
+    var s: Double
+    let v = 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
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/Utility/Interpolatable/KeyframeExtensions.swift

@@ -0,0 +1,47 @@
+//
+//  KeyframeExtensions.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/14/19.
+//
+
+import CoreGraphics
+import Foundation
+
+extension Keyframe where T: AnyInterpolatable {
+  func interpolate(to: Keyframe<T>, progress: CGFloat) -> T {
+    value._interpolate(
+      to: to.value,
+      amount: progress,
+      spatialOutTangent: spatialOutTangent?.pointValue,
+      spatialInTangent: to.spatialInTangent?.pointValue
+    )
+  }
+}
+
+extension Keyframe {
+  /// Interpolates the keyTime into a value from 0-1
+  func interpolatedProgress(_ to: Keyframe, keyTime: CGFloat) -> CGFloat {
+    let startTime = time
+    let endTime = to.time
+    if keyTime <= startTime {
+      return 0
+    }
+    if endTime <= keyTime {
+      return 1
+    }
+
+    if isHold {
+      return 0
+    }
+
+    let outTanPoint = outTangent?.pointValue ?? .zero
+    let inTanPoint = to.inTangent?.pointValue ?? CGPoint(x: 1, y: 1)
+    var progress: CGFloat = keyTime.remap(fromLow: startTime, fromHigh: endTime, toLow: 0, toHigh: 1)
+    if !outTanPoint.isZero || !inTanPoint.equalTo(CGPoint(x: 1, y: 1)) {
+      /// Cubic interpolation
+      progress = progress.cubicBezierInterpolate(.zero, outTanPoint, inTanPoint, CGPoint(x: 1, y: 1))
+    }
+    return progress
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/Utility/Interpolatable/KeyframeInterpolator.swift

@@ -0,0 +1,250 @@
+//
+//  KeyframeInterpolator.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/15/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - KeyframeInterpolator
+
+/// A value provider that produces a value at Time from a group of keyframes
+final class KeyframeInterpolator<ValueType: AnyInterpolatable>: ValueProvider {
+
+  // MARK: Lifecycle
+
+  init(keyframes: ContiguousArray<Keyframe<ValueType>>) {
+    self.keyframes = keyframes
+  }
+
+  // MARK: Internal
+
+  let keyframes: ContiguousArray<Keyframe<ValueType>>
+
+  var valueType: Any.Type {
+    ValueType.self
+  }
+
+  var storage: ValueProviderStorage<ValueType> {
+    .closure { [self] frame in
+      // First set the keyframe span for the frame.
+      updateSpanIndices(frame: frame)
+      lastUpdatedFrame = frame
+      // If only one keyframe return its value
+      let progress: CGFloat
+      let value: ValueType
+
+      if
+        let leading = leadingKeyframe,
+        let trailing = trailingKeyframe
+      {
+        /// We have leading and trailing keyframe.
+        progress = leading.interpolatedProgress(trailing, keyTime: frame)
+        value = leading.interpolate(to: trailing, progress: progress)
+      } else if let leading = leadingKeyframe {
+        progress = 0
+        value = leading.value
+      } else if let trailing = trailingKeyframe {
+        progress = 1
+        value = trailing.value
+      } else {
+        /// Satisfy the compiler.
+        progress = 0
+        value = keyframes[0].value
+      }
+      return value
+    }
+  }
+
+  /// Returns true to trigger a frame update for this interpolator.
+  ///
+  /// An interpolator will be asked if it needs to update every frame.
+  /// If the interpolator needs updating it will be asked to compute its value for
+  /// the given frame.
+  ///
+  /// Cases a keyframe should not be updated:
+  /// - If time is in span and leading keyframe is hold
+  /// - If time is after the last keyframe.
+  /// - If time is before the first keyframe
+  ///
+  /// Cases for updating a keyframe:
+  /// - If time is in the span, and is not a hold
+  /// - If time is outside of the span, and there are more keyframes
+  /// - If a value delegate is set
+  /// - If leading and trailing are both nil.
+  func hasUpdate(frame: CGFloat) -> Bool {
+    if lastUpdatedFrame == nil {
+      return true
+    }
+
+    if
+      let leading = leadingKeyframe,
+      trailingKeyframe == nil,
+      leading.time < frame
+    {
+      /// Frame is after bounds of keyframes
+      return false
+    }
+    if
+      let trailing = trailingKeyframe,
+      leadingKeyframe == nil,
+      frame < trailing.time
+    {
+      /// Frame is before bounds of keyframes
+      return false
+    }
+    if
+      let leading = leadingKeyframe,
+      let trailing = trailingKeyframe,
+      leading.isHold,
+      leading.time < frame,
+      frame < trailing.time
+    {
+      return false
+    }
+    return true
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate var lastUpdatedFrame: CGFloat?
+
+  fileprivate var leadingIndex: Int? = nil
+  fileprivate var trailingIndex: Int? = nil
+  fileprivate var leadingKeyframe: Keyframe<ValueType>? = nil
+  fileprivate var trailingKeyframe: Keyframe<ValueType>? = nil
+
+  /// Finds the appropriate Leading and Trailing keyframe index for the given time.
+  fileprivate func updateSpanIndices(frame: CGFloat) {
+    guard keyframes.count > 0 else {
+      leadingIndex = nil
+      trailingIndex = nil
+      leadingKeyframe = nil
+      trailingKeyframe = nil
+      return
+    }
+
+    // This function searches through the array to find the span of two keyframes
+    // that contain the current time.
+    //
+    // We could use Array.first(where:) but that would search through the entire array
+    // each frame.
+    // Instead we track the last used index and search either forwards or
+    // backwards from there. This reduces the iterations and complexity from
+    //
+    // O(n), where n is the length of the sequence to
+    // O(n), where n is the number of items after or before the last used index.
+    //
+
+    if keyframes.count == 1 {
+      /// Only one keyframe. Set it as first and move on.
+      leadingIndex = 0
+      trailingIndex = nil
+      leadingKeyframe = keyframes[0]
+      trailingKeyframe = nil
+      return
+    }
+
+    /// Sets the initial keyframes. This is often only needed for the first check.
+    if
+      leadingIndex == nil,
+      trailingIndex == nil
+    {
+      if frame < keyframes[0].time {
+        /// Time is before the first keyframe. Set it as the trailing.
+        trailingIndex = 0
+      } else {
+        /// Time is after the first keyframe. Set the keyframe and the trailing.
+        leadingIndex = 0
+        trailingIndex = 1
+      }
+    }
+
+    if
+      let currentTrailing = trailingIndex,
+      keyframes[currentTrailing].time <= frame
+    {
+      /// Time is after the current span. Iterate forward.
+      var newLeading = currentTrailing
+      var keyframeFound = false
+      while !keyframeFound {
+        leadingIndex = newLeading
+        trailingIndex = keyframes.validIndex(newLeading + 1)
+
+        guard let trailing = trailingIndex else {
+          /// We have reached the end of our keyframes. Time is after the last keyframe.
+          keyframeFound = true
+          continue
+        }
+        if frame < keyframes[trailing].time {
+          /// Keyframe in current span.
+          keyframeFound = true
+          continue
+        }
+        /// Advance the array.
+        newLeading = trailing
+      }
+
+    } else if
+      let currentLeading = leadingIndex,
+      frame < keyframes[currentLeading].time
+    {
+      /// Time is before the current span. Iterate backwards
+      var newTrailing = currentLeading
+
+      var keyframeFound = false
+      while !keyframeFound {
+        leadingIndex = keyframes.validIndex(newTrailing - 1)
+        trailingIndex = newTrailing
+
+        guard let leading = leadingIndex else {
+          /// We have reached the end of our keyframes. Time is after the last keyframe.
+          keyframeFound = true
+          continue
+        }
+        if keyframes[leading].time <= frame {
+          /// Keyframe in current span.
+          keyframeFound = true
+          continue
+        }
+        /// Step back
+        newTrailing = leading
+      }
+    }
+    if let keyFrame = leadingIndex {
+      leadingKeyframe = keyframes[keyFrame]
+    } else {
+      leadingKeyframe = nil
+    }
+
+    if let keyFrame = trailingIndex {
+      trailingKeyframe = keyframes[keyFrame]
+    } else {
+      trailingKeyframe = nil
+    }
+  }
+}
+
+extension Array {
+
+  fileprivate func validIndex(_ index: Int) -> Int? {
+    if 0 <= index, index < endIndex {
+      return index
+    }
+    return nil
+  }
+
+}
+
+extension ContiguousArray {
+
+  fileprivate func validIndex(_ index: Int) -> Int? {
+    if 0 <= index, index < endIndex {
+      return index
+    }
+    return nil
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/Utility/LottieAnimationSource.swift

@@ -0,0 +1,51 @@
+// Created by Cal Stephens on 7/26/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+// MARK: - LottieAnimationSource
+
+/// A data source for a Lottie animation.
+/// Either a `LottieAnimation` loaded from a `.json` file,
+/// or a `DotLottieFile` loaded from a `.lottie` file.
+public enum LottieAnimationSource: Sendable {
+  /// A `LottieAnimation` loaded from a `.json` file
+  case lottieAnimation(LottieAnimation)
+
+  /// A `DotLottieFile` loaded from a `.lottie` file
+  case dotLottieFile(DotLottieFile)
+}
+
+extension LottieAnimationSource {
+  /// The default animation displayed by this data source
+  var animation: LottieAnimation? {
+    switch self {
+    case .lottieAnimation(let animation):
+      animation
+    case .dotLottieFile:
+      dotLottieAnimation?.animation
+    }
+  }
+
+  /// The `DotLottieFile.Animation`, if this is a dotLottie animation
+  var dotLottieAnimation: DotLottieFile.Animation? {
+    switch self {
+    case .lottieAnimation:
+      nil
+    case .dotLottieFile(let dotLottieFile):
+      dotLottieFile.animation()
+    }
+  }
+}
+
+extension LottieAnimation {
+  /// This animation represented as a `LottieAnimationSource`
+  public var animationSource: LottieAnimationSource {
+    .lottieAnimation(self)
+  }
+}
+
+extension DotLottieFile {
+  /// This animation represented as a `LottieAnimationSource`
+  public var animationSource: LottieAnimationSource {
+    .dotLottieFile(self)
+  }
+}