Function triggerHydrationForBlockQueue

packages/core/src/defer/triggering.ts:439–508

(
  injector: Injector,
  hydrationQueue: string[],
  replayQueuedEventsFn?: Function,
)

 * events.
 */
export async function triggerHydrationForBlockQueue(
  injector: Injector,
  hydrationQueue: string[],
  replayQueuedEventsFn?: Function,
): Promise<void> {
  const dehydratedBlockRegistry = injector.get(DEHYDRATED_BLOCK_REGISTRY);
  const blocksBeingHydrated = dehydratedBlockRegistry.hydrating;

  // Indicate that we have some pending async work.
  const pendingTasks = injector.get(PendingTasksInternal);
  const taskId = pendingTasks.add();

  // Actually do the triggering and hydration of the queue of blocks
  for (let blockQueueIdx = 0; blockQueueIdx < hydrationQueue.length; blockQueueIdx++) {
    const dehydratedBlockId = hydrationQueue[blockQueueIdx];
    const dehydratedDeferBlock = dehydratedBlockRegistry.get(dehydratedBlockId);

    if (dehydratedDeferBlock != null) {
      // trigger the block resources and await next render for hydration. This should result
      // in the next block ɵɵdefer instruction being called and that block being added to the dehydrated registry.
      await triggerResourceLoadingForHydration(dehydratedDeferBlock);
      await nextRender(injector);

      // if the content has changed since server rendering, we need to check for the expected block
      // being in the registry or if errors occurred. In that case, we need to clean up the remaining expected
      // content that won't be rendered or fetched.
      if (deferBlockHasErrored(dehydratedDeferBlock)) {
        // Either the expected block has not yet had its ɵɵdefer instruction called or the block errored out when fetching
        // resources. In the former case, either we're hydrating too soon or the client and server differ. In both cases,
        // we need to clean up child content and promises.
        removeDehydratedViewList(dehydratedDeferBlock);
        cleanupRemainingHydrationQueue(
          hydrationQueue.slice(blockQueueIdx),
          dehydratedBlockRegistry,
        );
        break;
      }
      // The defer block has not errored and we've finished fetching resources and rendering.
      // At this point it is safe to resolve the hydration promise.
      blocksBeingHydrated.get(dehydratedBlockId)!.resolve();
    } else {
      // The expected block has not yet had its ɵɵdefer instruction called. This is likely due to content changing between
      // client and server. We need to clean up the dehydrated DOM in the container since it no longer is valid.
      cleanupParentContainer(blockQueueIdx, hydrationQueue, dehydratedBlockRegistry);
      cleanupRemainingHydrationQueue(hydrationQueue.slice(blockQueueIdx), dehydratedBlockRegistry);
      break;
    }
  }

  const lastBlockName = hydrationQueue[hydrationQueue.length - 1];

  // Await hydration completion for the last block.
  await blocksBeingHydrated.get(lastBlockName)?.promise;

  // All async work is done, remove the taskId from the registry.
  pendingTasks.remove(taskId);

  // Replay any queued events, if any exist and the replay operation was requested.