Function producerAccessed

packages/core/primitives/signals/src/graph.ts:212–295

(node: ReactiveNode)

 * Called by implementations when a producer's signal is read.
 */
export function producerAccessed(node: ReactiveNode): void {
  if (inNotificationPhase) {
    throw new Error(
      typeof ngDevMode !== 'undefined' && ngDevMode
        ? `Assertion error: signal read during notification phase`
        : '',
    );
  }

  if (activeConsumer === null) {
    // Accessed outside of a reactive context, so nothing to record.
    return;
  }

  activeConsumer.consumerOnSignalRead(node);

  const prevProducerLink = activeConsumer.producersTail;

  // If the last producer we accessed is the same as the current one, we can skip adding a new
  // link
  if (prevProducerLink !== undefined && prevProducerLink.producer === node) {
    return;
  }

  let nextProducerLink: ReactiveLink | undefined = undefined;
  const isRecomputing = activeConsumer.recomputing;
  if (isRecomputing) {
    // If we're incrementally rebuilding the producers list, we want to check if the next producer
    // in the list is the same as the one we're trying to add.

    // If the previous producer is defined, then the next producer is just the one that follows it.
    // Otherwise, we should check the head of the producers list (the first node that we accessed the last time this consumer was run).
    nextProducerLink =
      prevProducerLink !== undefined ? prevProducerLink.nextProducer : activeConsumer.producers;
    if (nextProducerLink !== undefined && nextProducerLink.producer === node) {
      // If the next producer is the same as the one we're trying to add, we can just update the
      // last read version, update the tail of the producers list of this rerun, and return.
      activeConsumer.producersTail = nextProducerLink;
      nextProducerLink.lastReadVersion = node.version;
      nextProducerLink.knownValidAtEpoch = epoch;
      return;
    }
  }

  const prevConsumerLink = node.consumersTail;

  // If the producer we're accessing already has a link to this consumer, we can skip adding a new
  // link. This can short circuit the creation of a new link in the case where the consumer reads alternating ReactiveNodes
  if (
    prevConsumerLink !== undefined &&
    prevConsumerLink.consumer === activeConsumer &&
    (!isRecomputing || prevConsumerLink.knownValidAtEpoch === epoch)
  ) {
    return;
  }

  // If we got here, it means that we need to create a new link between the producer and the consumer.
  const isLive = consumerIsLive(activeConsumer);