@octane-xplat/lottie 0.9.0 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Public/Keyframes/Interpolatable.swift

@@ -0,0 +1,285 @@
+// Created by Cal Stephens on 1/24/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import CoreGraphics
+
+// MARK: - Interpolatable
+
+/// A type that can be interpolated between two values
+public protocol Interpolatable: AnyInterpolatable {
+  /// Interpolates the `self` to the given number by `amount`.
+  ///  - Parameter to: The number to interpolate to.
+  ///  - Parameter amount: The amount to interpolate,
+  ///    relative to 0.0 (self) and 1.0 (to).
+  ///    `amount` can be greater than one and less than zero,
+  ///    and interpolation should not be clamped.
+  ///
+  ///  ```
+  ///  let number = 5
+  ///  let interpolated = number.interpolateTo(10, amount: 0.5)
+  ///  print(interpolated) // 7.5
+  ///  ```
+  ///
+  ///  ```
+  ///  let number = 5
+  ///  let interpolated = number.interpolateTo(10, amount: 1.5)
+  ///  print(interpolated) // 12.5
+  ///  ```
+  func interpolate(to: Self, amount: CGFloat) -> Self
+}
+
+// MARK: - SpatialInterpolatable
+
+/// A type that can be interpolated between two values,
+/// additionally using optional `spatialOutTangent` and `spatialInTangent` values.
+///  - If your implementation doesn't use the `spatialOutTangent` and `spatialInTangent`
+///    parameters, prefer implementing the simpler `Interpolatable` protocol.
+public protocol SpatialInterpolatable: AnyInterpolatable {
+  /// Interpolates the `self` to the given number by `amount`.
+  ///  - Parameter to: The number to interpolate to.
+  ///  - Parameter amount: The amount to interpolate,
+  ///    relative to 0.0 (self) and 1.0 (to).
+  ///    `amount` can be greater than one and less than zero,
+  ///    and interpolation should not be clamped.
+  func interpolate(
+    to: Self,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?
+  ) -> Self
+}
+
+// MARK: - AnyInterpolatable
+
+/// The base protocol that is implemented by both `Interpolatable` and `SpatialInterpolatable`
+/// Types should not directly implement this protocol.
+public protocol AnyInterpolatable {
+  /// Interpolates by calling either `Interpolatable.interpolate`
+  /// or `SpatialInterpolatable.interpolate`.
+  /// Should not be implemented or called by consumers.
+  func _interpolate(
+    to: Self,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?
+  ) -> Self
+}
+
+extension Interpolatable {
+  public func _interpolate(
+    to: Self,
+    amount: CGFloat,
+    spatialOutTangent _: CGPoint?,
+    spatialInTangent _: CGPoint?
+  ) -> Self {
+    interpolate(to: to, amount: amount)
+  }
+}
+
+extension SpatialInterpolatable {
+  /// Helper that interpolates this `SpatialInterpolatable`
+  /// with `nil` spatial in/out tangents
+  public func interpolate(to: Self, amount: CGFloat) -> Self {
+    interpolate(
+      to: to,
+      amount: amount,
+      spatialOutTangent: nil,
+      spatialInTangent: nil
+    )
+  }
+
+  public func _interpolate(
+    to: Self,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?
+  ) -> Self {
+    interpolate(
+      to: to,
+      amount: amount,
+      spatialOutTangent: spatialOutTangent,
+      spatialInTangent: spatialInTangent
+    )
+  }
+}
+
+// MARK: - Double + Interpolatable
+
+extension Double: Interpolatable { }
+
+// MARK: - CGFloat + Interpolatable
+
+extension CGFloat: Interpolatable { }
+
+// MARK: - Float + Interpolatable
+
+extension Float: Interpolatable { }
+
+extension Interpolatable where Self: BinaryFloatingPoint {
+  public func interpolate(to: Self, amount: CGFloat) -> Self {
+    self + ((to - self) * Self(amount))
+  }
+}
+
+// MARK: - CGRect + Interpolatable
+
+extension CGRect: Interpolatable {
+  public func interpolate(to: CGRect, amount: CGFloat) -> CGRect {
+    CGRect(
+      x: origin.x.interpolate(to: to.origin.x, amount: amount),
+      y: origin.y.interpolate(to: to.origin.y, amount: amount),
+      width: width.interpolate(to: to.width, amount: amount),
+      height: height.interpolate(to: to.height, amount: amount)
+    )
+  }
+}
+
+// MARK: - CGSize + Interpolatable
+
+extension CGSize: Interpolatable {
+  public func interpolate(to: CGSize, amount: CGFloat) -> CGSize {
+    CGSize(
+      width: width.interpolate(to: to.width, amount: amount),
+      height: height.interpolate(to: to.height, amount: amount)
+    )
+  }
+}
+
+// MARK: - CGPoint + SpatialInterpolatable
+
+extension CGPoint: SpatialInterpolatable {
+  public func interpolate(
+    to: CGPoint,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?
+  ) -> CGPoint {
+    guard
+      let outTan = spatialOutTangent,
+      let inTan = spatialInTangent
+    else {
+      return CGPoint(
+        x: x.interpolate(to: to.x, amount: amount),
+        y: y.interpolate(to: to.y, amount: amount)
+      )
+    }
+
+    let cp1 = self + outTan
+    let cp2 = to + inTan
+    return interpolate(to, outTangent: cp1, inTangent: cp2, amount: amount)
+  }
+}
+
+// MARK: - LottieColor + Interpolatable
+
+extension LottieColor: Interpolatable {
+  public func interpolate(to: LottieColor, amount: CGFloat) -> LottieColor {
+    LottieColor(
+      r: r.interpolate(to: to.r, amount: amount),
+      g: g.interpolate(to: to.g, amount: amount),
+      b: b.interpolate(to: to.b, amount: amount),
+      a: a.interpolate(to: to.a, amount: amount)
+    )
+  }
+}
+
+// MARK: - LottieVector1D + Interpolatable
+
+extension LottieVector1D: Interpolatable {
+  public func interpolate(to: LottieVector1D, amount: CGFloat) -> LottieVector1D {
+    value.interpolate(to: to.value, amount: amount).vectorValue
+  }
+}
+
+// MARK: - LottieVector2D + SpatialInterpolatable
+
+extension LottieVector2D: SpatialInterpolatable {
+  public func interpolate(
+    to: LottieVector2D,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?
+  ) -> LottieVector2D {
+    pointValue.interpolate(
+      to: to.pointValue,
+      amount: amount,
+      spatialOutTangent: spatialOutTangent,
+      spatialInTangent: spatialInTangent
+    )
+    .vector2dValue
+  }
+}
+
+// MARK: - LottieVector3D + SpatialInterpolatable
+
+extension LottieVector3D: SpatialInterpolatable {
+  public func interpolate(
+    to: LottieVector3D,
+    amount: CGFloat,
+    spatialOutTangent: CGPoint?,
+    spatialInTangent: CGPoint?
+  ) -> LottieVector3D {
+    if spatialInTangent != nil || spatialOutTangent != nil {
+      // TODO Support third dimension spatial interpolation
+      let point = pointValue.interpolate(
+        to: to.pointValue,
+        amount: amount,
+        spatialOutTangent: spatialOutTangent,
+        spatialInTangent: spatialInTangent
+      )
+
+      return LottieVector3D(
+        x: point.x,
+        y: point.y,
+        z: CGFloat(z.interpolate(to: to.z, amount: amount))
+      )
+    }
+
+    return LottieVector3D(
+      x: x.interpolate(to: to.x, amount: amount),
+      y: y.interpolate(to: to.y, amount: amount),
+      z: z.interpolate(to: to.z, amount: amount)
+    )
+  }
+}
+
+// MARK: - Array + Interpolatable, AnyInterpolatable
+
+extension Array: Interpolatable, AnyInterpolatable where Element: Interpolatable {
+  public func interpolate(to: [Element], amount: CGFloat) -> [Element] {
+    LottieLogger.shared.assert(
+      count == to.count,
+      "When interpolating Arrays, both array sound have the same element count."
+    )
+
+    return zip(self, to).map { lhs, rhs in
+      lhs.interpolate(to: rhs, amount: amount)
+    }
+  }
+}
+
+// MARK: - Optional + Interpolatable, AnyInterpolatable
+
+extension Optional: Interpolatable, AnyInterpolatable where Wrapped: Interpolatable {
+  public func interpolate(to: Wrapped?, amount: CGFloat) -> Wrapped? {
+    guard let self, let to else { return nil }
+    return self.interpolate(to: to, amount: amount)
+  }
+}
+
+// MARK: - Hold
+
+/// An `Interpolatable` container that animates using "hold" keyframes.
+/// The keyframes do not animate, and instead always display the value from the most recent keyframe.
+/// This is necessary when passing non-interpolatable values to a method that requires an `Interpolatable` conformance.
+struct Hold<T>: Interpolatable {
+  let value: T
+
+  func interpolate(to: Hold<T>, amount: CGFloat) -> Hold<T> {
+    if amount < 1 {
+      self
+    } else {
+      to
+    }
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/Keyframes/Keyframe.swift

@@ -0,0 +1,98 @@
+// Created by Cal Stephens on 1/24/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import CoreFoundation
+
+// MARK: - Keyframe
+
+/// A keyframe with a single value, and timing information
+/// about when the value should be displayed and how it
+/// should be interpolated.
+public final class Keyframe<T> {
+
+  // MARK: Lifecycle
+
+  /// Initialize a value-only keyframe with no time data.
+  public init(
+    _ value: T,
+    spatialInTangent: LottieVector3D? = nil,
+    spatialOutTangent: LottieVector3D? = nil
+  ) {
+    self.value = value
+    time = 0
+    isHold = true
+    inTangent = nil
+    outTangent = nil
+    self.spatialInTangent = spatialInTangent
+    self.spatialOutTangent = spatialOutTangent
+  }
+
+  /// Initialize a keyframe
+  public init(
+    value: T,
+    time: AnimationFrameTime,
+    isHold: Bool = false,
+    inTangent: LottieVector2D? = nil,
+    outTangent: LottieVector2D? = nil,
+    spatialInTangent: LottieVector3D? = nil,
+    spatialOutTangent: LottieVector3D? = nil
+  ) {
+    self.value = value
+    self.time = time
+    self.isHold = isHold
+    self.outTangent = outTangent
+    self.inTangent = inTangent
+    self.spatialInTangent = spatialInTangent
+    self.spatialOutTangent = spatialOutTangent
+  }
+
+  // MARK: Public
+
+  /// The value of the keyframe
+  public let value: T
+  /// The time in frames of the keyframe.
+  public let time: AnimationFrameTime
+  /// A hold keyframe freezes interpolation until the next keyframe that is not a hold.
+  public let isHold: Bool
+  /// The in tangent for the time interpolation curve.
+  public let inTangent: LottieVector2D?
+  /// The out tangent for the time interpolation curve.
+  public let outTangent: LottieVector2D?
+
+  /// The spatial in tangent of the vector.
+  public let spatialInTangent: LottieVector3D?
+  /// The spatial out tangent of the vector.
+  public let spatialOutTangent: LottieVector3D?
+}
+
+// MARK: Equatable
+
+extension Keyframe: Equatable where T: Equatable {
+  public static func ==(lhs: Keyframe<T>, rhs: Keyframe<T>) -> Bool {
+    lhs.value == rhs.value
+      && lhs.time == rhs.time
+      && lhs.isHold == rhs.isHold
+      && lhs.inTangent == rhs.inTangent
+      && lhs.outTangent == rhs.outTangent
+      && lhs.spatialInTangent == rhs.spatialOutTangent
+      && lhs.spatialOutTangent == rhs.spatialOutTangent
+  }
+}
+
+// MARK: Hashable
+
+extension Keyframe: Hashable where T: Hashable {
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
+    hasher.combine(time)
+    hasher.combine(isHold)
+    hasher.combine(inTangent)
+    hasher.combine(outTangent)
+    hasher.combine(spatialInTangent)
+    hasher.combine(spatialOutTangent)
+  }
+}
+
+// MARK: Sendable
+
+extension Keyframe: Sendable where T: Sendable { }

package/platforms/macos/src/vendor/Lottie/Public/Logging/LottieLogger.swift

@@ -0,0 +1,138 @@
+// Created by eric_horacek on 12/9/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - LottieLogger
+
+/// A shared logger that allows consumers to intercept Lottie assertions and warning messages to pipe
+/// into their own logging systems.
+public final class LottieLogger {
+
+  // MARK: Lifecycle
+
+  public init(
+    assert: @escaping Assert = { condition, message, file, line in
+      // If we default to `Swift.assert` directly with `assert: Assert = Swift.assert`,
+      // the call will unexpectedly not respect the -O flag and will crash in release
+      // https://github.com/swiftlang/swift/issues/60249
+      Swift.assert(condition(), message(), file: file, line: line)
+    },
+    assertionFailure: @escaping AssertionFailure = { message, file, line in
+      // If we default to `Swift.assertionFailure` directly with
+      // `assertionFailure: AssertionFailure = Swift.assertionFailure`,
+      // the call will unexpectedly not respect the -O flag and will crash in release
+      // https://github.com/swiftlang/swift/issues/60249
+      Swift.assertionFailure(message(), file: file, line: line)
+    },
+    warn: @escaping Warn = { message, _, _ in
+      #if DEBUG
+      // swiftlint:disable:next no_direct_standard_out_logs
+      print(message())
+      #endif
+    },
+    info: @escaping Info = { message in
+      #if DEBUG
+      // swiftlint:disable:next no_direct_standard_out_logs
+      print(message())
+      #endif
+    }
+  ) {
+    _assert = assert
+    _assertionFailure = assertionFailure
+    _warn = warn
+    _info = info
+  }
+
+  // MARK: Public
+
+  /// Logs that an assertion occurred.
+  public typealias Assert = (
+    _ condition: @autoclosure () -> Bool,
+    _ message: @autoclosure () -> String,
+    _ fileID: StaticString,
+    _ line: UInt
+  ) -> Void
+
+  /// Logs that an assertion failure occurred.
+  public typealias AssertionFailure = (
+    _ message: @autoclosure () -> String,
+    _ fileID: StaticString,
+    _ line: UInt
+  ) -> Void
+
+  /// Logs a warning message.
+  public typealias Warn = (
+    _ message: @autoclosure () -> String,
+    _ fileID: StaticString,
+    _ line: UInt
+  ) -> Void
+
+  /// Prints a purely informational message.
+  public typealias Info = (_ message: @autoclosure () -> String) -> Void
+
+  /// The shared instance used to log Lottie assertions and warnings.
+  ///
+  /// Set this to a new logger instance to intercept assertions and warnings logged by Lottie.
+  public static var shared = LottieLogger()
+
+  /// Logs that an assertion occurred.
+  public func assert(
+    _ condition: @autoclosure () -> Bool,
+    _ message: @autoclosure () -> String = String(),
+    fileID: StaticString = #fileID,
+    line: UInt = #line
+  ) {
+    _assert(condition(), message(), fileID, line)
+  }
+
+  /// Logs that an assertion failure occurred.
+  public func assertionFailure(
+    _ message: @autoclosure () -> String = String(),
+    fileID: StaticString = #fileID,
+    line: UInt = #line
+  ) {
+    _assertionFailure(message(), fileID, line)
+  }
+
+  /// Logs a warning message.
+  public func warn(
+    _ message: @autoclosure () -> String = String(),
+    fileID: StaticString = #fileID,
+    line: UInt = #line
+  ) {
+    _warn(message(), fileID, line)
+  }
+
+  /// Logs a purely informational message.
+  public func info(_ message: @autoclosure () -> String = String()) {
+    _info(message())
+  }
+
+  // MARK: Private
+
+  private let _assert: Assert
+  private let _assertionFailure: AssertionFailure
+  private let _warn: Warn
+  private let _info: Info
+
+}
+
+// MARK: - LottieLogger + printToConsole
+
+extension LottieLogger {
+  /// A `LottieLogger` instance that always prints to the console (by calling `print`)
+  /// instead of calling `assert` / `assertionFailure`, which halt execution in debug builds.
+  public static var printToConsole: LottieLogger {
+    LottieLogger(
+      assert: { condition, message, _, _ in
+        if !condition() {
+          // swiftlint:disable:next no_direct_standard_out_logs
+          print(message())
+        }
+      },
+      assertionFailure: { message, _, _ in
+        // swiftlint:disable:next no_direct_standard_out_logs
+        print(message())
+      }
+    )
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/Primitives/AnimationTime.swift

@@ -0,0 +1,15 @@
+//
+//  AnimationTime.swift
+//  lottie-swift-iOS
+//
+//  Created by Brandon Withrow on 2/6/19.
+//
+
+import CoreGraphics
+import Foundation
+
+/// Defines animation time in Frames (Seconds * Framerate).
+public typealias AnimationFrameTime = CGFloat
+
+/// Defines animation time by a progress from 0 (beginning of the animation) to 1 (end of the animation)
+public typealias AnimationProgressTime = CGFloat

package/platforms/macos/src/vendor/Lottie/Public/Primitives/LottieColor.swift

@@ -0,0 +1,43 @@
+//
+//  LottieColor.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+// MARK: - ColorFormatDenominator
+
+public enum ColorFormatDenominator: Hashable {
+  case One
+  case OneHundred
+  case TwoFiftyFive
+
+  var value: Double {
+    switch self {
+    case .One:
+      1.0
+    case .OneHundred:
+      100.0
+    case .TwoFiftyFive:
+      255.0
+    }
+  }
+}
+
+// MARK: - LottieColor
+
+public struct LottieColor: Hashable {
+
+  public init(r: Double, g: Double, b: Double, a: Double, denominator: ColorFormatDenominator = .One) {
+    self.r = r / denominator.value
+    self.g = g / denominator.value
+    self.b = b / denominator.value
+    self.a = a / denominator.value
+  }
+
+  public var r: Double
+  public var g: Double
+  public var b: Double
+  public var a: Double
+
+}

package/platforms/macos/src/vendor/Lottie/Public/Primitives/Vectors.swift

@@ -0,0 +1,36 @@
+//
+//  Vectors.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+// MARK: - LottieVector1D
+
+public struct LottieVector1D: Hashable, Sendable {
+
+  public init(_ value: Double) {
+    self.value = value
+  }
+
+  public let value: Double
+
+}
+
+// MARK: - LottieVector3D
+
+/// A three dimensional vector.
+/// These vectors are encoded and decoded from [Double]
+public struct LottieVector3D: Hashable, Sendable {
+
+  public init(x: Double, y: Double, z: Double) {
+    self.x = x
+    self.y = y
+    self.z = z
+  }
+
+  public let x: Double
+  public let y: Double
+  public let z: Double
+
+}