@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/Utility/Primitives/VectorsExtensions.swift

@@ -0,0 +1,368 @@
+//
+//  Vector.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/7/19.
+//
+
+import CoreGraphics
+import Foundation
+import QuartzCore
+
+// MARK: - LottieVector1D + Codable
+
+/// Single value container. Needed because lottie sometimes wraps a Double in an array.
+extension LottieVector1D: Codable {
+
+  // MARK: Lifecycle
+
+  public init(from decoder: Decoder) throws {
+    /// Try to decode an array of doubles
+    do {
+      var container = try decoder.unkeyedContainer()
+      value = try container.decode(Double.self)
+    } catch {
+      value = try decoder.singleValueContainer().decode(Double.self)
+    }
+  }
+
+  // MARK: Public
+
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    try container.encode(value)
+  }
+
+  // MARK: Internal
+
+  var cgFloatValue: CGFloat {
+    CGFloat(value)
+  }
+
+}
+
+// MARK: - LottieVector1D + AnyInitializable
+
+extension LottieVector1D: AnyInitializable {
+
+  init(value: Any) throws {
+    if
+      let array = value as? [Double],
+      let double = array.first
+    {
+      self.value = double
+    } else if let double = value as? Double {
+      self.value = double
+    } else {
+      throw InitializableError.invalidInput()
+    }
+  }
+
+}
+
+extension Double {
+  var vectorValue: LottieVector1D {
+    LottieVector1D(self)
+  }
+}
+
+// MARK: - LottieVector2D
+
+/// Needed for decoding json {x: y:} to a CGPoint
+public struct LottieVector2D: Codable, Hashable, Sendable {
+
+  // MARK: Lifecycle
+
+  init(x: Double, y: Double) {
+    self.x = x
+    self.y = y
+  }
+
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: LottieVector2D.CodingKeys.self)
+
+    do {
+      let xValue: [Double] = try container.decode([Double].self, forKey: .x)
+      x = xValue[0]
+    } catch {
+      x = try container.decode(Double.self, forKey: .x)
+    }
+
+    do {
+      let yValue: [Double] = try container.decode([Double].self, forKey: .y)
+      y = yValue[0]
+    } catch {
+      y = try container.decode(Double.self, forKey: .y)
+    }
+  }
+
+  // MARK: Public
+
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: LottieVector2D.CodingKeys.self)
+    try container.encode(x, forKey: .x)
+    try container.encode(y, forKey: .y)
+  }
+
+  // MARK: Internal
+
+  var x: Double
+  var y: Double
+
+  var pointValue: CGPoint {
+    CGPoint(x: x, y: y)
+  }
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case x
+    case y
+  }
+}
+
+// MARK: AnyInitializable
+
+extension LottieVector2D: AnyInitializable {
+
+  init(value: Any) throws {
+    guard let dictionary = value as? [String: Any] else {
+      throw InitializableError.invalidInput()
+    }
+
+    if
+      let array = dictionary[CodingKeys.x.rawValue] as? [Double],
+      let double = array.first
+    {
+      x = double
+    } else if let double = dictionary[CodingKeys.x.rawValue] as? Double {
+      x = double
+    } else {
+      throw InitializableError.invalidInput()
+    }
+    if
+      let array = dictionary[CodingKeys.y.rawValue] as? [Double],
+      let double = array.first
+    {
+      y = double
+    } else if let double = dictionary[CodingKeys.y.rawValue] as? Double {
+      y = double
+    } else {
+      throw InitializableError.invalidInput()
+    }
+  }
+}
+
+extension CGPoint {
+  var vector2dValue: LottieVector2D {
+    LottieVector2D(x: Double(x), y: Double(y))
+  }
+}
+
+// MARK: - LottieVector3D + Codable
+
+/// A three dimensional vector.
+/// These vectors are encoded and decoded from [Double]
+
+extension LottieVector3D: Codable {
+
+  // MARK: Lifecycle
+
+  init(x: CGFloat, y: CGFloat, z: CGFloat) {
+    self.x = Double(x)
+    self.y = Double(y)
+    self.z = Double(z)
+  }
+
+  public init(from decoder: Decoder) throws {
+    var container = try decoder.unkeyedContainer()
+
+    if !container.isAtEnd {
+      x = try container.decode(Double.self)
+    } else {
+      x = 0
+    }
+
+    if !container.isAtEnd {
+      y = try container.decode(Double.self)
+    } else {
+      y = 0
+    }
+
+    if !container.isAtEnd {
+      z = try container.decode(Double.self)
+    } else {
+      z = 0
+    }
+  }
+
+  // MARK: Public
+
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.unkeyedContainer()
+    try container.encode(x)
+    try container.encode(y)
+    try container.encode(z)
+  }
+
+}
+
+// MARK: - LottieVector3D + AnyInitializable
+
+extension LottieVector3D: AnyInitializable {
+
+  init(value: Any) throws {
+    guard var array = value as? [Double] else {
+      throw InitializableError.invalidInput()
+    }
+    x = array.count > 0 ? array.removeFirst() : 0
+    y = array.count > 0 ? array.removeFirst() : 0
+    z = array.count > 0 ? array.removeFirst() : 0
+  }
+
+}
+
+extension LottieVector3D {
+  public var pointValue: CGPoint {
+    CGPoint(x: x, y: y)
+  }
+
+  public var sizeValue: CGSize {
+    CGSize(width: x, height: y)
+  }
+}
+
+extension CGPoint {
+  var vector3dValue: LottieVector3D {
+    LottieVector3D(x: x, y: y, z: 0)
+  }
+}
+
+extension CGSize {
+  var vector3dValue: LottieVector3D {
+    LottieVector3D(x: width, y: height, z: 1)
+  }
+}
+
+extension CATransform3D {
+
+  enum Axis {
+    case x
+    case y
+    case z
+  }
+
+  static func makeSkew(skew: CGFloat, skewAxis: CGFloat) -> CATransform3D {
+    let mCos = cos(skewAxis.toRadians())
+    let mSin = sin(skewAxis.toRadians())
+    let aTan = tan(skew.toRadians())
+
+    let transform1 = CATransform3D(
+      m11: mCos,
+      m12: mSin,
+      m13: 0,
+      m14: 0,
+      m21: -mSin,
+      m22: mCos,
+      m23: 0,
+      m24: 0,
+      m31: 0,
+      m32: 0,
+      m33: 1,
+      m34: 0,
+      m41: 0,
+      m42: 0,
+      m43: 0,
+      m44: 1
+    )
+
+    let transform2 = CATransform3D(
+      m11: 1,
+      m12: 0,
+      m13: 0,
+      m14: 0,
+      m21: aTan,
+      m22: 1,
+      m23: 0,
+      m24: 0,
+      m31: 0,
+      m32: 0,
+      m33: 1,
+      m34: 0,
+      m41: 0,
+      m42: 0,
+      m43: 0,
+      m44: 1
+    )
+
+    let transform3 = CATransform3D(
+      m11: mCos,
+      m12: -mSin,
+      m13: 0,
+      m14: 0,
+      m21: mSin,
+      m22: mCos,
+      m23: 0,
+      m24: 0,
+      m31: 0,
+      m32: 0,
+      m33: 1,
+      m34: 0,
+      m41: 0,
+      m42: 0,
+      m43: 0,
+      m44: 1
+    )
+    return CATransform3DConcat(transform3, CATransform3DConcat(transform2, transform1))
+  }
+
+  static func makeTransform(
+    anchor: CGPoint,
+    position: CGPoint,
+    scale: CGSize,
+    rotationX: CGFloat,
+    rotationY: CGFloat,
+    rotationZ: CGFloat,
+    skew: CGFloat?,
+    skewAxis: CGFloat?
+  ) -> CATransform3D {
+    if let skew, let skewAxis {
+      return CATransform3DMakeTranslation(position.x, position.y, 0)
+        .rotated(rotationX, axis: .x)
+        .rotated(rotationY, axis: .y)
+        .rotated(rotationZ, axis: .z)
+        .skewed(skew: -skew, skewAxis: skewAxis)
+        .scaled(scale * 0.01)
+        .translated(anchor * -1)
+    }
+    return CATransform3DMakeTranslation(position.x, position.y, 0)
+      .rotated(rotationX, axis: .x)
+      .rotated(rotationY, axis: .y)
+      .rotated(rotationZ, axis: .z)
+      .scaled(scale * 0.01)
+      .translated(anchor * -1)
+  }
+
+  func rotated(_ degrees: CGFloat, axis: Axis) -> CATransform3D {
+    CATransform3DRotate(
+      self,
+      degrees.toRadians(),
+      axis == .x ? 1 : 0,
+      axis == .y ? 1 : 0,
+      axis == .z ? 1 : 0
+    )
+  }
+
+  func translated(_ translation: CGPoint) -> CATransform3D {
+    CATransform3DTranslate(self, translation.x, translation.y, 0)
+  }
+
+  func scaled(_ scale: CGSize) -> CATransform3D {
+    CATransform3DScale(self, scale.width, scale.height, 1)
+  }
+
+  func skewed(skew: CGFloat, skewAxis: CGFloat) -> CATransform3D {
+    CATransform3DConcat(CATransform3D.makeSkew(skew: skew, skewAxis: skewAxis), self)
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Public/Animation/LottieAnimation.swift

@@ -0,0 +1,179 @@
+//
+//  LottieAnimation.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/7/19.
+//
+
+import Foundation
+
+// MARK: - CoordinateSpace
+
+public enum CoordinateSpace: Int, Codable, Sendable {
+  case type2d
+  case type3d
+}
+
+// MARK: - LottieAnimation
+
+/// The `LottieAnimation` model is the top level model object in Lottie.
+///
+/// A `LottieAnimation` holds all of the animation data backing a Lottie Animation.
+/// Codable, see JSON schema [here](https://github.com/airbnb/lottie-web/tree/master/docs/json).
+public final class LottieAnimation: Codable, Sendable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: LottieAnimation.CodingKeys.self)
+    version = try container.decode(String.self, forKey: .version)
+    type = try container.decodeIfPresent(CoordinateSpace.self, forKey: .type) ?? .type2d
+    startFrame = try container.decode(AnimationFrameTime.self, forKey: .startFrame)
+    endFrame = try container.decode(AnimationFrameTime.self, forKey: .endFrame)
+    framerate = try container.decode(Double.self, forKey: .framerate)
+    width = try container.decode(Double.self, forKey: .width)
+    height = try container.decode(Double.self, forKey: .height)
+    layers = try container.decode([LayerModel].self, ofFamily: LayerType.self, forKey: .layers)
+    glyphs = try container.decodeIfPresent([Glyph].self, forKey: .glyphs)
+    fonts = try container.decodeIfPresent(FontList.self, forKey: .fonts)
+    assetLibrary = try container.decodeIfPresent(AssetLibrary.self, forKey: .assetLibrary)
+    markers = try container.decodeIfPresent([Marker].self, forKey: .markers)
+
+    if let markers {
+      var markerMap = [String: Marker]()
+      for marker in markers {
+        markerMap[marker.name] = marker
+      }
+      self.markerMap = markerMap
+    } else {
+      markerMap = nil
+    }
+  }
+
+  public init(dictionary: [String: Any]) throws {
+    version = try dictionary.value(for: CodingKeys.version)
+    if
+      let typeRawValue = dictionary[CodingKeys.type.rawValue] as? Int,
+      let type = CoordinateSpace(rawValue: typeRawValue)
+    {
+      self.type = type
+    } else {
+      type = .type2d
+    }
+    startFrame = try dictionary.value(for: CodingKeys.startFrame)
+    endFrame = try dictionary.value(for: CodingKeys.endFrame)
+    framerate = try dictionary.value(for: CodingKeys.framerate)
+    width = try dictionary.value(for: CodingKeys.width)
+    height = try dictionary.value(for: CodingKeys.height)
+    let layerDictionaries: [[String: Any]] = try dictionary.value(for: CodingKeys.layers)
+    layers = try [LayerModel].fromDictionaries(layerDictionaries)
+    if let glyphDictionaries = dictionary[CodingKeys.glyphs.rawValue] as? [[String: Any]] {
+      glyphs = try glyphDictionaries.map { try Glyph(dictionary: $0) }
+    } else {
+      glyphs = nil
+    }
+    if let fontsDictionary = dictionary[CodingKeys.fonts.rawValue] as? [String: Any] {
+      fonts = try FontList(dictionary: fontsDictionary)
+    } else {
+      fonts = nil
+    }
+    if let assetLibraryDictionaries = dictionary[CodingKeys.assetLibrary.rawValue] as? [[String: Any]] {
+      assetLibrary = try AssetLibrary(value: assetLibraryDictionaries)
+    } else {
+      assetLibrary = nil
+    }
+    if let markerDictionaries = dictionary[CodingKeys.markers.rawValue] as? [[String: Any]] {
+      let markers = try markerDictionaries.map { try Marker(dictionary: $0) }
+      var markerMap = [String: Marker]()
+      for marker in markers {
+        markerMap[marker.name] = marker
+      }
+      self.markers = markers
+      self.markerMap = markerMap
+    } else {
+      markers = nil
+      markerMap = nil
+    }
+  }
+
+  // MARK: Public
+
+  /// The start time of the composition in frameTime.
+  public let startFrame: AnimationFrameTime
+
+  /// The end time of the composition in frameTime.
+  public let endFrame: AnimationFrameTime
+
+  /// The frame rate of the composition.
+  public let framerate: Double
+
+  /// Return all marker names, in order, or an empty list if none are specified
+  public var markerNames: [String] {
+    guard let markers else { return [] }
+    return markers.map { $0.name }
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case version = "v"
+    case type = "ddd"
+    case startFrame = "ip"
+    case endFrame = "op"
+    case framerate = "fr"
+    case width = "w"
+    case height = "h"
+    case layers
+    case glyphs = "chars"
+    case fonts
+    case assetLibrary = "assets"
+    case markers
+  }
+
+  /// The version of the JSON Schema.
+  let version: String
+
+  /// The coordinate space of the composition.
+  let type: CoordinateSpace
+
+  /// The height of the composition in points.
+  let width: Double
+
+  /// The width of the composition in points.
+  let height: Double
+
+  /// The list of animation layers
+  let layers: [LayerModel]
+
+  /// The list of glyphs used for text rendering
+  let glyphs: [Glyph]?
+
+  /// The list of fonts used for text rendering
+  let fonts: FontList?
+
+  /// Asset Library
+  let assetLibrary: AssetLibrary?
+
+  /// Markers
+  let markers: [Marker]?
+  let markerMap: [String: Marker]?
+
+  /// The marker to use if "reduced motion" is enabled.
+  /// Supported marker names are case insensitive, and include:
+  ///  - reduced motion
+  ///  - reducedMotion
+  ///  - reduced_motion
+  ///  - reduced-motion
+  var reducedMotionMarker: Marker? {
+    let allowedReducedMotionMarkerNames = Set([
+      "reduced motion",
+      "reduced_motion",
+      "reduced-motion",
+      "reducedmotion",
+    ])
+
+    return markers?.first(where: { marker in
+      allowedReducedMotionMarkerNames.contains(marker.name.lowercased())
+    })
+  }
+}