Update Transaction implementation (#295)

* Update Transaction implementation

* Update TransactionModifier implementation

* Add documentation for TransactionModifier

* Add TransactionAnimation and move folder

* Fix SwiftPM build issue for release configuration

error: function type mismatch, declared as '@convention(c) (Optional<UnsafeMutableRawPointer>) -> ()' but used as '@convention(thin) (@owned Optional<AnyObject>) -> ()

Author: Kyle-Ye

Package.resolved

@@ -7,7 +7,7 @@
       "location" : "https://github.com/OpenSwiftUIProject/DarwinPrivateFrameworks.git",
       "state" : {
         "branch" : "main",
-        "revision" : "e431e3fd08c3d960639c0c95c998f17d0b0f48f3"
+        "revision" : "2ba5179547b9cefddfd304bbda6d0d0704946fe3"
       }
     },
     {
@@ -25,7 +25,7 @@
       "location" : "https://github.com/OpenSwiftUIProject/OpenGraph",
       "state" : {
         "branch" : "main",
-        "revision" : "5d2296f685b461c53432be78373a5c9a4f80fff3"
+        "revision" : "732ce4507120fbee7bc43ec0c8407f4c3d431811"
       }
     },
     {

Sources/OpenSwiftUICore/Data/State/StoredLocation.swift

@@ -99,8 +99,7 @@ package class StoredLocationBase<Value>: AnyLocation<Value>, Location, @unchecke
         guard shouldCommit else {
             return
         }
-        var newTransaction = transaction
-        newTransaction.override(.current)
+        var newTransaction = transaction.current
         onMainThread { [weak self] in
             guard let self else {
                 return

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

@@ -15,6 +15,21 @@ extension AsyncAttribute {
 
 extension Attribute {
     package func syncMainIfReferences<V>(do body: (Value) -> V) -> V {
-        preconditionFailure("TODO")
+        let (value, flags) = valueAndFlags(options: [._2])
+        if flags.contains(.requiresMainThread) {
+            var result: V?
+            Update.syncMain {
+                result = body(value)
+            }
+            return result!
+        } else {
+            return body(value)
+        }
     }
 }
+
+// FIXME: Add OGChangedValueFlagsRequiresMainThread in OpenGraph
+
+extension OGChangedValueFlags {
+    static let requiresMainThread = Self(rawValue: 2)
+}

Sources/OpenSwiftUICore/OpenGraph/Attribute/AsyncAttribute.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()
+}