@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Protocols/AnimatorNode.swift

@@ -0,0 +1,197 @@
+//
+//  AnimatorNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/15/19.
+//
+
+import QuartzCore
+
+// MARK: - NodeOutput
+
+/// Defines the basic outputs of an animator node.
+///
+protocol NodeOutput {
+
+  /// The parent node.
+  var parent: NodeOutput? { get }
+
+  var outputPath: CGPath? { get }
+
+  var isEnabled: Bool { get set }
+
+  /// Returns true if there are any updates upstream. OutputPath must be built before returning.
+  func hasOutputUpdates(_ forFrame: CGFloat) -> Bool
+
+}
+
+// MARK: - AnimatorNode
+
+/// The Animator Node is the base node in the render system tree.
+///
+/// It defines a single node that has an output path and option input node.
+/// At animation time the root animation node is asked to update its contents for
+/// the current frame.
+/// The node reaches up its chain of nodes until the first node that does not need
+/// updating is found. Then each node updates its contents down the render pipeline.
+/// Each node adds its local path to its input path and passes it forward.
+///
+/// An animator node holds a group of interpolators. These interpolators determine
+/// if the node needs an update for the current frame.
+///
+protocol AnimatorNode: AnyObject, KeypathSearchable {
+
+  /// The available properties of the Node.
+  ///
+  /// These properties are automatically updated each frame.
+  /// These properties are also settable and gettable through the dynamic
+  /// property system.
+  ///
+  var propertyMap: NodePropertyMap & KeypathSearchable { get }
+
+  /// The upstream input node
+  var parentNode: AnimatorNode? { get }
+
+  /// The output of the node.
+  var outputNode: NodeOutput { get }
+
+  /// Setters for marking current node state.
+  var isEnabled: Bool { get set }
+  var hasLocalUpdates: Bool { get set }
+  var hasUpstreamUpdates: Bool { get set }
+  var lastUpdateFrame: CGFloat? { get set }
+
+  /// Update the outputs of the node. Called if local contents were update or if outputsNeedUpdate returns true.
+  func rebuildOutputs(frame: CGFloat)
+
+  /// Marks if updates to this node affect nodes downstream.
+  func localUpdatesPermeateDownstream() -> Bool
+  func forceUpstreamOutputUpdates() -> Bool
+
+  /// Called at the end of this nodes update cycle. Always called. Optional.
+  func performAdditionalLocalUpdates(frame: CGFloat, forceLocalUpdate: Bool) -> Bool
+  func performAdditionalOutputUpdates(_ frame: CGFloat, forceOutputUpdate: Bool)
+
+  /// The default simply returns `hasLocalUpdates`
+  func shouldRebuildOutputs(frame: CGFloat) -> Bool
+}
+
+/// Basic Node Logic
+extension AnimatorNode {
+
+  func shouldRebuildOutputs(frame _: CGFloat) -> Bool {
+    hasLocalUpdates
+  }
+
+  func localUpdatesPermeateDownstream() -> Bool {
+    /// Optional override
+    true
+  }
+
+  func forceUpstreamOutputUpdates() -> Bool {
+    /// Optional
+    false
+  }
+
+  func performAdditionalLocalUpdates(frame _: CGFloat, forceLocalUpdate: Bool) -> Bool {
+    /// Optional
+    forceLocalUpdate
+  }
+
+  func performAdditionalOutputUpdates(_: CGFloat, forceOutputUpdate _: Bool) {
+    /// Optional
+  }
+
+  @discardableResult
+  func updateOutputs(_ frame: CGFloat, forceOutputUpdate: Bool) -> Bool {
+    guard isEnabled else {
+      // Disabled node, pass through.
+      lastUpdateFrame = frame
+      return parentNode?.updateOutputs(frame, forceOutputUpdate: forceOutputUpdate) ?? false
+    }
+
+    if forceOutputUpdate == false && lastUpdateFrame != nil && lastUpdateFrame! == frame {
+      /// This node has already updated for this frame. Go ahead and return the results.
+      return hasUpstreamUpdates || hasLocalUpdates
+    }
+
+    /// Ask if this node should force output updates upstream.
+    let forceUpstreamUpdates = forceOutputUpdate || forceUpstreamOutputUpdates()
+
+    /// Perform upstream output updates. Optionally mark upstream updates if any.
+    hasUpstreamUpdates = (
+      parentNode?
+        .updateOutputs(frame, forceOutputUpdate: forceUpstreamUpdates) ?? false || hasUpstreamUpdates
+    )
+
+    /// Perform additional local output updates
+    performAdditionalOutputUpdates(frame, forceOutputUpdate: forceUpstreamUpdates)
+
+    /// If there are local updates, or if updates have been force, rebuild outputs
+    if forceUpstreamUpdates || shouldRebuildOutputs(frame: frame) {
+      lastUpdateFrame = frame
+      rebuildOutputs(frame: frame)
+    }
+    return hasUpstreamUpdates || hasLocalUpdates
+  }
+
+  /// Rebuilds the content of this node, and upstream nodes if necessary.
+  @discardableResult
+  func updateContents(_ frame: CGFloat, forceLocalUpdate: Bool) -> Bool {
+    guard isEnabled else {
+      // Disabled node, pass through.
+      return parentNode?.updateContents(frame, forceLocalUpdate: forceLocalUpdate) ?? false
+    }
+
+    if forceLocalUpdate == false && lastUpdateFrame != nil && lastUpdateFrame! == frame {
+      /// This node has already updated for this frame. Go ahead and return the results.
+      return localUpdatesPermeateDownstream() ? hasUpstreamUpdates || hasLocalUpdates : hasUpstreamUpdates
+    }
+
+    /// Are there local updates? If so mark the node.
+    hasLocalUpdates = forceLocalUpdate ? forceLocalUpdate : propertyMap.needsLocalUpdate(frame: frame)
+
+    /// Were there upstream updates? If so mark the node
+    hasUpstreamUpdates = parentNode?.updateContents(frame, forceLocalUpdate: forceLocalUpdate) ?? false
+
+    /// Perform property updates if necessary.
+    if hasLocalUpdates {
+      /// Rebuild local properties
+      propertyMap.updateNodeProperties(frame: frame)
+    }
+
+    /// Ask the node to perform any other updates it might have.
+    hasUpstreamUpdates = performAdditionalLocalUpdates(frame: frame, forceLocalUpdate: forceLocalUpdate) || hasUpstreamUpdates
+
+    /// If the node can update nodes downstream, notify them, otherwise pass on any upstream updates downstream.
+    return localUpdatesPermeateDownstream() ? hasUpstreamUpdates || hasLocalUpdates : hasUpstreamUpdates
+  }
+
+  func updateTree(_ frame: CGFloat, forceUpdates: Bool = false) {
+    updateContents(frame, forceLocalUpdate: forceUpdates)
+    updateOutputs(frame, forceOutputUpdate: forceUpdates)
+  }
+
+}
+
+extension AnimatorNode {
+  /// Default implementation for Keypath searchable.
+  /// Forward all calls to the propertyMap.
+
+  var keypathName: String {
+    propertyMap.keypathName
+  }
+
+  var keypathProperties: [String: AnyNodeProperty] {
+    propertyMap.keypathProperties
+  }
+
+  var childKeypaths: [KeypathSearchable] {
+    propertyMap.childKeypaths
+  }
+
+  var keypathLayer: CALayer? {
+    nil
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Protocols/PathNode.swift

@@ -0,0 +1,20 @@
+//
+//  PathNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/17/19.
+//
+
+// MARK: - PathNode
+
+protocol PathNode {
+  var pathOutput: PathOutputNode { get }
+}
+
+extension PathNode where Self: AnimatorNode {
+
+  var outputNode: NodeOutput {
+    pathOutput
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Protocols/RenderNode.swift

@@ -0,0 +1,60 @@
+//
+//  RenderNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/17/19.
+//
+
+import QuartzCore
+
+// MARK: - RenderNode
+
+/// A protocol that defines a node that holds render instructions
+protocol RenderNode {
+  var renderer: Renderable & NodeOutput { get }
+}
+
+// MARK: - Renderable
+
+/// A protocol that defines anything with render instructions
+protocol Renderable {
+
+  /// The last frame in which this node was updated.
+  var hasUpdate: Bool { get }
+
+  /// Determines if the renderer requires a custom context for drawing.
+  /// If yes the shape layer will perform a custom drawing pass.
+  /// If no the shape layer will be a standard CAShapeLayer
+  var shouldRenderInContext: Bool { get }
+
+  func hasRenderUpdates(_ forFrame: CGFloat) -> Bool
+
+  /// Passes in the CAShapeLayer to update
+  func updateShapeLayer(layer: CAShapeLayer)
+
+  /// Asks the renderer what the renderable bounds is for the given box.
+  func renderBoundsFor(_ boundingBox: CGRect) -> CGRect
+
+  /// Opportunity for renderers to inject sublayers
+  func setupSublayers(layer: CAShapeLayer)
+
+  /// Renders the shape in a custom context
+  func render(_ inContext: CGContext)
+}
+
+extension RenderNode where Self: AnimatorNode {
+
+  var outputNode: NodeOutput {
+    renderer
+  }
+
+}
+
+extension Renderable {
+
+  func renderBoundsFor(_ boundingBox: CGRect) -> CGRect {
+    /// Optional
+    boundingBox
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/RenderLayers/ShapeContainerLayer.swift

@@ -0,0 +1,78 @@
+//
+//  ShapeContainerLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import QuartzCore
+
+/// The base layer that holds Shapes and Shape Renderers
+class ShapeContainerLayer: CALayer {
+
+  // MARK: Lifecycle
+
+  override init() {
+    super.init()
+    actions = [
+      "position": NSNull(),
+      "bounds": NSNull(),
+      "anchorPoint": NSNull(),
+      "transform": NSNull(),
+      "opacity": NSNull(),
+      "hidden": NSNull(),
+    ]
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  override init(layer: Any) {
+    guard let layer = layer as? ShapeContainerLayer else {
+      fatalError("init(layer:) wrong class.")
+    }
+    super.init(layer: layer)
+  }
+
+  // MARK: Internal
+
+  private(set) var renderLayers = [ShapeContainerLayer]()
+
+  var renderScale: CGFloat = 1 {
+    didSet {
+      updateRenderScale()
+    }
+  }
+
+  func insertRenderLayer(_ layer: ShapeContainerLayer) {
+    renderLayers.append(layer)
+    insertSublayer(layer, at: 0)
+  }
+
+  func markRenderUpdates(forFrame: CGFloat) {
+    if hasRenderUpdate(forFrame: forFrame) {
+      rebuildContents(forFrame: forFrame)
+    }
+    guard isHidden == false else { return }
+    for renderLayer in renderLayers {
+      renderLayer.markRenderUpdates(forFrame: forFrame)
+    }
+  }
+
+  func hasRenderUpdate(forFrame _: CGFloat) -> Bool {
+    false
+  }
+
+  func rebuildContents(forFrame _: CGFloat) {
+    /// Override
+  }
+
+  func updateRenderScale() {
+    contentsScale = renderScale
+    for renderLayer in renderLayers {
+      renderLayer.renderScale = renderScale
+    }
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/RenderLayers/ShapeRenderLayer.swift

@@ -0,0 +1,98 @@
+//
+//  RenderLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/18/19.
+//
+
+import QuartzCore
+
+/// The layer responsible for rendering shape objects
+final class ShapeRenderLayer: ShapeContainerLayer {
+
+  // MARK: Lifecycle
+
+  init(renderer: Renderable & NodeOutput) {
+    self.renderer = renderer
+    super.init()
+    anchorPoint = .zero
+    actions = [
+      "position": NSNull(),
+      "bounds": NSNull(),
+      "anchorPoint": NSNull(),
+      "path": NSNull(),
+      "transform": NSNull(),
+      "opacity": NSNull(),
+      "hidden": NSNull(),
+    ]
+    shapeLayer.actions = [
+      "position": NSNull(),
+      "bounds": NSNull(),
+      "anchorPoint": NSNull(),
+      "path": NSNull(),
+      "fillColor": NSNull(),
+      "strokeColor": NSNull(),
+      "lineWidth": NSNull(),
+      "miterLimit": NSNull(),
+      "lineDashPhase": NSNull(),
+      "opacity": NSNull(),
+      "hidden": NSNull(),
+    ]
+    addSublayer(shapeLayer)
+
+    renderer.setupSublayers(layer: shapeLayer)
+  }
+
+  override init(layer: Any) {
+    guard let layer = layer as? ShapeRenderLayer else {
+      fatalError("init(layer:) wrong class.")
+    }
+    renderer = layer.renderer
+    super.init(layer: layer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  fileprivate(set) var renderer: Renderable & NodeOutput
+
+  let shapeLayer = CAShapeLayer()
+
+  override func hasRenderUpdate(forFrame: CGFloat) -> Bool {
+    isHidden = !renderer.isEnabled
+    guard isHidden == false else { return false }
+    return renderer.hasRenderUpdates(forFrame)
+  }
+
+  override func rebuildContents(forFrame _: CGFloat) {
+    if renderer.shouldRenderInContext {
+      if let newPath = renderer.outputPath {
+        bounds = renderer.renderBoundsFor(newPath.boundingBox)
+      } else {
+        bounds = .zero
+      }
+      position = bounds.origin
+      setNeedsDisplay()
+    } else {
+      shapeLayer.path = renderer.outputPath
+      renderer.updateShapeLayer(layer: shapeLayer)
+    }
+  }
+
+  override func draw(in ctx: CGContext) {
+    if let path = renderer.outputPath {
+      if !path.isEmpty {
+        ctx.addPath(path)
+      }
+    }
+    renderer.render(ctx)
+  }
+
+  override func updateRenderScale() {
+    super.updateRenderScale()
+    shapeLayer.contentsScale = renderScale
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/Model/Assets/Asset.swift

@@ -0,0 +1,51 @@
+//
+//  Asset.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+// MARK: - Asset
+
+/// Base class assets defined in Lottie manifests
+public class Asset: Codable, DictionaryInitializable {
+
+  // MARK: Lifecycle
+
+  required public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: Asset.CodingKeys.self)
+    if let id = try? container.decode(String.self, forKey: .id) {
+      self.id = id
+    } else {
+      id = String(try container.decode(Int.self, forKey: .id))
+    }
+  }
+
+  required init(dictionary: [String: Any]) throws {
+    if let id = dictionary[CodingKeys.id.rawValue] as? String {
+      self.id = id
+    } else if let id = dictionary[CodingKeys.id.rawValue] as? Int {
+      self.id = String(id)
+    } else {
+      throw InitializableError.invalidInput()
+    }
+  }
+
+  // MARK: Public
+
+  /// The ID of the asset
+  public let id: String
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case id
+  }
+}
+
+// MARK: @unchecked Sendable
+
+/// Since `Asset` isn't `final`, we have to use `@unchecked Sendable` instead of `Sendable.`
+/// All `Asset` subclasses are immutable `Sendable` values.
+// swiftlint:disable:next no_unchecked_sendable
+extension Asset: @unchecked Sendable { }

package/platforms/macos/src/vendor/Lottie/Private/Model/Assets/AssetLibrary.swift

@@ -0,0 +1,75 @@
+//
+//  AssetLibrary.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+final class AssetLibrary: Codable, AnyInitializable, Sendable {
+
+  // MARK: Lifecycle
+
+  required init(from decoder: Decoder) throws {
+    var container = try decoder.unkeyedContainer()
+    var containerForKeys = container
+
+    var decodedAssets = [String: Asset]()
+
+    var imageAssets = [String: ImageAsset]()
+    var precompAssets = [String: PrecompAsset]()
+
+    while
+      !container.isAtEnd,
+      let keyContainer = try? containerForKeys.nestedContainer(keyedBy: PrecompAsset.CodingKeys.self)
+    {
+      if
+        keyContainer.contains(.layers),
+        let precompAsset = try? container.decode(PrecompAsset.self)
+      {
+        decodedAssets[precompAsset.id] = precompAsset
+        precompAssets[precompAsset.id] = precompAsset
+      } else if let imageAsset = try? container.decode(ImageAsset.self) {
+        decodedAssets[imageAsset.id] = imageAsset
+        imageAssets[imageAsset.id] = imageAsset
+      }
+    }
+    assets = decodedAssets
+    self.precompAssets = precompAssets
+    self.imageAssets = imageAssets
+  }
+
+  init(value: Any) throws {
+    guard let dictionaries = value as? [[String: Any]] else {
+      throw InitializableError.invalidInput()
+    }
+    var decodedAssets = [String: Asset]()
+    var imageAssets = [String: ImageAsset]()
+    var precompAssets = [String: PrecompAsset]()
+    for dictionary in dictionaries {
+      if dictionary[PrecompAsset.CodingKeys.layers.rawValue] != nil {
+        let asset = try PrecompAsset(dictionary: dictionary)
+        decodedAssets[asset.id] = asset
+        precompAssets[asset.id] = asset
+      } else if let asset = try? ImageAsset(dictionary: dictionary) {
+        decodedAssets[asset.id] = asset
+        imageAssets[asset.id] = asset
+      }
+    }
+    assets = decodedAssets
+    self.precompAssets = precompAssets
+    self.imageAssets = imageAssets
+  }
+
+  // MARK: Internal
+
+  /// The Assets
+  let assets: [String: Asset]
+
+  let imageAssets: [String: ImageAsset]
+  let precompAssets: [String: PrecompAsset]
+
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.unkeyedContainer()
+    try container.encode(contentsOf: Array(assets.values))
+  }
+}