How to globally observe @Dependency value updates in UIKit using Combine?

[acosmicflamingo]

Let's say I have @Dependency(\.font) appFont within a view controller that I want to observe, so any label will automatically update the font when a change occurs:

public class MyViewController1: UIViewController {
  var cancellables = Set<AnyCancellable>()

  @Dependency(\.font) var appFont

  lazy var label: UILabel = {
    let lbl = UILabel()
    appFont.sink { lbl.font = $0 }.store(in: cancellables)
    return lbl
  }
}

Is it possible to use @Dependency such that any MyViewController1 instances in the view stack (which is possible by pushing via navigation controller) that modifies font will trigger subscribers of all the other instances to update their labels accordingly?

[acosmicflamingo]

I've updated the description so it gets to the root of what I'm trying to figure out :)

[JacksonUtsch]

You could use a @Dependency client to observe something in that client. The associated field would be something like subscriber: () -> AnyPublisher<String, Never>. You could call font.subscriber().sink...

Although, this usage is not canonized in TCA. It is expected that the MyViewController1 should have access to state and send actions (via a ViewStore). @Dependency is currently made for use inside a reducer. Sometime soon it will placed in its own package and other use cases will be fleshed out. I'm not sure how the TaskLocal injection works out when @Dependency is outside a reducer.

[acosmicflamingo]

Thanks for the reply! Ah you know what, that is a good point about @dependency being meant to work inside the reducer, and what I am asking for seems to greatly deviate from TCA's principles.

After thinking about it and running some experiments, the proper way would actually be for me to save the font property within a module like "userSettings" that can be passed child stores with scoping. As for the asynchronous binding functionality, using Combine and viewStore.publisher pretty much gives me this same kind of behavior.

To update the font everywhere within the app, then I'd have to utilize the FontManager reducer like this on other reducers (with a dash of the TCA action boundaries concepts that Krzysztof highlights here: https://www.merowing.info/tca-action-boundries-convenience/):

public struct SettingsFeature {
public enum Action: TCAAction {
    public enum ViewAction: Equatable {
      case openFontManagerButtonTapped
    }

    public enum DelegateAction: Equatable {
      case lol
    }

    public enum InternalAction: Equatable {
      case fontManager(FontManager.Action)
    }

    case view(ViewAction)
    case delegate(DelegateAction)
    case _internal(InternalAction)
  }

  public var body: some ReducerProtocol<State, Action> {
    Scope(state: \.fontManager, action: /Action.InternalAction.fontManager) {
      FontManager()
    }
    Reduce { state, action in
    switch action {
      ...
      case let ._internal(.fontManager(.delegate(.fontWasUpdated(newFont)))):
        state.font = newFont
        return .none
      ...
    }
  }
}