improved animation control (#30)

* tighter grip on transactions

* animation completion tracking

* fixed animation tracking

* more animation completion tracking

* formatting

* build with 6.2.1

Author: sliemeobn

.github/workflows/ci-examples.yaml

@@ -19,9 +19,9 @@ jobs:
     strategy:
       matrix:
         swift:
-          - image: swift:6.2
-            wask-sdk-url: https://download.swift.org/swift-6.2-release/wasm/swift-6.2-RELEASE/swift-6.2-RELEASE_wasm.artifactbundle.tar.gz
-            wasm-sdk-checksum: fe4e8648309fce86ea522e9e0d1dc48e82df6ba6e5743dbf0c53db8429fb5224
+          - image: swift:6.2.1
+            wask-sdk-url: https://download.swift.org/swift-6.2.1-release/wasm-sdk/swift-6.2.1-RELEASE/swift-6.2.1-RELEASE_wasm.artifactbundle.tar.gz
+            wasm-sdk-checksum: 482b9f95462b87bedfafca94a092cf9ec4496671ca13b43745097122d20f18af
         examples:
           - Examples/Swiftle
           - Examples/Basic

.swift-version

@@ -1 +1 @@
-6.2.0
+6.2.1

Examples/Basic/Sources/App/AnimationsView.swift

@@ -15,7 +15,7 @@ struct AnimationsView {
             div(.style(["display": "flex", "flex-direction": "row", "gap": "10px"])) {
                 button { "Animate" }
                     .onClick { _ in
-                        withAnimation(.smooth) {
+                        withAnimation(.bouncy) {
                             angle += 1
                             isBallFading.toggle()
                         }

Examples/Basic/Sources/App/Views.swift

@@ -29,20 +29,16 @@ struct App {
         div {
             for _ in 0..<bindingViewCount {
                 BindingsView()
-                    .transition(.fade)
+                    .transition(.fade, animation: .bouncy)
             }
             button { "Add bindings view" }
                 .onClick { _ in
-                    withAnimation {
-                        bindingViewCount += 1
-                    }
+                    bindingViewCount += 1
                 }
             button { "Remove bindings view" }
                 .onClick { _ in
                     guard bindingViewCount > 0 else { return }
-                    withAnimation {
-                        bindingViewCount -= 1
-                    }
+                    bindingViewCount -= 1
                 }
         }
         hr()

Sources/ElementaryDOM/Animation/AnimatedValue.swift

@@ -1,38 +1,32 @@
-struct AnimationInstance {
-    struct TrackingReference {
-        let instanceID: AnimationTracker.InstanceID
-        let tracker: AnimationTracker
-    }
-
-    let startTime: Double
+private struct RunningAnimation {
+    let trackedInstance: AnimationTracker.Instance?
     let animation: Animation
-    let trackingReference: TrackingReference?
+    let startTime: Double
+    let target: AnimatableVector
+    var context: AnimationContext
+    var hasLogicallyCompleted: Bool = false
 
-    init(startTime: Double, animation: Animation, trackingReference: TrackingReference? = nil) {
-        self.startTime = startTime
-        self.animation = animation
-        self.trackingReference = trackingReference
-    }
+    mutating func animate(time: Double, additionalVector: AnimatableVector?) -> (AnimatableVector, Bool)? {
+        let result: AnimatableVector?
 
-    func reportLogicallyComplete() {
-        trackingReference?.tracker.reportLogicallyComplete(trackingReference!.instanceID)
-    }
+        let before = context.isLogicallyComplete
 
-    func reportRemoved() {
-        trackingReference?.tracker.reportRemoved(trackingReference!.instanceID)
-    }
-}
-
-private struct RunningAnimation {
-    let instance: AnimationInstance
-    let target: AnimatableVector
-
-    borrowing func animate(time: Double, context: inout AnimationContext, additionalVector: AnimatableVector?) -> AnimatableVector? {
         if let additionalVector {
-            instance.animation.animate(value: target + additionalVector, time: time - instance.startTime, context: &context)
+            result = animation.animate(value: target + additionalVector, time: time - startTime, context: &context)
         } else {
-            instance.animation.animate(value: target, time: time - instance.startTime, context: &context)
+            result = animation.animate(value: target, time: time - startTime, context: &context)
         }
+
+        return result.map { ($0, !before && context.isLogicallyComplete) }
+    }
+
+    mutating func reportRemoved() {
+        // TODO: maybe make this non-copyable and have a consuming remove func
+        trackedInstance?.reportRemoved()
+    }
+
+    mutating func reportLogicallyComplete() {
+        trackedInstance?.reportLogicallyComplete()
     }
 }
 
@@ -42,7 +36,6 @@ struct AnimatedValue<Value: AnimatableVectorConvertible>: ~Copyable {
     private var currentAnimationValue: Value
 
     private var animationBase: AnimatableVector
-    private var context: AnimationContext
 
     var model: Value { borrowing get { currentTarget } }
     var presentation: Value { borrowing get { currentAnimationValue } }
@@ -52,50 +45,76 @@ struct AnimatedValue<Value: AnimatableVectorConvertible>: ~Copyable {
         self.animationBase = value.animatableVector
         self.currentTarget = value
         self.currentAnimationValue = value
-        self.context = AnimationContext()
     }
 
     mutating func setValue(_ value: Value) {
         self.animationBase = value.animatableVector
         self.currentTarget = value
         self.currentAnimationValue = value
+        if !runningAnimations.isEmpty {
+            removeAnimations(upThrough: runningAnimations.endIndex - 1, skipBaseUpdate: true)
+        }
+    }
 
-        removeAnimations(upThrough: runningAnimations.endIndex - 1, skipBaseUpdate: true)
+    mutating func cancelAnimation() {
+        guard isAnimating else { return }
+
+        // setting value cancels all animations
+        setValue(currentTarget)
     }
 
-    mutating func animate(to value: Value, animation: AnimationInstance) {
-        self.progressToTime(animation.startTime)
+    mutating func animate(to value: Value, startTime: Double, animation: Animation, tracker: AnimationTracker? = nil) {
+
+        self.progressToTime(startTime)
         var animationTarget = value.animatableVector - currentTarget.animatableVector
+        var context = AnimationContext()
 
         if let previous = runningAnimations.last {
-            let elapsedTime = animation.startTime - previous.instance.startTime
-            let shouldMerge = animation.animation.shouldMerge(
-                previous: previous.instance.animation,
+            var previousContext = previous.context
+            let elapsedTime = startTime - previous.startTime
+            let shouldMerge = animation.shouldMerge(
+                previous: previous.animation,
                 value: previous.target,
                 time: elapsedTime,
-                context: &context
+                context: &previousContext
             )
 
             if shouldMerge {
                 self.animationBase = currentAnimationValue.animatableVector
                 self.removeAnimations(upThrough: runningAnimations.endIndex - 1, skipBaseUpdate: true)
                 animationTarget = value.animatableVector - self.animationBase
+                context = previousContext
+                // FIXME: this feels very hacky....
+                context.isLogicallyComplete = false
             }
         }
 
         self.currentTarget = value
-        runningAnimations.append(RunningAnimation(instance: animation, target: animationTarget))
+        runningAnimations.append(
+            RunningAnimation(
+                trackedInstance: tracker?.addAnimation(),
+                animation: animation,
+                startTime: startTime,
+                target: animationTarget,
+                context: context
+            )
+        )
     }
 
     mutating func progressToTime(_ time: Double) {
         guard isAnimating else { return }
 
-        let (animatedVector, finishedAnimationIndex) = calculateAnimationAtTime(
+        let (animatedVector, completedIndexes, finishedAnimationIndex) = calculateAnimationAtTime(
             time,
-            runningAnimations: runningAnimations,
-            context: &context
+            runningAnimations: &runningAnimations[...],
         )
 
+        // Report logical completion for any animations that became logically complete at this time.
+        // This must happen here (mutating path), not inside calculateAnimationAtTime, so peeking stays non-mutating.
+        for index in completedIndexes {
+            runningAnimations[index].reportLogicallyComplete()
+        }
+
         if let finishedAnimationIndex {
             removeAnimations(upThrough: finishedAnimationIndex)
         }
@@ -109,42 +128,52 @@ struct AnimatedValue<Value: AnimatableVectorConvertible>: ~Copyable {
         }
     }
 
-    // TODO: figure out the shape for this
-    func peekFutureValues(_ times: StrideThrough<Double>) -> [Value] {
+    // TODO: this can't be the best shape of this function...
+    func peekFutureValuesUnlessCompletedOrFinished(_ times: StrideThrough<Double>) -> [Value] {
         var results: [Value] = []
-        var contextCopy = context
         var runningAnimations = runningAnimations[...]
         var base = animationBase
 
         results.reserveCapacity(times.underestimatedCount)
 
         for time in times {
-            let (animatedVector, completedIndex) = calculateAnimationAtTime(
+            var shouldBailEarly = false
+
+            let (animatedVector, completedIndexes, removedUpToIndex) = calculateAnimationAtTime(
                 time,
-                runningAnimations: runningAnimations,
-                context: &contextCopy
+                runningAnimations: &runningAnimations,
             )
 
-            if let completedIndex {
-                for i in runningAnimations.startIndex...completedIndex {
+            if !completedIndexes.isEmpty {
+                shouldBailEarly = true
+            }
+
+            if let removedUpToIndex {
+                for i in runningAnimations.startIndex...removedUpToIndex {
                     base += runningAnimations[i].target
                 }
-                runningAnimations = runningAnimations[(completedIndex + 1)...]
+                runningAnimations = runningAnimations[(removedUpToIndex + 1)...]
+                shouldBailEarly = true
             }
 
             if runningAnimations.isEmpty {
                 results.append(self.currentTarget)
-                break
+                shouldBailEarly = true
+            } else {
+                results.append(Value(base + animatedVector))
             }
 
-            results.append(Value(base + animatedVector))
+            if shouldBailEarly {
+                break
+            }
         }
         return results
     }
 
     private mutating func removeAnimations(upThrough index: Int, skipBaseUpdate: Bool = false) {
         for i in 0...index {
-            runningAnimations[i].instance.reportRemoved()
+            // NOTE: completion is triggered automatically on removal, no extra handling needed here
+            runningAnimations[i].reportRemoved()
             if !skipBaseUpdate {
                 self.animationBase += runningAnimations[i].target
             }
@@ -153,22 +182,22 @@ struct AnimatedValue<Value: AnimatableVectorConvertible>: ~Copyable {
     }
 }
 
-private func calculateAnimationAtTime<AnimationList>(
+private func calculateAnimationAtTime(
     _ time: Double,
-    runningAnimations: AnimationList,
-    context: inout AnimationContext,
-) -> (animatedVector: AnimatableVector, finishedAnimationIndex: AnimationList.Index?)
-where AnimationList: Collection<RunningAnimation> {
+    runningAnimations: inout ArraySlice<RunningAnimation>
+) -> (animatedVector: AnimatableVector, completedIndexes: [Int], finishedAnimationIndex: Int?) {
     guard runningAnimations.count > 1 else {
         assert(runningAnimations.first != nil, "Running animations should not be empty")
-        if let vector = runningAnimations.first!.animate(time: time, context: &context, additionalVector: nil) {
-            return (vector, nil)
+        let index = runningAnimations.startIndex
+        if let (vector, logicallyCompleted) = runningAnimations[index].animate(time: time, additionalVector: nil) {
+            return (vector, logicallyCompleted ? [index] : [], nil)
         } else {
-            return (runningAnimations.first!.target, runningAnimations.indices.first)
+            return (runningAnimations[0].target, [], index)
         }
     }
 
-    var finishedAnimationIndex: AnimationList.Index?
+    var finishedAnimationIndex: Int?
+    var completedIndexes: [Int] = []
     var index = runningAnimations.startIndex
 
     let zero = AnimatableVector.zero(runningAnimations.first!.target)
@@ -177,11 +206,12 @@ where AnimationList: Collection<RunningAnimation> {
     var carryOverVector = zero
 
     while index < runningAnimations.endIndex {
-        let runningAnimation = runningAnimations[index]
-
-        if let vector = runningAnimation.animate(time: time, context: &context, additionalVector: carryOverVector) {
+        if let (vector, logicallyCompleted) = runningAnimations[index].animate(time: time, additionalVector: carryOverVector) {
             totalAnimationVector += vector
-            carryOverVector = runningAnimation.target - vector
+            carryOverVector = runningAnimations[index].target - vector
+            if logicallyCompleted {
+                completedIndexes.append(index)
+            }
         } else {
             finishedAnimationIndex = index
             //totalAnimationVector = zero
@@ -191,7 +221,7 @@ where AnimationList: Collection<RunningAnimation> {
         runningAnimations.formIndex(after: &index)
     }
 
-    return (totalAnimationVector, finishedAnimationIndex)
+    return (totalAnimationVector, completedIndexes, finishedAnimationIndex)
 }
 
 internal extension AnimatedValue {
@@ -200,8 +230,15 @@ internal extension AnimatedValue {
 
         let wasAnimating = isAnimating
 
-        if let animation = context.transaction?.newAnimation(at: context.currentFrameTime) {
-            self.animate(to: value, animation: animation)
+        if !context.transaction.disablesAnimation,
+            let animation = context.transaction.animation
+        {
+            self.animate(
+                to: value,
+                startTime: context.currentFrameTime,
+                animation: animation,
+                tracker: context.transaction._animationTracker
+            )
         } else {
             self.setValue(value)
         }

Sources/ElementaryDOM/Animation/Animation.swift

@@ -92,6 +92,7 @@ public extension Animation {
 
 public struct AnimationContext {
     var initialVelocity: AnimatableVector?
+    var isLogicallyComplete: Bool = false
     //TODO: provide container for custom values
 }