@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Public/TextProvider/AnimationTextProvider.swift

@@ -0,0 +1,135 @@
+//
+//  AnimationImageProvider.swift
+//  Lottie_iOS
+//
+//  Created by Alexandr Goncharov on 07/06/2019.
+//
+
+import Foundation
+
+// MARK: - AnimationKeypathTextProvider
+
+/// Protocol for providing dynamic text to for a Lottie animation.
+public protocol AnimationKeypathTextProvider: AnyObject {
+  /// The text to display for the given `AnimationKeypath`.
+  /// If `nil` is returned, continues using the existing default text value.
+  func text(for keypath: AnimationKeypath, sourceText: String) -> String?
+}
+
+// MARK: - AnimationKeypathTextProvider
+
+/// Legacy protocol for providing dynamic text for a Lottie animation.
+/// Instead prefer conforming to `AnimationKeypathTextProvider`.
+@available(*, deprecated, message: """
+  `AnimationKeypathTextProvider` has been deprecated and renamed to `LegacyAnimationTextProvider`. \
+  Instead, conform to `AnimationKeypathTextProvider` instead or conform to `LegacyAnimationTextProvider` explicitly.
+  """)
+public typealias AnimationTextProvider = LegacyAnimationTextProvider
+
+// MARK: - LegacyAnimationTextProvider
+
+/// Legacy protocol for providing dynamic text for a Lottie animation.
+/// Instead prefer conforming to `AnimationKeypathTextProvider`.
+public protocol LegacyAnimationTextProvider: AnimationKeypathTextProvider {
+  /// Legacy method to look up the text to display for the given keypath.
+  /// Instead, prefer implementing `AnimationKeypathTextProvider.`
+  /// The behavior of this method depends on the current rendering engine:
+  ///  - The Core Animation rendering engine always calls this method
+  ///    with the full keypath (e.g. `MY_LAYER.text_value`).
+  ///  - The Main Thread rendering engine always calls this method
+  ///    with the final component of the key path (e.g. just `text_value`).
+  func textFor(keypathName: String, sourceText: String) -> String
+}
+
+extension LegacyAnimationTextProvider {
+  public func text(for _: AnimationKeypath, sourceText _: String) -> String? {
+    nil
+  }
+}
+
+// MARK: - TextContentsScaleProvider
+
+/// `AnimationKeypathTextProvider` that can additionally customize the content scale of the rendered text
+public protocol TextContentsScaleProvider: AnimationKeypathTextProvider {
+  /// The `contentsScale` value to use when rendering text for the given layer keypath.
+  /// Customizing the `contentsScale` can help reduce aliasing caused by text resizing.
+  func contentsScale(for keypath: AnimationKeypath) -> CGFloat?
+}
+
+// MARK: - DictionaryTextProvider
+
+/// Text provider that simply map values from dictionary.
+///  - The dictionary keys can either be the full layer keypath string (e.g. `MY_LAYER.text_value`)
+///    or simply the final path component of the keypath (e.g. `text_value`).
+public final class DictionaryTextProvider: AnimationKeypathTextProvider, LegacyAnimationTextProvider {
+
+  // MARK: Lifecycle
+
+  public init(_ values: [String: String]) {
+    self.values = values
+  }
+
+  // MARK: Public
+
+  public func text(for keypath: AnimationKeypath, sourceText: String) -> String? {
+    if let valueForFullKeypath = values[keypath.fullPath] {
+      valueForFullKeypath
+    }
+
+    else if
+      let lastKeypathComponent = keypath.keys.last,
+      let valueForLastComponent = values[lastKeypathComponent]
+    {
+      valueForLastComponent
+    }
+
+    else {
+      sourceText
+    }
+  }
+
+  /// Never called directly by Lottie, but we continue to implement this conformance for backwards compatibility.
+  public func textFor(keypathName: String, sourceText: String) -> String {
+    values[keypathName] ?? sourceText
+  }
+
+  // MARK: Internal
+
+  let values: [String: String]
+}
+
+// MARK: Equatable
+
+extension DictionaryTextProvider: Equatable {
+  public static func ==(_ lhs: DictionaryTextProvider, _ rhs: DictionaryTextProvider) -> Bool {
+    lhs.values == rhs.values
+  }
+}
+
+// MARK: - DefaultTextProvider
+
+/// Default text provider. Uses text in the animation file
+public final class DefaultTextProvider: AnimationKeypathTextProvider, LegacyAnimationTextProvider {
+
+  // MARK: Lifecycle
+
+  public init() { }
+
+  // MARK: Public
+
+  public func textFor(keypathName _: String, sourceText: String) -> String {
+    sourceText
+  }
+
+  public func text(for _: AnimationKeypath, sourceText: String) -> String {
+    sourceText
+  }
+}
+
+// MARK: Equatable
+
+extension DefaultTextProvider: Equatable {
+  public static func ==(_: DefaultTextProvider, _: DefaultTextProvider) -> Bool {
+    true
+  }
+}

package/platforms/macos/src/vendor/Lottie/Public/iOS/AnimationSubview.swift

@@ -0,0 +1,19 @@
+//
+//  AnimationSubview.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+#if canImport(UIKit)
+import UIKit
+
+/// A view that can be added to a keypath of an AnimationView
+public final class AnimationSubview: UIView {
+
+  var viewLayer: CALayer? {
+    layer
+  }
+
+}
+#endif

package/platforms/macos/src/vendor/Lottie/Public/iOS/BundleImageProvider.swift

@@ -0,0 +1,98 @@
+//
+//  LottieBundleImageProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+#if canImport(UIKit)
+import UIKit
+
+/// An `AnimationImageProvider` that provides images by name from a specific bundle.
+/// The BundleImageProvider is initialized with a bundle and an optional searchPath.
+public final class BundleImageProvider: AnimationImageProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes an image provider with a bundle and an optional subpath.
+  ///
+  /// Provides images for an animation from a bundle. Additionally the provider can
+  /// search a specific subpath for the images.
+  ///
+  /// - Parameter bundle: The bundle containing images for the provider.
+  /// - Parameter searchPath: The subpath is a path within the bundle to search for image assets.
+  /// - Parameter contentsGravity: The contents gravity to use when rendering the image.
+  ///
+  public init(bundle: Bundle, searchPath: String?, contentsGravity: CALayerContentsGravity = .resize) {
+    self.bundle = bundle
+    self.searchPath = searchPath
+    self.contentsGravity = contentsGravity
+  }
+
+  // MARK: Public
+
+  public func imageForAsset(asset: ImageAsset) -> CGImage? {
+    if let base64Image = asset.base64Image {
+      return base64Image
+    }
+
+    let imagePath: String?
+    /// Try to find the image in the bundle.
+    if let searchPath {
+      /// Search in the provided search path for the image
+      var directoryPath = URL(fileURLWithPath: searchPath)
+      directoryPath.appendPathComponent(asset.directory)
+
+      if let path = bundle.path(forResource: asset.name, ofType: nil, inDirectory: directoryPath.path) {
+        /// First search for the image in the asset provided sub directory.
+        imagePath = path
+      } else if let path = bundle.path(forResource: asset.name, ofType: nil, inDirectory: searchPath) {
+        /// Try finding the image in the search path.
+        imagePath = path
+      } else {
+        imagePath = bundle.path(forResource: asset.name, ofType: nil)
+      }
+    } else {
+      if let path = bundle.path(forResource: asset.name, ofType: nil, inDirectory: asset.directory) {
+        /// First search for the image in the asset provided sub directory.
+        imagePath = path
+      } else {
+        /// First search for the image in bundle.
+        imagePath = bundle.path(forResource: asset.name, ofType: nil)
+      }
+    }
+
+    if imagePath == nil {
+      guard let image = UIImage(named: asset.name, in: bundle, compatibleWith: nil) else {
+        LottieLogger.shared.warn("Could not find image \"\(asset.name)\" in bundle")
+        return nil
+      }
+      return image.cgImage
+    }
+
+    guard let foundPath = imagePath, let image = UIImage(contentsOfFile: foundPath) else {
+      /// No image found.
+      LottieLogger.shared.warn("Could not find image \"\(asset.name)\" in bundle")
+      return nil
+    }
+    return image.cgImage
+  }
+
+  public func contentsGravity(for _: ImageAsset) -> CALayerContentsGravity {
+    contentsGravity
+  }
+
+  // MARK: Internal
+
+  let bundle: Bundle
+  let searchPath: String?
+  let contentsGravity: CALayerContentsGravity
+}
+
+extension BundleImageProvider: Equatable {
+  public static func ==(_ lhs: BundleImageProvider, _ rhs: BundleImageProvider) -> Bool {
+    lhs.bundle == rhs.bundle
+      && lhs.searchPath == rhs.searchPath
+  }
+}
+#endif

package/platforms/macos/src/vendor/Lottie/Public/iOS/Compatibility/CompatibleAnimationKeypath.swift

@@ -0,0 +1,33 @@
+//
+//  CompatibleAnimationKeypath.swift
+//  Lottie_iOS
+//
+//  Created by Tyler Hedrick on 3/6/19.
+//
+
+import Foundation
+#if canImport(UIKit)
+
+/// An Objective-C compatible wrapper around Lottie's AnimationKeypath
+@objc
+public final class CompatibleAnimationKeypath: NSObject {
+
+  // MARK: Lifecycle
+
+  /// Creates a keypath from a dot separated string. The string is separated by "."
+  @objc
+  public init(keypath: String) {
+    animationKeypath = AnimationKeypath(keypath: keypath)
+  }
+
+  /// Creates a keypath from a list of strings.
+  @objc
+  public init(keys: [String]) {
+    animationKeypath = AnimationKeypath(keys: keys)
+  }
+
+  // MARK: Public
+
+  public let animationKeypath: AnimationKeypath
+}
+#endif