Converge successive updates of an ObservableObject to a single update

Sources/Atoms/Atom/ObservableObjectAtom.swift

@@ -70,19 +70,22 @@ public extension ObservableObjectAtom {
         AtomProducer { context in
             context.transaction(object)
         } manageValue: { object, context in
+            var task: Task<Void, Never>?
             let cancellable = object
                 .objectWillChange
                 .sink { [weak object] _ in
                     // Wait until the object's property is set, because `objectWillChange`
                     // emits an event before the property is updated.
-                    Task { @MainActor in
-                        if !context.isTerminated, let object {
+                    task?.cancel()
+                    task = Task { @MainActor in
+                        if let object, !Task.isCancelled, !context.isTerminated {
                             context.update(with: object)
                         }
                     }
                 }
 
             context.onTermination = {
+                task?.cancel()
                 cancellable.cancel()
             }
         }

Tests/AtomsTests/Atom/ObservableObjectAtomTests.swift

@@ -116,4 +116,44 @@ final class ObservableObjectAtomTests: XCTestCase {
         XCTAssertEqual(effect.updatedCount, 3)
         XCTAssertEqual(effect.releasedCount, 1)
     }
+
+    @MainActor
+    func testUpdateMultipletimes() async {
+        final class TestObject: ObservableObject {
+            @Published
+            var value0 = 0
+            @Published
+            var value1 = 0
+
+            func update() {
+                value0 += 1
+                value1 += 1
+            }
+        }
+
+        struct TestAtom: ObservableObjectAtom, Hashable {
+            func object(context: Context) -> TestObject {
+                TestObject()
+            }
+        }
+
+        let atom = TestAtom()
+        let context = AtomTestContext()
+        let object = context.watch(atom)
+        var updatedCount = 0
+
+        context.onUpdate = {
+            updatedCount += 1
+        }
+
+        object.update()
+
+        await context.wait(for: atom) {
+            $0.value0 == 1 && $0.value1 == 1
+        }
+
+        XCTAssertEqual(updatedCount, 1)
+        XCTAssertEqual(object.value0, 1)
+        XCTAssertEqual(object.value1, 1)
+    }
 }