• Home
• org.mvnpm.at.angular
• core
• 18.2.6
• source code
• instructions.mjs

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

package.esm2022.src.defer.instructions.mjs Maven / Gradle / Ivy

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.dev/license
 */
import { setActiveConsumer } from '@angular/core/primitives/signals';
import { CachedInjectorService } from '../cached_injector_service';
import { EnvironmentInjector, InjectionToken } from '../di';
import { internalImportProvidersFrom } from '../di/provider_collection';
import { RuntimeError } from '../errors';
import { findMatchingDehydratedView } from '../hydration/views';
import { populateDehydratedViewsInLContainer } from '../linker/view_container_ref';
import { PendingTasks } from '../pending_tasks';
import { assertLContainer, assertTNodeForLView } from '../render3/assert';
import { bindingUpdated } from '../render3/bindings';
import { ChainedInjector } from '../render3/chained_injector';
import { getComponentDef, getDirectiveDef, getPipeDef } from '../render3/definition';
import { getTemplateLocationDetails } from '../render3/instructions/element_validation';
import { markViewDirty } from '../render3/instructions/mark_view_dirty';
import { handleError } from '../render3/instructions/shared';
import { declareTemplate } from '../render3/instructions/template';
import { isDestroyed } from '../render3/interfaces/type_checks';
import { HEADER_OFFSET, INJECTOR, PARENT, TVIEW } from '../render3/interfaces/view';
import { getCurrentTNode, getLView, getSelectedTNode, getTView, nextBindingIndex, } from '../render3/state';
import { isPlatformBrowser } from '../render3/util/misc_utils';
import { getConstant, getTNode, removeLViewOnDestroy, storeLViewOnDestroy, } from '../render3/util/view_utils';
import { addLViewToLContainer, createAndRenderEmbeddedLView, removeLViewFromLContainer, shouldAddViewToDom, } from '../render3/view_manipulation';
import { assertDefined, throwError } from '../util/assert';
import { performanceMarkFeature } from '../util/performance';
import { invokeAllTriggerCleanupFns, invokeTriggerCleanupFns, storeTriggerCleanupFn, } from './cleanup';
import { onHover, onInteraction, onViewport, registerDomTrigger } from './dom_triggers';
import { onIdle } from './idle_scheduler';
import { DEFER_BLOCK_STATE, DeferBlockBehavior, DeferBlockInternalState, DeferBlockState, DeferDependenciesLoadingState, LOADING_AFTER_CLEANUP_FN, NEXT_DEFER_BLOCK_STATE, STATE_IS_FROZEN_UNTIL, } from './interfaces';
import { onTimer, scheduleTimerTrigger } from './timer_scheduler';
import { addDepsToRegistry, assertDeferredDependenciesLoaded, getLDeferBlockDetails, getLoadingBlockAfter, getMinimumDurationForState, getPrimaryBlockTNode, getTDeferBlockDetails, getTemplateIndexForState, setLDeferBlockDetails, setTDeferBlockDetails, } from './utils';
/**
 * **INTERNAL**, avoid referencing it in application code.
 * *
 * Injector token that allows to provide `DeferBlockDependencyInterceptor` class
 * implementation.
 *
 * This token is only injected in devMode
 */
export const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR = new InjectionToken('DEFER_BLOCK_DEPENDENCY_INTERCEPTOR');
/**
 * **INTERNAL**, token used for configuring defer block behavior.
 */
export const DEFER_BLOCK_CONFIG = new InjectionToken(ngDevMode ? 'DEFER_BLOCK_CONFIG' : '');
/**
 * Returns whether defer blocks should be triggered.
 *
 * Currently, defer blocks are not triggered on the server,
 * only placeholder content is rendered (if provided).
 */
function shouldTriggerDeferBlock(injector) {
    const config = injector.get(DEFER_BLOCK_CONFIG, null, { optional: true });
    if (config?.behavior === DeferBlockBehavior.Manual) {
        return false;
    }
    return isPlatformBrowser(injector);
}
/**
 * Reference to the timer-based scheduler implementation of defer block state
 * rendering method. It's used to make timer-based scheduling tree-shakable.
 * If `minimum` or `after` parameters are used, compiler generates an extra
 * argument for the `ɵɵdefer` instruction, which references a timer-based
 * implementation.
 */
let applyDeferBlockStateWithSchedulingImpl = null;
/**
 * Enables timer-related scheduling if `after` or `minimum` parameters are setup
 * on the `@loading` or `@placeholder` blocks.
 */
export function ɵɵdeferEnableTimerScheduling(tView, tDetails, placeholderConfigIndex, loadingConfigIndex) {
    const tViewConsts = tView.consts;
    if (placeholderConfigIndex != null) {
        tDetails.placeholderBlockConfig = getConstant(tViewConsts, placeholderConfigIndex);
    }
    if (loadingConfigIndex != null) {
        tDetails.loadingBlockConfig = getConstant(tViewConsts, loadingConfigIndex);
    }
    // Enable implementation that supports timer-based scheduling.
    if (applyDeferBlockStateWithSchedulingImpl === null) {
        applyDeferBlockStateWithSchedulingImpl = applyDeferBlockStateWithScheduling;
    }
}
/**
 * Creates runtime data structures for defer blocks.
 *
 * @param index Index of the `defer` instruction.
 * @param primaryTmplIndex Index of the template with the primary block content.
 * @param dependencyResolverFn Function that contains dependencies for this defer block.
 * @param loadingTmplIndex Index of the template with the loading block content.
 * @param placeholderTmplIndex Index of the template with the placeholder block content.
 * @param errorTmplIndex Index of the template with the error block content.
 * @param loadingConfigIndex Index in the constants array of the configuration of the loading.
 *     block.
 * @param placeholderConfigIndex Index in the constants array of the configuration of the
 *     placeholder block.
 * @param enableTimerScheduling Function that enables timer-related scheduling if `after`
 *     or `minimum` parameters are setup on the `@loading` or `@placeholder` blocks.
 *
 * @codeGenApi
 */
export function ɵɵdefer(index, primaryTmplIndex, dependencyResolverFn, loadingTmplIndex, placeholderTmplIndex, errorTmplIndex, loadingConfigIndex, placeholderConfigIndex, enableTimerScheduling) {
    const lView = getLView();
    const tView = getTView();
    const adjustedIndex = index + HEADER_OFFSET;
    const tNode = declareTemplate(lView, tView, index, null, 0, 0);
    if (tView.firstCreatePass) {
        performanceMarkFeature('NgDefer');
        const tDetails = {
            primaryTmplIndex,
            loadingTmplIndex: loadingTmplIndex ?? null,
            placeholderTmplIndex: placeholderTmplIndex ?? null,
            errorTmplIndex: errorTmplIndex ?? null,
            placeholderBlockConfig: null,
            loadingBlockConfig: null,
            dependencyResolverFn: dependencyResolverFn ?? null,
            loadingState: DeferDependenciesLoadingState.NOT_STARTED,
            loadingPromise: null,
            providers: null,
        };
        enableTimerScheduling?.(tView, tDetails, placeholderConfigIndex, loadingConfigIndex);
        setTDeferBlockDetails(tView, adjustedIndex, tDetails);
    }
    const lContainer = lView[adjustedIndex];
    // If hydration is enabled, looks up dehydrated views in the DOM
    // using hydration annotation info and stores those views on LContainer.
    // In client-only mode, this function is a noop.
    populateDehydratedViewsInLContainer(lContainer, tNode, lView);
    // Init instance-specific defer details and store it.
    const lDetails = [
        null, // NEXT_DEFER_BLOCK_STATE
        DeferBlockInternalState.Initial, // DEFER_BLOCK_STATE
        null, // STATE_IS_FROZEN_UNTIL
        null, // LOADING_AFTER_CLEANUP_FN
        null, // TRIGGER_CLEANUP_FNS
        null, // PREFETCH_TRIGGER_CLEANUP_FNS
    ];
    setLDeferBlockDetails(lView, adjustedIndex, lDetails);
    const cleanupTriggersFn = () => invokeAllTriggerCleanupFns(lDetails);
    // When defer block is triggered - unsubscribe from LView destroy cleanup.
    storeTriggerCleanupFn(0 /* TriggerType.Regular */, lDetails, () => removeLViewOnDestroy(lView, cleanupTriggersFn));
    storeLViewOnDestroy(lView, cleanupTriggersFn);
}
/**
 * Loads defer block dependencies when a trigger value becomes truthy.
 * @codeGenApi
 */
export function ɵɵdeferWhen(rawValue) {
    const lView = getLView();
    const bindingIndex = nextBindingIndex();
    if (bindingUpdated(lView, bindingIndex, rawValue)) {
        const prevConsumer = setActiveConsumer(null);
        try {
            const value = Boolean(rawValue); // handle truthy or falsy values
            const tNode = getSelectedTNode();
            const lDetails = getLDeferBlockDetails(lView, tNode);
            const renderedState = lDetails[DEFER_BLOCK_STATE];
            if (value === false && renderedState === DeferBlockInternalState.Initial) {
                // If nothing is rendered yet, render a placeholder (if defined).
                renderPlaceholder(lView, tNode);
            }
            else if (value === true &&
                (renderedState === DeferBlockInternalState.Initial ||
                    renderedState === DeferBlockState.Placeholder)) {
                // The `when` condition has changed to `true`, trigger defer block loading
                // if the block is either in initial (nothing is rendered) or a placeholder
                // state.
                triggerDeferBlock(lView, tNode);
            }
        }
        finally {
            setActiveConsumer(prevConsumer);
        }
    }
}
/**
 * Prefetches the deferred content when a value becomes truthy.
 * @codeGenApi
 */
export function ɵɵdeferPrefetchWhen(rawValue) {
    const lView = getLView();
    const bindingIndex = nextBindingIndex();
    if (bindingUpdated(lView, bindingIndex, rawValue)) {
        const prevConsumer = setActiveConsumer(null);
        try {
            const value = Boolean(rawValue); // handle truthy or falsy values
            const tView = lView[TVIEW];
            const tNode = getSelectedTNode();
            const tDetails = getTDeferBlockDetails(tView, tNode);
            if (value === true && tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
                // If loading has not been started yet, trigger it now.
                triggerPrefetching(tDetails, lView, tNode);
            }
        }
        finally {
            setActiveConsumer(prevConsumer);
        }
    }
}
/**
 * Sets up logic to handle the `on idle` deferred trigger.
 * @codeGenApi
 */
export function ɵɵdeferOnIdle() {
    scheduleDelayedTrigger(onIdle);
}
/**
 * Sets up logic to handle the `prefetch on idle` deferred trigger.
 * @codeGenApi
 */
export function ɵɵdeferPrefetchOnIdle() {
    scheduleDelayedPrefetching(onIdle);
}
/**
 * Sets up logic to handle the `on immediate` deferred trigger.
 * @codeGenApi
 */
export function ɵɵdeferOnImmediate() {
    const lView = getLView();
    const tNode = getCurrentTNode();
    const tView = lView[TVIEW];
    const injector = lView[INJECTOR];
    const tDetails = getTDeferBlockDetails(tView, tNode);
    // Render placeholder block only if loading template is not present and we're on
    // the client to avoid content flickering, since it would be immediately replaced
    // by the loading block.
    if (!shouldTriggerDeferBlock(injector) || tDetails.loadingTmplIndex === null) {
        renderPlaceholder(lView, tNode);
    }
    triggerDeferBlock(lView, tNode);
}
/**
 * Sets up logic to handle the `prefetch on immediate` deferred trigger.
 * @codeGenApi
 */
export function ɵɵdeferPrefetchOnImmediate() {
    const lView = getLView();
    const tNode = getCurrentTNode();
    const tView = lView[TVIEW];
    const tDetails = getTDeferBlockDetails(tView, tNode);
    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
        triggerResourceLoading(tDetails, lView, tNode);
    }
}
/**
 * Creates runtime data structures for the `on timer` deferred trigger.
 * @param delay Amount of time to wait before loading the content.
 * @codeGenApi
 */
export function ɵɵdeferOnTimer(delay) {
    scheduleDelayedTrigger(onTimer(delay));
}
/**
 * Creates runtime data structures for the `prefetch on timer` deferred trigger.
 * @param delay Amount of time to wait before prefetching the content.
 * @codeGenApi
 */
export function ɵɵdeferPrefetchOnTimer(delay) {
    scheduleDelayedPrefetching(onTimer(delay));
}
/**
 * Creates runtime data structures for the `on hover` deferred trigger.
 * @param triggerIndex Index at which to find the trigger element.
 * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
 * @codeGenApi
 */
export function ɵɵdeferOnHover(triggerIndex, walkUpTimes) {
    const lView = getLView();
    const tNode = getCurrentTNode();
    renderPlaceholder(lView, tNode);
    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerDeferBlock(lView, tNode), 0 /* TriggerType.Regular */);
}
/**
 * Creates runtime data structures for the `prefetch on hover` deferred trigger.
 * @param triggerIndex Index at which to find the trigger element.
 * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
 * @codeGenApi
 */
export function ɵɵdeferPrefetchOnHover(triggerIndex, walkUpTimes) {
    const lView = getLView();
    const tNode = getCurrentTNode();
    const tView = lView[TVIEW];
    const tDetails = getTDeferBlockDetails(tView, tNode);
    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onHover, () => triggerPrefetching(tDetails, lView, tNode), 1 /* TriggerType.Prefetch */);
    }
}
/**
 * Creates runtime data structures for the `on interaction` deferred trigger.
 * @param triggerIndex Index at which to find the trigger element.
 * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
 * @codeGenApi
 */
export function ɵɵdeferOnInteraction(triggerIndex, walkUpTimes) {
    const lView = getLView();
    const tNode = getCurrentTNode();
    renderPlaceholder(lView, tNode);
    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onInteraction, () => triggerDeferBlock(lView, tNode), 0 /* TriggerType.Regular */);
}
/**
 * Creates runtime data structures for the `prefetch on interaction` deferred trigger.
 * @param triggerIndex Index at which to find the trigger element.
 * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
 * @codeGenApi
 */
export function ɵɵdeferPrefetchOnInteraction(triggerIndex, walkUpTimes) {
    const lView = getLView();
    const tNode = getCurrentTNode();
    const tView = lView[TVIEW];
    const tDetails = getTDeferBlockDetails(tView, tNode);
    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onInteraction, () => triggerPrefetching(tDetails, lView, tNode), 1 /* TriggerType.Prefetch */);
    }
}
/**
 * Creates runtime data structures for the `on viewport` deferred trigger.
 * @param triggerIndex Index at which to find the trigger element.
 * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
 * @codeGenApi
 */
export function ɵɵdeferOnViewport(triggerIndex, walkUpTimes) {
    const lView = getLView();
    const tNode = getCurrentTNode();
    renderPlaceholder(lView, tNode);
    registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onViewport, () => triggerDeferBlock(lView, tNode), 0 /* TriggerType.Regular */);
}
/**
 * Creates runtime data structures for the `prefetch on viewport` deferred trigger.
 * @param triggerIndex Index at which to find the trigger element.
 * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.
 * @codeGenApi
 */
export function ɵɵdeferPrefetchOnViewport(triggerIndex, walkUpTimes) {
    const lView = getLView();
    const tNode = getCurrentTNode();
    const tView = lView[TVIEW];
    const tDetails = getTDeferBlockDetails(tView, tNode);
    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
        registerDomTrigger(lView, tNode, triggerIndex, walkUpTimes, onViewport, () => triggerPrefetching(tDetails, lView, tNode), 1 /* TriggerType.Prefetch */);
    }
}
/********** Helper functions **********/
/**
 * Schedules triggering of a defer block for `on idle` and `on timer` conditions.
 */
function scheduleDelayedTrigger(scheduleFn) {
    const lView = getLView();
    const tNode = getCurrentTNode();
    renderPlaceholder(lView, tNode);
    // Only trigger the scheduled trigger on the browser
    // since we don't want to delay the server response.
    if (isPlatformBrowser(lView[INJECTOR])) {
        const cleanupFn = scheduleFn(() => triggerDeferBlock(lView, tNode), lView);
        const lDetails = getLDeferBlockDetails(lView, tNode);
        storeTriggerCleanupFn(0 /* TriggerType.Regular */, lDetails, cleanupFn);
    }
}
/**
 * Schedules prefetching for `on idle` and `on timer` triggers.
 *
 * @param scheduleFn A function that does the scheduling.
 */
function scheduleDelayedPrefetching(scheduleFn) {
    const lView = getLView();
    // Only trigger the scheduled trigger on the browser
    // since we don't want to delay the server response.
    if (isPlatformBrowser(lView[INJECTOR])) {
        const tNode = getCurrentTNode();
        const tView = lView[TVIEW];
        const tDetails = getTDeferBlockDetails(tView, tNode);
        if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {
            const lDetails = getLDeferBlockDetails(lView, tNode);
            const prefetch = () => triggerPrefetching(tDetails, lView, tNode);
            const cleanupFn = scheduleFn(prefetch, lView);
            storeTriggerCleanupFn(1 /* TriggerType.Prefetch */, lDetails, cleanupFn);
        }
    }
}
/**
 * Transitions a defer block to the new state. Updates the  necessary
 * data structures and renders corresponding block.
 *
 * @param newState New state that should be applied to the defer block.
 * @param tNode TNode that represents a defer block.
 * @param lContainer Represents an instance of a defer block.
 * @param skipTimerScheduling Indicates that `@loading` and `@placeholder` block
 *   should be rendered immediately, even if they have `after` or `minimum` config
 *   options setup. This flag to needed for testing APIs to transition defer block
 *   between states via `DeferFixture.render` method.
 */
export function renderDeferBlockState(newState, tNode, lContainer, skipTimerScheduling = false) {
    const hostLView = lContainer[PARENT];
    const hostTView = hostLView[TVIEW];
    // Check if this view is not destroyed. Since the loading process was async,
    // the view might end up being destroyed by the time rendering happens.
    if (isDestroyed(hostLView))
        return;
    // Make sure this TNode belongs to TView that represents host LView.
    ngDevMode && assertTNodeForLView(tNode, hostLView);
    const lDetails = getLDeferBlockDetails(hostLView, tNode);
    ngDevMode && assertDefined(lDetails, 'Expected a defer block state defined');
    const currentState = lDetails[DEFER_BLOCK_STATE];
    if (isValidStateChange(currentState, newState) &&
        isValidStateChange(lDetails[NEXT_DEFER_BLOCK_STATE] ?? -1, newState)) {
        const injector = hostLView[INJECTOR];
        const tDetails = getTDeferBlockDetails(hostTView, tNode);
        // Skips scheduling on the server since it can delay the server response.
        const needsScheduling = !skipTimerScheduling &&
            isPlatformBrowser(injector) &&
            (getLoadingBlockAfter(tDetails) !== null ||
                getMinimumDurationForState(tDetails, DeferBlockState.Loading) !== null ||
                getMinimumDurationForState(tDetails, DeferBlockState.Placeholder));
        if (ngDevMode && needsScheduling) {
            assertDefined(applyDeferBlockStateWithSchedulingImpl, 'Expected scheduling function to be defined');
        }
        const applyStateFn = needsScheduling
            ? applyDeferBlockStateWithSchedulingImpl
            : applyDeferBlockState;
        try {
            applyStateFn(newState, lDetails, lContainer, tNode, hostLView);
        }
        catch (error) {
            handleError(hostLView, error);
        }
    }
}
/**
 * Checks whether there is a cached injector associated with a given defer block
 * declaration and returns if it exists. If there is no cached injector present -
 * creates a new injector and stores in the cache.
 */
function getOrCreateEnvironmentInjector(parentInjector, tDetails, providers) {
    return parentInjector
        .get(CachedInjectorService)
        .getOrCreateInjector(tDetails, parentInjector, providers, ngDevMode ? 'DeferBlock Injector' : '');
}
/**
 * Creates a new injector, which contains providers collected from dependencies (NgModules) of
 * defer-loaded components. This function detects different types of parent injectors and creates
 * a new injector based on that.
 */
function createDeferBlockInjector(parentInjector, tDetails, providers) {
    // Check if the parent injector is an instance of a `ChainedInjector`.
    //
    // In this case, we retain the shape of the injector and use a newly created
    // `EnvironmentInjector` as a parent in the `ChainedInjector`. That is needed to
    // make sure that the primary injector gets consulted first (since it's typically
    // a NodeInjector) and `EnvironmentInjector` tree is consulted after that.
    if (parentInjector instanceof ChainedInjector) {
        const origInjector = parentInjector.injector;
        // Guaranteed to be an environment injector
        const parentEnvInjector = parentInjector.parentInjector;
        const envInjector = getOrCreateEnvironmentInjector(parentEnvInjector, tDetails, providers);
        return new ChainedInjector(origInjector, envInjector);
    }
    const parentEnvInjector = parentInjector.get(EnvironmentInjector);
    // If the `parentInjector` is *not* an `EnvironmentInjector` - we need to create
    // a new `ChainedInjector` with the following setup:
    //
    //  - the provided `parentInjector` becomes a primary injector
    //  - an existing (real) `EnvironmentInjector` becomes a parent injector for
    //    a newly-created one, which contains extra providers
    //
    // So the final order in which injectors would be consulted in this case would look like this:
    //
    //  1. Provided `parentInjector`
    //  2. Newly-created `EnvironmentInjector` with extra providers
    //  3. `EnvironmentInjector` from the `parentInjector`
    if (parentEnvInjector !== parentInjector) {
        const envInjector = getOrCreateEnvironmentInjector(parentEnvInjector, tDetails, providers);
        return new ChainedInjector(parentInjector, envInjector);
    }
    // The `parentInjector` is an instance of an `EnvironmentInjector`.
    // No need for special handling, we can use `parentInjector` as a
    // parent injector directly.
    return getOrCreateEnvironmentInjector(parentInjector, tDetails, providers);
}
/**
 * Applies changes to the DOM to reflect a given state.
 */
function applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView) {
    const stateTmplIndex = getTemplateIndexForState(newState, hostLView, tNode);
    if (stateTmplIndex !== null) {
        lDetails[DEFER_BLOCK_STATE] = newState;
        const hostTView = hostLView[TVIEW];
        const adjustedIndex = stateTmplIndex + HEADER_OFFSET;
        const activeBlockTNode = getTNode(hostTView, adjustedIndex);
        // There is only 1 view that can be present in an LContainer that
        // represents a defer block, so always refer to the first one.
        const viewIndex = 0;
        removeLViewFromLContainer(lContainer, viewIndex);
        let injector;
        if (newState === DeferBlockState.Complete) {
            // When we render a defer block in completed state, there might be
            // newly loaded standalone components used within the block, which may
            // import NgModules with providers. In order to make those providers
            // available for components declared in that NgModule, we create an instance
            // of an environment injector to host those providers and pass this injector
            // to the logic that creates a view.
            const tDetails = getTDeferBlockDetails(hostTView, tNode);
            const providers = tDetails.providers;
            if (providers && providers.length > 0) {
                injector = createDeferBlockInjector(hostLView[INJECTOR], tDetails, providers);
            }
        }
        const dehydratedView = findMatchingDehydratedView(lContainer, activeBlockTNode.tView.ssrId);
        const embeddedLView = createAndRenderEmbeddedLView(hostLView, activeBlockTNode, null, {
            dehydratedView,
            injector,
        });
        addLViewToLContainer(lContainer, embeddedLView, viewIndex, shouldAddViewToDom(activeBlockTNode, dehydratedView));
        markViewDirty(embeddedLView, 2 /* NotificationSource.DeferBlockStateUpdate */);
    }
}
/**
 * Extends the `applyDeferBlockState` with timer-based scheduling.
 * This function becomes available on a page if there are defer blocks
 * that use `after` or `minimum` parameters in the `@loading` or
 * `@placeholder` blocks.
 */
function applyDeferBlockStateWithScheduling(newState, lDetails, lContainer, tNode, hostLView) {
    const now = Date.now();
    const hostTView = hostLView[TVIEW];
    const tDetails = getTDeferBlockDetails(hostTView, tNode);
    if (lDetails[STATE_IS_FROZEN_UNTIL] === null || lDetails[STATE_IS_FROZEN_UNTIL] <= now) {
        lDetails[STATE_IS_FROZEN_UNTIL] = null;
        const loadingAfter = getLoadingBlockAfter(tDetails);
        const inLoadingAfterPhase = lDetails[LOADING_AFTER_CLEANUP_FN] !== null;
        if (newState === DeferBlockState.Loading && loadingAfter !== null && !inLoadingAfterPhase) {
            // Trying to render loading, but it has an `after` config,
            // so schedule an update action after a timeout.
            lDetails[NEXT_DEFER_BLOCK_STATE] = newState;
            const cleanupFn = scheduleDeferBlockUpdate(loadingAfter, lDetails, tNode, lContainer, hostLView);
            lDetails[LOADING_AFTER_CLEANUP_FN] = cleanupFn;
        }
        else {
            // If we transition to a complete or an error state and there is a pending
            // operation to render loading after a timeout - invoke a cleanup operation,
            // which stops the timer.
            if (newState > DeferBlockState.Loading && inLoadingAfterPhase) {
                lDetails[LOADING_AFTER_CLEANUP_FN]();
                lDetails[LOADING_AFTER_CLEANUP_FN] = null;
                lDetails[NEXT_DEFER_BLOCK_STATE] = null;
            }
            applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView);
            const duration = getMinimumDurationForState(tDetails, newState);
            if (duration !== null) {
                lDetails[STATE_IS_FROZEN_UNTIL] = now + duration;
                scheduleDeferBlockUpdate(duration, lDetails, tNode, lContainer, hostLView);
            }
        }
    }
    else {
        // We are still rendering the previous state.
        // Update the `NEXT_DEFER_BLOCK_STATE`, which would be
        // picked up once it's time to transition to the next state.
        lDetails[NEXT_DEFER_BLOCK_STATE] = newState;
    }
}
/**
 * Schedules an update operation after a specified timeout.
 */
function scheduleDeferBlockUpdate(timeout, lDetails, tNode, lContainer, hostLView) {
    const callback = () => {
        const nextState = lDetails[NEXT_DEFER_BLOCK_STATE];
        lDetails[STATE_IS_FROZEN_UNTIL] = null;
        lDetails[NEXT_DEFER_BLOCK_STATE] = null;
        if (nextState !== null) {
            renderDeferBlockState(nextState, tNode, lContainer);
        }
    };
    return scheduleTimerTrigger(timeout, callback, hostLView);
}
/**
 * Checks whether we can transition to the next state.
 *
 * We transition to the next state if the previous state was represented
 * with a number that is less than the next state. For example, if the current
 * state is "loading" (represented as `1`), we should not show a placeholder
 * (represented as `0`), but we can show a completed state (represented as `2`)
 * or an error state (represented as `3`).
 */
function isValidStateChange(currentState, newState) {
    return currentState < newState;
}
/**
 * Trigger prefetching of dependencies for a defer block.
 *
 * @param tDetails Static information about this defer block.
 * @param lView LView of a host view.
 */
export function triggerPrefetching(tDetails, lView, tNode) {
    if (lView[INJECTOR] && shouldTriggerDeferBlock(lView[INJECTOR])) {
        triggerResourceLoading(tDetails, lView, tNode);
    }
}
/**
 * Trigger loading of defer block dependencies if the process hasn't started yet.
 *
 * @param tDetails Static information about this defer block.
 * @param lView LView of a host view.
 */
export function triggerResourceLoading(tDetails, lView, tNode) {
    const injector = lView[INJECTOR];
    const tView = lView[TVIEW];
    if (tDetails.loadingState !== DeferDependenciesLoadingState.NOT_STARTED) {
        // If the loading status is different from initial one, it means that
        // the loading of dependencies is in progress and there is nothing to do
        // in this function. All details can be obtained from the `tDetails` object.
        return tDetails.loadingPromise ?? Promise.resolve();
    }
    const lDetails = getLDeferBlockDetails(lView, tNode);
    const primaryBlockTNode = getPrimaryBlockTNode(tView, tDetails);
    // Switch from NOT_STARTED -> IN_PROGRESS state.
    tDetails.loadingState = DeferDependenciesLoadingState.IN_PROGRESS;
    // Prefetching is triggered, cleanup all registered prefetch triggers.
    invokeTriggerCleanupFns(1 /* TriggerType.Prefetch */, lDetails);
    let dependenciesFn = tDetails.dependencyResolverFn;
    if (ngDevMode) {
        // Check if dependency function interceptor is configured.
        const deferDependencyInterceptor = injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, {
            optional: true,
        });
        if (deferDependencyInterceptor) {
            dependenciesFn = deferDependencyInterceptor.intercept(dependenciesFn);
        }
    }
    // Indicate that an application is not stable and has a pending task.
    const pendingTasks = injector.get(PendingTasks);
    const taskId = pendingTasks.add();
    // The `dependenciesFn` might be `null` when all dependencies within
    // a given defer block were eagerly referenced elsewhere in a file,
    // thus no dynamic `import()`s were produced.
    if (!dependenciesFn) {
        tDetails.loadingPromise = Promise.resolve().then(() => {
            tDetails.loadingPromise = null;
            tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
            pendingTasks.remove(taskId);
        });
        return tDetails.loadingPromise;
    }
    // Start downloading of defer block dependencies.
    tDetails.loadingPromise = Promise.allSettled(dependenciesFn()).then((results) => {
        let failed = false;
        const directiveDefs = [];
        const pipeDefs = [];
        for (const result of results) {
            if (result.status === 'fulfilled') {
                const dependency = result.value;
                const directiveDef = getComponentDef(dependency) || getDirectiveDef(dependency);
                if (directiveDef) {
                    directiveDefs.push(directiveDef);
                }
                else {
                    const pipeDef = getPipeDef(dependency);
                    if (pipeDef) {
                        pipeDefs.push(pipeDef);
                    }
                }
            }
            else {
                failed = true;
                break;
            }
        }
        // Loading is completed, we no longer need the loading Promise
        // and a pending task should also be removed.
        tDetails.loadingPromise = null;
        pendingTasks.remove(taskId);
        if (failed) {
            tDetails.loadingState = DeferDependenciesLoadingState.FAILED;
            if (tDetails.errorTmplIndex === null) {
                const templateLocation = ngDevMode ? getTemplateLocationDetails(lView) : '';
                const error = new RuntimeError(750 /* RuntimeErrorCode.DEFER_LOADING_FAILED */, ngDevMode &&
                    'Loading dependencies for `@defer` block failed, ' +
                        `but no \`@error\` block was configured${templateLocation}. ` +
                        'Consider using the `@error` block to render an error state.');
                handleError(lView, error);
            }
        }
        else {
            tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;
            // Update directive and pipe registries to add newly downloaded dependencies.
            const primaryBlockTView = primaryBlockTNode.tView;
            if (directiveDefs.length > 0) {
                primaryBlockTView.directiveRegistry = addDepsToRegistry(primaryBlockTView.directiveRegistry, directiveDefs);
                // Extract providers from all NgModules imported by standalone components
                // used within this defer block.
                const directiveTypes = directiveDefs.map((def) => def.type);
                const providers = internalImportProvidersFrom(false, ...directiveTypes);
                tDetails.providers = providers;
            }
            if (pipeDefs.length > 0) {
                primaryBlockTView.pipeRegistry = addDepsToRegistry(primaryBlockTView.pipeRegistry, pipeDefs);
            }
        }
    });
    return tDetails.loadingPromise;
}
/** Utility function to render placeholder content (if present) */
function renderPlaceholder(lView, tNode) {
    const lContainer = lView[tNode.index];
    ngDevMode && assertLContainer(lContainer);
    renderDeferBlockState(DeferBlockState.Placeholder, tNode, lContainer);
}
/**
 * Subscribes to the "loading" Promise and renders corresponding defer sub-block,
 * based on the loading results.
 *
 * @param lContainer Represents an instance of a defer block.
 * @param tNode Represents defer block info shared across all instances.
 */
function renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer) {
    ngDevMode &&
        assertDefined(tDetails.loadingPromise, 'Expected loading Promise to exist on this defer block');
    tDetails.loadingPromise.then(() => {
        if (tDetails.loadingState === DeferDependenciesLoadingState.COMPLETE) {
            ngDevMode && assertDeferredDependenciesLoaded(tDetails);
            // Everything is loaded, show the primary block content
            renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);
        }
        else if (tDetails.loadingState === DeferDependenciesLoadingState.FAILED) {
            renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);
        }
    });
}
/**
 * Attempts to trigger loading of defer block dependencies.
 * If the block is already in a loading, completed or an error state -
 * no additional actions are taken.
 */
function triggerDeferBlock(lView, tNode) {
    const tView = lView[TVIEW];
    const lContainer = lView[tNode.index];
    const injector = lView[INJECTOR];
    ngDevMode && assertLContainer(lContainer);
    if (!shouldTriggerDeferBlock(injector))
        return;
    const lDetails = getLDeferBlockDetails(lView, tNode);
    const tDetails = getTDeferBlockDetails(tView, tNode);
    // Defer block is triggered, cleanup all registered trigger functions.
    invokeAllTriggerCleanupFns(lDetails);
    switch (tDetails.loadingState) {
        case DeferDependenciesLoadingState.NOT_STARTED:
            renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
            triggerResourceLoading(tDetails, lView, tNode);
            // The `loadingState` might have changed to "loading".
            if (tDetails.loadingState ===
                DeferDependenciesLoadingState.IN_PROGRESS) {
                renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
            }
            break;
        case DeferDependenciesLoadingState.IN_PROGRESS:
            renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);
            renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);
            break;
        case DeferDependenciesLoadingState.COMPLETE:
            ngDevMode && assertDeferredDependenciesLoaded(tDetails);
            renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);
            break;
        case DeferDependenciesLoadingState.FAILED:
            renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);
            break;
        default:
            if (ngDevMode) {
                throwError('Unknown defer block state');
            }
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instructions.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/defer/instructions.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport {setActiveConsumer} from '@angular/core/primitives/signals';\n\nimport {CachedInjectorService} from '../cached_injector_service';\nimport {NotificationSource} from '../change_detection/scheduling/zoneless_scheduling';\nimport {EnvironmentInjector, InjectionToken, Injector, Provider} from '../di';\nimport {internalImportProvidersFrom} from '../di/provider_collection';\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {findMatchingDehydratedView} from '../hydration/views';\nimport {populateDehydratedViewsInLContainer} from '../linker/view_container_ref';\nimport {PendingTasks} from '../pending_tasks';\nimport {assertLContainer, assertTNodeForLView} from '../render3/assert';\nimport {bindingUpdated} from '../render3/bindings';\nimport {ChainedInjector} from '../render3/chained_injector';\nimport {getComponentDef, getDirectiveDef, getPipeDef} from '../render3/definition';\nimport {getTemplateLocationDetails} from '../render3/instructions/element_validation';\nimport {markViewDirty} from '../render3/instructions/mark_view_dirty';\nimport {handleError} from '../render3/instructions/shared';\nimport {declareTemplate} from '../render3/instructions/template';\nimport {LContainer} from '../render3/interfaces/container';\nimport {DirectiveDefList, PipeDefList} from '../render3/interfaces/definition';\nimport {TContainerNode, TNode} from '../render3/interfaces/node';\nimport {isDestroyed} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, INJECTOR, LView, PARENT, TVIEW, TView} from '../render3/interfaces/view';\nimport {\n  getCurrentTNode,\n  getLView,\n  getSelectedTNode,\n  getTView,\n  nextBindingIndex,\n} from '../render3/state';\nimport {isPlatformBrowser} from '../render3/util/misc_utils';\nimport {\n  getConstant,\n  getTNode,\n  removeLViewOnDestroy,\n  storeLViewOnDestroy,\n} from '../render3/util/view_utils';\nimport {\n  addLViewToLContainer,\n  createAndRenderEmbeddedLView,\n  removeLViewFromLContainer,\n  shouldAddViewToDom,\n} from '../render3/view_manipulation';\nimport {assertDefined, throwError} from '../util/assert';\nimport {performanceMarkFeature} from '../util/performance';\n\nimport {\n  invokeAllTriggerCleanupFns,\n  invokeTriggerCleanupFns,\n  storeTriggerCleanupFn,\n} from './cleanup';\nimport {onHover, onInteraction, onViewport, registerDomTrigger} from './dom_triggers';\nimport {onIdle} from './idle_scheduler';\nimport {\n  DEFER_BLOCK_STATE,\n  DeferBlockBehavior,\n  DeferBlockConfig,\n  DeferBlockDependencyInterceptor,\n  DeferBlockInternalState,\n  DeferBlockState,\n  DeferDependenciesLoadingState,\n  DeferredLoadingBlockConfig,\n  DeferredPlaceholderBlockConfig,\n  DependencyResolverFn,\n  LDeferBlockDetails,\n  LOADING_AFTER_CLEANUP_FN,\n  NEXT_DEFER_BLOCK_STATE,\n  STATE_IS_FROZEN_UNTIL,\n  TDeferBlockDetails,\n  TriggerType,\n} from './interfaces';\nimport {onTimer, scheduleTimerTrigger} from './timer_scheduler';\nimport {\n  addDepsToRegistry,\n  assertDeferredDependenciesLoaded,\n  getLDeferBlockDetails,\n  getLoadingBlockAfter,\n  getMinimumDurationForState,\n  getPrimaryBlockTNode,\n  getTDeferBlockDetails,\n  getTemplateIndexForState,\n  setLDeferBlockDetails,\n  setTDeferBlockDetails,\n} from './utils';\n\n/**\n * **INTERNAL**, avoid referencing it in application code.\n * *\n * Injector token that allows to provide `DeferBlockDependencyInterceptor` class\n * implementation.\n *\n * This token is only injected in devMode\n */\nexport const DEFER_BLOCK_DEPENDENCY_INTERCEPTOR =\n  new InjectionToken<DeferBlockDependencyInterceptor>('DEFER_BLOCK_DEPENDENCY_INTERCEPTOR');\n\n/**\n * **INTERNAL**, token used for configuring defer block behavior.\n */\nexport const DEFER_BLOCK_CONFIG = new InjectionToken<DeferBlockConfig>(\n  ngDevMode ? 'DEFER_BLOCK_CONFIG' : '',\n);\n\n/**\n * Returns whether defer blocks should be triggered.\n *\n * Currently, defer blocks are not triggered on the server,\n * only placeholder content is rendered (if provided).\n */\nfunction shouldTriggerDeferBlock(injector: Injector): boolean {\n  const config = injector.get(DEFER_BLOCK_CONFIG, null, {optional: true});\n  if (config?.behavior === DeferBlockBehavior.Manual) {\n    return false;\n  }\n  return isPlatformBrowser(injector);\n}\n\n/**\n * Reference to the timer-based scheduler implementation of defer block state\n * rendering method. It's used to make timer-based scheduling tree-shakable.\n * If `minimum` or `after` parameters are used, compiler generates an extra\n * argument for the `ɵɵdefer` instruction, which references a timer-based\n * implementation.\n */\nlet applyDeferBlockStateWithSchedulingImpl: typeof applyDeferBlockState | null = null;\n\n/**\n * Enables timer-related scheduling if `after` or `minimum` parameters are setup\n * on the `@loading` or `@placeholder` blocks.\n */\nexport function ɵɵdeferEnableTimerScheduling(\n  tView: TView,\n  tDetails: TDeferBlockDetails,\n  placeholderConfigIndex?: number | null,\n  loadingConfigIndex?: number | null,\n) {\n  const tViewConsts = tView.consts;\n  if (placeholderConfigIndex != null) {\n    tDetails.placeholderBlockConfig = getConstant<DeferredPlaceholderBlockConfig>(\n      tViewConsts,\n      placeholderConfigIndex,\n    );\n  }\n  if (loadingConfigIndex != null) {\n    tDetails.loadingBlockConfig = getConstant<DeferredLoadingBlockConfig>(\n      tViewConsts,\n      loadingConfigIndex,\n    );\n  }\n\n  // Enable implementation that supports timer-based scheduling.\n  if (applyDeferBlockStateWithSchedulingImpl === null) {\n    applyDeferBlockStateWithSchedulingImpl = applyDeferBlockStateWithScheduling;\n  }\n}\n\n/**\n * Creates runtime data structures for defer blocks.\n *\n * @param index Index of the `defer` instruction.\n * @param primaryTmplIndex Index of the template with the primary block content.\n * @param dependencyResolverFn Function that contains dependencies for this defer block.\n * @param loadingTmplIndex Index of the template with the loading block content.\n * @param placeholderTmplIndex Index of the template with the placeholder block content.\n * @param errorTmplIndex Index of the template with the error block content.\n * @param loadingConfigIndex Index in the constants array of the configuration of the loading.\n *     block.\n * @param placeholderConfigIndex Index in the constants array of the configuration of the\n *     placeholder block.\n * @param enableTimerScheduling Function that enables timer-related scheduling if `after`\n *     or `minimum` parameters are setup on the `@loading` or `@placeholder` blocks.\n *\n * @codeGenApi\n */\nexport function ɵɵdefer(\n  index: number,\n  primaryTmplIndex: number,\n  dependencyResolverFn?: DependencyResolverFn | null,\n  loadingTmplIndex?: number | null,\n  placeholderTmplIndex?: number | null,\n  errorTmplIndex?: number | null,\n  loadingConfigIndex?: number | null,\n  placeholderConfigIndex?: number | null,\n  enableTimerScheduling?: typeof ɵɵdeferEnableTimerScheduling,\n) {\n  const lView = getLView();\n  const tView = getTView();\n  const adjustedIndex = index + HEADER_OFFSET;\n  const tNode = declareTemplate(lView, tView, index, null, 0, 0);\n\n  if (tView.firstCreatePass) {\n    performanceMarkFeature('NgDefer');\n\n    const tDetails: TDeferBlockDetails = {\n      primaryTmplIndex,\n      loadingTmplIndex: loadingTmplIndex ?? null,\n      placeholderTmplIndex: placeholderTmplIndex ?? null,\n      errorTmplIndex: errorTmplIndex ?? null,\n      placeholderBlockConfig: null,\n      loadingBlockConfig: null,\n      dependencyResolverFn: dependencyResolverFn ?? null,\n      loadingState: DeferDependenciesLoadingState.NOT_STARTED,\n      loadingPromise: null,\n      providers: null,\n    };\n    enableTimerScheduling?.(tView, tDetails, placeholderConfigIndex, loadingConfigIndex);\n    setTDeferBlockDetails(tView, adjustedIndex, tDetails);\n  }\n\n  const lContainer = lView[adjustedIndex];\n\n  // If hydration is enabled, looks up dehydrated views in the DOM\n  // using hydration annotation info and stores those views on LContainer.\n  // In client-only mode, this function is a noop.\n  populateDehydratedViewsInLContainer(lContainer, tNode, lView);\n\n  // Init instance-specific defer details and store it.\n  const lDetails: LDeferBlockDetails = [\n    null, // NEXT_DEFER_BLOCK_STATE\n    DeferBlockInternalState.Initial, // DEFER_BLOCK_STATE\n    null, // STATE_IS_FROZEN_UNTIL\n    null, // LOADING_AFTER_CLEANUP_FN\n    null, // TRIGGER_CLEANUP_FNS\n    null, // PREFETCH_TRIGGER_CLEANUP_FNS\n  ];\n  setLDeferBlockDetails(lView, adjustedIndex, lDetails);\n\n  const cleanupTriggersFn = () => invokeAllTriggerCleanupFns(lDetails);\n\n  // When defer block is triggered - unsubscribe from LView destroy cleanup.\n  storeTriggerCleanupFn(TriggerType.Regular, lDetails, () =>\n    removeLViewOnDestroy(lView, cleanupTriggersFn),\n  );\n  storeLViewOnDestroy(lView, cleanupTriggersFn);\n}\n\n/**\n * Loads defer block dependencies when a trigger value becomes truthy.\n * @codeGenApi\n */\nexport function ɵɵdeferWhen(rawValue: unknown) {\n  const lView = getLView();\n  const bindingIndex = nextBindingIndex();\n  if (bindingUpdated(lView, bindingIndex, rawValue)) {\n    const prevConsumer = setActiveConsumer(null);\n    try {\n      const value = Boolean(rawValue); // handle truthy or falsy values\n      const tNode = getSelectedTNode();\n      const lDetails = getLDeferBlockDetails(lView, tNode);\n      const renderedState = lDetails[DEFER_BLOCK_STATE];\n      if (value === false && renderedState === DeferBlockInternalState.Initial) {\n        // If nothing is rendered yet, render a placeholder (if defined).\n        renderPlaceholder(lView, tNode);\n      } else if (\n        value === true &&\n        (renderedState === DeferBlockInternalState.Initial ||\n          renderedState === DeferBlockState.Placeholder)\n      ) {\n        // The `when` condition has changed to `true`, trigger defer block loading\n        // if the block is either in initial (nothing is rendered) or a placeholder\n        // state.\n        triggerDeferBlock(lView, tNode);\n      }\n    } finally {\n      setActiveConsumer(prevConsumer);\n    }\n  }\n}\n\n/**\n * Prefetches the deferred content when a value becomes truthy.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchWhen(rawValue: unknown) {\n  const lView = getLView();\n  const bindingIndex = nextBindingIndex();\n\n  if (bindingUpdated(lView, bindingIndex, rawValue)) {\n    const prevConsumer = setActiveConsumer(null);\n    try {\n      const value = Boolean(rawValue); // handle truthy or falsy values\n      const tView = lView[TVIEW];\n      const tNode = getSelectedTNode();\n      const tDetails = getTDeferBlockDetails(tView, tNode);\n      if (value === true && tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n        // If loading has not been started yet, trigger it now.\n        triggerPrefetching(tDetails, lView, tNode);\n      }\n    } finally {\n      setActiveConsumer(prevConsumer);\n    }\n  }\n}\n\n/**\n * Sets up logic to handle the `on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnIdle() {\n  scheduleDelayedTrigger(onIdle);\n}\n\n/**\n * Sets up logic to handle the `prefetch on idle` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnIdle() {\n  scheduleDelayedPrefetching(onIdle);\n}\n\n/**\n * Sets up logic to handle the `on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnImmediate() {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const injector = lView[INJECTOR]!;\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  // Render placeholder block only if loading template is not present and we're on\n  // the client to avoid content flickering, since it would be immediately replaced\n  // by the loading block.\n  if (!shouldTriggerDeferBlock(injector) || tDetails.loadingTmplIndex === null) {\n    renderPlaceholder(lView, tNode);\n  }\n  triggerDeferBlock(lView, tNode);\n}\n\n/**\n * Sets up logic to handle the `prefetch on immediate` deferred trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnImmediate() {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n    triggerResourceLoading(tDetails, lView, tNode);\n  }\n}\n\n/**\n * Creates runtime data structures for the `on timer` deferred trigger.\n * @param delay Amount of time to wait before loading the content.\n * @codeGenApi\n */\nexport function ɵɵdeferOnTimer(delay: number) {\n  scheduleDelayedTrigger(onTimer(delay));\n}\n\n/**\n * Creates runtime data structures for the `prefetch on timer` deferred trigger.\n * @param delay Amount of time to wait before prefetching the content.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnTimer(delay: number) {\n  scheduleDelayedPrefetching(onTimer(delay));\n}\n\n/**\n * Creates runtime data structures for the `on hover` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnHover(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n\n  renderPlaceholder(lView, tNode);\n  registerDomTrigger(\n    lView,\n    tNode,\n    triggerIndex,\n    walkUpTimes,\n    onHover,\n    () => triggerDeferBlock(lView, tNode),\n    TriggerType.Regular,\n  );\n}\n\n/**\n * Creates runtime data structures for the `prefetch on hover` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnHover(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n    registerDomTrigger(\n      lView,\n      tNode,\n      triggerIndex,\n      walkUpTimes,\n      onHover,\n      () => triggerPrefetching(tDetails, lView, tNode),\n      TriggerType.Prefetch,\n    );\n  }\n}\n\n/**\n * Creates runtime data structures for the `on interaction` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnInteraction(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n\n  renderPlaceholder(lView, tNode);\n  registerDomTrigger(\n    lView,\n    tNode,\n    triggerIndex,\n    walkUpTimes,\n    onInteraction,\n    () => triggerDeferBlock(lView, tNode),\n    TriggerType.Regular,\n  );\n}\n\n/**\n * Creates runtime data structures for the `prefetch on interaction` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnInteraction(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n    registerDomTrigger(\n      lView,\n      tNode,\n      triggerIndex,\n      walkUpTimes,\n      onInteraction,\n      () => triggerPrefetching(tDetails, lView, tNode),\n      TriggerType.Prefetch,\n    );\n  }\n}\n\n/**\n * Creates runtime data structures for the `on viewport` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferOnViewport(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n\n  renderPlaceholder(lView, tNode);\n  registerDomTrigger(\n    lView,\n    tNode,\n    triggerIndex,\n    walkUpTimes,\n    onViewport,\n    () => triggerDeferBlock(lView, tNode),\n    TriggerType.Regular,\n  );\n}\n\n/**\n * Creates runtime data structures for the `prefetch on viewport` deferred trigger.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to walk up/down the tree hierarchy to find the trigger.\n * @codeGenApi\n */\nexport function ɵɵdeferPrefetchOnViewport(triggerIndex: number, walkUpTimes?: number) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n  const tView = lView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n    registerDomTrigger(\n      lView,\n      tNode,\n      triggerIndex,\n      walkUpTimes,\n      onViewport,\n      () => triggerPrefetching(tDetails, lView, tNode),\n      TriggerType.Prefetch,\n    );\n  }\n}\n\n/********** Helper functions **********/\n\n/**\n * Schedules triggering of a defer block for `on idle` and `on timer` conditions.\n */\nfunction scheduleDelayedTrigger(\n  scheduleFn: (callback: VoidFunction, lView: LView) => VoidFunction,\n) {\n  const lView = getLView();\n  const tNode = getCurrentTNode()!;\n\n  renderPlaceholder(lView, tNode);\n\n  // Only trigger the scheduled trigger on the browser\n  // since we don't want to delay the server response.\n  if (isPlatformBrowser(lView[INJECTOR]!)) {\n    const cleanupFn = scheduleFn(() => triggerDeferBlock(lView, tNode), lView);\n    const lDetails = getLDeferBlockDetails(lView, tNode);\n    storeTriggerCleanupFn(TriggerType.Regular, lDetails, cleanupFn);\n  }\n}\n\n/**\n * Schedules prefetching for `on idle` and `on timer` triggers.\n *\n * @param scheduleFn A function that does the scheduling.\n */\nfunction scheduleDelayedPrefetching(\n  scheduleFn: (callback: VoidFunction, lView: LView) => VoidFunction,\n) {\n  const lView = getLView();\n\n  // Only trigger the scheduled trigger on the browser\n  // since we don't want to delay the server response.\n  if (isPlatformBrowser(lView[INJECTOR]!)) {\n    const tNode = getCurrentTNode()!;\n    const tView = lView[TVIEW];\n    const tDetails = getTDeferBlockDetails(tView, tNode);\n\n    if (tDetails.loadingState === DeferDependenciesLoadingState.NOT_STARTED) {\n      const lDetails = getLDeferBlockDetails(lView, tNode);\n      const prefetch = () => triggerPrefetching(tDetails, lView, tNode);\n      const cleanupFn = scheduleFn(prefetch, lView);\n      storeTriggerCleanupFn(TriggerType.Prefetch, lDetails, cleanupFn);\n    }\n  }\n}\n\n/**\n * Transitions a defer block to the new state. Updates the  necessary\n * data structures and renders corresponding block.\n *\n * @param newState New state that should be applied to the defer block.\n * @param tNode TNode that represents a defer block.\n * @param lContainer Represents an instance of a defer block.\n * @param skipTimerScheduling Indicates that `@loading` and `@placeholder` block\n *   should be rendered immediately, even if they have `after` or `minimum` config\n *   options setup. This flag to needed for testing APIs to transition defer block\n *   between states via `DeferFixture.render` method.\n */\nexport function renderDeferBlockState(\n  newState: DeferBlockState,\n  tNode: TNode,\n  lContainer: LContainer,\n  skipTimerScheduling = false,\n): void {\n  const hostLView = lContainer[PARENT];\n  const hostTView = hostLView[TVIEW];\n\n  // Check if this view is not destroyed. Since the loading process was async,\n  // the view might end up being destroyed by the time rendering happens.\n  if (isDestroyed(hostLView)) return;\n\n  // Make sure this TNode belongs to TView that represents host LView.\n  ngDevMode && assertTNodeForLView(tNode, hostLView);\n\n  const lDetails = getLDeferBlockDetails(hostLView, tNode);\n\n  ngDevMode && assertDefined(lDetails, 'Expected a defer block state defined');\n\n  const currentState = lDetails[DEFER_BLOCK_STATE];\n\n  if (\n    isValidStateChange(currentState, newState) &&\n    isValidStateChange(lDetails[NEXT_DEFER_BLOCK_STATE] ?? -1, newState)\n  ) {\n    const injector = hostLView[INJECTOR]!;\n    const tDetails = getTDeferBlockDetails(hostTView, tNode);\n    // Skips scheduling on the server since it can delay the server response.\n    const needsScheduling =\n      !skipTimerScheduling &&\n      isPlatformBrowser(injector) &&\n      (getLoadingBlockAfter(tDetails) !== null ||\n        getMinimumDurationForState(tDetails, DeferBlockState.Loading) !== null ||\n        getMinimumDurationForState(tDetails, DeferBlockState.Placeholder));\n\n    if (ngDevMode && needsScheduling) {\n      assertDefined(\n        applyDeferBlockStateWithSchedulingImpl,\n        'Expected scheduling function to be defined',\n      );\n    }\n\n    const applyStateFn = needsScheduling\n      ? applyDeferBlockStateWithSchedulingImpl!\n      : applyDeferBlockState;\n    try {\n      applyStateFn(newState, lDetails, lContainer, tNode, hostLView);\n    } catch (error: unknown) {\n      handleError(hostLView, error);\n    }\n  }\n}\n\n/**\n * Checks whether there is a cached injector associated with a given defer block\n * declaration and returns if it exists. If there is no cached injector present -\n * creates a new injector and stores in the cache.\n */\nfunction getOrCreateEnvironmentInjector(\n  parentInjector: Injector,\n  tDetails: TDeferBlockDetails,\n  providers: Provider[],\n) {\n  return parentInjector\n    .get(CachedInjectorService)\n    .getOrCreateInjector(\n      tDetails,\n      parentInjector as EnvironmentInjector,\n      providers,\n      ngDevMode ? 'DeferBlock Injector' : '',\n    );\n}\n\n/**\n * Creates a new injector, which contains providers collected from dependencies (NgModules) of\n * defer-loaded components. This function detects different types of parent injectors and creates\n * a new injector based on that.\n */\nfunction createDeferBlockInjector(\n  parentInjector: Injector,\n  tDetails: TDeferBlockDetails,\n  providers: Provider[],\n) {\n  // Check if the parent injector is an instance of a `ChainedInjector`.\n  //\n  // In this case, we retain the shape of the injector and use a newly created\n  // `EnvironmentInjector` as a parent in the `ChainedInjector`. That is needed to\n  // make sure that the primary injector gets consulted first (since it's typically\n  // a NodeInjector) and `EnvironmentInjector` tree is consulted after that.\n  if (parentInjector instanceof ChainedInjector) {\n    const origInjector = parentInjector.injector;\n    // Guaranteed to be an environment injector\n    const parentEnvInjector = parentInjector.parentInjector;\n\n    const envInjector = getOrCreateEnvironmentInjector(parentEnvInjector, tDetails, providers);\n    return new ChainedInjector(origInjector, envInjector);\n  }\n\n  const parentEnvInjector = parentInjector.get(EnvironmentInjector);\n\n  // If the `parentInjector` is *not* an `EnvironmentInjector` - we need to create\n  // a new `ChainedInjector` with the following setup:\n  //\n  //  - the provided `parentInjector` becomes a primary injector\n  //  - an existing (real) `EnvironmentInjector` becomes a parent injector for\n  //    a newly-created one, which contains extra providers\n  //\n  // So the final order in which injectors would be consulted in this case would look like this:\n  //\n  //  1. Provided `parentInjector`\n  //  2. Newly-created `EnvironmentInjector` with extra providers\n  //  3. `EnvironmentInjector` from the `parentInjector`\n  if (parentEnvInjector !== parentInjector) {\n    const envInjector = getOrCreateEnvironmentInjector(parentEnvInjector, tDetails, providers);\n    return new ChainedInjector(parentInjector, envInjector);\n  }\n\n  // The `parentInjector` is an instance of an `EnvironmentInjector`.\n  // No need for special handling, we can use `parentInjector` as a\n  // parent injector directly.\n  return getOrCreateEnvironmentInjector(parentInjector, tDetails, providers);\n}\n\n/**\n * Applies changes to the DOM to reflect a given state.\n */\nfunction applyDeferBlockState(\n  newState: DeferBlockState,\n  lDetails: LDeferBlockDetails,\n  lContainer: LContainer,\n  tNode: TNode,\n  hostLView: LView<unknown>,\n) {\n  const stateTmplIndex = getTemplateIndexForState(newState, hostLView, tNode);\n\n  if (stateTmplIndex !== null) {\n    lDetails[DEFER_BLOCK_STATE] = newState;\n    const hostTView = hostLView[TVIEW];\n    const adjustedIndex = stateTmplIndex + HEADER_OFFSET;\n    const activeBlockTNode = getTNode(hostTView, adjustedIndex) as TContainerNode;\n\n    // There is only 1 view that can be present in an LContainer that\n    // represents a defer block, so always refer to the first one.\n    const viewIndex = 0;\n\n    removeLViewFromLContainer(lContainer, viewIndex);\n\n    let injector: Injector | undefined;\n    if (newState === DeferBlockState.Complete) {\n      // When we render a defer block in completed state, there might be\n      // newly loaded standalone components used within the block, which may\n      // import NgModules with providers. In order to make those providers\n      // available for components declared in that NgModule, we create an instance\n      // of an environment injector to host those providers and pass this injector\n      // to the logic that creates a view.\n      const tDetails = getTDeferBlockDetails(hostTView, tNode);\n      const providers = tDetails.providers;\n      if (providers && providers.length > 0) {\n        injector = createDeferBlockInjector(hostLView[INJECTOR]!, tDetails, providers);\n      }\n    }\n    const dehydratedView = findMatchingDehydratedView(lContainer, activeBlockTNode.tView!.ssrId);\n    const embeddedLView = createAndRenderEmbeddedLView(hostLView, activeBlockTNode, null, {\n      dehydratedView,\n      injector,\n    });\n    addLViewToLContainer(\n      lContainer,\n      embeddedLView,\n      viewIndex,\n      shouldAddViewToDom(activeBlockTNode, dehydratedView),\n    );\n    markViewDirty(embeddedLView, NotificationSource.DeferBlockStateUpdate);\n  }\n}\n\n/**\n * Extends the `applyDeferBlockState` with timer-based scheduling.\n * This function becomes available on a page if there are defer blocks\n * that use `after` or `minimum` parameters in the `@loading` or\n * `@placeholder` blocks.\n */\nfunction applyDeferBlockStateWithScheduling(\n  newState: DeferBlockState,\n  lDetails: LDeferBlockDetails,\n  lContainer: LContainer,\n  tNode: TNode,\n  hostLView: LView<unknown>,\n) {\n  const now = Date.now();\n  const hostTView = hostLView[TVIEW];\n  const tDetails = getTDeferBlockDetails(hostTView, tNode);\n\n  if (lDetails[STATE_IS_FROZEN_UNTIL] === null || lDetails[STATE_IS_FROZEN_UNTIL] <= now) {\n    lDetails[STATE_IS_FROZEN_UNTIL] = null;\n\n    const loadingAfter = getLoadingBlockAfter(tDetails);\n    const inLoadingAfterPhase = lDetails[LOADING_AFTER_CLEANUP_FN] !== null;\n    if (newState === DeferBlockState.Loading && loadingAfter !== null && !inLoadingAfterPhase) {\n      // Trying to render loading, but it has an `after` config,\n      // so schedule an update action after a timeout.\n      lDetails[NEXT_DEFER_BLOCK_STATE] = newState;\n      const cleanupFn = scheduleDeferBlockUpdate(\n        loadingAfter,\n        lDetails,\n        tNode,\n        lContainer,\n        hostLView,\n      );\n      lDetails[LOADING_AFTER_CLEANUP_FN] = cleanupFn;\n    } else {\n      // If we transition to a complete or an error state and there is a pending\n      // operation to render loading after a timeout - invoke a cleanup operation,\n      // which stops the timer.\n      if (newState > DeferBlockState.Loading && inLoadingAfterPhase) {\n        lDetails[LOADING_AFTER_CLEANUP_FN]!();\n        lDetails[LOADING_AFTER_CLEANUP_FN] = null;\n        lDetails[NEXT_DEFER_BLOCK_STATE] = null;\n      }\n\n      applyDeferBlockState(newState, lDetails, lContainer, tNode, hostLView);\n\n      const duration = getMinimumDurationForState(tDetails, newState);\n      if (duration !== null) {\n        lDetails[STATE_IS_FROZEN_UNTIL] = now + duration;\n        scheduleDeferBlockUpdate(duration, lDetails, tNode, lContainer, hostLView);\n      }\n    }\n  } else {\n    // We are still rendering the previous state.\n    // Update the `NEXT_DEFER_BLOCK_STATE`, which would be\n    // picked up once it's time to transition to the next state.\n    lDetails[NEXT_DEFER_BLOCK_STATE] = newState;\n  }\n}\n\n/**\n * Schedules an update operation after a specified timeout.\n */\nfunction scheduleDeferBlockUpdate(\n  timeout: number,\n  lDetails: LDeferBlockDetails,\n  tNode: TNode,\n  lContainer: LContainer,\n  hostLView: LView<unknown>,\n): VoidFunction {\n  const callback = () => {\n    const nextState = lDetails[NEXT_DEFER_BLOCK_STATE];\n    lDetails[STATE_IS_FROZEN_UNTIL] = null;\n    lDetails[NEXT_DEFER_BLOCK_STATE] = null;\n    if (nextState !== null) {\n      renderDeferBlockState(nextState, tNode, lContainer);\n    }\n  };\n  return scheduleTimerTrigger(timeout, callback, hostLView);\n}\n\n/**\n * Checks whether we can transition to the next state.\n *\n * We transition to the next state if the previous state was represented\n * with a number that is less than the next state. For example, if the current\n * state is \"loading\" (represented as `1`), we should not show a placeholder\n * (represented as `0`), but we can show a completed state (represented as `2`)\n * or an error state (represented as `3`).\n */\nfunction isValidStateChange(\n  currentState: DeferBlockState | DeferBlockInternalState,\n  newState: DeferBlockState,\n): boolean {\n  return currentState < newState;\n}\n\n/**\n * Trigger prefetching of dependencies for a defer block.\n *\n * @param tDetails Static information about this defer block.\n * @param lView LView of a host view.\n */\nexport function triggerPrefetching(tDetails: TDeferBlockDetails, lView: LView, tNode: TNode) {\n  if (lView[INJECTOR] && shouldTriggerDeferBlock(lView[INJECTOR]!)) {\n    triggerResourceLoading(tDetails, lView, tNode);\n  }\n}\n\n/**\n * Trigger loading of defer block dependencies if the process hasn't started yet.\n *\n * @param tDetails Static information about this defer block.\n * @param lView LView of a host view.\n */\nexport function triggerResourceLoading(\n  tDetails: TDeferBlockDetails,\n  lView: LView,\n  tNode: TNode,\n): Promise<unknown> {\n  const injector = lView[INJECTOR]!;\n  const tView = lView[TVIEW];\n\n  if (tDetails.loadingState !== DeferDependenciesLoadingState.NOT_STARTED) {\n    // If the loading status is different from initial one, it means that\n    // the loading of dependencies is in progress and there is nothing to do\n    // in this function. All details can be obtained from the `tDetails` object.\n    return tDetails.loadingPromise ?? Promise.resolve();\n  }\n\n  const lDetails = getLDeferBlockDetails(lView, tNode);\n  const primaryBlockTNode = getPrimaryBlockTNode(tView, tDetails);\n\n  // Switch from NOT_STARTED -> IN_PROGRESS state.\n  tDetails.loadingState = DeferDependenciesLoadingState.IN_PROGRESS;\n\n  // Prefetching is triggered, cleanup all registered prefetch triggers.\n  invokeTriggerCleanupFns(TriggerType.Prefetch, lDetails);\n\n  let dependenciesFn = tDetails.dependencyResolverFn;\n\n  if (ngDevMode) {\n    // Check if dependency function interceptor is configured.\n    const deferDependencyInterceptor = injector.get(DEFER_BLOCK_DEPENDENCY_INTERCEPTOR, null, {\n      optional: true,\n    });\n\n    if (deferDependencyInterceptor) {\n      dependenciesFn = deferDependencyInterceptor.intercept(dependenciesFn);\n    }\n  }\n\n  // Indicate that an application is not stable and has a pending task.\n  const pendingTasks = injector.get(PendingTasks);\n  const taskId = pendingTasks.add();\n\n  // The `dependenciesFn` might be `null` when all dependencies within\n  // a given defer block were eagerly referenced elsewhere in a file,\n  // thus no dynamic `import()`s were produced.\n  if (!dependenciesFn) {\n    tDetails.loadingPromise = Promise.resolve().then(() => {\n      tDetails.loadingPromise = null;\n      tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;\n      pendingTasks.remove(taskId);\n    });\n    return tDetails.loadingPromise;\n  }\n\n  // Start downloading of defer block dependencies.\n  tDetails.loadingPromise = Promise.allSettled(dependenciesFn()).then((results) => {\n    let failed = false;\n    const directiveDefs: DirectiveDefList = [];\n    const pipeDefs: PipeDefList = [];\n\n    for (const result of results) {\n      if (result.status === 'fulfilled') {\n        const dependency = result.value;\n        const directiveDef = getComponentDef(dependency) || getDirectiveDef(dependency);\n        if (directiveDef) {\n          directiveDefs.push(directiveDef);\n        } else {\n          const pipeDef = getPipeDef(dependency);\n          if (pipeDef) {\n            pipeDefs.push(pipeDef);\n          }\n        }\n      } else {\n        failed = true;\n        break;\n      }\n    }\n\n    // Loading is completed, we no longer need the loading Promise\n    // and a pending task should also be removed.\n    tDetails.loadingPromise = null;\n    pendingTasks.remove(taskId);\n\n    if (failed) {\n      tDetails.loadingState = DeferDependenciesLoadingState.FAILED;\n\n      if (tDetails.errorTmplIndex === null) {\n        const templateLocation = ngDevMode ? getTemplateLocationDetails(lView) : '';\n        const error = new RuntimeError(\n          RuntimeErrorCode.DEFER_LOADING_FAILED,\n          ngDevMode &&\n            'Loading dependencies for `@defer` block failed, ' +\n              `but no \\`@error\\` block was configured${templateLocation}. ` +\n              'Consider using the `@error` block to render an error state.',\n        );\n        handleError(lView, error);\n      }\n    } else {\n      tDetails.loadingState = DeferDependenciesLoadingState.COMPLETE;\n\n      // Update directive and pipe registries to add newly downloaded dependencies.\n      const primaryBlockTView = primaryBlockTNode.tView!;\n      if (directiveDefs.length > 0) {\n        primaryBlockTView.directiveRegistry = addDepsToRegistry<DirectiveDefList>(\n          primaryBlockTView.directiveRegistry,\n          directiveDefs,\n        );\n\n        // Extract providers from all NgModules imported by standalone components\n        // used within this defer block.\n        const directiveTypes = directiveDefs.map((def) => def.type);\n        const providers = internalImportProvidersFrom(false, ...directiveTypes);\n        tDetails.providers = providers;\n      }\n      if (pipeDefs.length > 0) {\n        primaryBlockTView.pipeRegistry = addDepsToRegistry<PipeDefList>(\n          primaryBlockTView.pipeRegistry,\n          pipeDefs,\n        );\n      }\n    }\n  });\n  return tDetails.loadingPromise;\n}\n\n/** Utility function to render placeholder content (if present) */\nfunction renderPlaceholder(lView: LView, tNode: TNode) {\n  const lContainer = lView[tNode.index];\n  ngDevMode && assertLContainer(lContainer);\n\n  renderDeferBlockState(DeferBlockState.Placeholder, tNode, lContainer);\n}\n\n/**\n * Subscribes to the \"loading\" Promise and renders corresponding defer sub-block,\n * based on the loading results.\n *\n * @param lContainer Represents an instance of a defer block.\n * @param tNode Represents defer block info shared across all instances.\n */\nfunction renderDeferStateAfterResourceLoading(\n  tDetails: TDeferBlockDetails,\n  tNode: TNode,\n  lContainer: LContainer,\n) {\n  ngDevMode &&\n    assertDefined(tDetails.loadingPromise, 'Expected loading Promise to exist on this defer block');\n\n  tDetails.loadingPromise!.then(() => {\n    if (tDetails.loadingState === DeferDependenciesLoadingState.COMPLETE) {\n      ngDevMode && assertDeferredDependenciesLoaded(tDetails);\n\n      // Everything is loaded, show the primary block content\n      renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);\n    } else if (tDetails.loadingState === DeferDependenciesLoadingState.FAILED) {\n      renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);\n    }\n  });\n}\n\n/**\n * Attempts to trigger loading of defer block dependencies.\n * If the block is already in a loading, completed or an error state -\n * no additional actions are taken.\n */\nfunction triggerDeferBlock(lView: LView, tNode: TNode) {\n  const tView = lView[TVIEW];\n  const lContainer = lView[tNode.index];\n  const injector = lView[INJECTOR]!;\n  ngDevMode && assertLContainer(lContainer);\n\n  if (!shouldTriggerDeferBlock(injector)) return;\n\n  const lDetails = getLDeferBlockDetails(lView, tNode);\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  // Defer block is triggered, cleanup all registered trigger functions.\n  invokeAllTriggerCleanupFns(lDetails);\n\n  switch (tDetails.loadingState) {\n    case DeferDependenciesLoadingState.NOT_STARTED:\n      renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);\n      triggerResourceLoading(tDetails, lView, tNode);\n\n      // The `loadingState` might have changed to \"loading\".\n      if (\n        (tDetails.loadingState as DeferDependenciesLoadingState) ===\n        DeferDependenciesLoadingState.IN_PROGRESS\n      ) {\n        renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);\n      }\n      break;\n    case DeferDependenciesLoadingState.IN_PROGRESS:\n      renderDeferBlockState(DeferBlockState.Loading, tNode, lContainer);\n      renderDeferStateAfterResourceLoading(tDetails, tNode, lContainer);\n      break;\n    case DeferDependenciesLoadingState.COMPLETE:\n      ngDevMode && assertDeferredDependenciesLoaded(tDetails);\n      renderDeferBlockState(DeferBlockState.Complete, tNode, lContainer);\n      break;\n    case DeferDependenciesLoadingState.FAILED:\n      renderDeferBlockState(DeferBlockState.Error, tNode, lContainer);\n      break;\n    default:\n      if (ngDevMode) {\n        throwError('Unknown defer block state');\n      }\n  }\n}\n"]}