@octane-xplat/lottie 0.9.0 → 0.11.0

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Layers/TextLayer.swift

@@ -0,0 +1,157 @@
+// Created by Cal Stephens on 2/9/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+/// The `CALayer` type responsible for rendering `TextLayer`s
+final class TextLayer: BaseCompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(
+    textLayerModel: TextLayerModel,
+    context: LayerContext
+  ) throws {
+    self.textLayerModel = textLayerModel
+    super.init(layerModel: textLayerModel)
+    setupSublayers()
+    try configureRenderLayer(with: context)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  /// Called by CoreAnimation to create a shadow copy of this layer
+  /// More details: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+  override init(layer: Any) {
+    guard let typedLayer = layer as? Self else {
+      fatalError("\(Self.self).init(layer:) incorrectly called with \(type(of: layer))")
+    }
+
+    textLayerModel = typedLayer.textLayerModel
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Internal
+
+  override func setupAnimations(context: LayerAnimationContext) throws {
+    try super.setupAnimations(context: context)
+    let textAnimationContext = context.addingKeypathComponent(textLayerModel.name)
+
+    let sourceText = try textLayerModel.text.exactlyOneKeyframe(
+      context: textAnimationContext,
+      description: "text layer 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
+    }
+
+    // Apply the custom contents scale for this layer if it was provided
+    if
+      let contentsScaleProvider = context.textProvider as? TextContentsScaleProvider,
+      let contentsScale = contentsScaleProvider.contentsScale(for: textAnimationContext.currentKeypath)
+    {
+      renderLayer.contentsScale = contentsScale
+    }
+
+    renderLayer.sizeToFit()
+
+    // Check if there are any dynamic color overrides for this text layer.
+    // NOTE: The Core Animation engine currently only supports static color overrides for text.
+    // Animated ValueProviders will only have their first keyframe applied.
+    if
+      let customFillColor = try textAnimationContext.valueProviderStore.customKeyframes(
+        of: .color,
+        for: textAnimationContext
+          .currentKeypath
+          .appendingKey(PropertyName.color.rawValue),
+        context: textAnimationContext
+      )
+    {
+      if customFillColor.keyframes.count > 1 {
+        try textAnimationContext.logCompatibilityIssue("""
+          The Core Animation rendering engine currently doesn't support animated text color overrides.
+          """)
+      }
+
+      renderLayer.fillColor = customFillColor.keyframes[0].value
+    }
+
+    if
+      let customStrokeColor = try textAnimationContext.valueProviderStore.customKeyframes(
+        of: .color,
+        for: textAnimationContext
+          .currentKeypath
+          .appendingKey(PropertyName.strokeColor.rawValue),
+        context: textAnimationContext
+      )
+    {
+      renderLayer.strokeColor = customStrokeColor.keyframes[0].value
+    }
+  }
+
+  func configureRenderLayer(with context: LayerContext) throws {
+    // We can't use `CATextLayer`, because it doesn't support enough features we use.
+    // Instead, we use the same `CoreTextRenderLayer` (with a custom `draw` implementation)
+    // used by the Main Thread rendering engine. This means the Core Animation engine can't
+    // _animate_ text properties, but it can display static text without any issues.
+    let text = try textLayerModel.text.exactlyOneKeyframe(context: context, description: "text layer text")
+
+    // The Core Animation engine doesn't currently support `TextAnimator`s.
+    //  - We could add support for animating the transform-related properties without much trouble.
+    //  - We may be able to support animating `fillColor` by getting clever with layer blend modes
+    //    or masks (e.g. use `CoreTextRenderLayer` to draw black glyphs, and then fill them in
+    //    using a `CAShapeLayer`).
+    if !textLayerModel.animators.isEmpty {
+      try context.logCompatibilityIssue("""
+        The Core Animation rendering engine currently doesn't support text animators.
+        """)
+    }
+
+    renderLayer.font = context.fontProvider.fontFor(family: text.fontFamily, size: CGFloat(text.fontSize))
+
+    renderLayer.alignment = text.justification.textAlignment
+    renderLayer.lineHeight = CGFloat(text.lineHeight)
+    renderLayer.tracking = (CGFloat(text.fontSize) * CGFloat(text.tracking)) / 1000
+
+    renderLayer.fillColor = text.fillColorData?.cgColorValue
+    renderLayer.strokeColor = text.strokeColorData?.cgColorValue
+    renderLayer.strokeWidth = CGFloat(text.strokeWidth ?? 0)
+    renderLayer.strokeOnTop = text.strokeOverFill ?? false
+
+    renderLayer.preferredSize = text.textFrameSize?.sizeValue
+    renderLayer.sizeToFit()
+
+    renderLayer.transform = CATransform3DIdentity
+    renderLayer.position = text.textFramePosition?.pointValue ?? .zero
+  }
+
+  // MARK: Private
+
+  private let textLayerModel: TextLayerModel
+  private let renderLayer = CoreTextRenderLayer()
+
+  private func setupSublayers() {
+    // Place the text render layer in an additional container
+    //  - Direct sublayers of a `BaseCompositionLayer` always fill the bounds
+    //    of their superlayer -- so this container will be the bounds of self,
+    //    and the text render layer can be positioned anywhere.
+    let textContainerLayer = CALayer()
+    textContainerLayer.addSublayer(renderLayer)
+    addSublayer(textContainerLayer)
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Layers/TransformLayer.swift

@@ -0,0 +1,13 @@
+// Created by Cal Stephens on 12/21/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+/// The CALayer type responsible for only rendering the `transform` of a `LayerModel`
+final class TransformLayer: BaseCompositionLayer {
+
+  /// `TransformLayer`s don't render any visible content,
+  /// they just `transform` their sublayers
+  override var renderLayerContents: Bool {
+    false
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/ValueProviderStore.swift

@@ -0,0 +1,157 @@
+// Created by Cal Stephens on 1/13/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - ValueProviderStore
+
+/// Registration and storage for `AnyValueProvider`s that can dynamically
+/// provide custom values for `AnimationKeypath`s within a `LottieAnimation`.
+final class ValueProviderStore {
+
+  // MARK: Lifecycle
+
+  init(logger: LottieLogger) {
+    self.logger = logger
+  }
+
+  // MARK: Internal
+
+  /// Registers an `AnyValueProvider` for the given `AnimationKeypath`
+  func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath) {
+    logger.assert(
+      valueProvider.typeErasedStorage.isSupportedByCoreAnimationRenderingEngine,
+      """
+      The Core Animation rendering engine doesn't support Value Providers that vend a closure,
+      because that would require calling the closure on the main thread once per frame.
+      """
+    )
+
+    let supportedProperties = PropertyName.allCases.map { $0.rawValue }
+    let propertyBeingCustomized = keypath.keys.last ?? ""
+
+    logger.assert(
+      supportedProperties.contains(propertyBeingCustomized),
+      """
+      The Core Animation rendering engine currently doesn't support customizing "\(propertyBeingCustomized)" \
+      properties. Supported properties are: \(supportedProperties.joined(separator: ", ")).
+      """
+    )
+
+    valueProviders.removeAll(where: { $0.keypath == keypath })
+    valueProviders.append((keypath: keypath, valueProvider: valueProvider))
+  }
+
+  /// Removes all ValueProviders for the given `AnimationKeypath`
+  func removeValueProvider(for keypath: AnimationKeypath) {
+    valueProviders.removeAll(where: { $0.keypath.matches(keypath) })
+  }
+
+  /// Retrieves the custom value keyframes for the given property,
+  /// if an `AnyValueProvider` was registered for the given keypath.
+  func customKeyframes<Value>(
+    of customizableProperty: CustomizableProperty<Value>,
+    for keypath: AnimationKeypath,
+    context: LayerAnimationContext
+  ) throws -> KeyframeGroup<Value>? {
+    context.recordHierarchyKeypath?(keypath.fullPath)
+
+    guard let anyValueProvider = valueProvider(for: keypath) else {
+      return nil
+    }
+
+    // Retrieve the type-erased keyframes from the custom `ValueProvider`
+    let typeErasedKeyframes: [Keyframe<Any>]
+    switch anyValueProvider.typeErasedStorage {
+    case .singleValue(let typeErasedValue):
+      typeErasedKeyframes = [Keyframe(typeErasedValue)]
+
+    case .keyframes(let keyframes, _):
+      typeErasedKeyframes = keyframes
+
+    case .closure:
+      try context.logCompatibilityIssue("""
+        The Core Animation rendering engine doesn't support Value Providers that vend a closure,
+        because that would require calling the closure on the main thread once per frame.
+        """)
+      return nil
+    }
+
+    // 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, anyValueProvider) else {
+        logger.assertionFailure("""
+          Could not convert value of type \(type(of: typeErasedKeyframe.value)) from \(anyValueProvider) to expected type \(
+          Value
+          .self)
+          """)
+        return nil
+      }
+
+      return typeErasedKeyframe.withValue(convertedValue)
+    }
+
+    // Verify that all of the keyframes were successfully converted to the expected type
+    guard typedKeyframes.count == typeErasedKeyframes.count else {
+      return nil
+    }
+
+    return KeyframeGroup(keyframes: ContiguousArray(typedKeyframes))
+  }
+
+  // MARK: Private
+
+  private let logger: LottieLogger
+  private var valueProviders = [(keypath: AnimationKeypath, valueProvider: AnyValueProvider)]()
+
+  /// 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
+    valueProviders.last(where: { registeredKeypath, _ in
+      keypath.matches(registeredKeypath)
+    })?.valueProvider
+  }
+
+}
+
+extension AnyValueProviderStorage {
+  /// Whether or not this type of value provider is supported
+  /// by the new Core Animation rendering engine
+  var isSupportedByCoreAnimationRenderingEngine: Bool {
+    switch self {
+    case .singleValue, .keyframes:
+      true
+    case .closure:
+      false
+    }
+  }
+}
+
+extension AnimationKeypath {
+  /// Whether or not this keypath from the animation hierarchy
+  /// matches the given keypath (which may contain wildcards)
+  func matches(_ keypath: AnimationKeypath) -> Bool {
+    var regex = "^" // match the start of the string
+      + keypath.keys.joined(separator: "\\.") // match this keypath, escaping "." characters
+      + "$" // match the end of the string
+
+    // Replace the ** and * wildcards with markers that are guaranteed to be unique
+    // and won't conflict with regex syntax (e.g. `.*`).
+    let doubleWildcardMarker = UUID().uuidString
+    let singleWildcardMarker = UUID().uuidString
+    regex = regex.replacingOccurrences(of: "**", with: doubleWildcardMarker)
+    regex = regex.replacingOccurrences(of: "*", with: singleWildcardMarker)
+
+    // "**" wildcards match zero or more path segments separated by "\\."
+    //  - "**.Color" matches any of "Color", "Layer 1.Color", and "Layer 1.Layer 2.Color"
+    regex = regex.replacingOccurrences(of: "\(doubleWildcardMarker)\\.", with: ".*")
+    regex = regex.replacingOccurrences(of: doubleWildcardMarker, with: ".*")
+
+    // "*" wildcards match exactly one path component
+    //  - "*.Color" matches "Layer 1.Color" but not "Layer 1.Layer 2.Color"
+    regex = regex.replacingOccurrences(of: singleWildcardMarker, with: "[^.]+")
+
+    return fullPath.range(of: regex, options: .regularExpression) != nil
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/EpoxyCore/Diffing/Collection+Diff.swift

@@ -0,0 +1,267 @@
+//  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 reference 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/platforms/macos/src/vendor/Lottie/Private/EmbeddedLibraries/EpoxyCore/Diffing/Diffable.swift

@@ -0,0 +1,19 @@
+//  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 {
+
+  /// The identifier to use when checking identity while diffing.
+  var diffIdentifier: AnyHashable { get }
+
+  /// Checks for equality between items when diffing.
+  ///
+  /// - Parameters:
+  ///     - otherDiffableItem: The other item to check equality against while diffing.
+  func isDiffableItemEqual(to otherDiffableItem: Diffable) -> Bool
+
+}

package/platforms/macos/src/vendor/Lottie/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 }
+}