didChangeDependencies method

@override void didChangeDependencies()

Called when a dependency of this State object changes.

For example, if the previous call to build referenced an InheritedWidget that later changed, the framework would call this method to notify this object about the change.

This method is also called immediately after initState. It is safe to call BuildContext.dependOnInheritedWidgetOfExactType from this method.

Subclasses rarely override this method because the framework always calls build after a dependency changes. Some subclasses do override this method because they need to do some expensive work (e.g., network fetches) when their dependencies change, and that work would be too expensive to do for every build.

Implementation

@override
void didChangeDependencies() {
  super.didChangeDependencies();
  if (_registry != null) return; // already initialized

  final scope = InheritedTrinityScope.of(context);
  _registry = scope.registry;

  // We always create the node to know its concrete runtimeType
  final createdNodes = widget.nodes.map((factory) => factory()).toList();
  final resolvedNodes = <N>[];

  for (final node in createdNodes) {
    final key = node.runtimeKey;
    final existing = _registry!.getByKey(key);

    if (existing != null && existing is N) {
      // Automáticamente aplicamos reference counting si la misma Key existe.
      // Esto salva al nodo de ser destruido en transiciones rápidas.
      _registry!.retain(existing);
      resolvedNodes.add(existing);
      _shouldDispose[existing] = true;
      continue;
    }

    // Node does not exist → register
    resolvedNodes.add(node);
    _shouldDispose[node] = true;
    node.attach(scope);
    _registry!.register<N>(node);
    WidgetsBinding.instance.addPostFrameCallback((_) {
      node.onReady();
    });
  }

  _nodes = resolvedNodes;
  //This will be called only once, only when there is only one node
  if (widget.nodes.length == 1) {
    widget.onInit?.call(_nodes!.first);
  }
}