@octane-xplat/lottie 0.9.0 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/Model/Keyframes/KeyframeData.swift

@@ -0,0 +1,111 @@
+//
+//  Keyframe.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/7/19.
+//
+
+// MARK: - KeyframeData
+
+/// A generic class used to parse and remap keyframe json.
+///
+/// Keyframe json has a couple of different variations and formats depending on the
+/// type of keyframea and also the version of the JSON. By parsing the raw data
+/// we can reconfigure it into a constant format.
+final class KeyframeData<T> {
+
+  // MARK: Lifecycle
+
+  init(
+    startValue: T?,
+    endValue: T?,
+    time: AnimationFrameTime?,
+    hold: Int?,
+    inTangent: LottieVector2D?,
+    outTangent: LottieVector2D?,
+    spatialInTangent: LottieVector3D?,
+    spatialOutTangent: LottieVector3D?
+  ) {
+    self.startValue = startValue
+    self.endValue = endValue
+    self.time = time
+    self.hold = hold
+    self.inTangent = inTangent
+    self.outTangent = outTangent
+    self.spatialInTangent = spatialInTangent
+    self.spatialOutTangent = spatialOutTangent
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case startValue = "s"
+    case endValue = "e"
+    case time = "t"
+    case hold = "h"
+    case inTangent = "i"
+    case outTangent = "o"
+    case spatialInTangent = "ti"
+    case spatialOutTangent = "to"
+  }
+
+  /// The start value of the keyframe
+  let startValue: T?
+  /// The End value of the keyframe. Note: Newer versions animation json do not have this field.
+  let endValue: T?
+  /// The time in frames of the keyframe.
+  let time: AnimationFrameTime?
+  /// A hold keyframe freezes interpolation until the next keyframe that is not a hold.
+  let hold: Int?
+
+  /// The in tangent for the time interpolation curve.
+  let inTangent: LottieVector2D?
+  /// The out tangent for the time interpolation curve.
+  let outTangent: LottieVector2D?
+
+  /// The spacial in tangent of the vector.
+  let spatialInTangent: LottieVector3D?
+  /// The spacial out tangent of the vector.
+  let spatialOutTangent: LottieVector3D?
+
+  var isHold: Bool {
+    if let hold {
+      return hold > 0
+    }
+    return false
+  }
+}
+
+// MARK: Encodable
+
+extension KeyframeData: Encodable where T: Encodable { }
+
+// MARK: Decodable
+
+extension KeyframeData: Decodable where T: Decodable { }
+
+// MARK: DictionaryInitializable
+
+extension KeyframeData: DictionaryInitializable where T: AnyInitializable {
+  convenience init(dictionary: [String: Any]) throws {
+    let startValue = try? dictionary[CodingKeys.startValue.rawValue].flatMap(T.init)
+    let endValue = try? dictionary[CodingKeys.endValue.rawValue].flatMap(T.init)
+    let time: AnimationFrameTime? = try? dictionary.value(for: CodingKeys.time)
+    let hold: Int? = try? dictionary.value(for: CodingKeys.hold)
+    let inTangent: LottieVector2D? = try? dictionary.value(for: CodingKeys.inTangent)
+    let outTangent: LottieVector2D? = try? dictionary.value(for: CodingKeys.outTangent)
+    let spatialInTangent: LottieVector3D? = try? dictionary.value(for: CodingKeys.spatialInTangent)
+    let spatialOutTangent: LottieVector3D? = try? dictionary.value(for: CodingKeys.spatialOutTangent)
+
+    self.init(
+      startValue: startValue,
+      endValue: endValue,
+      time: time,
+      hold: hold,
+      inTangent: inTangent,
+      outTangent: outTangent,
+      spatialInTangent: spatialInTangent,
+      spatialOutTangent: spatialOutTangent
+    )
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/Keyframes/KeyframeGroup.swift

@@ -0,0 +1,265 @@
+//
+//  KeyframeGroup.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/14/19.
+//
+
+// MARK: - KeyframeGroup
+
+/// Used for coding/decoding a group of Keyframes by type.
+///
+/// Keyframe data is wrapped in a dictionary { "k" : KeyframeData }.
+/// The keyframe data can either be an array of keyframes or, if no animation is present, the raw value.
+/// This helper object is needed to properly decode the json.
+final class KeyframeGroup<T> {
+
+  // MARK: Lifecycle
+
+  init(
+    keyframes: ContiguousArray<Keyframe<T>>,
+    unsupportedAfterEffectsExpression: String? = nil
+  ) {
+    self.keyframes = keyframes
+    self.unsupportedAfterEffectsExpression = unsupportedAfterEffectsExpression
+  }
+
+  init(
+    _ value: T,
+    unsupportedAfterEffectsExpression: String? = nil
+  ) {
+    keyframes = [Keyframe(value)]
+    self.unsupportedAfterEffectsExpression = unsupportedAfterEffectsExpression
+  }
+
+  // MARK: Internal
+
+  enum KeyframeWrapperKey: String, CodingKey {
+    case keyframeData = "k"
+    case unsupportedAfterEffectsExpression = "x"
+  }
+
+  let keyframes: ContiguousArray<Keyframe<T>>
+
+  /// lottie-ios doesn't support After Effects expressions, but we parse them so we can log diagnostics.
+  /// More info: https://helpx.adobe.com/after-effects/using/expression-basics.html
+  let unsupportedAfterEffectsExpression: String?
+
+}
+
+// MARK: Decodable
+
+extension KeyframeGroup: Decodable where T: Decodable {
+  convenience init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: KeyframeWrapperKey.self)
+    let unsupportedAfterEffectsExpression = try? container.decode(String.self, forKey: .unsupportedAfterEffectsExpression)
+
+    if let keyframeData: T = try? container.decode(T.self, forKey: .keyframeData) {
+      /// Try to decode raw value; No keyframe data.
+      self.init(
+        keyframes: [Keyframe<T>(keyframeData)],
+        unsupportedAfterEffectsExpression: unsupportedAfterEffectsExpression
+      )
+    } else {
+      // Decode and array of keyframes.
+      //
+      // Body Movin and Lottie deal with keyframes in different ways.
+      //
+      // A keyframe object in Body movin defines a span of time with a START
+      // and an END, from the current keyframe time to the next keyframe time.
+      //
+      // A keyframe object in Lottie defines a singular point in time/space.
+      // This point has an in-tangent and an out-tangent.
+      //
+      // To properly decode this we must iterate through keyframes while holding
+      // reference to the previous keyframe.
+
+      var keyframesContainer = try container.nestedUnkeyedContainer(forKey: .keyframeData)
+      var keyframes = ContiguousArray<Keyframe<T>>()
+      var previousKeyframeData: KeyframeData<T>?
+      while !keyframesContainer.isAtEnd {
+        // Ensure that Time and Value are present.
+
+        let keyframeData = try keyframesContainer.decode(KeyframeData<T>.self)
+
+        guard
+          let value: T = keyframeData.startValue ?? previousKeyframeData?.endValue,
+          let time = keyframeData.time
+        else {
+          /// Missing keyframe data. JSON must be corrupt.
+          throw DecodingError.dataCorruptedError(
+            forKey: KeyframeWrapperKey.keyframeData,
+            in: container,
+            debugDescription: "Missing keyframe data."
+          )
+        }
+
+        keyframes.append(Keyframe<T>(
+          value: value,
+          time: AnimationFrameTime(time),
+          isHold: keyframeData.isHold,
+          inTangent: previousKeyframeData?.inTangent,
+          outTangent: keyframeData.outTangent,
+          spatialInTangent: previousKeyframeData?.spatialInTangent,
+          spatialOutTangent: keyframeData.spatialOutTangent
+        ))
+        previousKeyframeData = keyframeData
+      }
+      self.init(
+        keyframes: keyframes,
+        unsupportedAfterEffectsExpression: unsupportedAfterEffectsExpression
+      )
+    }
+  }
+}
+
+// MARK: Encodable
+
+extension KeyframeGroup: Encodable where T: Encodable {
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: KeyframeWrapperKey.self)
+
+    if keyframes.count == 1 {
+      let keyframe = keyframes[0]
+      try container.encode(keyframe.value, forKey: .keyframeData)
+    } else {
+      var keyframeContainer = container.nestedUnkeyedContainer(forKey: .keyframeData)
+
+      for i in 1..<keyframes.endIndex {
+        let keyframe = keyframes[i - 1]
+        let nextKeyframe = keyframes[i]
+        let keyframeData = KeyframeData<T>(
+          startValue: keyframe.value,
+          endValue: nextKeyframe.value,
+          time: keyframe.time,
+          hold: keyframe.isHold ? 1 : nil,
+          inTangent: nextKeyframe.inTangent,
+          outTangent: keyframe.outTangent,
+          spatialInTangent: nil,
+          spatialOutTangent: nil
+        )
+        try keyframeContainer.encode(keyframeData)
+      }
+    }
+  }
+}
+
+// MARK: DictionaryInitializable
+
+extension KeyframeGroup: DictionaryInitializable where T: AnyInitializable {
+  convenience init(dictionary: [String: Any]) throws {
+    var keyframes = ContiguousArray<Keyframe<T>>()
+    let unsupportedAfterEffectsExpression = dictionary[KeyframeWrapperKey.unsupportedAfterEffectsExpression.rawValue] as? String
+    if
+      let rawValue = dictionary[KeyframeWrapperKey.keyframeData.rawValue],
+      let value = try? T(value: rawValue)
+    {
+      keyframes = [Keyframe<T>(value)]
+    } else {
+      let frameDictionaries: [[String: Any]] =
+        if
+          let singleFrameDictionary =
+          dictionary[KeyframeWrapperKey.keyframeData.rawValue] as? [String: Any]
+        {
+          [singleFrameDictionary]
+        } else {
+          try dictionary.value(for: KeyframeWrapperKey.keyframeData)
+        }
+      var previousKeyframeData: KeyframeData<T>?
+      for frameDictionary in frameDictionaries {
+        let data = try KeyframeData<T>(dictionary: frameDictionary)
+        guard
+          let value: T = data.startValue ?? previousKeyframeData?.endValue,
+          let time = data.time
+        else {
+          throw InitializableError.invalidInput()
+        }
+        keyframes.append(Keyframe<T>(
+          value: value,
+          time: time,
+          isHold: data.isHold,
+          inTangent: previousKeyframeData?.inTangent,
+          outTangent: data.outTangent,
+          spatialInTangent: previousKeyframeData?.spatialInTangent,
+          spatialOutTangent: data.spatialOutTangent
+        ))
+        previousKeyframeData = data
+      }
+    }
+
+    self.init(
+      keyframes: keyframes,
+      unsupportedAfterEffectsExpression: unsupportedAfterEffectsExpression
+    )
+  }
+}
+
+// MARK: Equatable
+
+extension KeyframeGroup: Equatable where T: Equatable {
+  static func ==(_ lhs: KeyframeGroup<T>, _ rhs: KeyframeGroup<T>) -> Bool {
+    lhs.keyframes == rhs.keyframes
+  }
+}
+
+// MARK: Hashable
+
+extension KeyframeGroup: Hashable where T: Hashable {
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(keyframes)
+  }
+}
+
+// MARK: Sendable
+
+extension KeyframeGroup: Sendable where T: Sendable { }
+
+extension Keyframe {
+  /// Creates a copy of this `Keyframe` with the same timing data, but a different value
+  func withValue<Value>(_ newValue: Value) -> Keyframe<Value> {
+    Keyframe<Value>(
+      value: newValue,
+      time: time,
+      isHold: isHold,
+      inTangent: inTangent,
+      outTangent: outTangent,
+      spatialInTangent: spatialInTangent,
+      spatialOutTangent: spatialOutTangent
+    )
+  }
+}
+
+extension KeyframeGroup {
+  /// Maps the values of each individual keyframe in this group
+  func map<NewValue>(_ transformation: (T) throws -> NewValue) rethrows -> KeyframeGroup<NewValue> {
+    KeyframeGroup<NewValue>(
+      keyframes: ContiguousArray(try keyframes.map { keyframe in
+        keyframe.withValue(try transformation(keyframe.value))
+      }),
+      unsupportedAfterEffectsExpression: unsupportedAfterEffectsExpression
+    )
+  }
+}
+
+// MARK: - AnyKeyframeGroup
+
+/// A type-erased wrapper for `KeyframeGroup`s
+protocol AnyKeyframeGroup {
+  /// An untyped copy of these keyframes
+  var untyped: KeyframeGroup<Any> { get }
+
+  /// An untyped `KeyframeInterpolator` for these keyframes
+  var interpolator: AnyValueProvider { get }
+}
+
+// MARK: - KeyframeGroup + AnyKeyframeGroup
+
+extension KeyframeGroup: AnyKeyframeGroup where T: AnyInterpolatable {
+  var untyped: KeyframeGroup<Any> {
+    map { $0 as Any }
+  }
+
+  var interpolator: AnyValueProvider {
+    KeyframeInterpolator(keyframes: keyframes)
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/LayerEffects/DropShadowEffect.swift

@@ -0,0 +1,52 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+// MARK: - DropShadowEffect
+
+final class DropShadowEffect: LayerEffect {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The color of the drop shadow
+  var color: ColorEffectValue? {
+    value(named: "Shadow Color")
+  }
+
+  /// Opacity between 0 and 255
+  var opacity: Vector1DEffectValue? {
+    value(named: "Opacity")
+  }
+
+  /// The direction / angle of the drop shadow, in degrees
+  var direction: Vector1DEffectValue? {
+    value(named: "Direction")
+  }
+
+  /// The distance of the drop shadow
+  var distance: Vector1DEffectValue? {
+    value(named: "Distance")
+  }
+
+  /// The softness of the drop shadow
+  var softness: Vector1DEffectValue? {
+    value(named: "Softness")
+  }
+
+}
+
+// MARK: @unchecked Sendable
+
+/// `DropShadowEffect` inherits `@unchecked Sendable` from `LayerEffect` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension DropShadowEffect: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/LayerEffects/EffectValues/ColorEffectValue.swift

@@ -0,0 +1,45 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+// MARK: - ColorEffectValue
+
+final class ColorEffectValue: EffectValue {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    value = try? container.decode(KeyframeGroup<LottieColor>.self, forKey: .value)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let valueDictionary: [String: Any] = try dictionary.value(for: CodingKeys.value)
+    value = try KeyframeGroup<LottieColor>(dictionary: valueDictionary)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The value of the color
+  let value: KeyframeGroup<LottieColor>?
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(value, forKey: .value)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case value = "v"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `ColorEffectValue` inherits `@unchecked Sendable` from `EffectValue` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension ColorEffectValue: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/LayerEffects/EffectValues/EffectValue.swift

@@ -0,0 +1,98 @@
+// Created by Cal Stephens on 8/15/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+// MARK: - EffectValueType
+
+/// https://lottiefiles.github.io/lottie-docs/schema/#/$defs/effect-values
+enum EffectValueType: Int, Codable, Sendable {
+  case slider = 0
+  case angle = 1
+  case color = 2
+  case unknown = 9999
+
+  init(from decoder: Decoder) throws {
+    self = try EffectValueType(rawValue: decoder.singleValueContainer().decode(RawValue.self)) ?? .unknown
+  }
+}
+
+// MARK: ClassFamily
+
+extension EffectValueType: ClassFamily {
+  static var discriminator = Discriminator.type
+
+  func getType() -> AnyObject.Type {
+    switch self {
+    case .slider:
+      Vector1DEffectValue.self
+    case .angle:
+      Vector1DEffectValue.self
+    case .color:
+      ColorEffectValue.self
+    case .unknown:
+      // Unsupported
+      LayerEffect.self
+    }
+  }
+}
+
+// MARK: - EffectValue
+
+/// Base class for layer effects
+class EffectValue: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: EffectValue.CodingKeys.self)
+    type = try container.decode(EffectValueType.self, forKey: .type)
+    name = try container.decode(String.self, forKey: .name)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    type = (try? dictionary.value(for: CodingKeys.type)).flatMap(EffectValueType.init(rawValue:)) ?? .unknown
+    name = (try? dictionary.value(for: CodingKeys.name)) ?? "Effect"
+  }
+
+  // MARK: Internal
+
+  /// The type of effect value
+  let type: EffectValueType
+
+  /// The name of the effect value
+  let name: String
+
+  // MARK: Fileprivate
+
+  fileprivate enum CodingKeys: String, CodingKey {
+    case type = "ty"
+    case name = "nm"
+  }
+}
+
+extension [EffectValue] {
+  static func fromDictionaries(_ dictionaries: [[String: Any]]) throws -> [EffectValue] {
+    try dictionaries.compactMap { dictionary in
+      let shapeType = dictionary[EffectValue.CodingKeys.type.rawValue] as? Int
+      switch EffectValueType(rawValue: shapeType ?? EffectValueType.unknown.rawValue) {
+      case .slider:
+        return try Vector1DEffectValue(dictionary: dictionary)
+      case .angle:
+        return try Vector1DEffectValue(dictionary: dictionary)
+      case .color:
+        return try ColorEffectValue(dictionary: dictionary)
+      case .unknown:
+        // Unsupported
+        return try EffectValue(dictionary: dictionary)
+      case nil:
+        return nil
+      }
+    }
+  }
+}
+
+// MARK: - EffectValue + @unchecked Sendable
+
+/// Since `EffectValue` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `EffectValue` subclasses are immutable `Sendable` values.
+// swiftlint:disable:next no_unchecked_sendable
+extension EffectValue: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/LayerEffects/EffectValues/Vector1DEffectValue.swift

@@ -0,0 +1,45 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+// MARK: - Vector1DEffectValue
+
+final class Vector1DEffectValue: EffectValue {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    value = try? container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .value)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let valueDictionary: [String: Any] = try dictionary.value(for: CodingKeys.value)
+    value = try KeyframeGroup<LottieVector1D>(dictionary: valueDictionary)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The value of the slider
+  let value: KeyframeGroup<LottieVector1D>?
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(value, forKey: .value)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case value = "v"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `Vector1DEffectValue` inherits `@unchecked Sendable` from `EffectValue` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension Vector1DEffectValue: @unchecked Sendable { }