Add initializing lifecycle hook to AtomEffect

README.md

@@ -1403,7 +1403,8 @@ You can create custom effects that conform to the [`AtomEffect`](https://ra1028.
 
 |API|Use|
 |:--|:--|
-|[InitializeEffect](https://ra1028.github.io/swiftui-atom-properties/documentation/atoms/initializeeffect)|Performs an arbitrary action when the atom is initialized.|
+|[InitializingEffect](https://ra1028.github.io/swiftui-atom-properties/documentation/atoms/initializingeffect)|Performs an arbitrary action before the atom is initialized.|
+|[InitializeEffect](https://ra1028.github.io/swiftui-atom-properties/documentation/atoms/initializeeffect)|Performs an arbitrary action after the atom is initialized.|
 |[UpdateEffect](https://ra1028.github.io/swiftui-atom-properties/documentation/atoms/updateeffect)|Performs an arbitrary action when the atom is updated.|
 |[ReleaseEffect](https://ra1028.github.io/swiftui-atom-properties/documentation/atoms/releaseeffect)|Performs an arbitrary action when the atom is released.|
 |[MergedEffect](https://ra1028.github.io/swiftui-atom-properties/documentation/atoms/mergedeffect)|Merges multiple atom effects into one.|

Sources/Atoms/Atoms.docc/Atoms.md

@@ -37,6 +37,7 @@ Building state by compositing atoms automatically optimizes rendering based on i
 ### Effects
 
 - ``AtomEffect``
+- ``InitializingEffect``
 - ``InitializeEffect``
 - ``UpdateEffect``
 - ``ReleaseEffect``

Sources/Atoms/Core/StoreContext.swift

@@ -279,14 +279,15 @@ private extension StoreContext {
         for key: AtomKey,
         override: Override<Node>?
     ) -> Node.Produced {
-        let value = getValue(of: atom, for: key, override: override)
         let state = getState(of: atom, for: key)
+        let currentContext = AtomCurrentContext(store: self)
+
+        state.effect.initializing(context: currentContext)
 
+        let value = getValue(of: atom, for: key, override: override)
         store.state.caches[key] = AtomCache(atom: atom, value: value, initializedScope: currentScope)
 
-        let currentContext = AtomCurrentContext(store: self)
         state.effect.initialized(context: currentContext)
-
         return value
     }
 

Sources/Atoms/Effect/AtomEffect.swift

@@ -4,6 +4,7 @@
 /// initialized the first time the atom is used, and the instance will be retained
 /// until the atom is released, thus it allows to declare stateful side effects.
 ///
+/// SeeAlso: ``InitializingEffect``
 /// SeeAlso: ``InitializeEffect``
 /// SeeAlso: ``UpdateEffect``
 /// SeeAlso: ``ReleaseEffect``
@@ -14,8 +15,12 @@ public protocol AtomEffect {
     /// with other atoms.
     typealias Context = AtomCurrentContext
 
-    /// A lifecycle event that is triggered when the atom is first used and initialized,
-    /// or once it is released and re-initialized again.
+    /// A lifecycle event that is triggered before the atom is first used and initialized,
+    /// or once it is released and re-initialized.
+    func initializing(context: Context)
+
+    /// A lifecycle event that is triggered after the atom is first used and initialized,
+    /// or once it is released and re-initialized.
     func initialized(context: Context)
 
     /// A lifecycle event that is triggered when the atom is updated.
@@ -26,6 +31,7 @@ public protocol AtomEffect {
 }
 
 public extension AtomEffect {
+    func initializing(context: Context) {}
     func initialized(context: Context) {}
     func updated(context: Context) {}
     func released(context: Context) {}

Sources/Atoms/Effect/InitializeEffect.swift

@@ -1,15 +1,15 @@
-/// An atom effect that performs an arbitrary action when the atom is first used and initialized,
-/// or once it is released and re-initialized again.
+/// An atom effect that performs an arbitrary action after the atom is first used and initialized,
+/// or once it is released and re-initialized.
 public struct InitializeEffect: AtomEffect {
     private let action: @MainActor () -> Void
 
-    /// Creates an atom effect that performs the given action when the atom is initialized.
+    /// Creates an atom effect that performs the given action after the atom is initialized.
     public init(perform action: @MainActor @escaping () -> Void) {
         self.action = action
     }
 
-    /// A lifecycle event that is triggered when the atom is first used and initialized,
-    /// or once it is released and re-initialized again.
+    /// A lifecycle event that is triggered after the atom is first used and initialized,
+    /// or once it is released and re-initialized.
     public func initialized(context: Context) {
         action()
     }

Sources/Atoms/Effect/InitializingEffect.swift

@@ -0,0 +1,16 @@
+/// An atom effect that performs an arbitrary action before the atom is first used and initialized,
+/// or once it is released and re-initialized.
+public struct InitializingEffect: AtomEffect {
+    private let action: @MainActor () -> Void
+
+    /// Creates an atom effect that performs the given action before the atom is initialized.
+    public init(perform action: @MainActor @escaping () -> Void) {
+        self.action = action
+    }
+
+    /// A lifecycle event that is triggered before the atom is first used and initialized,
+    /// or once it is released and re-initialized.
+    public func initializing(context: Context) {
+        action()
+    }
+}

Tests/AtomsTests/Core/StoreContextTests.swift

@@ -1157,13 +1157,15 @@ final class StoreContextTests: XCTestCase {
         _ = context.watch(upstreamAtom, in: TransactionState(key: key))
 
         XCTAssertTrue((store.state.states[key]?.effect as? TestEffect) === effect)
+        XCTAssertEqual(effect.initializingCount, 1)
         XCTAssertEqual(effect.initializedCount, 1)
         XCTAssertEqual(effect.updatedCount, 0)
         XCTAssertEqual(effect.releasedCount, 0)
 
         context.set(1, for: atom)
 
         XCTAssertTrue((store.state.states[key]?.effect as? TestEffect) === effect)
+        XCTAssertEqual(effect.initializingCount, 1)
         XCTAssertEqual(effect.initializedCount, 1)
         XCTAssertEqual(effect.updatedCount, 1)
         XCTAssertEqual(effect.releasedCount, 0)
@@ -1173,27 +1175,31 @@ final class StoreContextTests: XCTestCase {
         context.set(4, for: atom)
 
         XCTAssertTrue((store.state.states[key]?.effect as? TestEffect) === effect)
+        XCTAssertEqual(effect.initializingCount, 1)
         XCTAssertEqual(effect.initializedCount, 1)
         XCTAssertEqual(effect.updatedCount, 4)
         XCTAssertEqual(effect.releasedCount, 0)
 
         context.set("Updated", for: upstreamAtom)
 
         XCTAssertTrue((store.state.states[key]?.effect as? TestEffect) === effect)
+        XCTAssertEqual(effect.initializingCount, 1)
         XCTAssertEqual(effect.initializedCount, 1)
         XCTAssertEqual(effect.updatedCount, 5)
         XCTAssertEqual(effect.releasedCount, 0)
 
         context.unwatch(atom, subscriber: subscriber)
 
         XCTAssertNil(store.state.states[key])
+        XCTAssertEqual(effect.initializingCount, 1)
         XCTAssertEqual(effect.initializedCount, 1)
         XCTAssertEqual(effect.updatedCount, 5)
         XCTAssertEqual(effect.releasedCount, 1)
 
         context.set(5, for: atom)
 
         XCTAssertNil(store.state.states[key])
+        XCTAssertEqual(effect.initializingCount, 1)
         XCTAssertEqual(effect.initializedCount, 1)
         XCTAssertEqual(effect.updatedCount, 5)
         XCTAssertEqual(effect.releasedCount, 1)

Tests/AtomsTests/Effect/InitializeEffectTests.swift

@@ -2,7 +2,7 @@ import XCTest
 
 @testable import Atoms
 
-final class InitializeTests: XCTestCase {
+final class InitializeEffectTests: XCTestCase {
     @MainActor
     func testEvent() {
         let context = AtomCurrentContext(store: .dummy)
@@ -11,6 +11,9 @@ final class InitializeTests: XCTestCase {
             performedCount += 1
         }
 
+        effect.initializing(context: context)
+        XCTAssertEqual(performedCount, 0)
+
         effect.initialized(context: context)
         XCTAssertEqual(performedCount, 1)
 

Tests/AtomsTests/Effect/InitializingEffectTests.swift

@@ -0,0 +1,26 @@
+import XCTest
+
+@testable import Atoms
+
+final class InitializingEffectTests: XCTestCase {
+    @MainActor
+    func testEvent() {
+        let context = AtomCurrentContext(store: .dummy)
+        var performedCount = 0
+        let effect = InitializingEffect {
+            performedCount += 1
+        }
+
+        effect.initializing(context: context)
+        XCTAssertEqual(performedCount, 1)
+
+        effect.initialized(context: context)
+        XCTAssertEqual(performedCount, 1)
+
+        effect.updated(context: context)
+        XCTAssertEqual(performedCount, 1)
+
+        effect.released(context: context)
+        XCTAssertEqual(performedCount, 1)
+    }
+}

Tests/AtomsTests/Effect/ReleaseEffectTests.swift

@@ -11,6 +11,9 @@ final class ReleaseEffectTests: XCTestCase {
             performedCount += 1
         }
 
+        effect.initializing(context: context)
+        XCTAssertEqual(performedCount, 0)
+
         effect.initialized(context: context)
         XCTAssertEqual(performedCount, 0)
 

Tests/AtomsTests/Effect/UpdateEffectTests.swift

@@ -11,6 +11,9 @@ final class UpdateEffectTests: XCTestCase {
             performedCount += 1
         }
 
+        effect.initializing(context: context)
+        XCTAssertEqual(performedCount, 0)
+
         effect.initialized(context: context)
         XCTAssertEqual(performedCount, 0)
 

Tests/AtomsTests/Utilities/Utilities.swift

@@ -7,10 +7,15 @@ final class Object {}
 struct UniqueKey: Hashable {}
 
 final class TestEffect: AtomEffect {
+    var initializingCount = 0
     var initializedCount = 0
     var updatedCount = 0
     var releasedCount = 0
 
+    func initializing(context: Context) {
+        initializingCount += 1
+    }
+
     func initialized(context: Context) {
         initializedCount += 1
     }