lottie-ios 4.4.3 → 4.5.0

package/Sources/Private/EmbeddedLibraries/ZipFoundation/Archive+Helpers.swift

@@ -83,6 +83,7 @@ extension Archive {
           bufferSize: bufferSize,
           progress: progress,
           provider: provider)
+
       case .deflate:
         (sizeWritten, checksum) = try writeCompressed(
           size: uncompressedSize,
@@ -90,9 +91,11 @@ extension Archive {
           progress: progress,
           provider: provider)
       }
+
     case .directory:
       _ = try provider(0, 0)
       if let progress { progress.completedUnitCount = progress.totalUnitCount }
+
     case .symlink:
       let (linkSizeWritten, linkChecksum) = try writeSymbolicLink(
         size: Int(uncompressedSize),
@@ -226,6 +229,7 @@ extension Archive {
           throw ArchiveError.invalidCentralDirectoryEntryCount
         }
         return (sizeOfCD + UInt64(cdDataLengthChange), numberOfTotalEntries + UInt64(countChange))
+
       case .remove:
         return (sizeOfCD - UInt64(-cdDataLengthChange), numberOfTotalEntries - UInt64(-countChange))
       }

package/Sources/Private/EmbeddedLibraries/ZipFoundation/Archive+Progress.swift

@@ -32,9 +32,9 @@ extension Archive {
   func totalUnitCountForReading(_ entry: Entry) -> Int64 {
     switch entry.type {
     case .file, .symlink:
-      return Int64(entry.uncompressedSize)
+      Int64(entry.uncompressedSize)
     case .directory:
-      return defaultDirectoryUnitCount
+      defaultDirectoryUnitCount
     }
   }
 

package/Sources/Private/EmbeddedLibraries/ZipFoundation/Archive+Reading.swift

@@ -52,6 +52,7 @@ extension Archive {
         skipCRC32: skipCRC32,
         progress: progress,
         consumer: consumer)
+
     case .directory:
       let consumer = { (_: Data) in
         try fileManager.createDirectory(at: url, withIntermediateDirectories: true, attributes: nil)
@@ -62,6 +63,7 @@ extension Archive {
         skipCRC32: skipCRC32,
         progress: progress,
         consumer: consumer)
+
     case .symlink:
       guard !fileManager.itemExists(at: url) else {
         throw CocoaError(.fileWriteFileExists, userInfo: [NSFilePathErrorKey: url.path])
@@ -121,6 +123,7 @@ extension Archive {
           skipCRC32: skipCRC32,
           progress: progress,
           with: consumer)
+
       case .deflate: checksum = try readCompressed(
           entry: entry,
           bufferSize: bufferSize,
@@ -128,9 +131,11 @@ extension Archive {
           progress: progress,
           with: consumer)
       }
+
     case .directory:
       try consumer(Data())
       progress?.completedUnitCount = totalUnitCountForReading(entry)
+
     case .symlink:
       let localFileHeader = entry.localFileHeader
       let size = Int(localFileHeader.compressedSize)

package/Sources/Private/EmbeddedLibraries/ZipFoundation/Archive+Writing.swift

@@ -96,6 +96,7 @@ extension Archive {
         bufferSize: bufferSize,
         progress: progress,
         provider: provider)
+
     case .directory:
       provider = { _, _ in Data() }
       try addEntry(
@@ -108,6 +109,7 @@ extension Archive {
         bufferSize: bufferSize,
         progress: progress,
         provider: provider)
+
     case .symlink:
       provider = { _, _ -> Data in
         let linkDestination = try fileManager.destinationOfSymbolicLink(atPath: fileURL.path)

package/Sources/Private/EmbeddedLibraries/ZipFoundation/Data+Compression.swift

@@ -169,6 +169,7 @@ extension Data {
         if operation == COMPRESSION_STREAM_DECODE, !skipCRC32 { crc32 = outputData.crc32(checksum: crc32) }
         stream.dst_ptr = destPointer
         stream.dst_size = bufferSize
+
       default: throw CompressionError.corruptedData
       }
     } while status == COMPRESSION_STATUS_OK

package/Sources/Private/EmbeddedLibraries/ZipFoundation/Entry+ZIP64.swift

@@ -121,9 +121,9 @@ extension Entry.ZIP64ExtendedInformation {
     var size: Int {
       switch self {
       case .uncompressedSize, .compressedSize, .relativeOffsetOfLocalHeader:
-        return 8
+        8
       case .diskNumberStart:
-        return 4
+        4
       }
     }
   }

package/Sources/Private/EmbeddedLibraries/ZipFoundation/Entry.swift

@@ -185,6 +185,7 @@ struct Entry: Equatable {
       default:
         return isDirectory ? .directory : .file
       }
+
     case .msdos:
       isDirectory = isDirectory || ((centralDirectoryStructure.externalFileAttributes >> 4) == 0x01)
       fallthrough // For all other OSes we can only guess based on the directory suffix char

package/Sources/Private/EmbeddedLibraries/ZipFoundation/FileManager+ZIP.swift

@@ -44,21 +44,22 @@ extension FileManager {
       let permissions = mode_t(externalFileAttributes >> 16) & ~S_IFMT
       let defaultPermissions = entryType == .directory ? defaultDirectoryPermissions : defaultFilePermissions
       return permissions == 0 ? defaultPermissions : UInt16(permissions)
+
     default:
       return entryType == .directory ? defaultDirectoryPermissions : defaultFilePermissions
     }
   }
 
   class func externalFileAttributesForEntry(of type: Entry.EntryType, permissions: UInt16) -> UInt32 {
-    var typeInt: UInt16
-    switch type {
-    case .file:
-      typeInt = UInt16(S_IFREG)
-    case .directory:
-      typeInt = UInt16(S_IFDIR)
-    case .symlink:
-      typeInt = UInt16(S_IFLNK)
-    }
+    let typeInt =
+      switch type {
+      case .file:
+        UInt16(S_IFREG)
+      case .directory:
+        UInt16(S_IFDIR)
+      case .symlink:
+        UInt16(S_IFLNK)
+      }
     var externalFileAttributes = UInt32(typeInt | UInt16(permissions))
     externalFileAttributes = (externalFileAttributes << 16)
     return externalFileAttributes

package/Sources/Private/MainThread/LayerContainers/CompLayers/CompositionLayer.swift

@@ -36,6 +36,10 @@ class CompositionLayer: CALayer, KeypathSearchable {
       "bounds" : NSNull(),
       "anchorPoint" : NSNull(),
       "sublayerTransform" : NSNull(),
+      "shadowOpacity" : NSNull(),
+      "shadowOffset" : NSNull(),
+      "shadowColor" : NSNull(),
+      "shadowRadius" : NSNull(),
     ]
 
     contentsLayer.anchorPoint = .zero
@@ -55,6 +59,14 @@ class CompositionLayer: CALayer, KeypathSearchable {
       contentsLayer.mask = maskLayer
     }
 
+    // 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 = layer.effects.first(where: { $0 is DropShadowEffect }) as? DropShadowModel
+    let dropShadowStyle = layer.styles.first(where: { $0 is DropShadowStyle }) as? DropShadowModel
+    if let dropShadowModel = dropShadowEffect ?? dropShadowStyle {
+      layerEffectNodes.append(DropShadowNode(model: dropShadowModel))
+    }
     name = layer.name
   }
 
@@ -72,6 +84,7 @@ class CompositionLayer: CALayer, KeypathSearchable {
     keypathName = layer.keypathName
     childKeypaths = [transformNode.transformProperties]
     maskLayer = nil
+    layerEffectNodes = layer.layerEffectNodes
     super.init(layer: layer)
   }
 
@@ -96,6 +109,8 @@ class CompositionLayer: CALayer, KeypathSearchable {
   let startFrame: CGFloat
   let timeStretch: CGFloat
 
+  var layerEffectNodes: [LayerEffectNode] = []
+
   // MARK: Keypath Searchable
 
   let keypathName: String
@@ -142,6 +157,10 @@ class CompositionLayer: CALayer, KeypathSearchable {
     contentsLayer.opacity = transformNode.opacity
     contentsLayer.isHidden = !layerVisible
     layerDelegate?.frameUpdated(frame: frame)
+
+    for layerEffectNode in layerEffectNodes {
+      layerEffectNode.updateWithFrame(layer: self, frame: frame)
+    }
   }
 
   func displayContentsWithFrame(frame _: CGFloat, forceUpdates _: Bool) {

package/Sources/Private/MainThread/LayerContainers/CompLayers/MaskContainerLayer.swift

@@ -11,19 +11,19 @@ extension MaskMode {
   var usableMode: MaskMode {
     switch self {
     case .add:
-      return .add
+      .add
     case .subtract:
-      return .subtract
+      .subtract
     case .intersect:
-      return .intersect
+      .intersect
     case .lighten:
-      return .add
+      .add
     case .darken:
-      return .darken
+      .darken
     case .difference:
-      return .intersect
+      .intersect
     case .none:
-      return .none
+      .none
     }
   }
 }

package/Sources/Private/MainThread/LayerContainers/CompLayers/PreCompositionLayer.swift

@@ -16,6 +16,7 @@ final class PreCompositionLayer: CompositionLayer {
     asset: PrecompAsset,
     layerImageProvider: LayerImageProvider,
     layerTextProvider: LayerTextProvider,
+    layerFontProvider: LayerFontProvider,
     textProvider: AnimationKeypathTextProvider,
     fontProvider: AnimationFontProvider,
     assetLibrary: AssetLibrary?,
@@ -38,6 +39,7 @@ final class PreCompositionLayer: CompositionLayer {
       assetLibrary: assetLibrary,
       layerImageProvider: layerImageProvider,
       layerTextProvider: layerTextProvider,
+      layerFontProvider: layerFontProvider,
       textProvider: textProvider,
       fontProvider: fontProvider,
       frameRate: frameRate,
@@ -77,6 +79,7 @@ final class PreCompositionLayer: CompositionLayer {
 
     layerImageProvider.addImageLayers(imageLayers)
     layerTextProvider.addTextLayers(textLayers)
+    layerFontProvider.addTextLayers(textLayers)
   }
 
   override init(layer: Any) {

package/Sources/Private/MainThread/LayerContainers/CompLayers/TextCompositionLayer.swift

@@ -16,22 +16,22 @@ extension TextJustification {
   var textAlignment: NSTextAlignment {
     switch self {
     case .left:
-      return .left
+      .left
     case .right:
-      return .right
+      .right
     case .center:
-      return .center
+      .center
     }
   }
 
   var caTextAlignement: CATextLayerAlignmentMode {
     switch self {
     case .left:
-      return .left
+      .left
     case .right:
-      return .right
+      .right
     case .center:
-      return .center
+      .center
     }
   }
 }
@@ -121,20 +121,24 @@ final class TextCompositionLayer: CompositionLayer {
     // Prior to Lottie 4.3.0 the Main Thread rendering engine always just used `LegacyAnimationTextProvider`
     // and called it with the `keypathName` (only the last path component of the full keypath).
     // Starting in Lottie 4.3.0 we use `AnimationKeypathTextProvider` instead if implemented.
-    let textString: String
-    if let keypathTextValue = textProvider.text(for: fullAnimationKeypath, sourceText: text.text) {
-      textString = keypathTextValue
-    } else if let legacyTextProvider = textProvider as? LegacyAnimationTextProvider {
-      textString = legacyTextProvider.textFor(keypathName: keypathName, sourceText: text.text)
-    } else {
-      textString = text.text
-    }
+    let textString: String =
+      if let keypathTextValue = textProvider.text(for: fullAnimationKeypath, sourceText: text.text) {
+        keypathTextValue
+      } else if let legacyTextProvider = textProvider as? LegacyAnimationTextProvider {
+        legacyTextProvider.textFor(keypathName: keypathName, sourceText: text.text)
+      } else {
+        text.text
+      }
 
     let strokeColor = rootNode?.textOutputNode.strokeColor ?? text.strokeColorData?.cgColorValue
     let strokeWidth = rootNode?.textOutputNode.strokeWidth ?? CGFloat(text.strokeWidth ?? 0)
     let tracking = (CGFloat(text.fontSize) * (rootNode?.textOutputNode.tracking ?? CGFloat(text.tracking))) / 1000.0
     let matrix = rootNode?.textOutputNode.xform ?? CATransform3DIdentity
     let ctFont = fontProvider.fontFor(family: text.fontFamily, size: CGFloat(text.fontSize))
+    let start = rootNode?.textOutputNode.start.flatMap { Int($0) }
+    let end = rootNode?.textOutputNode.end.flatMap { Int($0) }
+    let selectedRangeOpacity = rootNode?.textOutputNode.selectedRangeOpacity
+    let textRangeUnit = rootNode?.textAnimatorProperties.textRangeUnit
 
     // Set all of the text layer options
     textLayer.text = textString
@@ -143,6 +147,12 @@ final class TextCompositionLayer: CompositionLayer {
     textLayer.lineHeight = CGFloat(text.lineHeight)
     textLayer.tracking = tracking
 
+    // Configure the text animators
+    textLayer.start = start
+    textLayer.end = end
+    textLayer.textRangeUnit = textRangeUnit
+    textLayer.selectedRangeOpacity = selectedRangeOpacity
+
     if let fillColor = rootNode?.textOutputNode.fillColor {
       textLayer.fillColor = fillColor
     } else if let fillColor = text.fillColorData?.cgColorValue {

package/Sources/Private/MainThread/LayerContainers/MainThreadAnimationLayer.swift

@@ -37,6 +37,7 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
       assetLibrary: animation.assetLibrary,
       layerImageProvider: layerImageProvider,
       layerTextProvider: layerTextProvider,
+      layerFontProvider: layerFontProvider,
       textProvider: textProvider,
       fontProvider: fontProvider,
       frameRate: CGFloat(animation.framerate),
@@ -127,16 +128,16 @@ final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
 
   public override func display() {
     guard Thread.isMainThread else { return }
-    var newFrame: CGFloat
-    if
-      let animationKeys = animationKeys(),
-      !animationKeys.isEmpty
-    {
-      newFrame = presentation()?.currentFrame ?? currentFrame
-    } else {
-      // We ignore the presentation's frame if there's no animation in the layer.
-      newFrame = currentFrame
-    }
+    var newFrame: CGFloat =
+      if
+        let animationKeys = animationKeys(),
+        !animationKeys.isEmpty
+      {
+        presentation()?.currentFrame ?? currentFrame
+      } else {
+        // We ignore the presentation's frame if there's no animation in the layer.
+        currentFrame
+      }
     if respectAnimationFrameRate {
       newFrame = floor(newFrame)
     }

package/Sources/Private/MainThread/LayerContainers/Utility/CompositionLayersInitializer.swift

@@ -14,6 +14,7 @@ extension [LayerModel] {
     assetLibrary: AssetLibrary?,
     layerImageProvider: LayerImageProvider,
     layerTextProvider: LayerTextProvider,
+    layerFontProvider: LayerFontProvider,
     textProvider: AnimationKeypathTextProvider,
     fontProvider: AnimationFontProvider,
     frameRate: CGFloat,
@@ -49,6 +50,7 @@ extension [LayerModel] {
           asset: precompAsset,
           layerImageProvider: layerImageProvider,
           layerTextProvider: layerTextProvider,
+          layerFontProvider: layerFontProvider,
           textProvider: textProvider,
           fontProvider: fontProvider,
           assetLibrary: assetLibrary,

package/Sources/Private/MainThread/LayerContainers/Utility/CoreTextRenderLayer.swift

@@ -39,7 +39,7 @@ final class CoreTextRenderLayer: CALayer {
     }
   }
 
-  public var alignment: NSTextAlignment = .left {
+  public var alignment = NSTextAlignment.left {
     didSet {
       needsContentUpdate = true
       setNeedsLayout()
@@ -102,6 +102,40 @@ final class CoreTextRenderLayer: CALayer {
     }
   }
 
+  public var start: Int? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  public var end: Int? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  /// The type of unit to use when computing the `start` / `end` range within the text string
+  public var textRangeUnit: TextRangeUnit? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  /// The opacity to apply to the range between `start` and `end`
+  public var selectedRangeOpacity: CGFloat? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
   public func sizeToFit() {
     updateTextContent()
     bounds = drawingRect
@@ -137,19 +171,19 @@ final class CoreTextRenderLayer: CALayer {
 
     let drawingPath = CGPath(rect: drawingRect, transform: nil)
 
-    let fillFrame: CTFrame?
-    if let setter = fillFrameSetter {
-      fillFrame = CTFramesetterCreateFrame(setter, CFRangeMake(0, attributedString.length), drawingPath, nil)
-    } else {
-      fillFrame = nil
-    }
+    let fillFrame: CTFrame? =
+      if let setter = fillFrameSetter {
+        CTFramesetterCreateFrame(setter, CFRangeMake(0, attributedString.length), drawingPath, nil)
+      } else {
+        nil
+      }
 
-    let strokeFrame: CTFrame?
-    if let setter = strokeFrameSetter {
-      strokeFrame = CTFramesetterCreateFrame(setter, CFRangeMake(0, attributedString.length), drawingPath, nil)
-    } else {
-      strokeFrame = nil
-    }
+    let strokeFrame: CTFrame? =
+      if let setter = strokeFrameSetter {
+        CTFramesetterCreateFrame(setter, CFRangeMake(0, attributedString.length), drawingPath, nil)
+      } else {
+        nil
+      }
 
     // This fixes a vertical padding issue that arises when drawing some fonts.
     // For some reason some fonts, such as Helvetica draw with and ascender that is greater than the one reported by CTFontGetAscender.
@@ -176,14 +210,14 @@ final class CoreTextRenderLayer: CALayer {
 
   // MARK: Private
 
-  private var drawingRect: CGRect = .zero
-  private var drawingAnchor: CGPoint = .zero
+  private var drawingRect = CGRect.zero
+  private var drawingAnchor = CGPoint.zero
   private var fillFrameSetter: CTFramesetter?
   private var attributedString: NSAttributedString?
   private var strokeFrameSetter: CTFramesetter?
   private var needsContentUpdate = false
 
-  // Draws Debug colors for the font alignment.
+  /// Draws Debug colors for the font alignment.
   private func drawDebug(_ ctx: CGContext) {
     if let font {
       let ascent = CTFontGetAscent(font)
@@ -259,7 +293,58 @@ final class CoreTextRenderLayer: CALayer {
       attributes[NSAttributedString.Key.foregroundColor] = fillColor
     }
 
-    let attrString = NSAttributedString(string: text, attributes: attributes)
+    let attrString = NSMutableAttributedString(string: text, attributes: attributes)
+
+    // Apply the text animator within between the `start` and `end` indices
+    if let selectedRangeOpacity {
+      // The start and end of a text animator refer to the portions of the text
+      // where that animator is applies. In the schema these can be represented
+      // in absolute index value, or as percentages relative to the dynamic string length.
+      var startIndex: Int
+      var endIndex: Int
+
+      switch textRangeUnit ?? .percentage {
+      case .index:
+        startIndex = start ?? 0
+        endIndex = end ?? text.count
+
+      case .percentage:
+        let startPercentage = Double(start ?? 0) / 100
+        let endPercentage = Double(end ?? 100) / 100
+
+        startIndex = Int(round(Double(attrString.length) * startPercentage))
+        endIndex = Int(round(Double(attrString.length) * endPercentage))
+      }
+
+      // Carefully cap the indices, since passing invalid indices
+      // to `NSAttributedString` will crash the app.
+      startIndex = startIndex.clamp(0, attrString.length)
+      endIndex = endIndex.clamp(0, attrString.length)
+
+      // Make sure the end index actually comes after the start index
+      if endIndex < startIndex {
+        swap(&startIndex, &endIndex)
+      }
+
+      // Apply the `selectedRangeOpacity` to the current `fillColor` if provided
+      let textRangeColor: CGColor
+      if let fillColor {
+        if let (r, g, b) = fillColor.rgb {
+          textRangeColor = .rgba(r, g, b, selectedRangeOpacity)
+        } else {
+          LottieLogger.shared.warn("Could not convert color \(fillColor) to RGB values.")
+          textRangeColor = .rgba(0, 0, 0, selectedRangeOpacity)
+        }
+      } else {
+        textRangeColor = .rgba(0, 0, 0, selectedRangeOpacity)
+      }
+
+      attrString.addAttribute(
+        NSAttributedString.Key.foregroundColor,
+        value: textRangeColor,
+        range: NSRange(location: startIndex, length: endIndex - startIndex))
+    }
+
     attributedString = attrString
 
     if fillColor != nil {

package/Sources/Private/MainThread/LayerContainers/Utility/LayerTransformNode.swift

@@ -119,17 +119,17 @@ class LayerTransformNode: AnimatorNode {
   func rebuildOutputs(frame _: CGFloat) {
     opacity = Float(transformProperties.opacity.value.cgFloatValue) * 0.01
 
-    let position: CGPoint
-    if let point = transformProperties.position?.value.pointValue {
-      position = point
-    } else if
-      let xPos = transformProperties.positionX?.value.cgFloatValue,
-      let yPos = transformProperties.positionY?.value.cgFloatValue
-    {
-      position = CGPoint(x: xPos, y: yPos)
-    } else {
-      position = .zero
-    }
+    let position: CGPoint =
+      if let point = transformProperties.position?.value.pointValue {
+        point
+      } else if
+        let xPos = transformProperties.positionX?.value.cgFloatValue,
+        let yPos = transformProperties.positionY?.value.cgFloatValue
+      {
+        CGPoint(x: xPos, y: yPos)
+      } else {
+        .zero
+      }
 
     localTransform = CATransform3D.makeTransform(
       anchor: transformProperties.anchor.value.pointValue,

package/Sources/Private/MainThread/NodeRenderSystem/Extensions/ItemsExtension.swift

@@ -49,10 +49,12 @@ extension [ShapeItem] {
         switch star.starType {
         case .none:
           continue
+
         case .polygon:
           let node = PolygonNode(parentNode: nodeTree.rootNode, star: star)
           nodeTree.rootNode = node
           nodeTree.childrenNodes.append(node)
+
         case .star:
           let node = StarNode(parentNode: nodeTree.rootNode, star: star)
           nodeTree.rootNode = node