@octane-xplat/lottie 0.0.1 → 0.10.0

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

@@ -0,0 +1,103 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+// MARK: - LayerEffectType
+
+/// https://lottiefiles.github.io/lottie-docs/schema/#/$defs/effects
+enum LayerEffectType: Int, Codable, Sendable {
+  case dropShadow = 25
+  case unknown = 9999
+
+  init(from decoder: Decoder) throws {
+    self = try LayerEffectType(rawValue: decoder.singleValueContainer().decode(RawValue.self)) ?? .unknown
+  }
+}
+
+// MARK: ClassFamily
+
+extension LayerEffectType: ClassFamily {
+  static var discriminator = Discriminator.type
+
+  func getType() -> AnyObject.Type {
+    switch self {
+    case .dropShadow:
+      DropShadowEffect.self
+    case .unknown:
+      // Unsupported
+      LayerEffect.self
+    }
+  }
+}
+
+// MARK: - LayerEffect
+
+/// Base class for layer effects
+class LayerEffect: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: LayerEffect.CodingKeys.self)
+    name = try container.decodeIfPresent(String.self, forKey: .name) ?? "Effect"
+    type = try container.decode(LayerEffectType.self, forKey: .type)
+    effects = try container.decodeIfPresent([EffectValue].self, ofFamily: EffectValueType.self, forKey: .effects) ?? []
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    name = (try? dictionary.value(for: CodingKeys.name)) ?? "Layer"
+    type = LayerEffectType(rawValue: try dictionary.value(for: CodingKeys.type)) ?? .unknown
+    if let valueDictionaries = dictionary[CodingKeys.effects.rawValue] as? [[String: Any]] {
+      effects = try [EffectValue].fromDictionaries(valueDictionaries)
+    } else {
+      effects = []
+    }
+  }
+
+  // MARK: Internal
+
+  /// The name of the effect
+  let name: String
+
+  /// The type of effect
+  let type: LayerEffectType
+
+  /// Values that configure the behavior of the effect
+  let effects: [EffectValue]
+
+  /// Retrieves the `EffectValue` for the given name
+  func value<ValueType: EffectValue>(named name: String) -> ValueType? {
+    effects.first(where: {
+      $0.name == name && $0 is ValueType
+    }) as? ValueType
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate enum CodingKeys: String, CodingKey {
+    case name = "nm"
+    case type = "ty"
+    case effects = "ef"
+  }
+}
+
+extension [LayerEffect] {
+  static func fromDictionaries(_ dictionaries: [[String: Any]]) throws -> [LayerEffect] {
+    try dictionaries.compactMap { dictionary in
+      let shapeType = dictionary[LayerEffect.CodingKeys.type.rawValue] as? Int
+      switch LayerEffectType(rawValue: shapeType ?? LayerEffectType.unknown.rawValue) {
+      case .dropShadow:
+        return try DropShadowEffect(dictionary: dictionary)
+      case .unknown, nil:
+        // Unsupported
+        return try LayerEffect(dictionary: dictionary)
+      }
+    }
+  }
+}
+
+// MARK: - LayerEffect + @unchecked Sendable
+
+/// Since `LayerEffect` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `LayerEffect` subclasses are immutable `Sendable` values.
+// swiftlint:disable:next no_unchecked_sendable
+extension LayerEffect: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/LayerStyles/DropShadowStyle.swift

@@ -0,0 +1,79 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+// MARK: - DropShadowStyle
+
+final class DropShadowStyle: LayerStyle {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: DropShadowStyle.CodingKeys.self)
+    opacity = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
+    color = try container.decode(KeyframeGroup<LottieColor>.self, forKey: .color)
+    angle = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .angle)
+    size = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .size)
+    distance = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .distance)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let opacityDictionary: [String: Any] = try dictionary.value(for: CodingKeys.opacity)
+    opacity = try KeyframeGroup<LottieVector1D>(dictionary: opacityDictionary)
+    let colorDictionary: [String: Any] = try dictionary.value(for: CodingKeys.color)
+    color = try KeyframeGroup<LottieColor>(dictionary: colorDictionary)
+    let angleDictionary: [String: Any] = try dictionary.value(for: CodingKeys.angle)
+    angle = try KeyframeGroup<LottieVector1D>(dictionary: angleDictionary)
+    let sizeDictionary: [String: Any] = try dictionary.value(for: CodingKeys.size)
+    size = try KeyframeGroup<LottieVector1D>(dictionary: sizeDictionary)
+    let distanceDictionary: [String: Any] = try dictionary.value(for: CodingKeys.distance)
+    distance = try KeyframeGroup<LottieVector1D>(dictionary: distanceDictionary)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The opacity of the drop shadow
+  let opacity: KeyframeGroup<LottieVector1D>
+
+  /// The color of the drop shadow
+  let color: KeyframeGroup<LottieColor>
+
+  /// The angle of the drop shadow, in degrees,
+  /// with `0` representing a shadow straight-down from the layer
+  /// (`offsetY=distance, offsetX=0`).
+  let angle: KeyframeGroup<LottieVector1D>
+
+  /// The size of the drop shadow
+  let size: KeyframeGroup<LottieVector1D>
+
+  /// The distance of the drop shadow
+  let distance: KeyframeGroup<LottieVector1D>
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(opacity, forKey: .opacity)
+    try container.encode(color, forKey: .color)
+    try container.encode(angle, forKey: .angle)
+    try container.encode(size, forKey: .size)
+    try container.encode(distance, forKey: .distance)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case color = "c"
+    case opacity = "o"
+    case angle = "a"
+    case size = "s"
+    case distance = "d"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `DropShadowStyle` inherits `@unchecked Sendable` from `LayerStyle` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension DropShadowStyle: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/LayerStyles/LayerStyle.swift

@@ -0,0 +1,85 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+// MARK: - LayerStyleType
+
+enum LayerStyleType: Int, Codable, Sendable {
+  case dropShadow = 1
+  case unknown = 9999
+
+  init(from decoder: Decoder) throws {
+    self = try LayerStyleType(rawValue: decoder.singleValueContainer().decode(RawValue.self)) ?? .unknown
+  }
+}
+
+// MARK: ClassFamily
+
+extension LayerStyleType: ClassFamily {
+  static var discriminator = Discriminator.type
+
+  func getType() -> AnyObject.Type {
+    switch self {
+    case .dropShadow:
+      DropShadowStyle.self
+    case .unknown:
+      // Unsupported
+      LayerStyle.self
+    }
+  }
+}
+
+// MARK: - LayerStyle
+
+/// Base class for layer styles
+class LayerStyle: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: LayerStyle.CodingKeys.self)
+    name = try container.decodeIfPresent(String.self, forKey: .name) ?? "Style"
+    type = try container.decode(LayerStyleType.self, forKey: .type)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    name = (try? dictionary.value(for: CodingKeys.name)) ?? "Layer"
+    type = LayerStyleType(rawValue: try dictionary.value(for: CodingKeys.type)) ?? .unknown
+  }
+
+  // MARK: Internal
+
+  /// The name of the style
+  let name: String
+
+  /// The type of style
+  let type: LayerStyleType
+
+  // MARK: Fileprivate
+
+  fileprivate enum CodingKeys: String, CodingKey {
+    case name = "nm"
+    case type = "ty"
+  }
+}
+
+extension [LayerStyle] {
+  static func fromDictionaries(_ dictionaries: [[String: Any]]) throws -> [LayerStyle] {
+    try dictionaries.compactMap { dictionary in
+      let shapeType = dictionary[LayerStyle.CodingKeys.type.rawValue] as? Int
+      switch LayerStyleType(rawValue: shapeType ?? LayerStyleType.unknown.rawValue) {
+      case .dropShadow:
+        return try DropShadowStyle(dictionary: dictionary)
+      case .unknown, nil:
+        // Unsupported
+        return try LayerStyle(dictionary: dictionary)
+      }
+    }
+  }
+}
+
+// MARK: - LayerStyle + @unchecked Sendable
+
+/// Since `LayerStyle` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `LayerStyle` subclasses are immutable `Sendable` values.
+// swiftlint:disable:next no_unchecked_sendable
+extension LayerStyle: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/Layers/ImageLayerModel.swift

@@ -0,0 +1,49 @@
+//
+//  ImageLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - ImageLayerModel
+
+/// A layer that holds an image.
+final class ImageLayerModel: LayerModel {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: ImageLayerModel.CodingKeys.self)
+    referenceID = try container.decode(String.self, forKey: .referenceID)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    referenceID = try dictionary.value(for: CodingKeys.referenceID)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The reference ID of the image.
+  let referenceID: String
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(referenceID, forKey: .referenceID)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case referenceID = "refId"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `ImageLayerModel` inherits `@unchecked Sendable` from `LayerModel` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension ImageLayerModel: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/Layers/LayerModel.swift

@@ -0,0 +1,266 @@
+//
+//  Layer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/7/19.
+//
+
+// MARK: - LayerType + ClassFamily
+
+/// Used for mapping a heterogeneous list to classes for parsing.
+extension LayerType: ClassFamily {
+  static var discriminator = Discriminator.type
+
+  func getType() -> AnyObject.Type {
+    switch self {
+    case .precomp:
+      PreCompLayerModel.self
+    case .solid:
+      SolidLayerModel.self
+    case .image:
+      ImageLayerModel.self
+    case .null:
+      LayerModel.self
+    case .shape:
+      ShapeLayerModel.self
+    case .text:
+      TextLayerModel.self
+    case .unknown:
+      LayerModel.self
+    }
+  }
+}
+
+// MARK: - LayerType
+
+public enum LayerType: Int, Codable {
+  case precomp
+  case solid
+  case image
+  case null
+  case shape
+  case text
+  case unknown
+
+  public init(from decoder: Decoder) throws {
+    self = try LayerType(rawValue: decoder.singleValueContainer().decode(RawValue.self)) ?? .null
+  }
+}
+
+// MARK: - MatteType
+
+public enum MatteType: Int, Codable {
+  case none
+  case add
+  case invert
+  case unknown
+}
+
+// MARK: - BlendMode
+
+public enum BlendMode: Int, Codable {
+  case normal
+  case multiply
+  case screen
+  case overlay
+  case darken
+  case lighten
+  case colorDodge
+  case colorBurn
+  case hardLight
+  case softLight
+  case difference
+  case exclusion
+  case hue
+  case saturation
+  case color
+  case luminosity
+}
+
+// MARK: - LayerModel
+
+/// A base top container for shapes, images, and other view objects.
+class LayerModel: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: LayerModel.CodingKeys.self)
+    name = try container.decodeIfPresent(String.self, forKey: .name) ?? "Layer"
+    index = try container.decodeIfPresent(Int.self, forKey: .index) ?? .random(in: Int.min...Int.max)
+    type = try container.decode(LayerType.self, forKey: .type)
+    coordinateSpace = try container.decodeIfPresent(CoordinateSpace.self, forKey: .coordinateSpace) ?? .type2d
+    inFrame = try container.decode(Double.self, forKey: .inFrame)
+    outFrame = try container.decode(Double.self, forKey: .outFrame)
+    startTime = try container.decode(Double.self, forKey: .startTime)
+    transform = try container.decodeIfPresent(Transform.self, forKey: .transform) ?? .default
+    parent = try container.decodeIfPresent(Int.self, forKey: .parent)
+    blendMode = try container.decodeIfPresent(BlendMode.self, forKey: .blendMode) ?? .normal
+    masks = try container.decodeIfPresent([Mask].self, forKey: .masks)
+    timeStretch = try container.decodeIfPresent(Double.self, forKey: .timeStretch) ?? 1
+    matte = try container.decodeIfPresent(MatteType.self, forKey: .matte)
+    hidden = try container.decodeIfPresent(Bool.self, forKey: .hidden) ?? false
+    styles = try container.decodeIfPresent([LayerStyle].self, ofFamily: LayerStyleType.self, forKey: .styles) ?? []
+    effects = try container.decodeIfPresent([LayerEffect].self, ofFamily: LayerEffectType.self, forKey: .effects) ?? []
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    name = (try? dictionary.value(for: CodingKeys.name)) ?? "Layer"
+    index = try dictionary.value(for: CodingKeys.index) ?? .random(in: Int.min...Int.max)
+    type = LayerType(rawValue: try dictionary.value(for: CodingKeys.type)) ?? .null
+    if
+      let coordinateSpaceRawValue = dictionary[CodingKeys.coordinateSpace.rawValue] as? Int,
+      let coordinateSpace = CoordinateSpace(rawValue: coordinateSpaceRawValue)
+    {
+      self.coordinateSpace = coordinateSpace
+    } else {
+      coordinateSpace = .type2d
+    }
+    inFrame = try dictionary.value(for: CodingKeys.inFrame)
+    outFrame = try dictionary.value(for: CodingKeys.outFrame)
+    startTime = try dictionary.value(for: CodingKeys.startTime)
+    parent = try? dictionary.value(for: CodingKeys.parent)
+    if
+      let transformDictionary: [String: Any] = try dictionary.value(for: CodingKeys.transform),
+      let transform = try? Transform(dictionary: transformDictionary)
+    {
+      self.transform = transform
+    } else {
+      transform = .default
+    }
+    if
+      let blendModeRawValue = dictionary[CodingKeys.blendMode.rawValue] as? Int,
+      let blendMode = BlendMode(rawValue: blendModeRawValue)
+    {
+      self.blendMode = blendMode
+    } else {
+      blendMode = .normal
+    }
+    if let maskDictionaries = dictionary[CodingKeys.masks.rawValue] as? [[String: Any]] {
+      masks = try maskDictionaries.map { try Mask(dictionary: $0) }
+    } else {
+      masks = nil
+    }
+    timeStretch = (try? dictionary.value(for: CodingKeys.timeStretch)) ?? 1
+    if let matteRawValue = dictionary[CodingKeys.matte.rawValue] as? Int {
+      matte = MatteType(rawValue: matteRawValue)
+    } else {
+      matte = nil
+    }
+    hidden = (try? dictionary.value(for: CodingKeys.hidden)) ?? false
+    if let styleDictionaries = dictionary[CodingKeys.styles.rawValue] as? [[String: Any]] {
+      styles = try [LayerStyle].fromDictionaries(styleDictionaries)
+    } else {
+      styles = []
+    }
+    if let effectDictionaries = dictionary[CodingKeys.effects.rawValue] as? [[String: Any]] {
+      effects = try [LayerEffect].fromDictionaries(effectDictionaries)
+    } else {
+      effects = []
+    }
+  }
+
+  // MARK: Internal
+
+  /// The readable name of the layer
+  let name: String
+
+  /// The index of the layer
+  let index: Int
+
+  /// The type of the layer.
+  let type: LayerType
+
+  /// The coordinate space
+  let coordinateSpace: CoordinateSpace
+
+  /// The in time of the layer in frames.
+  let inFrame: Double
+  /// The out time of the layer in frames.
+  let outFrame: Double
+
+  /// The start time of the layer in frames.
+  let startTime: Double
+
+  /// The transform of the layer
+  let transform: Transform
+
+  /// The index of the parent layer, if applicable.
+  let parent: Int?
+
+  /// The blending mode for the layer
+  let blendMode: BlendMode
+
+  /// An array of masks for the layer.
+  let masks: [Mask]?
+
+  /// A number that stretches time by a multiplier
+  let timeStretch: Double
+
+  /// The type of matte if any.
+  let matte: MatteType?
+
+  /// Whether or not this layer is hidden, in which case it will not be rendered.
+  let hidden: Bool
+
+  /// A list of styles to apply to this layer
+  let styles: [LayerStyle]
+
+  /// A list of effects to apply to this layer
+  let effects: [LayerEffect]
+
+  // MARK: Fileprivate
+
+  fileprivate enum CodingKeys: String, CodingKey {
+    case name = "nm"
+    case index = "ind"
+    case type = "ty"
+    case coordinateSpace = "ddd"
+    case inFrame = "ip"
+    case outFrame = "op"
+    case startTime = "st"
+    case transform = "ks"
+    case parent
+    case blendMode = "bm"
+    case masks = "masksProperties"
+    case timeStretch = "sr"
+    case matte = "tt"
+    case hidden = "hd"
+    case styles = "sy"
+    case effects = "ef"
+  }
+}
+
+extension [LayerModel] {
+
+  static func fromDictionaries(_ dictionaries: [[String: Any]]) throws -> [LayerModel] {
+    try dictionaries.compactMap { dictionary in
+      let layerType = dictionary[LayerModel.CodingKeys.type.rawValue] as? Int
+      switch LayerType(rawValue: layerType ?? LayerType.null.rawValue) {
+      case .precomp:
+        return try PreCompLayerModel(dictionary: dictionary)
+      case .solid:
+        return try SolidLayerModel(dictionary: dictionary)
+      case .image:
+        return try ImageLayerModel(dictionary: dictionary)
+      case .null:
+        return try LayerModel(dictionary: dictionary)
+      case .shape:
+        return try ShapeLayerModel(dictionary: dictionary)
+      case .text:
+        return try TextLayerModel(dictionary: dictionary)
+      case .unknown:
+        return try LayerModel(dictionary: dictionary)
+      case .none:
+        return nil
+      }
+    }
+  }
+}
+
+// MARK: - LayerModel + @unchecked Sendable
+
+/// Since `LayerModel` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `LayerModel` subclasses are immutable `Sendable` values.
+// swiftlint:disable:next no_unchecked_sendable
+extension LayerModel: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/Layers/PreCompLayerModel.swift

@@ -0,0 +1,74 @@
+//
+//  PreCompLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - PreCompLayerModel
+
+/// A layer that holds another animation composition.
+final class PreCompLayerModel: LayerModel {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: PreCompLayerModel.CodingKeys.self)
+    referenceID = try container.decode(String.self, forKey: .referenceID)
+    timeRemapping = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .timeRemapping)
+    width = try container.decode(Double.self, forKey: .width)
+    height = try container.decode(Double.self, forKey: .height)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    referenceID = try dictionary.value(for: CodingKeys.referenceID)
+    if let timeRemappingDictionary = dictionary[CodingKeys.timeRemapping.rawValue] as? [String: Any] {
+      timeRemapping = try KeyframeGroup<LottieVector1D>(dictionary: timeRemappingDictionary)
+    } else {
+      timeRemapping = nil
+    }
+    width = try dictionary.value(for: CodingKeys.width)
+    height = try dictionary.value(for: CodingKeys.height)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The reference ID of the precomp.
+  let referenceID: String
+
+  /// A value that remaps time over time.
+  let timeRemapping: KeyframeGroup<LottieVector1D>?
+
+  /// Precomp Width
+  let width: Double
+
+  /// Precomp Height
+  let height: Double
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(referenceID, forKey: .referenceID)
+    try container.encode(timeRemapping, forKey: .timeRemapping)
+    try container.encode(width, forKey: .width)
+    try container.encode(height, forKey: .height)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case referenceID = "refId"
+    case timeRemapping = "tm"
+    case width = "w"
+    case height = "h"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `PreCompLayerModel` inherits `@unchecked Sendable` from `LayerModel` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension PreCompLayerModel: @unchecked Sendable { }