From AnyPublisher<NetworkPath, Never> to @Sendable (NetworkPath) async throws -> Void

[saroar]

I am trying to update old PathMonitorClient code to async

having some issue
Old Code

public struct NetworkPath {
  public var status: NWPath.Status

  public init(status: NWPath.Status) {
    self.status = status
  }
}

extension NetworkPath {
  public init(rawValue: NWPath) {
    status = rawValue.status
  }
}

public struct PathMonitorClient {
  public var networkPathPublisher: AnyPublisher<NetworkPath, Never>

  public init(
    networkPathPublisher: AnyPublisher<NetworkPath, Never>
  ) {
    self.networkPathPublisher = networkPathPublisher
  }
}

// Live
extension PathMonitorClient {
  public static func live(queue: DispatchQueue) -> Self {
    let monitor = NWPathMonitor()
    let subject = PassthroughSubject<NWPath, Never>()
    monitor.pathUpdateHandler = subject.send

    return Self(
      networkPathPublisher:
        subject
        .handleEvents(
          receiveSubscription: { _ in monitor.start(queue: queue) },
          receiveCancel: monitor.cancel
        )
        .map(NetworkPath.init(rawValue:))
        .eraseToAnyPublisher()
    )
  }
}

Here is new Code

public struct NetworkPath {
  public var status: NWPath.Status

  public init(status: NWPath.Status) {
    self.status = status
  }
}

extension NetworkPath {
  public init(rawValue: NWPath) {
    status = rawValue.status
  }
}

public struct PathMonitorClient {
  public typealias NPath = @Sendable (NetworkPath) async throws -> Void

    public var nPath: NPath

  public init(
    nPath: @escaping NPath
  ) {
    self.nPath = nPath
  }
}

// Live Implementation

extension PathMonitorClient: DependencyKey {
    static public var liveValue = Self.path()

    public static func path(queue: DispatchQueue = .main) -> Self {
        let monitor = NWPathMonitor()
        return Self(
            nPath: monitor.paths().map(NetworkPath.init(rawValue:))* 👉 Here I getting issue 
        )
    }
}
// * issue 👉 Cannot convert value of type 'AsyncMapSequence<AsyncStream<NWPath>, NetworkPath>' 
// to expected argument type 'PathMonitorClient.NPath' (aka '@Sendable (NetworkPath) async throws -> ()')

// Extension
extension NWPathMonitor {
    func paths() -> AsyncStream<NWPath> {
        AsyncStream { continuation in
            pathUpdateHandler = { path in
                continuation.yield(path)
            }
            continuation.onTermination = { [weak self] _ in
                self?.cancel()
            }
            start(queue: DispatchQueue(label: "NSPathMonitor.paths"))
        }
    }
}

// Then you can do things like:
func startMonitoring() async {
    let monitor = NWPathMonitor()
    let path = monitor.paths()

    for await path in monitor.paths() {
        print(path.debugDescription)
    }
}

Going to add CommonTCALibraries so rest of community can get help Click 👇🏼

Going to add CommonTCALibraries so rest of community can get help

[saroar]

Fixed by changing

public typealias NPath = @Sendable () async throws -> AsyncStream< NetworkPath >
extension PathMonitorClient: DependencyKey {
    static public var liveValue: Self = .init {
        AsyncStream { continuation in
            let monitor = NWPathMonitor() // will be any issue memory ? 
            monitor.pathUpdateHandler = { path in
                continuation.yield(NetworkPath.init(rawValue: path))
            }
            continuation.onTermination = { _ in
                monitor.cancel()
            }
            monitor.start(queue: DispatchQueue(label: "NSPathMonitor.paths"))
        }
    }
}

[saroar]

only confuse here

extension PathMonitorClient {
    static public let noop = Self(
        nPath: { AsyncStream.never }
    )

    static public let satisfied = Self(
        nPath: { .init { continuation in continuation.yield(NetworkPath(status: .satisfied)) } }
    )

    static public let unsatisfied = Self(
        nPath: { .init { continuation in continuation.yield(NetworkPath(status: .unsatisfied)) } }
    )
}

// old one have to convert new 
  public static let flakey = Self(
    networkPathPublisher: Timer.publish(every: 2, on: .main, in: .default)
      .autoconnect()
      .scan(.satisfied) { status, _ in
        status == .satisfied ? .unsatisfied : .satisfied
      }
      .map { NetworkPath(status: $0) }
      .eraseToAnyPublisher()
  )
  // New
  static public let flakey = Self(
        nPath: { .init { continuation in
            Timer.scheduledTimer(withTimeInterval: 2, repeats: true) { flip in
                var status = NetworkPath(status: .satisfied).status == .satisfied
                    ? NetworkPath(status: .unsatisfied)
                    : NetworkPath(status: .satisfied)
                    continuation.yield(status)
                }
            }
        }
    )