@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/Model/ShapeItems/Star.swift

@@ -0,0 +1,136 @@
+//
+//  Star.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - StarType
+
+enum StarType: Int, Codable, Sendable {
+  case none
+  case star
+  case polygon
+}
+
+// MARK: - Star
+
+final class Star: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Star.CodingKeys.self)
+    direction = try container.decodeIfPresent(PathDirection.self, forKey: .direction) ?? .clockwise
+    position = try container.decode(KeyframeGroup<LottieVector3D>.self, forKey: .position)
+    outerRadius = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .outerRadius)
+    outerRoundness = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .outerRoundness)
+    innerRadius = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .innerRadius)
+    innerRoundness = try container.decodeIfPresent(KeyframeGroup<LottieVector1D>.self, forKey: .innerRoundness)
+    rotation = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .rotation)
+    points = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .points)
+    starType = try container.decode(StarType.self, forKey: .starType)
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if
+      let directionRawValue = dictionary[CodingKeys.direction.rawValue] as? Int,
+      let direction = PathDirection(rawValue: directionRawValue)
+    {
+      self.direction = direction
+    } else {
+      direction = .clockwise
+    }
+    let positionDictionary: [String: Any] = try dictionary.value(for: CodingKeys.position)
+    position = try KeyframeGroup<LottieVector3D>(dictionary: positionDictionary)
+    let outerRadiusDictionary: [String: Any] = try dictionary.value(for: CodingKeys.outerRadius)
+    outerRadius = try KeyframeGroup<LottieVector1D>(dictionary: outerRadiusDictionary)
+    let outerRoundnessDictionary: [String: Any] = try dictionary.value(for: CodingKeys.outerRoundness)
+    outerRoundness = try KeyframeGroup<LottieVector1D>(dictionary: outerRoundnessDictionary)
+    if let innerRadiusDictionary = dictionary[CodingKeys.innerRadius.rawValue] as? [String: Any] {
+      innerRadius = try KeyframeGroup<LottieVector1D>(dictionary: innerRadiusDictionary)
+    } else {
+      innerRadius = nil
+    }
+    if let innerRoundnessDictionary = dictionary[CodingKeys.innerRoundness.rawValue] as? [String: Any] {
+      innerRoundness = try KeyframeGroup<LottieVector1D>(dictionary: innerRoundnessDictionary)
+    } else {
+      innerRoundness = nil
+    }
+    let rotationDictionary: [String: Any] = try dictionary.value(for: CodingKeys.rotation)
+    rotation = try KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
+    let pointsDictionary: [String: Any] = try dictionary.value(for: CodingKeys.points)
+    points = try KeyframeGroup<LottieVector1D>(dictionary: pointsDictionary)
+    let starTypeRawValue: Int = try dictionary.value(for: CodingKeys.starType)
+    guard let starType = StarType(rawValue: starTypeRawValue) else {
+      throw InitializableError.invalidInput()
+    }
+    self.starType = starType
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The direction of the star.
+  let direction: PathDirection
+
+  /// The position of the star
+  let position: KeyframeGroup<LottieVector3D>
+
+  /// The outer radius of the star
+  let outerRadius: KeyframeGroup<LottieVector1D>
+
+  /// The outer roundness of the star
+  let outerRoundness: KeyframeGroup<LottieVector1D>
+
+  /// The outer radius of the star
+  let innerRadius: KeyframeGroup<LottieVector1D>?
+
+  /// The outer roundness of the star
+  let innerRoundness: KeyframeGroup<LottieVector1D>?
+
+  /// The rotation of the star
+  let rotation: KeyframeGroup<LottieVector1D>
+
+  /// The number of points on the star
+  let points: KeyframeGroup<LottieVector1D>
+
+  /// The type of star
+  let starType: StarType
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(direction, forKey: .direction)
+    try container.encode(position, forKey: .position)
+    try container.encode(outerRadius, forKey: .outerRadius)
+    try container.encode(outerRoundness, forKey: .outerRoundness)
+    try container.encode(innerRadius, forKey: .innerRadius)
+    try container.encode(innerRoundness, forKey: .innerRoundness)
+    try container.encode(rotation, forKey: .rotation)
+    try container.encode(points, forKey: .points)
+    try container.encode(starType, forKey: .starType)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case direction = "d"
+    case position = "p"
+    case outerRadius = "or"
+    case outerRoundness = "os"
+    case innerRadius = "ir"
+    case innerRoundness = "is"
+    case rotation = "r"
+    case points = "pt"
+    case starType = "sy"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `Star` inherits `@unchecked Sendable` from `ShapeItem` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension Star: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/ShapeItems/Stroke.swift

@@ -0,0 +1,144 @@
+//
+//  Stroke.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - Stroke
+
+final class Stroke: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Stroke.CodingKeys.self)
+    opacity = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .opacity)
+    color = try container.decode(KeyframeGroup<LottieColor>.self, forKey: .color)
+    width = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .width)
+    lineCap = try container.decodeIfPresent(LineCap.self, forKey: .lineCap) ?? .round
+    lineJoin = try container.decodeIfPresent(LineJoin.self, forKey: .lineJoin) ?? .round
+    miterLimit = try container.decodeIfPresent(Double.self, forKey: .miterLimit) ?? 4
+    dashPattern = try container.decodeIfPresent([DashElement].self, forKey: .dashPattern)
+    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 widthDictionary: [String: Any] = try dictionary.value(for: CodingKeys.width)
+    width = try KeyframeGroup<LottieVector1D>(dictionary: widthDictionary)
+    if
+      let lineCapRawValue = dictionary[CodingKeys.lineCap.rawValue] as? Int,
+      let lineCap = LineCap(rawValue: lineCapRawValue)
+    {
+      self.lineCap = lineCap
+    } else {
+      lineCap = .round
+    }
+    if
+      let lineJoinRawValue = dictionary[CodingKeys.lineJoin.rawValue] as? Int,
+      let lineJoin = LineJoin(rawValue: lineJoinRawValue)
+    {
+      self.lineJoin = lineJoin
+    } else {
+      lineJoin = .round
+    }
+    miterLimit = (try? dictionary.value(for: CodingKeys.miterLimit)) ?? 4
+    let dashPatternDictionaries = dictionary[CodingKeys.dashPattern.rawValue] as? [[String: Any]]
+    dashPattern = try? dashPatternDictionaries?.map { try DashElement(dictionary: $0) }
+    try super.init(dictionary: dictionary)
+  }
+
+  init(
+    name: String,
+    hidden: Bool,
+    opacity: KeyframeGroup<LottieVector1D>,
+    color: KeyframeGroup<LottieColor>,
+    width: KeyframeGroup<LottieVector1D>,
+    lineCap: LineCap,
+    lineJoin: LineJoin,
+    miterLimit: Double,
+    dashPattern: [DashElement]?
+  ) {
+    self.opacity = opacity
+    self.color = color
+    self.width = width
+    self.lineCap = lineCap
+    self.lineJoin = lineJoin
+    self.miterLimit = miterLimit
+    self.dashPattern = dashPattern
+    super.init(name: name, type: .stroke, hidden: hidden)
+  }
+
+  // MARK: Internal
+
+  /// The opacity of the stroke
+  let opacity: KeyframeGroup<LottieVector1D>
+
+  /// The Color of the stroke
+  let color: KeyframeGroup<LottieColor>
+
+  /// The width of the stroke
+  let width: KeyframeGroup<LottieVector1D>
+
+  /// Line Cap
+  let lineCap: LineCap
+
+  /// Line Join
+  let lineJoin: LineJoin
+
+  /// Miter Limit
+  let miterLimit: Double
+
+  /// The dash pattern of the stroke
+  let dashPattern: [DashElement]?
+
+  /// Creates a copy of this Stroke with the given updated width keyframes
+  func copy(width newWidth: KeyframeGroup<LottieVector1D>) -> Stroke {
+    Stroke(
+      name: name,
+      hidden: hidden,
+      opacity: opacity,
+      color: color,
+      width: newWidth,
+      lineCap: lineCap,
+      lineJoin: lineJoin,
+      miterLimit: miterLimit,
+      dashPattern: dashPattern
+    )
+  }
+
+  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(width, forKey: .width)
+    try container.encode(lineCap, forKey: .lineCap)
+    try container.encode(lineJoin, forKey: .lineJoin)
+    try container.encode(miterLimit, forKey: .miterLimit)
+    try container.encodeIfPresent(dashPattern, forKey: .dashPattern)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case opacity = "o"
+    case color = "c"
+    case width = "w"
+    case lineCap = "lc"
+    case lineJoin = "lj"
+    case miterLimit = "ml"
+    case dashPattern = "d"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `Stroke` inherits `@unchecked Sendable` from `ShapeItem` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension Stroke: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/ShapeItems/Trim.swift

@@ -0,0 +1,90 @@
+//
+//  Trim.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/8/19.
+//
+
+// MARK: - TrimType
+
+enum TrimType: Int, Codable {
+  case simultaneously = 1
+  case individually = 2
+}
+
+// MARK: - Trim
+
+final class Trim: ShapeItem {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Trim.CodingKeys.self)
+    start = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .start)
+    end = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .end)
+    offset = try container.decode(KeyframeGroup<LottieVector1D>.self, forKey: .offset)
+    trimType = try container.decodeIfPresent(TrimType.self, forKey: .trimType) ?? .individually
+    try super.init(from: decoder)
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    let startDictionary: [String: Any] = try dictionary.value(for: CodingKeys.start)
+    start = try KeyframeGroup<LottieVector1D>(dictionary: startDictionary)
+    let endDictionary: [String: Any] = try dictionary.value(for: CodingKeys.end)
+    end = try KeyframeGroup<LottieVector1D>(dictionary: endDictionary)
+    let offsetDictionary: [String: Any] = try dictionary.value(for: CodingKeys.offset)
+    offset = try KeyframeGroup<LottieVector1D>(dictionary: offsetDictionary)
+    let trimTypeRawValue: Int = try dictionary.value(for: CodingKeys.trimType) ?? TrimType.individually.rawValue
+    guard let trimType = TrimType(rawValue: trimTypeRawValue) else {
+      throw InitializableError.invalidInput()
+    }
+    self.trimType = trimType
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The start of the trim
+  let start: KeyframeGroup<LottieVector1D>
+
+  /// The end of the trim
+  let end: KeyframeGroup<LottieVector1D>
+
+  /// The offset of the trim
+  let offset: KeyframeGroup<LottieVector1D>
+
+  let trimType: TrimType
+
+  /// If this trim doesn't affect the path at all then we can consider it empty
+  var isEmpty: Bool {
+    start.keyframes.count == 1
+      && start.keyframes[0].value.value == 0
+      && end.keyframes.count == 1
+      && end.keyframes[0].value.value == 100
+  }
+
+  override func encode(to encoder: Encoder) throws {
+    try super.encode(to: encoder)
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(start, forKey: .start)
+    try container.encode(end, forKey: .end)
+    try container.encode(offset, forKey: .offset)
+    try container.encode(trimType, forKey: .trimType)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case start = "s"
+    case end = "e"
+    case offset = "o"
+    case trimType = "m"
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// `Trim` inherits `@unchecked Sendable` from `ShapeItem` and
+/// we need to restate that here to avoid a warning in Xcode 16
+// swiftlint:disable:next no_unchecked_sendable
+extension Trim: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/Text/Font.swift

@@ -0,0 +1,67 @@
+//
+//  Font.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+// MARK: - Font
+
+final class Font: Codable, Sendable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    name = try container.decode(String.self, forKey: .name)
+    familyName = try container.decode(String.self, forKey: .familyName)
+    style = try container.decode(String.self, forKey: .style)
+    ascent = try container.decodeIfPresent(Double.self, forKey: .ascent) ?? 0
+  }
+
+  init(dictionary: [String: Any]) throws {
+    name = try dictionary.value(for: CodingKeys.name)
+    familyName = try dictionary.value(for: CodingKeys.familyName)
+    style = try dictionary.value(for: CodingKeys.style)
+    ascent = (try? dictionary.value(for: CodingKeys.ascent)) ?? 0
+  }
+
+  // MARK: Internal
+
+  let name: String
+  let familyName: String
+  let style: String
+  let ascent: Double
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case name = "fName"
+    case familyName = "fFamily"
+    case style = "fStyle"
+    case ascent
+  }
+
+}
+
+// MARK: - FontList
+
+/// A list of fonts
+final class FontList: Codable, Sendable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  init(dictionary: [String: Any]) throws {
+    let fontDictionaries: [[String: Any]] = try dictionary.value(for: CodingKeys.fonts)
+    fonts = try fontDictionaries.map { try Font(dictionary: $0) }
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case fonts = "list"
+  }
+
+  let fonts: [Font]
+
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/Text/Glyph.swift

@@ -0,0 +1,94 @@
+//
+//  Glyph.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+/// A model that holds a vector character
+final class Glyph: Codable, Sendable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Glyph.CodingKeys.self)
+    character = try container.decode(String.self, forKey: .character)
+    fontSize = try container.decode(Double.self, forKey: .fontSize)
+    fontFamily = try container.decode(String.self, forKey: .fontFamily)
+    fontStyle = try container.decode(String.self, forKey: .fontStyle)
+    width = try container.decode(Double.self, forKey: .width)
+    if
+      container.contains(.shapeWrapper),
+      let shapeContainer = try? container.nestedContainer(keyedBy: ShapeKey.self, forKey: .shapeWrapper),
+      shapeContainer.contains(.shapes)
+    {
+      shapes = try shapeContainer.decode([ShapeItem].self, ofFamily: ShapeType.self, forKey: .shapes)
+    } else {
+      shapes = []
+    }
+  }
+
+  init(dictionary: [String: Any]) throws {
+    character = try dictionary.value(for: CodingKeys.character)
+    fontSize = try dictionary.value(for: CodingKeys.fontSize)
+    fontFamily = try dictionary.value(for: CodingKeys.fontFamily)
+    fontStyle = try dictionary.value(for: CodingKeys.fontStyle)
+    width = try dictionary.value(for: CodingKeys.width)
+    if
+      let shapes = dictionary[CodingKeys.shapeWrapper.rawValue] as? [String: Any],
+      let shapeDictionaries = shapes[ShapeKey.shapes.rawValue] as? [[String: Any]]
+    {
+      self.shapes = try [ShapeItem].fromDictionaries(shapeDictionaries)
+    } else {
+      shapes = [ShapeItem]()
+    }
+  }
+
+  // MARK: Internal
+
+  /// The character
+  let character: String
+
+  /// The font size of the character
+  let fontSize: Double
+
+  /// The font family of the character
+  let fontFamily: String
+
+  /// The Style of the character
+  let fontStyle: String
+
+  /// The Width of the character
+  let width: Double
+
+  /// The Shape Data of the Character
+  let shapes: [ShapeItem]
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+
+    try container.encode(character, forKey: .character)
+    try container.encode(fontSize, forKey: .fontSize)
+    try container.encode(fontFamily, forKey: .fontFamily)
+    try container.encode(fontStyle, forKey: .fontStyle)
+    try container.encode(width, forKey: .width)
+
+    var shapeContainer = container.nestedContainer(keyedBy: ShapeKey.self, forKey: .shapeWrapper)
+    try shapeContainer.encode(shapes, forKey: .shapes)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case character = "ch"
+    case fontSize = "size"
+    case fontFamily = "fFamily"
+    case fontStyle = "style"
+    case width = "w"
+    case shapeWrapper = "data"
+  }
+
+  private enum ShapeKey: String, CodingKey {
+    case shapes
+  }
+}