lottie-ios 4.2.0 → 4.3.1

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
+}

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

@@ -0,0 +1,48 @@
+// Created by eric_horacek on 3/15/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+/// A generic result builder that enables a DSL for building arrays of Epoxy models.
+@resultBuilder
+enum EpoxyModelArrayBuilder<Model> {
+  typealias Expression = Model
+  typealias Component = [Model]
+
+  static func buildExpression(_ expression: Expression) -> Component {
+    [expression]
+  }
+
+  static func buildExpression(_ expression: Component) -> Component {
+    expression
+  }
+
+  static func buildExpression(_ expression: Expression?) -> Component {
+    if let expression = expression {
+      return [expression]
+    }
+    return []
+  }
+
+  static func buildBlock(_ children: Component...) -> Component {
+    children.flatMap { $0 }
+  }
+
+  static func buildBlock(_ component: Component) -> Component {
+    component
+  }
+
+  static func buildOptional(_ children: Component?) -> Component {
+    children ?? []
+  }
+
+  static func buildEither(first child: Component) -> Component {
+    child
+  }
+
+  static func buildEither(second child: Component) -> Component {
+    child
+  }
+
+  static func buildArray(_ components: [Component]) -> Component {
+    components.flatMap { $0 }
+  }
+}

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

@@ -0,0 +1,158 @@
+// Created by eric_horacek on 11/18/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - EpoxyModelProperty
+
+/// A property that can be stored in any concrete `EpoxyModeled` type.
+///
+/// Custom model properties can be declared in any module. It's recommended that properties are
+/// declared as `var`s in extensions to `EpoxyModeled` with a `*Property` suffix.
+///
+/// For example, to declare a `EpoxyModelProperty` that fulfills the `TitleProviding` protocol:
+///
+/// ````
+/// internal protocol TitleProviding {
+///   var title: String? { get }
+/// }
+///
+/// extension EpoxyModeled where Self: TitleProviding {
+///   internal var title: String? {
+///     get { self[titleProperty] }
+///     set { self[titleProperty] = newValue }
+///   }
+///
+///   internal func title(_ value: String?) -> Self {
+///     copy(updating: titleProperty, to: value)
+///   }
+///
+///   private var titleProperty: EpoxyModelProperty<String?> {
+///     .init(keyPath: \TitleProviding.title, defaultValue: nil, updateStrategy: .replace)
+///   }
+/// }
+/// ````
+struct EpoxyModelProperty<Value> {
+
+  // MARK: Lifecycle
+
+  /// Creates a property identified by a `KeyPath` to its provided `value` and with its default
+  /// value if not customized in content by consumers.
+  ///
+  /// The `updateStrategy` is used to update the value when updating from an old value to a new
+  /// value.
+  init<Model>(
+    keyPath: KeyPath<Model, Value>,
+    defaultValue: @escaping @autoclosure () -> Value,
+    updateStrategy: UpdateStrategy)
+  {
+    self.keyPath = keyPath
+    self.defaultValue = defaultValue
+    self.updateStrategy = updateStrategy
+  }
+
+  // MARK: Internal
+
+  /// The `KeyPath` that uniquely identifies this property.
+  let keyPath: AnyKeyPath
+
+  /// A closure that produces the default property value when called.
+  let defaultValue: () -> Value
+
+  /// A closure used to update an `EpoxyModelProperty` from an old value to a new value.
+  let updateStrategy: UpdateStrategy
+
+}
+
+// MARK: EpoxyModelProperty.UpdateStrategy
+
+extension EpoxyModelProperty {
+  /// A closure used to update an `EpoxyModelProperty` from an old value to a new value.
+  struct UpdateStrategy {
+
+    // MARK: Lifecycle
+
+    init(update: @escaping (Value, Value) -> Value) {
+      self.update = update
+    }
+
+    // MARK: Public
+
+    /// A closure used to update an `EpoxyModelProperty` from an old value to a new value.
+    var update: (_ old: Value, _ new: Value) -> Value
+  }
+}
+
+// MARK: Defaults
+
+extension EpoxyModelProperty.UpdateStrategy {
+  /// Replaces the old value with the new value when an update occurs.
+  static var replace: Self {
+    .init { _, new in new }
+  }
+
+  /// Chains the new closure value onto the old closure value, returning a new closure that first
+  /// calls the old closure and then subsequently calls the new closure.
+  static func chain() -> EpoxyModelProperty<(() -> Void)?>.UpdateStrategy {
+    .init { old, new in
+      guard let new = new else { return old }
+      guard let old = old else { return new }
+      return {
+        old()
+        new()
+      }
+    }
+  }
+
+  /// Chains the new closure value onto the old closure value, returning a new closure that first
+  /// calls the old closure and then subsequently calls the new closure.
+  static func chain<A>() -> EpoxyModelProperty<((A) -> Void)?>.UpdateStrategy {
+    .init { old, new in
+      guard let new = new else { return old }
+      guard let old = old else { return new }
+      return { a in
+        old(a)
+        new(a)
+      }
+    }
+  }
+
+  /// Chains the new closure value onto the old closure value, returning a new closure that first
+  /// calls the old closure and then subsequently calls the new closure.
+  static func chain<A, B>() -> EpoxyModelProperty<((A, B) -> Void)?>.UpdateStrategy {
+    .init { old, new in
+      guard let new = new else { return old }
+      guard let old = old else { return new }
+      return { a, b in
+        old(a, b)
+        new(a, b)
+      }
+    }
+  }
+
+  /// Chains the new closure value onto the old closure value, returning a new closure that first
+  /// calls the old closure and then subsequently calls the new closure.
+  static func chain<A, B, C>() -> EpoxyModelProperty<((A, B, C) -> Void)?>.UpdateStrategy {
+    .init { old, new in
+      guard let new = new else { return old }
+      guard let old = old else { return new }
+      return { a, b, c in
+        old(a, b, c)
+        new(a, b, c)
+      }
+    }
+  }
+
+  /// Chains the new closure value onto the old closure value, returning a new closure that first
+  /// calls the old closure and then subsequently calls the new closure.
+  static func chain<A, B, C, D>() -> EpoxyModelProperty<((A, B, C, D) -> Void)?>.UpdateStrategy {
+    .init { old, new in
+      guard let new = new else { return old }
+      guard let old = old else { return new }
+      return { a, b, c, d in
+        old(a, b, c, d)
+        new(a, b, c, d)
+      }
+    }
+  }
+
+  // Add more arities as needed
+}

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

@@ -0,0 +1,88 @@
+// Created by eric_horacek on 11/18/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - EpoxyModelStorage
+
+/// The underlying storage for an `EpoxyModeled` model that is capable of storing any
+/// `EpoxyModelProperty`.
+///
+/// Supports being extended with additional storage capabilities in other modules and conditionally
+/// based on the provider capabilities that the content containing this storage conforms to.
+struct EpoxyModelStorage {
+
+  // MARK: Lifecycle
+
+  init() { }
+
+  // MARK: Internal
+
+  /// Stores or retrieves the value of the specified property.
+  subscript<Property>(property: EpoxyModelProperty<Property>) -> Property {
+    get {
+      guard let propertyStorage = storage[property.keyPath] else {
+        return property.defaultValue()
+      }
+
+      // This cast will never fail as the storage is only settable via this subscript and the
+      // `KeyPath` key is unique for any provider and value type pair.
+      // swiftlint:disable:next force_cast
+      return propertyStorage.value as! Property
+    }
+    set {
+      // We first update the value without using the `updateStrategy` since the likely scenario
+      // is that there won't be a collision that requires the `updateStrategy`, and we'll be able to
+      // return without incurring the cost of another write.
+      let propertyStorage = PropertyStorage(value: newValue, property: property)
+
+      guard var replaced = storage.updateValue(propertyStorage, forKey: property.keyPath) else {
+        return
+      }
+
+      // This cast will never fail as the storage is only settable via this subscript and the
+      // `KeyPath` key is unique for any provider and value type pair.
+      // swiftlint:disable:next force_cast
+      replaced.value = property.updateStrategy.update(replaced.value as! Property, newValue)
+
+      storage[property.keyPath] = replaced
+    }
+  }
+
+  /// Merges the given storage into this storage.
+  ///
+  /// In the case of a collision, the `UpdateStrategy` of the property is used to determine the
+  /// resulting value in this storage.
+  mutating func merge(_ other: Self) {
+    for (key, otherValue) in other.storage {
+      // We first update the value without using the `updateStrategy` since the likely scenario
+      // is that there won't be a collision that requires the `updateStrategy`, and we'll be able to
+      // return without incurring the cost of another write.
+      guard var replaced = storage.updateValue(otherValue, forKey: key) else {
+        continue
+      }
+
+      replaced.value = replaced.property.update(old: replaced.value, new: otherValue.value)
+
+      storage[key] = replaced
+    }
+  }
+
+  // MARK: Private
+
+  /// The underlying storage for the properties, with a key of the `EpoxyModelProperty.keyPath` and
+  /// a value of the property's `PropertyStorage`.
+  ///
+  /// Does not include default values.
+  private var storage = [AnyKeyPath: PropertyStorage]()
+
+}
+
+// MARK: - PropertyStorage
+
+/// A value stored within an `EpoxyModelStorage`.
+private struct PropertyStorage {
+  /// The type-erased value of the `EpoxyModelProperty`.
+  var value: Any
+
+  /// The property's corresponding `EpoxyModelProperty`, erased to an `AnyEpoxyModelProperty`.
+  var property: AnyEpoxyModelProperty
+}

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

@@ -0,0 +1,54 @@
+// Created by eric_horacek on 11/18/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - EpoxyModeled
+
+/// A protocol that all concrete Epoxy declarative UI model types conform to.
+///
+/// This protocol should be conditionally extended to fulfill provider protocols and with chainable
+/// setters for those providers that concrete model types can receive by declaring conformance to
+/// provider protocols.
+protocol EpoxyModeled {
+  /// The underlying storage of this model that stores the current property values.
+  var storage: EpoxyModelStorage { get set }
+}
+
+// MARK: Extensions
+
+extension EpoxyModeled {
+  /// Stores or retrieves a value of the specified property in `storage`.
+  ///
+  /// If the value was set previously for the given `property`, the conflict is resolved using the
+  /// `EpoxyModelProperty.UpdateStrategy` of the `property`.
+  subscript<Property>(property: EpoxyModelProperty<Property>) -> Property {
+    get { storage[property] }
+    set { storage[property] = newValue }
+  }
+
+  /// Returns a copy of this model with the given property updated to the provided value.
+  ///
+  /// Typically called from within the context of a chainable setter to allow fluent setting of a
+  /// property, e.g.:
+  ///
+  /// ````
+  /// internal func title(_ value: String?) -> Self {
+  ///   copy(updating: titleProperty, to: value)
+  /// }
+  /// ````
+  ///
+  /// If a `value` was set previously for the given `property`, the conflict is resolved using the
+  /// `EpoxyModelProperty.UpdateStrategy` of the `property`.
+  func copy<Value>(updating property: EpoxyModelProperty<Value>, to value: Value) -> Self {
+    var copy = self
+    copy.storage[property] = value
+    return copy
+  }
+
+  /// Returns a copy of this model produced by merging the given `other` model's storage into this
+  /// model's storage.
+  func merging(_ other: EpoxyModeled) -> Self {
+    var copy = self
+    copy.storage.merge(other.storage)
+    return copy
+  }
+}