Function triggerHydrationFromBlockName

packages/core/src/defer/triggering.ts:374–427

(
  injector: Injector,
  blockName: string,
  replayQueuedEventsFn?: Function,
)

 * events.
 */
export async function triggerHydrationFromBlockName(
  injector: Injector,
  blockName: string,
  replayQueuedEventsFn?: Function,
) {
  const dehydratedBlockRegistry = injector.get(DEHYDRATED_BLOCK_REGISTRY);
  const blocksBeingHydrated = dehydratedBlockRegistry.hydrating;

  // Make sure we don't hydrate/trigger the same thing multiple times
  if (blocksBeingHydrated.has(blockName)) {
    return;
  }

  // Trigger resource loading and hydration for the blocks in the queue in the order of highest block
  // to lowest block. Once a block has finished resource loading, after next render fires after hydration
  // finishes. The new block will have its defer instruction called and will be in the registry.
  // Due to timing related to potential nested control flow, this has to be scheduled after the next render.
  const {parentBlockPromise, hydrationQueue} = getParentBlockHydrationQueue(blockName, injector);
  if (hydrationQueue.length === 0) return;

  // It's possible that the hydrationQueue topmost item is actually in the process of hydrating and has
  // a promise already. In that case, we don't want to destroy that promise and queue it again.
  if (parentBlockPromise !== null) {
    hydrationQueue.shift();
  }

  // The hydrating map in the registry prevents re-triggering hydration for a block that's already in
  // the hydration queue. Here we generate promises for each of the blocks about to be hydrated
  populateHydratingStateForQueue(dehydratedBlockRegistry, hydrationQueue);

  // We await this after populating the hydration state so we can prevent re-triggering hydration for
  // the same blocks while this promise is being awaited.
  if (parentBlockPromise !== null) {
    await parentBlockPromise;
  }

  const topmostParentBlock = hydrationQueue[0];
  if (dehydratedBlockRegistry.has(topmostParentBlock)) {
    // the topmost parent block is already in the registry and we can proceed
    // with hydration.
    await triggerHydrationForBlockQueue(injector, hydrationQueue, replayQueuedEventsFn);
  } else {
    // the topmost parent block is not yet in the registry, which may mean
    // a lazy loaded route, a control flow branch was taken, a route has
    // been navigated, etc. So we need to queue up the hydration process
    // so that it can be finished after the top block has had its defer
    // instruction executed.
    dehydratedBlockRegistry.awaitParentBlock(
      topmostParentBlock,
      async () =>
        await triggerHydrationForBlockQueue(injector, hydrationQueue, replayQueuedEventsFn),
    );
  }
}

/**
 * The core mechanism for incremental hydration. This triggers