lottie-ios 4.2.0 → 4.3.0

package/Sources/Private/Model/Keyframes/KeyframeGroup.swift

@@ -14,7 +14,6 @@ import Foundation
 /// 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
@@ -86,8 +85,8 @@ extension KeyframeGroup: Decodable where T: Decodable {
 
         guard
           let value: T = keyframeData.startValue ?? previousKeyframeData?.endValue,
-          let time = keyframeData.time else
-        {
+          let time = keyframeData.time
+        else {
           /// Missing keyframe data. JSON must be corrupt.
           throw DecodingError.dataCorruptedError(
             forKey: KeyframeWrapperKey.keyframeData,
@@ -165,8 +164,8 @@ extension KeyframeGroup: DictionaryInitializable where T: AnyInitializable {
         let data = try KeyframeData<T>(dictionary: frameDictionary)
         guard
           let value: T = data.startValue ?? previousKeyframeData?.endValue,
-          let time = data.time else
-        {
+          let time = data.time
+        else {
           throw InitializableError.invalidInput
         }
         keyframes.append(Keyframe<T>(
@@ -203,6 +202,10 @@ extension KeyframeGroup: Hashable where T: Hashable {
   }
 }
 
+// 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> {

package/Sources/Private/Model/LayerEffects/DropShadowEffect.swift

@@ -0,0 +1,45 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+import Foundation
+
+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")
+  }
+
+}

package/Sources/Private/Model/LayerEffects/EffectValues/ColorEffectValue.swift

@@ -0,0 +1,38 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+import Foundation
+
+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"
+  }
+}

package/Sources/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.
+
+import Foundation
+
+// 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:
+      return Vector1DEffectValue.self
+    case .angle:
+      return Vector1DEffectValue.self
+    case .color:
+      return ColorEffectValue.self
+    case .unknown:
+      // Unsupported
+      return LayerEffect.self
+    }
+  }
+}
+
+// MARK: - EffectValue
+
+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 = EffectValueType(rawValue: try dictionary.value(for: CodingKeys.type)) ?? .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 Array where Element == 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 + Sendable
+
+/// Since `EffectValue` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `EffectValue` subclasses are immutable `Sendable` values.
+extension EffectValue: @unchecked Sendable { }

package/Sources/Private/Model/LayerEffects/EffectValues/Vector1DEffectValue.swift

@@ -0,0 +1,38 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+import Foundation
+
+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"
+  }
+}

package/Sources/Private/Model/LayerEffects/LayerEffect.swift

@@ -0,0 +1,103 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+import Foundation
+
+// 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:
+      return DropShadowEffect.self
+    case .unknown:
+      // Unsupported
+      return LayerEffect.self
+    }
+  }
+}
+
+// MARK: - LayerEffect
+
+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 Array where Element == 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 + Sendable
+
+/// Since `LayerEffect` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `LayerEffect` subclasses are immutable `Sendable` values.
+extension LayerEffect: @unchecked Sendable { }

package/Sources/Private/Model/LayerStyles/DropShadowStyle.swift

@@ -0,0 +1,72 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+import Foundation
+
+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"
+  }
+}

package/Sources/Private/Model/LayerStyles/LayerStyle.swift

@@ -0,0 +1,85 @@
+// Created by Cal Stephens on 8/14/23.
+// Copyright © 2023 Airbnb Inc. All rights reserved.
+
+import Foundation
+
+// 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:
+      return DropShadowStyle.self
+    case .unknown:
+      // Unsupported
+      return LayerStyle.self
+    }
+  }
+}
+
+// MARK: - LayerStyle
+
+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 Array where Element == 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 + Sendable
+
+/// Since `LayerStyle` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `LayerStyle` subclasses are immutable `Sendable` values.
+extension LayerStyle: @unchecked Sendable { }

package/Sources/Private/Model/Layers/LayerModel.swift

@@ -99,6 +99,8 @@ class LayerModel: Codable, DictionaryInitializable {
     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 {
@@ -138,6 +140,16 @@ class LayerModel: Codable, DictionaryInitializable {
       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
@@ -180,8 +192,15 @@ class LayerModel: Codable, DictionaryInitializable {
   /// 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 {
@@ -199,6 +218,8 @@ class LayerModel: Codable, DictionaryInitializable {
     case timeStretch = "sr"
     case matte = "tt"
     case hidden = "hd"
+    case styles = "sy"
+    case effects = "ef"
   }
 }
 
@@ -226,3 +247,9 @@ extension Array where Element == LayerModel {
     }
   }
 }
+
+// MARK: - LayerModel + Sendable
+
+/// Since `LayerModel` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `LayerModel` subclasses are immutable `Sendable` values.
+extension LayerModel: @unchecked Sendable { }

package/Sources/Private/Model/Objects/Marker.swift

@@ -8,7 +8,7 @@
 import Foundation
 
 /// A time marker
-final class Marker: Codable, DictionaryInitializable {
+final class Marker: Codable, Sendable, DictionaryInitializable {
 
   // MARK: Lifecycle
 

package/Sources/Private/Model/Objects/Transform.swift

@@ -154,8 +154,7 @@ final class Transform: Codable, DictionaryInitializable {
       let rotation = try? KeyframeGroup<LottieVector1D>(dictionary: rotationDictionary)
     {
       rotationZ = rotation
-    }
-    else {
+    } else {
       rotationZ = KeyframeGroup(LottieVector1D(0))
     }
     rotation = nil

package/Sources/Private/Model/ShapeItems/GradientFill.swift

@@ -9,7 +9,7 @@ import Foundation
 
 // MARK: - GradientType
 
-enum GradientType: Int, Codable {
+enum GradientType: Int, Codable, Sendable {
   case none
   case linear
   case radial

package/Sources/Private/Model/ShapeItems/GradientStroke.swift

@@ -9,7 +9,7 @@ import Foundation
 
 // MARK: - LineCap
 
-enum LineCap: Int, Codable {
+enum LineCap: Int, Codable, Sendable {
   case none
   case butt
   case round
@@ -18,7 +18,7 @@ enum LineCap: Int, Codable {
 
 // MARK: - LineJoin
 
-enum LineJoin: Int, Codable {
+enum LineJoin: Int, Codable, Sendable {
   case none
   case miter
   case round

package/Sources/Private/Model/ShapeItems/Merge.swift

@@ -9,7 +9,7 @@ import Foundation
 
 // MARK: - MergeMode
 
-enum MergeMode: Int, Codable {
+enum MergeMode: Int, Codable, Sendable {
   case none
   case merge
   case add