@octane-xplat/lottie 0.9.0 → 0.11.0

package/platforms/macos/src/vendor/Lottie/Public/DynamicProperties/ValueProviders/FloatValueProvider.swift

@@ -0,0 +1,81 @@
+//
+//  DoubleValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - FloatValueProvider
+
+/// A `ValueProvider` that returns a CGFloat Value
+public final class FloatValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes with a block provider
+  public init(block: @escaping CGFloatValueBlock) {
+    self.block = block
+    float = 0
+    identity = UUID()
+  }
+
+  /// Initializes with a single float.
+  public init(_ float: CGFloat) {
+    self.float = float
+    block = nil
+    hasUpdate = true
+    identity = float
+  }
+
+  // MARK: Public
+
+  /// Returns a CGFloat for a CGFloat(Frame Time)
+  public typealias CGFloatValueBlock = (CGFloat) -> CGFloat
+
+  public var float: CGFloat {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  public var valueType: Any.Type {
+    LottieVector1D.self
+  }
+
+  public var storage: ValueProviderStorage<LottieVector1D> {
+    if let block {
+      return .closure { frame in
+        self.hasUpdate = false
+        return LottieVector1D(Double(block(frame)))
+      }
+    } else {
+      hasUpdate = false
+      return .singleValue(LottieVector1D(Double(float)))
+    }
+  }
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
+    if block != nil {
+      return true
+    }
+    return hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+
+  private var block: CGFloatValueBlock?
+  private var identity: AnyHashable
+}
+
+// MARK: Equatable
+
+extension FloatValueProvider: Equatable {
+  public static func ==(_ lhs: FloatValueProvider, _ rhs: FloatValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/DynamicProperties/ValueProviders/GradientValueProvider.swift

@@ -0,0 +1,138 @@
+//
+//  GradientValueProvider.swift
+//  lottie-swift
+//
+//  Created by Enrique Bermúdez on 10/27/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - GradientValueProvider
+
+/// A `ValueProvider` that returns a Gradient Color Value.
+public final class GradientValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes with a block provider.
+  public init(
+    block: @escaping ColorsValueBlock,
+    locations: ColorLocationsBlock? = nil
+  ) {
+    self.block = block
+    locationsBlock = locations
+    colors = []
+    self.locations = []
+    identity = UUID()
+  }
+
+  /// Initializes with an array of colors.
+  public init(
+    _ colors: [LottieColor],
+    locations: [Double] = []
+  ) {
+    self.colors = colors
+    self.locations = locations
+    identity = [AnyHashable(colors), AnyHashable(locations)]
+    updateValueArray()
+    hasUpdate = true
+  }
+
+  // MARK: Public
+
+  /// Returns a [LottieColor] for a CGFloat(Frame Time).
+  public typealias ColorsValueBlock = (CGFloat) -> [LottieColor]
+  /// Returns a [Double](Color locations) for a CGFloat(Frame Time).
+  public typealias ColorLocationsBlock = (CGFloat) -> [Double]
+
+  /// The colors values of the provider.
+  public var colors: [LottieColor] {
+    didSet {
+      updateValueArray()
+      hasUpdate = true
+    }
+  }
+
+  /// The color location values of the provider.
+  public var locations: [Double] {
+    didSet {
+      updateValueArray()
+      hasUpdate = true
+    }
+  }
+
+  public var valueType: Any.Type {
+    [Double].self
+  }
+
+  public var storage: ValueProviderStorage<[Double]> {
+    if let block {
+      .closure { [self] frame in
+        hasUpdate = false
+
+        let newColors = block(frame)
+        let newLocations = locationsBlock?(frame) ?? []
+        value = value(from: newColors, locations: newLocations)
+
+        return value
+      }
+    } else {
+      .singleValue(value)
+    }
+  }
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
+    if block != nil || locationsBlock != nil {
+      return true
+    }
+    return hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+
+  private var block: ColorsValueBlock?
+  private var locationsBlock: ColorLocationsBlock?
+  private var value = [Double]()
+
+  private let identity: AnyHashable
+
+  private func value(from colors: [LottieColor], locations: [Double]) -> [Double] {
+    var colorValues = [Double]()
+    var alphaValues = [Double]()
+    var shouldAddAlphaValues = false
+
+    for i in 0..<colors.count {
+      if colors[i].a < 1 { shouldAddAlphaValues = true }
+
+      let location = locations.count > i
+        ? locations[i]
+        : (colors.count > 1 ? Double(i) / Double(colors.count - 1) : 0.0)
+
+      colorValues.append(location)
+      colorValues.append(colors[i].r)
+      colorValues.append(colors[i].g)
+      colorValues.append(colors[i].b)
+
+      alphaValues.append(location)
+      alphaValues.append(colors[i].a)
+    }
+
+    return colorValues + (shouldAddAlphaValues ? alphaValues : [])
+  }
+
+  private func updateValueArray() {
+    value = value(from: colors, locations: locations)
+  }
+
+}
+
+// MARK: Equatable
+
+extension GradientValueProvider: Equatable {
+  public static func ==(_ lhs: GradientValueProvider, _ rhs: GradientValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/DynamicProperties/ValueProviders/PointValueProvider.swift

@@ -0,0 +1,81 @@
+//
+//  PointValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - PointValueProvider
+
+/// A `ValueProvider` that returns a CGPoint Value
+public final class PointValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes with a block provider
+  public init(block: @escaping PointValueBlock) {
+    self.block = block
+    point = .zero
+    identity = UUID()
+  }
+
+  /// Initializes with a single point.
+  public init(_ point: CGPoint) {
+    self.point = point
+    block = nil
+    hasUpdate = true
+    identity = [point.x, point.y]
+  }
+
+  // MARK: Public
+
+  /// Returns a CGPoint for a CGFloat(Frame Time)
+  public typealias PointValueBlock = (CGFloat) -> CGPoint
+
+  public var point: CGPoint {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  public var valueType: Any.Type {
+    LottieVector3D.self
+  }
+
+  public var storage: ValueProviderStorage<LottieVector3D> {
+    if let block {
+      return .closure { frame in
+        self.hasUpdate = false
+        return block(frame).vector3dValue
+      }
+    } else {
+      hasUpdate = false
+      return .singleValue(point.vector3dValue)
+    }
+  }
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
+    if block != nil {
+      return true
+    }
+    return hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+
+  private var block: PointValueBlock?
+  private let identity: AnyHashable
+}
+
+// MARK: Equatable
+
+extension PointValueProvider: Equatable {
+  public static func ==(_ lhs: PointValueProvider, _ rhs: PointValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/DynamicProperties/ValueProviders/SizeValueProvider.swift

@@ -0,0 +1,81 @@
+//
+//  SizeValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - SizeValueProvider
+
+/// A `ValueProvider` that returns a CGSize Value
+public final class SizeValueProvider: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes with a block provider
+  public init(block: @escaping SizeValueBlock) {
+    self.block = block
+    size = .zero
+    identity = UUID()
+  }
+
+  /// Initializes with a single size.
+  public init(_ size: CGSize) {
+    self.size = size
+    block = nil
+    hasUpdate = true
+    identity = [size.width, size.height]
+  }
+
+  // MARK: Public
+
+  /// Returns a CGSize for a CGFloat(Frame Time)
+  public typealias SizeValueBlock = (CGFloat) -> CGSize
+
+  public var size: CGSize {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  public var valueType: Any.Type {
+    LottieVector3D.self
+  }
+
+  public var storage: ValueProviderStorage<LottieVector3D> {
+    if let block {
+      return .closure { frame in
+        self.hasUpdate = false
+        return block(frame).vector3dValue
+      }
+    } else {
+      hasUpdate = false
+      return .singleValue(size.vector3dValue)
+    }
+  }
+
+  public func hasUpdate(frame _: CGFloat) -> Bool {
+    if block != nil {
+      return true
+    }
+    return hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+
+  private var block: SizeValueBlock?
+  private let identity: AnyHashable
+}
+
+// MARK: Equatable
+
+extension SizeValueProvider: Equatable {
+  public static func ==(_ lhs: SizeValueProvider, _ rhs: SizeValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/FontProvider/AnimationFontProvider.swift

@@ -0,0 +1,41 @@
+//
+//  AnimationFontProvider.swift
+//  Lottie
+//
+//  Created by Brandon Withrow on 8/5/20.
+//  Copyright © 2020 YurtvilleProds. All rights reserved.
+//
+
+import CoreText
+
+// MARK: - AnimationFontProvider
+
+/// Font provider is a protocol that is used to supply fonts to `LottieAnimationView`.
+///
+public protocol AnimationFontProvider {
+  func fontFor(family: String, size: CGFloat) -> CTFont?
+}
+
+// MARK: - DefaultFontProvider
+
+/// Default Font provider.
+public final class DefaultFontProvider: AnimationFontProvider {
+
+  // MARK: Lifecycle
+
+  public init() { }
+
+  // MARK: Public
+
+  public func fontFor(family: String, size: CGFloat) -> CTFont? {
+    CTFontCreateWithName(family as CFString, size, nil)
+  }
+}
+
+// MARK: Equatable
+
+extension DefaultFontProvider: Equatable {
+  public static func ==(_: DefaultFontProvider, _: DefaultFontProvider) -> Bool {
+    true
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/ImageProvider/AnimationImageProvider.swift

@@ -0,0 +1,43 @@
+//
+//  LottieImageProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+import QuartzCore
+
+// MARK: - AnimationImageProvider
+
+/// Image provider is a protocol that is used to supply images to `LottieAnimationView`.
+///
+/// Some animations require a reference to an image. The image provider loads and
+/// provides those images to the `LottieAnimationView`.  Lottie includes a couple of
+/// prebuilt Image Providers that supply images from a Bundle, or from a FilePath.
+///
+/// Additionally custom Image Providers can be made to load images from a URL,
+/// or to Cache images.
+public protocol AnimationImageProvider {
+
+  /// Whether or not the resulting image of this image provider can be cached by Lottie. Defaults to true.
+  /// If true, Lottie may internally cache the result of `imageForAsset`
+  var cacheEligible: Bool { get }
+
+  /// The image to display for the given `ImageAsset` defined in the `LottieAnimation` JSON file.
+  func imageForAsset(asset: ImageAsset) -> CGImage?
+
+  /// Specifies how the layer's contents are positioned or scaled within its bounds for a given asset.
+  /// Defaults to `.resize`, which stretches the image to fill the layer.
+  func contentsGravity(for asset: ImageAsset) -> CALayerContentsGravity
+}
+
+extension AnimationImageProvider {
+  public var cacheEligible: Bool {
+    true
+  }
+
+  /// The default value is `.resize`, similar to that of `CALayer`.
+  public func contentsGravity(for _: ImageAsset) -> CALayerContentsGravity {
+    .resize
+  }
+}