lottie-ios 3.2.2 → 3.4.1

package/{lottie-swift/src → Sources}/Private/Model/Assets/PrecompAsset.swift

@@ -8,20 +8,30 @@
 import Foundation
 
 final class PrecompAsset: Asset {
-  
-  /// Layers of the precomp
-  let layers: [LayerModel]
-  
-  enum CodingKeys : String, CodingKey {
-    case layers = "layers"
-  }
-  
+
+  // MARK: Lifecycle
+
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: PrecompAsset.CodingKeys.self)
-    self.layers = try container.decode([LayerModel].self, ofFamily: LayerType.self, forKey: .layers)
+    layers = try container.decode([LayerModel].self, ofFamily: LayerType.self, forKey: .layers)
     try super.init(from: decoder)
   }
-  
+
+  required init(dictionary: [String: Any]) throws {
+    let layerDictionaries: [[String: Any]] = try dictionary.value(for: CodingKeys.layers)
+    layers = try [LayerModel].fromDictionaries(layerDictionaries)
+    try super.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  enum CodingKeys: String, CodingKey {
+    case layers
+  }
+
+  /// Layers of the precomp
+  let layers: [LayerModel]
+
   override func encode(to encoder: Encoder) throws {
     try super.encode(to: encoder)
     var container = encoder.container(keyedBy: CodingKeys.self)

package/Sources/Private/Model/DictionaryInitializable.swift

@@ -0,0 +1,67 @@
+//
+//  DictionaryInitializable.swift
+//  Lottie
+//
+//  Created by Marcelo Fabri on 5/5/22.
+//
+
+import Foundation
+
+// MARK: - InitializableError
+
+enum InitializableError: Error {
+  case invalidInput
+}
+
+// MARK: - DictionaryInitializable
+
+protocol DictionaryInitializable {
+
+  init(dictionary: [String: Any]) throws
+
+}
+
+// MARK: - AnyInitializable
+
+protocol AnyInitializable {
+
+  init(value: Any) throws
+
+}
+
+extension Dictionary {
+
+  @_disfavoredOverload
+  func value<T, KeyType: RawRepresentable>(for key: KeyType) throws -> T where KeyType.RawValue == Key {
+    guard let value = self[key.rawValue] as? T else {
+      throw InitializableError.invalidInput
+    }
+    return value
+  }
+
+  func value<T: AnyInitializable, KeyType: RawRepresentable>(for key: KeyType) throws -> T where KeyType.RawValue == Key {
+    if let value = self[key.rawValue] as? T {
+      return value
+    }
+
+    if let value = self[key.rawValue] {
+      return try T(value: value)
+    }
+
+    throw InitializableError.invalidInput
+  }
+
+}
+
+// MARK: - Array + AnyInitializable
+
+extension Array: AnyInitializable where Element == Double {
+
+  init(value: Any) throws {
+    guard let array = value as? [Double] else {
+      throw InitializableError.invalidInput
+    }
+    self = array
+  }
+
+}

package/Sources/Private/Model/Extensions/Bundle.swift

@@ -0,0 +1,34 @@
+import Foundation
+#if os(iOS) || os(tvOS) || os(watchOS) || targetEnvironment(macCatalyst)
+import UIKit
+#endif
+
+extension Bundle {
+  func getAnimationData(_ name: String, subdirectory: String? = nil) throws -> Data? {
+    // Check for files in the bundle at the given path
+    let name = name.removingJSONSuffix()
+    if let url = url(forResource: name, withExtension: "json", subdirectory: subdirectory) {
+      return try Data(contentsOf: url)
+    }
+
+    // Check for data assets (not available on macOS)
+    #if os(iOS) || os(tvOS) || os(watchOS) || targetEnvironment(macCatalyst)
+    let assetKey = subdirectory != nil ? "\(subdirectory ?? "")/\(name)" : name
+    return NSDataAsset(name: assetKey, bundle: self)?.data
+    #else
+    return nil
+    #endif
+  }
+}
+
+extension String {
+  fileprivate func removingJSONSuffix() -> String {
+    // Allow filenames to be passed with a ".json" extension (but not other extensions)
+    // to keep the behavior from Lottie 2.x - instead of failing to load the animation
+    guard hasSuffix(".json") else {
+      return self
+    }
+
+    return (self as NSString).deletingPathExtension
+  }
+}

package/{lottie-swift/src → Sources}/Private/Model/Extensions/KeyedDecodingContainerExtensions.swift

@@ -2,30 +2,34 @@
 
 import Foundation
 
+// MARK: - ClassFamily
+
 /// To support a new class family, create an enum that conforms to this protocol and contains the different types.
 protocol ClassFamily: Decodable {
   /// The discriminator key.
   static var discriminator: Discriminator { get }
-  
+
   /// Returns the class type of the object corresponding to the value.
   func getType() -> AnyObject.Type
 }
 
+// MARK: - Discriminator
+
 /// Discriminator key enum used to retrieve discriminator fields in JSON payloads.
 enum Discriminator: String, CodingKey {
   case type = "ty"
 }
 
 extension KeyedDecodingContainer {
-  
+
   /// Decode a heterogeneous list of objects for a given family.
   /// - Parameters:
   ///     - heterogeneousType: The decodable type of the list.
   ///     - family: The ClassFamily enum for the type family.
   ///     - key: The CodingKey to look up the list in the current container.
   /// - Returns: The resulting list of heterogeneousType elements.
-  func decode<T : Decodable, U : ClassFamily>(_ heterogeneousType: [T].Type, ofFamily family: U.Type, forKey key: K) throws -> [T] {
-    var container = try self.nestedUnkeyedContainer(forKey: key)
+  func decode<T: Decodable, U: ClassFamily>(_: [T].Type, ofFamily family: U.Type, forKey key: K) throws -> [T] {
+    var container = try nestedUnkeyedContainer(forKey: key)
     var list = [T]()
     var tmpContainer = container
     while !container.isAtEnd {

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

@@ -0,0 +1,113 @@
+//
+//  Keyframe.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/7/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// 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: Vector2D?,
+    outTangent: Vector2D?,
+    spatialInTangent: Vector3D?,
+    spatialOutTangent: Vector3D?)
+  {
+    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: Vector2D?
+  /// The out tangent for the time interpolation curve.
+  let outTangent: Vector2D?
+
+  /// The spacial in tangent of the vector.
+  let spatialInTangent: Vector3D?
+  /// The spacial out tangent of the vector.
+  let spatialOutTangent: Vector3D?
+
+  var isHold: Bool {
+    if let hold = 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: Vector2D? = try? dictionary.value(for: CodingKeys.inTangent)
+    let outTangent: Vector2D? = try? dictionary.value(for: CodingKeys.outTangent)
+    let spatialInTangent: Vector3D? = try? dictionary.value(for: CodingKeys.spatialInTangent)
+    let spatialOutTangent: Vector3D? = 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/Sources/Private/Model/Keyframes/KeyframeGroup.swift

@@ -0,0 +1,197 @@
+//
+//  KeyframeGroup.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/14/19.
+//
+
+import Foundation
+
+// 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>>) {
+    self.keyframes = keyframes
+  }
+
+  init(_ value: T) {
+    keyframes = [Keyframe(value)]
+  }
+
+  // MARK: Internal
+
+  enum KeyframeWrapperKey: String, CodingKey {
+    case keyframeData = "k"
+  }
+
+  let keyframes: ContiguousArray<Keyframe<T>>
+
+}
+
+// MARK: Decodable
+
+extension KeyframeGroup: Decodable where T: Decodable {
+  convenience init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: KeyframeWrapperKey.self)
+
+    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)])
+    } 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)
+    }
+  }
+}
+
+// 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>>()
+    if
+      let rawValue = dictionary[KeyframeWrapperKey.keyframeData.rawValue],
+      let value = try? T(value: rawValue)
+    {
+      keyframes = [Keyframe<T>(value)]
+    } else {
+      var frameDictionaries: [[String: Any]]
+      if let singleFrameDictionary = dictionary[KeyframeWrapperKey.keyframeData.rawValue] as? [String: Any] {
+        frameDictionaries = [singleFrameDictionary]
+      } else {
+        frameDictionaries = 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)
+  }
+}
+
+// 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)
+  }
+}
+
+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)
+  }
+}

package/{lottie-swift/src → Sources}/Private/Model/Layers/ImageLayerModel.swift

@@ -9,24 +9,34 @@ import Foundation
 
 /// A layer that holds an image.
 final class ImageLayerModel: LayerModel {
-  
-  /// The reference ID of the image.
-  let referenceID: String
-  
-  private enum CodingKeys : String, CodingKey {
-    case referenceID = "refId"
-  }
-  
+
+  // MARK: Lifecycle
+
   required init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: ImageLayerModel.CodingKeys.self)
-    self.referenceID = try container.decode(String.self, forKey: .referenceID)
+    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"
+  }
 }