d

src/Bus.swift

@@ -6,119 +6,87 @@ public enum Bus { }
 extension Bus {
   final class Service {
     static let singleton = Service()
-    let broadcaster = PassthroughSubject<(key: String, value: Any), Never>()
+    let events = PassthroughSubject<(key: String, value: Any), Never>()
     var subscriptions = Set<AnyCancellable>()
     
     func send(_ key: String, _ value: Any) {
-        /**/print("ИГР BusS.send key/value: '\(key)'/'\(value)'")
-        broadcaster.send((key, value))
+      /**/print("ИГР BusS.send key/value: '\(key)'/'\(value)'")
+      events.send((key, value))
     }
   }
 }
 
 public extension Bus {
-    static func receiveAsync<T>(
-        _ subscriptions: inout Set<AnyCancellable>,
-        _ keys: Set<String>,
-        _ handler: @escaping ((String, T) -> Void)
-    ) {
-        Service.singleton.broadcaster
-            .compactMap { v -> (String, T)? in
-                guard
-                    keys.contains(v.key),
-                    let value = v.value as? T
-                else {
-                    return nil
-                }
-                return (v.key, value)
-            }
-            .receive(on: DispatchQueue.main)
-            .sink { v in handler(v.0, v.1) }
-            .store(in: &subscriptions)
-    }
+  static func receiveAsync<T>(
+    _ subscriptions: inout Set<AnyCancellable>,
+    _ keys: Set<String>,
+    _ handler: @escaping ((String, T) -> Void)
+  ) {
+    Service.singleton.events
+      .compactMap { convertKeyValue(keys, $0) }
+      .receive(on: DispatchQueue.main)
+      .sink { v in handler(v.0, v.1) }
+      .store(in: &subscriptions)
+  }
 
-    static func receiveSync<T>(
-        _ subscriptions: inout Set<AnyCancellable>,
-        _ keys: Set<String>,
-        _ handler: @escaping ((String, T) -> Void)
-    ) {
-        Service.singleton.broadcaster
-            .compactMap { v -> (String, T)? in
-                guard
-                    keys.contains(v.key),
-                    let value = v.value as? T
-                else {
-                    return nil
-                }
-                return (v.key, value)
-            }
-            .sink { v in handler(v.0, v.1) }
-            .store(in: &subscriptions)
-    }
-    
-    static func sendAsync<T>(
-        _ subscriptions: inout Set<AnyCancellable>,
-        _ key: String,
-        _ node: AnyPublisher<T, Never>
-    ) {
-        node
-            .receive(on: DispatchQueue.main)
-            .sink { v in Service.singleton.send(key, v) }
-            .store(in: &subscriptions)
-    }
-    
-    static func sendSync<T>(
-        _ subscriptions: inout Set<AnyCancellable>,
-        _ key: String,
-        _ node: AnyPublisher<T, Never>
-    ) {
-        node
-            .sink { v in Service.singleton.send(key, v) }
-            .store(in: &subscriptions)
-    }
-    
-    static func sendOnce(_ key: String, _ value: Any) {
-        Service.singleton.send(key, value)
-    }
+  static func receiveSync<T>(
+    _ subscriptions: inout Set<AnyCancellable>,
+    _ keys: Set<String>,
+    _ handler: @escaping ((String, T) -> Void)
+  ) {
+    Service.singleton.events
+      .compactMap { convertKeyValue(keys, $0) }
+      .sink { v in handler(v.0, v.1) }
+      .store(in: &subscriptions)
+  }
+  
+  static func sendAsync<T>(
+    _ subscriptions: inout Set<AnyCancellable>,
+    _ key: String,
+    _ node: AnyPublisher<T, Never>
+  ) {
+    node
+      .receive(on: DispatchQueue.main)
+      .sink { v in Service.singleton.send(key, v) }
+      .store(in: &subscriptions)
+  }
+  
+  static func sendSync<T>(
+    _ subscriptions: inout Set<AnyCancellable>,
+    _ key: String,
+    _ node: AnyPublisher<T, Never>
+  ) {
+    node
+      .sink { v in Service.singleton.send(key, v) }
+      .store(in: &subscriptions)
+  }
+  
+  static func send(_ key: String, _ value: Any) {
+    Service.singleton.send(key, value)
+  }
 }
 
 public extension Bus {
-    static func processSync<Src, Dst>(
-        _ subscriptions: inout Set<AnyCancellable>,
-        _ handler: @escaping ((Src) -> Dst?),
-        _ keyIn: String,
-        _ keyOut: String
-    ) {
-        Service.singleton.broadcaster
-            .compactMap {
-                guard
-                    $0.key == keyIn,
-                    let vIn = $0.value as? Src
-                else {
-                    return nil
-                }
-                return handler(vIn)
-            }
-            .sink { vOut in Service.singleton.send(keyOut, vOut) }
-            .store(in: &subscriptions)
-    }
+  static func processSync<Src, Dst>(
+    _ subscriptions: inout Set<AnyCancellable>,
+    _ handler: @escaping ((Src) -> Dst?),
+    _ keyIn: String,
+    _ keyOut: String
+  ) {
+    Service.singleton.events
+      .compactMap { processKeyValue($0, keyIn, handler) }
+      .sink { vOut in Service.singleton.send(keyOut, vOut) }
+      .store(in: &subscriptions)
+  }
 
-    static func processSyncG<Src, Dst>(
-        _ handler: @escaping ((Src) -> Dst?),
-        _ keyIn: String,
-        _ keyOut: String
-    ) {
-        Service.singleton.broadcaster
-            .compactMap {
-                guard
-                    $0.key == keyIn,
-                    let vIn = $0.value as? Src
-                else {
-                    return nil
-                }
-                return handler(vIn)
-            }
-            .sink { vOut in Service.singleton.send(keyOut, vOut) }
-            .store(in: &Service.singleton.subscriptions)
-    }
+  static func processSyncG<Src, Dst>(
+    _ handler: @escaping ((Src) -> Dst?),
+    _ keyIn: String,
+    _ keyOut: String
+  ) {
+    Service.singleton.events
+      .compactMap { processKeyValue($0, keyIn, handler) }
+      .sink { vOut in Service.singleton.send(keyOut, vOut) }
+      .store(in: &Service.singleton.subscriptions)
+  }
 }