Extending dependencies with Combine publishers (or any functionality) outside of this repository

[acosmicflamingo]

There are some dependencies with great functionality (e.d. AccessibilityDependency), but they only give me 90% of what I want. Because of that, I've created my own dependencies that essentially wrap around these dependencies (e.g. I've created a A11yClient dependency that is 90% a carbon copy of AccessibilityDependency and 10% extra useful functionality like Combine publisher generators). However, it seems pretty silly that I have to maintain a codebase that is 90% the same as another well-maintained one. This was especially apparent when I was trying to override a11yClient.$isVoiceOverEnabled and additionally had to override accessibility.$isVoiceOverEnabled to get my UIView to work in Xcode Previews.

One workaround I came up with is extending a dependency in this manner:

extension DeviceDependency.Device {
  public struct Publisher {
    @Dependency(\.applicationClient) var applicationClient
    @Dependency(\.notificationCenter) var notificationCenter

    @MainActor
    public var interfaceOrientation: AnyPublisher<UIInterfaceOrientation, Never> {
      let interfaceOrientationGenerator = { @MainActor @Sendable (
        applicationClient: UIApplicationClient
      ) -> UIInterfaceOrientation in
        applicationClient.keyWindow?.windowScene?.interfaceOrientation ?? .unknown
      }
      let condition = interfaceOrientationGenerator
      let notification = DeviceClient.interfaceOrientationDidChangeNotification
      return Just(condition(applicationClient))
        .merge(
          with: notificationCenter.publisher(for: notification)
            .map { _ in condition(applicationClient) }
        ).removeDuplicates()
        .eraseToAnyPublisher()
    }
  }

  public var publisher: Publisher {
    .init()
  }

That allows me to subscribe to the interfaceOrientation publisher, and gives the impression that deviceClient does in fact have a publisher property:

deviceClient.publisher.interfaceOrientation
  .map(\.isPortrait)
  .sink { [weak self] isPortrait in
    guard let self else { return }

    stackView.axis = isPortrait ? .vertical : .horizontal
  }
  .store(in: &cancellables)

While it doesn't conform to ConfigurableProxy protocol and is much harder to test, that seems like a decent tradeoff since it's rather straightforward nature and doesn't really need to be tested so thoroughly. Even then, it does seem a bit hacky to create a brand new DeviceDependency.Publisher instance every time publisher is accessed (while _implementation is only instantiated once in DependenciesAdditions's dependencies that conform to ConfigurableProxy protocol).

Is there a better way for me to be able to extend API of these powerful dependencies while retaining clean API and ability to test in the process?

[acosmicflamingo]

Might have found a clean approach for the Combine publishers use-case. Just create a static var that stores the instance. Since DeviceDependency.Device in itself is singleton-esque, every instance where @Dependency(\.device) var device is being accessed will also access the same _publisher value.

import AccessibilityDependency
import Combine
import UIKit

extension Accessibility {
  private static var _publisher = Publisher()

  public struct Publisher {
    @Dependency(\.notificationCenter) var notificationCenter

    public var isBoldTextEnabled: AnyPublisher<Bool, Never> {
      let condition = { UIAccessibility.isBoldTextEnabled }
      return Just(condition())
        .merge(
          with: notificationCenter.publisher(
            for: UIAccessibility.boldTextStatusDidChangeNotification
          )
          .map { _ in condition() }
        ).removeDuplicates()
        .eraseToAnyPublisher()
    }
  }

  public var publisher: Publisher {
    get { Self._publisher }
    set { Self._publisher = newValue }
  }
}