lottie-ios 4.2.0 → 4.3.0

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

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/Internal/AnyEpoxyModelProperty.swift

@@ -0,0 +1,29 @@
+// Created by eric_horacek on 12/1/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - AnyEpoxyModelProperty
+
+/// An erased `EpoxyModelProperty`, with the ability to call the `UpdateStrategy` even when the type
+/// has been erased.
+protocol AnyEpoxyModelProperty {
+  /// Returns the updated property from updating from given old to new property.
+  func update(old: Any, new: Any) -> Any
+}
+
+// MARK: - EpoxyModelProperty + AnyEpoxyModelProperty
+
+extension EpoxyModelProperty: AnyEpoxyModelProperty {
+  func update(old: Any, new: Any) -> Any {
+    guard let typedOld = old as? Value else {
+      EpoxyLogger.shared.assertionFailure(
+        "Expected old to be of type \(Value.self), instead found \(old). This is programmer error.")
+      return defaultValue()
+    }
+    guard let typedNew = new as? Value else {
+      EpoxyLogger.shared.assertionFailure(
+        "Expected new to be of type \(Value.self), instead found \(old). This is programmer error.")
+      return defaultValue()
+    }
+    return updateStrategy.update(typedOld, typedNew)
+  }
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/Internal/ClassReference.swift

@@ -0,0 +1,39 @@
+// Created by Cal Stephens on 10/15/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+// MARK: - ClassReference
+
+/// A `Hashable` value wrapper around an `AnyClass` value
+///  - Unlike `ObjectIdentifier(class)`, `ClassReference(class)`
+///    preserves the `AnyClass` value and is more human-readable.
+struct ClassReference {
+  init(_ class: AnyClass) {
+    self.class = `class`
+  }
+
+  let `class`: AnyClass
+}
+
+// MARK: Equatable
+
+extension ClassReference: Equatable {
+  static func ==(_ lhs: Self, _ rhs: Self) -> Bool {
+    ObjectIdentifier(lhs.class) == ObjectIdentifier(rhs.class)
+  }
+}
+
+// MARK: Hashable
+
+extension ClassReference: Hashable {
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(ObjectIdentifier(`class`))
+  }
+}
+
+// MARK: CustomStringConvertible
+
+extension ClassReference: CustomStringConvertible {
+  var description: String {
+    String(describing: `class`)
+  }
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/Providers/AnimatedProviding.swift

@@ -0,0 +1,10 @@
+// Created by eric_horacek on 12/16/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+/// The capability of providing a flag indicating whether an operation should be animated.
+///
+/// Typically conformed to by the `CallbackContext` of a `CallbackContextEpoxyModeled`.
+protocol AnimatedProviding {
+  /// Whether this operation should be animated.
+  var animated: Bool { get }
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/Providers/DataIDProviding.swift

@@ -0,0 +1,57 @@
+// Created by eric_horacek on 12/1/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - DataIDProviding
+
+/// The capability of providing a stable data identifier with an erased type.
+///
+/// While it has similar semantics, this type cannot inherit from `Identifiable` as this would give
+/// it an associated type, which would cause the `keyPath` used in its `EpoxyModelProperty` to not
+/// be stable across types if written as `\Self.dataID` since the `KeyPath` `Root` would be
+/// different for each type.
+///
+/// - SeeAlso: `Identifiable`.
+protocol DataIDProviding {
+  /// A stable identifier that uniquely identifies this instance, with its typed erased.
+  ///
+  /// Defaults to `DefaultDataID.noneProvided` if no data ID is provided.
+  var dataID: AnyHashable { get }
+}
+
+// MARK: - EpoxyModeled
+
+extension EpoxyModeled where Self: DataIDProviding {
+
+  // MARK: Internal
+
+  /// A stable identifier that uniquely identifies this model, with its typed erased.
+  var dataID: AnyHashable {
+    get { self[dataIDProperty] }
+    set { self[dataIDProperty] = newValue }
+  }
+
+  /// Returns a copy of this model with the ID replaced with the provided ID.
+  func dataID(_ value: AnyHashable) -> Self {
+    copy(updating: dataIDProperty, to: value)
+  }
+
+  // MARK: Private
+
+  private var dataIDProperty: EpoxyModelProperty<AnyHashable> {
+    EpoxyModelProperty(
+      keyPath: \DataIDProviding.dataID,
+      defaultValue: DefaultDataID.noneProvided,
+      updateStrategy: .replace)
+  }
+}
+
+// MARK: - DefaultDataID
+
+/// The default data ID when none is provided.
+enum DefaultDataID: Hashable, CustomDebugStringConvertible {
+  case noneProvided
+
+  var debugDescription: String {
+    "DefaultDataID.noneProvided"
+  }
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/Providers/DidDisplayProviding.swift

@@ -0,0 +1,41 @@
+// Created by eric_horacek on 1/6/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+// MARK: - DidDisplayProviding
+
+/// A sentinel protocol for enabling an `CallbackContextEpoxyModeled` to provide a `didDisplay`
+/// closure property.
+///
+/// - SeeAlso: `WillDisplayProviding`
+/// - SeeAlso: `DidEndDisplayingProviding`
+protocol DidDisplayProviding { }
+
+// MARK: - CallbackContextEpoxyModeled
+
+extension CallbackContextEpoxyModeled where Self: DidDisplayProviding {
+
+  // MARK: Internal
+
+  /// A closure that's called after a view has been added to the view hierarchy following any
+  /// appearance animations.
+  typealias DidDisplay = (_ context: CallbackContext) -> Void
+
+  /// A closure that's called after the view has been added to the view hierarchy following any
+  /// appearance animations.
+  var didDisplay: DidDisplay? {
+    get { self[didDisplayProperty] }
+    set { self[didDisplayProperty] = newValue }
+  }
+
+  /// Returns a copy of this model with the given did display closure called after the current did
+  /// display closure of this model, if there is one.
+  func didDisplay(_ value: DidDisplay?) -> Self {
+    copy(updating: didDisplayProperty, to: value)
+  }
+
+  // MARK: Private
+
+  private var didDisplayProperty: EpoxyModelProperty<DidDisplay?> {
+    .init(keyPath: \Self.didDisplay, defaultValue: nil, updateStrategy: .chain())
+  }
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/Providers/DidEndDisplayingProviding.swift

@@ -0,0 +1,41 @@
+// Created by eric_horacek on 12/15/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - DidEndDisplayingProviding
+
+/// A sentinel protocol for enabling an `CallbackContextEpoxyModeled` to provide a
+/// `didEndDisplaying` closure property.
+protocol DidEndDisplayingProviding { }
+
+// MARK: - CallbackContextEpoxyModeled
+
+extension CallbackContextEpoxyModeled where Self: DidEndDisplayingProviding {
+
+  // MARK: Internal
+
+  /// A closure that's called when a view is no longer displayed following any disappearance
+  /// animations and when it has been removed from the view hierarchy.
+  typealias DidEndDisplaying = (_ context: CallbackContext) -> Void
+
+  /// A closure that's called when the view is no longer displayed following any disappearance
+  /// animations and when it has been removed from the view hierarchy.
+  var didEndDisplaying: DidEndDisplaying? {
+    get { self[didEndDisplayingProperty] }
+    set { self[didEndDisplayingProperty] = newValue }
+  }
+
+  /// Returns a copy of this model with the given did end displaying closure called after the
+  /// current did end displaying closure of this model, if there is one.
+  func didEndDisplaying(_ value: DidEndDisplaying?) -> Self {
+    copy(updating: didEndDisplayingProperty, to: value)
+  }
+
+  // MARK: Private
+
+  private var didEndDisplayingProperty: EpoxyModelProperty<DidEndDisplaying?> {
+    .init(
+      keyPath: \Self.didEndDisplaying,
+      defaultValue: nil,
+      updateStrategy: .chain())
+  }
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/Providers/DidSelectProviding.swift

@@ -0,0 +1,36 @@
+// Created by eric_horacek on 12/2/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - DidSelectProviding
+
+/// A sentinel protocol for enabling an `CallbackContextEpoxyModeled` to provide a `didSelect`
+/// closure property.
+protocol DidSelectProviding { }
+
+// MARK: - CallbackContextEpoxyModeled
+
+extension CallbackContextEpoxyModeled where Self: DidSelectProviding {
+
+  // MARK: Internal
+
+  /// A closure that's called to handle this model's view being selected.
+  typealias DidSelect = (CallbackContext) -> Void
+
+  /// A closure that's called to handle this model's view being selected.
+  var didSelect: DidSelect? {
+    get { self[didSelectProperty] }
+    set { self[didSelectProperty] = newValue }
+  }
+
+  /// Returns a copy of this model with the given did select closure called after the current did
+  /// select closure of this model, if there is one.
+  func didSelect(_ value: DidSelect?) -> Self {
+    copy(updating: didSelectProperty, to: value)
+  }
+
+  // MARK: Private
+
+  private var didSelectProperty: EpoxyModelProperty<DidSelect?> {
+    .init(keyPath: \Self.didSelect, defaultValue: nil, updateStrategy: .chain())
+  }
+}

package/Sources/Private/EmbeddedLibraries/EpoxyCore/Model/Providers/ErasedContentProviding.swift

@@ -0,0 +1,49 @@
+// Created by eric_horacek on 12/2/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - ErasedContentProviding
+
+/// The capability of providing an type-erased `Equatable` content instance.
+protocol ErasedContentProviding {
+  /// The type-erased content instance of this model, else `nil` if there is no content.
+  ///
+  /// If there was an `AnyEquatable` type, we could store this property using it. Instead we need
+  /// need to store `isErasedContentEqual` to determine equality.
+  var erasedContent: Any? { get }
+
+  /// A closure that can be called to determine whether the given `model`'s `erasedContent` is equal
+  /// to this model's `erasedContent`, else `nil` if there is no content or the content is always
+  /// equal.
+  var isErasedContentEqual: ((Self) -> Bool)? { get }
+}
+
+// MARK: - EpoxyModeled
+
+extension EpoxyModeled where Self: ErasedContentProviding {
+
+  // MARK: Internal
+
+  /// The type-erased content instance of this model, else `nil` if there is no content.
+  var erasedContent: Any? {
+    get { self[contentProperty] }
+    set { self[contentProperty] = newValue }
+  }
+
+  /// A closure that can be called to determine whether the given `model`'s `erasedContent` is equal
+  /// to this model's `erasedContent`, else `nil` if there is no content or the content is always
+  /// equal.
+  var isErasedContentEqual: ((Self) -> Bool)? {
+    get { self[isContentEqualProperty] }
+    set { self[isContentEqualProperty] = newValue }
+  }
+
+  // MARK: Private
+
+  private var contentProperty: EpoxyModelProperty<Any?> {
+    .init(keyPath: \Self.erasedContent, defaultValue: nil, updateStrategy: .replace)
+  }
+
+  private var isContentEqualProperty: EpoxyModelProperty<((Self) -> Bool)?> {
+    .init(keyPath: \Self.isErasedContentEqual, defaultValue: nil, updateStrategy: .replace)
+  }
+}