Add TransactionAnimation and move folder

Author: Kyle-Ye

Sources/OpenSwiftUICore/Data/Transaction/Transaction+Animation.swift

@@ -0,0 +1,102 @@
+//
+//  TransactionAnimation.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: Complete
+//  ID: 39EC6D46662E6D7A6963F5C611934B0A (SwiftUI)
+//  ID: D98E9A1069CEEADA58829ED440E36F30 (SwiftUICore)
+
+extension Transaction {
+    /// Creates a transaction and assigns its animation property.
+    ///
+    /// - Parameter animation: The animation to perform when the current state
+    ///   changes.
+    public init(animation: Animation?) {
+        self.init()
+        self.animation = animation
+    }
+    
+    /// The animation, if any, associated with the current state change.
+    public var animation: Animation? {
+        get { self[AnimationKey.self] }
+        set { self[AnimationKey.self] = newValue }
+    }
+
+    package var effectiveAnimation: Animation? {
+        animation ?? (tracksVelocity ? .velocityTracking : nil)
+    }
+
+    package var _animationFrameInterval: Double? {
+        get { self[AnimationFrameIntervalKey.self] }
+        set { self[AnimationFrameIntervalKey.self] = newValue }
+    }
+
+    package var _animationReason: UInt32? {
+        get { self[AnimationReasonKey.self] }
+        set { self[AnimationReasonKey.self] = newValue }
+    }
+
+    package var isAnimated: Bool {
+        guard let animation,
+              !disablesAnimations else {
+            return false
+        }
+        return true
+    }
+
+    /// A Boolean value that indicates whether views should disable animations.
+    ///
+    /// This value is `true` during the initial phase of a two-part transition
+    /// update, to prevent ``View/animation(_:)`` from inserting new animations
+    /// into the transaction.
+    public var disablesAnimations: Bool {
+        get { self[DisablesAnimationsKey.self] }
+        set { self[DisablesAnimationsKey.self] = newValue }
+    }
+
+    package var disablesContentTransitions: Bool {
+        get { self[DisablesContentTransactionKey.self] }
+        set { self[DisablesContentTransactionKey.self] = newValue }
+      }
+
+    package mutating func disableAnimations() {
+        animation = nil
+        disablesAnimations = true
+    }
+
+    package var animationIgnoringTransitionPhase: Animation? {
+        guard disablesAnimations else {
+            return animation
+        }
+        var result: Animation?
+        forEach(keyType: AnimationKey.self) { animation, stop in
+            guard let animation else {
+                return
+            }
+            result = animation
+            stop = true
+        }
+        return result
+    }
+}
+
+private struct AnimationKey: TransactionKey {
+    static var defaultValue: Animation? { nil }
+}
+
+private struct DisablesAnimationsKey: TransactionKey {
+    static var defaultValue: Bool { false }
+}
+
+private struct AnimationFrameIntervalKey: TransactionKey {
+    static var defaultValue: Double? { nil }
+}
+
+private struct AnimationReasonKey: TransactionKey {
+    static var defaultValue: UInt32? { nil }
+}
+
+private struct DisablesContentTransactionKey: TransactionKey {
+    static var defaultValue: Bool { false }
+}

Sources/OpenSwiftUICore/Animation/AnimatableArray.swift renamed to Sources/OpenSwiftUICore/View/Animation/Animation/AnimatableArray.swift

@@ -0,0 +1,55 @@
+//
+//  VelocityTrackingAnimation.swift
+//  OpenSwiftUICore
+//
+//  Audited for iOS 18.0
+//  Status: WIP
+//  ID: FD9125BC1E04E33D1D7BE4A31225AA98 (SwiftUICore)
+
+// MARK: - TracksVelocityKey
+
+private struct TracksVelocityKey: TransactionKey {
+    static var defaultValue: Bool { false }
+}
+
+extension Transaction {
+    /// Whether this transaction will track the velocity of any animatable
+    /// properties that change.
+    ///
+    /// This property can be enabled in an interactive context to track velocity
+    /// during a user interaction so that when the interaction ends, an
+    /// animation can use the accumulated velocities to create animations that
+    /// preserve them. This tracking is mutually exclusive with an animation
+    /// being used during a view change, since if there is an animation, it is
+    /// responsible for managing its own velocity.
+    ///
+    /// Gesture onChanged and updating callbacks automatically set this property
+    /// to true.
+    ///
+    /// This example shows an interaction which applies changes, tracking
+    /// velocity until the final change, which applies an animation (which will
+    /// start with the velocity that was tracked during the previous changes).
+    /// These changes could come from a server or from an interactive control
+    /// like a slider.
+    ///
+    ///     func receiveChange(change: ChangeInfo) {
+    ///         var transaction = Transaction()
+    ///         if change.isFinal {
+    ///             transaction.animation = .spring
+    ///         } else {
+    ///             transaction.tracksVelocity = true
+    ///         }
+    ///         withTransaction(transaction) {
+    ///             state.applyChange(change)
+    ///         }
+    ///     }
+    public var tracksVelocity: Bool {
+        get { self[TracksVelocityKey.self] }
+        set { self[TracksVelocityKey.self] = newValue }
+    }
+}
+
+extension Animation {
+    // FIXME: VelocityTrackingAnimation
+    static let velocityTracking: Animation = Animation()
+}