Merge branch 'main' into muukii/accumulation

.gitignore

@@ -72,4 +72,6 @@ fastlane/test_output
 Derived
 *.xcodeproj
 
+Workspace.xcworkspace/
+
 # End of https://www.gitignore.io/api/swift

.mise.toml

@@ -0,0 +1,2 @@
+[tools]
+tuist = "4.10.2"

Package.resolved

@@ -36,24 +36,6 @@
         "version" : "1.1.0"
       }
     },
-    {
-      "identity" : "swift-docc-plugin",
-      "kind" : "remoteSourceControl",
-      "location" : "https://github.com/apple/swift-docc-plugin.git",
-      "state" : {
-        "revision" : "26ac5758409154cc448d7ab82389c520fa8a8247",
-        "version" : "1.3.0"
-      }
-    },
-    {
-      "identity" : "swift-docc-symbolkit",
-      "kind" : "remoteSourceControl",
-      "location" : "https://github.com/apple/swift-docc-symbolkit",
-      "state" : {
-        "revision" : "b45d1f2ed151d057b54504d653e0da5552844e34",
-        "version" : "1.0.0"
-      }
-    },
     {
       "identity" : "swift-macro-testing",
       "kind" : "remoteSourceControl",

Package.swift

@@ -21,7 +21,6 @@ let package = Package(
   ],
   dependencies: [
     .package(url: "https://github.com/ReactiveX/RxSwift.git", from: "6.0.0"),
-    .package(url: "https://github.com/apple/swift-docc-plugin.git", from: "1.3.0"),
     .package(url: "https://github.com/apple/swift-atomics.git", from: "1.0.2"),
     .package(url: "https://github.com/apple/swift-collections", from: "1.1.0"),
     .package(url: "https://github.com/VergeGroup/swift-concurrency-task-manager", from: "1.1.0"),

Sources/Verge/Library/EventEmitter.swift

@@ -19,7 +19,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-@_implementationOnly import Atomics
+import Atomics
 import Combine
 import Foundation
 import os

Sources/Verge/Library/StoreActivitySubscription.swift

@@ -1,5 +1,5 @@
 import Combine
-@_implementationOnly import Atomics
+import Atomics
 
 /**
  A subscription that is compatible with Combine’s Cancellable.

Sources/Verge/Library/StoreStateSubscription.swift

@@ -1,5 +1,5 @@
 import Combine
-@_implementationOnly import Atomics
+import Atomics
 
 @available(*, deprecated, message: "StoreSubscription has separated into StoreStateSubscription and StoreActivitySubscription.")
 public typealias StoreSubscription = Cancellable

Sources/Verge/Library/VergeAnyCancellable.swift

@@ -1,5 +1,5 @@
 import Combine
-@_implementationOnly import Atomics
+import Atomics
 
 /// A typealias to `Set<AnyCancellable>`.
 public typealias VergeAnyCancellables = Set<AnyCancellable>

Sources/Verge/Store/AnyTargetQueue.swift

@@ -20,7 +20,7 @@
 // THE SOFTWARE.
 
 import Foundation
-@_implementationOnly import Atomics
+import Atomics
 
 public protocol TargetQueueType {
   func execute(_ workItem: @escaping () -> Void)

Sources/Verge/Store/Changes.swift

@@ -187,6 +187,17 @@ public final class Changes<Value: Equatable>: @unchecked Sendable, ChangesType,
     )
   }
 
+  func replacePrevious(_ previous: Changes<Value>) -> Changes<Value> {
+    return .init(
+      previous: previous,
+      innerBox: innerBox,
+      version: version,
+      traces: traces,
+      modification: nil,
+      transaction: _transaction
+    )
+  }
+
   @inlinable
   public func asChanges() -> Changes<Value> {
     self
@@ -340,6 +351,33 @@ extension Changes {
 
   }
 
+  @inline(__always)
+  fileprivate func _takeIfChanged_packed_nonEquatable<each Element>(
+    _ compose: (Value) throws -> (repeat each Element),
+    comparator: some Comparison<(repeat each Element)>
+  ) rethrows -> (repeat each Element)? {
+
+    let current = self.primitive
+
+    guard let previousValue = previous else {
+      return try compose(consume current)
+    }
+
+    let old = previousValue.primitive
+
+    let composedFromCurrent = try compose(consume current)
+    let composedFromOld = try compose(old)
+
+    let isEqual = comparator(composedFromOld, composedFromCurrent)
+
+    guard isEqual == false else {
+      return nil
+    }
+
+    return composedFromCurrent
+
+  }
+
   /// Performs a closure if the selected value changed from the previous one.
   ///
   /// - Parameters:
@@ -376,6 +414,7 @@ extension Changes {
   /**
    Performs a closure if the selected value changed from the previous one.
    */
+  @available(*, deprecated, message: "Use another function that returns IfChangedBox")
   public func ifChanged<T, Result>(
     _ selector: ChangesKeyPath<T>,
     _ comparer: some Comparison<T>,
@@ -416,6 +455,17 @@ extension Changes {
     return .init(value: (repeat each result))
   }
 
+  public borrowing func ifChanged<each Element>(
+    _ compose: (borrowing Value) -> (repeat each Element),
+    comparator: some Comparison<(repeat each Element)>
+  ) -> IfChangedBox<(repeat each Element)> {
+    guard let result = _takeIfChanged_packed_nonEquatable(compose, comparator: comparator) else {
+      return .init()
+    }
+
+    return .init(value: (repeat each result))
+  }
+
   /**
    singular variant
    */

Sources/Verge/Store/Store+RunLoop.swift

@@ -0,0 +1,130 @@
+import Foundation
+
+extension Store {
+
+  /// Push an event to run event loop.
+  public func updateMainLoop() {
+    RunLoop.main.perform(inModes: [.common]) {}
+  }
+
+  /**
+   Subscribes state updates in given run-loop.
+   */
+  public func pollMainLoop(receive: @escaping @MainActor (Changes<State>) -> Void) -> VergeAnyCancellable {
+
+    var latestState: Changes<State>? = nil
+
+    let subscription = RunLoopActivityObserver.addObserver(acitivity: .beforeWaiting, in: .main) {
+
+      let newState = self.state
+
+      guard (latestState?.version ?? 0) < newState.version else {
+        return
+      }
+
+      latestState = newState
+
+      let state: Changes<State>
+
+      if let latestState {
+        state = newState.replacePrevious(latestState)
+      } else {
+        state = newState.droppedPrevious()
+      }
+
+      MainActor.assumeIsolated {
+        receive(state)
+      }
+
+    }
+
+    return .init {
+      RunLoopActivityObserver.remove(subscription)
+    }
+  }
+
+}
+
+private enum RunLoopActivityObserver {
+
+  struct Subscription {
+    let mode: CFRunLoopMode
+    let observer: CFRunLoopObserver?
+    weak var targetRunLoop: RunLoop?
+  }
+
+  static func addObserver(acitivity: CFRunLoopActivity, in runLoop: RunLoop, callback: @escaping () -> Void) -> Subscription {
+
+    let o = CFRunLoopObserverCreateWithHandler(kCFAllocatorDefault, acitivity.rawValue, true, Int.max, { observer, activity in
+      callback()
+    });
+
+    assert(o != nil)
+
+    let mode = CFRunLoopMode.commonModes!
+    let cfRunLoop = runLoop.getCFRunLoop()
+
+    CFRunLoopAddObserver(cfRunLoop, o, mode);
+
+    return .init(mode: mode, observer: o, targetRunLoop: runLoop)
+  }
+
+  static func remove(_ subscription: Subscription) {
+
+    guard let observer = subscription.observer, let targetRunLoop = subscription.targetRunLoop else {
+      return
+    }
+
+    CFRunLoopRemoveObserver(targetRunLoop.getCFRunLoop(), observer, subscription.mode);
+  }
+
+}
+
+#if DEBUG && canImport(SwiftUI)
+import SwiftUI
+
+#Preview {
+  Content()
+}
+
+private struct StoreState: StateType {
+  var count: Int = 0
+}
+
+private struct Content: View {
+
+  let store = Store<_, Never>(initialState: StoreState())
+
+  @State var subscription: VergeAnyCancellable?
+  @State var timer: Timer?
+
+  var body: some View {
+    VStack {
+      Button("Up") {
+        store.commit {
+          $0.count += 1
+        }
+      }
+      Button("Background Up") {
+
+        for _ in 0..<10 {
+          store.commit {
+            $0.count += 1
+          }
+        }
+
+      }
+      Button("Run") {
+        RunLoop.main.run(until: Date(timeIntervalSinceNow: 19))
+      }
+    }
+      .onAppear {
+        subscription = store.pollMainLoop { state in
+          print(state.count)
+        }
+      }
+  }
+
+}
+#endif
+

Sources/Verge/Store/Store.swift

@@ -23,7 +23,7 @@ import Foundation
 import os.log
 import ConcurrencyTaskManager
 
-@_implementationOnly import Atomics
+import Atomics
 
 #if canImport(Combine)
 import Combine
@@ -323,6 +323,12 @@ extension Store {
 // MARK: - Wait
 extension Store {
 
+  /**
+   Commit operation does not mean that emitting latest state for all of subscribers synchronously.
+   Updating state of the store will be updated immediately.
+
+   To wait until all of the subscribers get the latest state, you can use this method.
+   */
   public func waitUntilAllEventConsumed() async {
     await withCheckedContinuation { c in
       accept(.waiter({
@@ -807,9 +813,13 @@ extension Store {
     mutation: (inout InoutRef<State>) throws -> Result
   ) async rethrows -> Result {
 
-    return try await writer.perform { [self] _ in
+    let result = try await writer.perform { [self] _ in
       try self.commit(mutation: mutation)
     }
+
+    await self.waitUntilAllEventConsumed()
+
+    return result
   }
 
 }

Sources/Verge/Store/StoreDriverType.swift

@@ -196,6 +196,19 @@ extension StoreDriverType where Scope == TargetStore.State {
 
 }
 
+extension StoreDriverType {
+
+  /**
+   Commit operation does not mean that emitting latest state for all of subscribers synchronously.
+   Updating state of the store will be updated immediately.
+
+   To wait until all of the subscribers get the latest state, you can use this method.
+   */
+  public func waitUntilAllEventConsumed() async {
+    await store.asStore().waitUntilAllEventConsumed()
+  }
+}
+
 extension StoreDriverType {
 
   /**

Sources/Verge/SwiftUI/OnReceive.swift

@@ -22,8 +22,18 @@ extension View {
   /// - Parameters:
   ///   - instance: The `DispatcherType` instance to subscribe to.
   ///   - perform: A closure to execute when the `State` changes.
-  public func onReceiveState<D: StoreDriverType>(_ instance: D, perform: @escaping @MainActor (Changes<D.TargetStore.State>) -> Void) -> some View {
-    onReceive(instance.store.asStore()._statePublisher().receive(on: DispatchQueue.main), perform: perform)
+  public func onReceiveState<D: StoreDriverType>(
+    _ instance: D,
+    perform: @escaping @MainActor (Changes<D.TargetStore.State>) -> Void
+  ) -> some View {
+    onReceive(
+      instance.store.asStore()._statePublisher().receive(on: DispatchQueue.main),
+      perform: { value in
+        MainActor.assumeIsolated {
+          perform(value)
+        }
+      }
+    )
   }
 
   /// Adds an action to perform when the specified `DispatcherType` publishes an activity.
@@ -46,8 +56,18 @@ extension View {
   /// - Parameters:
   ///   - instance: The `DispatcherType` instance to subscribe to.
   ///   - perform: A closure to execute when the `Activity` is published.
-  public func onReceiveActivity<D: StoreDriverType>(_ instance: D, perform: @escaping @MainActor (D.TargetStore.Activity) -> Void) -> some View {
-    onReceive(instance.store.asStore()._activityPublisher().receive(on: DispatchQueue.main), perform: perform)
+  public func onReceiveActivity<D: StoreDriverType>(
+    _ instance: D,
+    perform: @escaping @MainActor (D.TargetStore.Activity) -> Void
+  ) -> some View {
+    onReceive(
+      instance.store.asStore()._activityPublisher().receive(on: DispatchQueue.main),
+      perform: { value in
+        MainActor.assumeIsolated {
+          perform(value)
+        }
+      }
+    )
   }
 
 }

Sources/Verge/SwiftUI/StoreObject.swift

@@ -111,7 +111,7 @@ enum Preview_StoreObject: PreviewProvider {
     }
   }
 
-  final class ViewModel: StoreComponentType {
+  final class ViewModel: StoreDriverType {
 
     struct State: Equatable {
       var count: Int = 0