lottie-ios 4.2.0 → 4.3.1

package/Sources/Private/CoreAnimation/Layers/AnimationLayer.swift

@@ -38,11 +38,14 @@ struct LayerAnimationContext {
   /// The logger that should be used for assertions and warnings
   let logger: LottieLogger
 
+  /// Mutable state related to log events, stored on the `CoreAnimationLayer`.
+  let loggingState: LoggingState
+
   /// The AnimationKeypath represented by the current layer
   var currentKeypath: AnimationKeypath
 
-  /// The `AnimationTextProvider`
-  var textProvider: AnimationTextProvider
+  /// The `AnimationKeypathTextProvider`
+  var textProvider: AnimationKeypathTextProvider
 
   /// Records the given animation keypath so it can be logged or collected into a list
   ///  - Used for `CoreAnimationLayer.logHierarchyKeypaths()` and `allHierarchyKeypaths()`
@@ -84,3 +87,19 @@ struct LayerAnimationContext {
     return copy
   }
 }
+
+// MARK: - LoggingState
+
+/// Mutable state related to log events, stored on the `CoreAnimationLayer`.
+final class LoggingState {
+
+  // MARK: Lifecycle
+
+  init() { }
+
+  // MARK: Internal
+
+  /// Whether or not the warning about unsupported After Effects expressions
+  /// has been logged yet for this layer.
+  var hasLoggedAfterEffectsExpressionsWarning = false
+}

package/Sources/Private/CoreAnimation/Layers/BaseCompositionLayer.swift

@@ -67,6 +67,15 @@ class BaseCompositionLayer: BaseAnimationLayer {
         inFrame: CGFloat(baseLayerModel.inFrame),
         outFrame: CGFloat(baseLayerModel.outFrame),
         context: context)
+
+      // There are two different drop shadow schemas, either using `DropShadowEffect` or `DropShadowStyle`.
+      // If both happen to be present, prefer the `DropShadowEffect` (which is the drop shadow schema
+      // supported on other platforms).
+      let dropShadowEffect = baseLayerModel.effects.first(where: { $0 is DropShadowEffect }) as? DropShadowModel
+      let dropShadowStyle = baseLayerModel.styles.first(where: { $0 is DropShadowStyle }) as? DropShadowModel
+      if let dropShadowModel = dropShadowEffect ?? dropShadowStyle {
+        try contentsLayer.addDropShadowAnimations(for: dropShadowModel, context: context)
+      }
     }
   }
 

package/Sources/Private/CoreAnimation/Layers/ImageLayer.swift

@@ -48,6 +48,7 @@ final class ImageLayer: BaseCompositionLayer {
 
     self.imageAsset = imageAsset
     contentsLayer.contents = image
+    contentsLayer.contentsGravity = context.imageProvider.contentsGravity(for: imageAsset)
     setNeedsLayout()
   }
 

package/Sources/Private/CoreAnimation/Layers/LayerModel+makeAnimationLayer.swift

@@ -9,7 +9,7 @@ import QuartzCore
 struct LayerContext {
   let animation: LottieAnimation
   let imageProvider: AnimationImageProvider
-  let textProvider: AnimationTextProvider
+  let textProvider: AnimationKeypathTextProvider
   let fontProvider: AnimationFontProvider
   let compatibilityTracker: CompatibilityTracker
   var layerName: String

package/Sources/Private/CoreAnimation/Layers/RepeaterLayer.swift

@@ -93,4 +93,6 @@ extension RepeaterTransform: TransformModel {
   var _position: KeyframeGroup<LottieVector3D>? { position }
   var _positionX: KeyframeGroup<LottieVector1D>? { nil }
   var _positionY: KeyframeGroup<LottieVector1D>? { nil }
+  var _skew: KeyframeGroup<LottieVector1D>? { nil }
+  var _skewAxis: KeyframeGroup<LottieVector1D>? { nil }
 }

package/Sources/Private/CoreAnimation/Layers/ShapeLayer.swift

@@ -41,7 +41,8 @@ final class ShapeLayer: BaseCompositionLayer {
     if let repeater = shapeLayer.items.first(where: { $0 is Repeater }) as? Repeater {
       try setUpRepeater(repeater, context: context)
     } else {
-      try setupGroups(from: shapeLayer.items, parentGroup: nil, parentGroupPath: [], context: context)
+      let shapeItems = shapeLayer.items.map { ShapeItemLayer.Item(item: $0, groupPath: []) }
+      try setupGroups(from: shapeItems, parentGroup: nil, parentGroupPath: [], context: context)
     }
   }
 
@@ -50,7 +51,8 @@ final class ShapeLayer: BaseCompositionLayer {
     let copyCount = Int(try repeater.copies.exactlyOneKeyframe(context: context, description: "repeater copies").value)
 
     for index in 0..<copyCount {
-      for groupLayer in try makeGroupLayers(from: items, parentGroup: nil, parentGroupPath: [], context: context) {
+      let shapeItems = items.map { ShapeItemLayer.Item(item: $0, groupPath: []) }
+      for groupLayer in try makeGroupLayers(from: shapeItems, parentGroup: nil, parentGroupPath: [], context: context) {
         let repeatedLayer = RepeaterLayer(repeater: repeater, childLayer: groupLayer, index: index)
         addSublayer(repeatedLayer)
       }
@@ -127,7 +129,7 @@ final class GroupLayer: BaseAnimationLayer {
   private func setupLayerHierarchy(context: LayerContext) throws {
     // Groups can contain other groups, so we may have to continue
     // recursively creating more `GroupLayer`s
-    try setupGroups(from: group.items, parentGroup: group, parentGroupPath: groupPath, context: context)
+    try setupGroups(from: items, parentGroup: group, parentGroupPath: groupPath, context: context)
 
     // Create `ShapeItemLayer`s for each subgroup of shapes that should be rendered as a single unit
     //  - These groups are listed from front-to-back, so we have to add the sublayers in reverse order
@@ -183,7 +185,7 @@ extension CALayer {
   ///  - Each `Group` item becomes its own `GroupLayer` sublayer.
   ///  - Other `ShapeItem` are applied to all sublayers
   fileprivate func setupGroups(
-    from items: [ShapeItem],
+    from items: [ShapeItemLayer.Item],
     parentGroup: Group?,
     parentGroupPath: [String],
     context: LayerContext)
@@ -204,29 +206,27 @@ extension CALayer {
   ///  - Each `Group` item becomes its own `GroupLayer` sublayer.
   ///  - Other `ShapeItem` are applied to all sublayers
   fileprivate func makeGroupLayers(
-    from items: [ShapeItem],
+    from items: [ShapeItemLayer.Item],
     parentGroup: Group?,
     parentGroupPath: [String],
     context: LayerContext)
     throws -> [GroupLayer]
   {
-    var (groupItems, otherItems) = items
-      .filter { !$0.hidden }
-      .grouped(by: { $0 is Group })
+    var groupItems = items.compactMap { $0.item as? Group }.filter { !$0.hidden }
+    var otherItems = items.filter { !($0.item is Group) && !$0.item.hidden }
 
     // Handle the top-level `shapeLayer.items` array. This is typically just a single `Group`,
     // but in practice can be any combination of items. The implementation expects all path-drawing
     // shape items to be managed by a `GroupLayer`, so if there's a top-level path item we
     // have to create a placeholder group.
-    if parentGroup == nil, otherItems.contains(where: { $0.drawsCGPath }) {
-      groupItems = [Group(items: items, name: "")]
+    if parentGroup == nil, otherItems.contains(where: { $0.item.drawsCGPath }) {
+      groupItems = [Group(items: items.map { $0.item }, name: "")]
       otherItems = []
     }
 
     // Any child items that wouldn't be included in a valid shape render group
     // need to be applied to child groups (otherwise they'd be silently ignored).
     let inheritedItemsForChildGroups = otherItems
-      .map { ShapeItemLayer.Item(item: $0, groupPath: parentGroupPath) }
       .shapeRenderGroups(groupHasChildGroupsToInheritUnusedItems: !groupItems.isEmpty)
       .unusedItems
 
@@ -235,8 +235,6 @@ extension CALayer {
     let groupsInZAxisOrder = groupItems.reversed()
 
     return try groupsInZAxisOrder.compactMap { group in
-      guard let group = group as? Group else { return nil }
-
       var pathForChildren = parentGroupPath
       if !group.name.isEmpty {
         pathForChildren.append(group.name)

package/Sources/Private/CoreAnimation/Layers/SolidLayer.swift

@@ -30,16 +30,31 @@ final class SolidLayer: BaseCompositionLayer {
     super.init(layer: typedLayer)
   }
 
+  // MARK: Internal
+
+  override func setupAnimations(context: LayerAnimationContext) throws {
+    try super.setupAnimations(context: context)
+
+    // Even though the Lottie json schema provides a fixed `solidLayer.colorHex` value,
+    // we still need to create a set of keyframes and go through the standard `CAAnimation`
+    // codepath so that this value can be customized using the custom `ValueProvider`s API.
+    try shapeLayer.addAnimation(
+      for: .fillColor,
+      keyframes: KeyframeGroup(solidLayer.colorHex.cgColor),
+      value: { $0 },
+      context: context)
+  }
+
   // MARK: Private
 
   private let solidLayer: SolidLayerModel
 
+  /// Render the fill color in a child `CAShapeLayer`
+  ///  - Using a `CAShapeLayer` specifically, instead of a `CALayer` with a `backgroundColor`,
+  ///    allows the size of the fill shape to be different from `contentsLayer.size`.
+  private let shapeLayer = CAShapeLayer()
+
   private func setupContentLayer() {
-    // Render the fill color in a child `CAShapeLayer`
-    //  - Using a `CAShapeLayer` specifically, instead of a `CALayer` with a `backgroundColor`,
-    //    allows the size of the fill shape to be different from `contentsLayer.size`.
-    let shapeLayer = CAShapeLayer()
-    shapeLayer.fillColor = solidLayer.colorHex.cgColor
     shapeLayer.path = CGPath(rect: .init(x: 0, y: 0, width: solidLayer.width, height: solidLayer.height), transform: nil)
     addSublayer(shapeLayer)
   }

package/Sources/Private/CoreAnimation/Layers/TextLayer.swift

@@ -44,9 +44,19 @@ final class TextLayer: BaseCompositionLayer {
       context: textAnimationContext,
       description: "text layer text")
 
-    renderLayer.text = context.textProvider.textFor(
-      keypathName: textAnimationContext.currentKeypath.fullPath,
-      sourceText: sourceText.text)
+    // Prior to Lottie 4.3.0 the Core Animation rendering engine always just used `LegacyAnimationTextProvider`
+    // but incorrectly called it with the full keypath string, unlike the Main Thread rendering engine
+    // which only used the last component of the keypath. Starting in Lottie 4.3.0 we use `AnimationKeypathTextProvider`
+    // instead if implemented.
+    if let keypathTextValue = context.textProvider.text(for: textAnimationContext.currentKeypath, sourceText: sourceText.text) {
+      renderLayer.text = keypathTextValue
+    } else if let legacyTextProvider = context.textProvider as? LegacyAnimationTextProvider {
+      renderLayer.text = legacyTextProvider.textFor(
+        keypathName: textAnimationContext.currentKeypath.fullPath,
+        sourceText: sourceText.text)
+    } else {
+      renderLayer.text = sourceText.text
+    }
 
     renderLayer.sizeToFit()
   }

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