lottie-ios 4.2.0 → 4.3.0

package/Sources/Private/CoreAnimation/ValueProviderStore.swift

@@ -36,6 +36,7 @@ final class ValueProviderStore {
       properties. Supported properties are: \(supportedProperties.joined(separator: ", ")).
       """)
 
+    valueProviders.removeAll(where: { $0.keypath == keypath })
     valueProviders.append((keypath: keypath, valueProvider: valueProvider))
   }
 
@@ -72,9 +73,11 @@ final class ValueProviderStore {
 
     // Convert the type-erased keyframe values using this `CustomizableProperty`'s conversion closure
     let typedKeyframes = typeErasedKeyframes.compactMap { typeErasedKeyframe -> Keyframe<Value>? in
-      guard let convertedValue = customizableProperty.conversion(typeErasedKeyframe.value) else {
+      guard let convertedValue = customizableProperty.conversion(typeErasedKeyframe.value, anyValueProvider) else {
         logger.assertionFailure("""
-          Could not convert value of type \(type(of: typeErasedKeyframe.value)) to expected type \(Value.self)
+          Could not convert value of type \(type(of: typeErasedKeyframe.value)) from \(anyValueProvider) to expected type \(
+          Value
+          .self)
           """)
         return nil
       }
@@ -93,10 +96,9 @@ final class ValueProviderStore {
   // MARK: Private
 
   private let logger: LottieLogger
-
   private var valueProviders = [(keypath: AnimationKeypath, valueProvider: AnyValueProvider)]()
 
-  /// Retrieves the most-recently-registered Value Provider that matches the given keypat
+  /// Retrieves the most-recently-registered Value Provider that matches the given keypath.
   private func valueProvider(for keypath: AnimationKeypath) -> AnyValueProvider? {
     // Find the last keypath matching the given keypath,
     // so we return the value provider that was registered most-recently

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Diffing/Collection+Diff.swift

@@ -0,0 +1,263 @@
+//  Created by Laura Skelton on 11/25/16.
+//  Copyright © 2016 Airbnb. All rights reserved.
+
+// MARK: - Collection
+
+extension Collection where Element: Diffable, Index == Int {
+
+  /// Diffs two collections (e.g. `Array`s) of `Diffable` items, returning an `IndexChangeset`
+  /// representing the minimal set of changes to get from the other collection to this collection.
+  ///
+  /// - Parameters:
+  ///     - from other: The collection of old data.
+  func makeChangeset(from other: Self) -> IndexChangeset {
+    // Arranging the elements contiguously prior to diffing improves performance by ~40%.
+    let new = ContiguousArray(self)
+    let old = ContiguousArray(other)
+
+    /// The entries in both this and the other collection, keyed by their `dataID`s.
+    var entries = [AnyHashable: EpoxyEntry](minimumCapacity: new.count)
+    var duplicates = [EpoxyEntry]()
+
+    var newResults = ContiguousArray<NewRecord>()
+    newResults.reserveCapacity(new.count)
+
+    for index in new.indices {
+      let id = new[index].diffIdentifier
+      let entry = entries[id, default: EpoxyEntry()]
+      if entry.trackNewIndex(index) {
+        duplicates.append(entry)
+      }
+      entries[id] = entry
+      newResults.append(NewRecord(entry: entry))
+    }
+
+    var oldResults = ContiguousArray<OldRecord>()
+    oldResults.reserveCapacity(old.count)
+
+    for index in old.indices {
+      let id = old[index].diffIdentifier
+      let entry = entries[id]
+      entry?.pushOldIndex(index)
+      oldResults.append(OldRecord(entry: entry))
+    }
+
+    for newIndex in new.indices {
+      let entry = newResults[newIndex].entry
+      if let oldIndex = entry.popOldIndex() {
+        let newItem = new[newIndex]
+        let oldItem = other[oldIndex]
+
+        if !oldItem.isDiffableItemEqual(to: newItem) {
+          entry.isUpdated = true
+        }
+
+        newResults[newIndex].correspondingOldIndex = oldIndex
+        oldResults[oldIndex].correspondingNewIndex = newIndex
+      }
+    }
+
+    var deletes = [Int]()
+    var deleteOffsets = [Int]()
+    deleteOffsets.reserveCapacity(old.count)
+    var runningDeleteOffset = 0
+
+    for index in old.indices {
+      deleteOffsets.append(runningDeleteOffset)
+
+      let record = oldResults[index]
+
+      if record.correspondingNewIndex == nil {
+        deletes.append(index)
+        runningDeleteOffset += 1
+      }
+    }
+
+    var inserts = [Int]()
+    var updates = [(Int, Int)]()
+    var moves = [(Int, Int)]()
+    var insertOffsets = [Int]()
+    insertOffsets.reserveCapacity(new.count)
+    var runningInsertOffset = 0
+
+    for index in new.indices {
+      insertOffsets.append(runningInsertOffset)
+
+      let record = newResults[index]
+
+      if let oldArrayIndex = record.correspondingOldIndex {
+        if record.entry.isUpdated {
+          updates.append((oldArrayIndex, index))
+        }
+
+        let insertOffset = insertOffsets[index]
+        let deleteOffset = deleteOffsets[oldArrayIndex]
+        if (oldArrayIndex - deleteOffset + insertOffset) != index {
+          moves.append((oldArrayIndex, index))
+        }
+
+      } else {
+        inserts.append(index)
+        runningInsertOffset += 1
+      }
+    }
+
+    EpoxyLogger.shared.assert(
+      old.count + inserts.count - deletes.count == new.count,
+      "Failed sanity check for old count with changes matching new count.")
+
+    return IndexChangeset(
+      inserts: inserts,
+      deletes: deletes,
+      updates: updates,
+      moves: moves,
+      newIndices: oldResults.map { $0.correspondingNewIndex },
+      duplicates: duplicates.map { $0.newIndices })
+  }
+
+  /// Diffs between two collections (eg. `Array`s) of `Diffable` items, and returns an `IndexPathChangeset`
+  /// representing the minimal set of changes to get from the other collection to this collection.
+  ///
+  /// - Parameters:
+  ///     - from other: The collection of old data.
+  ///     - fromSection: The section the other collection's data exists within. Defaults to `0`.
+  ///     - toSection: The section this collection's data exists within. Defaults to `0`.
+  func makeIndexPathChangeset(
+    from other: Self,
+    fromSection: Int = 0,
+    toSection: Int = 0)
+    -> IndexPathChangeset
+  {
+    let indexChangeset = makeChangeset(from: other)
+
+    return IndexPathChangeset(
+      inserts: indexChangeset.inserts.map { index in
+        [toSection, index]
+      },
+      deletes: indexChangeset.deletes.map { index in
+        [fromSection, index]
+      },
+      updates: indexChangeset.updates.map { fromIndex, toIndex in
+        ([fromSection, fromIndex], [toSection, toIndex])
+      },
+      moves: indexChangeset.moves.map { fromIndex, toIndex in
+        ([fromSection, fromIndex], [toSection, toIndex])
+      },
+      duplicates: indexChangeset.duplicates.map { duplicate in
+        duplicate.map { index in
+          [toSection, index]
+        }
+      })
+  }
+
+  /// Diffs between two collections (e.g. `Array`s) of `Diffable` items, returning an
+  /// `IndexSetChangeset` representing the minimal set of changes to get from the other collection
+  /// to this collection.
+  ///
+  /// - Parameters:
+  ///     - from other: The collection of old data.
+  func makeIndexSetChangeset(from other: Self) -> IndexSetChangeset {
+    let indexChangeset = makeChangeset(from: other)
+
+    return IndexSetChangeset(
+      inserts: .init(indexChangeset.inserts),
+      deletes: .init(indexChangeset.deletes),
+      updates: indexChangeset.updates,
+      moves: indexChangeset.moves,
+      newIndices: indexChangeset.newIndices,
+      duplicates: indexChangeset.duplicates.map { .init($0) })
+  }
+
+}
+
+extension Collection where Element: DiffableSection, Index == Int {
+  /// Diffs between two collections (e.g. `Array`s) of `DiffableSection` items, returning an
+  /// `SectionedChangeset` representing the minimal set of changes to get from the other collection
+  /// to this collection.
+  ///
+  /// - Parameters:
+  ///     - from other: The collection of old data.
+  func makeSectionedChangeset(from other: Self) -> SectionedChangeset {
+    let sectionChangeset = makeIndexSetChangeset(from: other)
+    var itemChangeset = IndexPathChangeset()
+
+    for fromSectionIndex in other.indices {
+      guard let toSectionIndex = sectionChangeset.newIndices[fromSectionIndex] else {
+        continue
+      }
+
+      let fromItems = other[fromSectionIndex].diffableItems
+      let toItems = self[toSectionIndex].diffableItems
+
+      let itemIndexChangeset = toItems.makeIndexPathChangeset(
+        from: fromItems,
+        fromSection: fromSectionIndex,
+        toSection: toSectionIndex)
+
+      itemChangeset += itemIndexChangeset
+    }
+
+    return SectionedChangeset(sectionChangeset: sectionChangeset, itemChangeset: itemChangeset)
+  }
+}
+
+// MARK: - EpoxyEntry
+
+/// A bookkeeping refrence type for the diffing algorithm.
+private final class EpoxyEntry {
+
+  // MARK: Internal
+
+  private(set) var oldIndices = [Int]()
+  private(set) var newIndices = [Int]()
+  var isUpdated = false
+
+  /// Tracks an index from the new indices, returning `true` if this entry has previously tracked
+  /// a new index as a means to identify duplicates and `false` otherwise.
+  func trackNewIndex(_ index: Int) -> Bool {
+    let previouslyEmpty = newIndices.isEmpty
+
+    newIndices.append(index)
+
+    // We've encountered a duplicate, return true so we can track it.
+    if !previouslyEmpty, newIndices.count == 2 {
+      return true
+    }
+
+    return false
+  }
+
+  func pushOldIndex(_ index: Int) {
+    oldIndices.append(index)
+  }
+
+  func popOldIndex() -> Int? {
+    guard currentOldIndex < oldIndices.endIndex else {
+      return nil
+    }
+    defer {
+      currentOldIndex += 1
+    }
+    return oldIndices[currentOldIndex]
+  }
+
+  // MARK: Private
+
+  private var currentOldIndex = 0
+}
+
+// MARK: - OldRecord
+
+/// A bookkeeping type for pairing up an old element with its new index.
+private struct OldRecord {
+  var entry: EpoxyEntry?
+  var correspondingNewIndex: Int? = nil
+}
+
+// MARK: - NewRecord
+
+/// A bookkeeping type for pairing up a new element with its old index.
+private struct NewRecord {
+  var entry: EpoxyEntry
+  var correspondingOldIndex: Int? = nil
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Diffing/Diffable.swift

@@ -0,0 +1,18 @@
+//  Created by Laura Skelton on 5/11/17.
+//  Copyright © 2017 Airbnb. All rights reserved.
+
+// MARK: - Diffable
+
+/// A protocol that allows us to check identity and equality between items for the purposes of
+/// diffing.
+protocol Diffable {
+
+  /// Checks for equality between items when diffing.
+  ///
+  /// - Parameters:
+  ///     - otherDiffableItem: The other item to check equality against while diffing.
+  func isDiffableItemEqual(to otherDiffableItem: Diffable) -> Bool
+
+  /// The identifier to use when checking identity while diffing.
+  var diffIdentifier: AnyHashable { get }
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Diffing/DiffableSection.swift

@@ -0,0 +1,16 @@
+// Created by eric_horacek on 12/9/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - DiffableSection
+
+/// A protocol that allows us to check identity and equality between sections of `Diffable` items
+/// for the purposes of diffing.
+protocol DiffableSection: Diffable {
+  /// The diffable items in this section.
+  associatedtype DiffableItems: Collection where
+    DiffableItems.Index == Int,
+    DiffableItems.Element: Diffable
+
+  /// The diffable items in this section.
+  var diffableItems: DiffableItems { get }
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Diffing/IndexChangeset.swift

@@ -0,0 +1,187 @@
+//  Created by Laura Skelton on 11/25/16.
+//  Copyright © 2016 Airbnb. All rights reserved.
+
+import Foundation
+
+// MARK: - IndexChangeset
+
+/// A set of inserts, deletes, updates, and moves that define the changes between two collections.
+struct IndexChangeset {
+
+  // MARK: Lifecycle
+
+  init(
+    inserts: [Int] = [],
+    deletes: [Int] = [],
+    updates: [(old: Int, new: Int)] = [],
+    moves: [(old: Int, new: Int)] = [],
+    newIndices: [Int?] = [],
+    duplicates: [[Int]] = [])
+  {
+    self.inserts = inserts
+    self.deletes = deletes
+    self.updates = updates
+    self.moves = moves
+    self.newIndices = newIndices
+    self.duplicates = duplicates
+  }
+
+  // MARK: Internal
+
+  /// The inserted indices needed to get from the old collection to the new collection.
+  var inserts: [Int]
+
+  /// The deleted indices needed to get from the old collection to the new collection.
+  var deletes: [Int]
+
+  /// The updated indices needed to get from the old collection to the new collection.
+  var updates: [(old: Int, new: Int)]
+
+  /// The moved indices needed to get from the old collection to the new collection.
+  var moves: [(old: Int, new: Int)]
+
+  /// A record for each old collection item to its index (if any) is in the new collection.
+  ///
+  /// The indexes of this `Array` represent the indexes old collection, with elements of the
+  /// corresponding index of the same item in the new collection it exists, else `nil`.
+  var newIndices: [Int?]
+
+  /// A record of each element in the new collection that has an identical `diffIdentifier` with
+  /// another element in the same collection.
+  ///
+  /// Each element in the outer `Array` corresponds to a duplicated identifier, with each inner
+  /// `[Int]` containing the indexes that share a duplicate identifier in the new collection.
+  ///
+  /// While the diffing algorithm makes a best effort to handle duplicates, they can lead to
+  /// unexpected behavior since identity of elements cannot be established and should be avoided if
+  /// possible.
+  var duplicates: [[Int]]
+
+  /// Whether there are any inserts, deletes, moves, or updates in this changeset.
+  var isEmpty: Bool {
+    inserts.isEmpty && deletes.isEmpty && updates.isEmpty && moves.isEmpty
+  }
+}
+
+// MARK: - IndexPathChangeset
+
+/// A set of inserts, deletes, updates, and moves that define the changes between two collections
+/// with indexes stored as `IndexPath`s.
+struct IndexPathChangeset {
+
+  // MARK: Lifecycle
+
+  init(
+    inserts: [IndexPath] = [],
+    deletes: [IndexPath] = [],
+    updates: [(old: IndexPath, new: IndexPath)] = [],
+    moves: [(old: IndexPath, new: IndexPath)] = [],
+    duplicates: [[IndexPath]] = [])
+  {
+    self.inserts = inserts
+    self.deletes = deletes
+    self.updates = updates
+    self.moves = moves
+    self.duplicates = duplicates
+  }
+
+  // MARK: Internal
+
+  /// The inserted `IndexPath`s needed to get from the old collection to the new collection.
+  var inserts: [IndexPath]
+
+  /// The deleted `IndexPath`s needed to get from the old collection to the new collection.
+  var deletes: [IndexPath]
+
+  /// The updated `IndexPath`s needed to get from the old collection to the new collection.
+  var updates: [(old: IndexPath, new: IndexPath)]
+
+  /// The moved `IndexPath`s needed to get from the old collection to the new collection.
+  var moves: [(old: IndexPath, new: IndexPath)]
+
+  /// A record for each element in the new collection that has an identical `diffIdentifier` with
+  /// another element in the same collection.
+  ///
+  /// Each element in the outer `Array` corresponds to a duplicated identifier, with each inner
+  /// `[IndexPath]` corresponding to the indexes that share a duplicate identifier in the new
+  /// collection.
+  ///
+  /// While the diffing algorithm makes a best effort to handle duplicates, they can lead to
+  /// unexpected behavior since identity of elements cannot be established and should be avoided if
+  /// possible.
+  var duplicates: [[IndexPath]]
+
+  /// Whether there are any inserts, deletes, moves, or updates in this changeset.
+  var isEmpty: Bool {
+    inserts.isEmpty && deletes.isEmpty && updates.isEmpty && moves.isEmpty
+  }
+
+  static func += (left: inout IndexPathChangeset, right: IndexPathChangeset) {
+    left.inserts += right.inserts
+    left.deletes += right.deletes
+    left.updates += right.updates
+    left.moves += right.moves
+    left.duplicates += right.duplicates
+  }
+}
+
+// MARK: - IndexSetChangeset
+
+/// A set of inserts, deletes, updates, and moves that define the changes between two collections
+/// with indexes stored as `IndexSet`.
+struct IndexSetChangeset {
+
+  // MARK: Lifecycle
+
+  init(
+    inserts: IndexSet = [],
+    deletes: IndexSet = [],
+    updates: [(old: Int, new: Int)] = [],
+    moves: [(old: Int, new: Int)] = [],
+    newIndices: [Int?] = [],
+    duplicates: [IndexSet] = [])
+  {
+    self.inserts = inserts
+    self.deletes = deletes
+    self.updates = updates
+    self.moves = moves
+    self.newIndices = newIndices
+    self.duplicates = duplicates
+  }
+
+  // MARK: Internal
+
+  /// An `IndexSet` of inserts needed to get from the old collection to the new collection.
+  var inserts: IndexSet
+
+  /// An `IndexSet` of deletes needed to get from the old collection to the new collection.
+  var deletes: IndexSet
+
+  /// The updated indices needed to get from the old collection to the new collection.
+  var updates: [(old: Int, new: Int)]
+
+  /// The moved indices needed to get from the old collection to the new collection.
+  var moves: [(old: Int, new: Int)]
+
+  /// A record for each old collection item of what its index (if any) is in the new collection.
+  ///
+  /// The indexes of this `Array` represent the indexes old collection, with elements of the
+  /// corresponding index of the same item in the new collection it exists, else `nil`.
+  var newIndices: [Int?]
+
+  /// A record for each element in the new collection that has an identical `diffIdentifier` with
+  /// another element in the same collection.
+  ///
+  /// Each element in the `Array` corresponds to a duplicated identifier, with each `IndexSet`
+  /// containing the indexes that share a duplicate identifier in the new collection.
+  ///
+  /// While the diffing algorithm makes a best effort to handle duplicates, they can lead to
+  /// unexpected behavior since identity of elements cannot be established and should be avoided if
+  /// possible.
+  var duplicates: [IndexSet]
+
+  /// Whether there are any inserts, deletes, moves, or updates in this changeset.
+  var isEmpty: Bool {
+    inserts.isEmpty && deletes.isEmpty && updates.isEmpty && moves.isEmpty
+  }
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Diffing/SectionedChangeset.swift

@@ -0,0 +1,32 @@
+//  Created by Laura Skelton on 5/11/17.
+//  Copyright © 2017 Airbnb. All rights reserved.
+
+/// A set of the minimum changes to get from one array of `DiffableSection`s to another, used for
+/// diffing.
+struct SectionedChangeset {
+
+  // MARK: Lifecycle
+
+  init(
+    sectionChangeset: IndexSetChangeset,
+    itemChangeset: IndexPathChangeset)
+  {
+    self.sectionChangeset = sectionChangeset
+    self.itemChangeset = itemChangeset
+  }
+
+  // MARK: Internal
+
+  /// A set of the minimum changes to get from one set of sections to another.
+  var sectionChangeset: IndexSetChangeset
+
+  /// A set of the minimum changes to get from one set of items to another, aggregated across all
+  /// sections.
+  var itemChangeset: IndexPathChangeset
+
+  /// Whether there are any inserts, deletes, moves, or updates in this changeset.
+  var isEmpty: Bool {
+    sectionChangeset.isEmpty && itemChangeset.isEmpty
+  }
+
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Logging/EpoxyLogger.swift

@@ -0,0 +1,99 @@
+// Created by eric_horacek on 12/9/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+/// A shared logger that allows consumers to intercept Epoxy assertions and warning messages to pipe
+/// into their own logging systems.
+final class EpoxyLogger {
+
+  // MARK: Lifecycle
+
+  init(
+    assert: @escaping Assert = { condition, message, file, line in
+      // If we default to `Swift.assert` directly with `assert: Assert = Swift.assert`,
+      // the call will unexpectedly not respect the -O flag and will crash in release
+      // https://github.com/apple/swift/issues/60249
+      Swift.assert(condition(), message(), file: file, line: line)
+    },
+    assertionFailure: @escaping AssertionFailure = { message, file, line in
+      // If we default to `Swift.assertionFailure` directly with
+      // `assertionFailure: AssertionFailure = Swift.assertionFailure`,
+      // the call will unexpectedly not respect the -O flag and will crash in release
+      // https://github.com/apple/swift/issues/60249
+      Swift.assertionFailure(message(), file: file, line: line)
+    },
+    warn: @escaping Warn = { message, _, _ in
+      #if DEBUG
+      // swiftlint:disable:next no_direct_standard_out_logs
+      print(message())
+      #endif
+    })
+  {
+    _assert = assert
+    _assertionFailure = assertionFailure
+    _warn = warn
+  }
+
+  // MARK: Internal
+
+  /// Logs that an assertion occurred.
+  typealias Assert = (
+    _ condition: @autoclosure () -> Bool,
+    _ message: @autoclosure () -> String,
+    _ fileID: StaticString,
+    _ line: UInt)
+    -> Void
+
+  /// Logs that an assertion failure occurred.
+  typealias AssertionFailure = (
+    _ message: @autoclosure () -> String,
+    _ fileID: StaticString,
+    _ line: UInt)
+    -> Void
+
+  /// Logs a warning message.
+  typealias Warn = (
+    _ message: @autoclosure () -> String,
+    _ fileID: StaticString,
+    _ line: UInt)
+    -> Void
+
+  /// The shared instance used to log Epoxy assertions and warnings.
+  ///
+  /// Set this to a new logger instance to intercept assertions and warnings logged by Epoxy.
+  static var shared = EpoxyLogger()
+
+  /// Logs that an assertion occurred.
+  func assert(
+    _ condition: @autoclosure () -> Bool,
+    _ message: @autoclosure () -> String = String(),
+    fileID: StaticString = #fileID,
+    line: UInt = #line)
+  {
+    _assert(condition(), message(), fileID, line)
+  }
+
+  /// Logs that an assertion failure occurred.
+  func assertionFailure(
+    _ message: @autoclosure () -> String = String(),
+    fileID: StaticString = #fileID,
+    line: UInt = #line)
+  {
+    _assertionFailure(message(), fileID, line)
+  }
+
+  /// Logs a warning message.
+  func warn(
+    _ message: @autoclosure () -> String = String(),
+    fileID: StaticString = #fileID,
+    line: UInt = #line)
+  {
+    _warn(message(), fileID, line)
+  }
+
+  // MARK: Private
+
+  private let _assert: Assert
+  private let _assertionFailure: AssertionFailure
+  private let _warn: Warn
+
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/CallbackContextEpoxyModeled.swift

@@ -0,0 +1,8 @@
+// Created by eric_horacek on 12/15/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+/// An Epoxy model with an associated context type that's passed into callback closures.
+protocol CallbackContextEpoxyModeled: EpoxyModeled {
+  /// A context type that's passed into callback closures.
+  associatedtype CallbackContext
+}