Navegación en UIKit dirigida por el estado

UIKit guarda la navegación en sus propios objetos. La pila de una app vive dentro del array viewControllers de un UINavigationController, y qué hoja está presentada vive en una propiedad de un controlador. Eso significa que la verdad sobre dónde está el usuario reside en un lugar que no puedes construir en un test, ni serializar para restaurar una sesión, ni recibir desde un enlace profundo sin simular una secuencia de toques. Es, con diferencia, el peor sitio donde poner un dato importante, y es donde lleva estando desde 2008. Llevar esa información al State no es una excentricidad de TCA sino la reparación de un defecto estructural, y el precio a pagar es escribir el pequeño reconciliador que mantiene sincronizados el dato y los objetos. Esta lección lo escribe entero y después enseña a no escribirlo.

Presentar como consecuencia del estado

El modelado del dominio es idéntico al que ya conoces: un destino opcional anotado con @Presents, un enum de destinos si hay varios, y la acción del hijo enrutada hacia el padre. El controlador no toca nada de eso; lo único que hace es observar y reaccionar.

@Reducer
struct Bandeja {
  @ObservableState
  struct State: Equatable {
    @Presents var destino: Destino.State?
    var mensajes: IdentifiedArrayOf<Mensaje> = []
  }
  enum Action {
    case filaSeleccionada(id: Mensaje.ID)
    case destino(PresentationAction<Destino.Action>)
  }
}

El reconciliador manual es un bloque de observación dedicado que compara lo que el estado dice con lo que hay presentado y aplica la diferencia. La clave está en llevar una referencia al controlador que presentaste, porque sin ella no puedes distinguir no hay nada presentado de hay presentado algo que tú no pusiste.

private weak var presentado: UIViewController?

private func observarDestino() {
  observe { [weak self] in
    guard let self else { return }
    switch (store.destino, presentado) {
    case (.some, .none):
      guard let hijo = store.scope(state: \.destino?.detalle, action: \.destino.detalle)
      else { return }
      let vc = DetalleViewController(store: hijo)
      presentado = vc
      present(vc, animated: true)
    case (.none, .some(let vc)):
      presentado = nil
      vc.dismiss(animated: true)
    default:
      break
    }
  }
}

Tres cosas merecen atención. La reconciliación es idempotente por construcción: si el estado dice que hay destino y ya hay uno presentado, no hace nada, y por eso las ejecuciones de más del bloque no producen dos hojas apiladas. La referencia se anula antes de pedir el cierre, para que una reejecución durante la animación no vuelva a entrar por la rama de cierre. Y el store del hijo se obtiene rebanando el del padre, con lo que el controlador presentado ignora por completo quién lo presentó: recibe su StoreOf y nada más, igual que una vista de fila en el Nivel 15.

El sentido inverso: quién avisa de que se cerró

Aquí está la asimetría que hace difícil la navegación en UIKit y que casi nadie anticipa. La dirección estado a pantalla es una función que tú calculas y que por tanto controlas. La dirección pantalla a estado no lo es, porque UIKit le ofrece al usuario varias formas de cerrar una pantalla que no pasan por tu código: arrastrar una hoja hacia abajo, pulsar el botón de retroceso de la barra, hacer el gesto interactivo de vuelta desde el borde. Si no interceptas cada una de esas salidas, el controlador desaparece de la pantalla y el estado sigue afirmando que está ahí. A partir de ese instante, el modelo y lo que el usuario ve son dos relatos distintos, y todo lo que se apoye en el primero —efectos que siguen vivos, una acción que llega tarde, una restauración— se comporta de forma incomprensible.

extension BandejaViewController: UIAdaptivePresentationControllerDelegate {
  func presentationControllerDidDismiss(_ controller: UIPresentationController) {
    presentado = nil
    store.send(.destino(.dismiss))
  }
}

// Para el retroceso de una pila, en el controlador hijo
override func didMove(toParent parent: UIViewController?) {
  super.didMove(toParent: parent)
  if parent == nil { store.send(.cerradoPorElUsuario) }
}

Repara en que ese envío no es una excepción a la regla de que el manejador no decide: informar de que el usuario cerró la hoja es exactamente el tipo de hecho que debe entrar como acción. Lo que sería una violación es que el manejador pusiera store.destino a nulo por su cuenta, cosa que además no puede hacer porque el estado no es escribible desde fuera del reducer.

Pilas de controladores y StackState

Una pila es el mismo problema con cardinalidad variable: en lugar de dos casos hay que comparar dos secuencias y aplicar el mínimo de operaciones. La capa de UIKit resuelve el caso general con un NavigationStackController que recibe el scope de la pila y una fábrica de controladores por caso, en simetría exacta con el NavigationStack de SwiftUI.

let controlador = NavigationStackController(
  path: $store.scope(state: \.camino, action: \.camino)
) {
  RaizViewController(store: store)
}

// dentro de la raiz, para empujar un destino
store.send(.detallePulsado(id: id))

La ganancia respecto al reconciliador manual no es solo de líneas. Un empujón manual exige decidir qué hacer cuando el estado añade dos elementos de golpe, cuando quita tres, o cuando reemplaza el camino entero por un enlace profundo; el ayudante ya resolvió esa comparación. Y para las alertas y los diálogos de confirmación existe un puente directo desde AlertState, de modo que el mismo valor que se afirma en un test construye el UIAlertController real.

present(item: $store.scope(state: \.alerta, action: \.alerta)) { estado in
  UIAlertController(state: estado) { accion in
    store.send(.alerta(.presented(accion)))
  }
}

flowchart TD
A[Toque en una fila] --> S[store punto send accion]
S --> R[Reducer asigna el destino en el estado]
R --> O[Bloque de reconciliacion]
O --> P[present o pushViewController]
G[Gesto de cierre del usuario] --> D[Delegado de presentacion]
D --> S2[store punto send accion de cierre]
S2 --> R2[Reducer pone el destino a nulo]
R2 --> O
style O fill:#89b4fa,color:#11111b