Animation Modifier (#117)

* Implement animation modifier

* Do not notify update if the object is already terminated

* Weak capture

Author: ra1028

Sources/Atoms/Atoms.docc/Atoms.md

@@ -30,6 +30,7 @@ Building state by compositing atoms automatically optimizes rendering based on i
 - ``Atom/changes``
 - ``Atom/changes(of:)``
 - ``Atom/phase``
+- ``Atom/animation(_:)``
 
 ### Attributes
 
@@ -75,6 +76,7 @@ Building state by compositing atoms automatically optimizes rendering based on i
 - ``ChangesModifier``
 - ``ChangesOfModifier``
 - ``TaskPhaseModifier``
+- ``AnimationModifier``
 - ``AtomLoader``
 - ``RefreshableAtomLoader``
 - ``AsyncAtomLoader``

Sources/Atoms/Context/AtomTestContext.swift

@@ -321,9 +321,11 @@ public struct AtomTestContext: AtomWatchableContext {
     @inlinable
     @discardableResult
     public func watch<Node: Atom>(_ atom: Node) -> Node.Loader.Value {
-        _store.watch(atom, subscriber: _subscriber, requiresObjectUpdate: true) { [weak _state] in
-            _state?.notifyUpdate()
-        }
+        _store.watch(
+            atom,
+            subscriber: _subscriber,
+            subscription: _subscription
+        )
     }
 
     /// Returns the already cached value associated with a given atom without side effects.
@@ -430,7 +432,7 @@ internal extension AtomTestContext {
         }
 
         @usableFromInline
-        func notifyUpdate() {
+        func update() {
             onUpdate?()
             notifier.send()
         }
@@ -451,6 +453,13 @@ internal extension AtomTestContext {
 
     @usableFromInline
     var _subscriber: Subscriber {
-        Subscriber(_state.subscriberState, location: location)
+        Subscriber(_state.subscriberState)
+    }
+
+    @usableFromInline
+    var _subscription: Subscription {
+        Subscription(location: location) { [weak _state] in
+            _state?.update()
+        }
     }
 }

Sources/Atoms/Context/AtomViewContext.swift

@@ -9,16 +9,16 @@ public struct AtomViewContext: AtomWatchableContext {
     @usableFromInline
     internal let _subscriber: Subscriber
     @usableFromInline
-    internal let _notifyUpdate: () -> Void
+    internal let _subscription: Subscription
 
     internal init(
         store: StoreContext,
         subscriber: Subscriber,
-        notifyUpdate: @escaping () -> Void
+        subscription: Subscription
     ) {
         _store = store
         _subscriber = subscriber
-        _notifyUpdate = notifyUpdate
+        _subscription = subscription
     }
 
     /// Accesses the value associated with the given atom without watching it.
@@ -198,8 +198,7 @@ public struct AtomViewContext: AtomWatchableContext {
         _store.watch(
             atom,
             subscriber: _subscriber,
-            requiresObjectUpdate: false,
-            notifyUpdate: _notifyUpdate
+            subscription: _subscription
         )
     }
 

Sources/Atoms/Core/Loader/AtomLoader.swift

@@ -19,12 +19,19 @@ public protocol AtomLoader {
     /// Returns a boolean value indicating whether it should notify updates downstream
     /// by checking the equivalence of the given old value and new value.
     func shouldUpdate(newValue: Value, oldValue: Value) -> Bool
+
+    /// Performs atom update.
+    func performUpdate(_ body: () -> Void)
 }
 
 public extension AtomLoader {
     func shouldUpdate(newValue: Value, oldValue: Value) -> Bool {
         true
     }
+
+    func performUpdate(_ body: () -> Void) {
+        body()
+    }
 }
 
 /// A loader protocol that represents an actual implementation of the corresponding atom

Sources/Atoms/Core/Loader/AtomLoaderContext.swift

@@ -1,31 +1,35 @@
 /// The context structure to interact with an atom store.
 @MainActor
 public struct AtomLoaderContext<Value, Coordinator> {
-    internal let store: StoreContext
-    internal let transaction: Transaction
-    internal let coordinator: Coordinator
-    internal let update: @MainActor (Value, UpdateOrder) -> Void
+    private let store: StoreContext
+    private let transaction: Transaction
+    private let coordinator: Coordinator
+    private let update: @MainActor (Value) -> Void
 
     internal init(
         store: StoreContext,
         transaction: Transaction,
         coordinator: Coordinator,
-        update: @escaping @MainActor (Value, UpdateOrder) -> Void
+        update: @escaping @MainActor (Value) -> Void
     ) {
         self.store = store
         self.transaction = transaction
         self.coordinator = coordinator
         self.update = update
     }
 
+    internal var isTerminated: Bool {
+        transaction.isTerminated
+    }
+
     internal var modifierContext: AtomModifierContext<Value> {
         AtomModifierContext(transaction: transaction) { value in
             update(with: value)
         }
     }
 
-    internal func update(with value: Value, order: UpdateOrder = .newValue) {
-        update(value, order)
+    internal func update(with value: Value) {
+        update(value)
     }
 
     internal func addTermination(_ termination: @MainActor @escaping () -> Void) {

Sources/Atoms/Core/Loader/ModifiedAtomLoader.swift

@@ -30,6 +30,11 @@ public struct ModifiedAtomLoader<Node: Atom, Modifier: AtomModifier>: AtomLoader
     public func shouldUpdate(newValue: Value, oldValue: Value) -> Bool {
         modifier.shouldUpdate(newValue: newValue, oldValue: oldValue)
     }
+
+    /// Performs atom update.
+    public func performUpdate(_ body: () -> Void) {
+        modifier.performUpdate(body)
+    }
 }
 
 extension ModifiedAtomLoader: RefreshableAtomLoader where Node.Loader: RefreshableAtomLoader, Modifier: RefreshableAtomModifier {

Sources/Atoms/Core/Loader/ObservableObjectAtomLoader.swift

@@ -23,14 +23,18 @@ public struct ObservableObjectAtomLoader<Node: ObservableObjectAtom>: AtomLoader
 
     /// Manage given overridden value updates and cancellations.
     public func manageOverridden(value: Value, context: Context) -> Value {
-        let cancellable = value.objectWillChange.sink { [weak value] _ in
-            guard let value else {
-                return
+        let cancellable = value
+            .objectWillChange
+            .sink { [weak value] _ in
+                // Wait until the object's property is set, because `objectWillChange`
+                // emits an event before the property is updated.
+                RunLoop.main.perform(inModes: [.common]) {
+                    if !context.isTerminated, let value {
+                        context.update(with: value)
+                    }
+                }
             }
 
-            context.update(with: value, order: .objectWillChange)
-        }
-
         context.addTermination(cancellable.cancel)
 
         return value

Sources/Atoms/Core/StoreContext.swift

@@ -1,5 +1,3 @@
-import Foundation
-
 @usableFromInline
 @MainActor
 internal struct StoreContext {
@@ -90,7 +88,7 @@ internal struct StoreContext {
         let key = AtomKey(atom, scopeKey: scopeKey)
 
         if let cache = lookupCache(of: atom, for: key) {
-            update(atom: atom, for: key, value: value, cache: cache, order: .newValue)
+            update(atom: atom, for: key, newValue: value, cache: cache)
         }
     }
 
@@ -101,9 +99,8 @@ internal struct StoreContext {
         let key = AtomKey(atom, scopeKey: scopeKey)
 
         if let cache = lookupCache(of: atom, for: key) {
-            var value = cache.value
-            body(&value)
-            update(atom: atom, for: key, value: value, cache: cache, order: .newValue)
+            let newValue = mutating(cache.value, body)
+            update(atom: atom, for: key, newValue: newValue, cache: cache)
         }
     }
 
@@ -129,18 +126,12 @@ internal struct StoreContext {
     func watch<Node: Atom>(
         _ atom: Node,
         subscriber: Subscriber,
-        requiresObjectUpdate: Bool,
-        notifyUpdate: @escaping () -> Void
+        subscription: Subscription
     ) -> Node.Loader.Value {
         let override = lookupOverride(of: atom)
         let scopeKey = lookupScopeKey(of: atom, isScopedOverriden: override?.isScoped ?? false)
         let key = AtomKey(atom, scopeKey: scopeKey)
         let cache = getCache(of: atom, for: key, override: override)
-        let subscription = Subscription(
-            location: subscriber.location,
-            requiresObjectUpdate: requiresObjectUpdate,
-            notifyUpdate: notifyUpdate
-        )
         let isNewSubscription = subscriber.subscribingKeys.insert(key).inserted
 
         store.state.subscriptions[key, default: [:]].updateValue(subscription, forKey: subscriber.key)
@@ -177,8 +168,8 @@ internal struct StoreContext {
         }
 
         // Notify update unless it's cancelled or terminated by other operations.
-        if !Task.isCancelled && !context.transaction.isTerminated {
-            update(atom: atom, for: key, value: value, cache: cache, order: .newValue)
+        if !Task.isCancelled && !context.isTerminated {
+            update(atom: atom, for: key, newValue: value, cache: cache)
         }
 
         return value
@@ -199,7 +190,7 @@ internal struct StoreContext {
 
         // Notify update unless it's cancelled or terminated by other operations.
         if !Task.isCancelled && !transaction.isTerminated {
-            update(atom: atom, for: key, value: value, cache: cache, order: .newValue)
+            update(atom: atom, for: key, newValue: value, cache: cache)
         }
 
         return value
@@ -214,7 +205,7 @@ internal struct StoreContext {
 
         if let cache = lookupCache(of: atom, for: key) {
             let newCache = makeCache(of: atom, for: key, override: override)
-            update(atom: atom, for: key, value: newCache.value, cache: cache, order: .newValue)
+            update(atom: atom, for: key, newValue: newCache.value, cache: cache)
         }
     }
 
@@ -289,7 +280,7 @@ internal struct StoreContext {
             // Notify updates only for the subscriptions of restored atoms.
             if let subscriptions = store.state.subscriptions[key] {
                 for subscription in ContiguousArray(subscriptions.values) {
-                    subscription.notifyUpdate()
+                    subscription.update()
                 }
             }
         }
@@ -336,54 +327,38 @@ private extension StoreContext {
             store: self,
             transaction: transaction,
             coordinator: state.coordinator
-        ) { value, order in
-            guard let cache = lookupCache(of: atom, for: key) else {
-                return
+        ) { newValue in
+            if let cache = lookupCache(of: atom, for: key) {
+                update(atom: atom, for: key, newValue: newValue, cache: cache)
             }
-
-            update(
-                atom: atom,
-                for: key,
-                value: value,
-                cache: cache,
-                order: order
-            )
         }
     }
 
     func update<Node: Atom>(
         atom: Node,
         for key: AtomKey,
-        value: Node.Loader.Value,
-        cache: AtomCache<Node>,
-        order: UpdateOrder
+        newValue: Node.Loader.Value,
+        cache: AtomCache<Node>
     ) {
         let oldValue = cache.value
 
-        if case .newValue = order {
-            var cache = cache
-            cache.value = value
-            store.state.caches[key] = cache
+        store.state.caches[key] = mutating(cache) {
+            $0.value = newValue
         }
 
-        // Do not notify update if the new value and the old value are equivalent.
-        if !atom._loader.shouldUpdate(newValue: value, oldValue: oldValue) {
+        guard atom._loader.shouldUpdate(newValue: newValue, oldValue: oldValue) else {
             return
         }
 
-        // Notifying update to view subscriptions first.
-        if let subscriptions = store.state.subscriptions[key] {
-            for subscription in ContiguousArray(subscriptions.values) {
-                if case .objectWillChange = order, subscription.requiresObjectUpdate {
-                    RunLoop.current.perform(subscription.notifyUpdate)
-                }
-                else {
-                    subscription.notifyUpdate()
+        atom._loader.performUpdate {
+            // Notifies update to view subscriptions first.
+            if let subscriptions = store.state.subscriptions[key] {
+                for subscription in ContiguousArray(subscriptions.values) {
+                    subscription.update()
                 }
             }
-        }
 
-        func notifyUpdate() {
+            // Notifies update to downstream atoms.
             if let children = store.graph.children[key] {
                 for child in ContiguousArray(children) {
                     // Reset the atom value and then notifies downstream atoms.
@@ -398,21 +373,7 @@ private extension StoreContext {
 
             let state = getState(of: atom, for: key)
             let context = AtomCurrentContext(store: self, coordinator: state.coordinator)
-            atom.updated(newValue: value, oldValue: oldValue, context: context)
-        }
-
-        switch order {
-        case .newValue:
-            notifyUpdate()
-
-        case .objectWillChange:
-            // At the timing when `ObservableObject/objectWillChange` emits, its properties
-            // have not yet been updated and are still old when dependent atoms read it.
-            // As a workaround, the update is executed in the next run loop
-            // so that the downstream atoms can receive the object that's already updated.
-            RunLoop.current.perform {
-                notifyUpdate()
-            }
+            atom.updated(newValue: newValue, oldValue: oldValue, context: context)
         }
     }
 

Sources/Atoms/Core/Subscriber.swift

@@ -4,12 +4,10 @@ internal struct Subscriber {
     private weak var state: SubscriberState?
 
     let key: SubscriberKey
-    let location: SourceLocation
 
-    init(_ state: SubscriberState, location: SourceLocation) {
+    init(_ state: SubscriberState) {
         self.state = state
         self.key = SubscriberKey(token: state.token)
-        self.location = location
     }
 
     var subscribingKeys: Set<AtomKey> {

Sources/Atoms/Core/Subscription.swift

@@ -1,6 +1,6 @@
+@usableFromInline
 @MainActor
 internal struct Subscription {
     let location: SourceLocation
-    let requiresObjectUpdate: Bool
-    let notifyUpdate: () -> Void
+    let update: () -> Void
 }